From 9eaa679b5adea3a842eb944927d77f3d447646fe Mon Sep 17 00:00:00 2001 From: Tomas Vondra Date: Thu, 5 Sep 2024 18:14:09 +0200 Subject: [PATCH v20240905 2/4] Size fast-path slots using max_locks_per_transaction Instead of using a hard-coded value of 64 groups (1024 fast-path slots), determine the value based on max_locks_per_transaction GUC. This size is calculated startup, before allocating shared memory. The default value of max_locks_per_transaction value is 64, which means 4 fast-path groups by default. The max_locks_per_transaction GUC is the best information about how many locks to expect per backend, but it's main purpose is to size the shared lock table. It is often set to an average number of locks needed by a backend, while some backends may need substantially more locks. This means fast-path capacity calculated from max_locks_per_transaction may not be sufficient for those lock-hungry backends, forcing them to use the shared lock table. If that is a problem, the only solution is to increase the GUC, even if the capacity of the shared lock table was already sufficient. That is not free, because each lock in the shared lock table requires almost 500B. The assumption is this is not an issue. Either there are only few of those lock-intensive backends, in which case concurrency when accessing the shared lock table is not an issue. Or there are enough of them to actually need a higher max_locks_per_transaction value. It may turn out we actually need a separate GUC for fast-path locking, but let's not add one until we're sure that's actually the case. An alternative approach might be to size the fast-path arrays for a multiple of max_locks_per_transaction. The cost of adding a fast-path slot is much lower (only ~5B compared to ~500B for shared lock table), so this would be cheaper than increasing max_locks_per_transaction. But it's not clear what multiple of max_locks_per_transaction to use. --- src/backend/bootstrap/bootstrap.c | 2 ++ src/backend/postmaster/postmaster.c | 5 +++ src/backend/storage/lmgr/lock.c | 34 +++++++++++++++------ src/backend/storage/lmgr/proc.c | 47 +++++++++++++++++++++++++++++ src/backend/tcop/postgres.c | 3 ++ src/backend/utils/init/postinit.c | 34 +++++++++++++++++++++ src/include/miscadmin.h | 1 + src/include/storage/proc.h | 11 ++++--- 8 files changed, 123 insertions(+), 14 deletions(-) diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c index 7637581a184..ed59dfce893 100644 --- a/src/backend/bootstrap/bootstrap.c +++ b/src/backend/bootstrap/bootstrap.c @@ -309,6 +309,8 @@ BootstrapModeMain(int argc, char *argv[], bool check_only) InitializeMaxBackends(); + InitializeFastPathLocks(); + CreateSharedMemoryAndSemaphores(); /* diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 96bc1d1cfed..f4a16595d7f 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -903,6 +903,11 @@ PostmasterMain(int argc, char *argv[]) */ InitializeMaxBackends(); + /* + * Also calculate the size of the fast-path lock arrays in PGPROC. + */ + InitializeFastPathLocks(); + /* * Give preloaded libraries a chance to request additional shared memory. */ diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c index f41e4a33f06..134cd8a6e34 100644 --- a/src/backend/storage/lmgr/lock.c +++ b/src/backend/storage/lmgr/lock.c @@ -166,8 +166,13 @@ typedef struct TwoPhaseLockRecord * might be higher than the real number if another backend has transferred * our locks to the primary lock table, but it can never be lower than the * real value, since only we can acquire locks on our own behalf. + * + * XXX Allocate a static array of the maximum size. We could have a pointer + * and then allocate just the right size to save a couple kB, but that does + * not seem worth the extra complexity of having to initialize it etc. This + * way it gets initialized automaticaly. */ -static int FastPathLocalUseCounts[FP_LOCK_GROUPS_PER_BACKEND]; +static int FastPathLocalUseCounts[FP_LOCK_GROUPS_PER_BACKEND_MAX]; /* * Flag to indicate if the relation extension lock is held by this backend. @@ -184,6 +189,17 @@ static int FastPathLocalUseCounts[FP_LOCK_GROUPS_PER_BACKEND]; */ static bool IsRelationExtensionLockHeld PG_USED_FOR_ASSERTS_ONLY = false; +/* + * Number of fast-path locks per backend - size of the arrays in PGPROC. + * This is set only once during start, before initializing shared memory, + * and remains constant after that. + * + * We set the limit based on max_locks_per_transaction GUC, because that's + * the best information about expected number of locks per backend we have. + * See InitializeFastPathLocks for details. + */ +int FastPathLockGroupsPerBackend = 0; + /* * Macros to calculate the group and index for a relation. * @@ -198,7 +214,7 @@ static bool IsRelationExtensionLockHeld PG_USED_FOR_ASSERTS_ONLY = false; * did (rel % 100000) or something like that first, that'd be enough to * not wrap around. But even if it wrapped, would that be a problem? */ -#define FAST_PATH_LOCK_REL_GROUP(rel) (((uint64) (rel) * 49157) % FP_LOCK_GROUPS_PER_BACKEND) +#define FAST_PATH_LOCK_REL_GROUP(rel) (((uint64) (rel) * 49157) % FastPathLockGroupsPerBackend) /* * Given a lock index (into the per-backend array), calculated using the @@ -213,7 +229,7 @@ static bool IsRelationExtensionLockHeld PG_USED_FOR_ASSERTS_ONLY = false; /* Calculate index in the whole per-backend array of lock slots. */ #define FP_LOCK_SLOT_INDEX(group, index) \ - (AssertMacro(((group) >= 0) && ((group) < FP_LOCK_GROUPS_PER_BACKEND)), \ + (AssertMacro(((group) >= 0) && ((group) < FastPathLockGroupsPerBackend)), \ AssertMacro(((index) >= 0) && ((index) < FP_LOCK_SLOTS_PER_GROUP)), \ ((group) * FP_LOCK_SLOTS_PER_GROUP + (index))) @@ -2100,7 +2116,7 @@ LockRelease(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock) /* Which FP group does the lock belong to? */ group = FAST_PATH_LOCK_REL_GROUP(locktag->locktag_field2); - Assert(group >= 0 && group < FP_LOCK_GROUPS_PER_BACKEND); + Assert(group >= 0 && group < FastPathLockGroupsPerBackend); /* Attempt fast release of any lock eligible for the fast path. */ if (EligibleForRelationFastPath(locktag, lockmode) && @@ -2679,7 +2695,7 @@ FastPathGrantRelationLock(Oid relid, LOCKMODE lockmode) /* Which FP group does the lock belong to? */ group = FAST_PATH_LOCK_REL_GROUP(relid); - Assert(group < FP_LOCK_GROUPS_PER_BACKEND); + Assert(group < FastPathLockGroupsPerBackend); /* Scan for existing entry for this relid, remembering empty slot. */ for (i = 0; i < FP_LOCK_SLOTS_PER_GROUP; i++) @@ -2730,7 +2746,7 @@ FastPathUnGrantRelationLock(Oid relid, LOCKMODE lockmode) /* Which FP group does the lock belong to? */ group = FAST_PATH_LOCK_REL_GROUP(relid); - Assert(group < FP_LOCK_GROUPS_PER_BACKEND); + Assert(group < FastPathLockGroupsPerBackend); FastPathLocalUseCounts[group] = 0; for (i = 0; i < FP_LOCK_SLOTS_PER_GROUP; i++) @@ -2810,7 +2826,7 @@ FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag /* Which FP group does the lock belong to? */ group = FAST_PATH_LOCK_REL_GROUP(relid); - Assert(group < FP_LOCK_GROUPS_PER_BACKEND); + Assert(group < FastPathLockGroupsPerBackend); for (j = 0; j < FP_LOCK_SLOTS_PER_GROUP; j++) { @@ -2879,7 +2895,7 @@ FastPathGetRelationLockEntry(LOCALLOCK *locallock) /* Which FP group does the lock belong to? */ group = FAST_PATH_LOCK_REL_GROUP(relid); - Assert(group < FP_LOCK_GROUPS_PER_BACKEND); + Assert(group < FastPathLockGroupsPerBackend); LWLockAcquire(&MyProc->fpInfoLock, LW_EXCLUSIVE); @@ -3001,7 +3017,7 @@ GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp) /* Which FP group does the lock belong to? */ group = FAST_PATH_LOCK_REL_GROUP(locktag->locktag_field2); - Assert(group < FP_LOCK_GROUPS_PER_BACKEND); + Assert(group < FastPathLockGroupsPerBackend); if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods)) elog(ERROR, "unrecognized lock method: %d", lockmethodid); diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c index ac66da8638f..a91b6f8a6c0 100644 --- a/src/backend/storage/lmgr/proc.c +++ b/src/backend/storage/lmgr/proc.c @@ -103,6 +103,8 @@ ProcGlobalShmemSize(void) Size size = 0; Size TotalProcs = add_size(MaxBackends, add_size(NUM_AUXILIARY_PROCS, max_prepared_xacts)); + Size fpLockBitsSize, + fpRelIdSize; /* ProcGlobal */ size = add_size(size, sizeof(PROC_HDR)); @@ -113,6 +115,18 @@ ProcGlobalShmemSize(void) size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->subxidStates))); size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->statusFlags))); + /* + * fast-path lock arrays + * + * XXX The explicit alignment may not be strictly necessary, as both + * values are already multiples of 8 bytes, which is what MAXALIGN does. + * But better to make that obvious. + */ + fpLockBitsSize = MAXALIGN(FastPathLockGroupsPerBackend * sizeof(uint64)); + fpRelIdSize = MAXALIGN(FastPathLockGroupsPerBackend * sizeof(Oid) * FP_LOCK_SLOTS_PER_GROUP); + + size = add_size(size, mul_size(TotalProcs, (fpLockBitsSize + fpRelIdSize))); + return size; } @@ -162,6 +176,10 @@ InitProcGlobal(void) j; bool found; uint32 TotalProcs = MaxBackends + NUM_AUXILIARY_PROCS + max_prepared_xacts; + char *fpPtr, + *fpEndPtr PG_USED_FOR_ASSERTS_ONLY; + Size fpLockBitsSize, + fpRelIdSize; /* Create the ProcGlobal shared structure */ ProcGlobal = (PROC_HDR *) @@ -211,12 +229,38 @@ InitProcGlobal(void) ProcGlobal->statusFlags = (uint8 *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->statusFlags)); MemSet(ProcGlobal->statusFlags, 0, TotalProcs * sizeof(*ProcGlobal->statusFlags)); + /* + * Allocate arrays for fast-path locks. Those are variable-length, so + * can't be included in PGPROC. We allocate a separate piece of shared + * memory and then divide that between backends. + */ + fpLockBitsSize = MAXALIGN(FastPathLockGroupsPerBackend * sizeof(uint64)); + fpRelIdSize = MAXALIGN(FastPathLockGroupsPerBackend * sizeof(Oid) * FP_LOCK_SLOTS_PER_GROUP); + + fpPtr = ShmemAlloc(TotalProcs * (fpLockBitsSize + fpRelIdSize)); + MemSet(fpPtr, 0, TotalProcs * (fpLockBitsSize + fpRelIdSize)); + + /* For asserts checking we did not overflow. */ + fpEndPtr = fpPtr + (TotalProcs * (fpLockBitsSize + fpRelIdSize)); + for (i = 0; i < TotalProcs; i++) { PGPROC *proc = &procs[i]; /* Common initialization for all PGPROCs, regardless of type. */ + /* + * Set the fast-path lock arrays, and move the pointer. We interleave + * the two arrays, to keep at least some locality. + */ + proc->fpLockBits = (uint64 *) fpPtr; + fpPtr += fpLockBitsSize; + + proc->fpRelId = (Oid *) fpPtr; + fpPtr += fpRelIdSize; + + Assert(fpPtr <= fpEndPtr); + /* * Set up per-PGPROC semaphore, latch, and fpInfoLock. Prepared xact * dummy PGPROCs don't need these though - they're never associated @@ -278,6 +322,9 @@ InitProcGlobal(void) pg_atomic_init_u64(&(proc->waitStart), 0); } + /* We expect to consume exactly the expected amount of data. */ + Assert(fpPtr = fpEndPtr); + /* * Save pointers to the blocks of PGPROC structures reserved for auxiliary * processes and prepared transactions. diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index 8bc6bea1135..f54ae00abca 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -4166,6 +4166,9 @@ PostgresSingleUserMain(int argc, char *argv[], /* Initialize MaxBackends */ InitializeMaxBackends(); + /* Initialize size of fast-path lock cache. */ + InitializeFastPathLocks(); + /* * Give preloaded libraries a chance to request additional shared memory. */ diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c index 3b50ce19a2c..1faf756c8d8 100644 --- a/src/backend/utils/init/postinit.c +++ b/src/backend/utils/init/postinit.c @@ -557,6 +557,40 @@ InitializeMaxBackends(void) MAX_BACKENDS))); } +/* + * Initialize the number of fast-path lock slots in PGPROC. + * + * This must be called after modules have had the chance to alter GUCs in + * shared_preload_libraries and before shared memory size is determined. + * + * The default max_locks_per_xact=64 means 4 groups by default. + * + * We allow anything between 1 and 1024 groups, with the usual power-of-2 + * logic. The 1 is the "old" value before allowing multiple groups, 1024 + * is an arbitrary limit (matching max_locks_per_xact = 16k). Values over + * 1024 are unlikely to be beneficial - we're likely to hit other + * bottlenecks long before that. + */ +void +InitializeFastPathLocks(void) +{ + Assert(FastPathLockGroupsPerBackend == 0); + + /* we need at least one group */ + FastPathLockGroupsPerBackend = 1; + + while (FastPathLockGroupsPerBackend < FP_LOCK_GROUPS_PER_BACKEND_MAX) + { + /* stop once we exceed max_locks_per_xact */ + if (FastPathLockGroupsPerBackend * FP_LOCK_SLOTS_PER_GROUP >= max_locks_per_xact) + break; + + FastPathLockGroupsPerBackend *= 2; + } + + Assert(FastPathLockGroupsPerBackend <= FP_LOCK_GROUPS_PER_BACKEND_MAX); +} + /* * Early initialization of a backend (either standalone or under postmaster). * This happens even before InitPostgres. diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h index 25348e71eb9..e26d108a470 100644 --- a/src/include/miscadmin.h +++ b/src/include/miscadmin.h @@ -475,6 +475,7 @@ extern PGDLLIMPORT ProcessingMode Mode; #define INIT_PG_OVERRIDE_ROLE_LOGIN 0x0004 extern void pg_split_opts(char **argv, int *argcp, const char *optstr); extern void InitializeMaxBackends(void); +extern void InitializeFastPathLocks(void); extern void InitPostgres(const char *in_dbname, Oid dboid, const char *username, Oid useroid, bits32 flags, diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h index 845058da9fa..0e55c166529 100644 --- a/src/include/storage/proc.h +++ b/src/include/storage/proc.h @@ -83,9 +83,11 @@ struct XidCache * rather than the main lock table. This eases contention on the lock * manager LWLocks. See storage/lmgr/README for additional details. */ -#define FP_LOCK_GROUPS_PER_BACKEND 64 +extern PGDLLIMPORT int FastPathLockGroupsPerBackend; +#define FP_LOCK_GROUPS_PER_BACKEND_MAX 1024 #define FP_LOCK_SLOTS_PER_GROUP 16 /* don't change */ -#define FP_LOCK_SLOTS_PER_BACKEND (FP_LOCK_SLOTS_PER_GROUP * FP_LOCK_GROUPS_PER_BACKEND) +#define FP_LOCK_SLOTS_PER_BACKEND (FP_LOCK_SLOTS_PER_GROUP * FastPathLockGroupsPerBackend) + /* * Flags for PGPROC.delayChkptFlags * @@ -293,9 +295,8 @@ struct PGPROC /* Lock manager data, recording fast-path locks taken by this backend. */ LWLock fpInfoLock; /* protects per-backend fast-path state */ - uint64 fpLockBits[FP_LOCK_GROUPS_PER_BACKEND]; /* lock modes held for - * each fast-path slot */ - Oid fpRelId[FP_LOCK_SLOTS_PER_BACKEND]; /* slots for rel oids */ + uint64 *fpLockBits; /* lock modes held for each fast-path slot */ + Oid *fpRelId; /* slots for rel oids */ bool fpVXIDLock; /* are we holding a fast-path VXID lock? */ LocalTransactionId fpLocalTransactionId; /* lxid for fast-path VXID * lock */ -- 2.46.0