X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=f981664dbb9255fd2efb75c7ef13b11e3d90e112;hp=16f73d47bdee8ba3f5feedff584ba11aa5461900;hb=7bcd97933a20b649964bf96eb840a6190e777428;hpb=195b54c31228027756b381af80137936dcabd194

diff --git a/src/search.cpp b/src/search.cpp
index 16f73d47..f981664d 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -72,7 +72,6 @@ namespace {
     void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; }
     void incrementNodeCounter(int threadID) { threads[threadID].nodes++; }
     void incrementBetaCounter(Color us, Depth d, int threadID) { threads[threadID].betaCutOffs[us] += unsigned(d); }
-    void print_current_line(SearchStack ss[], int ply, int threadID);
 
     void resetNodeCounters();
     void resetBetaCounters();
@@ -85,17 +84,17 @@ namespace {
     void put_threads_to_sleep();
     void idle_loop(int threadID, SplitPoint* waitSp);
     bool split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue,
-               const Value futilityValue, Depth depth, int* moves, MovePicker* mp, int master, bool pvNode);
+               Depth depth, int* moves, MovePicker* mp, int master, bool pvNode);
 
   private:
-    friend void poll();
+    friend void poll(SearchStack ss[], int ply);
 
     int ActiveThreads;
     volatile bool AllThreadsShouldExit, AllThreadsShouldSleep;
     Thread threads[MAX_THREADS];
     SplitPoint SplitPointStack[MAX_THREADS][ACTIVE_SPLIT_POINTS_MAX];
 
-    Lock MPLock, IOLock;
+    Lock MPLock;
 
 #if !defined(_MSC_VER)
     pthread_cond_t WaitCond;
