From 07c4705a22e6cdd5717df46a974ce00a69fc901f Mon Sep 17 00:00:00 2001 From: Dmitrii Dolgov <9erthalion6@gmail.com> Date: Wed, 11 Nov 2020 15:19:48 +0100 Subject: [PATCH v4 1/2] Rename vaccumFlags to statusFlags With more flags associated to a PGPROC entry that are not related to vacuum (currently existing or planned), the name "statusFlags" describes its purpose better. --- src/backend/access/transam/twophase.c | 2 +- src/backend/commands/vacuum.c | 6 +-- src/backend/postmaster/autovacuum.c | 6 +-- src/backend/replication/logical/logical.c | 4 +- src/backend/replication/slot.c | 4 +- src/backend/storage/ipc/procarray.c | 54 +++++++++++------------ src/backend/storage/lmgr/deadlock.c | 4 +- src/backend/storage/lmgr/proc.c | 20 ++++----- src/include/storage/proc.h | 12 ++--- 9 files changed, 56 insertions(+), 56 deletions(-) diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c index 7940060443..873bf9bad9 100644 --- a/src/backend/access/transam/twophase.c +++ b/src/backend/access/transam/twophase.c @@ -464,7 +464,7 @@ MarkAsPreparingGuts(GlobalTransaction gxact, TransactionId xid, const char *gid, proc->xid = xid; Assert(proc->xmin == InvalidTransactionId); proc->delayChkpt = false; - proc->vacuumFlags = 0; + proc->statusFlags = 0; proc->pid = 0; proc->backendId = InvalidBackendId; proc->databaseId = databaseid; diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index 1b6717f727..d89ba3031f 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -1742,10 +1742,10 @@ vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params) * might appear to go backwards, which is probably Not Good. */ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); - MyProc->vacuumFlags |= PROC_IN_VACUUM; + MyProc->statusFlags |= PROC_IN_VACUUM; if (params->is_wraparound) - MyProc->vacuumFlags |= PROC_VACUUM_FOR_WRAPAROUND; - ProcGlobal->vacuumFlags[MyProc->pgxactoff] = MyProc->vacuumFlags; + MyProc->statusFlags |= PROC_VACUUM_FOR_WRAPAROUND; + ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags; LWLockRelease(ProcArrayLock); } diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 2cef56f115..aa5b97fbac 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -2509,7 +2509,7 @@ do_autovacuum(void) tab->at_datname, tab->at_nspname, tab->at_relname); EmitErrorReport(); - /* this resets ProcGlobal->vacuumFlags[i] too */ + /* this resets ProcGlobal->statusFlags[i] too */ AbortOutOfAnyTransaction(); FlushErrorState(); MemoryContextResetAndDeleteChildren(PortalContext); @@ -2525,7 +2525,7 @@ do_autovacuum(void) did_vacuum = true; - /* ProcGlobal->vacuumFlags[i] are reset at the next end of xact */ + /* ProcGlobal->statusFlags[i] are reset at the next end of xact */ /* be tidy */ deleted: @@ -2702,7 +2702,7 @@ perform_work_item(AutoVacuumWorkItem *workitem) cur_datname, cur_nspname, cur_relname); EmitErrorReport(); - /* this resets ProcGlobal->vacuumFlags[i] too */ + /* this resets ProcGlobal->statusFlags[i] too */ AbortOutOfAnyTransaction(); FlushErrorState(); MemoryContextResetAndDeleteChildren(PortalContext); diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c index d5cfbeaa4a..f1f4df7d70 100644 --- a/src/backend/replication/logical/logical.c +++ b/src/backend/replication/logical/logical.c @@ -182,8 +182,8 @@ StartupDecodingContext(List *output_plugin_options, if (!IsTransactionOrTransactionBlock()) { LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); - MyProc->vacuumFlags |= PROC_IN_LOGICAL_DECODING; - ProcGlobal->vacuumFlags[MyProc->pgxactoff] = MyProc->vacuumFlags; + MyProc->statusFlags |= PROC_IN_LOGICAL_DECODING; + ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags; LWLockRelease(ProcArrayLock); } diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c index 09be1d8c48..5ed955ba0b 100644 --- a/src/backend/replication/slot.c +++ b/src/backend/replication/slot.c @@ -528,8 +528,8 @@ ReplicationSlotRelease(void) /* might not have been set when we've been a plain slot */ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); - MyProc->vacuumFlags &= ~PROC_IN_LOGICAL_DECODING; - ProcGlobal->vacuumFlags[MyProc->pgxactoff] = MyProc->vacuumFlags; + MyProc->statusFlags &= ~PROC_IN_LOGICAL_DECODING; + ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags; LWLockRelease(ProcArrayLock); } diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c index 05661e379e..3a28da0e80 100644 --- a/src/backend/storage/ipc/procarray.c +++ b/src/backend/storage/ipc/procarray.c @@ -488,13 +488,13 @@ ProcArrayAdd(PGPROC *proc) (arrayP->numProcs - index) * sizeof(*ProcGlobal->xids)); memmove(&ProcGlobal->subxidStates[index + 1], &ProcGlobal->subxidStates[index], (arrayP->numProcs - index) * sizeof(*ProcGlobal->subxidStates)); - memmove(&ProcGlobal->vacuumFlags[index + 1], &ProcGlobal->vacuumFlags[index], - (arrayP->numProcs - index) * sizeof(*ProcGlobal->vacuumFlags)); + memmove(&ProcGlobal->statusFlags[index + 1], &ProcGlobal->statusFlags[index], + (arrayP->numProcs - index) * sizeof(*ProcGlobal->statusFlags)); arrayP->pgprocnos[index] = proc->pgprocno; ProcGlobal->xids[index] = proc->xid; ProcGlobal->subxidStates[index] = proc->subxidStatus; - ProcGlobal->vacuumFlags[index] = proc->vacuumFlags; + ProcGlobal->statusFlags[index] = proc->statusFlags; arrayP->numProcs++; @@ -562,7 +562,7 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid) Assert(TransactionIdIsValid(ProcGlobal->xids[proc->pgxactoff] == 0)); Assert(TransactionIdIsValid(ProcGlobal->subxidStates[proc->pgxactoff].count == 0)); Assert(TransactionIdIsValid(ProcGlobal->subxidStates[proc->pgxactoff].overflowed == false)); - ProcGlobal->vacuumFlags[proc->pgxactoff] = 0; + ProcGlobal->statusFlags[proc->pgxactoff] = 0; for (index = 0; index < arrayP->numProcs; index++) { @@ -575,8 +575,8 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid) (arrayP->numProcs - index - 1) * sizeof(*ProcGlobal->xids)); memmove(&ProcGlobal->subxidStates[index], &ProcGlobal->subxidStates[index + 1], (arrayP->numProcs - index - 1) * sizeof(*ProcGlobal->subxidStates)); - memmove(&ProcGlobal->vacuumFlags[index], &ProcGlobal->vacuumFlags[index + 1], - (arrayP->numProcs - index - 1) * sizeof(*ProcGlobal->vacuumFlags)); + memmove(&ProcGlobal->statusFlags[index], &ProcGlobal->statusFlags[index + 1], + (arrayP->numProcs - index - 1) * sizeof(*ProcGlobal->statusFlags)); arrayP->pgprocnos[arrayP->numProcs - 1] = -1; /* for debugging */ arrayP->numProcs--; @@ -660,13 +660,13 @@ ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid) /* must be cleared with xid/xmin: */ /* avoid unnecessarily dirtying shared cachelines */ - if (proc->vacuumFlags & PROC_VACUUM_STATE_MASK) + if (proc->statusFlags & PROC_VACUUM_STATE_MASK) { Assert(!LWLockHeldByMe(ProcArrayLock)); LWLockAcquire(ProcArrayLock, LW_SHARED); - Assert(proc->vacuumFlags == ProcGlobal->vacuumFlags[proc->pgxactoff]); - proc->vacuumFlags &= ~PROC_VACUUM_STATE_MASK; - ProcGlobal->vacuumFlags[proc->pgxactoff] = proc->vacuumFlags; + Assert(proc->statusFlags == ProcGlobal->statusFlags[proc->pgxactoff]); + proc->statusFlags &= ~PROC_VACUUM_STATE_MASK; + ProcGlobal->statusFlags[proc->pgxactoff] = proc->statusFlags; LWLockRelease(ProcArrayLock); } } @@ -695,10 +695,10 @@ ProcArrayEndTransactionInternal(PGPROC *proc, TransactionId latestXid) /* must be cleared with xid/xmin: */ /* avoid unnecessarily dirtying shared cachelines */ - if (proc->vacuumFlags & PROC_VACUUM_STATE_MASK) + if (proc->statusFlags & PROC_VACUUM_STATE_MASK) { - proc->vacuumFlags &= ~PROC_VACUUM_STATE_MASK; - ProcGlobal->vacuumFlags[proc->pgxactoff] = proc->vacuumFlags; + proc->statusFlags &= ~PROC_VACUUM_STATE_MASK; + ProcGlobal->statusFlags[proc->pgxactoff] = proc->statusFlags; } /* Clear the subtransaction-XID cache too while holding the lock */ @@ -875,7 +875,7 @@ ProcArrayClearTransaction(PGPROC *proc) proc->xmin = InvalidTransactionId; proc->recoveryConflictPending = false; - Assert(!(proc->vacuumFlags & PROC_VACUUM_STATE_MASK)); + Assert(!(proc->statusFlags & PROC_VACUUM_STATE_MASK)); Assert(!proc->delayChkpt); /* @@ -1710,7 +1710,7 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h) { int pgprocno = arrayP->pgprocnos[index]; PGPROC *proc = &allProcs[pgprocno]; - int8 vacuumFlags = ProcGlobal->vacuumFlags[index]; + int8 statusFlags = ProcGlobal->statusFlags[index]; TransactionId xid; TransactionId xmin; @@ -1745,7 +1745,7 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h) * removed, as long as pg_subtrans is not truncated) or doing logical * decoding (which manages xmin separately, check below). */ - if (vacuumFlags & (PROC_IN_VACUUM | PROC_IN_LOGICAL_DECODING)) + if (statusFlags & (PROC_IN_VACUUM | PROC_IN_LOGICAL_DECODING)) continue; /* shared tables need to take backends in all database into account */ @@ -2194,7 +2194,7 @@ GetSnapshotData(Snapshot snapshot) TransactionId *xip = snapshot->xip; int *pgprocnos = arrayP->pgprocnos; XidCacheStatus *subxidStates = ProcGlobal->subxidStates; - uint8 *allVacuumFlags = ProcGlobal->vacuumFlags; + uint8 *allStatusFlags = ProcGlobal->statusFlags; /* * First collect set of pgxactoff/xids that need to be included in the @@ -2204,7 +2204,7 @@ GetSnapshotData(Snapshot snapshot) { /* Fetch xid just once - see GetNewTransactionId */ TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]); - uint8 vacuumFlags; + uint8 statusFlags; Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff); @@ -2243,8 +2243,8 @@ GetSnapshotData(Snapshot snapshot) * Skip over backends doing logical decoding which manages xmin * separately (check below) and ones running LAZY VACUUM. */ - vacuumFlags = allVacuumFlags[pgxactoff]; - if (vacuumFlags & (PROC_IN_LOGICAL_DECODING | PROC_IN_VACUUM)) + statusFlags = allStatusFlags[pgxactoff]; + if (statusFlags & (PROC_IN_LOGICAL_DECODING | PROC_IN_VACUUM)) continue; if (NormalTransactionIdPrecedes(xid, xmin)) @@ -2483,11 +2483,11 @@ ProcArrayInstallImportedXmin(TransactionId xmin, { int pgprocno = arrayP->pgprocnos[index]; PGPROC *proc = &allProcs[pgprocno]; - int vacuumFlags = ProcGlobal->vacuumFlags[index]; + int statusFlags = ProcGlobal->statusFlags[index]; TransactionId xid; /* Ignore procs running LAZY VACUUM */ - if (vacuumFlags & PROC_IN_VACUUM) + if (statusFlags & PROC_IN_VACUUM) continue; /* We are only interested in the specific virtual transaction. */ @@ -3142,7 +3142,7 @@ IsBackendPid(int pid) * If excludeXmin0 is true, skip processes with xmin = 0. * If allDbs is false, skip processes attached to other databases. * If excludeVacuum isn't zero, skip processes for which - * (vacuumFlags & excludeVacuum) is not zero. + * (statusFlags & excludeVacuum) is not zero. * * Note: the purpose of the limitXmin and excludeXmin0 parameters is to * allow skipping backends whose oldest live snapshot is no older than @@ -3176,12 +3176,12 @@ GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0, { int pgprocno = arrayP->pgprocnos[index]; PGPROC *proc = &allProcs[pgprocno]; - uint8 vacuumFlags = ProcGlobal->vacuumFlags[index]; + uint8 statusFlags = ProcGlobal->statusFlags[index]; if (proc == MyProc) continue; - if (excludeVacuum & vacuumFlags) + if (excludeVacuum & statusFlags) continue; if (allDbs || proc->databaseId == MyDatabaseId) @@ -3596,7 +3596,7 @@ CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared) { int pgprocno = arrayP->pgprocnos[index]; PGPROC *proc = &allProcs[pgprocno]; - uint8 vacuumFlags = ProcGlobal->vacuumFlags[index]; + uint8 statusFlags = ProcGlobal->statusFlags[index]; if (proc->databaseId != databaseId) continue; @@ -3610,7 +3610,7 @@ CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared) else { (*nbackends)++; - if ((vacuumFlags & PROC_IS_AUTOVACUUM) && + if ((statusFlags & PROC_IS_AUTOVACUUM) && nautovacs < MAXAUTOVACPIDS) autovac_pids[nautovacs++] = proc->pid; } diff --git a/src/backend/storage/lmgr/deadlock.c b/src/backend/storage/lmgr/deadlock.c index e1246b8a4d..cb7a8f0fd2 100644 --- a/src/backend/storage/lmgr/deadlock.c +++ b/src/backend/storage/lmgr/deadlock.c @@ -618,7 +618,7 @@ FindLockCycleRecurseMember(PGPROC *checkProc, * that an autovacuum won't be canceled with less than * deadlock_timeout grace period. * - * Note we read vacuumFlags without any locking. This is + * Note we read statusFlags without any locking. This is * OK only for checking the PROC_IS_AUTOVACUUM flag, * because that flag is set at process start and never * reset. There is logic elsewhere to avoid canceling an @@ -628,7 +628,7 @@ FindLockCycleRecurseMember(PGPROC *checkProc, * ProcArrayLock. */ if (checkProc == MyProc && - proc->vacuumFlags & PROC_IS_AUTOVACUUM) + proc->statusFlags & PROC_IS_AUTOVACUUM) blocking_autovacuum_proc = proc; /* We're done looking at this proclock */ diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c index 88566bd9fa..d1738c65f5 100644 --- a/src/backend/storage/lmgr/proc.c +++ b/src/backend/storage/lmgr/proc.c @@ -111,7 +111,7 @@ ProcGlobalShmemSize(void) size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->xids))); size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->subxidStates))); - size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->vacuumFlags))); + size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->statusFlags))); return size; } @@ -210,8 +210,8 @@ InitProcGlobal(void) MemSet(ProcGlobal->xids, 0, TotalProcs * sizeof(*ProcGlobal->xids)); ProcGlobal->subxidStates = (XidCacheStatus *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->subxidStates)); MemSet(ProcGlobal->subxidStates, 0, TotalProcs * sizeof(*ProcGlobal->subxidStates)); - ProcGlobal->vacuumFlags = (uint8 *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->vacuumFlags)); - MemSet(ProcGlobal->vacuumFlags, 0, TotalProcs * sizeof(*ProcGlobal->vacuumFlags)); + ProcGlobal->statusFlags = (uint8 *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->statusFlags)); + MemSet(ProcGlobal->statusFlags, 0, TotalProcs * sizeof(*ProcGlobal->statusFlags)); for (i = 0; i < TotalProcs; i++) { @@ -393,10 +393,10 @@ InitProcess(void) MyProc->tempNamespaceId = InvalidOid; MyProc->isBackgroundWorker = IsBackgroundWorker; MyProc->delayChkpt = false; - MyProc->vacuumFlags = 0; + MyProc->statusFlags = 0; /* NB -- autovac launcher intentionally does not set IS_AUTOVACUUM */ if (IsAutoVacuumWorkerProcess()) - MyProc->vacuumFlags |= PROC_IS_AUTOVACUUM; + MyProc->statusFlags |= PROC_IS_AUTOVACUUM; MyProc->lwWaiting = false; MyProc->lwWaitMode = 0; MyProc->waitLock = NULL; @@ -574,7 +574,7 @@ InitAuxiliaryProcess(void) MyProc->tempNamespaceId = InvalidOid; MyProc->isBackgroundWorker = IsBackgroundWorker; MyProc->delayChkpt = false; - MyProc->vacuumFlags = 0; + MyProc->statusFlags = 0; MyProc->lwWaiting = false; MyProc->lwWaitMode = 0; MyProc->waitLock = NULL; @@ -1310,7 +1310,7 @@ ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable) if (deadlock_state == DS_BLOCKED_BY_AUTOVACUUM && allow_autovacuum_cancel) { PGPROC *autovac = GetBlockingAutoVacuumPgproc(); - uint8 vacuumFlags; + uint8 statusFlags; LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); @@ -1318,9 +1318,9 @@ ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable) * Only do it if the worker is not working to protect against Xid * wraparound. */ - vacuumFlags = ProcGlobal->vacuumFlags[autovac->pgxactoff]; - if ((vacuumFlags & PROC_IS_AUTOVACUUM) && - !(vacuumFlags & PROC_VACUUM_FOR_WRAPAROUND)) + statusFlags = ProcGlobal->statusFlags[autovac->pgxactoff]; + if ((statusFlags & PROC_IS_AUTOVACUUM) && + !(statusFlags & PROC_VACUUM_FOR_WRAPAROUND)) { int pid = autovac->pid; StringInfoData locktagbuf; diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h index 9c9a50ae45..63aea0e253 100644 --- a/src/include/storage/proc.h +++ b/src/include/storage/proc.h @@ -49,7 +49,7 @@ struct XidCache }; /* - * Flags for ProcGlobal->vacuumFlags[] + * Flags for ProcGlobal->statusFlags[] */ #define PROC_IS_AUTOVACUUM 0x01 /* is it an autovac worker? */ #define PROC_IN_VACUUM 0x02 /* currently running lazy vacuum */ @@ -175,9 +175,9 @@ struct PGPROC bool delayChkpt; /* true if this proc delays checkpoint start */ - uint8 vacuumFlags; /* this backend's vacuum flags, see PROC_* + uint8 statusFlags; /* this backend's status flags, see PROC_* * above. mirrored in - * ProcGlobal->vacuumFlags[pgxactoff] */ + * ProcGlobal->statusFlags[pgxactoff] */ /* * Info to allow us to wait for synchronous replication, if needed. * waitLSN is InvalidXLogRecPtr if not waiting; set only by user backend. @@ -273,7 +273,7 @@ extern PGDLLIMPORT PGPROC *MyProc; * allow for as tight loops accessing the data as possible. Second, to prevent * updates of frequently changing data (e.g. xmin) from invalidating * cachelines also containing less frequently changing data (e.g. xid, - * vacuumFlags). Third to condense frequently accessed data into as few + * statusFlags). Third to condense frequently accessed data into as few * cachelines as possible. * * There are two main reasons to have the data mirrored between these dense @@ -315,10 +315,10 @@ typedef struct PROC_HDR XidCacheStatus *subxidStates; /* - * Array mirroring PGPROC.vacuumFlags for each PGPROC currently in the + * Array mirroring PGPROC.statusFlags for each PGPROC currently in the * procarray. */ - uint8 *vacuumFlags; + uint8 *statusFlags; /* Length of allProcs array */ uint32 allProcCount; -- 2.21.0