From bf42b34a31fd1b3d79ce7a6e6390c284fa2789d8 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Fri, 20 Mar 2026 15:29:53 +0200 Subject: [PATCH v8 04/16] refactor predicate.c: Use separate variables for different sizes for clarity The ShmemInit function is very complicated currently. These refactorings move it in a direction that is more natural with the new shmem callbacks. --- src/backend/storage/lmgr/predicate.c | 68 ++++++++++++++-------------- 1 file changed, 35 insertions(+), 33 deletions(-) diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c index 27682f416e7..40950ee3a4f 100644 --- a/src/backend/storage/lmgr/predicate.c +++ b/src/backend/storage/lmgr/predicate.c @@ -1113,7 +1113,10 @@ void PredicateLockShmemInit(void) { HASHCTL info; - int64 max_table_size; + int64 max_predicate_lock_targets; + int64 max_predicate_locks; + int64 max_serializable_xacts; + int64 max_rw_conflicts; Size requestSize; bool found; @@ -1125,7 +1128,7 @@ PredicateLockShmemInit(void) * Compute size of predicate lock target hashtable. Note these * calculations must agree with PredicateLockShmemSize! */ - max_table_size = NPREDICATELOCKTARGETENTS(); + max_predicate_lock_targets = NPREDICATELOCKTARGETENTS(); /* * Allocate hash table for PREDICATELOCKTARGET structs. This stores @@ -1136,8 +1139,8 @@ PredicateLockShmemInit(void) info.num_partitions = NUM_PREDICATELOCK_PARTITIONS; PredicateLockTargetHash = ShmemInitHash("PREDICATELOCKTARGET hash", - max_table_size, - max_table_size, + max_predicate_lock_targets, + max_predicate_lock_targets, &info, HASH_ELEM | HASH_BLOBS | HASH_PARTITION | HASH_FIXED_SIZE); @@ -1169,11 +1172,11 @@ PredicateLockShmemInit(void) info.num_partitions = NUM_PREDICATELOCK_PARTITIONS; /* Assume an average of 2 xacts per target */ - max_table_size *= 2; + max_predicate_locks = max_predicate_lock_targets * 2; PredicateLockHash = ShmemInitHash("PREDICATELOCK hash", - max_table_size, - max_table_size, + max_predicate_locks, + max_predicate_locks, &info, HASH_ELEM | HASH_FUNCTION | HASH_PARTITION | HASH_FIXED_SIZE); @@ -1181,23 +1184,20 @@ PredicateLockShmemInit(void) /* * Compute size for serializable transaction hashtable. Note these * calculations must agree with PredicateLockShmemSize! - */ - max_table_size = (MaxBackends + max_prepared_xacts); - - /* - * Allocate a list to hold information on transactions participating in - * predicate locking. * * Assume an average of 10 predicate locking transactions per backend. * This allows aggressive cleanup while detail is present before data must * be summarized for storage in SLRU and the "dummy" transaction. */ - max_table_size *= 10; + max_serializable_xacts = (MaxBackends + max_prepared_xacts) * 10; + /* + * Allocate a list to hold information on transactions participating in + * predicate locking. + */ requestSize = add_size(PredXactListDataSize, - (mul_size((Size) max_table_size, + (mul_size((Size) max_serializable_xacts, sizeof(SERIALIZABLEXACT)))); - PredXact = ShmemInitStruct("PredXactList", requestSize, &found); @@ -1220,7 +1220,7 @@ PredicateLockShmemInit(void) PredXact->element = (SERIALIZABLEXACT *) ((char *) PredXact + PredXactListDataSize); /* Add all elements to available list, clean. */ - for (i = 0; i < max_table_size; i++) + for (i = 0; i < max_serializable_xacts; i++) { LWLockInitialize(&PredXact->element[i].perXactPredicateListLock, LWTRANCHE_PER_XACT_PREDICATE_LIST); @@ -1254,8 +1254,8 @@ PredicateLockShmemInit(void) info.entrysize = sizeof(SERIALIZABLEXID); SerializableXidHash = ShmemInitHash("SERIALIZABLEXID hash", - max_table_size, - max_table_size, + max_serializable_xacts, + max_serializable_xacts, &info, HASH_ELEM | HASH_BLOBS | HASH_FIXED_SIZE); @@ -1271,10 +1271,10 @@ PredicateLockShmemInit(void) * occasional transactions canceled when trying to flag conflicts. That's * probably OK. */ - max_table_size *= 5; + max_rw_conflicts = max_serializable_xacts * 5; requestSize = RWConflictPoolHeaderDataSize + - mul_size((Size) max_table_size, + mul_size((Size) max_rw_conflicts, RWConflictDataSize); RWConflictPool = ShmemInitStruct("RWConflictPool", @@ -1292,7 +1292,7 @@ PredicateLockShmemInit(void) RWConflictPool->element = (RWConflict) ((char *) RWConflictPool + RWConflictPoolHeaderDataSize); /* Add all elements to available list, clean. */ - for (i = 0; i < max_table_size; i++) + for (i = 0; i < max_rw_conflicts; i++) { dlist_push_tail(&RWConflictPool->availableList, &RWConflictPool->element[i].outLink); @@ -1353,16 +1353,19 @@ Size PredicateLockShmemSize(void) { Size size = 0; - long max_table_size; + int64 max_predicate_lock_targets; + int64 max_predicate_locks; + int64 max_serializable_xacts; + int64 max_rw_conflicts; /* predicate lock target hash table */ - max_table_size = NPREDICATELOCKTARGETENTS(); - size = add_size(size, hash_estimate_size(max_table_size, + max_predicate_lock_targets = NPREDICATELOCKTARGETENTS(); + size = add_size(size, hash_estimate_size(max_predicate_lock_targets, sizeof(PREDICATELOCKTARGET))); /* predicate lock hash table */ - max_table_size *= 2; - size = add_size(size, hash_estimate_size(max_table_size, + max_predicate_locks = max_predicate_lock_targets * 2; + size = add_size(size, hash_estimate_size(max_predicate_locks, sizeof(PREDICATELOCK))); /* @@ -1372,20 +1375,19 @@ PredicateLockShmemSize(void) size = add_size(size, size / 10); /* transaction list */ - max_table_size = MaxBackends + max_prepared_xacts; - max_table_size *= 10; + max_serializable_xacts = (MaxBackends + max_prepared_xacts) * 10; size = add_size(size, PredXactListDataSize); - size = add_size(size, mul_size((Size) max_table_size, + size = add_size(size, mul_size((Size) max_serializable_xacts, sizeof(SERIALIZABLEXACT))); /* transaction xid table */ - size = add_size(size, hash_estimate_size(max_table_size, + size = add_size(size, hash_estimate_size(max_serializable_xacts, sizeof(SERIALIZABLEXID))); /* rw-conflict pool */ - max_table_size *= 5; + max_rw_conflicts = max_serializable_xacts * 5; size = add_size(size, RWConflictPoolHeaderDataSize); - size = add_size(size, mul_size((Size) max_table_size, + size = add_size(size, mul_size((Size) max_rw_conflicts, RWConflictDataSize)); /* Head for list of finished serializable transactions. */ -- 2.47.3