Remove more volatile qualifiers.

Prior to commit 0709b7ee72e4bc71ad07b7120acd117265ab51d0, access to
variables within a spinlock-protected critical section had to be done
through a volatile pointer, but that should no longer be necessary.
This continues work begun in df4077cda2eae3eb4a5cf387da0c1e7616e73204
and 6ba4ecbf477e0b25dd7bde1b0c4e07fc2da19348.

Thomas Munro and Michael Paquier

diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c
index 3b3a09ef8860b0497a415cec0ca1d823aaa78841..dc5b85615506717979870b56021d8e09565a0601 100644 (file)
--- a/src/backend/postmaster/checkpointer.c
+++ b/src/backend/postmaster/checkpointer.c
@@ -288,13 +288,10 @@ CheckpointerMain(void)
        /* Warn any waiting backends that the checkpoint failed. */
        if (ckpt_active)
        {
-           /* use volatile pointer to prevent code rearrangement */
-           volatile CheckpointerShmemStruct *cps = CheckpointerShmem;
-
-           SpinLockAcquire(&cps->ckpt_lck);
-           cps->ckpt_failed++;
-           cps->ckpt_done = cps->ckpt_started;
-           SpinLockRelease(&cps->ckpt_lck);
+           SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
+           CheckpointerShmem->ckpt_failed++;
+           CheckpointerShmem->ckpt_done = CheckpointerShmem->ckpt_started;
+           SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
            ckpt_active = false;
        }
@@ -428,9 +425,6 @@ CheckpointerMain(void)
            bool        ckpt_performed = false;
            bool        do_restartpoint;
 
-           /* use volatile pointer to prevent code rearrangement */
-           volatile CheckpointerShmemStruct *cps = CheckpointerShmem;
-
            /*
             * Check if we should perform a checkpoint or a restartpoint. As a
             * side-effect, RecoveryInProgress() initializes TimeLineID if
@@ -443,11 +437,11 @@ CheckpointerMain(void)
             * checkpoint we should perform, and increase the started-counter
             * to acknowledge that we've started a new checkpoint.
             */
-           SpinLockAcquire(&cps->ckpt_lck);
-           flags |= cps->ckpt_flags;
-           cps->ckpt_flags = 0;
-           cps->ckpt_started++;
-           SpinLockRelease(&cps->ckpt_lck);
+           SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
+           flags |= CheckpointerShmem->ckpt_flags;
+           CheckpointerShmem->ckpt_flags = 0;
+           CheckpointerShmem->ckpt_started++;
+           SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
            /*
             * The end-of-recovery checkpoint is a real checkpoint that's
@@ -505,9 +499,9 @@ CheckpointerMain(void)
            /*
             * Indicate checkpoint completion to any waiting backends.
             */
