X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fthread.cpp;h=344cfb794782d7a559194ccf7007645c2bc63bd2;hp=60c0ce71c683b0f917a8b2e28535eb8ff2548b2f;hb=f5622cd5ec7836e899e263cc4cd4cc386e1ed5f4;hpb=a1a7bc84da4a6f180179e437494dd485cba1711d

diff --git a/src/thread.cpp b/src/thread.cpp
index 60c0ce71..344cfb79 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);
 }
 
 
@@ -181,20 +181,20 @@ void MainThread::idle_loop() {
 
 
 // init() is called at startup to create and launch requested threads, that will
-// go immediately to sleep due to 'sleepWhileIdle' set to true. We cannot use
-// a c'tor because Threads is a static object and we need a fully initialized
-// engine at this point due to allocation of Endgames in Thread c'tor.
+// go immediately to sleep. We cannot use a c'tor because Threads is a static
+// object and we need a fully initialized engine at this point due to allocation
+// of Endgames in Thread c'tor.
 
 void ThreadPool::init() {
 
-  sleepWhileIdle = true;
   timer = new_thread<TimerThread>();
   push_back(new_thread<MainThread>());
   read_uci_options();
 }
 
 
-// exit() cleanly terminates the threads before the program exits
+// exit() cleanly terminates the threads before the program exits. Cannot be done in
+// d'tor because we have to terminate the threads before to free ThreadPool object.
 
 void ThreadPool::exit() {
 
@@ -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;
@@ -292,45 +292,40 @@ void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Valu
   Threads.mutex.lock();
   sp.mutex.lock();
 
+  sp.allSlavesSearching = true; // Must be set under lock protection
   ++splitPointsSize;
   activeSplitPoint = &sp;
   activePosition = NULL;
 
-  int slavesCnt = 1; // This thread is always included
-  Thread* slave;
-
-  while (!Fake && (slave = Threads.available_slave(this)) != NULL)
-  {
-      ++slavesCnt;
-      sp.slavesMask |= 1ULL << slave->idx;
-      slave->activeSplitPoint = &sp;
-      slave->searching = true; // Slave leaves idle_loop()
-      slave->notify_one(); // Could be sleeping
-  }
+  if (!Fake)
+      for (Thread* slave; (slave = Threads.available_slave(this)) != NULL; )
+      {
+          sp.slavesMask.set(slave->idx);
+          slave->activeSplitPoint = &sp;
+          slave->searching = true; // Slave leaves idle_loop()
+          slave->notify_one(); // Could be sleeping
+      }
 
   // Everything is set up. The master thread enters the idle loop, from which
   // it will instantly launch a search, because its 'searching' flag is set.
   // The thread will return from the idle loop when all slaves have finished
   // their work at this split point.
-  if (slavesCnt > 1 || Fake)
-  {
-      sp.mutex.unlock();
-      Threads.mutex.unlock();
-
-      Thread::idle_loop(); // Force a call to base class idle_loop()
-
-      // In the helpful master concept, a master can help only a sub-tree of its
-      // split point and because everything is finished here, it's not possible
-      // for the master to be booked.
-      assert(!searching);
-      assert(!activePosition);
-
-      // We have returned from the idle loop, which means that all threads are
-      // finished. Note that setting 'searching' and decreasing splitPointsSize is
-      // done under lock protection to avoid a race with Thread::available_to().
-      Threads.mutex.lock();
-      sp.mutex.lock();
-  }
+  sp.mutex.unlock();
+  Threads.mutex.unlock();
+
+  Thread::idle_loop(); // Force a call to base class idle_loop()
+
+  // In the helpful master concept, a master can help only a sub-tree of its
+  // split point and because everything is finished here, it's not possible
+  // for the master to be booked.
+  assert(!searching);
+  assert(!activePosition);
+
+  // We have returned from the idle loop, which means that all threads are
+  // finished. Note that setting 'searching' and decreasing splitPointsSize is
+  // done under lock protection to avoid a race with Thread::available_to().
+  Threads.mutex.lock();
+  sp.mutex.lock();
 
   searching = true;
   --splitPointsSize;