diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c index beb8f20708..61460fce60 100644 --- a/src/backend/access/heap/heapam_handler.c +++ b/src/backend/access/heap/heapam_handler.c @@ -2459,14 +2459,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 4c91e721d0..6261946196 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,7 +511,8 @@ 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]; @@ -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 @@ -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 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]; + 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,10 +1761,10 @@ 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]; + const PGPROC *proc = &allProcs[pgprocno]; int8 statusFlags = ProcGlobal->statusFlags[index]; TransactionId xid; TransactionId xmin; @@ -2163,21 +2182,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); @@ -2249,17 +2267,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]); @@ -2339,7 +2358,7 @@ GetSnapshotData(Snapshot snapshot) if (nsubxids > 0) { int pgprocno = pgprocnos[pgxactoff]; - PGPROC *proc = &allProcs[pgprocno]; + const PGPROC *proc = &allProcs[pgprocno]; pg_read_barrier(); /* pairs with GetNewTransactionId */ @@ -2527,21 +2546,26 @@ 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]; + const PGPROC *proc = &allProcs[pgprocno]; int statusFlags = ProcGlobal->statusFlags[index]; TransactionId xid; @@ -2673,6 +2697,7 @@ GetRunningTransactionData(void) TransactionId latestCompletedXid; TransactionId oldestRunningXid; TransactionId *xids; + int numProcs = arrayP->numProcs; int index; int count; int subcount; @@ -2722,7 +2747,7 @@ GetRunningTransactionData(void) /* * Spin over procArray collecting all xids */ - for (index = 0; index < arrayP->numProcs; index++) + for (index = 0; index < numProcs; index++) { TransactionId xid; @@ -2766,10 +2791,10 @@ 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]; + const PGPROC *proc = &allProcs[pgprocno]; int nsubxids; /* @@ -2839,9 +2864,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()); @@ -2861,7 +2887,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; @@ -2904,9 +2930,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)); @@ -2929,16 +2954,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 @@ -2954,12 +2979,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; @@ -3000,8 +3027,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; @@ -3011,10 +3039,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]; + const PGPROC *proc = &allProcs[pgprocno]; if (proc->delayChkpt) { @@ -3044,16 +3072,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]; + const PGPROC *proc = &allProcs[pgprocno]; VirtualTransactionId vxid; GET_VXID_FROM_PGPROC(vxid, *proc); @@ -3113,25 +3142,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; } /* @@ -3150,31 +3180,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]; + const PGPROC *proc = &allProcs[pgprocno]; if (other_xids[index] == xid) { - result = proc->pid; - break; + return proc->pid; } } - LWLockRelease(ProcArrayLock); - - return result; + return 0; } /* @@ -3221,7 +3249,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; @@ -3231,10 +3260,10 @@ 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]; + const PGPROC *proc = &allProcs[pgprocno]; uint8 statusFlags = ProcGlobal->statusFlags[index]; if (proc == MyProc) @@ -3246,7 +3275,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; @@ -3307,7 +3336,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; @@ -3328,10 +3358,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]; + const PGPROC *proc = &allProcs[pgprocno]; /* Exclude prepared transactions */ if (proc->pid == 0) @@ -3341,7 +3371,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 @@ -3387,13 +3417,14 @@ 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]; @@ -3435,8 +3466,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 */ @@ -3448,10 +3480,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]; + const PGPROC *proc = &allProcs[pgprocno]; /* * Since we're not holding a lock, need to be prepared to deal with @@ -3488,16 +3523,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]; + const PGPROC *proc = &allProcs[pgprocno]; if (proc->pid == 0) continue; /* do not count prepared xacts */ @@ -3518,16 +3554,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]; + const PGPROC *proc = &allProcs[pgprocno]; if (proc->pid == 0) continue; /* do not count prepared xacts */ @@ -3549,15 +3586,16 @@ 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]; + const int pgprocno = arrayP->pgprocnos[index]; PGPROC *proc = &allProcs[pgprocno]; if (databaseid == InvalidOid || proc->databaseId == databaseid) @@ -3589,16 +3627,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]; + const PGPROC *proc = &allProcs[pgprocno]; if (proc->pid == 0) continue; /* do not count prepared xacts */ @@ -3639,7 +3678,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]; @@ -3648,9 +3687,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(); @@ -3658,10 +3698,10 @@ 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]; + const PGPROC *proc = &allProcs[pgprocno]; uint8 statusFlags = ProcGlobal->statusFlags[index]; if (proc->databaseId != databaseId) @@ -3718,16 +3758,17 @@ void TerminateOtherDBBackends(Oid databaseId) { ProcArrayStruct *arrayP = procArray; - List *pids = NIL; + 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]; + const PGPROC *proc = &allProcs[pgprocno]; if (proc->databaseId != databaseId) continue; @@ -3769,7 +3810,7 @@ TerminateOtherDBBackends(Oid databaseId) foreach(lc, pids) { int pid = lfirst_int(lc); - PGPROC *proc = BackendPidGetProc(pid); + const PGPROC *proc = BackendPidGetProc(pid); if (proc != NULL) { @@ -3797,7 +3838,7 @@ TerminateOtherDBBackends(Oid databaseId) foreach(lc, pids) { int pid = lfirst_int(lc); - PGPROC *proc = BackendPidGetProc(pid); + const PGPROC *proc = BackendPidGetProc(pid); if (proc != NULL) {