Provide a way to predefine LWLock tranche IDs.

It's a bit cumbersome to use LWLockNewTrancheId(), because the returned
value needs to be shared between backends so that each backend can call
LWLockRegisterTranche() with the correct ID.  So, for built-in tranches,
use a hard-coded value instead.

This is motivated by an upcoming patch adding further built-in tranches.

Andres Freund and Robert Haas

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 71fc8ffa272d423789dc59652d09de93865b61ce..147fd538d2fc2493edff4d6ed85e8a61361c769b 100644 (file)
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -512,7 +512,6 @@ typedef struct XLogCtlInsert
     */
    WALInsertLockPadded *WALInsertLocks;
    LWLockTranche WALInsertLockTranche;
-   int         WALInsertLockTrancheId;
 } XLogCtlInsert;
 
 /*
@@ -4653,7 +4652,7 @@ XLOGShmemInit(void)
 
        /* Initialize local copy of WALInsertLocks and register the tranche */
        WALInsertLocks = XLogCtl->Insert.WALInsertLocks;
-       LWLockRegisterTranche(XLogCtl->Insert.WALInsertLockTrancheId,
+       LWLockRegisterTranche(LWTRANCHE_WAL_INSERT,
                              &XLogCtl->Insert.WALInsertLockTranche);
        return;
    }
@@ -4677,17 +4676,14 @@ XLOGShmemInit(void)
        (WALInsertLockPadded *) allocptr;
    allocptr += sizeof(WALInsertLockPadded) * NUM_XLOGINSERT_LOCKS;
 
-   XLogCtl->Insert.WALInsertLockTrancheId = LWLockNewTrancheId();
-
    XLogCtl->Insert.WALInsertLockTranche.name = "WALInsertLocks";
    XLogCtl->Insert.WALInsertLockTranche.array_base = WALInsertLocks;
    XLogCtl->Insert.WALInsertLockTranche.array_stride = sizeof(WALInsertLockPadded);
 
-   LWLockRegisterTranche(XLogCtl->Insert.WALInsertLockTrancheId, &XLogCtl->Insert.WALInsertLockTranche);
+   LWLockRegisterTranche(LWTRANCHE_WAL_INSERT, &XLogCtl->Insert.WALInsertLockTranche);
    for (i = 0; i < NUM_XLOGINSERT_LOCKS; i++)
    {
-       LWLockInitialize(&WALInsertLocks[i].l.lock,
-                        XLogCtl->Insert.WALInsertLockTrancheId);
+       LWLockInitialize(&WALInsertLocks[i].l.lock, LWTRANCHE_WAL_INSERT);
        WALInsertLocks[i].l.insertingAt = InvalidXLogRecPtr;
    }
 

diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c
index b13ebc637c29ef84dd64123e58002f465db39e0a..84691df053b875c71e90c5032bd951837750a40e 100644 (file)
--- a/src/backend/storage/lmgr/lwlock.c
+++ b/src/backend/storage/lmgr/lwlock.c
@@ -445,7 +445,7 @@ CreateLWLocks(void)
 
        /* Initialize all LWLocks in main array */
        for (id = 0, lock = MainLWLockArray; id < numLocks; id++, lock++)
-           LWLockInitialize(&lock->lock, 0);
+           LWLockInitialize(&lock->lock, LWTRANCHE_MAIN);
 
        /*
         * Initialize the dynamic-allocation counters, which are stored just
@@ -457,7 +457,7 @@ CreateLWLocks(void)
        LWLockCounter = (int *) ((char *) MainLWLockArray - 3 * sizeof(int));
        LWLockCounter[0] = NUM_FIXED_LWLOCKS;
        LWLockCounter[1] = numLocks;
-       LWLockCounter[2] = 1;   /* 0 is the main array */
+       LWLockCounter[2] = LWTRANCHE_FIRST_USER_DEFINED;
    }
 
    if (LWLockTrancheArray == NULL)
@@ -466,12 +466,13 @@ CreateLWLocks(void)
        LWLockTrancheArray = (LWLockTranche **)
            MemoryContextAlloc(TopMemoryContext,
                          LWLockTranchesAllocated * sizeof(LWLockTranche *));
+       Assert(LWLockTranchesAllocated >= LWTRANCHE_FIRST_USER_DEFINED);
    }
 
    MainLWLockTranche.name = "main";
    MainLWLockTranche.array_base = MainLWLockArray;
    MainLWLockTranche.array_stride = sizeof(LWLockPadded);
-   LWLockRegisterTranche(0, &MainLWLockTranche);
+   LWLockRegisterTranche(LWTRANCHE_MAIN, &MainLWLockTranche);
 }
 
 /*

diff --git a/src/include/storage/lwlock.h b/src/include/storage/lwlock.h
index 4653e099b0dba11519bbad59622e4a32b0ce5ff2..ed9025babd183c98f2f360ac0ac044dba6e09100 100644 (file)
--- a/src/include/storage/lwlock.h
+++ b/src/include/storage/lwlock.h
@@ -176,6 +176,17 @@ extern int LWLockNewTrancheId(void);
 extern void LWLockRegisterTranche(int tranche_id, LWLockTranche *tranche);
 extern void LWLockInitialize(LWLock *lock, int tranche_id);
 
+/*
+ * We reserve a few predefined tranche IDs.  A call to LWLockNewTrancheId
+ * will never return a value less than LWTRANCHE_FIRST_USER_DEFINED.
+ */
+typedef enum BuiltinTrancheIds
+{
+   LWTRANCHE_MAIN,
+   LWTRANCHE_WAL_INSERT,
+   LWTRANCHE_FIRST_USER_DEFINED
+}  BuiltinTrancheIds;
+
 /*
  * Prior to PostgreSQL 9.4, we used an enum type called LWLockId to refer
  * to LWLocks.  New code should instead use LWLock *.  However, for the