Remove volatile qualifiers from lwlock.c.

Now that spinlocks (hopefully!) act as compiler barriers, as of commit
0709b7ee72e4bc71ad07b7120acd117265ab51d0, this should be safe.  This
serves as a demonstration of the new coding style, and may be optimized
better on some machines as well.

diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c
index 7c96da5c3d8b30ef6274df190f2f6f6b51fffb5c..66fb2e42317ae45d4acc6129460b22af6e875eb0 100644 (file)
--- a/src/backend/storage/lmgr/lwlock.c
+++ b/src/backend/storage/lmgr/lwlock.c
@@ -112,7 +112,7 @@ static lwlock_stats lwlock_stats_dummy;
 bool           Trace_lwlocks = false;
 
 inline static void
-PRINT_LWDEBUG(const char *where, const volatile LWLock *lock)
+PRINT_LWDEBUG(const char *where, const LWLock *lock)
 {
        if (Trace_lwlocks)
                elog(LOG, "%s(%s %d): excl %d shared %d head %p rOK %d",
@@ -406,9 +406,7 @@ LWLock *
 LWLockAssign(void)
 {
        LWLock     *result;
-
-       /* use volatile pointer to prevent code rearrangement */
-       volatile int *LWLockCounter;
+       int                *LWLockCounter;
 
        LWLockCounter = (int *) ((char *) MainLWLockArray - 3 * sizeof(int));
        SpinLockAcquire(ShmemLock);
@@ -429,9 +427,7 @@ int
 LWLockNewTrancheId(void)
 {
        int                     result;
-
-       /* use volatile pointer to prevent code rearrangement */
-       volatile int *LWLockCounter;
+       int                *LWLockCounter;
 
        LWLockCounter = (int *) ((char *) MainLWLockArray - 3 * sizeof(int));
        SpinLockAcquire(ShmemLock);
@@ -511,9 +507,8 @@ LWLockAcquireWithVar(LWLock *l, uint64 *valptr, uint64 val)
 
 /* internal function to implement LWLockAcquire and LWLockAcquireWithVar */
 static inline bool
-LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
+LWLockAcquireCommon(LWLock *lock, LWLockMode mode, uint64 *valptr, uint64 val)
 {
-       volatile LWLock *lock = l;
        PGPROC     *proc = MyProc;
        bool            retry = false;
        bool            result = true;
@@ -525,7 +520,7 @@ LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
        PRINT_LWDEBUG("LWLockAcquire", lock);
 
 #ifdef LWLOCK_STATS
-       lwstats = get_lwlock_stats_entry(l);
+       lwstats = get_lwlock_stats_entry(lock);
 
        /* Count lock acquisition attempts */
        if (mode == LW_EXCLUSIVE)
@@ -642,13 +637,13 @@ LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
                 * so that the lock manager or signal manager will see the received
                 * signal when it next waits.
                 */
-               LOG_LWDEBUG("LWLockAcquire", T_NAME(l), T_ID(l), "waiting");
+               LOG_LWDEBUG("LWLockAcquire", T_NAME(lock), T_ID(lock), "waiting");
 
 #ifdef LWLOCK_STATS
                lwstats->block_count++;
 #endif
 
-               TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(l), T_ID(l), mode);
+               TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), T_ID(lock), mode);
 
                for (;;)
                {
@@ -659,9 +654,9 @@ LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
                        extraWaits++;
                }
 
-               TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(l), T_ID(l), mode);
+               TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), T_ID(lock), mode);
 
-               LOG_LWDEBUG("LWLockAcquire", T_NAME(l), T_ID(l), "awakened");
+               LOG_LWDEBUG("LWLockAcquire", T_NAME(lock), T_ID(lock), "awakened");
 
                /* Now loop back and try to acquire lock again. */
                retry = true;
@@ -675,10 +670,10 @@ LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
        /* We are done updating shared state of the lock itself. */
        SpinLockRelease(&lock->mutex);
 
-       TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(l), T_ID(l), mode);
+       TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(lock), T_ID(lock), mode);
 
        /* Add lock to list of locks held by this backend */
-       held_lwlocks[num_held_lwlocks++] = l;
+       held_lwlocks[num_held_lwlocks++] = lock;
 
        /*
         * Fix the process wait semaphore's count for any absorbed wakeups.
@@ -697,9 +692,8 @@ LWLockAcquireCommon(LWLock *l, LWLockMode mode, uint64 *valptr, uint64 val)
  * If successful, cancel/die interrupts are held off until lock release.
  */
 bool
