Use separate lwlock tranches for buffer, lock, and predicate lock managers.

This finishes the work - spread across many commits over the last
several months - of putting each type of lock other than the named
individual locks into a separate tranche.

Amit Kapila

diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c
index fe22c29e9b005c61acf32f56669f32e03d4597b3..d245857a814d891d0943483daacfbe9599a6452e 100644 (file)
--- a/src/backend/storage/lmgr/lwlock.c
+++ b/src/backend/storage/lmgr/lwlock.c
@@ -125,6 +125,9 @@ static int  LWLockTranchesAllocated = 0;
  */
 LWLockPadded *MainLWLockArray = NULL;
 static LWLockTranche MainLWLockTranche;
+static LWLockTranche BufMappingLWLockTranche;
+static LWLockTranche LockManagerLWLockTranche;
+static LWLockTranche PredicateLockManagerLWLockTranche;
 
 /*
  * We use this structure to keep track of locked LWLocks for release
@@ -159,6 +162,9 @@ NamedLWLockTranche *NamedLWLockTrancheArray = NULL;
 
 static bool lock_named_request_allowed = true;
 
+static void InitializeLWLocks(void);
+static void RegisterLWLockTranches(void);
+
 #ifdef LWLOCK_STATS
 typedef struct lwlock_stats_key
 {
@@ -395,14 +401,12 @@ LWLockShmemSize(void)
 }
 
 /*
- * Allocate shmem space for the main LWLock array and named tranches and
- * initialize it.  We also register the main and named tranche here.
+ * Allocate shmem space for the main LWLock array and all tranches and
+ * initialize it.  We also register all the LWLock tranches here.
  */
 void
 CreateLWLocks(void)
 {
-       int                     i;
-
        StaticAssertExpr(LW_VAL_EXCLUSIVE > (uint32) MAX_BACKENDS,
                                         "MAX_BACKENDS too big for lwlock.c");
 
@@ -412,14 +416,9 @@ CreateLWLocks(void)
 
        if (!IsUnderPostmaster)
        {
-               int                     numLocks = NUM_FIXED_LWLOCKS;
-               int                     numNamedLocks = NumLWLocksByNamedTranches();
                Size            spaceLocks = LWLockShmemSize();
-               LWLockPadded *lock;
                int                *LWLockCounter;
                char       *ptr;
-               int                     id;
-               int                     j;
 
                /* Allocate space */
                ptr = (char *) ShmemAlloc(spaceLocks);
@@ -432,10 +431,6 @@ CreateLWLocks(void)
 
                MainLWLockArray = (LWLockPadded *) ptr;
 
-               /* Initialize all fixed LWLocks in main array */
-               for (id = 0, lock = MainLWLockArray; id < numLocks; id++, lock++)
-                       LWLockInitialize(&lock->lock, LWTRANCHE_MAIN);
-
                /*
                 * Initialize the dynamic-allocation counter for tranches, which is
                 * stored just before the first LWLock.
@@ -443,44 +438,92 @@ CreateLWLocks(void)
                LWLockCounter = (int *) ((char *) MainLWLockArray - sizeof(int));
                *LWLockCounter = LWTRANCHE_FIRST_USER_DEFINED;
 
-               /* Initialize named tranches. */
-               if (NamedLWLockTrancheRequests > 0)
-               {
-                       char       *trancheNames;
+               /* Initialize all LWLocks */
+               InitializeLWLocks();
+       }
+
+       /* Register all LWLock tranches */
+       RegisterLWLockTranches();
+}
+
+/*
+ * Initialize LWLocks that are fixed and those belonging to named tranches.
+ */
+static void
+InitializeLWLocks(void)
+{
+       int                     numNamedLocks = NumLWLocksByNamedTranches();
+       int                     id;
+       int                     i;
+       int                     j;
+       LWLockPadded *lock;
+
+       /* Initialize all individual LWLocks in main array */
+       for (id = 0, lock = MainLWLockArray; id < NUM_INDIVIDUAL_LWLOCKS; id++, lock++)
+               LWLockInitialize(&lock->lock, LWTRANCHE_MAIN);
+
+       /* Initialize buffer mapping LWLocks in main array */
+       lock = MainLWLockArray + NUM_INDIVIDUAL_LWLOCKS;
+       for (id = 0; id < NUM_BUFFER_PARTITIONS; id++, lock++)
+               LWLockInitialize(&lock->lock, LWTRANCHE_BUFFER_MAPPING);
+
+       /* Initialize lmgrs' LWLocks in main array */
+       lock = MainLWLockArray + NUM_INDIVIDUAL_LWLOCKS + NUM_BUFFER_PARTITIONS;
+       for (id = 0; id < NUM_LOCK_PARTITIONS; id++, lock++)
+               LWLockInitialize(&lock->lock, LWTRANCHE_LOCK_MANAGER);
+
+       /* Initialize predicate lmgrs' LWLocks in main array */
+       lock = MainLWLockArray + NUM_INDIVIDUAL_LWLOCKS +
+               NUM_BUFFER_PARTITIONS + NUM_LOCK_PARTITIONS;
+       for (id = 0; id < NUM_PREDICATELOCK_PARTITIONS; id++, lock++)
+               LWLockInitialize(&lock->lock, LWTRANCHE_PREDICATE_LOCK_MANAGER);
+
+       /* Initialize named tranches. */
+       if (NamedLWLockTrancheRequests > 0)
+       {
+               char       *trancheNames;
 
-                       NamedLWLockTrancheArray = (NamedLWLockTranche *)
-                               &MainLWLockArray[numLocks + numNamedLocks];
+               NamedLWLockTrancheArray = (NamedLWLockTranche *)
+                       &MainLWLockArray[NUM_FIXED_LWLOCKS + numNamedLocks];
 
-                       trancheNames = (char *) NamedLWLockTrancheArray +
-                               (NamedLWLockTrancheRequests * sizeof(NamedLWLockTranche));
-                       lock = &MainLWLockArray[numLocks];
+               trancheNames = (char *) NamedLWLockTrancheArray +
+                       (NamedLWLockTrancheRequests * sizeof(NamedLWLockTranche));
+               lock = &MainLWLockArray[NUM_FIXED_LWLOCKS];
 
-                       for (i = 0; i < NamedLWLockTrancheRequests; i++)
-                       {
-                               NamedLWLockTrancheRequest *request;
-                               NamedLWLockTranche *tranche;
-                               char       *name;
-
-                               request = &NamedLWLockTrancheRequestArray[i];
-                               tranche = &NamedLWLockTrancheArray[i];
-
-                               name = trancheNames;
-                               trancheNames += strlen(request->tranche_name) + 1;
-                               strcpy(name, request->tranche_name);
-                               tranche->lwLockTranche.name = name;
-                               tranche->trancheId = LWLockNewTrancheId();
-                               tranche->lwLockTranche.array_base = lock;
-                               tranche->lwLockTranche.array_stride = sizeof(LWLockPadded);
-
-                               for (j = 0; j < request->num_lwlocks; j++, lock++)
-                                       LWLockInitialize(&lock->lock, tranche->trancheId);
-                       }
+               for (i = 0; i < NamedLWLockTrancheRequests; i++)
+               {
+                       NamedLWLockTrancheRequest *request;
+                       NamedLWLockTranche *tranche;
+                       char       *name;
+
+                       request = &NamedLWLockTrancheRequestArray[i];
+                       tranche = &NamedLWLockTrancheArray[i];
+
+                       name = trancheNames;
+                       trancheNames += strlen(request->tranche_name) + 1;
+                       strcpy(name, request->tranche_name);
+                       tranche->lwLockTranche.name = name;
+                       tranche->trancheId = LWLockNewTrancheId();
+                       tranche->lwLockTranche.array_base = lock;
+                       tranche->lwLockTranche.array_stride = sizeof(LWLockPadded);
+
+                       for (j = 0; j < request->num_lwlocks; j++, lock++)
+                               LWLockInitialize(&lock->lock, tranche->trancheId);
                }
        }
+}
+
+/*
+ * Register named tranches and tranches for fixed LWLocks.
+ */
+static void
+RegisterLWLockTranches(void)
+{
+       int                     i;
 
        if (LWLockTrancheArray == NULL)
        {
-               LWLockTranchesAllocated = 16;
+               LWLockTranchesAllocated = 32;
                LWLockTrancheArray = (LWLockTranche **)
                        MemoryContextAlloc(TopMemoryContext,
                                                  LWLockTranchesAllocated * sizeof(LWLockTranche *));
@@ -492,6 +535,23 @@ CreateLWLocks(void)
        MainLWLockTranche.array_stride = sizeof(LWLockPadded);
        LWLockRegisterTranche(LWTRANCHE_MAIN, &MainLWLockTranche);
 
+       BufMappingLWLockTranche.name = "buffer_mapping";
+       BufMappingLWLockTranche.array_base = MainLWLockArray + NUM_INDIVIDUAL_LWLOCKS;
+       BufMappingLWLockTranche.array_stride = sizeof(LWLockPadded);
+       LWLockRegisterTranche(LWTRANCHE_BUFFER_MAPPING, &BufMappingLWLockTranche);
+
+       LockManagerLWLockTranche.name = "lock_manager";
+       LockManagerLWLockTranche.array_base = MainLWLockArray + NUM_INDIVIDUAL_LWLOCKS +
+               NUM_BUFFER_PARTITIONS;
+       LockManagerLWLockTranche.array_stride = sizeof(LWLockPadded);
+       LWLockRegisterTranche(LWTRANCHE_LOCK_MANAGER, &LockManagerLWLockTranche);
+
+       PredicateLockManagerLWLockTranche.name = "predicate_lock_manager";
+       PredicateLockManagerLWLockTranche.array_base = MainLWLockArray + NUM_INDIVIDUAL_LWLOCKS +
+               NUM_BUFFER_PARTITIONS + NUM_LOCK_PARTITIONS;
+       PredicateLockManagerLWLockTranche.array_stride = sizeof(LWLockPadded);
+       LWLockRegisterTranche(LWTRANCHE_PREDICATE_LOCK_MANAGER, &PredicateLockManagerLWLockTranche);
+
        /* Register named tranches. */
        for (i = 0; i < NamedLWLockTrancheRequests; i++)
                LWLockRegisterTranche(NamedLWLockTrancheArray[i].trancheId,

diff --git a/src/include/storage/lwlock.h b/src/include/storage/lwlock.h
index 57db8c548ab71da28da87cb80587bdc38cf277ad..de92d166e4c7fb7c57a70b3526d912cbdbfa5a7e 100644 (file)
--- a/src/include/storage/lwlock.h
+++ b/src/include/storage/lwlock.h
@@ -233,6 +233,9 @@ typedef enum BuiltinTrancheIds
        LWTRANCHE_REPLICATION_ORIGIN,
        LWTRANCHE_REPLICATION_SLOT_IO_IN_PROGRESS,
        LWTRANCHE_PROC,
+       LWTRANCHE_BUFFER_MAPPING,
+       LWTRANCHE_LOCK_MANAGER,
+       LWTRANCHE_PREDICATE_LOCK_MANAGER,
        LWTRANCHE_FIRST_USER_DEFINED
 }      BuiltinTrancheIds;