diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c index 1b8b640012..5b6f3d65f2 100644 --- a/src/backend/access/heap/heapam_handler.c +++ b/src/backend/access/heap/heapam_handler.c @@ -2460,14 +2460,15 @@ reform_and_rewrite_tuple(HeapTuple tuple, TupleDesc oldTupDesc = RelationGetDescr(OldHeap); TupleDesc newTupDesc = RelationGetDescr(NewHeap); HeapTuple copiedTuple; + int natts = newTupDesc->natts; int i; heap_deform_tuple(tuple, oldTupDesc, values, isnull); /* Be sure to null out any dropped columns */ - for (i = 0; i < newTupDesc->natts; i++) + for (i = 0; i < natts; i++) { - if (TupleDescAttr(newTupDesc, i)->attisdropped) + if (!isnull[i] && TupleDescAttr(newTupDesc, i)->attisdropped) isnull[i] = true; } diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c index 085bd1e407..0f0c5032c4 100644 --- a/src/backend/storage/ipc/procarray.c +++ b/src/backend/storage/ipc/procarray.c @@ -445,6 +445,7 @@ void ProcArrayAdd(PGPROC *proc) { ProcArrayStruct *arrayP = procArray; + int numProcs; int index; int movecount; @@ -473,7 +474,8 @@ ProcArrayAdd(PGPROC *proc) * Since the occurrence of adding/removing a proc is much lower than the * access to the ProcArray itself, the overhead should be marginal */ - for (index = 0; index < arrayP->numProcs; index++) + numProcs = arrayP->numProcs; + for (index = 0; index < numProcs; index++) { int procno PG_USED_FOR_ASSERTS_ONLY = arrayP->pgprocnos[index]; @@ -485,7 +487,7 @@ ProcArrayAdd(PGPROC *proc) break; } - movecount = arrayP->numProcs - index; + movecount = numProcs - index; memmove(&arrayP->pgprocnos[index + 1], &arrayP->pgprocnos[index], movecount * sizeof(*arrayP->pgprocnos)); @@ -509,9 +511,10 @@ ProcArrayAdd(PGPROC *proc) /* adjust pgxactoff for all following PGPROCs */ index++; - for (; index < arrayP->numProcs; index++) + numProcs = arrayP->numProcs; + for (; index < numProcs; index++) { - int procno = arrayP->pgprocnos[index]; + int procno = arrayP->pgprocnos[index]; Assert(procno >= 0 && procno < (arrayP->maxProcs + NUM_AUXILIARY_PROCS)); Assert(allProcs[procno].pgxactoff == index - 1); @@ -541,8 +544,10 @@ void ProcArrayRemove(PGPROC *proc, TransactionId latestXid) { ProcArrayStruct *arrayP = procArray; + int numProcs; int myoff; int movecount; + int index; #ifdef XIDCACHE_DEBUG /* dump stats at backend shutdown, but not prepared-xact end */ @@ -607,7 +612,8 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid) * Adjust pgxactoff of following procs for removed PGPROC (note that * numProcs already has been decremented). */ - for (int index = myoff; index < arrayP->numProcs; index++) + numProcs = arrayP->numProcs; + for (index = myoff; index < numProcs; index++) { int procno = arrayP->pgprocnos[index]; @@ -703,7 +709,7 @@ ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid) static inline void ProcArrayEndTransactionInternal(PGPROC *proc, TransactionId latestXid) { - size_t pgxactoff = proc->pgxactoff; + int pgxactoff = proc->pgxactoff; /* * Note: we need exclusive lock here because we're going to change other @@ -761,7 +767,7 @@ ProcArrayEndTransactionInternal(PGPROC *proc, TransactionId latestXid) static void ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid) { - PROC_HDR *procglobal = ProcGlobal; + const PROC_HDR *procglobal = ProcGlobal; uint32 nextidx; uint32 wakeidx; @@ -829,12 +835,12 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid) /* Walk the list and clear all XIDs. */ while (nextidx != INVALID_PGPROCNO) { - PGPROC *proc = &allProcs[nextidx]; + PGPROC *nextproc = &allProcs[nextidx]; - ProcArrayEndTransactionInternal(proc, proc->procArrayGroupMemberXid); + ProcArrayEndTransactionInternal(nextproc, nextproc->procArrayGroupMemberXid); /* Move to next proc in list. */ - nextidx = pg_atomic_read_u32(&proc->procArrayGroupNext); + nextidx = pg_atomic_read_u32(&nextproc->procArrayGroupNext); } /* We're done with the lock now. */ @@ -849,18 +855,18 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid) */ while (wakeidx != INVALID_PGPROCNO) { - PGPROC *proc = &allProcs[wakeidx]; + PGPROC *nextproc = &allProcs[wakeidx]; - wakeidx = pg_atomic_read_u32(&proc->procArrayGroupNext); - pg_atomic_write_u32(&proc->procArrayGroupNext, INVALID_PGPROCNO); + wakeidx = pg_atomic_read_u32(&nextproc->procArrayGroupNext); + pg_atomic_write_u32(&nextproc->procArrayGroupNext, INVALID_PGPROCNO); /* ensure all previous writes are visible before follower continues. */ pg_write_barrier(); - proc->procArrayGroupMember = false; + nextproc->procArrayGroupMember = false; - if (proc != MyProc) - PGSemaphoreUnlock(proc->sem); + if (nextproc != MyProc) + PGSemaphoreUnlock(nextproc->sem); } } @@ -875,7 +881,7 @@ ProcArrayGroupClearXid(PGPROC *proc, TransactionId latestXid) void ProcArrayClearTransaction(PGPROC *proc) { - size_t pgxactoff; + int pgxactoff; /* * Currently we need to lock ProcArrayLock exclusively here, as we @@ -1024,6 +1030,7 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running) { TransactionId *xids; int nxids; + int cnts; int i; Assert(standbyState >= STANDBY_INITIALIZED); @@ -1126,9 +1133,10 @@ ProcArrayApplyRecoveryInfo(RunningTransactions running) * Add to the temp array any xids which have not already completed. */ nxids = 0; - for (i = 0; i < running->xcnt + running->subxcnt; i++) + cnts = running->xcnt + running->subxcnt; + for (i = 0; i < cnts; i++) { - TransactionId xid = running->xids[i]; + const TransactionId xid = running->xids[i]; /* * The running-xacts snapshot can contain xids that were still visible @@ -1349,14 +1357,14 @@ TransactionIdIsInProgress(TransactionId xid) { static TransactionId *xids = NULL; static TransactionId *other_xids; - XidCacheStatus *other_subxidstates; - int nxids = 0; - ProcArrayStruct *arrayP = procArray; + const XidCacheStatus *other_subxidstates; + const ProcArrayStruct *arrayP = procArray; TransactionId topxid; TransactionId latestCompletedXid; + int nxids = 0; + int pgxactoff; int mypgxactoff; - size_t numProcs; - int j; + int numProcs; /* * Don't bother checking a transaction older than RecentXmin; it could not @@ -1432,12 +1440,13 @@ TransactionIdIsInProgress(TransactionId xid) /* No shortcuts, gotta grovel through the array */ mypgxactoff = MyProc->pgxactoff; numProcs = arrayP->numProcs; - for (size_t pgxactoff = 0; pgxactoff < numProcs; pgxactoff++) + for (pgxactoff = 0; pgxactoff < numProcs; pgxactoff++) { - int pgprocno; - PGPROC *proc; + const PGPROC *proc; TransactionId pxid; - int pxids; + int pxids; + int pgprocno; + int j; /* Ignore ourselves --- dealt with it above */ if (pgxactoff == mypgxactoff) @@ -1558,7 +1567,9 @@ TransactionIdIsInProgress(TransactionId xid) Assert(TransactionIdIsValid(topxid)); if (!TransactionIdEquals(topxid, xid)) { - for (int i = 0; i < nxids; i++) + int i; + + for (i = 0; i < nxids; i++) { if (TransactionIdEquals(xids[i], topxid)) return true; @@ -1579,10 +1590,11 @@ TransactionIdIsInProgress(TransactionId xid) bool TransactionIdIsActive(TransactionId xid) { - bool result = false; - ProcArrayStruct *arrayP = procArray; - TransactionId *other_xids = ProcGlobal->xids; + const ProcArrayStruct *arrayP; + const TransactionId *other_xids; + int numProcs; int i; + bool result; /* * Don't bother checking a transaction older than RecentXmin; it could not @@ -1591,12 +1603,17 @@ TransactionIdIsActive(TransactionId xid) if (TransactionIdPrecedes(xid, RecentXmin)) return false; + arrayP = procArray; + other_xids = ProcGlobal->xids; + numProcs = arrayP->numProcs; + result = false; + LWLockAcquire(ProcArrayLock, LW_SHARED); - for (i = 0; i < arrayP->numProcs; i++) + for (i = 0; i < numProcs; i++) { - int pgprocno = arrayP->pgprocnos[i]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = arrayP->pgprocnos[i]; + const PGPROC *proc = &allProcs[pgprocno]; TransactionId pxid; /* Fetch xid just once - see GetNewTransactionId */ @@ -1689,10 +1706,12 @@ TransactionIdIsActive(TransactionId xid) static void ComputeXidHorizons(ComputeXidHorizonsResult *h) { - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; TransactionId kaxmin; + const TransactionId *other_xids = ProcGlobal->xids; + int numProcs = arrayP->numProcs; + int index; bool in_recovery = RecoveryInProgress(); - TransactionId *other_xids = ProcGlobal->xids; LWLockAcquire(ProcArrayLock, LW_SHARED); @@ -1742,11 +1761,11 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h) h->slot_xmin = procArray->replication_slot_xmin; h->slot_catalog_xmin = procArray->replication_slot_catalog_xmin; - for (int index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; - int8 statusFlags = ProcGlobal->statusFlags[index]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; + int8 statusFlags = ProcGlobal->statusFlags[index]; TransactionId xid; TransactionId xmin; @@ -2162,21 +2181,20 @@ GetSnapshotDataReuse(Snapshot snapshot) Snapshot GetSnapshotData(Snapshot snapshot) { - ProcArrayStruct *arrayP = procArray; - TransactionId *other_xids = ProcGlobal->xids; + const ProcArrayStruct *arrayP = procArray; + const TransactionId *other_xids = ProcGlobal->xids; + FullTransactionId latest_completed; TransactionId xmin; TransactionId xmax; - size_t count = 0; - int subcount = 0; - bool suboverflowed = false; - FullTransactionId latest_completed; TransactionId oldestxid; - int mypgxactoff; TransactionId myxid; - uint64 curXactCompletionCount; - TransactionId replication_slot_xmin = InvalidTransactionId; TransactionId replication_slot_catalog_xmin = InvalidTransactionId; + uint64 curXactCompletionCount; + int mypgxactoff; + int count = 0; + int subcount = 0; + bool suboverflowed = false; Assert(snapshot != NULL); @@ -2248,17 +2266,18 @@ GetSnapshotData(Snapshot snapshot) if (!snapshot->takenDuringRecovery) { - size_t numProcs = arrayP->numProcs; TransactionId *xip = snapshot->xip; - int *pgprocnos = arrayP->pgprocnos; - XidCacheStatus *subxidStates = ProcGlobal->subxidStates; - uint8 *allStatusFlags = ProcGlobal->statusFlags; + const XidCacheStatus *subxidStates = ProcGlobal->subxidStates; + const uint8 *allStatusFlags = ProcGlobal->statusFlags; + const int *pgprocnos = arrayP->pgprocnos; + int numProcs = arrayP->numProcs; + int pgxactoff; /* * First collect set of pgxactoff/xids that need to be included in the * snapshot. */ - for (size_t pgxactoff = 0; pgxactoff < numProcs; pgxactoff++) + for (pgxactoff = 0; pgxactoff < numProcs; pgxactoff++) { /* Fetch xid just once - see GetNewTransactionId */ TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]); @@ -2328,7 +2347,6 @@ GetSnapshotData(Snapshot snapshot) */ if (!suboverflowed) { - if (subxidStates[pgxactoff].overflowed) suboverflowed = true; else @@ -2337,8 +2355,8 @@ GetSnapshotData(Snapshot snapshot) if (nsubxids > 0) { - int pgprocno = pgprocnos[pgxactoff]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = pgprocnos[pgxactoff]; + const PGPROC *proc = &allProcs[pgprocno]; pg_read_barrier(); /* pairs with GetNewTransactionId */ @@ -2526,22 +2544,27 @@ bool ProcArrayInstallImportedXmin(TransactionId xmin, VirtualTransactionId *sourcevxid) { - bool result = false; - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP; + int numProcs; int index; + bool result; Assert(TransactionIdIsNormal(xmin)); if (!sourcevxid) return false; + arrayP = procArray; + numProcs = arrayP->numProcs; + result = false; + /* Get lock so source xact can't end while we're doing this */ LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; - int statusFlags = ProcGlobal->statusFlags[index]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; + int statusFlags = ProcGlobal->statusFlags[index]; TransactionId xid; /* Ignore procs running LAZY VACUUM */ @@ -2600,8 +2623,8 @@ ProcArrayInstallImportedXmin(TransactionId xmin, bool ProcArrayInstallRestoredXmin(TransactionId xmin, PGPROC *proc) { - bool result = false; TransactionId xid; + bool result = false; Assert(TransactionIdIsNormal(xmin)); Assert(proc != NULL); @@ -2672,6 +2695,7 @@ GetRunningTransactionData(void) TransactionId latestCompletedXid; TransactionId oldestRunningXid; TransactionId *xids; + int numProcs = arrayP->numProcs; int index; int count; int subcount; @@ -2721,7 +2745,7 @@ GetRunningTransactionData(void) /* * Spin over procArray collecting all xids */ - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { TransactionId xid; @@ -2765,11 +2789,11 @@ GetRunningTransactionData(void) { XidCacheStatus *other_subxidstates = ProcGlobal->subxidStates; - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; - int nsubxids; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; + int nsubxids; /* * Save subtransaction XIDs. Other backends can't add or remove @@ -2838,9 +2862,10 @@ GetRunningTransactionData(void) TransactionId GetOldestActiveTransactionId(void) { - ProcArrayStruct *arrayP = procArray; - TransactionId *other_xids = ProcGlobal->xids; + const ProcArrayStruct *arrayP = procArray; + const TransactionId *other_xids = ProcGlobal->xids; TransactionId oldestRunningXid; + int numProcs = arrayP->numProcs; int index; Assert(!RecoveryInProgress()); @@ -2860,7 +2885,7 @@ GetOldestActiveTransactionId(void) * Spin over procArray collecting all xids and subxids. */ LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { TransactionId xid; @@ -2903,9 +2928,8 @@ GetOldestActiveTransactionId(void) TransactionId GetOldestSafeDecodingTransactionId(bool catalogOnly) { - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; TransactionId oldestSafeXid; - int index; bool recovery_in_progress = RecoveryInProgress(); Assert(LWLockHeldByMe(ProcArrayLock)); @@ -2928,16 +2952,16 @@ GetOldestSafeDecodingTransactionId(bool catalogOnly) * slot's general xmin horizon, but the catalog horizon is only usable * when only catalog data is going to be looked at. */ - if (TransactionIdIsValid(procArray->replication_slot_xmin) && - TransactionIdPrecedes(procArray->replication_slot_xmin, + if (TransactionIdIsValid(arrayP->replication_slot_xmin) && + TransactionIdPrecedes(arrayP->replication_slot_xmin, oldestSafeXid)) - oldestSafeXid = procArray->replication_slot_xmin; + oldestSafeXid = arrayP->replication_slot_xmin; if (catalogOnly && - TransactionIdIsValid(procArray->replication_slot_catalog_xmin) && - TransactionIdPrecedes(procArray->replication_slot_catalog_xmin, + TransactionIdIsValid(arrayP->replication_slot_catalog_xmin) && + TransactionIdPrecedes(arrayP->replication_slot_catalog_xmin, oldestSafeXid)) - oldestSafeXid = procArray->replication_slot_catalog_xmin; + oldestSafeXid = arrayP->replication_slot_catalog_xmin; /* * If we're not in recovery, we walk over the procarray and collect the @@ -2953,12 +2977,14 @@ GetOldestSafeDecodingTransactionId(bool catalogOnly) */ if (!recovery_in_progress) { - TransactionId *other_xids = ProcGlobal->xids; + const TransactionId *other_xids = ProcGlobal->xids; + int numProcs = arrayP->numProcs; + int index; /* * Spin over procArray collecting min(ProcGlobal->xids[i]) */ - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { TransactionId xid; @@ -2999,8 +3025,9 @@ GetOldestSafeDecodingTransactionId(bool catalogOnly) VirtualTransactionId * GetVirtualXIDsDelayingChkpt(int *nvxids) { + const ProcArrayStruct *arrayP = procArray; VirtualTransactionId *vxids; - ProcArrayStruct *arrayP = procArray; + int numProcs = arrayP->numProcs; int count = 0; int index; @@ -3010,10 +3037,10 @@ GetVirtualXIDsDelayingChkpt(int *nvxids) LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; if (proc->delayChkpt) { @@ -3043,16 +3070,17 @@ GetVirtualXIDsDelayingChkpt(int *nvxids) bool HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids) { - bool result = false; - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; + int numProcs = arrayP->numProcs; int index; + bool result = false; LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; VirtualTransactionId vxid; GET_VXID_FROM_PGPROC(vxid, *proc); @@ -3089,7 +3117,7 @@ HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids) PGPROC * BackendPidGetProc(int pid) { - PGPROC *result; + const PGPROC *result; if (pid == 0) /* never match dummy PGPROCs */ return NULL; @@ -3112,25 +3140,26 @@ BackendPidGetProc(int pid) PGPROC * BackendPidGetProcWithLock(int pid) { - PGPROC *result = NULL; - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP; + int numProcs; int index; if (pid == 0) /* never match dummy PGPROCs */ return NULL; - for (index = 0; index < arrayP->numProcs; index++) + arrayP = procArray; + numProcs = arrayP->numProcs; + for (index = 0; index < numProcs; index++) { - PGPROC *proc = &allProcs[arrayP->pgprocnos[index]]; + const PGPROC *proc = &allProcs[arrayP->pgprocnos[index]]; if (proc->pid == pid) { - result = proc; - break; + return proc; } } - return result; + return NULL; } /* @@ -3149,31 +3178,29 @@ BackendPidGetProcWithLock(int pid) int BackendXidGetPid(TransactionId xid) { - int result = 0; - ProcArrayStruct *arrayP = procArray; - TransactionId *other_xids = ProcGlobal->xids; + const ProcArrayStruct *arrayP; + const TransactionId *other_xids; + int numProcs; int index; if (xid == InvalidTransactionId) /* never match invalid xid */ return 0; - LWLockAcquire(ProcArrayLock, LW_SHARED); - - for (index = 0; index < arrayP->numProcs; index++) + arrayP = procArray; + other_xids = ProcGlobal->xids; + numProcs = arrayP->numProcs; + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; if (other_xids[index] == xid) { - result = proc->pid; - break; + return proc->pid; } } - LWLockRelease(ProcArrayLock); - - return result; + return 0; } /* @@ -3220,7 +3247,8 @@ GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0, int *nvxids) { VirtualTransactionId *vxids; - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; + int numProcs = arrayP->numProcs; int count = 0; int index; @@ -3230,11 +3258,11 @@ GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0, LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; - uint8 statusFlags = ProcGlobal->statusFlags[index]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; + uint8 statusFlags = ProcGlobal->statusFlags[index]; if (proc == MyProc) continue; @@ -3245,7 +3273,7 @@ GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0, if (allDbs || proc->databaseId == MyDatabaseId) { /* Fetch xmin just once - might change on us */ - TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin); + const TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin); if (excludeXmin0 && !TransactionIdIsValid(pxmin)) continue; @@ -3306,7 +3334,8 @@ VirtualTransactionId * GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid) { static VirtualTransactionId *vxids; - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; + int numProcs = arrayP->numProcs; int count = 0; int index; @@ -3327,10 +3356,10 @@ GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid) LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; /* Exclude prepared transactions */ if (proc->pid == 0) @@ -3340,7 +3369,7 @@ GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid) proc->databaseId == dbOid) { /* Fetch xmin just once - can't change on us, but good coding */ - TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin); + const TransactionId pxmin = UINT32_ACCESS_ONCE(proc->xmin); /* * We ignore an invalid pxmin because this means that backend has @@ -3386,16 +3415,17 @@ pid_t SignalVirtualTransaction(VirtualTransactionId vxid, ProcSignalReason sigmode, bool conflictPending) { - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; + int numProcs = arrayP->numProcs; int index; pid_t pid = 0; LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; + PGPROC *proc = &allProcs[pgprocno]; VirtualTransactionId procvxid; GET_VXID_FROM_PGPROC(procvxid, *proc); @@ -3434,8 +3464,9 @@ SignalVirtualTransaction(VirtualTransactionId vxid, ProcSignalReason sigmode, bool MinimumActiveBackends(int min) { - ProcArrayStruct *arrayP = procArray; - int count = 0; + ProcArrayStruct *arrayP; + int count; + int numProcs; int index; /* Quick short-circuit if no minimum is specified */ @@ -3447,10 +3478,13 @@ MinimumActiveBackends(int min) * bogus, but since we are only testing fields for zero or nonzero, it * should be OK. The result is only used for heuristic purposes anyway... */ - for (index = 0; index < arrayP->numProcs; index++) + count = 0; + arrayP = procArray; + numProcs = arrayP->numProcs; + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; /* * Since we're not holding a lock, need to be prepared to deal with @@ -3487,16 +3521,17 @@ MinimumActiveBackends(int min) int CountDBBackends(Oid databaseid) { - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; + int numProcs = arrayP->numProcs; int count = 0; int index; LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; if (proc->pid == 0) continue; /* do not count prepared xacts */ @@ -3517,16 +3552,17 @@ CountDBBackends(Oid databaseid) int CountDBConnections(Oid databaseid) { - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; + int numProcs = arrayP->numProcs; int count = 0; int index; LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; if (proc->pid == 0) continue; /* do not count prepared xacts */ @@ -3548,16 +3584,17 @@ CountDBConnections(Oid databaseid) void CancelDBBackends(Oid databaseid, ProcSignalReason sigmode, bool conflictPending) { - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; + int numProcs = arrayP->numProcs; int index; /* tell all backends to die */ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; + const int pgprocno = arrayP->pgprocnos[index]; + PGPROC *proc = &allProcs[pgprocno]; if (databaseid == InvalidOid || proc->databaseId == databaseid) { @@ -3588,16 +3625,17 @@ CancelDBBackends(Oid databaseid, ProcSignalReason sigmode, bool conflictPending) int CountUserBackends(Oid roleid) { - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; + int numProcs = arrayP->numProcs; int count = 0; int index; LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; if (proc->pid == 0) continue; /* do not count prepared xacts */ @@ -3638,7 +3676,7 @@ CountUserBackends(Oid roleid) bool CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared) { - ProcArrayStruct *arrayP = procArray; + const ProcArrayStruct *arrayP = procArray; #define MAXAUTOVACPIDS 10 /* max autovacs to SIGTERM per iteration */ int autovac_pids[MAXAUTOVACPIDS]; @@ -3647,9 +3685,10 @@ CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared) /* 50 tries with 100ms sleep between tries makes 5 sec total wait */ for (tries = 0; tries < 50; tries++) { + int numProcs = arrayP->numProcs; + int index; int nautovacs = 0; bool found = false; - int index; CHECK_FOR_INTERRUPTS(); @@ -3657,11 +3696,11 @@ CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared) LWLockAcquire(ProcArrayLock, LW_SHARED); - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { - int pgprocno = arrayP->pgprocnos[index]; - PGPROC *proc = &allProcs[pgprocno]; - uint8 statusFlags = ProcGlobal->statusFlags[index]; + int pgprocno = arrayP->pgprocnos[index]; + const PGPROC *proc = &allProcs[pgprocno]; + uint8 statusFlags = ProcGlobal->statusFlags[index]; if (proc->databaseId != databaseId) continue; @@ -3716,17 +3755,18 @@ CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared) void TerminateOtherDBBackends(Oid databaseId) { - ProcArrayStruct *arrayP = procArray; - List *pids = NIL; + const ProcArrayStruct *arrayP = procArray; + const List *pids = NIL; + int numProcs = procArray->numProcs; int nprepared = 0; int i; LWLockAcquire(ProcArrayLock, LW_SHARED); - for (i = 0; i < procArray->numProcs; i++) + for (i = 0; i < numProcs; i++) { - int pgprocno = arrayP->pgprocnos[i]; - PGPROC *proc = &allProcs[pgprocno]; + int pgprocno = arrayP->pgprocnos[i]; + const PGPROC *proc = &allProcs[pgprocno]; if (proc->databaseId != databaseId) continue; @@ -3767,8 +3807,8 @@ TerminateOtherDBBackends(Oid databaseId) */ foreach(lc, pids) { - int pid = lfirst_int(lc); - PGPROC *proc = BackendPidGetProc(pid); + int pid = lfirst_int(lc); + const PGPROC *proc = BackendPidGetProc(pid); if (proc != NULL) { @@ -3795,8 +3835,8 @@ TerminateOtherDBBackends(Oid databaseId) */ foreach(lc, pids) { - int pid = lfirst_int(lc); - PGPROC *proc = BackendPidGetProc(pid); + int pid = lfirst_int(lc); + const PGPROC *proc = BackendPidGetProc(pid); if (proc != NULL) {