LCOV - code coverage report
Current view: top level - src/test/modules/test_lwlock_tranches - test_lwlock_tranches.c (source / functions) Coverage Total Hit
Test: PostgreSQL 20devel Lines: 87.5 % 48 42
Test Date: 2026-07-03 19:57:34 Functions: 100.0 % 13 13
Legend: Lines:     hit not hit
Branches: + taken - not taken # not executed
Branches: 55.6 % 18 10

             Branch data     Line data    Source code
       1                 :             : /*--------------------------------------------------------------------------
       2                 :             :  *
       3                 :             :  * test_lwlock_tranches.c
       4                 :             :  *      Test code for LWLock tranches allocated by extensions.
       5                 :             :  *
       6                 :             :  * Copyright (c) 2025-2026, PostgreSQL Global Development Group
       7                 :             :  *
       8                 :             :  * IDENTIFICATION
       9                 :             :  *      src/test/modules/test_lwlock_tranches/test_lwlock_tranches.c
      10                 :             :  *
      11                 :             :  * -------------------------------------------------------------------------
      12                 :             :  */
      13                 :             : 
      14                 :             : #include "postgres.h"
      15                 :             : 
      16                 :             : #include "fmgr.h"
      17                 :             : #include "miscadmin.h"
      18                 :             : #include "storage/lwlock.h"
      19                 :             : #include "utils/builtins.h"
      20                 :             : #include "utils/wait_classes.h"
      21                 :             : 
      22                 :           1 : PG_MODULE_MAGIC;
      23                 :             : 
      24                 :             : static shmem_request_hook_type prev_shmem_request_hook;
      25                 :             : static void test_lwlock_tranches_shmem_request(void);
      26                 :             : 
      27                 :             : void
      28                 :           1 : _PG_init(void)
      29                 :             : {
      30                 :           1 :     prev_shmem_request_hook = shmem_request_hook;
      31                 :           1 :     shmem_request_hook = test_lwlock_tranches_shmem_request;
      32                 :           1 : }
      33                 :             : 
      34                 :             : static void
      35                 :           1 : test_lwlock_tranches_shmem_request(void)
      36                 :             : {
      37         [ -  + ]:           1 :     if (prev_shmem_request_hook)
      38                 :           0 :         prev_shmem_request_hook();
      39                 :             : 
      40                 :             :     /*
      41                 :             :      * Request some tranches with RequestNamedLWLockTranche() for
      42                 :             :      * test_startup_lwlocks()
      43                 :             :      */
      44                 :           1 :     RequestNamedLWLockTranche("test_lwlock_tranches_startup", 1);
      45                 :           1 :     RequestNamedLWLockTranche("test_lwlock_tranches_startup10", 10);
      46                 :           1 : }
      47                 :             : 
      48                 :             : /*
      49                 :             :  * Test locks requested with RequestNamedLWLockTranche
      50                 :             :  */
      51                 :           2 : PG_FUNCTION_INFO_V1(test_startup_lwlocks);
      52                 :             : Datum
      53                 :           1 : test_startup_lwlocks(PG_FUNCTION_ARGS)
      54                 :             : {
      55                 :             :     LWLockPadded *lwlock_startup;
      56                 :             :     LWLockPadded *lwlock_startup10;
      57                 :             : 
      58                 :             :     /* Check that the locks can be used */
      59                 :           1 :     lwlock_startup = GetNamedLWLockTranche("test_lwlock_tranches_startup");
      60                 :           1 :     lwlock_startup10 = GetNamedLWLockTranche("test_lwlock_tranches_startup10");
      61                 :             : 
      62                 :           1 :     LWLockAcquire(&lwlock_startup->lock, LW_EXCLUSIVE);
      63         [ +  + ]:          11 :     for (int i = 0; i < 10; i++)
      64                 :          10 :         LWLockAcquire(&lwlock_startup10[i].lock, LW_EXCLUSIVE);
      65                 :             : 
      66                 :           1 :     LWLockRelease(&lwlock_startup->lock);
      67         [ +  + ]:          11 :     for (int i = 0; i < 10; i++)
      68                 :          10 :         LWLockRelease(&lwlock_startup10[i].lock);
      69                 :             : 
      70                 :             :     /*
      71                 :             :      * Check that GetLWLockIdentifier() returns the expected value for
      72                 :             :      * tranches
      73                 :             :      */
      74         [ -  + ]:           1 :     if (strcmp("test_lwlock_tranches_startup",
      75                 :             :                GetLWLockIdentifier(PG_WAIT_LWLOCK, LWTRANCHE_FIRST_USER_DEFINED)) != 0)
      76         [ #  # ]:           0 :         elog(ERROR, "incorrect startup lock tranche name");
      77         [ -  + ]:           1 :     if (strcmp("test_lwlock_tranches_startup10",
      78                 :             :                GetLWLockIdentifier(PG_WAIT_LWLOCK, LWTRANCHE_FIRST_USER_DEFINED + 1)) != 0)
      79         [ #  # ]:           0 :         elog(ERROR, "incorrect startup lock tranche name");
      80                 :             : 
      81                 :           1 :     PG_RETURN_VOID();
      82                 :             : }
      83                 :             : 
      84                 :             : /*
      85                 :             :  * Wrapper for LWLockNewTrancheId().
      86                 :             :  */
      87                 :           2 : PG_FUNCTION_INFO_V1(test_lwlock_tranche_create);
      88                 :             : Datum
      89                 :         257 : test_lwlock_tranche_create(PG_FUNCTION_ARGS)
      90                 :             : {
      91         [ +  + ]:         257 :     char       *tranche_name = PG_ARGISNULL(0) ? NULL : TextDatumGetCString(PG_GETARG_DATUM(0));
      92                 :             :     int         tranche_id;
      93                 :             : 
      94                 :         257 :     tranche_id = LWLockNewTrancheId(tranche_name);
      95                 :             : 
      96                 :         254 :     PG_RETURN_INT32(tranche_id);
      97                 :             : }
      98                 :             : 
      99                 :             : /*
     100                 :             :  * Wrapper for GetNamedLWLockTranche().
     101                 :             :  */
     102                 :           2 : PG_FUNCTION_INFO_V1(test_lwlock_tranche_lookup);
     103                 :             : Datum
     104                 :           2 : test_lwlock_tranche_lookup(PG_FUNCTION_ARGS)
     105                 :             : {
     106                 :           2 :     char       *tranche_name = TextDatumGetCString(PG_GETARG_DATUM(0));
     107                 :             : 
     108                 :           2 :     (void) GetNamedLWLockTranche(tranche_name);
     109                 :             : 
     110                 :           0 :     PG_RETURN_VOID();
     111                 :             : }
     112                 :             : 
     113                 :           2 : PG_FUNCTION_INFO_V1(test_lwlock_get_lwlock_identifier);
     114                 :             : Datum
     115                 :           4 : test_lwlock_get_lwlock_identifier(PG_FUNCTION_ARGS)
     116                 :             : {
     117                 :           4 :     int         eventId = PG_GETARG_INT32(0);
     118                 :             :     const char *tranche_name;
     119                 :             : 
     120                 :           4 :     tranche_name = GetLWLockIdentifier(PG_WAIT_LWLOCK, eventId);
     121                 :             : 
     122         [ +  - ]:           4 :     if (tranche_name)
     123                 :           4 :         PG_RETURN_TEXT_P(cstring_to_text(tranche_name));
     124                 :             :     else
     125                 :           0 :         PG_RETURN_NULL();
     126                 :             : }
     127                 :             : 
     128                 :             : /*
     129                 :             :  * Wrapper for LWLockInitialize().
     130                 :             :  */
     131                 :           2 : PG_FUNCTION_INFO_V1(test_lwlock_initialize);
     132                 :             : Datum
     133                 :           1 : test_lwlock_initialize(PG_FUNCTION_ARGS)
     134                 :             : {
     135                 :           1 :     int         tranche_id = PG_GETARG_INT32(0);
     136                 :             :     LWLock      lock;
     137                 :             : 
     138                 :           1 :     LWLockInitialize(&lock, tranche_id);
     139                 :             : 
     140                 :           0 :     PG_RETURN_VOID();
     141                 :             : }
        

Generated by: LCOV version 2.0-1