From d71f7070406bc018e3ca868461d77a90eaebfcbc Mon Sep 17 00:00:00 2001
From: Joona Kiiski <joona.kiiski@gmail.com>
Date: Thu, 12 Mar 2015 20:36:32 +0000
Subject: [PATCH] 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
---
 src/search.cpp |  4 ++--
 src/thread.cpp |  7 ++++---
 src/thread.h   | 16 +++++++++++++++-
 3 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/src/search.cpp b/src/search.cpp
index ca1fe49c..e0ba7938 100644
--- 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 d8740db2..007ed46e 100644
--- 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 4d70bf2f..8f930149 100644
--- 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;
 };
 
 
-- 
2.39.2