Remove volatile qualifiers from proc.c and procarray.c

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.

Michael Paquier

diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
index b13fe03993806c4c9396adb52bacde0cf30c24f3..0dc41170fe411175003f23f67ea210200e929d34 100644 (file)
--- a/src/backend/storage/ipc/procarray.c
+++ b/src/backend/storage/ipc/procarray.c
@@ -3718,8 +3718,6 @@ static int
 KnownAssignedXidsGetAndSetXmin(TransactionId *xarray, TransactionId *xmin,
                                                           TransactionId xmax)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile ProcArrayStruct *pArray = procArray;
        int                     count = 0;
        int                     head,
                                tail;
@@ -3734,10 +3732,10 @@ KnownAssignedXidsGetAndSetXmin(TransactionId *xarray, TransactionId *xmin,
         *
         * Must take spinlock to ensure we see up-to-date array contents.
         */
-       SpinLockAcquire(&pArray->known_assigned_xids_lck);
-       tail = pArray->tailKnownAssignedXids;
-       head = pArray->headKnownAssignedXids;
-       SpinLockRelease(&pArray->known_assigned_xids_lck);
+       SpinLockAcquire(&procArray->known_assigned_xids_lck);
+       tail = procArray->tailKnownAssignedXids;
+       head = procArray->headKnownAssignedXids;
+       SpinLockRelease(&procArray->known_assigned_xids_lck);
 
        for (i = tail; i < head; i++)
        {
@@ -3777,8 +3775,6 @@ KnownAssignedXidsGetAndSetXmin(TransactionId *xarray, TransactionId *xmin,
 static TransactionId
 KnownAssignedXidsGetOldestXmin(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile ProcArrayStruct *pArray = procArray;
        int                     head,
                                tail;
        int                     i;
@@ -3786,10 +3782,10 @@ KnownAssignedXidsGetOldestXmin(void)
        /*
         * Fetch head just once, since it may change while we loop.
         */
-       SpinLockAcquire(&pArray->known_assigned_xids_lck);
-       tail = pArray->tailKnownAssignedXids;
-       head = pArray->headKnownAssignedXids;
-       SpinLockRelease(&pArray->known_assigned_xids_lck);
+       SpinLockAcquire(&procArray->known_assigned_xids_lck);
+       tail = procArray->tailKnownAssignedXids;
+       head = procArray->headKnownAssignedXids;
+       SpinLockRelease(&procArray->known_assigned_xids_lck);
 
        for (i = tail; i < head; i++)
        {

diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c
index 2c2535b7b198ee8b4ef334cdf3c80ddffbb1186f..bb10c1bed0077b9a06a6b5b4a2555c0bfe6601e8 100644 (file)
--- a/src/backend/storage/lmgr/proc.c
+++ b/src/backend/storage/lmgr/proc.c
@@ -283,15 +283,13 @@ InitProcGlobal(void)
 void
 InitProcess(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile PROC_HDR *procglobal = ProcGlobal;
        PGPROC * volatile * procgloballist;
 
        /*
         * ProcGlobal should be set up already (if we are a backend, we inherit
         * this by fork() or EXEC_BACKEND mechanism from the postmaster).
         */
-       if (procglobal == NULL)
+       if (ProcGlobal == NULL)
                elog(PANIC, "proc header uninitialized");
 
        if (MyProc != NULL)
@@ -299,11 +297,11 @@ InitProcess(void)
 
        /* Decide which list should supply our PGPROC. */
        if (IsAnyAutoVacuumProcess())
-               procgloballist = &procglobal->autovacFreeProcs;
+               procgloballist = &ProcGlobal->autovacFreeProcs;
        else if (IsBackgroundWorker)
-               procgloballist = &procglobal->bgworkerFreeProcs;
+               procgloballist = &ProcGlobal->bgworkerFreeProcs;
        else
-               procgloballist = &procglobal->freeProcs;
+               procgloballist = &ProcGlobal->freeProcs;
 
        /*
         * Try to get a proc struct from the appropriate free list.  If this
@@ -314,7 +312,7 @@ InitProcess(void)
         */
        SpinLockAcquire(ProcStructLock);
 
-       set_spins_per_delay(procglobal->spins_per_delay);
+       set_spins_per_delay(ProcGlobal->spins_per_delay);
 
        MyProc = *procgloballist;
 
@@ -578,13 +576,10 @@ InitAuxiliaryProcess(void)
 void
 PublishStartupProcessInformation(void)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile PROC_HDR *procglobal = ProcGlobal;
-
        SpinLockAcquire(ProcStructLock);
 
-       procglobal->startupProc = MyProc;
-       procglobal->startupProcPid = MyProcPid;
+       ProcGlobal->startupProc = MyProc;
+       ProcGlobal->startupProcPid = MyProcPid;
 
        SpinLockRelease(ProcStructLock);
 }
@@ -627,12 +622,9 @@ HaveNFreeProcs(int n)
 {
        PGPROC     *proc;
 
-       /* use volatile pointer to prevent code rearrangement */
-       volatile PROC_HDR *procglobal = ProcGlobal;
-
        SpinLockAcquire(ProcStructLock);
 
-       proc = procglobal->freeProcs;
+       proc = ProcGlobal->freeProcs;
 
        while (n > 0 && proc != NULL)
        {
@@ -772,8 +764,6 @@ RemoveProcFromArray(int code, Datum arg)
 static void
 ProcKill(int code, Datum arg)
 {
-       /* use volatile pointer to prevent code rearrangement */
-       volatile PROC_HDR *procglobal = ProcGlobal;
        PGPROC     *proc;
        PGPROC * volatile * procgloballist;
 
@@ -822,7 +812,7 @@ ProcKill(int code, Datum arg)
        *procgloballist = proc;
 
        /* Update shared estimate of spins_per_delay */
-       procglobal->spins_per_delay = update_spins_per_delay(procglobal->spins_per_delay);
+       ProcGlobal->spins_per_delay = update_spins_per_delay(ProcGlobal->spins_per_delay);
 
        SpinLockRelease(ProcStructLock);
 
@@ -1644,9 +1634,6 @@ ProcSendSignal(int pid)
 
        if (RecoveryInProgress())
        {
-               /* use volatile pointer to prevent code rearrangement */
-               volatile PROC_HDR *procglobal = ProcGlobal;
-
                SpinLockAcquire(ProcStructLock);
 
                /*
@@ -1657,8 +1644,8 @@ ProcSendSignal(int pid)
                 * backend, so BackendPidGetProc() will not return any pid at all. So
                 * we remember the information for this special case.
                 */
-               if (pid == procglobal->startupProcPid)
-                       proc = procglobal->startupProc;
+               if (pid == ProcGlobal->startupProcPid)
+                       proc = ProcGlobal->startupProc;
 
                SpinLockRelease(ProcStructLock);
        }