@@ -288,7 +287,7 @@ namespace {
 
   int current_search_time();
   int nps();
-  void poll();
+  void poll(SearchStack ss[], int ply);
   void ponderhit();
   void wait_for_stop_or_ponderhit();
   void init_ss_array(SearchStack ss[]);
@@ -1052,37 +1051,50 @@ namespace {
     if (depth < OnePly)
         return qsearch(pos, ss, alpha, beta, Depth(0), ply, threadID);
 
-    // Initialize, and make an early exit in case of an aborted search,
-    // an instant draw, maximum ply reached, etc.
+    // Step 1. Initialize node and poll
+    // Polling can abort search.
     init_node(ss, ply, threadID);
 
-    // After init_node() that calls poll()
+    // Step 2. Check for aborted search and immediate draw
     if (AbortSearch || TM.thread_should_stop(threadID))
         return Value(0);
 
     if (pos.is_draw() || ply >= PLY_MAX - 1)
         return VALUE_DRAW;
 
-    // Mate distance pruning
+    // Step 3. Mate distance pruning
     oldAlpha = alpha;
     alpha = Max(value_mated_in(ply), alpha);
     beta = Min(value_mate_in(ply+1), beta);
     if (alpha >= beta)
         return alpha;
 
-    // Transposition table lookup. At PV nodes, we don't use the TT for
-    // pruning, but only for move ordering. This is to avoid problems in
-    // the following areas:
+    // Step 4. Transposition table lookup
+    // At PV nodes, we don't use the TT for pruning, but only for move ordering.
+    // This is to avoid problems in the following areas:
     //
     // * Repetition draw detection
     // * Fifty move rule detection
     // * Searching for a mate
     // * Printing of full PV line
-    //
     tte = TT.retrieve(pos.get_key());
     ttMove = (tte ? tte->move() : MOVE_NONE);
 
-    // Go with internal iterative deepening if we don't have a TT move
+    // Step 5. Evaluate the position statically
+    // At PV nodes we do this only to update gain statistics
+    isCheck = pos.is_check();
+    if (!isCheck)
+    {
+        EvalInfo ei;
+        ss[ply].eval = evaluate(pos, ei, threadID);
+        update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
+    }
+
+    // Step 6. Razoring (is omitted in PV nodes)
+    // Step 7. Static null move pruning (is omitted in PV nodes)
+    // Step 8. Null move search with verification search (is omitted in PV nodes)
+
+    // Step 9. Internal iterative deepening
     if (   UseIIDAtPVNodes
         && depth >= 5*OnePly
         && ttMove == MOVE_NONE)
@@ -1092,24 +1104,14 @@ namespace {
         tte = TT.retrieve(pos.get_key());
     }
 
-    isCheck = pos.is_check();
-    if (!isCheck)
-    {
-        // Update gain statistics of the previous move that lead
-        // us in this position.
-        EvalInfo ei;
-        ss[ply].eval = evaluate(pos, ei, threadID);
-        update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
-    }
+    // Step 10. Loop through moves
+    // Loop through all legal moves until no moves remain or a beta cutoff occurs
 
-    // Initialize a MovePicker object for the current position, and prepare
-    // to search all moves
+    // Initialize a MovePicker object for the current position
     mateThreat = pos.has_mate_threat(opposite_color(pos.side_to_move()));
-    CheckInfo ci(pos);
     MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
+    CheckInfo ci(pos);
 
-    // Loop through all legal moves until no moves remain or a beta cutoff
-    // occurs.
     while (   alpha < beta
            && (move = mp.get_next_move()) != MOVE_NONE
            && !TM.thread_should_stop(threadID))
@@ -1120,7 +1122,7 @@ namespace {
       moveIsCheck = pos.move_is_check(move, ci);
       captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
-      // Decide the new search depth
+      // Step 11. Decide the new search depth
       ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, singleEvasion, mateThreat, &dangerous);
 
       // Singular extension search. We extend the TT move if its value is much better than
@@ -1146,17 +1148,21 @@ namespace {
 
       newDepth = depth - OnePly + ext;
 
-      // Update current move
+      // Update current move (this must be done after singular extension search)
       movesSearched[moveCount++] = ss[ply].currentMove = move;
 
-      // Make and search the move
+      // Step 12. Futility pruning (is omitted in PV nodes)
+
+      // Step 13. Make the move
       pos.do_move(move, st, ci, moveIsCheck);
 
-      if (moveCount == 1) // The first move in list is the PV
+      // Step extra. pv search (only in PV nodes)
+      // The first move in list is the expected PV
+      if (moveCount == 1)
           value = -search_pv(pos, ss, -beta, -alpha, newDepth, ply+1, threadID);
       else
       {
-        // Try to reduce non-pv search depth by one ply if move seems not problematic,
+        // Step 14. Reduced search
         // if the move fails high will be re-searched at full depth.
         bool doFullDepthSearch = true;
 
@@ -1174,19 +1180,24 @@ namespace {
             }
         }
 
-        if (doFullDepthSearch) // Go with full depth non-pv search
+        // Step 15. Full depth search
+        if (doFullDepthSearch)
         {
             ss[ply].reduction = Depth(0);
             value = -search(pos, ss, -alpha, newDepth, ply+1, true, threadID);
+
+            // Step extra. pv search (only in PV nodes)
             if (value > alpha && value < beta)
                 value = -search_pv(pos, ss, -beta, -alpha, newDepth, ply+1, threadID);
         }
       }
+
+      // Step 16. Undo move
       pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
-      // New best move?
+      // Step 17. Check for new best move
       if (value > bestValue)
       {
           bestValue = value;
@@ -1199,7 +1210,7 @@ namespace {
           }
       }
 
-      // Split?
+      // Step 18. Check for split
       if (   TM.active_threads() > 1
           && bestValue < beta
           && depth >= MinimumSplitDepth
@@ -1207,16 +1218,18 @@ namespace {
           && TM.available_thread_exists(threadID)
           && !AbortSearch
           && !TM.thread_should_stop(threadID)
-          && TM.split(pos, ss, ply, &alpha, beta, &bestValue, VALUE_NONE,
+          && TM.split(pos, ss, ply, &alpha, beta, &bestValue,
                       depth, &moveCount, &mp, threadID, true))
           break;
     }
 
-    // All legal moves have been searched.  A special case: If there were
+    // Step 19. Check for mate and stalemate
+    // All legal moves have been searched and if there were
     // no legal moves, it must be mate or stalemate.
     if (moveCount == 0)
         return (isCheck ? value_mated_in(ply) : VALUE_DRAW);
 
+    // Step 20. Update tables
     // If the search is not aborted, update the transposition table,
     // history counters, and killer moves.
     if (AbortSearch || TM.thread_should_stop(threadID))
@@ -1258,11 +1271,11 @@ namespace {
     const TTEntry* tte;
     Move ttMove, move;
     Depth ext, newDepth;
-    Value bestValue, staticValue, nullValue, value, futilityValue, futilityValueScaled;
+    Value bestValue, refinedValue, nullValue, value, futilityValueScaled;
     bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
     int moveCount = 0;
-    futilityValue = staticValue = bestValue = value = -VALUE_INFINITE;
+    refinedValue = bestValue = value = -VALUE_INFINITE;
 
     if (depth < OnePly)
         return qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
@@ -1288,7 +1301,7 @@ namespace {
     // Step 4. Transposition table lookup
 
     // We don't want the score of a partial search to overwrite a previous full search
-    // TT value, so we use a different position key in case of an excluded move exsists.
+    // TT value, so we use a different position key in case of an excluded move exists.
     Key posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key();
 
     tte = TT.retrieve(posKey);
@@ -1306,13 +1319,11 @@ namespace {
     if (!isCheck)
     {
         if (tte && (tte->type() & VALUE_TYPE_EVAL))
-            staticValue = value_from_tt(tte->value(), ply);
+            ss[ply].eval = value_from_tt(tte->value(), ply);
         else
-            staticValue = evaluate(pos, ei, threadID);
+            ss[ply].eval = evaluate(pos, ei, threadID);
 
-        ss[ply].eval = staticValue;
-        futilityValue = staticValue + futility_margin(depth, 0); //FIXME: Remove me, only for split
-        staticValue = refine_eval(tte, staticValue, ply); // Enhance accuracy with TT value if possible
+        refinedValue = refine_eval(tte, ss[ply].eval, ply); // Enhance accuracy with TT value if possible
         update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
     }
 
@@ -1320,7 +1331,7 @@ namespace {
     if (   !value_is_mate(beta)
         && !isCheck
         && depth < RazorDepth
-        && staticValue < beta - (0x200 + 16 * depth)
+        && refinedValue < beta - (0x200 + 16 * depth)
         && ss[ply - 1].currentMove != MOVE_NULL
         && ttMove == MOVE_NONE
         && !pos.has_pawn_on_7th(pos.side_to_move()))
@@ -1337,8 +1348,8 @@ namespace {
     if (  !isCheck
         && allowNullmove
         && depth < RazorDepth
-        && staticValue - futility_margin(depth, 0) >= beta)
-        return staticValue - futility_margin(depth, 0);
+        && refinedValue - futility_margin(depth, 0) >= beta)
+        return refinedValue - futility_margin(depth, 0);
 
     // Step 8. Null move search with verification search
     // When we jump directly to qsearch() we do a null move only if static value is
@@ -1349,7 +1360,7 @@ namespace {
         && !isCheck
         && !value_is_mate(beta)
         &&  ok_to_do_nullmove(pos)
-        &&  staticValue >= beta - (depth >= 4 * OnePly ? NullMoveMargin : 0))
+        &&  refinedValue >= beta - (depth >= 4 * OnePly ? NullMoveMargin : 0))
     {
         ss[ply].currentMove = MOVE_NULL;
 
@@ -1359,7 +1370,7 @@ namespace {
         int R = 3 + (depth >= 5 * OnePly ? depth / 8 : 0);
 
         // Null move dynamic reduction based on value
-        if (staticValue - beta > PawnValueMidgame)
+        if (refinedValue - beta > PawnValueMidgame)
             R++;
 
         nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
@@ -1402,12 +1413,13 @@ namespace {
         tte = TT.retrieve(posKey);
     }
 
-    // Initialize a MovePicker object for the current position, and prepare
-    // to search all moves.
+    // Step 10. Loop through moves
+    // Loop through all legal moves until no moves remain or a beta cutoff occurs
+
+    // Initialize a MovePicker object for the current position
     MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
     CheckInfo ci(pos);
 
-    // Loop through all legal moves until no moves remain or a beta cutoff occurs
     while (   bestValue < beta
            && (move = mp.get_next_move()) != MOVE_NONE
            && !TM.thread_should_stop(threadID))
@@ -1421,7 +1433,7 @@ namespace {
       singleEvasion = (isCheck && mp.number_of_evasions() == 1);
       captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
-      // Decide the new search depth
+      // Step 11. Decide the new search depth
       ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, singleEvasion, mateThreat, &dangerous);
 
       // Singular extension search. We extend the TT move if its value is much better than
@@ -1448,10 +1460,10 @@ namespace {
 
       newDepth = depth - OnePly + ext;
 
-      // Update current move
+      // Update current move (this must be done after singular extension search)
       movesSearched[moveCount++] = ss[ply].currentMove = move;
 
-      // Futility pruning
+      // Step 12. Futility pruning
       if (   !isCheck
           && !dangerous
           && !captureOrPromotion
@@ -1477,10 +1489,10 @@ namespace {
           }
       }
 
-      // Make and search the move
+      // Step 13. Make the move
       pos.do_move(move, st, ci, moveIsCheck);
 
-      // Try to reduce non-pv search depth by one ply if move seems not problematic,
+      // Step 14. Reduced search
       // if the move fails high will be re-searched at full depth.
       bool doFullDepthSearch = true;
 
@@ -1498,16 +1510,19 @@ namespace {
           }
       }
 
-      if (doFullDepthSearch) // Go with full depth non-pv search
+      // Step 15. Full depth search
+      if (doFullDepthSearch)
       {
           ss[ply].reduction = Depth(0);
           value = -search(pos, ss, -(beta-1), newDepth, ply+1, true, threadID);
       }
+
+      // Step 16. Undo move
       pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
-      // New best move?
+      // Step 17. Check for new best move
       if (value > bestValue)
       {
           bestValue = value;
@@ -1518,7 +1533,7 @@ namespace {
               ss[ply].mateKiller = move;
       }
 
-      // Split?
+      // Step 18. Check for split
       if (   TM.active_threads() > 1
           && bestValue < beta
           && depth >= MinimumSplitDepth
@@ -1526,16 +1541,19 @@ namespace {
           && TM.available_thread_exists(threadID)
           && !AbortSearch
           && !TM.thread_should_stop(threadID)
-          && TM.split(pos, ss, ply, NULL, beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue
+          && TM.split(pos, ss, ply, NULL, beta, &bestValue,
                       depth, &moveCount, &mp, threadID, false))
           break;
     }
 
-    // All legal moves have been searched. A special case: If there were
+    // Step 19. Check for mate and stalemate
+    // All legal moves have been searched and if there were
     // no legal moves, it must be mate or stalemate.
+    // If one move was excluded return fail low.
     if (!moveCount)
         return excludedMove ? beta - 1 : (pos.is_check() ? value_mated_in(ply) : VALUE_DRAW);
 
+    // Step 20. Update tables
     // If the search is not aborted, update the transposition table,
     // history counters, and killer moves.
     if (AbortSearch || TM.thread_should_stop(threadID))
@@ -1769,15 +1787,17 @@ namespace {
     Position pos(*sp->pos);
     CheckInfo ci(pos);
     SearchStack* ss = sp->sstack[threadID];
+    StateInfo st;
     Value value = -VALUE_INFINITE;
     Move move;
     int moveCount;
     bool isCheck = pos.is_check();
-    bool useFutilityPruning =     sp->depth < 7 * OnePly //FIXME: sync with search
-                              && !isCheck;
 
-    while (    lock_grab_bool(&(sp->lock))
-           &&  sp->bestValue < sp->beta
+    // Step 10. Loop through moves
+    // Loop through all legal moves until no moves remain or a beta cutoff occurs
+    lock_grab(&(sp->lock));
+
+    while (    sp->bestValue < sp->beta
            && !TM.thread_should_stop(threadID)
            && (move = sp->mp->get_next_move()) != MOVE_NONE)
     {
@@ -1789,45 +1809,48 @@ namespace {
       bool moveIsCheck = pos.move_is_check(move, ci);
       bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
-      ss[sp->ply].currentMove = move;
-
-      // Decide the new search depth
+      // Step 11. Decide the new search depth
       bool dangerous;
       Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
       Depth newDepth = sp->depth - OnePly + ext;
 
-      // Prune?
-      if (    useFutilityPruning
+      // Update current move
+      ss[sp->ply].currentMove = move;
+
+      // Step 12. Futility pruning
+      if (   !isCheck
           && !dangerous
-          && !captureOrPromotion)
+          && !captureOrPromotion
+          && !move_is_castle(move))
       {
           // Move count based pruning
           if (   moveCount >= futility_move_count(sp->depth)
               && ok_to_prune(pos, move, ss[sp->ply].threatMove)
               && sp->bestValue > value_mated_in(PLY_MAX))
+          {
+              lock_grab(&(sp->lock));
               continue;
+          }
 
           // Value based pruning
-          Value futilityValueScaled = sp->futilityValue - moveCount * 8; //FIXME: sync with search
+          Depth predictedDepth = newDepth - nonpv_reduction(sp->depth, moveCount);
+          Value futilityValueScaled =  ss[sp->ply].eval + futility_margin(predictedDepth, moveCount)
+                                     + H.gain(pos.piece_on(move_from(move)), move_to(move)) + 45;
 
           if (futilityValueScaled < sp->beta)
           {
-              if (futilityValueScaled > sp->bestValue) // Less then 1% of cases
-              {
-                  lock_grab(&(sp->lock));
-                  if (futilityValueScaled > sp->bestValue)
-                      sp->bestValue = futilityValueScaled;
-                  lock_release(&(sp->lock));
-              }
+              lock_grab(&(sp->lock));
+
+              if (futilityValueScaled > sp->bestValue)
+                  sp->bestValue = futilityValueScaled;
               continue;
           }
       }
 
-      // Make and search the move.
-      StateInfo st;
+      // Step 13. Make the move
       pos.do_move(move, st, ci, moveIsCheck);
 
-      // Try to reduce non-pv search depth by one ply if move seems not problematic,
+      // Step 14. Reduced search
       // if the move fails high will be re-searched at full depth.
       bool doFullDepthSearch = true;
 
@@ -1844,36 +1867,36 @@ namespace {
           }
       }
 
-      if (doFullDepthSearch) // Go with full depth non-pv search
+      // Step 15. Full depth search
+      if (doFullDepthSearch)
       {
           ss[sp->ply].reduction = Depth(0);
           value = -search(pos, ss, -(sp->beta - 1), newDepth, sp->ply+1, true, threadID);
       }
+
+      // Step 16. Undo move
       pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
-      // New best move?
-      if (value > sp->bestValue) // Less then 2% of cases
+      // Step 17. Check for new best move
+      lock_grab(&(sp->lock));
+
+      if (value > sp->bestValue && !TM.thread_should_stop(threadID))
       {
-          lock_grab(&(sp->lock));
-          if (value > sp->bestValue && !TM.thread_should_stop(threadID))
+          sp->bestValue = value;
+          if (sp->bestValue >= sp->beta)
           {
-              sp->bestValue = value;
-              if (sp->bestValue >= sp->beta)
-              {
-                  sp->stopRequest = true;
-                  sp_update_pv(sp->parentSstack, ss, sp->ply);
-              }
+              sp->stopRequest = true;
+              sp_update_pv(sp->parentSstack, ss, sp->ply);
           }
-          lock_release(&(sp->lock));
       }
     }
 
     /* Here we have the lock still grabbed */
 
-    sp->cpus--;
     sp->slaves[threadID] = 0;
+    sp->cpus--;
 
     lock_release(&(sp->lock));
   }
@@ -1895,12 +1918,16 @@ namespace {
     Position pos(*sp->pos);
     CheckInfo ci(pos);
     SearchStack* ss = sp->sstack[threadID];
+    StateInfo st;
     Value value = -VALUE_INFINITE;
     int moveCount;
     Move move;
 
-    while (    lock_grab_bool(&(sp->lock))
-           &&  sp->alpha < sp->beta
+    // Step 10. Loop through moves
+    // Loop through all legal moves until no moves remain or a beta cutoff occurs
+    lock_grab(&(sp->lock));
+
+    while (    sp->alpha < sp->beta
            && !TM.thread_should_stop(threadID)
            && (move = sp->mp->get_next_move()) != MOVE_NONE)
     {
@@ -1912,18 +1939,20 @@ namespace {
       bool moveIsCheck = pos.move_is_check(move, ci);
       bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
-      ss[sp->ply].currentMove = move;
-
-      // Decide the new search depth
+      // Step 11. Decide the new search depth
       bool dangerous;
       Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
       Depth newDepth = sp->depth - OnePly + ext;
 
-      // Make and search the move.
-      StateInfo st;
+      // Update current move
+      ss[sp->ply].currentMove = move;
+
+      // Step 12. Futility pruning (is omitted in PV nodes)
+
+      // Step 13. Make the move
       pos.do_move(move, st, ci, moveIsCheck);
 
-      // Try to reduce non-pv search depth by one ply if move seems not problematic,
+      // Step 14. Reduced search
       // if the move fails high will be re-searched at full depth.
       bool doFullDepthSearch = true;
 
@@ -1941,7 +1970,8 @@ namespace {
           }
       }
 
-      if (doFullDepthSearch) // Go with full depth non-pv search
+      // Step 15. Full depth search
+      if (doFullDepthSearch)
       {
           Value localAlpha = sp->alpha;
           ss[sp->ply].reduction = Depth(0);
@@ -1956,38 +1986,37 @@ namespace {
                   value = -search_pv(pos, ss, -sp->beta, -localAlpha, newDepth, sp->ply+1, threadID);
           }
       }
+
+      // Step 16. Undo move
       pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
-      // New best move?
-      if (value > sp->bestValue) // Less then 2% of cases
+      // Step 17. Check for new best move
+      lock_grab(&(sp->lock));
+
+      if (value > sp->bestValue && !TM.thread_should_stop(threadID))
       {
-          lock_grab(&(sp->lock));
-          if (value > sp->bestValue && !TM.thread_should_stop(threadID))
+          sp->bestValue = value;
+          if (value > sp->alpha)
           {
-              sp->bestValue = value;
-              if (value > sp->alpha)
-              {
-                  // Ask threads to stop before to modify sp->alpha
-                  if (value >= sp->beta)
-                      sp->stopRequest = true;
-
-                  sp->alpha = value;
-
-                  sp_update_pv(sp->parentSstack, ss, sp->ply);
-                  if (value == value_mate_in(sp->ply + 1))
-                      ss[sp->ply].mateKiller = move;
-              }
+              // Ask threads to stop before to modify sp->alpha
+              if (value >= sp->beta)
+                  sp->stopRequest = true;
+
+              sp->alpha = value;
+
+              sp_update_pv(sp->parentSstack, ss, sp->ply);
+              if (value == value_mate_in(sp->ply + 1))
+                  ss[sp->ply].mateKiller = move;
           }
-          lock_release(&(sp->lock));
       }
     }
 
     /* Here we have the lock still grabbed */
 
-    sp->cpus--;
     sp->slaves[threadID] = 0;
+    sp->cpus--;
 
     lock_release(&(sp->lock));
   }
@@ -2011,13 +2040,12 @@ namespace {
         NodesSincePoll++;
         if (NodesSincePoll >= NodesBetweenPolls)
         {
-            poll();
+            poll(ss, ply);
             NodesSincePoll = 0;
         }
     }
     ss[ply].init(ply);
     ss[ply + 2].initKillers();
-    TM.print_current_line(ss, ply, threadID);
   }
 
 
@@ -2375,7 +2403,7 @@ namespace {
   // looks at the time consumed so far and decides if it's time to abort the
   // search.
 
-  void poll() {
+  void poll(SearchStack ss[], int ply) {
 
     static int lastInfoTime;
     int t = current_search_time();
@@ -2417,7 +2445,6 @@ namespace {
     else if (t - lastInfoTime >= 1000)
     {
         lastInfoTime = t;
-        lock_grab(&TM.IOLock);
 
         if (dbg_show_mean)
             dbg_print_mean();
@@ -2428,10 +2455,15 @@ namespace {
         cout << "info nodes " << TM.nodes_searched() << " nps " << nps()
              << " time " << t << " hashfull " << TT.full() << endl;
 
-        lock_release(&TM.IOLock);
+        // We only support current line printing in single thread mode
+        if (ShowCurrentLine && TM.active_threads() == 1)
+        {
+            cout << "info currline";
+            for (int p = 0; p < ply; p++)
+                cout << " " << ss[p].currentMove;
 
-        if (ShowCurrentLine)
-            TM.threads[0].printCurrentLineRequest = true;
+            cout << endl;
+        }
     }
 
     // Should we stop the search?
@@ -2660,7 +2692,6 @@ namespace {
 
     // Initialize global locks
     lock_init(&MPLock, NULL);
-    lock_init(&IOLock, NULL);
 
     // Initialize SplitPointStack locks
     for (i = 0; i < MAX_THREADS; i++)
@@ -2818,7 +2849,7 @@ namespace {
   // splitPoint->cpus becomes 0), split() returns true.
 
   bool ThreadsManager::split(const Position& p, SearchStack* sstck, int ply,
-             Value* alpha, const Value beta, Value* bestValue, const Value futilityValue,
+             Value* alpha, const Value beta, Value* bestValue,
              Depth depth, int* moves, MovePicker* mp, int master, bool pvNode) {
 
     assert(p.is_ok());
@@ -2858,7 +2889,6 @@ namespace {
     splitPoint->beta = beta;
     splitPoint->pvNode = pvNode;
     splitPoint->bestValue = *bestValue;
-    splitPoint->futilityValue = futilityValue;
     splitPoint->master = master;
     splitPoint->mp = mp;
     splitPoint->moves = *moves;
@@ -2963,47 +2993,8 @@ namespace {
 
     // This makes the threads to go to sleep
     AllThreadsShouldSleep = true;
-
-    // Reset flags to a known state.
-    for (int i = 1; i < ActiveThreads; i++)
-    {
-        // This flag can be in a random state
-        threads[i].printCurrentLineRequest = false;
-    }
-  }
-
-  // print_current_line() prints _once_ the current line of search for a
-  // given thread and then setup the print request for the next thread.
-  // Called when the UCI option UCI_ShowCurrLine is 'true'.
-
-  void ThreadsManager::print_current_line(SearchStack ss[], int ply, int threadID) {
-
-    assert(ply >= 0 && ply < PLY_MAX);
-    assert(threadID >= 0 && threadID < ActiveThreads);
-
-    if (!threads[threadID].printCurrentLineRequest)
-        return;
-
-    // One shot only
-    threads[threadID].printCurrentLineRequest = false;
-
-    if (threads[threadID].state == THREAD_SEARCHING)
-    {
-        lock_grab(&IOLock);
-        cout << "info currline " << (threadID + 1);
-        for (int p = 0; p < ply; p++)
-            cout << " " << ss[p].currentMove;
-
-        cout << endl;
-        lock_release(&IOLock);
-    }
-
-    // Setup print request for the next thread ID
-    if (threadID + 1 < ActiveThreads)
-        threads[threadID + 1].printCurrentLineRequest = true;
   }
 
-
   /// The RootMoveList class
 
   // RootMoveList c'tor