X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=43fb7067a4692a0ca8915c68316215125e109261;hp=ac90531f8c618a44c983cbbc3d4454f71163a97f;hb=c01af5676913cbb8a522bd080b6d8559c7450f3a;hpb=b5d38ad1e5cc7ad4c350b3ef4d1db5241bad8b93

diff --git a/src/search.cpp b/src/search.cpp
index ac90531f..43fb7067 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -653,6 +653,7 @@ void SearchStack::init(int ply) {
   currentMove = threatMove = MOVE_NONE;
   reduction = Depth(0);
   eval = VALUE_NONE;
+  evalInfo = NULL;
 }
 
 void SearchStack::initKillers() {
@@ -886,7 +887,7 @@ namespace {
   Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value alpha, Value beta) {
 
     Value oldAlpha = alpha;
-    Value value;
+    Value value = -VALUE_INFINITE;
     CheckInfo ci(pos);
 
     // Loop through all the moves in the root move list
@@ -955,6 +956,8 @@ namespace {
         {
             // Try to reduce non-pv search depth by one ply if move seems not problematic,
             // if the move fails high will be re-searched at full depth.
+            bool doFullDepthSearch = true;
+
             if (   depth >= 3*OnePly // FIXME was newDepth
                 && !dangerous
                 && !captureOrPromotion
@@ -965,13 +968,11 @@ namespace {
                 {
                     ss[0].reduction = Depth(int(floor(red * int(OnePly))));
                     value = -search(pos, ss, -alpha, newDepth-ss[0].reduction, 1, true, 0);
+                    doFullDepthSearch = (value > alpha);
                 }
-                else
-                    value = alpha + 1; // Just to trigger next condition
-            } else
-                value = alpha + 1; // Just to trigger next condition
+            }
 
-            if (value > alpha)
+            if (doFullDepthSearch)
             {
                 value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
 
@@ -1105,7 +1106,7 @@ namespace {
     Value oldAlpha, value;
     bool isCheck, mateThreat, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
     int moveCount = 0;
-    Value bestValue = -VALUE_INFINITE;
+    Value bestValue = value = -VALUE_INFINITE;
 
     if (depth < OnePly)
         return qsearch(pos, ss, alpha, beta, Depth(0), ply, threadID);
@@ -1207,6 +1208,8 @@ namespace {
       {
         // Try to reduce non-pv search depth by one ply if move seems not problematic,
         // if the move fails high will be re-searched at full depth.
+        bool doFullDepthSearch = true;
+
         if (    depth >= 3*OnePly
             && !dangerous
             && !captureOrPromotion
@@ -1218,14 +1221,11 @@ namespace {
           {
               ss[ply].reduction = Depth(int(floor(red * int(OnePly))));
               value = -search(pos, ss, -alpha, newDepth-ss[ply].reduction, ply+1, true, threadID);
+              doFullDepthSearch = (value > alpha);
           }
-          else
-              value = alpha + 1; // Just to trigger next condition
         }
-        else
-            value = alpha + 1; // Just to trigger next condition
 
-        if (value > alpha) // Go with full depth non-pv search
+        if (doFullDepthSearch) // Go with full depth non-pv search
         {
             ss[ply].reduction = Depth(0);
             value = -search(pos, ss, -alpha, newDepth, ply+1, true, threadID);
@@ -1328,11 +1328,11 @@ namespace {
     const TTEntry* tte;
     Move ttMove, move;
     Depth ext, newDepth;
-    Value staticValue, nullValue, value, futilityValue, futilityValueScaled;
+    Value bestValue, staticValue, nullValue, value, futilityValue, futilityValueScaled;
     bool isCheck, useFutilityPruning, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
     int moveCount = 0;
-    Value bestValue = -VALUE_INFINITE;
+    futilityValue = staticValue = bestValue = value = -VALUE_INFINITE;
 
     if (depth < OnePly)
         return qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
@@ -1376,14 +1376,15 @@ namespace {
     const int FutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2);
 
     // Evaluate the position statically
-    if (isCheck)
-        ss[ply].eval = VALUE_NONE;
-    else
+    if (!isCheck)
     {
         if (tte && (tte->type() & VALUE_TYPE_EVAL))
             staticValue = value_from_tt(tte->value(), ply);
         else
+        {
             staticValue = evaluate(pos, ei, threadID);
+            ss[ply].evalInfo = &ei;
+        }
 
         ss[ply].eval = staticValue;
         futilityValue = staticValue + FutilityValueMargin;
@@ -1456,7 +1457,7 @@ namespace {
 
     // Go with internal iterative deepening if we don't have a TT move
     if (UseIIDAtNonPVNodes && ttMove == MOVE_NONE && depth >= 8*OnePly &&
-        !isCheck && evaluate(pos, ei, threadID) >= beta - IIDMargin)
+        !isCheck && ss[ply].eval >= beta - IIDMargin)
     {
         search(pos, ss, beta, Min(depth/2, depth-2*OnePly), ply, false, threadID);
         ttMove = ss[ply].pv[ply];
@@ -1541,6 +1542,8 @@ namespace {
 
       // Try to reduce non-pv search depth by one ply if move seems not problematic,
       // if the move fails high will be re-searched at full depth.
+      bool doFullDepthSearch = true;
+
       if (    depth >= 3*OnePly
           && !dangerous
           && !captureOrPromotion
@@ -1553,14 +1556,11 @@ namespace {
           {
               ss[ply].reduction = Depth(int(floor(red * int(OnePly))));
               value = -search(pos, ss, -(beta-1), newDepth-ss[ply].reduction, ply+1, true, threadID);
+              doFullDepthSearch = (value >= beta);
           }
-          else
-              value = beta; // Just to trigger next condition
       }
-      else
-          value = beta; // Just to trigger next condition
 
-      if (value >= beta) // Go with full depth non-pv search
+      if (doFullDepthSearch) // Go with full depth non-pv search
       {
           ss[ply].reduction = Depth(0);
           value = -search(pos, ss, -(beta-1), newDepth, ply+1, true, threadID);
@@ -1810,14 +1810,13 @@ namespace {
     Position pos = Position(sp->pos);
     CheckInfo ci(pos);
     SearchStack* ss = sp->sstack[threadID];
-    Value value;
+    Value value = -VALUE_INFINITE;
     Move move;
     bool isCheck = pos.is_check();
     bool useFutilityPruning =     sp->depth < SelectiveDepth
                               && !isCheck;
 
     const int FutilityMoveCountMargin = 3 + (1 << (3 * int(sp->depth) / 8));
-    const int FutilityValueMargin = 112 * bitScanReverse32(int(sp->depth) * int(sp->depth) / 2);
 
     while (    sp->bestValue < sp->beta
            && !thread_should_stop(threadID)
@@ -1851,12 +1850,6 @@ namespace {
               continue;
 
           // Value based pruning
-          if (sp->futilityValue == VALUE_NONE)
-          {
-              EvalInfo ei;
-              sp->futilityValue = evaluate(pos, ei, threadID) + FutilityValueMargin;
-          }
-
           Value futilityValueScaled = sp->futilityValue - moveCount * IncrementalFutilityMargin;
 
           if (futilityValueScaled < sp->beta)
@@ -1878,6 +1871,8 @@ namespace {
 
       // Try to reduce non-pv search depth by one ply if move seems not problematic,
       // if the move fails high will be re-searched at full depth.
+      bool doFullDepthSearch = true;
+
       if (   !dangerous
           && !captureOrPromotion
           && !move_is_castle(move)
@@ -1888,14 +1883,11 @@ namespace {
           {
               ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly))));
               value = -search(pos, ss, -(sp->beta-1), newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
+              doFullDepthSearch = (value >= sp->beta);
           }
-          else
-              value = sp->beta; // Just to trigger next condition
       }
-      else
-          value = sp->beta; // Just to trigger next condition
 
-      if (value >= sp->beta) // Go with full depth non-pv search
+      if (doFullDepthSearch) // Go with full depth non-pv search
       {
           ss[sp->ply].reduction = Depth(0);
           value = -search(pos, ss, -(sp->beta - 1), newDepth, sp->ply+1, true, threadID);
@@ -1960,7 +1952,7 @@ namespace {
     Position pos = Position(sp->pos);
     CheckInfo ci(pos);
     SearchStack* ss = sp->sstack[threadID];
-    Value value;
+    Value value = -VALUE_INFINITE;
     Move move;
 
     while (    sp->alpha < sp->beta
@@ -1989,6 +1981,8 @@ namespace {
 
       // Try to reduce non-pv search depth by one ply if move seems not problematic,
       // if the move fails high will be re-searched at full depth.
+      bool doFullDepthSearch = true;
+
       if (   !dangerous
           && !captureOrPromotion
           && !move_is_castle(move)
@@ -1997,24 +1991,23 @@ namespace {
           double red = 0.5 + ln(moveCount) * ln(sp->depth / 2) / 6.0;
           if (red >= 1.0)
           {
+              Value localAlpha = sp->alpha;
               ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly))));
-              value = -search(pos, ss, -sp->alpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
+              value = -search(pos, ss, -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
+              doFullDepthSearch = (value > localAlpha);
           }
-          else
-              value = sp->alpha + 1; // Just to trigger next condition
       }
-      else
-          value = sp->alpha + 1; // Just to trigger next condition
 
-      if (value > sp->alpha) // Go with full depth non-pv search
+      if (doFullDepthSearch) // Go with full depth non-pv search
       {
+          Value localAlpha = sp->alpha;
           ss[sp->ply].reduction = Depth(0);
-          value = -search(pos, ss, -sp->alpha, newDepth, sp->ply+1, true, threadID);
+          value = -search(pos, ss, -localAlpha, newDepth, sp->ply+1, true, threadID);
 
-          if (value > sp->alpha && value < sp->beta)
+          if (value > localAlpha && value < sp->beta)
           {
               // When the search fails high at ply 1 while searching the first
-              // move at the root, set the flag failHighPly1.  This is used for
+              // move at the root, set the flag failHighPly1. This is used for
               // time managment: We don't want to stop the search early in
               // such cases, because resolving the fail high at ply 1 could
               // result in a big drop in score at the root.