X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fthread.cpp;h=4fa081482ffab4144de201a4fd56014e25c1be19;hp=457a92780ced8cb17348516c2d8fc69e6b5b6334;hb=6a48325c49dfd58a0226b2085cd9419531d5ec1e;hpb=b1cf1acb93532248fb10c2ca983d80389d5aeb84

diff --git a/src/thread.cpp b/src/thread.cpp
index 457a9278..4fa08148 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -141,7 +141,7 @@ void Thread::wait_for_stop_or_ponderhit() {
 
 bool Thread::cutoff_occurred() const {
 
-  for (SplitPoint* sp = splitPoint; sp; sp = sp->parent)
+  for (SplitPoint* sp = curSplitPoint; sp; sp = sp->parent)
       if (sp->cutoff)
           return true;
 
@@ -163,24 +163,22 @@ bool Thread::is_available_to(int master) const {
 
   // Make a local copy to be sure doesn't become zero under our feet while
   // testing next condition and so leading to an out of bound access.
-  int sp_count = activeSplitPoints;
+  int spCnt = splitPointsCnt;
 
   // No active split points means that the thread is available as a slave for any
   // other thread otherwise apply the "helpful master" concept if possible.
-  return !sp_count || (splitPoints[sp_count - 1].slavesMask & (1ULL << master));
+  return !spCnt || (splitPoints[spCnt - 1].slavesMask & (1ULL << master));
 }
 
 
-// read_uci_options() updates number of active threads and other parameters
-// according to the UCI options values. It is called before to start a new search.
+// read_uci_options() updates internal threads parameters from the corresponding
+// UCI options. It is called before to start a new search.
 
 void ThreadsManager::read_uci_options() {
 
   maxThreadsPerSplitPoint = Options["Max Threads per Split Point"];
   minimumSplitDepth       = Options["Min Split Depth"] * ONE_PLY;
   useSleepingThreads      = Options["Use Sleeping Threads"];
-
-  set_size(Options["Threads"]);
 }
 
 
@@ -189,11 +187,11 @@ void ThreadsManager::read_uci_options() {
 
 void ThreadsManager::set_size(int cnt) {
 
-  assert(cnt > 0 && cnt <= MAX_THREADS);
+  assert(cnt > 0 && cnt < MAX_THREADS);
 
   activeThreads = cnt;
 
-  for (int i = 1; i < MAX_THREADS; i++) // Ignore main thread
+  for (int i = 0; i < MAX_THREADS; i++)
       if (i < activeThreads)
       {
           // Dynamically allocate pawn and material hash tables according to the
@@ -201,8 +199,12 @@ void ThreadsManager::set_size(int cnt) {
           // possible threads if only few are used.
           threads[i].pawnTable.init();
           threads[i].materialTable.init();
+          threads[i].maxPly = 0;
 
           threads[i].do_sleep = false;
+
+          if (!useSleepingThreads)
+              threads[i].wake_up();
       }
       else
           threads[i].do_sleep = true;
@@ -222,7 +224,7 @@ void ThreadsManager::init() {
       lock_init(threads[i].sleepLock);
       cond_init(threads[i].sleepCond);
 
-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
+      for (int j = 0; j < MAX_SPLITPOINTS_PER_THREAD; j++)
           lock_init(threads[i].splitPoints[j].lock);
   }
 
@@ -262,7 +264,7 @@ void ThreadsManager::exit() {
       lock_destroy(threads[i].sleepLock);
       cond_destroy(threads[i].sleepCond);
 
-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
+      for (int j = 0; j < MAX_SPLITPOINTS_PER_THREAD; j++)
           lock_destroy(threads[i].splitPoints[j].lock);
   }
 
@@ -311,13 +313,13 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
   int master = pos.thread();
   Thread& masterThread = threads[master];
 
-  if (masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS)
+  if (masterThread.splitPointsCnt >= MAX_SPLITPOINTS_PER_THREAD)
       return bestValue;
 
   // Pick the next available split point from the split point stack
-  SplitPoint* sp = &masterThread.splitPoints[masterThread.activeSplitPoints];
+  SplitPoint* sp = &masterThread.splitPoints[masterThread.splitPointsCnt++];
 
-  sp->parent = masterThread.splitPoint;
+  sp->parent = masterThread.curSplitPoint;
   sp->master = master;
   sp->cutoff = false;
   sp->slavesMask = 1ULL << master;
@@ -335,6 +337,7 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
 
   assert(masterThread.is_searching);
 
+  masterThread.curSplitPoint = sp;
   int slavesCnt = 0;
 
   // Try to allocate available threads and ask them to start searching setting
@@ -347,7 +350,7 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
       if (threads[i].is_available_to(master))
       {
           sp->slavesMask |= 1ULL << i;
-          threads[i].splitPoint = sp;
+          threads[i].curSplitPoint = sp;
           threads[i].is_searching = true; // Slave leaves idle_loop()
 
           if (useSleepingThreads)
@@ -357,9 +360,6 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
               break;
       }
 
-  masterThread.splitPoint = sp;
-  masterThread.activeSplitPoints++;
-
   lock_release(splitLock);
   lock_release(sp->lock);
 
@@ -369,17 +369,23 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
   // the thread will return from the idle loop when all slaves have finished
   // their work at this split point.
   if (slavesCnt || Fake)
+  {
       masterThread.idle_loop(sp);
 
+      // In helpful master concept a master can help only a sub-tree of its split
+      // point, and because here is all finished is not possible master is booked.
+      assert(!masterThread.is_searching);
+  }
+
   // We have returned from the idle loop, which means that all threads are
-  // finished. Note that setting is_searching and decreasing activeSplitPoints is
+  // finished. Note that setting is_searching and decreasing splitPointsCnt is
   // done under lock protection to avoid a race with Thread::is_available_to().
   lock_grab(sp->lock); // To protect sp->nodes
   lock_grab(splitLock);
 
   masterThread.is_searching = true;
-  masterThread.activeSplitPoints--;
-  masterThread.splitPoint = sp->parent;
+  masterThread.splitPointsCnt--;
+  masterThread.curSplitPoint = sp->parent;
   pos.set_nodes_searched(pos.nodes_searched() + sp->nodes);
 
   lock_release(splitLock);