Merge pull request #4 from per-framework/feature/using-atomic-wait-to-bail-out-of-spinning

Using atomic_wait & atomic_notify_all to bail out of spinning

Author: polytypic

README.md

@@ -1,7 +1,7 @@
 # [≡](#contents) [MCS.C++](#) [![Gitter](https://badges.gitter.im/per-framework/community.svg)](https://gitter.im/per-framework/community) [![Build Status](https://travis-ci.org/per-framework/mcs.cpp.svg?branch=v1)](https://travis-ci.org/per-framework/mcs.cpp) [![Code Coverage](https://img.shields.io/codecov/c/github/per-framework/mcs.cpp/v1.svg)](https://codecov.io/gh/per-framework/mcs.cpp/branch/v1)
 
-[MCS lock](http://web.mit.edu/6.173/www/currentsemester/readings/R06-scalable-synchronization-1991.pdf)
-implementation for C++.
+[MCS](http://web.mit.edu/6.173/www/currentsemester/readings/R06-scalable-synchronization-1991.pdf)
+based lock implementation for C++.
 
 See [`synopsis.hpp`](provides/include/mcs_v1/synopsis.hpp) for the API.
 

provides/include/mcs_v1/mcs.hpp

@@ -5,18 +5,19 @@
 
 #include "dumpster_v1/finally.hpp"
 
-inline void mcs_v1::lock::acquire(holder &holder) {
-  Private::acquire(*this, holder);
+inline void mcs_v1::lock::acquire(holder &holder, unsigned max_spin_count) {
+  Private::acquire(*this, holder, max_spin_count);
 }
 
 inline void mcs_v1::lock::release(holder &holder) {
   Private::release(*this, holder);
 }
 
 template <class Action>
-std::invoke_result_t<Action> mcs_v1::lock::holding(Action &&action) {
+std::invoke_result_t<Action> mcs_v1::lock::holding(Action &&action,
+                                                   unsigned max_spin_count) {
   holder holder;
-  acquire(holder);
+  acquire(holder, max_spin_count);
   auto releaser = dumpster::finally([&]() { release(holder); });
   return action();
 }

provides/include/mcs_v1/private.hpp

@@ -15,15 +15,17 @@ class Private {
   class holder_t;
   class lock_t;
 
-  static void acquire(lock_t &lock, holder_t &holder);
+  enum state_t : uint8_t { SPINNING, WAITING, RELEASED };
+
+  static void acquire(lock_t &lock, holder_t &holder, unsigned max_spin_count);
   static void release(lock_t &lock, holder_t &holder);
 };
 
 } // namespace mcs_v1
 
 class mcs_v1::Private::holder_t {
   friend class Private;
-  volatile bool *locked;
+  std::atomic<std::atomic<state_t> *> state;
 };
 
 class mcs_v1::Private::lock_t {

provides/include/mcs_v1/synopsis.hpp

@@ -31,17 +31,22 @@ struct lock : Private::lock_t {
   /// Locks are not CopyAssignable.
   lock &operator=(const lock &) = delete;
 
+  static constexpr unsigned default_max_spin_count = 1000;
+
   /// Acquires the lock.  The `holder` must be allocated by the caller, kept
   /// alive while the lock is held, and passed to `release` to release the lock.
   /// A unique holder per live acquire is required.
-  void acquire(holder &holder);
+  void acquire(holder &holder,
+               unsigned max_spin_count = default_max_spin_count);
 
   /// Releases the lock.  The `holder` must be the same instance that was passed
   /// in a matching call to `acquire`.
   void release(holder &holder);
 
   /// Invokes the action holding the lock.
-  template <class Action> std::invoke_result_t<Action> holding(Action &&action);
+  template <class Action>
+  std::invoke_result_t<Action>
+  holding(Action &&action, unsigned max_spin_count = default_max_spin_count);
 };
 
 } // namespace mcs_v1

provides/library/mcs.cpp

@@ -1,26 +1,40 @@
 #include "mcs_v1/mcs.hpp"
 
+#include "polyfill_v1/atomic.hpp"
+
 #include "intrinsics_v1/pause.hpp"
 
-void mcs_v1::Private::acquire(lock_t &lock, holder_t &holder) {
-  holder.locked = nullptr;
-  if (holder_t *predecessor = lock.tail.exchange(&holder)) {
-    volatile bool locked = true;
-    predecessor->locked = &locked;
-    do {
+void mcs_v1::Private::acquire(lock_t &lock,
+                              holder_t &holder,
+                              unsigned max_spin_count) {
+  holder.state.store(nullptr, std::memory_order_relaxed);
+  if (holder_t *predecessor =
+          lock.tail.exchange(&holder, std::memory_order_acquire)) {
+    std::atomic<state_t> state(SPINNING);
+    predecessor->state.store(&state, std::memory_order_release);
+    while (max_spin_count) {
       intrinsics_v1::pause();
-    } while (locked);
+      if (SPINNING != state.load(std::memory_order_acquire))
+        return;
+      max_spin_count -= 1;
+    }
+    if (SPINNING == state.exchange(WAITING, std::memory_order_acq_rel))
+      std::atomic_wait(&state, WAITING, std::memory_order_acquire);
   }
 }
 
 void mcs_v1::Private::release(lock_t &lock, holder_t &holder) {
   holder_t *pholder = &holder;
-  if (!holder.locked) {
-    if (lock.tail.compare_exchange_strong(pholder, nullptr))
+  std::atomic<state_t> *state = holder.state.load(std::memory_order_relaxed);
+  if (!state) {
+    if (lock.tail.compare_exchange_strong(
+            pholder, nullptr, std::memory_order_release))
       return;
     do {
       intrinsics_v1::pause();
-    } while (!holder.locked);
+      state = holder.state.load(std::memory_order_relaxed);
+    } while (!state);
   }
-  *holder.locked = false;
+  if (WAITING == state->exchange(RELEASED))
+    std::atomic_notify_all(state);
 }