From 9d7157b07f125449141b85e6c0c93127e89e6899 Mon Sep 17 00:00:00 2001 From: Ubuntu Date: Tue, 12 Aug 2025 15:01:55 +0000 Subject: [PATCH v7 1/2] Implement a DSA for LWLock tranche names Previously, only LWLock tranches registered during postmaster startup were available to all backends via a tranche name array inherited through fork. Other backends that wanted to know about a tranche name had to register it using LWLockRegisterTranche. While this design worked as intended, it was not ideal because if a backend did not call LWLockRegisterTranche, it would show a generic "extension" wait_event name in pg_stat_activity instead of the actual tranche name. This caused inconsistencies with other backends that registered the tranche name. Commit fe07100e82b0 made dynamic creation of named DSA areas (and dshash) much simpler for a backend, so it is anticipated that fewer tranche names will be registered during postmaster startup in the future, with more registered dynamically. This will make the above issue more common. To address this, this change introduces a DSA to store LWLock tranche names after postmaster startup. When a backend looks up a tranche name by tranche ID, it first checks its local cache; if the name is not found locally, it fetches it from the DSA and caches it for future lookups. This also simplifies the API for registering tranche names: all registration work is now done via LWLockNewTrancheId, which accepts a tranche name. The LWLockRegisterTranche call is no longer required. Additionally, while users should not pass arbitrary tranche IDs (that is, IDs not created via LWLockNewTrancheId) to LWLockInitialize, nothing technically prevents them from doing so. Therefore, we must continue to handle such cases gracefully by returning a default "extension" tranche name. Discussion: https://www.postgresql.org/message-id/flat/CAA5RZ0vvED3naph8My8Szv6DL4AxOVK3eTPS0qXsaKi%3DbVdW2A%40mail.gmail.com --- contrib/pg_prewarm/autoprewarm.c | 4 +- doc/src/sgml/xfunc.sgml | 20 +- src/backend/storage/ipc/dsm_registry.c | 16 +- src/backend/storage/ipc/ipci.c | 2 + src/backend/storage/lmgr/lwlock.c | 433 +++++++++++++++--- .../utils/activity/wait_event_names.txt | 2 + src/backend/utils/init/postinit.c | 2 + src/include/storage/lwlock.h | 22 +- src/include/storage/lwlocklist.h | 2 + src/test/modules/test_dsa/test_dsa.c | 6 +- .../test_dsm_registry/test_dsm_registry.c | 4 +- .../modules/test_radixtree/test_radixtree.c | 9 +- src/test/modules/test_slru/test_slru.c | 6 +- .../modules/test_tidstore/test_tidstore.c | 3 +- 14 files changed, 418 insertions(+), 113 deletions(-) diff --git a/contrib/pg_prewarm/autoprewarm.c b/contrib/pg_prewarm/autoprewarm.c index c01b9c7e6a4..b623589b430 100644 --- a/contrib/pg_prewarm/autoprewarm.c +++ b/contrib/pg_prewarm/autoprewarm.c @@ -864,7 +864,7 @@ apw_init_state(void *ptr) { AutoPrewarmSharedState *state = (AutoPrewarmSharedState *) ptr; - LWLockInitialize(&state->lock, LWLockNewTrancheId()); + LWLockInitialize(&state->lock, LWLockNewTrancheId("autoprewarm")); state->bgworker_pid = InvalidPid; state->pid_using_dumpfile = InvalidPid; } @@ -883,8 +883,6 @@ apw_init_shmem(void) sizeof(AutoPrewarmSharedState), apw_init_state, &found); - LWLockRegisterTranche(apw_state->lock.tranche, "autoprewarm"); - return found; } diff --git a/doc/src/sgml/xfunc.sgml b/doc/src/sgml/xfunc.sgml index 30219f432d9..32ea6c87be8 100644 --- a/doc/src/sgml/xfunc.sgml +++ b/doc/src/sgml/xfunc.sgml @@ -3758,9 +3758,10 @@ LWLockPadded *GetNamedLWLockTranche(const char *tranche_name) There is another, more flexible method of obtaining LWLocks that can be done after server startup and outside a shmem_request_hook. To do so, first allocate a - tranche_id by calling: + tranche_id with an associated tranche_name + by calling: -int LWLockNewTrancheId(void) +int LWLockNewTrancheId(const char *tranche_name) Next, initialize each LWLock, passing the new tranche_id as an argument: @@ -3778,17 +3779,16 @@ void LWLockInitialize(LWLock *lock, int tranche_id) - Finally, each backend using the tranche_id should - associate it with a tranche_name by calling: - -void LWLockRegisterTranche(int tranche_id, const char *tranche_name) - + It is possible to use a tranche_id that was not retrieved + using LWLockNewTrancheId, but this is not recommended. + The ID may clash with an already registered tranche name, or the specified + name may not be found. In such cases, looking up the name will return a generic + "extension" tranche name. - A complete usage example of LWLockNewTrancheId, - LWLockInitialize, and - LWLockRegisterTranche can be found in + A complete usage example of LWLockNewTrancheId and + LWLockInitialize can be found in contrib/pg_prewarm/autoprewarm.c in the PostgreSQL source tree. diff --git a/src/backend/storage/ipc/dsm_registry.c b/src/backend/storage/ipc/dsm_registry.c index 1682cc6d34c..cc0adc19971 100644 --- a/src/backend/storage/ipc/dsm_registry.c +++ b/src/backend/storage/ipc/dsm_registry.c @@ -307,9 +307,8 @@ GetNamedDSA(const char *name, bool *found) entry->type = DSMR_ENTRY_TYPE_DSA; /* Initialize the LWLock tranche for the DSA. */ - state->tranche = LWLockNewTrancheId(); strcpy(state->tranche_name, name); - LWLockRegisterTranche(state->tranche, state->tranche_name); + state->tranche = LWLockNewTrancheId(state->tranche_name); /* Initialize the DSA. */ ret = dsa_create(state->tranche); @@ -330,9 +329,6 @@ GetNamedDSA(const char *name, bool *found) ereport(ERROR, (errmsg("requested DSA already attached to current process"))); - /* Initialize existing LWLock tranche for the DSA. */ - LWLockRegisterTranche(state->tranche, state->tranche_name); - /* Attach to existing DSA. */ ret = dsa_attach(state->handle); dsa_pin_mapping(ret); @@ -389,14 +385,12 @@ GetNamedDSHash(const char *name, const dshash_parameters *params, bool *found) entry->type = DSMR_ENTRY_TYPE_DSH; /* Initialize the LWLock tranche for the DSA. */ - dsa_state->tranche = LWLockNewTrancheId(); sprintf(dsa_state->tranche_name, "%s%s", name, DSMR_DSA_TRANCHE_SUFFIX); - LWLockRegisterTranche(dsa_state->tranche, dsa_state->tranche_name); + dsa_state->tranche = LWLockNewTrancheId(dsa_state->tranche_name); /* Initialize the LWLock tranche for the dshash table. */ - dsh_state->tranche = LWLockNewTrancheId(); strcpy(dsh_state->tranche_name, name); - LWLockRegisterTranche(dsh_state->tranche, dsh_state->tranche_name); + dsh_state->tranche = LWLockNewTrancheId(dsh_state->tranche_name); /* Initialize the DSA for the hash table. */ dsa = dsa_create(dsa_state->tranche); @@ -427,10 +421,6 @@ GetNamedDSHash(const char *name, const dshash_parameters *params, bool *found) ereport(ERROR, (errmsg("requested DSHash already attached to current process"))); - /* Initialize existing LWLock tranches for the DSA and dshash table. */ - LWLockRegisterTranche(dsa_state->tranche, dsa_state->tranche_name); - LWLockRegisterTranche(dsh_state->tranche, dsh_state->tranche_name); - /* Attach to existing DSA for the hash table. */ dsa = dsa_attach(dsa_state->handle); dsa_pin_mapping(dsa); diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c index 2fa045e6b0f..c8e4d55cf80 100644 --- a/src/backend/storage/ipc/ipci.c +++ b/src/backend/storage/ipc/ipci.c @@ -343,6 +343,8 @@ CreateOrAttachShmemStructs(void) WaitEventCustomShmemInit(); InjectionPointShmemInit(); AioShmemInit(); + + LWLockTrancheNamesShmemInit(); } /* diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c index ec9c345ffdf..7bf455beda4 100644 --- a/src/backend/storage/lmgr/lwlock.c +++ b/src/backend/storage/lmgr/lwlock.c @@ -80,6 +80,7 @@ #include "pg_trace.h" #include "pgstat.h" #include "port/pg_bitutils.h" +#include "storage/ipc.h" #include "storage/proc.h" #include "storage/proclist.h" #include "storage/procnumber.h" @@ -125,9 +126,12 @@ StaticAssertDecl((LW_VAL_EXCLUSIVE & LW_FLAG_MASK) == 0, * 2. There are some predefined tranches for built-in groups of locks defined * in lwlocklist.h. We absorb the names of these tranches, too. * - * 3. Extensions can create new tranches, via either RequestNamedLWLockTranche - * or LWLockRegisterTranche. The names of these that are known in the current - * process appear in LWLockTrancheNames[]. + * 3. Extensions can create new tranches using either RequestNamedLWLockTranche + * or LWLockNewTrancheId. Tranche names are registered in LWLockTrancheNames in + * two ways: if registration happens during postmaster startup, the names are + * stored directly in the local array; if registration happens afterward, the + * names are first stored in shared memory and later cached into the local array + * during lookup. * * All these names are user-visible as wait event names, so choose with care * ... and do not forget to update the documentation's list of wait events. @@ -144,14 +148,6 @@ StaticAssertDecl(lengthof(BuiltinTrancheNames) == LWTRANCHE_FIRST_USER_DEFINED, "missing entries in BuiltinTrancheNames[]"); -/* - * This is indexed by tranche ID minus LWTRANCHE_FIRST_USER_DEFINED, and - * stores the names of all dynamically-created tranches known to the current - * process. Any unused entries in the array will contain NULL. - */ -static const char **LWLockTrancheNames = NULL; -static int LWLockTrancheNamesAllocated = 0; - /* * This points to the main array of LWLocks in shared memory. Backends inherit * the pointer by fork from the postmaster (except in the EXEC_BACKEND case, @@ -187,6 +183,51 @@ typedef struct NamedLWLockTrancheRequest static NamedLWLockTrancheRequest *NamedLWLockTrancheRequestArray = NULL; static int NamedLWLockTrancheRequestsAllocated = 0; +typedef struct LWLockTrancheNamesShmem +{ + /* pointer to the DSA shared memory, created in-place */ + void *raw_dsa_area; + /* DSA Pointer to a list of DSA pointers, each storing a tranche name */ + dsa_pointer list_ptr; + + /* + * The number of slots allocated for tranche names. The allocated size + * will grow geometrically to reduce resizing of the list_ptr. + */ + int allocated; + + /* lock to protect access to the list */ + LWLock lock; +} LWLockTrancheNamesShmem; + +typedef struct LWLockTrancheNamesStruct +{ + /* + * Tranche names allocated in shared memory after postmaster startup, when + * dynamic allocation is allowed. + */ + LWLockTrancheNamesShmem *shmem; + dsa_area *dsa; + + /* + * Tranche names stored in local backend memory, either during postmaster + * startup or as a local cache afterward. + */ + const char **local; + int allocated; /* number of pre-allocated slots for tranche + * names */ + int max_used_index; /* max index currently storing a tranche name. + * This is used to know a starting point when + * syncing from shared memory */ +} LWLockTrancheNamesStruct; + +static LWLockTrancheNamesStruct LWLockTrancheNames = +{ + NULL, NULL, NULL, 0 +}; + +#define LWLOCK_TRANCHE_NAMES_INIT_SIZE 16 + /* * NamedLWLockTrancheRequests is both the valid length of the request array, * and the length of the shared-memory NamedLWLockTrancheArray later on. @@ -201,7 +242,11 @@ NamedLWLockTranche *NamedLWLockTrancheArray = NULL; static void InitializeLWLocks(void); static inline void LWLockReportWaitStart(LWLock *lock); static inline void LWLockReportWaitEnd(void); +static void SetLocalTrancheName(int tranche_index, const char *tranche_name); +static void SetSharedTrancheName(int tranche_index, const char *tranche_name); static const char *GetLWTrancheName(uint16 trancheId); +static void LWLockTrancheNamesAttach(void); +static void LWLockTrancheNamesDetach(void); #define T_NAME(lock) \ GetLWTrancheName((lock)->tranche) @@ -448,11 +493,6 @@ CreateLWLocks(void) /* Initialize all LWLocks */ InitializeLWLocks(); } - - /* Register named extension LWLock tranches in the current process. */ - for (int i = 0; i < NamedLWLockTrancheRequests; i++) - LWLockRegisterTranche(NamedLWLockTrancheArray[i].trancheId, - NamedLWLockTrancheArray[i].trancheName); } /* @@ -513,7 +553,7 @@ InitializeLWLocks(void) name = trancheNames; trancheNames += strlen(request->tranche_name) + 1; strcpy(name, request->tranche_name); - tranche->trancheId = LWLockNewTrancheId(); + tranche->trancheId = LWLockNewTrancheId(name); tranche->trancheName = name; for (j = 0; j < request->num_lwlocks; j++, lock++) @@ -569,61 +609,144 @@ GetNamedLWLockTranche(const char *tranche_name) } /* - * Allocate a new tranche ID. + * Allocate a new tranche ID and register it with the given tranche + * name. Tranche indexes created by the postmaster will not be used + * for a tranche created in shared memory, since the index is generated + * from the shared LWLockCounter. + * + * The tranche name will be user-visible as a wait event name, so use + * a name that matches the style of existing wait events. */ int -LWLockNewTrancheId(void) +LWLockNewTrancheId(const char *tranche_name) { - int result; + int tranche_id; + int tranche_index; int *LWLockCounter; LWLockCounter = (int *) ((char *) MainLWLockArray - sizeof(int)); /* We use the ShmemLock spinlock to protect LWLockCounter */ SpinLockAcquire(ShmemLock); - result = (*LWLockCounter)++; + tranche_id = (*LWLockCounter)++; SpinLockRelease(ShmemLock); - return result; + tranche_index = tranche_id - LWTRANCHE_FIRST_USER_DEFINED; + + if (!IsUnderPostmaster) + SetLocalTrancheName(tranche_index, tranche_name); + else + SetSharedTrancheName(tranche_index, tranche_name); + + return tranche_id; } /* - * Register a dynamic tranche name in the lookup table of the current process. - * - * This routine will save a pointer to the tranche name passed as an argument, - * so the name should be allocated in a backend-lifetime context - * (shared memory, TopMemoryContext, static constant, or similar). - * - * The tranche name will be user-visible as a wait event name, so try to - * use a name that fits the style for those. + * Adds a tranche name to shared memory. This routine should only be + * called from LWLockNewTrancheId. */ -void -LWLockRegisterTranche(int tranche_id, const char *tranche_name) +static void +SetSharedTrancheName(int tranche_index, const char *tranche_name) { - /* This should only be called for user-defined tranches. */ - if (tranche_id < LWTRANCHE_FIRST_USER_DEFINED) - return; + dsa_pointer *name_ptrs; + dsa_pointer str_ptr; + char *str_addr; + int len; + int current_allocated; - /* Convert to array index. */ - tranche_id -= LWTRANCHE_FIRST_USER_DEFINED; + LWLockAcquire(&LWLockTrancheNames.shmem->lock, LW_EXCLUSIVE); - /* If necessary, create or enlarge array. */ - if (tranche_id >= LWLockTrancheNamesAllocated) + current_allocated = LWLockTrancheNames.shmem->allocated; + + /* Tranche array does not exist, initialize it */ + if (!DsaPointerIsValid(LWLockTrancheNames.shmem->list_ptr)) + { + int init_alloc = LWLOCK_TRANCHE_NAMES_INIT_SIZE; + + LWLockTrancheNames.shmem->allocated = init_alloc; + LWLockTrancheNames.shmem->list_ptr = + dsa_allocate0(LWLockTrancheNames.dsa, init_alloc * sizeof(dsa_pointer)); + + name_ptrs = dsa_get_address(LWLockTrancheNames.dsa, LWLockTrancheNames.shmem->list_ptr); + memset(name_ptrs, InvalidDsaPointer, init_alloc); + } + + /* + * Need to enlarge the tranche array. Allocate a new list, copy the + * current tranche name pointers into it, and update shared memory to + * point to the new list. + */ + else if (tranche_index >= current_allocated) { - int newalloc; + int new_alloc = pg_nextpower2_32(Max(LWLOCK_TRANCHE_NAMES_INIT_SIZE, + tranche_index + 1)); - newalloc = pg_nextpower2_32(Max(8, tranche_id + 1)); + dsa_pointer new_list = dsa_allocate(LWLockTrancheNames.dsa, + new_alloc * sizeof(dsa_pointer)); - if (LWLockTrancheNames == NULL) - LWLockTrancheNames = (const char **) + dsa_pointer *old_ptrs = dsa_get_address(LWLockTrancheNames.dsa, + LWLockTrancheNames.shmem->list_ptr); + + name_ptrs = dsa_get_address(LWLockTrancheNames.dsa, new_list); + + memset(name_ptrs, InvalidDsaPointer, new_alloc); + memcpy(name_ptrs, old_ptrs, sizeof(dsa_pointer) * current_allocated); + + dsa_free(LWLockTrancheNames.dsa, LWLockTrancheNames.shmem->list_ptr); + + LWLockTrancheNames.shmem->list_ptr = new_list; + LWLockTrancheNames.shmem->allocated = new_alloc; + } + /* Use the current list */ + else + { + name_ptrs = dsa_get_address(LWLockTrancheNames.dsa, + LWLockTrancheNames.shmem->list_ptr); + } + + /* Allocate and copy new string */ + len = strlen(tranche_name) + 1; + str_ptr = dsa_allocate(LWLockTrancheNames.dsa, len); + str_addr = dsa_get_address(LWLockTrancheNames.dsa, str_ptr); + memcpy(str_addr, tranche_name, len); + + name_ptrs[tranche_index] = str_ptr; + + LWLockRelease(&LWLockTrancheNames.shmem->lock); +} + +/* + * Adds a tranche name to local memory. This routine should only be + * called from LWLockNewTrancheId and SyncLWLockTrancheNames. + */ +static void +SetLocalTrancheName(int tranche_index, const char *tranche_name) +{ + int newalloc; + + Assert(tranche_name); + + /* If necessary, create or enlarge array. */ + if (tranche_index >= LWLockTrancheNames.allocated) + { + newalloc = pg_nextpower2_32(Max(8, tranche_index + 1)); + + if (LWLockTrancheNames.local == NULL) + { + LWLockTrancheNames.local = (const char **) MemoryContextAllocZero(TopMemoryContext, newalloc * sizeof(char *)); + } else - LWLockTrancheNames = - repalloc0_array(LWLockTrancheNames, const char *, LWLockTrancheNamesAllocated, newalloc); - LWLockTrancheNamesAllocated = newalloc; + { + LWLockTrancheNames.local = + repalloc0_array(LWLockTrancheNames.local, const char *, LWLockTrancheNames.allocated, newalloc); + } + + LWLockTrancheNames.allocated = newalloc; } - LWLockTrancheNames[tranche_id] = tranche_name; + LWLockTrancheNames.local[tranche_index] = tranche_name; + LWLockTrancheNames.max_used_index = tranche_index; } /* @@ -708,28 +831,96 @@ LWLockReportWaitEnd(void) pgstat_report_wait_end(); } +/* + * Synchronize local tranche names with those stored in shared memory. + * + * Starts syncing from the first unused local index up to the number of + * allocated tranche slots in shared memory. If the requested tranche_index + * is not found during syncing, sets its name to "extension" as a fallback. + * + * The tranche_index parameter is the one that triggered syncing. If it is + * not found in shared memory, set it to "extension" locally. + */ +static void +SyncLWLockTrancheNames(uint16 tranche_index) +{ + bool requested_id_set = false; + + /* Acquire shared lock on tranche names shared memory */ + LWLockAcquire(&LWLockTrancheNames.shmem->lock, LW_SHARED); + + /* Proceed only if tranche_index is within allocated range */ + if (tranche_index < LWLockTrancheNames.shmem->allocated) + { + /* Get array of pointers to tranche names in shared memory */ + dsa_pointer *pointers = dsa_get_address(LWLockTrancheNames.dsa, + LWLockTrancheNames.shmem->list_ptr); + int next_index = LWLockTrancheNames.max_used_index + 1; + int allocated = LWLockTrancheNames.shmem->allocated; + + /* Iterate through tranche entries from next unused index */ + for (int i = next_index; i < allocated; i++) + { + const char *tranche_name; + + /* + * Stop if pointer is invalid, indicating no more valid tranche + * names after this point. + */ + if (!DsaPointerIsValid(pointers[i])) + break; + + /* Get tranche name from shared memory */ + tranche_name = (const char *) dsa_get_address(LWLockTrancheNames.dsa, pointers[i]); + + /* Mark if requested tranche index was found */ + if (tranche_index == i) + requested_id_set = true; + + /* Update local tranche name */ + SetLocalTrancheName(i, tranche_name); + } + } + + /* + * If requested tranche index was not found in shared memory, assign it a + * default name of "extension". + */ + if (!requested_id_set) + SetLocalTrancheName(tranche_index, "extension"); + + /* Release shared lock */ + LWLockRelease(&LWLockTrancheNames.shmem->lock); +} + /* * Return the name of an LWLock tranche. */ static const char * GetLWTrancheName(uint16 trancheId) { + const char *tranche_name = NULL; + /* Built-in tranche or individual LWLock? */ if (trancheId < LWTRANCHE_FIRST_USER_DEFINED) return BuiltinTrancheNames[trancheId]; + trancheId -= LWTRANCHE_FIRST_USER_DEFINED; + /* - * It's an extension tranche, so look in LWLockTrancheNames[]. However, - * it's possible that the tranche has never been registered in the current - * process, in which case give up and return "extension". + * This is an extension tranche, so check LWLockTrancheNames[]. First, + * synchronize the local list with shared memory if necessary, then + * perform the lookup. If the tranche hasn't been registered by the + * extension, return "extension". */ - trancheId -= LWTRANCHE_FIRST_USER_DEFINED; + if (trancheId >= LWLockTrancheNames.allocated || + LWLockTrancheNames.local[trancheId] == NULL) + SyncLWLockTrancheNames(trancheId); - if (trancheId >= LWLockTrancheNamesAllocated || - LWLockTrancheNames[trancheId] == NULL) - return "extension"; + if (trancheId < LWLockTrancheNames.allocated) + tranche_name = LWLockTrancheNames.local[trancheId]; - return LWLockTrancheNames[trancheId]; + return tranche_name ? tranche_name : "extension"; } /* @@ -1995,3 +2186,135 @@ LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode) } return false; } + +/* + * Size of the shared memory to create in place the tranche DSA. + */ +static Size +LWLockTrancheNamesInitSize() +{ + Size sz; + + /* + * This value is used by other facilities, see pgstat_shmem.c, so it's + * good enough. + */ + sz = 256 * 1024; + + Assert(dsa_minimum_size() <= sz); + + return MAXALIGN(sz); +} + +Size +LWLockTrancheNamesShmemSize(void) +{ + Size sz; + + sz = MAXALIGN(sizeof(LWLockTrancheNamesStruct)); + sz = add_size(sz, LWLockTrancheNamesInitSize()); + + return sz; +} + +/* + * Allocate the DSA to store tranche names in dynamic shared memory. This + * allocation happens during postmaster startup, so create_in_place is used. + * At this stage, the postmaster should only create the DSA and avoid any other + * operations, as allocating additional DSM segments will not yet be possible. + */ +void +LWLockTrancheNamesShmemInit(void) +{ + bool found; + + /* Initialize or attach to shared memory structure */ + LWLockTrancheNames.shmem = (LWLockTrancheNamesShmem *) + ShmemInitStruct("Dynamic LWLock tranche names", + LWLockTrancheNamesShmemSize(), + &found); + + if (!IsUnderPostmaster) + { + dsa_area *dsa; + LWLockTrancheNamesShmem *ctl = LWLockTrancheNames.shmem; + char *p = (char *) ctl; + + /* Calculate layout within the shared memory region */ + p += MAXALIGN(sizeof(LWLockTrancheNamesShmem)); + ctl->raw_dsa_area = p; + p += MAXALIGN(LWLockTrancheNamesInitSize()); + + LWLockInitialize(&ctl->lock, LWTRANCHE_LWLOCK_TRANCHE_NAMES_LIST); + + /* Create a dynamic shared memory area in-place */ + dsa = dsa_create_in_place(ctl->raw_dsa_area, + LWLockTrancheNamesInitSize(), + LWTRANCHE_LWLOCK_TRANCHE_NAMES_DSA, + NULL); + + /* + * Postmaster will never access these again, thus free the local + * dsa/dshash references. + */ + dsa_pin(dsa); + dsa_detach(dsa); + + ctl->allocated = 0; + ctl->list_ptr = InvalidDsaPointer; + } + else + { + Assert(found); + } +} + +static void +LWLockTrancheNamesAttach(void) +{ + MemoryContext oldcontext; + + Assert(LWLockTrancheNames.dsa == NULL); + + /* stats shared memory persists for the backend lifetime */ + oldcontext = MemoryContextSwitchTo(TopMemoryContext); + + LWLockTrancheNames.dsa = dsa_attach_in_place(LWLockTrancheNames.shmem->raw_dsa_area, + NULL); + dsa_pin_mapping(LWLockTrancheNames.dsa); + + Assert(LWLockTrancheNames.dsa); + + MemoryContextSwitchTo(oldcontext); +} + +static void +LWLockTrancheNamesDetach(void) +{ + Assert(LWLockTrancheNames.dsa); + + dsa_detach(LWLockTrancheNames.dsa); + + dsa_release_in_place(LWLockTrancheNames.shmem->raw_dsa_area); + + LWLockTrancheNames.dsa = NULL; +} + +/* Detach the DSA from a backend */ +static void +LWLockTrancheNamesShutdownHook(int code, Datum arg) +{ + Assert(IsUnderPostmaster || !IsPostmasterEnvironment); + + LWLockTrancheNamesDetach(); +} + +/* Attach the DSA to a backend */ +void +LWLockTrancheNamesBEInit(void) +{ + LWLockTrancheNamesAttach(); + + /* Set up a process-exit hook to clean up */ + before_shmem_exit(LWLockTrancheNamesShutdownHook, 0); +} diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt index 0be307d2ca0..f60ed927892 100644 --- a/src/backend/utils/activity/wait_event_names.txt +++ b/src/backend/utils/activity/wait_event_names.txt @@ -406,6 +406,8 @@ SubtransSLRU "Waiting to access the sub-transaction SLRU cache." XactSLRU "Waiting to access the transaction status SLRU cache." ParallelVacuumDSA "Waiting for parallel vacuum dynamic shared memory allocation." AioUringCompletion "Waiting for another process to complete IO via io_uring." +LWLockDynamicTranchesDSA "Waiting to access the LWLock tranche names DSA area." +LWLockDynamicTranchesList "Waiting to access the list of LWLock tranche names in DSA." # No "ABI_compatibility" region here as WaitEventLWLock has its own C code. diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c index 641e535a73c..1ef04c6b5ec 100644 --- a/src/backend/utils/init/postinit.c +++ b/src/backend/utils/init/postinit.c @@ -662,6 +662,8 @@ BaseInit(void) * drop ephemeral slots, which in turn triggers stats reporting. */ ReplicationSlotInitialize(); + + LWLockTrancheNamesBEInit(); } diff --git a/src/include/storage/lwlock.h b/src/include/storage/lwlock.h index 5e717765764..8a008fc67dd 100644 --- a/src/include/storage/lwlock.h +++ b/src/include/storage/lwlock.h @@ -156,22 +156,18 @@ extern void RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks) extern LWLockPadded *GetNamedLWLockTranche(const char *tranche_name); /* - * There is another, more flexible method of obtaining lwlocks. First, call - * LWLockNewTrancheId just once to obtain a tranche ID; this allocates from - * a shared counter. Next, each individual process using the tranche should - * call LWLockRegisterTranche() to associate that tranche ID with a name. - * Finally, LWLockInitialize should be called just once per lwlock, passing - * the tranche ID as an argument. - * - * It may seem strange that each process using the tranche must register it - * separately, but dynamic shared memory segments aren't guaranteed to be - * mapped at the same address in all coordinating backends, so storing the - * registration in the main shared memory segment wouldn't work for that case. + * An alternative, more flexible method of obtaining lwlocks is available. + * First, call LWLockNewTrancheId once, providing an associated tranche name. + * This function allocates a tranche ID from a shared counter. Then, for each + * lwlock, call LWLockInitialize once, passing the tranche ID as an argument. */ -extern int LWLockNewTrancheId(void); -extern void LWLockRegisterTranche(int tranche_id, const char *tranche_name); +extern int LWLockNewTrancheId(const char *tranche_name); extern void LWLockInitialize(LWLock *lock, int tranche_id); +extern void LWLockTrancheNamesShmemInit(void); +extern Size LWLockTrancheNamesShmemSize(void); +extern void LWLockTrancheNamesBEInit(void); + /* * Every tranche ID less than NUM_INDIVIDUAL_LWLOCKS is reserved; also, * we reserve additional tranche IDs for builtin tranches not included in diff --git a/src/include/storage/lwlocklist.h b/src/include/storage/lwlocklist.h index 208d2e3a8ed..5978648c09d 100644 --- a/src/include/storage/lwlocklist.h +++ b/src/include/storage/lwlocklist.h @@ -135,3 +135,5 @@ PG_LWLOCKTRANCHE(SUBTRANS_SLRU, SubtransSLRU) PG_LWLOCKTRANCHE(XACT_SLRU, XactSLRU) PG_LWLOCKTRANCHE(PARALLEL_VACUUM_DSA, ParallelVacuumDSA) PG_LWLOCKTRANCHE(AIO_URING_COMPLETION, AioUringCompletion) +PG_LWLOCKTRANCHE(LWLOCK_TRANCHE_NAMES_DSA, LWLockDynamicTranchesDSA) +PG_LWLOCKTRANCHE(LWLOCK_TRANCHE_NAMES_LIST, LWLockDynamicTranchesList) diff --git a/src/test/modules/test_dsa/test_dsa.c b/src/test/modules/test_dsa/test_dsa.c index cd24d0f4873..01d5c6fa67f 100644 --- a/src/test/modules/test_dsa/test_dsa.c +++ b/src/test/modules/test_dsa/test_dsa.c @@ -29,8 +29,7 @@ test_dsa_basic(PG_FUNCTION_ARGS) dsa_pointer p[100]; /* XXX: this tranche is leaked */ - tranche_id = LWLockNewTrancheId(); - LWLockRegisterTranche(tranche_id, "test_dsa"); + tranche_id = LWLockNewTrancheId("test_dsa"); a = dsa_create(tranche_id); for (int i = 0; i < 100; i++) @@ -70,8 +69,7 @@ test_dsa_resowners(PG_FUNCTION_ARGS) ResourceOwner childowner; /* XXX: this tranche is leaked */ - tranche_id = LWLockNewTrancheId(); - LWLockRegisterTranche(tranche_id, "test_dsa"); + tranche_id = LWLockNewTrancheId("test_dsa"); /* Create DSA in parent resource owner */ a = dsa_create(tranche_id); diff --git a/src/test/modules/test_dsm_registry/test_dsm_registry.c b/src/test/modules/test_dsm_registry/test_dsm_registry.c index 141c8ed1b34..7f3e6849401 100644 --- a/src/test/modules/test_dsm_registry/test_dsm_registry.c +++ b/src/test/modules/test_dsm_registry/test_dsm_registry.c @@ -48,7 +48,7 @@ init_tdr_dsm(void *ptr) { TestDSMRegistryStruct *dsm = (TestDSMRegistryStruct *) ptr; - LWLockInitialize(&dsm->lck, LWLockNewTrancheId()); + LWLockInitialize(&dsm->lck, LWLockNewTrancheId("test_dsm_registry")); dsm->val = 0; } @@ -61,8 +61,6 @@ tdr_attach_shmem(void) sizeof(TestDSMRegistryStruct), init_tdr_dsm, &found); - LWLockRegisterTranche(tdr_dsm->lck.tranche, "test_dsm_registry"); - if (tdr_dsa == NULL) tdr_dsa = GetNamedDSA("test_dsm_registry_dsa", &found); diff --git a/src/test/modules/test_radixtree/test_radixtree.c b/src/test/modules/test_radixtree/test_radixtree.c index 80ad0296164..787162c8793 100644 --- a/src/test/modules/test_radixtree/test_radixtree.c +++ b/src/test/modules/test_radixtree/test_radixtree.c @@ -124,10 +124,9 @@ test_empty(void) rt_iter *iter; uint64 key; #ifdef TEST_SHARED_RT - int tranche_id = LWLockNewTrancheId(); + int tranche_id = LWLockNewTrancheId("test_radix_tree"); dsa_area *dsa; - LWLockRegisterTranche(tranche_id, "test_radix_tree"); dsa = dsa_create(tranche_id); radixtree = rt_create(dsa, tranche_id); #else @@ -167,10 +166,9 @@ test_basic(rt_node_class_test_elem *test_info, int shift, bool asc) uint64 *keys; int children = test_info->nkeys; #ifdef TEST_SHARED_RT - int tranche_id = LWLockNewTrancheId(); + int tranche_id = LWLockNewTrancheId("test_radix_tree"); dsa_area *dsa; - LWLockRegisterTranche(tranche_id, "test_radix_tree"); dsa = dsa_create(tranche_id); radixtree = rt_create(dsa, tranche_id); #else @@ -304,10 +302,9 @@ test_random(void) int num_keys = 100000; uint64 *keys; #ifdef TEST_SHARED_RT - int tranche_id = LWLockNewTrancheId(); + int tranche_id = LWLockNewTrancheId("test_radix_tree"); dsa_area *dsa; - LWLockRegisterTranche(tranche_id, "test_radix_tree"); dsa = dsa_create(tranche_id); radixtree = rt_create(dsa, tranche_id); #else diff --git a/src/test/modules/test_slru/test_slru.c b/src/test/modules/test_slru/test_slru.c index 32750930e43..8c0367eeee4 100644 --- a/src/test/modules/test_slru/test_slru.c +++ b/src/test/modules/test_slru/test_slru.c @@ -232,11 +232,9 @@ test_slru_shmem_startup(void) (void) MakePGDirectory(slru_dir_name); /* initialize the SLRU facility */ - test_tranche_id = LWLockNewTrancheId(); - LWLockRegisterTranche(test_tranche_id, "test_slru_tranche"); + test_tranche_id = LWLockNewTrancheId("test_slru_tranche"); - test_buffer_tranche_id = LWLockNewTrancheId(); - LWLockRegisterTranche(test_tranche_id, "test_buffer_tranche"); + test_buffer_tranche_id = LWLockNewTrancheId("test_buffer_tranche"); TestSlruCtl->PagePrecedes = test_slru_page_precedes_logically; SimpleLruInit(TestSlruCtl, "TestSLRU", diff --git a/src/test/modules/test_tidstore/test_tidstore.c b/src/test/modules/test_tidstore/test_tidstore.c index eb16e0fbfa6..0c8f43867e5 100644 --- a/src/test/modules/test_tidstore/test_tidstore.c +++ b/src/test/modules/test_tidstore/test_tidstore.c @@ -103,8 +103,7 @@ test_create(PG_FUNCTION_ARGS) { int tranche_id; - tranche_id = LWLockNewTrancheId(); - LWLockRegisterTranche(tranche_id, "test_tidstore"); + tranche_id = LWLockNewTrancheId("test_tidstore"); tidstore = TidStoreCreateShared(tidstore_max_size, tranche_id); -- 2.43.0