X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=98f3e3fdf0ca44553b279ff9e024cd7c7cb746ed;hp=52e7600b073e2e2617c894dfdae1d71a94f3e8f1;hb=55db87147237e84a4a2341ca10fb56c1ccfac32c;hpb=98cd8239cc351f337132bb8cf08be728580c078d

diff --git a/src/search.cpp b/src/search.cpp
index 52e7600b..98f3e3fd 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -482,7 +482,7 @@ namespace {
     Key posKey;
     Move ttMove, move, excludedMove, bestMove, threatMove;
     Depth ext, newDepth;
-    Value bestValue, value, ttValue;
+    Value bestValue, value, ttValue, ttValueUpper;
     Value eval, nullValue, futilityValue;
     bool inCheck, givesCheck, pvMove, singularExtensionNode;
     bool captureOrPromotion, dangerous, doFullDepthSearch;
@@ -544,31 +544,43 @@ namespace {
     tte = TT.probe(posKey);
     ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
     ttValue = tte ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE;
+    ttValueUpper = tte ? value_from_tt(tte->value_upper(), ss->ply) : VALUE_NONE;
 
     // At PV nodes we check for exact scores, while at non-PV nodes we check for
     // a fail high/low. Biggest advantage at probing at PV nodes is to have a
     // smooth experience in analysis mode. We don't probe at Root nodes otherwise
     // we should also update RootMoveList to avoid bogus output.
-    if (   !RootNode
-        && tte
-        && tte->depth() >= depth
-        && ttValue != VALUE_NONE // Only in case of TT access race
-        && (           PvNode ?  tte->type() == BOUND_EXACT
-            : ttValue >= beta ? (tte->type() & BOUND_LOWER)
-                              : (tte->type() & BOUND_UPPER)))
+    if (!RootNode && tte)
     {
-        TT.refresh(tte);
-        ss->currentMove = ttMove; // Can be MOVE_NONE
+        // Fail High
+        if (  (tte->type() & BOUND_LOWER)
+            && ttValue >= beta
+            && tte->depth() >= depth
+            && ttValue != VALUE_NONE) // Only in case of TT access race
+        {
+            // Update killers, we assume ttMove caused a cut-off
+            if (    ttMove
+                && !pos.is_capture_or_promotion(ttMove)
+                &&  ttMove != ss->killers[0])
+            {
+                ss->killers[1] = ss->killers[0];
+                ss->killers[0] = ttMove;
+            }
+            TT.refresh(tte);
+            ss->currentMove = ttMove; // Can be MOVE_NONE
+            return ttValue;
+        }
 
-        if (    ttValue >= beta
-            &&  ttMove
-            && !pos.is_capture_or_promotion(ttMove)
-            &&  ttMove != ss->killers[0])
+        // Fail Low
+        if (  (tte->type() & BOUND_UPPER)
+            && ttValueUpper <= alpha
+            && tte->depth_upper() >= depth
+            && ttValueUpper != VALUE_NONE) // Only in case of TT access race
         {
-            ss->killers[1] = ss->killers[0];
-            ss->killers[0] = ttMove;
+            TT.refresh(tte);
+            ss->currentMove = ttMove; // Can be MOVE_NONE
+            return ttValueUpper;
         }
-        return ttValue;
     }
 
     // Step 5. Evaluate the position statically and update parent's gain statistics
@@ -1089,8 +1101,8 @@ split_point_start: // At split points actual search starts from here
     const TTEntry* tte;
     Key posKey;
     Move ttMove, move, bestMove;
-    Value bestValue, value, ttValue, futilityValue, futilityBase, oldAlpha;
-    bool givesCheck, enoughMaterial, evasionPrunable;
+    Value bestValue, value, ttValue, ttValueUpper, futilityValue, futilityBase, oldAlpha;
+    bool givesCheck, enoughMaterial, evasionPrunable, fromNull;
     Depth ttDepth;
 
     // To flag BOUND_EXACT a node with eval above alpha and no available moves
@@ -1099,6 +1111,7 @@ split_point_start: // At split points actual search starts from here
 
     ss->currentMove = bestMove = MOVE_NONE;
     ss->ply = (ss-1)->ply + 1;
+    fromNull = (ss-1)->currentMove == MOVE_NULL;
 
     // Check for an instant draw or maximum ply reached
     if (pos.is_draw<false, false>() || ss->ply > MAX_PLY)
@@ -1110,21 +1123,34 @@ split_point_start: // At split points actual search starts from here
     tte = TT.probe(posKey);
     ttMove = tte ? tte->move() : MOVE_NONE;
     ttValue = tte ? value_from_tt(tte->value(),ss->ply) : VALUE_NONE;
+    ttValueUpper = tte ? value_from_tt(tte->value_upper(),ss->ply) : VALUE_NONE;
 
     // Decide whether or not to include checks, this fixes also the type of
     // TT entry depth that we are going to use. Note that in qsearch we use
     // only two types of depth in TT: DEPTH_QS_CHECKS or DEPTH_QS_NO_CHECKS.
     ttDepth = InCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS
                                                   : DEPTH_QS_NO_CHECKS;
-    if (   tte
-        && tte->depth() >= ttDepth
-        && ttValue != VALUE_NONE // Only in case of TT access race
-        && (           PvNode ?  tte->type() == BOUND_EXACT
-            : ttValue >= beta ? (tte->type() & BOUND_LOWER)
-                              : (tte->type() & BOUND_UPPER)))
+    if (tte)
     {
-        ss->currentMove = ttMove; // Can be MOVE_NONE
-        return ttValue;
+        // Fail High
+        if (  (tte->type() & BOUND_LOWER)
+            && ttValue >= beta
+            && tte->depth() >= ttDepth
+            && ttValue != VALUE_NONE) // Only in case of TT access race
+        {
+            ss->currentMove = ttMove; // Can be MOVE_NONE
+            return ttValue;
+        }
+
+        // Fail Low
+        if (  (tte->type() & BOUND_UPPER)
+            && ttValueUpper <= alpha
+            && tte->depth_upper() >= ttDepth
+            && ttValueUpper != VALUE_NONE) // Only in case of TT access race
+        {
+            ss->currentMove = ttMove; // Can be MOVE_NONE
+            return ttValueUpper;
+        }
     }
 
     // Evaluate the position statically
@@ -1136,7 +1162,14 @@ split_point_start: // At split points actual search starts from here
     }
     else
     {
-        ss->staticEval = bestValue = evaluate(pos, ss->evalMargin);
+        if (fromNull)
+        {
+            // Approximated score. Real one is slightly higher due to tempo
+            ss->staticEval = bestValue = -(ss-1)->staticEval;
+            ss->evalMargin = VALUE_ZERO;
+        }
+        else
+            ss->staticEval = bestValue = evaluate(pos, ss->evalMargin);
 
         // Stand pat. Return immediately if static value is at least beta
         if (bestValue >= beta)
@@ -1171,6 +1204,7 @@ split_point_start: // At split points actual search starts from here
       // Futility pruning
       if (   !PvNode
           && !InCheck
+          && !fromNull
           && !givesCheck
           &&  move != ttMove
           &&  enoughMaterial