-LWLockConditionalAcquire(LWLock *l, LWLockMode mode)
+LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
 {
-       volatile LWLock *lock = l;
        bool            mustwait;
 
        PRINT_LWDEBUG("LWLockConditionalAcquire", lock);
@@ -747,14 +741,16 @@ LWLockConditionalAcquire(LWLock *l, LWLockMode mode)
        {
                /* Failed to get lock, so release interrupt holdoff */
                RESUME_INTERRUPTS();
-               LOG_LWDEBUG("LWLockConditionalAcquire", T_NAME(l), T_ID(l), "failed");
-               TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL(T_NAME(l), T_ID(l), mode);
+               LOG_LWDEBUG("LWLockConditionalAcquire",
+                                       T_NAME(lock), T_ID(lock), "failed");
+               TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL(T_NAME(lock),
+                                                                                                T_ID(lock), mode);
        }
        else
        {
                /* Add lock to list of locks held by this backend */
-               held_lwlocks[num_held_lwlocks++] = l;
-               TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE(T_NAME(l), T_ID(l), mode);
+               held_lwlocks[num_held_lwlocks++] = lock;
+               TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE(T_NAME(lock), T_ID(lock), mode);
        }
 
        return !mustwait;
@@ -775,9 +771,8 @@ LWLockConditionalAcquire(LWLock *l, LWLockMode mode)
  * wake up, observe that their records have already been flushed, and return.
  */
 bool
-LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
+LWLockAcquireOrWait(LWLock *lock, LWLockMode mode)
 {
-       volatile LWLock *lock = l;
        PGPROC     *proc = MyProc;
        bool            mustwait;
        int                     extraWaits = 0;
@@ -788,7 +783,7 @@ LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
        PRINT_LWDEBUG("LWLockAcquireOrWait", lock);
 
 #ifdef LWLOCK_STATS
-       lwstats = get_lwlock_stats_entry(l);
+       lwstats = get_lwlock_stats_entry(lock);
 #endif
 
        /* Ensure we will have room to remember the lock */
@@ -855,13 +850,14 @@ LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
                 * Wait until awakened.  Like in LWLockAcquire, be prepared for bogus
                 * wakups, because we share the semaphore with ProcWaitForSignal.
                 */
-               LOG_LWDEBUG("LWLockAcquireOrWait", T_NAME(l), T_ID(l), "waiting");
+               LOG_LWDEBUG("LWLockAcquireOrWait", T_NAME(lock), T_ID(lock),
+                                       "waiting");
 
 #ifdef LWLOCK_STATS
                lwstats->block_count++;
 #endif
 
-               TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(l), T_ID(l), mode);
+               TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), T_ID(lock), mode);
 
                for (;;)
                {
@@ -872,9 +868,10 @@ LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
                        extraWaits++;
                }
 
-               TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(l), T_ID(l), mode);
+               TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), T_ID(lock), mode);
 
-               LOG_LWDEBUG("LWLockAcquireOrWait", T_NAME(l), T_ID(l), "awakened");
+               LOG_LWDEBUG("LWLockAcquireOrWait", T_NAME(lock), T_ID(lock),
+                                       "awakened");
        }
        else
        {
@@ -892,14 +889,16 @@ LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
        {
                /* Failed to get lock, so release interrupt holdoff */
                RESUME_INTERRUPTS();
-               LOG_LWDEBUG("LWLockAcquireOrWait", T_NAME(l), T_ID(l), "failed");
-               TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_FAIL(T_NAME(l), T_ID(l), mode);
+               LOG_LWDEBUG("LWLockAcquireOrWait", T_NAME(lock), T_ID(lock), "failed");
+               TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_FAIL(T_NAME(lock), T_ID(lock),
+                                                                                                        mode);
        }
        else
        {
                /* Add lock to list of locks held by this backend */
-               held_lwlocks[num_held_lwlocks++] = l;
-               TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT(T_NAME(l), T_ID(l), mode);
+               held_lwlocks[num_held_lwlocks++] = lock;
+               TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT(T_NAME(lock), T_ID(lock),
+                                                                                               mode);
        }
 
        return !mustwait;
@@ -924,10 +923,8 @@ LWLockAcquireOrWait(LWLock *l, LWLockMode mode)
  * in shared mode, returns 'true'.
  */
 bool
-LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
+LWLockWaitForVar(LWLock *lock, uint64 *valptr, uint64 oldval, uint64 *newval)
 {
-       volatile LWLock *lock = l;
-       volatile uint64 *valp = valptr;
        PGPROC     *proc = MyProc;
        int                     extraWaits = 0;
        bool            result = false;
@@ -938,7 +935,7 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
        PRINT_LWDEBUG("LWLockWaitForVar", lock);
 
 #ifdef LWLOCK_STATS
-       lwstats = get_lwlock_stats_entry(l);
+       lwstats = get_lwlock_stats_entry(lock);
 #endif   /* LWLOCK_STATS */
 
        /*
@@ -981,7 +978,7 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
                }
                else
                {
-                       value = *valp;
+                       value = *valptr;
                        if (value != oldval)
                        {
                                result = false;
@@ -1023,13 +1020,14 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
                 * so that the lock manager or signal manager will see the received
                 * signal when it next waits.
                 */
-               LOG_LWDEBUG("LWLockWaitForVar", T_NAME(l), T_ID(l), "waiting");
+               LOG_LWDEBUG("LWLockWaitForVar", T_NAME(lock), T_ID(lock), "waiting");
 
 #ifdef LWLOCK_STATS
                lwstats->block_count++;
 #endif
 
-               TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(l), T_ID(l), LW_EXCLUSIVE);
+               TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), T_ID(lock),
+                                                                                  LW_EXCLUSIVE);
 
                for (;;)
                {
@@ -1040,9 +1038,10 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
                        extraWaits++;
                }
 