-           SpinLockAcquire(&cps->ckpt_lck);
-           cps->ckpt_done = cps->ckpt_started;
-           SpinLockRelease(&cps->ckpt_lck);
+           SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
+           CheckpointerShmem->ckpt_done = CheckpointerShmem->ckpt_started;
+           SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
            if (ckpt_performed)
            {
@@ -957,8 +951,6 @@ CheckpointerShmemInit(void)
 void
 RequestCheckpoint(int flags)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile CheckpointerShmemStruct *cps = CheckpointerShmem;
    int         ntries;
    int         old_failed,
                old_started;
@@ -992,13 +984,13 @@ RequestCheckpoint(int flags)
     * a "stronger" request by another backend.  The flag senses must be
     * chosen to make this work!
     */
-   SpinLockAcquire(&cps->ckpt_lck);
+   SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
 
-   old_failed = cps->ckpt_failed;
-   old_started = cps->ckpt_started;
-   cps->ckpt_flags |= flags;
+   old_failed = CheckpointerShmem->ckpt_failed;
+   old_started = CheckpointerShmem->ckpt_started;
+   CheckpointerShmem->ckpt_flags |= flags;
 
-   SpinLockRelease(&cps->ckpt_lck);
+   SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
    /*
     * Send signal to request checkpoint.  It's possible that the checkpointer
@@ -1046,9 +1038,9 @@ RequestCheckpoint(int flags)
        /* Wait for a new checkpoint to start. */
        for (;;)
        {
-           SpinLockAcquire(&cps->ckpt_lck);
-           new_started = cps->ckpt_started;
-           SpinLockRelease(&cps->ckpt_lck);
+           SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
+           new_started = CheckpointerShmem->ckpt_started;
+           SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
            if (new_started != old_started)
                break;
@@ -1064,10 +1056,10 @@ RequestCheckpoint(int flags)
        {
            int         new_done;
 
-           SpinLockAcquire(&cps->ckpt_lck);
-           new_done = cps->ckpt_done;
-           new_failed = cps->ckpt_failed;
-           SpinLockRelease(&cps->ckpt_lck);
+           SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
+           new_done = CheckpointerShmem->ckpt_done;
+           new_failed = CheckpointerShmem->ckpt_failed;
+           SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
            if (new_done - new_started >= 0)
                break;
@@ -1368,15 +1360,13 @@ UpdateSharedMemoryConfig(void)
 bool
 FirstCallSinceLastCheckpoint(void)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile CheckpointerShmemStruct *cps = CheckpointerShmem;
    static int  ckpt_done = 0;
    int         new_done;
    bool        FirstCall = false;
 
-   SpinLockAcquire(&cps->ckpt_lck);
-   new_done = cps->ckpt_done;
-   SpinLockRelease(&cps->ckpt_lck);
+   SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
+   new_done = CheckpointerShmem->ckpt_done;
+   SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
    if (new_done != ckpt_done)
        FirstCall = true;

diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c
index 5a07e1d9a69c946e2a57988aba79f9d2264b8abb..1ce90811cc88aaae0cf592f70ed9c465cb9da1be 100644 (file)
--- a/src/backend/replication/logical/logical.c
+++ b/src/backend/replication/logical/logical.c
@@ -848,16 +848,13 @@ LogicalConfirmReceivedLocation(XLogRecPtr lsn)
        bool        updated_xmin = false;
        bool        updated_restart = false;
 
-       /* use volatile pointer to prevent code rearrangement */
-       volatile ReplicationSlot *slot = MyReplicationSlot;
+       SpinLockAcquire(&MyReplicationSlot->mutex);
 
-       SpinLockAcquire(&slot->mutex);
-
-       slot->data.confirmed_flush = lsn;
+       MyReplicationSlot->data.confirmed_flush = lsn;
 
        /* if were past the location required for bumping xmin, do so */
-       if (slot->candidate_xmin_lsn != InvalidXLogRecPtr &&
-           slot->candidate_xmin_lsn <= lsn)
+       if (MyReplicationSlot->candidate_xmin_lsn != InvalidXLogRecPtr &&
+           MyReplicationSlot->candidate_xmin_lsn <= lsn)
        {
            /*
             * We have to write the changed xmin to disk *before* we change
@@ -868,28 +865,28 @@ LogicalConfirmReceivedLocation(XLogRecPtr lsn)
             * ->effective_xmin once the new state is synced to disk. After a
             * crash ->effective_xmin is set to ->xmin.
             */
-           if (TransactionIdIsValid(slot->candidate_catalog_xmin) &&
-               slot->data.catalog_xmin != slot->candidate_catalog_xmin)
+           if (TransactionIdIsValid(MyReplicationSlot->candidate_catalog_xmin) &&
+               MyReplicationSlot->data.catalog_xmin != MyReplicationSlot->candidate_catalog_xmin)
            {
-               slot->data.catalog_xmin = slot->candidate_catalog_xmin;
-               slot->candidate_catalog_xmin = InvalidTransactionId;
-               slot->candidate_xmin_lsn = InvalidXLogRecPtr;
+               MyReplicationSlot->data.catalog_xmin = MyReplicationSlot->candidate_catalog_xmin;
+               MyReplicationSlot->candidate_catalog_xmin = InvalidTransactionId;
+               MyReplicationSlot->candidate_xmin_lsn = InvalidXLogRecPtr;
                updated_xmin = true;
            }
        }
 
-       if (slot->candidate_restart_valid != InvalidXLogRecPtr &&
-           slot->candidate_restart_valid <= lsn)
+       if (MyReplicationSlot->candidate_restart_valid != InvalidXLogRecPtr &&
+           MyReplicationSlot->candidate_restart_valid <= lsn)
        {
-           Assert(slot->candidate_restart_lsn != InvalidXLogRecPtr);
+           Assert(MyReplicationSlot->candidate_restart_lsn != InvalidXLogRecPtr);
 
-           slot->data.restart_lsn = slot->candidate_restart_lsn;
-           slot->candidate_restart_lsn = InvalidXLogRecPtr;
-           slot->candidate_restart_valid = InvalidXLogRecPtr;
+           MyReplicationSlot->data.restart_lsn = MyReplicationSlot->candidate_restart_lsn;
+           MyReplicationSlot->candidate_restart_lsn = InvalidXLogRecPtr;
+           MyReplicationSlot->candidate_restart_valid = InvalidXLogRecPtr;
            updated_restart = true;
        }
 
-       SpinLockRelease(&slot->mutex);
+       SpinLockRelease(&MyReplicationSlot->mutex);
 
        /* first write new xmin to disk, so we know whats up after a crash */
        if (updated_xmin || updated_restart)
@@ -907,9 +904,9 @@ LogicalConfirmReceivedLocation(XLogRecPtr lsn)
         */
        if (updated_xmin)
        {
-           SpinLockAcquire(&slot->mutex);
-           slot->effective_catalog_xmin = slot->data.catalog_xmin;
-           SpinLockRelease(&slot->mutex);
+           SpinLockAcquire(&MyReplicationSlot->mutex);
+           MyReplicationSlot->effective_catalog_xmin = MyReplicationSlot->data.catalog_xmin;
+           SpinLockRelease(&MyReplicationSlot->mutex);
 
            ReplicationSlotsComputeRequiredXmin(false);
            ReplicationSlotsComputeRequiredLSN();
@@ -917,10 +914,8 @@ LogicalConfirmReceivedLocation(XLogRecPtr lsn)
    }
    else
    {
-       volatile ReplicationSlot *slot = MyReplicationSlot;
-
-       SpinLockAcquire(&slot->mutex);
-       slot->data.confirmed_flush = lsn;
-       SpinLockRelease(&slot->mutex);
+       SpinLockAcquire(&MyReplicationSlot->mutex);
+       MyReplicationSlot->data.confirmed_flush = lsn;
+       SpinLockRelease(&MyReplicationSlot->mutex);
    }
 }

diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index a4b86e039e390ae28a456374a062b124e7698050..92ec6326de12069b05dfd17b7be5253d10b333b6 100644 (file)
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -288,15 +288,11 @@ ReplicationSlotCreate(const char *name, bool db_specific,
    slot->in_use = true;
 
    /* We can now mark the slot active, and that makes it our slot. */
-   {
-       volatile ReplicationSlot *vslot = slot;
-
-       SpinLockAcquire(&slot->mutex);
-       Assert(vslot->active_pid == 0);
-       vslot->active_pid = MyProcPid;
-       SpinLockRelease(&slot->mutex);
-       MyReplicationSlot = slot;
-   }
+   SpinLockAcquire(&slot->mutex);
+   Assert(slot->active_pid == 0);
+   slot->active_pid = MyProcPid;
+   SpinLockRelease(&slot->mutex);
+   MyReplicationSlot = slot;
 
    LWLockRelease(ReplicationSlotControlLock);
 
@@ -329,12 +325,10 @@ ReplicationSlotAcquire(const char *name)
 
        if (s->in_use && strcmp(name, NameStr(s->data.name)) == 0)
        {
-           volatile ReplicationSlot *vslot = s;
-
            SpinLockAcquire(&s->mutex);
-           active_pid = vslot->active_pid;
+           active_pid = s->active_pid;
            if (active_pid == 0)
-               vslot->active_pid = MyProcPid;
+               s->active_pid = MyProcPid;
            SpinLockRelease(&s->mutex);
            slot = s;
            break;
@@ -380,10 +374,8 @@ ReplicationSlotRelease(void)
    else
    {
        /* Mark slot inactive.  We're not freeing it, just disconnecting. */
-       volatile ReplicationSlot *vslot = slot;
-
        SpinLockAcquire(&slot->mutex);
-       vslot->active_pid = 0;
+       slot->active_pid = 0;
        SpinLockRelease(&slot->mutex);
    }
 
@@ -459,11 +451,10 @@ ReplicationSlotDropAcquired(void)
    }
    else
    {
-       volatile ReplicationSlot *vslot = slot;
        bool        fail_softly = slot->data.persistency == RS_EPHEMERAL;
 
        SpinLockAcquire(&slot->mutex);
-       vslot->active_pid = 0;
+       slot->active_pid = 0;
        SpinLockRelease(&slot->mutex);
 
        ereport(fail_softly ? WARNING : ERROR,
@@ -533,16 +524,13 @@ ReplicationSlotSave(void)
 void
 ReplicationSlotMarkDirty(void)
 {
+   ReplicationSlot *slot = MyReplicationSlot;
    Assert(MyReplicationSlot != NULL);
 
-   {
-       volatile ReplicationSlot *vslot = MyReplicationSlot;
-
-       SpinLockAcquire(&vslot->mutex);
-       MyReplicationSlot->just_dirtied = true;
-       MyReplicationSlot->dirty = true;
-       SpinLockRelease(&vslot->mutex);
-   }
+   SpinLockAcquire(&slot->mutex);
+   MyReplicationSlot->just_dirtied = true;
+   MyReplicationSlot->dirty = true;
+   SpinLockRelease(&slot->mutex);
 }
 
 /*
@@ -557,13 +545,9 @@ ReplicationSlotPersist(void)
    Assert(slot != NULL);
    Assert(slot->data.persistency != RS_PERSISTENT);
 
-   {
-       volatile ReplicationSlot *vslot = slot;
-
-       SpinLockAcquire(&slot->mutex);
-       vslot->data.persistency = RS_PERSISTENT;
-       SpinLockRelease(&slot->mutex);
-   }
+   SpinLockAcquire(&slot->mutex);
+   slot->data.persistency = RS_PERSISTENT;
+   SpinLockRelease(&slot->mutex);
 
    ReplicationSlotMarkDirty();
    ReplicationSlotSave();
@@ -593,14 +577,10 @@ ReplicationSlotsComputeRequiredXmin(bool already_locked)
        if (!s->in_use)
            continue;
 
-       {
-           volatile ReplicationSlot *vslot = s;
-
-           SpinLockAcquire(&s->mutex);
-           effective_xmin = vslot->effective_xmin;
-           effective_catalog_xmin = vslot->effective_catalog_xmin;
-           SpinLockRelease(&s->mutex);
-       }
+       SpinLockAcquire(&s->mutex);
+       effective_xmin = s->effective_xmin;
+       effective_catalog_xmin = s->effective_catalog_xmin;
+       SpinLockRelease(&s->mutex);
 
        /* check the data xmin */
        if (TransactionIdIsValid(effective_xmin) &&
@@ -641,13 +621,9 @@ ReplicationSlotsComputeRequiredLSN(void)
        if (!s->in_use)
            continue;
 
-       {
-           volatile ReplicationSlot *vslot = s;
-
-           SpinLockAcquire(&s->mutex);
-           restart_lsn = vslot->data.restart_lsn;
-           SpinLockRelease(&s->mutex);
-       }
+       SpinLockAcquire(&s->mutex);
+       restart_lsn = s->data.restart_lsn;
+       SpinLockRelease(&s->mutex);
 
        if (restart_lsn != InvalidXLogRecPtr &&
            (min_required == InvalidXLogRecPtr ||
@@ -684,7 +660,7 @@ ReplicationSlotsComputeLogicalRestartLSN(void)
 
    for (i = 0; i < max_replication_slots; i++)
    {
-       volatile ReplicationSlot *s;
+       ReplicationSlot *s;
        XLogRecPtr  restart_lsn;
 
        s = &ReplicationSlotCtl->replication_slots[i];
@@ -733,7 +709,7 @@ ReplicationSlotsCountDBSlots(Oid dboid, int *nslots, int *nactive)
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
    for (i = 0; i < max_replication_slots; i++)
    {
-       volatile ReplicationSlot *s;
+       ReplicationSlot *s;
 
        s = &ReplicationSlotCtl->replication_slots[i];
 
@@ -1023,14 +999,10 @@ SaveSlotToPath(ReplicationSlot *slot, const char *dir, int elevel)
    bool        was_dirty;
 
    /* first check whether there's something to write out */
-   {
-       volatile ReplicationSlot *vslot = slot;
-
-       SpinLockAcquire(&vslot->mutex);
-       was_dirty = vslot->dirty;
-       vslot->just_dirtied = false;
-       SpinLockRelease(&vslot->mutex);
-   }
+   SpinLockAcquire(&slot->mutex);
+   was_dirty = slot->dirty;
+   slot->just_dirtied = false;
+   SpinLockRelease(&slot->mutex);
 
    /* and don't do anything if there's nothing to write */
    if (!was_dirty)
@@ -1124,14 +1096,10 @@ SaveSlotToPath(ReplicationSlot *slot, const char *dir, int elevel)
     * Successfully wrote, unset dirty bit, unless somebody dirtied again
     * already.
     */
-   {
-       volatile ReplicationSlot *vslot = slot;
-
-       SpinLockAcquire(&vslot->mutex);
-       if (!vslot->just_dirtied)
-           vslot->dirty = false;
-       SpinLockRelease(&vslot->mutex);
-   }
+   SpinLockAcquire(&slot->mutex);
+   if (!slot->just_dirtied)
+       slot->dirty = false;
+   SpinLockRelease(&slot->mutex);
 
    LWLockRelease(slot->io_in_progress_lock);
 }

diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
index 41e57f24397348c183d3a1eab77455042644375b..183a3a553db3904de9be417d0ab1941e096d0240 100644 (file)
--- a/src/backend/replication/walreceiver.c
+++ b/src/backend/replication/walreceiver.c
@@ -192,9 +192,7 @@ WalReceiverMain(void)
    TimeLineID  startpointTLI;
    TimeLineID  primaryTLI;
    bool        first_stream;
-
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
+   WalRcvData *walrcv = WalRcv;
    TimestampTz last_recv_timestamp;
    bool        ping_sent;
 
@@ -559,8 +557,7 @@ WalReceiverMain(void)
 static void
 WalRcvWaitForStartPosition(XLogRecPtr *startpoint, TimeLineID *startpointTLI)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
+   WalRcvData *walrcv = WalRcv;
    int         state;
 
    SpinLockAcquire(&walrcv->mutex);
@@ -693,8 +690,7 @@ WalRcvFetchTimeLineHistoryFiles(TimeLineID first, TimeLineID last)
 static void
 WalRcvDie(int code, Datum arg)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
+   WalRcvData *walrcv = WalRcv;
 
    /* Ensure that all WAL records received are flushed to disk */
    XLogWalRcvFlush(true);
@@ -974,8 +970,7 @@ XLogWalRcvFlush(bool dying)
 {
    if (LogstreamResult.Flush < LogstreamResult.Write)
    {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile WalRcvData *walrcv = WalRcv;
+       WalRcvData *walrcv = WalRcv;
 
        issue_xlog_fsync(recvFile, recvSegNo);
 
@@ -1179,8 +1174,7 @@ XLogWalRcvSendHSFeedback(bool immed)
 static void
 ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
+   WalRcvData *walrcv = WalRcv;
 
    TimestampTz lastMsgReceiptTime = GetCurrentTimestamp();
 

diff --git a/src/backend/replication/walreceiverfuncs.c b/src/backend/replication/walreceiverfuncs.c
index f77a790fd878527c667381d344b40ed3917e349d..4452f25d72a86e5536a80772130e57bd41bb3aa6 100644 (file)
--- a/src/backend/replication/walreceiverfuncs.c
+++ b/src/backend/replication/walreceiverfuncs.c
@@ -72,8 +72,7 @@ WalRcvShmemInit(void)
 bool
 WalRcvRunning(void)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
+   WalRcvData *walrcv = WalRcv;
    WalRcvState state;
    pg_time_t   startTime;
 
@@ -118,8 +117,7 @@ WalRcvRunning(void)
 bool
 WalRcvStreaming(void)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
+   WalRcvData *walrcv = WalRcv;
    WalRcvState state;
    pg_time_t   startTime;
 
@@ -165,8 +163,7 @@ WalRcvStreaming(void)
 void
 ShutdownWalRcv(void)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
+   WalRcvData *walrcv = WalRcv;
    pid_t       walrcvpid = 0;
 
    /*
@@ -227,8 +224,7 @@ void
 RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr, const char *conninfo,
                     const char *slotname)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
+   WalRcvData *walrcv = WalRcv;
    bool        launch = false;
    pg_time_t   now = (pg_time_t) time(NULL);
 
@@ -298,8 +294,7 @@ RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr, const char *conninfo,
 XLogRecPtr
 GetWalRcvWriteRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
+   WalRcvData *walrcv = WalRcv;
    XLogRecPtr  recptr;
 
    SpinLockAcquire(&walrcv->mutex);
@@ -320,9 +315,7 @@ GetWalRcvWriteRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI)
 int
 GetReplicationApplyDelay(void)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
-
+   WalRcvData *walrcv = WalRcv;
    XLogRecPtr  receivePtr;
    XLogRecPtr  replayPtr;
 
@@ -359,8 +352,7 @@ GetReplicationApplyDelay(void)
 int
 GetReplicationTransferLatency(void)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalRcvData *walrcv = WalRcv;
+   WalRcvData *walrcv = WalRcv;
 
    TimestampTz lastMsgSendTime;
    TimestampTz lastMsgReceiptTime;

diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index c95fe75a7215151ec4049b9d6731c9b52c9c383d..c6043cd3ce4ed6a5fec977b3b4b57efc26e58b3a 100644 (file)
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -641,8 +641,7 @@ StartReplication(StartReplicationCmd *cmd)
 
        /* Initialize shared memory status, too */
        {
-           /* use volatile pointer to prevent code rearrangement */
-           volatile WalSnd *walsnd = MyWalSnd;
+           WalSnd *walsnd = MyWalSnd;
 
            SpinLockAcquire(&walsnd->mutex);
            walsnd->sentPtr = sentPtr;
@@ -990,8 +989,7 @@ StartLogicalReplication(StartReplicationCmd *cmd)
 
    /* Also update the sent position status in shared memory */
    {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile WalSnd *walsnd = MyWalSnd;
+       WalSnd *walsnd = MyWalSnd;
 
        SpinLockAcquire(&walsnd->mutex);
        walsnd->sentPtr = MyReplicationSlot->data.restart_lsn;
@@ -1494,9 +1492,7 @@ static void
 PhysicalConfirmReceivedLocation(XLogRecPtr lsn)
 {
    bool        changed = false;
-
-   /* use volatile pointer to prevent code rearrangement */
-   volatile ReplicationSlot *slot = MyReplicationSlot;
+   ReplicationSlot *slot = MyReplicationSlot;
 
    Assert(lsn != InvalidXLogRecPtr);
    SpinLockAcquire(&slot->mutex);
@@ -1554,8 +1550,7 @@ ProcessStandbyReplyMessage(void)
     * standby.
     */
    {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile WalSnd *walsnd = MyWalSnd;
+       WalSnd *walsnd = MyWalSnd;
 
        SpinLockAcquire(&walsnd->mutex);
        walsnd->write = writePtr;
@@ -1584,7 +1579,7 @@ static void
 PhysicalReplicationSlotNewXmin(TransactionId feedbackXmin)
 {
    bool        changed = false;
-   volatile ReplicationSlot *slot = MyReplicationSlot;
+   ReplicationSlot *slot = MyReplicationSlot;
 
    SpinLockAcquire(&slot->mutex);
    MyPgXact->xmin = InvalidTransactionId;
@@ -1934,8 +1929,7 @@ InitWalSenderSlot(void)
     */
    for (i = 0; i < max_wal_senders; i++)
    {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile WalSnd *walsnd = &WalSndCtl->walsnds[i];
+       WalSnd *walsnd = &WalSndCtl->walsnds[i];
 
        SpinLockAcquire(&walsnd->mutex);
 
@@ -2145,8 +2139,7 @@ retry:
     */
    if (am_cascading_walsender)
    {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile WalSnd *walsnd = MyWalSnd;
+       WalSnd *walsnd = MyWalSnd;
        bool        reload;
 
        SpinLockAcquire(&walsnd->mutex);
@@ -2384,8 +2377,7 @@ XLogSendPhysical(void)
 
    /* Update shared memory status */
    {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile WalSnd *walsnd = MyWalSnd;
+       WalSnd *walsnd = MyWalSnd;
 
        SpinLockAcquire(&walsnd->mutex);
        walsnd->sentPtr = sentPtr;
@@ -2447,8 +2439,7 @@ XLogSendLogical(void)
 
    /* Update shared memory status */
    {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile WalSnd *walsnd = MyWalSnd;
+       WalSnd *walsnd = MyWalSnd;
 
        SpinLockAcquire(&walsnd->mutex);
        walsnd->sentPtr = sentPtr;
@@ -2539,8 +2530,7 @@ WalSndRqstFileReload(void)
 
    for (i = 0; i < max_wal_senders; i++)
    {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile WalSnd *walsnd = &WalSndCtl->walsnds[i];
+       WalSnd *walsnd = &WalSndCtl->walsnds[i];
 
        if (walsnd->pid == 0)
            continue;
@@ -2692,8 +2682,7 @@ WalSndWakeup(void)
 void
 WalSndSetState(WalSndState state)
 {
-   /* use volatile pointer to prevent code rearrangement */
-   volatile WalSnd *walsnd = MyWalSnd;
+   WalSnd *walsnd = MyWalSnd;
 
    Assert(am_walsender);
 
@@ -2777,8 +2766,7 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 
    for (i = 0; i < max_wal_senders; i++)
    {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile WalSnd *walsnd = &WalSndCtl->walsnds[i];
+       WalSnd *walsnd = &WalSndCtl->walsnds[i];
        XLogRecPtr  sentPtr;
        XLogRecPtr  write;
        XLogRecPtr  flush;
@@ -2934,8 +2922,7 @@ GetOldestWALSendPointer(void)
 
    for (i = 0; i < max_wal_senders; i++)
    {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile WalSnd *walsnd = &WalSndCtl->walsnds[i];
+       WalSnd *walsnd = &WalSndCtl->walsnds[i];
        XLogRecPtr  recptr;
 
        if (walsnd->pid == 0)