From 6ba4ecbf477e0b25dd7bde1b0c4e07fc2da19348 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Mon, 22 Sep 2014 23:35:08 +0200 Subject: [PATCH] Remove most volatile qualifiers from xlog.c For the reason outlined in df4077cda2e also remove volatile qualifiers from xlog.c. Some of these uses of volatile have been added after noticing problems back when spinlocks didn't imply compiler barriers. So they are a good test - in fact removing the volatiles breaks when done without the barriers in spinlocks present. Several uses of volatile remain where they are explicitly used to access shared memory without locks. These locations are ok with slightly out of date data, but removing the volatile might lead to the variables never being reread from memory. These uses could also be replaced by barriers, but that's a separate change of doubtful value. --- src/backend/access/transam/xlog.c | 470 +++++++++++------------------- 1 file changed, 173 insertions(+), 297 deletions(-) diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index 544d76e852..46eef5f21b 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -1220,16 +1220,13 @@ begin:; */ if (StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); /* advance global request to include new block(s) */ - if (xlogctl->LogwrtRqst.Write < EndPos) - xlogctl->LogwrtRqst.Write = EndPos; + if (XLogCtl->LogwrtRqst.Write < EndPos) + XLogCtl->LogwrtRqst.Write = EndPos; /* update local result copy while I have the chance */ - LogwrtResult = xlogctl->LogwrtResult; - SpinLockRelease(&xlogctl->info_lck); + LogwrtResult = XLogCtl->LogwrtResult; + SpinLockRelease(&XLogCtl->info_lck); } /* @@ -1324,7 +1321,7 @@ static void ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr) { - volatile XLogCtlInsert *Insert = &XLogCtl->Insert; + XLogCtlInsert *Insert = &XLogCtl->Insert; uint64 startbytepos; uint64 endbytepos; uint64 prevbytepos; @@ -1379,7 +1376,7 @@ ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos, static bool ReserveXLogSwitch(XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr) { - volatile XLogCtlInsert *Insert = &XLogCtl->Insert; + XLogCtlInsert *Insert = &XLogCtl->Insert; uint64 startbytepos; uint64 endbytepos; uint64 prevbytepos; @@ -1697,7 +1694,7 @@ WaitXLogInsertionsToFinish(XLogRecPtr upto) uint64 bytepos; XLogRecPtr reservedUpto; XLogRecPtr finishedUpto; - volatile XLogCtlInsert *Insert = &XLogCtl->Insert; + XLogCtlInsert *Insert = &XLogCtl->Insert; int i; if (MyProc == NULL) @@ -2132,16 +2129,11 @@ AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic) break; /* Before waiting, get info_lck and update LogwrtResult */ - { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - if (xlogctl->LogwrtRqst.Write < OldPageRqstPtr) - xlogctl->LogwrtRqst.Write = OldPageRqstPtr; - LogwrtResult = xlogctl->LogwrtResult; - SpinLockRelease(&xlogctl->info_lck); - } + SpinLockAcquire(&XLogCtl->info_lck); + if (XLogCtl->LogwrtRqst.Write < OldPageRqstPtr) + XLogCtl->LogwrtRqst.Write = OldPageRqstPtr; + LogwrtResult = XLogCtl->LogwrtResult; + SpinLockRelease(&XLogCtl->info_lck); /* * Now that we have an up-to-date LogwrtResult value, see if we @@ -2549,16 +2541,13 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible) * code in a couple of places. */ { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->LogwrtResult = LogwrtResult; - if (xlogctl->LogwrtRqst.Write < LogwrtResult.Write) - xlogctl->LogwrtRqst.Write = LogwrtResult.Write; - if (xlogctl->LogwrtRqst.Flush < LogwrtResult.Flush) - xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->LogwrtResult = LogwrtResult; + if (XLogCtl->LogwrtRqst.Write < LogwrtResult.Write) + XLogCtl->LogwrtRqst.Write = LogwrtResult.Write; + if (XLogCtl->LogwrtRqst.Flush < LogwrtResult.Flush) + XLogCtl->LogwrtRqst.Flush = LogwrtResult.Flush; + SpinLockRelease(&XLogCtl->info_lck); } } @@ -2573,15 +2562,12 @@ XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN) XLogRecPtr WriteRqstPtr = asyncXactLSN; bool sleeping; - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - LogwrtResult = xlogctl->LogwrtResult; - sleeping = xlogctl->WalWriterSleeping; - if (xlogctl->asyncXactLSN < asyncXactLSN) - xlogctl->asyncXactLSN = asyncXactLSN; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + LogwrtResult = XLogCtl->LogwrtResult; + sleeping = XLogCtl->WalWriterSleeping; + if (XLogCtl->asyncXactLSN < asyncXactLSN) + XLogCtl->asyncXactLSN = asyncXactLSN; + SpinLockRelease(&XLogCtl->info_lck); /* * If the WALWriter is sleeping, we should kick it to make it come out of @@ -2614,12 +2600,9 @@ XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN) void XLogSetReplicationSlotMinimumLSN(XLogRecPtr lsn) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->replicationSlotMinLSN = lsn; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->replicationSlotMinLSN = lsn; + SpinLockRelease(&XLogCtl->info_lck); } @@ -2630,13 +2613,11 @@ XLogSetReplicationSlotMinimumLSN(XLogRecPtr lsn) static XLogRecPtr XLogGetReplicationSlotMinimumLSN(void) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogRecPtr retval; - SpinLockAcquire(&xlogctl->info_lck); - retval = xlogctl->replicationSlotMinLSN; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + retval = XLogCtl->replicationSlotMinLSN; + SpinLockRelease(&XLogCtl->info_lck); return retval; } @@ -2672,8 +2653,6 @@ UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force) updateMinRecoveryPoint = false; else if (force || minRecoveryPoint < lsn) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogRecPtr newMinRecoveryPoint; TimeLineID newMinRecoveryPointTLI; @@ -2690,10 +2669,10 @@ UpdateMinRecoveryPoint(XLogRecPtr lsn, bool force) * all. Instead, we just log a warning and continue with recovery. * (See also the comments about corrupt LSNs in XLogFlush.) */ - SpinLockAcquire(&xlogctl->info_lck); - newMinRecoveryPoint = xlogctl->replayEndRecPtr; - newMinRecoveryPointTLI = xlogctl->replayEndTLI; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + newMinRecoveryPoint = XLogCtl->replayEndRecPtr; + newMinRecoveryPointTLI = XLogCtl->replayEndTLI; + SpinLockRelease(&XLogCtl->info_lck); if (!force && newMinRecoveryPoint < lsn) elog(WARNING, @@ -2777,16 +2756,14 @@ XLogFlush(XLogRecPtr record) */ for (;;) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogRecPtr insertpos; /* read LogwrtResult and update local state */ - SpinLockAcquire(&xlogctl->info_lck); - if (WriteRqstPtr < xlogctl->LogwrtRqst.Write) - WriteRqstPtr = xlogctl->LogwrtRqst.Write; - LogwrtResult = xlogctl->LogwrtResult; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + if (WriteRqstPtr < XLogCtl->LogwrtRqst.Write) + WriteRqstPtr = XLogCtl->LogwrtRqst.Write; + LogwrtResult = XLogCtl->LogwrtResult; + SpinLockRelease(&XLogCtl->info_lck); /* done already? */ if (record <= LogwrtResult.Flush) @@ -2923,15 +2900,10 @@ XLogBackgroundFlush(void) return false; /* read LogwrtResult and update local state */ - { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - LogwrtResult = xlogctl->LogwrtResult; - WriteRqstPtr = xlogctl->LogwrtRqst.Write; - SpinLockRelease(&xlogctl->info_lck); - } + SpinLockAcquire(&XLogCtl->info_lck); + LogwrtResult = XLogCtl->LogwrtResult; + WriteRqstPtr = XLogCtl->LogwrtRqst.Write; + SpinLockRelease(&XLogCtl->info_lck); /* back off to last completed page boundary */ WriteRqstPtr -= WriteRqstPtr % XLOG_BLCKSZ; @@ -2939,12 +2911,9 @@ XLogBackgroundFlush(void) /* if we have already flushed that far, consider async commit records */ if (WriteRqstPtr <= LogwrtResult.Flush) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - WriteRqstPtr = xlogctl->asyncXactLSN; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + WriteRqstPtr = XLogCtl->asyncXactLSN; + SpinLockRelease(&XLogCtl->info_lck); flexible = false; /* ensure it all gets written */ } @@ -3055,14 +3024,9 @@ XLogNeedsFlush(XLogRecPtr record) return false; /* read LogwrtResult and update local state */ - { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - LogwrtResult = xlogctl->LogwrtResult; - SpinLockRelease(&xlogctl->info_lck); - } + SpinLockAcquire(&XLogCtl->info_lck); + LogwrtResult = XLogCtl->LogwrtResult; + SpinLockRelease(&XLogCtl->info_lck); /* check again */ if (record <= LogwrtResult.Flush) @@ -3684,13 +3648,11 @@ PreallocXlogFiles(XLogRecPtr endptr) void CheckXLogRemoved(XLogSegNo segno, TimeLineID tli) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogSegNo lastRemovedSegNo; - SpinLockAcquire(&xlogctl->info_lck); - lastRemovedSegNo = xlogctl->lastRemovedSegNo; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + lastRemovedSegNo = XLogCtl->lastRemovedSegNo; + SpinLockRelease(&XLogCtl->info_lck); if (segno <= lastRemovedSegNo) { @@ -3714,13 +3676,11 @@ CheckXLogRemoved(XLogSegNo segno, TimeLineID tli) XLogSegNo XLogGetLastRemovedSegno(void) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogSegNo lastRemovedSegNo; - SpinLockAcquire(&xlogctl->info_lck); - lastRemovedSegNo = xlogctl->lastRemovedSegNo; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + lastRemovedSegNo = XLogCtl->lastRemovedSegNo; + SpinLockRelease(&XLogCtl->info_lck); return lastRemovedSegNo; } @@ -3732,17 +3692,15 @@ XLogGetLastRemovedSegno(void) static void UpdateLastRemovedPtr(char *filename) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; uint32 tli; XLogSegNo segno; XLogFromFileName(filename, &tli, &segno); - SpinLockAcquire(&xlogctl->info_lck); - if (segno > xlogctl->lastRemovedSegNo) - xlogctl->lastRemovedSegNo = segno; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + if (segno > XLogCtl->lastRemovedSegNo) + XLogCtl->lastRemovedSegNo = segno; + SpinLockRelease(&XLogCtl->info_lck); } /* @@ -4700,13 +4658,10 @@ GetFakeLSNForUnloggedRel(void) { XLogRecPtr nextUnloggedLSN; - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - /* increment the unloggedLSN counter, need SpinLock */ - SpinLockAcquire(&xlogctl->ulsn_lck); - nextUnloggedLSN = xlogctl->unloggedLSN++; - SpinLockRelease(&xlogctl->ulsn_lck); + SpinLockAcquire(&XLogCtl->ulsn_lck); + nextUnloggedLSN = XLogCtl->unloggedLSN++; + SpinLockRelease(&XLogCtl->ulsn_lck); return nextUnloggedLSN; } @@ -5738,13 +5693,11 @@ recoveryPausesHere(void) bool RecoveryIsPaused(void) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; bool recoveryPause; - SpinLockAcquire(&xlogctl->info_lck); - recoveryPause = xlogctl->recoveryPause; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + recoveryPause = XLogCtl->recoveryPause; + SpinLockRelease(&XLogCtl->info_lck); return recoveryPause; } @@ -5752,12 +5705,9 @@ RecoveryIsPaused(void) void SetRecoveryPause(bool recoveryPause) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->recoveryPause = recoveryPause; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->recoveryPause = recoveryPause; + SpinLockRelease(&XLogCtl->info_lck); } /* @@ -5855,12 +5805,9 @@ recoveryApplyDelay(XLogRecord *record) static void SetLatestXTime(TimestampTz xtime) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->recoveryLastXTime = xtime; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->recoveryLastXTime = xtime; + SpinLockRelease(&XLogCtl->info_lck); } /* @@ -5869,13 +5816,11 @@ SetLatestXTime(TimestampTz xtime) TimestampTz GetLatestXTime(void) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; TimestampTz xtime; - SpinLockAcquire(&xlogctl->info_lck); - xtime = xlogctl->recoveryLastXTime; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + xtime = XLogCtl->recoveryLastXTime; + SpinLockRelease(&XLogCtl->info_lck); return xtime; } @@ -5889,12 +5834,9 @@ GetLatestXTime(void) static void SetCurrentChunkStartTime(TimestampTz xtime) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->currentChunkStartTime = xtime; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->currentChunkStartTime = xtime; + SpinLockRelease(&XLogCtl->info_lck); } /* @@ -5904,13 +5846,11 @@ SetCurrentChunkStartTime(TimestampTz xtime) TimestampTz GetCurrentChunkReplayStartTime(void) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; TimestampTz xtime; - SpinLockAcquire(&xlogctl->info_lck); - xtime = xlogctl->currentChunkStartTime; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + xtime = XLogCtl->currentChunkStartTime; + SpinLockRelease(&XLogCtl->info_lck); return xtime; } @@ -6434,9 +6374,6 @@ StartupXLOG(void) { int rmid; - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - /* * Update pg_control to show that we are recovering and to show the * selected checkpoint as the place we are starting from. We also mark @@ -6623,18 +6560,18 @@ StartupXLOG(void) * if we had just replayed the record before the REDO location (or the * checkpoint record itself, if it's a shutdown checkpoint). */ - SpinLockAcquire(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); if (checkPoint.redo < RecPtr) - xlogctl->replayEndRecPtr = checkPoint.redo; + XLogCtl->replayEndRecPtr = checkPoint.redo; else - xlogctl->replayEndRecPtr = EndRecPtr; - xlogctl->replayEndTLI = ThisTimeLineID; - xlogctl->lastReplayedEndRecPtr = xlogctl->replayEndRecPtr; - xlogctl->lastReplayedTLI = xlogctl->replayEndTLI; - xlogctl->recoveryLastXTime = 0; - xlogctl->currentChunkStartTime = 0; - xlogctl->recoveryPause = false; - SpinLockRelease(&xlogctl->info_lck); + XLogCtl->replayEndRecPtr = EndRecPtr; + XLogCtl->replayEndTLI = ThisTimeLineID; + XLogCtl->lastReplayedEndRecPtr = XLogCtl->replayEndRecPtr; + XLogCtl->lastReplayedTLI = XLogCtl->replayEndTLI; + XLogCtl->recoveryLastXTime = 0; + XLogCtl->currentChunkStartTime = 0; + XLogCtl->recoveryPause = false; + SpinLockRelease(&XLogCtl->info_lck); /* Also ensure XLogReceiptTime has a sane value */ XLogReceiptTime = GetCurrentTimestamp(); @@ -6733,7 +6670,7 @@ StartupXLOG(void) * otherwise would is a minor issue, so it doesn't seem worth * adding another spinlock cycle to prevent that. */ - if (xlogctl->recoveryPause) + if (((volatile XLogCtlData *) XLogCtl)->recoveryPause) recoveryPausesHere(); /* @@ -6758,7 +6695,7 @@ StartupXLOG(void) * here otherwise pausing during the delay-wait wouldn't * work. */ - if (xlogctl->recoveryPause) + if (((volatile XLogCtlData *) XLogCtl)->recoveryPause) recoveryPausesHere(); } @@ -6831,10 +6768,10 @@ StartupXLOG(void) * Update shared replayEndRecPtr before replaying this record, * so that XLogFlush will update minRecoveryPoint correctly. */ - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->replayEndRecPtr = EndRecPtr; - xlogctl->replayEndTLI = ThisTimeLineID; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->replayEndRecPtr = EndRecPtr; + XLogCtl->replayEndTLI = ThisTimeLineID; + SpinLockRelease(&XLogCtl->info_lck); /* * If we are attempting to enter Hot Standby mode, process @@ -6854,10 +6791,10 @@ StartupXLOG(void) * Update lastReplayedEndRecPtr after this record has been * successfully replayed. */ - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->lastReplayedEndRecPtr = EndRecPtr; - xlogctl->lastReplayedTLI = ThisTimeLineID; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->lastReplayedEndRecPtr = EndRecPtr; + XLogCtl->lastReplayedTLI = ThisTimeLineID; + SpinLockRelease(&XLogCtl->info_lck); /* Remember this record as the last-applied one */ LastRec = ReadRecPtr; @@ -7267,14 +7204,9 @@ StartupXLOG(void) * there are no race conditions concerning visibility of other recent * updates to shared memory.) */ - { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->SharedRecoveryInProgress = false; - SpinLockRelease(&xlogctl->info_lck); - } + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->SharedRecoveryInProgress = false; + SpinLockRelease(&XLogCtl->info_lck); /* * If there were cascading standby servers connected to us, nudge any wal @@ -7377,12 +7309,9 @@ CheckRecoveryConsistency(void) reachedConsistency && IsUnderPostmaster) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->SharedHotStandbyActive = true; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->SharedHotStandbyActive = true; + SpinLockRelease(&XLogCtl->info_lck); LocalHotStandbyActive = true; @@ -7467,13 +7396,10 @@ HotStandbyActive(void) return true; else { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - /* spinlock is essential on machines with weak memory ordering! */ - SpinLockAcquire(&xlogctl->info_lck); - LocalHotStandbyActive = xlogctl->SharedHotStandbyActive; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + LocalHotStandbyActive = XLogCtl->SharedHotStandbyActive; + SpinLockRelease(&XLogCtl->info_lck); return LocalHotStandbyActive; } @@ -7688,8 +7614,6 @@ InitXLOGAccess(void) XLogRecPtr GetRedoRecPtr(void) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogRecPtr ptr; /* @@ -7697,9 +7621,9 @@ GetRedoRecPtr(void) * grabbed a WAL insertion lock to read the master copy, someone might * update it just after we've released the lock. */ - SpinLockAcquire(&xlogctl->info_lck); - ptr = xlogctl->RedoRecPtr; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + ptr = XLogCtl->RedoRecPtr; + SpinLockRelease(&XLogCtl->info_lck); if (RedoRecPtr < ptr) RedoRecPtr = ptr; @@ -7718,13 +7642,11 @@ GetRedoRecPtr(void) XLogRecPtr GetInsertRecPtr(void) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogRecPtr recptr; - SpinLockAcquire(&xlogctl->info_lck); - recptr = xlogctl->LogwrtRqst.Write; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + recptr = XLogCtl->LogwrtRqst.Write; + SpinLockRelease(&XLogCtl->info_lck); return recptr; } @@ -7736,13 +7658,11 @@ GetInsertRecPtr(void) XLogRecPtr GetFlushRecPtr(void) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogRecPtr recptr; - SpinLockAcquire(&xlogctl->info_lck); - recptr = xlogctl->LogwrtResult.Flush; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + recptr = XLogCtl->LogwrtResult.Flush; + SpinLockRelease(&XLogCtl->info_lck); return recptr; } @@ -7779,15 +7699,10 @@ GetNextXidAndEpoch(TransactionId *xid, uint32 *epoch) TransactionId nextXid; /* Must read checkpoint info first, else have race condition */ - { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - ckptXidEpoch = xlogctl->ckptXidEpoch; - ckptXid = xlogctl->ckptXid; - SpinLockRelease(&xlogctl->info_lck); - } + SpinLockAcquire(&XLogCtl->info_lck); + ckptXidEpoch = XLogCtl->ckptXidEpoch; + ckptXid = XLogCtl->ckptXid; + SpinLockRelease(&XLogCtl->info_lck); /* Now fetch current nextXid */ nextXid = ReadNewTransactionId(); @@ -7990,8 +7905,6 @@ LogCheckpointEnd(bool restartpoint) void CreateCheckPoint(int flags) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; bool shutdown; CheckPoint checkPoint; XLogRecPtr recptr; @@ -8151,7 +8064,7 @@ CreateCheckPoint(int flags) * XLogInserts that happen while we are dumping buffers must assume that * their buffer changes are not included in the checkpoint. */ - RedoRecPtr = xlogctl->Insert.RedoRecPtr = checkPoint.redo; + RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo; /* * Now we can release the WAL insertion locks, allowing other xacts to @@ -8160,9 +8073,9 @@ CreateCheckPoint(int flags) WALInsertLockRelease(); /* Update the info_lck-protected copy of RedoRecPtr as well */ - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->RedoRecPtr = checkPoint.redo; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->RedoRecPtr = checkPoint.redo; + SpinLockRelease(&XLogCtl->info_lck); /* * If enabled, log checkpoint start. We postpone this until now so as not @@ -8334,15 +8247,10 @@ CreateCheckPoint(int flags) LWLockRelease(ControlFileLock); /* Update shared-memory copy of checkpoint XID/epoch */ - { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->ckptXidEpoch = checkPoint.nextXidEpoch; - xlogctl->ckptXid = checkPoint.nextXid; - SpinLockRelease(&xlogctl->info_lck); - } + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->ckptXidEpoch = checkPoint.nextXidEpoch; + XLogCtl->ckptXid = checkPoint.nextXid; + SpinLockRelease(&XLogCtl->info_lck); /* * We are now done with critical updates; no need for system panic if we @@ -8497,9 +8405,6 @@ CheckPointGuts(XLogRecPtr checkPointRedo, int flags) static void RecoveryRestartPoint(const CheckPoint *checkPoint) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - /* * Also refrain from creating a restartpoint if we have seen any * references to non-existent pages. Restarting recovery from the @@ -8521,10 +8426,10 @@ RecoveryRestartPoint(const CheckPoint *checkPoint) * Copy the checkpoint record to shared memory, so that checkpointer can * work out the next time it wants to perform a restartpoint. */ - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->lastCheckPointRecPtr = ReadRecPtr; - xlogctl->lastCheckPoint = *checkPoint; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->lastCheckPointRecPtr = ReadRecPtr; + XLogCtl->lastCheckPoint = *checkPoint; + SpinLockRelease(&XLogCtl->info_lck); } /* @@ -8546,9 +8451,6 @@ CreateRestartPoint(int flags) XLogSegNo _logSegNo; TimestampTz xtime; - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - /* * Acquire CheckpointLock to ensure only one restartpoint or checkpoint * happens at a time. @@ -8556,10 +8458,10 @@ CreateRestartPoint(int flags) LWLockAcquire(CheckpointLock, LW_EXCLUSIVE); /* Get a local copy of the last safe checkpoint record. */ - SpinLockAcquire(&xlogctl->info_lck); - lastCheckPointRecPtr = xlogctl->lastCheckPointRecPtr; - lastCheckPoint = xlogctl->lastCheckPoint; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + lastCheckPointRecPtr = XLogCtl->lastCheckPointRecPtr; + lastCheckPoint = XLogCtl->lastCheckPoint; + SpinLockRelease(&XLogCtl->info_lck); /* * Check that we're still in recovery mode. It's ok if we exit recovery @@ -8618,13 +8520,13 @@ CreateRestartPoint(int flags) * happening. */ WALInsertLockAcquireExclusive(); - xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo; + XLogCtl->Insert.RedoRecPtr = lastCheckPoint.redo; WALInsertLockRelease(); /* Also update the info_lck-protected copy */ - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->RedoRecPtr = lastCheckPoint.redo; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->RedoRecPtr = lastCheckPoint.redo; + SpinLockRelease(&XLogCtl->info_lck); /* * Prepare to accumulate statistics. @@ -9384,15 +9286,10 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record) ControlFile->checkPointCopy.nextXid = checkPoint.nextXid; /* Update shared-memory copy of checkpoint XID/epoch */ - { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->ckptXidEpoch = checkPoint.nextXidEpoch; - xlogctl->ckptXid = checkPoint.nextXid; - SpinLockRelease(&xlogctl->info_lck); - } + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->ckptXidEpoch = checkPoint.nextXidEpoch; + XLogCtl->ckptXid = checkPoint.nextXid; + SpinLockRelease(&XLogCtl->info_lck); /* * We should've already switched to the new TLI before replaying this @@ -9436,15 +9333,10 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record) ControlFile->checkPointCopy.nextXid = checkPoint.nextXid; /* Update shared-memory copy of checkpoint XID/epoch */ - { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->ckptXidEpoch = checkPoint.nextXidEpoch; - xlogctl->ckptXid = checkPoint.nextXid; - SpinLockRelease(&xlogctl->info_lck); - } + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->ckptXidEpoch = checkPoint.nextXidEpoch; + XLogCtl->ckptXid = checkPoint.nextXid; + SpinLockRelease(&XLogCtl->info_lck); /* TLI should not change in an on-line checkpoint */ if (checkPoint.ThisTimeLineID != ThisTimeLineID) @@ -9581,8 +9473,6 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record) } else if (info == XLOG_FPW_CHANGE) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; bool fpw; memcpy(&fpw, XLogRecGetData(record), sizeof(bool)); @@ -9594,10 +9484,10 @@ xlog_redo(XLogRecPtr lsn, XLogRecord *record) */ if (!fpw) { - SpinLockAcquire(&xlogctl->info_lck); - if (xlogctl->lastFpwDisableRecPtr < ReadRecPtr) - xlogctl->lastFpwDisableRecPtr = ReadRecPtr; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + if (XLogCtl->lastFpwDisableRecPtr < ReadRecPtr) + XLogCtl->lastFpwDisableRecPtr = ReadRecPtr; + SpinLockRelease(&XLogCtl->info_lck); } /* Keep track of full_page_writes */ @@ -9972,8 +9862,6 @@ do_pg_start_backup(const char *backupidstr, bool fast, TimeLineID *starttli_p, if (backup_started_in_recovery) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogRecPtr recptr; /* @@ -9981,9 +9869,9 @@ do_pg_start_backup(const char *backupidstr, bool fast, TimeLineID *starttli_p, * (i.e., since last restartpoint used as backup starting * checkpoint) contain full-page writes. */ - SpinLockAcquire(&xlogctl->info_lck); - recptr = xlogctl->lastFpwDisableRecPtr; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + recptr = XLogCtl->lastFpwDisableRecPtr; + SpinLockRelease(&XLogCtl->info_lck); if (!checkpointfpw || startpoint <= recptr) ereport(ERROR, @@ -10326,17 +10214,15 @@ do_pg_stop_backup(char *labelfile, bool waitforarchive, TimeLineID *stoptli_p) */ if (backup_started_in_recovery) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogRecPtr recptr; /* * Check to see if all WAL replayed during online backup contain * full-page writes. */ - SpinLockAcquire(&xlogctl->info_lck); - recptr = xlogctl->lastFpwDisableRecPtr; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + recptr = XLogCtl->lastFpwDisableRecPtr; + SpinLockRelease(&XLogCtl->info_lck); if (startpoint <= recptr) ereport(ERROR, @@ -10523,15 +10409,13 @@ do_pg_abort_backup(void) XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; XLogRecPtr recptr; TimeLineID tli; - SpinLockAcquire(&xlogctl->info_lck); - recptr = xlogctl->lastReplayedEndRecPtr; - tli = xlogctl->lastReplayedTLI; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + recptr = XLogCtl->lastReplayedEndRecPtr; + tli = XLogCtl->lastReplayedTLI; + SpinLockRelease(&XLogCtl->info_lck); if (replayTLI) *replayTLI = tli; @@ -10544,7 +10428,7 @@ GetXLogReplayRecPtr(TimeLineID *replayTLI) XLogRecPtr GetXLogInsertRecPtr(void) { - volatile XLogCtlInsert *Insert = &XLogCtl->Insert; + XLogCtlInsert *Insert = &XLogCtl->Insert; uint64 current_bytepos; SpinLockAcquire(&Insert->insertpos_lck); @@ -10560,14 +10444,9 @@ GetXLogInsertRecPtr(void) XLogRecPtr GetXLogWriteRecPtr(void) { - { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - LogwrtResult = xlogctl->LogwrtResult; - SpinLockRelease(&xlogctl->info_lck); - } + SpinLockAcquire(&XLogCtl->info_lck); + LogwrtResult = XLogCtl->LogwrtResult; + SpinLockRelease(&XLogCtl->info_lck); return LogwrtResult.Write; } @@ -11393,10 +11272,7 @@ WakeupRecovery(void) void SetWalWriterSleeping(bool sleeping) { - /* use volatile pointer to prevent code rearrangement */ - volatile XLogCtlData *xlogctl = XLogCtl; - - SpinLockAcquire(&xlogctl->info_lck); - xlogctl->WalWriterSleeping = sleeping; - SpinLockRelease(&xlogctl->info_lck); + SpinLockAcquire(&XLogCtl->info_lck); + XLogCtl->WalWriterSleeping = sleeping; + SpinLockRelease(&XLogCtl->info_lck); }