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

diff --git a/src/thread.cpp b/src/thread.cpp
index 60c0ce71..ca87e1dd 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -23,7 +23,7 @@
 #include "movegen.h"
 #include "search.h"
 #include "thread.h"
-#include "ucioption.h"
+#include "uci.h"
 
 using namespace Search;
 
@@ -69,12 +69,12 @@ void ThreadBase::notify_one() {
 }
 
 
-// wait_for() set the thread to sleep until condition 'b' turns true
+// wait_for() set the thread to sleep until 'condition' turns true
 
-void ThreadBase::wait_for(volatile const bool& b) {
+void ThreadBase::wait_for(volatile const bool& condition) {
 
   mutex.lock();
-  while (!b) sleepCondition.wait(mutex);
+  while (!condition) sleepCondition.wait(mutex);
   mutex.unlock();
 }
 
@@ -119,11 +119,11 @@ bool Thread::available_to(const Thread* master) const {
 
   // Make a local copy to be sure it doesn't become zero under our feet while
   // testing next condition and so leading to an out of bounds access.
-  int size = splitPointsSize;
+  const int size = splitPointsSize;
 
   // 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() {
 
@@ -255,8 +255,7 @@ Thread* ThreadPool::available_slave(const Thread* master) const {
 // leave their idle loops and call search(). When all threads have returned from
 // search() then split() returns.
 
-template <bool Fake>
-void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Value* bestValue,
+void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bestValue,
                    Move* bestMove, Depth depth, int moveCount,
                    MovePicker* movePicker, int nodeType, bool cutNode) {
 
@@ -271,7 +270,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,17 +291,14 @@ 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)
+  for (Thread* slave; (slave = Threads.available_slave(this)) != NULL; )
   {
-      ++slavesCnt;
-      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
@@ -312,25 +308,22 @@ void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Valu
   // 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;
@@ -344,19 +337,14 @@ void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Valu
   Threads.mutex.unlock();
 }
 
-// Explicit template instantiations
-template void Thread::split<false>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, int, MovePicker*, int, bool);
-template void Thread::split< true>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, int, MovePicker*, int, bool);
-
-
 // wait_for_think_finished() waits for main thread to go to sleep then returns
 
 void ThreadPool::wait_for_think_finished() {
 
-  MainThread* t = main();
-  t->mutex.lock();
-  while (t->thinking) sleepCondition.wait(t->mutex);
-  t->mutex.unlock();
+  MainThread* th = main();
+  th->mutex.lock();
+  while (th->thinking) sleepCondition.wait(th->mutex);
+  th->mutex.unlock();
 }