Don't wake up /sleep threads in think() anymore

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index f955f96d4180e10f6467f0ee29c24a23b81fbb23..29d022added67563087a207714086d02c45b50fe 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -83,7 +83,6 @@ namespace {
     bool thread_is_available(int slave, int master) const;
     bool thread_should_stop(int threadID) const;
     void wake_sleeping_thread(int threadID);
-    void put_threads_to_sleep();
     void idle_loop(int threadID, SplitPoint* sp);
 
     template <bool Fake>
@@ -94,9 +93,9 @@ namespace {
     friend void poll();
 
     int ActiveThreads;
-    volatile bool AllThreadsShouldExit, AllThreadsShouldSleep;
+    volatile bool AllThreadsShouldExit;
     Thread threads[MAX_THREADS];
-    Lock MPLock, WaitLock;
+    Lock MPLock;
     WaitCondition WaitCond[MAX_THREADS];
   };
 
@@ -465,10 +464,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr
       init_eval(ThreadsMgr.active_threads());
   }
 
-  // Wake up needed threads
-  for (int i = 1; i < newActiveThreads; i++)
-      ThreadsMgr.wake_sleeping_thread(i);
-
   // Set thinking time
   int myTime = time[pos.side_to_move()];
   int myIncrement = increment[pos.side_to_move()];
@@ -501,8 +496,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr
   if (UseLogFile)
       LogFile.close();
 
-  ThreadsMgr.put_threads_to_sleep();
-
   return !Quit;
 }
 
@@ -2224,30 +2217,37 @@ split_point_start: // At split points actual search starts from here
 
         // If we are not thinking, wait for a condition to be signaled
         // instead of wasting CPU time polling for work.
-        while (AllThreadsShouldSleep || threadID >= ActiveThreads)
+        while (   threadID >= ActiveThreads
+               || threads[threadID].state == THREAD_INITIALIZING
+               || (!sp && threads[threadID].state == THREAD_AVAILABLE))
         {
             assert(!sp);
             assert(threadID != 0);
-            threads[threadID].state = THREAD_SLEEPING;
 
-#if !defined(_MSC_VER)
-            lock_grab(&WaitLock);
-            if (AllThreadsShouldSleep || threadID >= ActiveThreads)
-                pthread_cond_wait(&WaitCond[threadID], &WaitLock);
-            lock_release(&WaitLock);
-#else
-            WaitForSingleObject(WaitCond[threadID], INFINITE);
-#endif
-        }
+            if (AllThreadsShouldExit)
+                break;
 
-        // If thread has just woken up, mark it as available
-        if (threads[threadID].state == THREAD_SLEEPING)
+            lock_grab(&MPLock);
+
+            // Retest condition under lock protection
+            if (!(   threadID >= ActiveThreads
+                  || threads[threadID].state == THREAD_INITIALIZING
+                  || (!sp && threads[threadID].state == THREAD_AVAILABLE)))
+            {
+                lock_release(&MPLock);
+                continue;
+            }
+
+            // Put thread to sleep
             threads[threadID].state = THREAD_AVAILABLE;
+            cond_wait(&WaitCond[threadID], &MPLock);
+            lock_release(&MPLock);
+        }
 
         // If this thread has been assigned work, launch a search
         if (threads[threadID].state == THREAD_WORKISWAITING)
         {
-            assert(!AllThreadsShouldExit && !AllThreadsShouldSleep);
+            assert(!AllThreadsShouldExit);
 
             threads[threadID].state = THREAD_SEARCHING;
 
@@ -2301,14 +2301,9 @@ split_point_start: // At split points actual search starts from here
 
     // Initialize global locks
     lock_init(&MPLock);
-    lock_init(&WaitLock);
 
     for (i = 0; i < MAX_THREADS; i++)
-#if !defined(_MSC_VER)
-        pthread_cond_init(&WaitCond[i], NULL);
-#else
-        WaitCond[i] = CreateEvent(0, FALSE, FALSE, 0);
-#endif
+        cond_init(&WaitCond[i]);
 
     // Initialize splitPoints[] locks
     for (i = 0; i < MAX_THREADS; i++)
@@ -2318,14 +2313,13 @@ split_point_start: // At split points actual search starts from here
     // Will be set just before program exits to properly end the threads
     AllThreadsShouldExit = false;
 
-    // Threads will be put to sleep as soon as created
-    AllThreadsShouldSleep = true;
-
-    // All threads except the main thread should be initialized to THREAD_AVAILABLE
+    // Threads will be put all threads to sleep as soon as created
     ActiveThreads = 1;
+
+    // All threads except the main thread should be initialized to THREAD_INITIALIZING
     threads[0].state = THREAD_SEARCHING;
     for (i = 1; i < MAX_THREADS; i++)
-        threads[i].state = THREAD_AVAILABLE;
+        threads[i].state = THREAD_INITIALIZING;
 
     // Launch the helper threads
     for (i = 1; i < MAX_THREADS; i++)
@@ -2345,7 +2339,7 @@ split_point_start: // At split points actual search starts from here
         }
 
         // Wait until the thread has finished launching and is gone to sleep
-        while (threads[i].state != THREAD_SLEEPING) {}
+        while (threads[i].state == THREAD_INITIALIZING) {}
     }
   }
 
@@ -2356,7 +2350,6 @@ split_point_start: // At split points actual search starts from here
   void ThreadsManager::exit_threads() {
 
     AllThreadsShouldExit = true; // Let the woken up threads to exit idle_loop()
-    ActiveThreads = MAX_THREADS; // Avoid any woken up thread comes back to sleep
 
     // Wake up all the threads and waits for termination
     for (int i = 1; i < MAX_THREADS; i++)
@@ -2370,7 +2363,6 @@ split_point_start: // At split points actual search starts from here
         for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
             lock_destroy(&(threads[i].splitPoints[j].lock));
 
-    lock_destroy(&WaitLock);
     lock_destroy(&MPLock);
 
     // Now we can safely destroy the wait conditions
@@ -2536,6 +2528,8 @@ split_point_start: // At split points actual search starts from here
             assert(i == master || threads[i].state == THREAD_BOOKED);
 
             threads[i].state = THREAD_WORKISWAITING; // This makes the slave to exit from idle_loop()
+            if (i != master)
+                wake_sleeping_thread(i);
         }
 
     // Everything is set up. The master thread enters the idle loop, from
@@ -2563,33 +2557,12 @@ split_point_start: // At split points actual search starts from here
 
   void ThreadsManager::wake_sleeping_thread(int threadID) {
 
-    assert(threadID > 0);
-    assert(threads[threadID].state == THREAD_SLEEPING);
-
-    AllThreadsShouldSleep = false; // Avoid the woken up thread comes back to sleep
-
-#if !defined(_MSC_VER)
-        pthread_mutex_lock(&WaitLock);
-        pthread_cond_signal(&WaitCond[threadID]);
-        pthread_mutex_unlock(&WaitLock);
-#else
-        SetEvent(WaitCond[threadID]);
-#endif
+     lock_grab(&MPLock);
+     cond_signal(&WaitCond[threadID]);
+     lock_release(&MPLock);
   }
 
 
-  // put_threads_to_sleep() makes all the threads go to sleep just before
-  // to leave think(), at the end of the search. Threads should have already
-  // finished the job and should be idle.
-
-  void ThreadsManager::put_threads_to_sleep() {
-
-    assert(!AllThreadsShouldSleep || ActiveThreads == 1);
-
-    // This makes the threads to go to sleep
-    AllThreadsShouldSleep = true;
-  }
-
   /// The RootMoveList class
 
   // RootMoveList c'tor