Micro optimize LWLockAttemptLock() a bit.

LWLockAttemptLock pointlessly read the lock's state in every loop
iteration, even though pg_atomic_compare_exchange_u32() returns the old
value. Instead do that only once before the loop iteration.

Additionally there's no need to have the expected_state variable,
old_state mostly had the same value anyway.

Noticed-By: Heikki Linnakangas
Backpatch: 9.5, no reason to let the branches diverge at this point

diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c
index ae03eb14196c80fec7a0d042da94726a4a2e2b65..687ed6399cb19ed3183bb75a0214b57229e05675 100644 (file)
--- a/src/backend/storage/lmgr/lwlock.c
+++ b/src/backend/storage/lmgr/lwlock.c
@@ -582,29 +582,33 @@ LWLockInitialize(LWLock *lock, int tranche_id)
 static bool
 LWLockAttemptLock(LWLock *lock, LWLockMode mode)
 {
+       uint32          old_state;
+
        AssertArg(mode == LW_EXCLUSIVE || mode == LW_SHARED);
 
+       /*
+        * Read once outside the loop, later iterations will get the newer value
+        * via compare & exchange.
+        */
+       old_state = pg_atomic_read_u32(&lock->state);
+
        /* loop until we've determined whether we could acquire the lock or not */
        while (true)
        {
-               uint32          old_state;
-               uint32          expected_state;
                uint32          desired_state;
                bool            lock_free;
 
-               old_state = pg_atomic_read_u32(&lock->state);
-               expected_state = old_state;
-               desired_state = expected_state;
+               desired_state = old_state;
 
                if (mode == LW_EXCLUSIVE)
                {
-                       lock_free = (expected_state & LW_LOCK_MASK) == 0;
+                       lock_free = (old_state & LW_LOCK_MASK) == 0;
                        if (lock_free)
                                desired_state += LW_VAL_EXCLUSIVE;
                }
                else
                {
-                       lock_free = (expected_state & LW_VAL_EXCLUSIVE) == 0;
+                       lock_free = (old_state & LW_VAL_EXCLUSIVE) == 0;
                        if (lock_free)
                                desired_state += LW_VAL_SHARED;
                }
@@ -620,7 +624,7 @@ LWLockAttemptLock(LWLock *lock, LWLockMode mode)
                 * Retry if the value changed since we last looked at it.
                 */
                if (pg_atomic_compare_exchange_u32(&lock->state,
-                                                                                  &expected_state, desired_state))
+                                                                                  &old_state, desired_state))
                {
                        if (lock_free)
                        {