Introduce yielding spin locks

Idea and original implementation by Stephane Nicolet

7 threads 15+0.05
ELO: 3.54 +-2.9 (95%) LOS: 99.2%
Total: 17971 W: 2976 L: 2793 D: 12202

There is no functional change in single thread mode

diff --git a/src/search.cpp b/src/search.cpp
index ca1fe49c5fb700a2ad5955a0efa80c9d18b13e48..e0ba79380c3ecbce68f2431ceeb4952e2383f970 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -1696,7 +1696,7 @@ void Thread::idle_loop() {
               if (   sp->allSlavesSearching
                   && sp->slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT)
               {
-                  mutex.lock();
+                  allocMutex.lock();
 
                   if (can_join(sp))
                   {
@@ -1705,7 +1705,7 @@ void Thread::idle_loop() {
                       searching = true;
                   }
 
-                  mutex.unlock();
+                  allocMutex.unlock();
               }
 
               sp->mutex.unlock();

diff --git a/src/thread.cpp b/src/thread.cpp
index d8740db2a66c39f04e49171cc7991e7d0e75b4f8..007ed46e10c54bb85e12955f835b3ba6c8d79ede 100644 (file)
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -174,17 +174,18 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes
   while (    sp.slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT
          && (slave = Threads.available_slave(&sp)) != nullptr)
   {
-     slave->mutex.lock();
+     slave->allocMutex.lock();
 
       if (slave->can_join(activeSplitPoint))
       {
           activeSplitPoint->slavesMask.set(slave->idx);
           slave->activeSplitPoint = activeSplitPoint;
           slave->searching = true;
-          slave->sleepCondition.notify_one(); // Could be sleeping
       }
 
-      slave->mutex.unlock();
+      slave->allocMutex.unlock();
+
+      slave->notify_one(); // Could be sleeping
   }
 
   // Everything is set up. The master thread enters the idle loop, from which

diff --git a/src/thread.h b/src/thread.h
index 4d70bf2fbd038a9da98971c04c1bada7ba523743..8f930149f333e764d3525fc9d93fd8f4dba3798b 100644 (file)
--- a/src/thread.h
+++ b/src/thread.h
@@ -40,6 +40,19 @@ const size_t MAX_THREADS = 128;
 const size_t MAX_SPLITPOINTS_PER_THREAD = 8;
 const size_t MAX_SLAVES_PER_SPLITPOINT = 4;
 
+class Spinlock {
+  std::atomic_int _lock;
+
+public:
+  Spinlock() { _lock = 1; } // Init here to workaround a bug with MSVC 2013
+  void lock() {
+      while (_lock.fetch_sub(1, std::memory_order_acquire) != 1)
+          for (int cnt = 0; _lock.load(std::memory_order_relaxed) <= 0; ++cnt)
+              if (cnt >= 10000) std::this_thread::yield(); // Be nice to hyperthreading
+  }
+  void unlock() { _lock.store(1, std::memory_order_release); }
+};
+
 
 /// SplitPoint struct stores information shared by the threads searching in
 /// parallel below the same split point. It is populated at splitting time.
@@ -60,7 +73,7 @@ struct SplitPoint {
   SplitPoint* parentSplitPoint;
 
   // Shared variable data
-  Mutex mutex;
+  Spinlock mutex;
   std::bitset<MAX_THREADS> slavesMask;
   volatile bool allSlavesSearching;
   volatile uint64_t nodes;
@@ -114,6 +127,7 @@ struct Thread : public ThreadBase {
   SplitPoint* volatile activeSplitPoint;
   volatile size_t splitPointsSize;
   volatile bool searching;
+  Spinlock allocMutex;
 };