-               TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(l), T_ID(l), LW_EXCLUSIVE);
+               TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), T_ID(lock),
+                                                                                 LW_EXCLUSIVE);
 
-               LOG_LWDEBUG("LWLockWaitForVar", T_NAME(l), T_ID(l), "awakened");
+               LOG_LWDEBUG("LWLockWaitForVar", T_NAME(lock), T_ID(lock), "awakened");
 
                /* Now loop back and check the status of the lock again. */
        }
@@ -1050,7 +1049,7 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
        /* We are done updating shared state of the lock itself. */
        SpinLockRelease(&lock->mutex);
 
-       TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(l), T_ID(l), LW_EXCLUSIVE);
+       TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(lock), T_ID(lock), LW_EXCLUSIVE);
 
        /*
         * Fix the process wait semaphore's count for any absorbed wakeups.
@@ -1078,10 +1077,8 @@ LWLockWaitForVar(LWLock *l, uint64 *valptr, uint64 oldval, uint64 *newval)
  * The caller must be holding the lock in exclusive mode.
  */
 void
-LWLockUpdateVar(LWLock *l, uint64 *valptr, uint64 val)
+LWLockUpdateVar(LWLock *lock, uint64 *valptr, uint64 val)
 {
-       volatile LWLock *lock = l;
-       volatile uint64 *valp = valptr;
        PGPROC     *head;
        PGPROC     *proc;
        PGPROC     *next;
@@ -1093,7 +1090,7 @@ LWLockUpdateVar(LWLock *l, uint64 *valptr, uint64 val)
        Assert(lock->exclusive == 1);
 
        /* Update the lock's value */
-       *valp = val;
+       *valptr = val;
 
        /*
         * See if there are any LW_WAIT_UNTIL_FREE waiters that need to be woken
@@ -1139,9 +1136,8 @@ LWLockUpdateVar(LWLock *l, uint64 *valptr, uint64 val)
  * LWLockRelease - release a previously acquired lock
  */
 void
-LWLockRelease(LWLock *l)
+LWLockRelease(LWLock *lock)
 {
-       volatile LWLock *lock = l;
        PGPROC     *head;
        PGPROC     *proc;
        int                     i;
@@ -1154,11 +1150,11 @@ LWLockRelease(LWLock *l)
         */
        for (i = num_held_lwlocks; --i >= 0;)
        {
-               if (l == held_lwlocks[i])
+               if (lock == held_lwlocks[i])
                        break;
        }
        if (i < 0)
-               elog(ERROR, "lock %s %d is not held", T_NAME(l), T_ID(l));
+               elog(ERROR, "lock %s %d is not held", T_NAME(lock), T_ID(lock));
        num_held_lwlocks--;
        for (; i < num_held_lwlocks; i++)
                held_lwlocks[i] = held_lwlocks[i + 1];
@@ -1238,14 +1234,15 @@ LWLockRelease(LWLock *l)
        /* We are done updating shared state of the lock itself. */
        SpinLockRelease(&lock->mutex);
 
-       TRACE_POSTGRESQL_LWLOCK_RELEASE(T_NAME(l), T_ID(l));
+       TRACE_POSTGRESQL_LWLOCK_RELEASE(T_NAME(lock), T_ID(lock));
 
        /*
         * Awaken any waiters I removed from the queue.
         */
        while (head != NULL)
        {
-               LOG_LWDEBUG("LWLockRelease", T_NAME(l), T_ID(l), "release waiter");
+               LOG_LWDEBUG("LWLockRelease", T_NAME(lock), T_ID(lock),
+                                       "release waiter");
                proc = head;
                head = proc->lwWaitLink;
                proc->lwWaitLink = NULL;