Rename PGPROC fields related to group XID clearing again.

Commit 0e141c0fbb211bdd23783afa731e3eef95c9ad7a introduced a new
facility to reduce ProcArrayLock contention by clearing several XIDs
from the ProcArray under a single lock acquisition.  The names
initially chosen were deemed not to be very good choices, so commit
4aec49899e5782247e134f94ce1c6ee926f88e1c renamed them.  But now it
seems like we still didn't get it right.  A pending patch wants to
add similar infrastructure for batching CLOG updates, so the names
need to be clear enough to allow a new set of structure members with
a related purpose.

Amit Kapila

diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
index 6ded0f0f1267d316d0c79ae9b093344cf8c6b548..91218d0e56b11f7f11b7ad5409773210f355d9c1 100644 (file)
--- a/src/backend/storage/ipc/procarray.c
+++ b/src/backend/storage/ipc/procarray.c
@@ -497,14 +497,14 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid)
        Assert(TransactionIdIsValid(allPgXact[proc->pgprocno].xid));
 
        /* Add ourselves to the list of processes needing a group XID clear. */
-       proc->clearXid = true;
-       proc->backendLatestXid = latestXid;
+       proc->procArrayGroupMember = true;
+       proc->procArrayGroupMemberXid = latestXid;
        while (true)
        {
-               nextidx = pg_atomic_read_u32(&procglobal->firstClearXidElem);
-               pg_atomic_write_u32(&proc->nextClearXidElem, nextidx);
+               nextidx = pg_atomic_read_u32(&procglobal->procArrayGroupFirst);
+               pg_atomic_write_u32(&proc->procArrayGroupNext, nextidx);
 
-               if (pg_atomic_compare_exchange_u32(&procglobal->firstClearXidElem,
+               if (pg_atomic_compare_exchange_u32(&procglobal->procArrayGroupFirst,
                                                                                   &nextidx,
                                                                                   (uint32) proc->pgprocno))
                        break;
@@ -523,12 +523,12 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid)
                {
                        /* acts as a read barrier */
                        PGSemaphoreLock(&proc->sem);
-                       if (!proc->clearXid)
+                       if (!proc->procArrayGroupMember)
                                break;
                        extraWaits++;
                }
 
-               Assert(pg_atomic_read_u32(&proc->nextClearXidElem) == INVALID_PGPROCNO);
+               Assert(pg_atomic_read_u32(&proc->procArrayGroupNext) == INVALID_PGPROCNO);
 
                /* Fix semaphore count for any absorbed wakeups */
                while (extraWaits-- > 0)
@@ -546,8 +546,8 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid)
         */
        while (true)
        {
-               nextidx = pg_atomic_read_u32(&procglobal->firstClearXidElem);
-               if (pg_atomic_compare_exchange_u32(&procglobal->firstClearXidElem,
+               nextidx = pg_atomic_read_u32(&procglobal->procArrayGroupFirst);
+               if (pg_atomic_compare_exchange_u32(&procglobal->procArrayGroupFirst,
                                                                                   &nextidx,
                                                                                   INVALID_PGPROCNO))
                        break;
@@ -562,10 +562,10 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid)
                PGPROC  *proc = &allProcs[nextidx];
                PGXACT  *pgxact = &allPgXact[nextidx];
 
-               ProcArrayEndTransactionInternal(proc, pgxact, proc->backendLatestXid);
+               ProcArrayEndTransactionInternal(proc, pgxact, proc->procArrayGroupMemberXid);
 
                /* Move to next proc in list. */
-               nextidx = pg_atomic_read_u32(&proc->nextClearXidElem);
+               nextidx = pg_atomic_read_u32(&proc->procArrayGroupNext);
        }
 
        /* We're done with the lock now. */
@@ -582,13 +582,13 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid)
        {
                PGPROC  *proc = &allProcs[wakeidx];
 
-               wakeidx = pg_atomic_read_u32(&proc->nextClearXidElem);
-               pg_atomic_write_u32(&proc->nextClearXidElem, INVALID_PGPROCNO);
+               wakeidx = pg_atomic_read_u32(&proc->procArrayGroupNext);
+               pg_atomic_write_u32(&proc->procArrayGroupNext, INVALID_PGPROCNO);
 
                /* ensure all previous writes are visible before follower continues. */
                pg_write_barrier();
 
-               proc->clearXid = false;
+               proc->procArrayGroupMember = false;
 
                if (proc != MyProc)
                        PGSemaphoreUnlock(&proc->sem);

diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c
index 084be5a026ca5b7aeb1c520a9d9c821db3823f26..844222eec2d49743aab2ffc3154ef06ea5f76475 100644 (file)
--- a/src/backend/storage/lmgr/proc.c
+++ b/src/backend/storage/lmgr/proc.c
@@ -181,7 +181,7 @@ InitProcGlobal(void)
        ProcGlobal->startupBufferPinWaitBufId = -1;
        ProcGlobal->walwriterLatch = NULL;
        ProcGlobal->checkpointerLatch = NULL;
-       pg_atomic_init_u32(&ProcGlobal->firstClearXidElem, INVALID_PGPROCNO);
+       pg_atomic_init_u32(&ProcGlobal->procArrayGroupFirst, INVALID_PGPROCNO);
 
        /*
         * Create and initialize all the PGPROC structures we'll need.  There are
@@ -396,9 +396,9 @@ InitProcess(void)
        SHMQueueElemInit(&(MyProc->syncRepLinks));
 
        /* Initialize fields for group XID clearing. */
-       MyProc->clearXid = false;
-       MyProc->backendLatestXid = InvalidTransactionId;
-       pg_atomic_init_u32(&MyProc->nextClearXidElem, INVALID_PGPROCNO);
+       MyProc->procArrayGroupMember = false;
+       MyProc->procArrayGroupMemberXid = InvalidTransactionId;
+       pg_atomic_init_u32(&MyProc->procArrayGroupNext, INVALID_PGPROCNO);
 
        /* Check that group locking fields are in a proper initial state. */
        Assert(MyProc->lockGroupLeaderIdentifier == 0);

diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h
index 66ab255f4c6dbed4d331bc3fbd704d0e35608a61..81bddbba638c7b0d4833b06665aeeeeaea8b06cc 100644 (file)
--- a/src/include/storage/proc.h
+++ b/src/include/storage/proc.h
@@ -142,9 +142,15 @@ struct PGPROC
        struct XidCache subxids;        /* cache for subtransaction XIDs */
 
        /* Support for group XID clearing. */
-       bool                    clearXid;
-       pg_atomic_uint32        nextClearXidElem;
-       TransactionId   backendLatestXid;
+       /* true, if member of ProcArray group waiting for XID clear */
+       bool                    procArrayGroupMember;
+       /* next ProcArray group member waiting for XID clear */
+       pg_atomic_uint32        procArrayGroupNext;
+       /*
+        * latest transaction id among the transaction's main XID and
+        * subtransactions
+        */
+       TransactionId   procArrayGroupMemberXid;
 
        /* Per-backend LWLock.  Protects fields below. */
        LWLock          backendLock;
@@ -217,7 +223,7 @@ typedef struct PROC_HDR
        /* Head of list of bgworker free PGPROC structures */
        PGPROC     *bgworkerFreeProcs;
        /* First pgproc waiting for group XID clear */
-       pg_atomic_uint32 firstClearXidElem;
+       pg_atomic_uint32 procArrayGroupFirst;
        /* WALWriter process's latch */
        Latch      *walwriterLatch;
        /* Checkpointer process's latch */