Do not return from idle_loop() with lock held

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index 94c03619a39e8c818739316096f1acfc87b08574..17e54e4cd3cbedc32a9656f314fa8ac1514790f2 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -82,7 +82,7 @@ namespace {
     bool thread_should_stop(int threadID) const;
     void wake_sleeping_threads();
     void put_threads_to_sleep();
-    void idle_loop(int threadID, SplitPoint* waitSp);
+    void idle_loop(int threadID, SplitPoint* sp);
     bool split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue,
                Depth depth, bool mateThreat, int* moves, MovePicker* mp, int master, bool pvNode);
 
@@ -387,7 +387,7 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
       if (get_option_value_string("Book File") != OpeningBook.file_name())
           OpeningBook.open(get_option_value_string("Book File"));
 
-      Move bookMove = OpeningBook.get_move(pos);
+      Move bookMove = OpeningBook.get_move(pos, get_option_value_bool("Best Book Move"));
       if (bookMove != MOVE_NONE)
       {
           if (PonderSearch)
@@ -560,7 +560,7 @@ void init_search() {
       for (int j = 0; j < 64; j++) // j == moveNumber
       {
           // FIXME: test using log instead of BSR
-          FutilityMarginsMatrix[i][j] = (i < 2 ? 0 : 112 * bitScanReverse32(i * i / 2)) - 8 * j;
+          FutilityMarginsMatrix[i][j] = (i < 2 ? 0 : 112 * bitScanReverse32(i * i / 2)) - 8 * j + 45;
       }
 
   // Init futility move count array
@@ -1301,6 +1301,9 @@ namespace {
 
     if (tte && ok_to_use_TT(tte, depth, beta, ply))
     {
+        // Refresh tte entry to avoid aging
+        TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove);
+
         ss[ply].currentMove = ttMove; // Can be MOVE_NONE
         return value_from_tt(tte->value(), ply);
     }
@@ -1379,18 +1382,13 @@ namespace {
             if (nullValue >= value_mate_in(PLY_MAX))
                 nullValue = beta;
 
-            // Do zugzwang verification search for high depths, don't store in TT
-            // if search was stopped.
-            if (   (   depth < 6 * OnePly
-                    || search(pos, ss, beta, depth-5*OnePly, ply, false, threadID) >= beta)
-                && !AbortSearch
-                && !TM.thread_should_stop(threadID))
-            {
-                assert(value_to_tt(nullValue, ply) == nullValue);
+            if (depth < 6 * OnePly)
+                return nullValue;
 
-                TT.store(posKey, nullValue, VALUE_TYPE_LOWER, depth, MOVE_NONE);
+            // Do zugzwang verification search
+            Value v = search(pos, ss, beta, depth-5*OnePly, ply, false, threadID);
+            if (v >= beta)
                 return nullValue;
-            }
         } else {
             // The null move failed low, which means that we may be faced with
             // some kind of threat. If the previous move was reduced, check if
@@ -1485,7 +1483,7 @@ namespace {
           // Value based pruning
           Depth predictedDepth = newDepth - nonpv_reduction(depth, moveCount); // We illogically ignore reduction condition depth >= 3*OnePly
           futilityValueScaled =  ss[ply].eval + futility_margin(predictedDepth, moveCount)
-                               + H.gain(pos.piece_on(move_from(move)), move_to(move)) + 45;
+                               + H.gain(pos.piece_on(move_from(move)), move_to(move));
 
           if (futilityValueScaled < beta)
           {
@@ -1666,7 +1664,7 @@ namespace {
         alpha = bestValue;
 
     // If we are near beta then try to get a cutoff pushing checks a bit further
-    bool deepChecks = depth == -OnePly && staticValue >= beta - PawnValueMidgame / 8;
+    bool deepChecks = (depth == -OnePly && staticValue >= beta - PawnValueMidgame / 8);
 
     // Initialize a MovePicker object for the current position, and prepare
     // to search the moves. Because the depth is <= 0 here, only captures,
@@ -1712,7 +1710,7 @@ namespace {
 
       // Detect blocking evasions that are candidate to be pruned
       evasionPrunable =   isCheck
-                       && bestValue != -VALUE_INFINITE
+                       && bestValue > value_mated_in(PLY_MAX)
                        && !pos.move_is_capture(move)
                        && pos.type_of_piece_on(move_from(move)) != KING
                        && !pos.can_castle(pos.side_to_move());
@@ -1843,7 +1841,7 @@ namespace {
           // Value based pruning
           Depth predictedDepth = newDepth - nonpv_reduction(sp->depth, moveCount);
           futilityValueScaled =  ss[sp->ply].eval + futility_margin(predictedDepth, moveCount)
-                                     + H.gain(pos.piece_on(move_from(move)), move_to(move)) + 45;
+                               + H.gain(pos.piece_on(move_from(move)), move_to(move));
 
           if (futilityValueScaled < sp->beta)
           {
@@ -2638,10 +2636,10 @@ namespace {
 
 
   // idle_loop() is where the threads are parked when they have no work to do.
-  // The parameter "waitSp", if non-NULL, is a pointer to an active SplitPoint
+  // The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint
   // object for which the current thread is the master.
 
-  void ThreadsManager::idle_loop(int threadID, SplitPoint* waitSp) {
+  void ThreadsManager::idle_loop(int threadID, SplitPoint* sp) {
 
     assert(threadID >= 0 && threadID < MAX_THREADS);
 
@@ -2651,7 +2649,7 @@ namespace {
         // master should exit as last one.
         if (AllThreadsShouldExit)
         {
-            assert(!waitSp);
+            assert(!sp);
             threads[threadID].state = THREAD_TERMINATED;
             return;
         }
@@ -2660,7 +2658,7 @@ namespace {
         // instead of wasting CPU time polling for work.
         while (AllThreadsShouldSleep || threadID >= ActiveThreads)
         {
-            assert(!waitSp);
+            assert(!sp);
             assert(threadID != 0);
             threads[threadID].state = THREAD_SLEEPING;
 
@@ -2697,8 +2695,13 @@ namespace {
 
         // If this thread is the master of a split point and all threads have
         // finished their work at this split point, return from the idle loop.
-        if (waitSp != NULL && waitSp->cpus == 0)
+        if (sp && sp->cpus == 0)
         {
+            // Because sp->cpus is decremented under lock protection,
+            // be sure sp->lock has been released before to proceed.
+            lock_grab(&(sp->lock));
+            lock_release(&(sp->lock));
+
             assert(threads[threadID].state == THREAD_AVAILABLE);
 
             threads[threadID].state = THREAD_SEARCHING;
@@ -2769,7 +2772,7 @@ namespace {
         }
 
         // Wait until the thread has finished launching and is gone to sleep
-        while (threads[i].state != THREAD_SLEEPING);
+        while (threads[i].state != THREAD_SLEEPING) {}
     }
   }
 
@@ -2810,7 +2813,7 @@ namespace {
 
     SplitPoint* sp;
 
-    for (sp = threads[threadID].splitPoint; sp && !sp->stopRequest; sp = sp->parent);
+    for (sp = threads[threadID].splitPoint; sp && !sp->stopRequest; sp = sp->parent) {}
     return sp != NULL;
   }