From aab5863dd42da0a8e493a2ffaca96319b3d19ebb Mon Sep 17 00:00:00 2001
From: Marco Costalba <mcostalba@gmail.com>
Date: Tue, 18 Mar 2014 12:07:26 +0100
Subject: [PATCH] Increase max threads to 128

Thanks to std::bitset we can easily increase
the limit of active threads above 64.

Thanks to Lucas Braesch for pointing at the
correct solution of using std::bitset.

No functional change.
---
 src/search.cpp | 21 +++++++++------------
 src/thread.cpp |  6 +++---
 src/thread.h   |  5 +++--
 3 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/src/search.cpp b/src/search.cpp
index 421d95fe..ccf3b56d 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -1470,7 +1470,7 @@ void Thread::idle_loop() {
           mutex.lock();
 
           // If we are master and all slaves have finished then exit idle_loop
-          if (this_sp && !this_sp->slavesMask)
+          if (this_sp && this_sp->slavesMask.none())
           {
               mutex.unlock();
               break;
@@ -1529,14 +1529,14 @@ void Thread::idle_loop() {
 
           searching = false;
           activePosition = NULL;
-          sp->slavesMask &= ~(1ULL << idx);
+          sp->slavesMask.reset(idx);
           sp->nodes += pos.nodes_searched();
 
           // Wake up the master thread so to allow it to return from the idle
           // loop in case we are the last slave of the split point.
           if (    Threads.sleepWhileIdle
               &&  this != sp->masterThread
-              && !sp->slavesMask)
+              &&  sp->slavesMask.none())
           {
               assert(!sp->masterThread->searching);
               sp->masterThread->notify_one();
@@ -1551,10 +1551,10 @@ void Thread::idle_loop() {
 
       // If this thread is the master of a split point and all slaves have finished
       // their work at this split point, return from the idle loop.
-      if (this_sp && !this_sp->slavesMask)
+      if (this_sp && this_sp->slavesMask.none())
       {
           this_sp->mutex.lock();
-          bool finished = !this_sp->slavesMask; // Retest under lock protection
+          bool finished = this_sp->slavesMask.none(); // Retest under lock protection
           this_sp->mutex.unlock();
           if (finished)
               return;
@@ -1597,13 +1597,10 @@ void check_time() {
               sp.mutex.lock();
 
               nodes += sp.nodes;
-              Bitboard sm = sp.slavesMask;
-              while (sm)
-              {
-                  Position* pos = Threads[pop_lsb(&sm)]->activePosition;
-                  if (pos)
-                      nodes += pos->nodes_searched();
-              }
+
+              for (size_t idx = 0; idx < Threads.size(); ++idx)
+                  if (sp.slavesMask.test(idx) && Threads[idx]->activePosition)
+                      nodes += Threads[idx]->activePosition->nodes_searched();
 
               sp.mutex.unlock();
           }
diff --git a/src/thread.cpp b/src/thread.cpp
index cdc94ee0..432d573d 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -123,7 +123,7 @@ bool Thread::available_to(const Thread* master) const {
 
   // No split points means that the thread is available as a slave for any
   // other thread otherwise apply the "helpful master" concept if possible.
-  return !size || (splitPoints[size - 1].slavesMask & (1ULL << master->idx));
+  return !size || splitPoints[size - 1].slavesMask.test(master->idx);
 }
 
 
@@ -271,7 +271,7 @@ void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Valu
 
   sp.masterThread = this;
   sp.parentSplitPoint = activeSplitPoint;
-  sp.slavesMask = 1ULL << idx;
+  sp.slavesMask = 0, sp.slavesMask.set(idx);
   sp.depth = depth;
   sp.bestValue = *bestValue;
   sp.bestMove = *bestMove;
@@ -299,7 +299,7 @@ void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Valu
   if (!Fake)
       for (Thread* slave; (slave = Threads.available_slave(this)) != NULL; )
       {
-          sp.slavesMask |= 1ULL << slave->idx;
+          sp.slavesMask.set(slave->idx);
           slave->activeSplitPoint = &sp;
           slave->searching = true; // Slave leaves idle_loop()
           slave->notify_one(); // Could be sleeping
diff --git a/src/thread.h b/src/thread.h
index ddeb4902..046980d2 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -20,6 +20,7 @@
 #ifndef THREAD_H_INCLUDED
 #define THREAD_H_INCLUDED
 
+#include <bitset>
 #include <vector>
 
 #include "material.h"
@@ -28,7 +29,7 @@
 #include "position.h"
 #include "search.h"
 
-const int MAX_THREADS = 64; // Because SplitPoint::slavesMask is a uint64_t
+const int MAX_THREADS = 128;
 const int MAX_SPLITPOINTS_PER_THREAD = 8;
 
 struct Mutex {
@@ -75,7 +76,7 @@ struct SplitPoint {
 
   // Shared data
   Mutex mutex;
-  volatile uint64_t slavesMask;
+  std::bitset<MAX_THREADS> slavesMask;
   volatile uint64_t nodes;
   volatile Value alpha;
   volatile Value bestValue;
-- 
2.39.2