Avoid research in case thread has already been asked to stop

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index 11299121ba2435a4d1631df85616e22e779f7521..670ab1511f5b51c085a4bad8df2e7a62b2a7b032 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -442,9 +442,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
   // Wake up sleeping threads
   TM.wake_sleeping_threads();
 
-  for (int i = 1; i < TM.active_threads(); i++)
-      assert(TM.thread_is_available(i, 0));
-
   // Set thinking time
   int myTime = time[side_to_move];
   int myIncrement = increment[side_to_move];
@@ -1838,7 +1835,7 @@ namespace {
           if (ss[sp->ply].reduction)
           {
               value = -search(pos, ss, -(sp->beta-1), newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
-              doFullDepthSearch = (value >= sp->beta);
+              doFullDepthSearch = (value >= sp->beta && !TM.thread_should_stop(threadID));
           }
       }
 
@@ -1935,7 +1932,7 @@ namespace {
           {
               Value localAlpha = sp->alpha;
               value = -search(pos, ss, -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
-              doFullDepthSearch = (value > localAlpha);
+              doFullDepthSearch = (value > localAlpha && !TM.thread_should_stop(threadID));
           }
       }
 
@@ -1945,16 +1942,14 @@ namespace {
           ss[sp->ply].reduction = Depth(0);
           value = -search(pos, ss, -localAlpha, newDepth, sp->ply+1, true, threadID);
 
-          if (value > localAlpha && value < sp->beta)
+          if (value > localAlpha && value < sp->beta && !TM.thread_should_stop(threadID))
           {
               // If another thread has failed high then sp->alpha has been increased
               // to be higher or equal then beta, if so, avoid to start a PV search.
               localAlpha = sp->alpha;
               if (localAlpha < sp->beta)
                   value = -search_pv(pos, ss, -sp->beta, -localAlpha, newDepth, sp->ply+1, threadID);
-              else
-                  assert(TM.thread_should_stop(threadID));
-        }
+          }
       }
       pos.undo_move(move);
 
@@ -2586,35 +2581,39 @@ namespace {
     {
         // Slave threads can exit as soon as AllThreadsShouldExit raises,
         // master should exit as last one.
-        if (AllThreadsShouldExit && !waitSp)
+        if (AllThreadsShouldExit)
         {
+            assert(!waitSp);
             threads[threadID].state = THREAD_TERMINATED;
             return;
         }
 
         // If we are not thinking, wait for a condition to be signaled
         // instead of wasting CPU time polling for work.
-        while (    threadID != 0
-               && !AllThreadsShouldExit
-               && (AllThreadsShouldSleep || threadID >= ActiveThreads))
+        while (AllThreadsShouldSleep || threadID >= ActiveThreads)
         {
+            assert(!waitSp);
+            assert(threadID != 0);
             threads[threadID].state = THREAD_SLEEPING;
 
 #if !defined(_MSC_VER)
             pthread_mutex_lock(&WaitLock);
-            pthread_cond_wait(&WaitCond, &WaitLock);
+            if (AllThreadsShouldSleep || threadID >= ActiveThreads)
+                pthread_cond_wait(&WaitCond, &WaitLock);
             pthread_mutex_unlock(&WaitLock);
 #else
             WaitForSingleObject(SitIdleEvent[threadID], INFINITE);
 #endif
-            // State is already changed by wake_sleeping_threads()
-            assert(threads[threadID].state == THREAD_AVAILABLE || threadID >= ActiveThreads);
         }
 
+        // If thread has just woken up, mark it as available
+        if (threads[threadID].state == THREAD_SLEEPING)
+            threads[threadID].state = THREAD_AVAILABLE;
+
         // If this thread has been assigned work, launch a search
         if (threads[threadID].state == THREAD_WORKISWAITING)
         {
-            assert(!AllThreadsShouldExit);
+            assert(!AllThreadsShouldExit && !AllThreadsShouldSleep);
 
             threads[threadID].state = THREAD_SEARCHING;
 
@@ -2632,8 +2631,7 @@ namespace {
         // finished their work at this split point, return from the idle loop.
         if (waitSp != NULL && waitSp->cpus == 0)
         {
-            assert(   threads[threadID].state == THREAD_AVAILABLE
-                   || threads[threadID].state == THREAD_SEARCHING);
+            assert(threads[threadID].state == THREAD_AVAILABLE);
 
             threads[threadID].state = THREAD_SEARCHING;
             return;
@@ -2821,9 +2819,11 @@ namespace {
     assert(p.is_ok());
     assert(sstck != NULL);
     assert(ply >= 0 && ply < PLY_MAX);
-    assert(*bestValue >= -VALUE_INFINITE && *bestValue <= *alpha);
-    assert(!pvNode || *alpha < *beta);
-    assert(*beta <= VALUE_INFINITE);
+    assert(*bestValue >= -VALUE_INFINITE);
+    assert(   ( pvNode && *bestValue <= *alpha)
+           || (!pvNode && *bestValue <   beta ));
+    assert(!pvNode || *alpha < beta);
+    assert(beta <= VALUE_INFINITE);
     assert(depth > Depth(0));
     assert(master >= 0 && master < ActiveThreads);
     assert(ActiveThreads > 1);
@@ -2934,12 +2934,8 @@ namespace {
         return;
 
     for (int i = 1; i < ActiveThreads; i++)
-    {
         assert(threads[i].state == THREAD_SLEEPING);
 
-        threads[i].state = THREAD_AVAILABLE;
-    }
-
 #if !defined(_MSC_VER)
     pthread_mutex_lock(&WaitLock);
     pthread_cond_broadcast(&WaitCond);
@@ -2963,12 +2959,9 @@ namespace {
     // This makes the threads to go to sleep
     AllThreadsShouldSleep = true;
 
-    // Wait for the threads to be all sleeping and reset flags
-    // to a known state.
+    // Reset flags to a known state.
     for (int i = 1; i < ActiveThreads; i++)
     {
-        while (threads[i].state != THREAD_SLEEPING);
-
         // This flag can be in a random state
         threads[i].printCurrentLineRequest = false;
     }