performance: Address maintainer feedback on shared_mutex spin loops and update copyright

arpittkhandelwal · arpittkhandelwal · commit 6acdd90a6397 · 2026-04-16T08:00:52.000+05:30
diff --git a/libs/core/synchronization/include/hpx/synchronization/shared_mutex.hpp b/libs/core/synchronization/include/hpx/synchronization/shared_mutex.hpp
@@ -121,9 +121,9 @@ namespace hpx::detail {
 
         bool try_lock_shared()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 if (s.data.exclusive || s.data.exclusive_waiting_blocked)
                 {
                     return false;
@@ -136,6 +136,7 @@ namespace hpx::detail {
                 {
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
             return true;
         }
@@ -163,9 +164,9 @@ namespace hpx::detail {
 
         void unlock_shared()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 auto s1 = s;
 
                 if (--s.data.shared_count == 0)
@@ -205,14 +206,15 @@ namespace hpx::detail {
                 {
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
         }
 
         void lock()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 while (s.data.shared_count != 0 || s.data.exclusive)
                 {
                     auto s1 = s;
@@ -235,14 +237,15 @@ namespace hpx::detail {
                 {
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
         }
 
         bool try_lock()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 if (s.data.shared_count || s.data.exclusive)
                 {
                     return false;
@@ -255,15 +258,16 @@ namespace hpx::detail {
                 {
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
             return true;
         }
 
         void unlock()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 auto s1 = s;
 
                 s.data.exclusive = false;
@@ -276,6 +280,7 @@ namespace hpx::detail {
                     release_waiters(lk);
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
         }
 
@@ -308,9 +313,9 @@ namespace hpx::detail {
 
         bool try_lock_upgrade()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 if (s.data.exclusive || s.data.exclusive_waiting_blocked ||
                     s.data.upgrade)
                 {
@@ -325,15 +330,16 @@ namespace hpx::detail {
                 {
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
             return true;
         }
 
         void unlock_upgrade()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 auto s1 = s;
 
                 bool release = false;
@@ -358,6 +364,7 @@ namespace hpx::detail {
                 {
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
         }
 
@@ -405,9 +412,9 @@ namespace hpx::detail {
 
         void unlock_and_lock_upgrade()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 auto s1 = s;
 
                 s.data.exclusive = false;
@@ -422,14 +429,15 @@ namespace hpx::detail {
                     release_waiters(lk);
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
         }
 
         void unlock_and_lock_shared()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 auto s1 = s;
 
                 s.data.exclusive = false;
@@ -443,14 +451,15 @@ namespace hpx::detail {
                     release_waiters(lk);
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
         }
 
         bool try_unlock_shared_and_lock()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 if (s.data.exclusive || s.data.exclusive_waiting_blocked ||
                     s.data.upgrade || s.data.shared_count != 1)
                 {
@@ -465,15 +474,16 @@ namespace hpx::detail {
                 {
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
             return true;
         }
 
         void unlock_upgrade_and_lock_shared()
         {
+            auto s = state.load(std::memory_order_acquire);
             while (true)
             {
-                auto s = state.load(std::memory_order_acquire);
                 auto s1 = s;
 
                 s.data.exclusive_waiting_blocked = false;
@@ -486,6 +496,7 @@ namespace hpx::detail {
                     release_waiters(lk);
                     break;
                 }
+                s = state.load(std::memory_order_acquire);
             }
         }
 
diff --git a/tests/performance/local/shared_mutex_overhead.cpp b/tests/performance/local/shared_mutex_overhead.cpp
@@ -1,4 +1,4 @@
-//  (C) Copyright 2024 Arpit Khandelwal
+//  (C) Copyright 2026 Arpit Khandelwal
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying

Original file line number	Diff line number	Diff line change
`@@ -121,9 +121,9 @@ namespace hpx::detail {`
`121`	`121`
`122`	`122`	`bool try_lock_shared()`
`123`	`123`	`{`
	`124`	`+ auto s = state.load(std::memory_order_acquire);`
`124`	`125`	`while (true)`
`125`	`126`	`{`
`126`		`- auto s = state.load(std::memory_order_acquire);`
`127`	`127`	`if (s.data.exclusive \|\| s.data.exclusive_waiting_blocked)`
`128`	`128`	`{`
`129`	`129`	`return false;`
`@@ -136,6 +136,7 @@ namespace hpx::detail {`
`136`	`136`	`{`
`137`	`137`	`break;`
`138`	`138`	`}`
	`139`	`+ s = state.load(std::memory_order_acquire);`
`139`	`140`	`}`
`140`	`141`	`return true;`
`141`	`142`	`}`
`@@ -163,9 +164,9 @@ namespace hpx::detail {`
`163`	`164`
`164`	`165`	`void unlock_shared()`
`165`	`166`	`{`
	`167`	`+ auto s = state.load(std::memory_order_acquire);`
`166`	`168`	`while (true)`
`167`	`169`	`{`
`168`		`- auto s = state.load(std::memory_order_acquire);`
`169`	`170`	`auto s1 = s;`
`170`	`171`
`171`	`172`	`if (--s.data.shared_count == 0)`
`@@ -205,14 +206,15 @@ namespace hpx::detail {`
`205`	`206`	`{`
`206`	`207`	`break;`
`207`	`208`	`}`
	`209`	`+ s = state.load(std::memory_order_acquire);`
`208`	`210`	`}`
`209`	`211`	`}`
`210`	`212`
`211`	`213`	`void lock()`
`212`	`214`	`{`
	`215`	`+ auto s = state.load(std::memory_order_acquire);`
`213`	`216`	`while (true)`
`214`	`217`	`{`
`215`		`- auto s = state.load(std::memory_order_acquire);`
`216`	`218`	`while (s.data.shared_count != 0 \|\| s.data.exclusive)`
`217`	`219`	`{`
`218`	`220`	`auto s1 = s;`
`@@ -235,14 +237,15 @@ namespace hpx::detail {`
`235`	`237`	`{`
`236`	`238`	`break;`
`237`	`239`	`}`
	`240`	`+ s = state.load(std::memory_order_acquire);`
`238`	`241`	`}`
`239`	`242`	`}`
`240`	`243`
`241`	`244`	`bool try_lock()`
`242`	`245`	`{`
	`246`	`+ auto s = state.load(std::memory_order_acquire);`
`243`	`247`	`while (true)`
`244`	`248`	`{`
`245`		`- auto s = state.load(std::memory_order_acquire);`
`246`	`249`	`if (s.data.shared_count \|\| s.data.exclusive)`
`247`	`250`	`{`
`248`	`251`	`return false;`
`@@ -255,15 +258,16 @@ namespace hpx::detail {`
`255`	`258`	`{`
`256`	`259`	`break;`
`257`	`260`	`}`
	`261`	`+ s = state.load(std::memory_order_acquire);`
`258`	`262`	`}`
`259`	`263`	`return true;`
`260`	`264`	`}`
`261`	`265`
`262`	`266`	`void unlock()`
`263`	`267`	`{`
	`268`	`+ auto s = state.load(std::memory_order_acquire);`
`264`	`269`	`while (true)`
`265`	`270`	`{`
`266`		`- auto s = state.load(std::memory_order_acquire);`
`267`	`271`	`auto s1 = s;`
`268`	`272`
`269`	`273`	`s.data.exclusive = false;`
`@@ -276,6 +280,7 @@ namespace hpx::detail {`
`276`	`280`	`release_waiters(lk);`
`277`	`281`	`break;`
`278`	`282`	`}`
	`283`	`+ s = state.load(std::memory_order_acquire);`
`279`	`284`	`}`
`280`	`285`	`}`
`281`	`286`
`@@ -308,9 +313,9 @@ namespace hpx::detail {`
`308`	`313`
`309`	`314`	`bool try_lock_upgrade()`
`310`	`315`	`{`
	`316`	`+ auto s = state.load(std::memory_order_acquire);`
`311`	`317`	`while (true)`
`312`	`318`	`{`
`313`		`- auto s = state.load(std::memory_order_acquire);`
`314`	`319`	`if (s.data.exclusive \|\| s.data.exclusive_waiting_blocked \|\|`
`315`	`320`	`s.data.upgrade)`
`316`	`321`	`{`
`@@ -325,15 +330,16 @@ namespace hpx::detail {`
`325`	`330`	`{`
`326`	`331`	`break;`
`327`	`332`	`}`
	`333`	`+ s = state.load(std::memory_order_acquire);`
`328`	`334`	`}`
`329`	`335`	`return true;`
`330`	`336`	`}`
`331`	`337`
`332`	`338`	`void unlock_upgrade()`
`333`	`339`	`{`
	`340`	`+ auto s = state.load(std::memory_order_acquire);`
`334`	`341`	`while (true)`
`335`	`342`	`{`
`336`		`- auto s = state.load(std::memory_order_acquire);`
`337`	`343`	`auto s1 = s;`
`338`	`344`
`339`	`345`	`bool release = false;`
`@@ -358,6 +364,7 @@ namespace hpx::detail {`
`358`	`364`	`{`
`359`	`365`	`break;`
`360`	`366`	`}`
	`367`	`+ s = state.load(std::memory_order_acquire);`
`361`	`368`	`}`
`362`	`369`	`}`
`363`	`370`
`@@ -405,9 +412,9 @@ namespace hpx::detail {`
`405`	`412`
`406`	`413`	`void unlock_and_lock_upgrade()`
`407`	`414`	`{`
	`415`	`+ auto s = state.load(std::memory_order_acquire);`
`408`	`416`	`while (true)`
`409`	`417`	`{`
`410`		`- auto s = state.load(std::memory_order_acquire);`
`411`	`418`	`auto s1 = s;`
`412`	`419`
`413`	`420`	`s.data.exclusive = false;`
`@@ -422,14 +429,15 @@ namespace hpx::detail {`
`422`	`429`	`release_waiters(lk);`
`423`	`430`	`break;`
`424`	`431`	`}`
	`432`	`+ s = state.load(std::memory_order_acquire);`
`425`	`433`	`}`
`426`	`434`	`}`
`427`	`435`
`428`	`436`	`void unlock_and_lock_shared()`
`429`	`437`	`{`
	`438`	`+ auto s = state.load(std::memory_order_acquire);`
`430`	`439`	`while (true)`
`431`	`440`	`{`
`432`		`- auto s = state.load(std::memory_order_acquire);`
`433`	`441`	`auto s1 = s;`
`434`	`442`
`435`	`443`	`s.data.exclusive = false;`
`@@ -443,14 +451,15 @@ namespace hpx::detail {`
`443`	`451`	`release_waiters(lk);`
`444`	`452`	`break;`
`445`	`453`	`}`
	`454`	`+ s = state.load(std::memory_order_acquire);`
`446`	`455`	`}`
`447`	`456`	`}`
`448`	`457`
`449`	`458`	`bool try_unlock_shared_and_lock()`
`450`	`459`	`{`
	`460`	`+ auto s = state.load(std::memory_order_acquire);`
`451`	`461`	`while (true)`
`452`	`462`	`{`
`453`		`- auto s = state.load(std::memory_order_acquire);`
`454`	`463`	`if (s.data.exclusive \|\| s.data.exclusive_waiting_blocked \|\|`
`455`	`464`	`s.data.upgrade \|\| s.data.shared_count != 1)`
`456`	`465`	`{`
`@@ -465,15 +474,16 @@ namespace hpx::detail {`
`465`	`474`	`{`
`466`	`475`	`break;`
`467`	`476`	`}`
	`477`	`+ s = state.load(std::memory_order_acquire);`
`468`	`478`	`}`
`469`	`479`	`return true;`
`470`	`480`	`}`
`471`	`481`
`472`	`482`	`void unlock_upgrade_and_lock_shared()`
`473`	`483`	`{`
	`484`	`+ auto s = state.load(std::memory_order_acquire);`
`474`	`485`	`while (true)`
`475`	`486`	`{`
`476`		`- auto s = state.load(std::memory_order_acquire);`
`477`	`487`	`auto s1 = s;`
`478`	`488`
`479`	`489`	`s.data.exclusive_waiting_blocked = false;`
`@@ -486,6 +496,7 @@ namespace hpx::detail {`
`486`	`496`	`release_waiters(lk);`
`487`	`497`	`break;`
`488`	`498`	`}`
	`499`	`+ s = state.load(std::memory_order_acquire);`
`489`	`500`	`}`
`490`	`501`	`}`
`491`	`502`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// (C) Copyright 2024 Arpit Khandelwal`
	`1`	`+// (C) Copyright 2026 Arpit Khandelwal`
`2`	`2`	`//`
`3`	`3`	`// SPDX-License-Identifier: BSL-1.0`
`4`	`4`	`// Distributed under the Boost Software License, Version 1.0. (See accompanying`