Retire Thread::BOOKED

Start a slave as soon as is allocated.

No functional change with faked split.

Regression tested the full split() series and after
2000 games no regression and no crash.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/thread.cpp b/src/thread.cpp
index 24fbebc0832521be170247f62f9462e76bbd86a2..f5bd50ea5cfa28ec157d3082ba440058c51189e5 100644 (file)
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -283,18 +283,23 @@ Value ThreadsManager::split(Position& pos, SearchStack* ss, Value alpha, Value b
 
   int workersCnt = 1; // At least the master is included
 
-  // Try to allocate available threads setting state to Thread::BOOKED, this
-  // must be done under lock protection to avoid concurrent allocation of
-  // the same slave by another master.
+  // Try to allocate available threads and ask them to start searching setting
+  // the state to Thread::WORKISWAITING, this must be done under lock protection
+  // to avoid concurrent allocation of the same slave by another master.
   lock_grab(&threadsLock);
 
   for (i = 0; !Fake && i < activeThreads && workersCnt < maxThreadsPerSplitPoint; i++)
       if (i != master && threads[i].is_available_to(master))
       {
-          threads[i].state = Thread::BOOKED;
-          threads[i].splitPoint = &splitPoint;
-          splitPoint.is_slave[i] = true;
           workersCnt++;
+          splitPoint.is_slave[i] = true;
+          threads[i].splitPoint = &splitPoint;
+
+          // This makes the slave to exit from idle_loop()
+          threads[i].state = Thread::WORKISWAITING;
+
+          if (useSleepingThreads)
+              threads[i].wake_up();
       }
 
   lock_release(&threadsLock);
@@ -303,27 +308,14 @@ Value ThreadsManager::split(Position& pos, SearchStack* ss, Value alpha, Value b
   if (!Fake && workersCnt == 1)
       return bestValue;
 
-  masterThread.activeSplitPoints++;
   masterThread.splitPoint = &splitPoint;
-
-  // Tell the threads that they have some work to do. This will make them leave
-  // their idle loop.
-  for (i = 0; i < activeThreads; i++)
-      if (i == master || splitPoint.is_slave[i])
-      {
-          assert(i == master || threads[i].state == Thread::BOOKED);
-
-          // This makes the slave to exit from idle_loop()
-          threads[i].state = Thread::WORKISWAITING;
-
-          if (useSleepingThreads && i != master)
-              threads[i].wake_up();
-      }
+  masterThread.activeSplitPoints++;
+  masterThread.state = Thread::WORKISWAITING;
 
   // Everything is set up. The master thread enters the idle loop, from
   // which it will instantly launch a search, because its state is
-  // THREAD_WORKISWAITING.  We send the split point as a second parameter to the
-  // idle loop, which means that the main thread will return from the idle
+  // Thread::WORKISWAITING. We send the split point as a second parameter to
+  // the idle loop, which means that the main thread will return from the idle
   // loop when all threads have finished their work at this split point.
   idle_loop(master, &splitPoint);
 

diff --git a/src/thread.h b/src/thread.h
index 6ee07d34668d6bcada9cfdd34473a96135c1d6e2..cdb0d9b8b2561509a6a820048aff5a8e874ce7c1 100644 (file)
--- a/src/thread.h
+++ b/src/thread.h
@@ -70,8 +70,7 @@ struct Thread {
     INITIALIZING,  // Thread is initializing itself
     SEARCHING,     // Thread is performing work
     AVAILABLE,     // Thread is waiting for work
-    BOOKED,        // Other thread (master) has booked us as a slave
-    WORKISWAITING, // Master has ordered us to start
+    WORKISWAITING, // Master has ordered us to start searching
     TERMINATED     // We are quitting and thread is terminated
   };