From a455878d99561d4b199915ed7a7fb02f5e621710 Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Thu, 11 Feb 2016 08:55:24 -0500 Subject: [PATCH] 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 --- src/backend/storage/ipc/procarray.c | 28 ++++++++++++++-------------- src/backend/storage/lmgr/proc.c | 8 ++++---- src/include/storage/proc.h | 14 ++++++++++---- 3 files changed, 28 insertions(+), 22 deletions(-) diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c index 6ded0f0f12..91218d0e56 100644 --- 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 084be5a026..844222eec2 100644 --- 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 66ab255f4c..81bddbba63 100644 --- 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 */ -- 2.40.0