]> git.sesse.net Git - stockfish/blobdiff - src/search.cpp
Rename staticValue to refinedValue
[stockfish] / src / search.cpp
index a052ea18f8828d3c56c8dc8cee94c0cde34bcbcc..6de686b30cd54b81af292afe9c7240fedfaba52a 100644 (file)
@@ -1272,11 +1272,11 @@ namespace {
     const TTEntry* tte;
     Move ttMove, move;
     Depth ext, newDepth;
-    Value bestValue, staticValue, nullValue, value, futilityValue, futilityValueScaled;
+    Value bestValue, refinedValue, nullValue, value, futilityValue, futilityValueScaled;
     bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
     int moveCount = 0;
-    futilityValue = staticValue = bestValue = value = -VALUE_INFINITE;
+    futilityValue = refinedValue = bestValue = value = -VALUE_INFINITE;
 
     if (depth < OnePly)
         return qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
@@ -1302,7 +1302,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);
@@ -1320,13 +1320,12 @@ 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
+        futilityValue = ss[ply].eval + futility_margin(depth, 0); //FIXME: Remove me, only for split
+        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);
     }
 
@@ -1334,7 +1333,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()))
@@ -1351,8 +1350,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
@@ -1363,7 +1362,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;
 
@@ -1373,7 +1372,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);
@@ -1790,6 +1789,7 @@ namespace {
     Position pos(*sp->pos);
     CheckInfo ci(pos);
     SearchStack* ss = sp->sstack[threadID];
+    StateInfo st;
     Value value = -VALUE_INFINITE;
     Move move;
     int moveCount;
@@ -1797,8 +1797,9 @@ namespace {
     bool useFutilityPruning =     sp->depth < 7 * OnePly //FIXME: sync with search
                               && !isCheck;
 
-    while (    lock_grab_bool(&(sp->lock))
-           &&  sp->bestValue < sp->beta
+    lock_grab(&(sp->lock));
+
+    while (    sp->bestValue < sp->beta
            && !TM.thread_should_stop(threadID)
            && (move = sp->mp->get_next_move()) != MOVE_NONE)
     {
@@ -1826,29 +1827,28 @@ namespace {
           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
 
           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;
 
@@ -1865,36 +1865,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));
   }
@@ -1916,12 +1916,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)
     {
@@ -1933,18 +1937,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;
 
@@ -1962,7 +1968,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);
@@ -1977,38 +1984,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));
   }