Use a boolean instead as thread's state
authorMarco Costalba <mcostalba@gmail.com>
Wed, 10 Aug 2011 11:12:10 +0000 (12:12 +0100)
committerMarco Costalba <mcostalba@gmail.com>
Wed, 10 Aug 2011 11:26:52 +0000 (12:26 +0100)
Now that we have just two mutually exclusive thread's states
we can repleace them by a simple boolean.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
src/search.cpp
src/thread.cpp
src/thread.h

index 65b128f5f0dce6a18133113e2f7ecf3954c3101d..0f2373cd28fd28838c1e79990c5d26349ae554a2 100644 (file)
@@ -2154,7 +2154,7 @@ void Thread::idle_loop(SplitPoint* sp) {
       // instead of wasting CPU time polling for work.
       while (   do_sleep
              || do_terminate
-             || (Threads.use_sleeping_threads() && state == Thread::AVAILABLE))
+             || (Threads.use_sleeping_threads() && !is_searching))
       {
           assert((!sp && threadID) || Threads.use_sleeping_threads());
 
@@ -2180,14 +2180,14 @@ void Thread::idle_loop(SplitPoint* sp) {
           // particular we need to avoid a deadlock in case a master thread has,
           // in the meanwhile, allocated us and sent the wake_up() call before we
           // had the chance to grab the lock.
-          if (do_sleep || state == Thread::AVAILABLE)
+          if (do_sleep || !is_searching)
               cond_wait(&sleepCond, &sleepLock);
 
           lock_release(&sleepLock);
       }
 
       // If this thread has been assigned work, launch a search
-      if (state == Thread::SEARCHING)
+      if (is_searching)
       {
           assert(!do_terminate);
 
@@ -2208,15 +2208,15 @@ void Thread::idle_loop(SplitPoint* sp) {
           else
               assert(false);
 
-          assert(state == Thread::SEARCHING);
+          assert(is_searching);
 
-          state = Thread::AVAILABLE;
+          is_searching = false;
 
           // Wake up 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.use_sleeping_threads()
               && threadID != tsp->master
-              && Threads[tsp->master].state == Thread::AVAILABLE)
+              && !Threads[tsp->master].is_searching)
               Threads[tsp->master].wake_up();
       }
 
index f620c71c69d2640de29e098ba904f68ddcadd023..8269dcf3d50029d2e4e355a8da8c345b48ddee80 100644 (file)
@@ -84,7 +84,7 @@ bool Thread::cutoff_occurred() const {
 
 bool Thread::is_available_to(int master) const {
 
-  if (state != AVAILABLE)
+  if (is_searching)
       return false;
 
   // Make a local copy to be sure doesn't become zero under our feet while
@@ -161,7 +161,7 @@ void ThreadsManager::init() {
   }
 
   // Initialize main thread's associated data
-  threads[0].state = Thread::SEARCHING;
+  threads[0].is_searching = true;
   threads[0].threadID = 0;
   set_size(1); // This makes all the threads but the main to go to sleep
 
@@ -169,7 +169,7 @@ void ThreadsManager::init() {
   // threads will go immediately to sleep.
   for (int i = 1; i < MAX_THREADS; i++)
   {
-      threads[i].state = Thread::AVAILABLE;
+      threads[i].is_searching = false;
       threads[i].threadID = i;
 
 #if defined(_MSC_VER)
@@ -286,7 +286,7 @@ Value ThreadsManager::split(Position& pos, SearchStack* ss, Value alpha, Value b
       sp->is_slave[i] = false;
 
   // If we are here it means we are not available
-  assert(masterThread.state == Thread::SEARCHING);
+  assert(masterThread.is_searching);
 
   int workersCnt = 1; // At least the master is included
 
@@ -303,7 +303,7 @@ Value ThreadsManager::split(Position& pos, SearchStack* ss, Value alpha, Value b
           threads[i].splitPoint = sp;
 
           // This makes the slave to exit from idle_loop()
-          threads[i].state = Thread::SEARCHING;
+          threads[i].is_searching = true;
 
           if (useSleepingThreads)
               threads[i].wake_up();
@@ -318,23 +318,23 @@ Value ThreadsManager::split(Position& pos, SearchStack* ss, Value alpha, Value b
   masterThread.splitPoint = sp;
   masterThread.activeSplitPoints++;
 
-  // 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
-  // loop when all threads have finished their work at this split point.
+  // Everything is set up. The master thread enters the idle loop, from which
+  // it will instantly launch a search, because its is_searching flag is set.
+  // We pass the split point as a parameter to the idle loop, which means that
+  // the thread will return from the idle loop when all slaves have finished
+  // their work at this split point.
   masterThread.idle_loop(sp);
 
   // In helpful master concept a master can help only a sub-tree, and
   // because here is all finished is not possible master is booked.
-  assert(masterThread.state == Thread::AVAILABLE);
+  assert(!masterThread.is_searching);
 
   // We have returned from the idle loop, which means that all threads are
   // finished. Note that changing state and decreasing activeSplitPoints is done
   // under lock protection to avoid a race with Thread::is_available_to().
   lock_grab(&threadsLock);
 
-  masterThread.state = Thread::SEARCHING;
+  masterThread.is_searching = true;
   masterThread.activeSplitPoints--;
 
   lock_release(&threadsLock);
index 8d3fd615bcb3fa089c0d072075cb3299b37a01a0..b7d426e25e8a14b05e30ed107ad73bf5829e6403 100644 (file)
@@ -65,12 +65,6 @@ struct SplitPoint {
 
 struct Thread {
 
-  enum ThreadState
-  {
-    AVAILABLE,     // Thread is waiting for work
-    SEARCHING      // Thread is performing work
-  };
-
   void wake_up();
   bool cutoff_occurred() const;
   bool is_available_to(int master) const;
@@ -83,9 +77,9 @@ struct Thread {
   int maxPly;
   Lock sleepLock;
   WaitCondition sleepCond;
-  volatile ThreadState state;
   SplitPoint* volatile splitPoint;
   volatile int activeSplitPoints;
+  volatile bool is_searching;
   volatile bool do_sleep;
   volatile bool do_terminate;