X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=a4ce7eff3abf10c7a76c057c75271a4f1a4949df;hp=8e6181cc97dee8693b7be8636e2ae72a64049ed3;hb=d11426c7779b45a5f91f260ecb9e0c4c1e964e2b;hpb=b09cbaebb9fad91320e723f92930b5ec6fd88e9f

diff --git a/src/search.cpp b/src/search.cpp
index 8e6181cc..a4ce7eff 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -133,9 +133,6 @@ namespace {
   // when the static evaluation is at most IIDMargin below beta.
   const Value IIDMargin = Value(0x100);
 
-  // Use easy moves?
-  const bool UseEasyMove = true;
-
   // Easy move margin.  An easy move candidate must be at least this much
   // better than the second best move.
   const Value EasyMoveMargin = Value(0x200);
@@ -169,7 +166,7 @@ namespace {
   // nodes, and at pre-frontier nodes
   Value FutilityMargin0 = Value(0x80);
   Value FutilityMargin1 = Value(0x100);
-  Value FutilityMargin2 = Value(0x300);
+  Value FutilityMargin2 = Value(0x200);
 
   // Razoring
   Depth RazorDepth = 4*OnePly;
@@ -940,16 +937,17 @@ namespace {
     assert(ply >= 0 && ply < PLY_MAX);
     assert(threadID >= 0 && threadID < ActiveThreads);
 
-    // Initialize, and make an early exit in case of an aborted search,
-    // an instant draw, maximum ply reached, etc.
-    if (AbortSearch || thread_should_stop(threadID))
-        return Value(0);
-
     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.
     init_node(pos, ss, ply, threadID);
 
+    // After init_node() that calls poll()
+    if (AbortSearch || thread_should_stop(threadID))
+        return Value(0);
+
     if (pos.is_draw())
         return VALUE_DRAW;
 
@@ -1037,7 +1035,7 @@ namespace {
         else
             value = alpha + 1; // Just to trigger next condition
 
-        if (value > alpha) // Go with full depth pv search
+        if (value > alpha) // Go with full depth non-pv search
         {
             ss[ply].reduction = Depth(0);
             value = -search(pos, ss, -alpha, newDepth, ply+1, true, threadID);
@@ -1075,7 +1073,9 @@ namespace {
           // If we are at ply 1, and we are searching the first root move at
           // ply 0, set the 'Problem' variable if the score has dropped a lot
           // (from the computer's point of view) since the previous iteration:
-          if (Iteration >= 2 && -value <= ValueByIteration[Iteration-1] - ProblemMargin)
+          if (   ply == 1
+              && Iteration >= 2
+              && -value <= ValueByIteration[Iteration-1] - ProblemMargin)
               Problem = true;
       }
 
@@ -1132,21 +1132,22 @@ namespace {
     assert(ply >= 0 && ply < PLY_MAX);
     assert(threadID >= 0 && threadID < ActiveThreads);
 
-    EvalInfo ei;
+    if (depth < OnePly)
+        return qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
 
     // Initialize, and make an early exit in case of an aborted search,
     // an instant draw, maximum ply reached, etc.
+    init_node(pos, ss, ply, threadID);
+
+    // After init_node() that calls poll()
     if (AbortSearch || thread_should_stop(threadID))
         return Value(0);
 
-    if (depth < OnePly)
-        return qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
-
-    init_node(pos, ss, ply, threadID);
-
     if (pos.is_draw())
         return VALUE_DRAW;
 
+    EvalInfo ei;
+
     if (ply >= PLY_MAX - 1)
         return evaluate(pos, ei, threadID);
 
@@ -1189,8 +1190,8 @@ namespace {
         Value nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
 
         // Check for a null capture artifact, if the value without the null capture
-        // is above beta then there is a good possibility that this is a cut-node.
-        // We will do an IID later to find a ttMove.
+        // is above beta then mark the node as a suspicious failed low. We will verify
+        // later if we are really under threat.
         if (   UseNullDrivenIID
             && nullValue < beta
             && depth > 6 * OnePly
@@ -1236,13 +1237,12 @@ namespace {
         }
     }
     // Null move search not allowed, try razoring
-    else if (   !isCheck
-             && !value_is_mate(beta)
-             && (  (approximateEval < beta - RazorMargin && depth < RazorDepth)
-                 ||(approximateEval < beta - PawnValueMidgame && depth <= OnePly)))
+    else if (   !value_is_mate(beta)
+             && approximateEval < beta - RazorMargin
+             && depth < RazorDepth)
     {
         Value v = qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
-        if (v < beta)
+        if (v < beta - RazorMargin / 2)
             return v;
     }
 
@@ -1257,7 +1257,9 @@ namespace {
     {
         // The null move failed low due to a suspicious capture. Perhaps we
         // are facing a null capture artifact due to the side to move change
-        // and this is a cut-node. So it's a good time to search for a ttMove.
+        // and this position should fail high. So do a normal search with a
+        // reduced depth to get a good ttMove to use in the following full
+        // depth search.
         Move tm = ss[ply].threatMove;
 
         assert(tm != MOVE_NONE);
@@ -1306,18 +1308,18 @@ namespace {
           && !moveIsCapture
           && !move_promotion(move))
       {
-          // History pruning. See ok_to_prune() definition.
+          // History pruning. See ok_to_prune() definition
           if (   moveCount >= 2 + int(depth)
               && ok_to_prune(pos, move, ss[ply].threatMove, depth))
               continue;
 
-          // Value based pruning.
-          if (depth < 3 * OnePly && approximateEval < beta)
+          // Value based pruning
+          if (depth < 6 * OnePly && approximateEval < beta)
           {
               if (futilityValue == VALUE_NONE)
                   futilityValue =  evaluate(pos, ei, threadID)
-                                + (depth < 2 * OnePly ? FutilityMargin1 : FutilityMargin2);
-
+                                + (depth < 2 * OnePly ? FutilityMargin1
+                                                      : FutilityMargin2 + (depth - 2*OnePly) * 32);
               if (futilityValue < beta)
               {
                   if (futilityValue > bestValue)
@@ -1420,15 +1422,14 @@ namespace {
     assert(ply >= 0 && ply < PLY_MAX);
     assert(threadID >= 0 && threadID < ActiveThreads);
 
-    EvalInfo ei;
-
     // Initialize, and make an early exit in case of an aborted search,
     // an instant draw, maximum ply reached, etc.
+    init_node(pos, ss, ply, threadID);
+
+    // After init_node() that calls poll()
     if (AbortSearch || thread_should_stop(threadID))
         return Value(0);
 
-    init_node(pos, ss, ply, threadID);
-
     if (pos.is_draw())
         return VALUE_DRAW;
 
@@ -1438,6 +1439,7 @@ namespace {
         return value_from_tt(tte->value(), ply);
 
     // Evaluate the position statically
+    EvalInfo ei;
     bool isCheck = pos.is_check();
     Value staticValue = (isCheck ? -VALUE_INFINITE : evaluate(pos, ei, threadID));
 
@@ -1775,8 +1777,10 @@ namespace {
         }
         // If we are at ply 1, and we are searching the first root move at
         // ply 0, set the 'Problem' variable if the score has dropped a lot
-        // (from the computer's point of view) since the previous iteration:
-        if (Iteration >= 2 && -value <= ValueByIteration[Iteration-1] - ProblemMargin)
+        // (from the computer's point of view) since the previous iteration.
+        if (   sp->ply == 1
+            && Iteration >= 2
+            && -value <= ValueByIteration[Iteration-1] - ProblemMargin)
             Problem = true;
       }
       lock_release(&(sp->lock));
@@ -1785,7 +1789,7 @@ namespace {
     lock_grab(&(sp->lock));
 
     // If this is the master thread and we have been asked to stop because of
-    // a beta cutoff higher up in the tree, stop all slave threads:
+    // a beta cutoff higher up in the tree, stop all slave threads.
     if (sp->master == threadID && thread_should_stop(threadID))
         for (int i = 0; i < ActiveThreads; i++)
             if (sp->slaves[i])
@@ -2170,6 +2174,8 @@ namespace {
   Depth extension(const Position &pos, Move m, bool pvNode, bool check,
                   bool singleReply, bool mateThreat, bool* dangerous) {
 
+    assert(m != MOVE_NONE);
+
     Depth result = Depth(0);
     *dangerous = check || singleReply || mateThreat;
 
@@ -2193,10 +2199,12 @@ namespace {
         *dangerous = true;
     }
 
-    if (   pos.midgame_value_of_piece_on(move_to(m)) >= RookValueMidgame
+    if (   pos.move_is_capture(m)
+        && pos.type_of_piece_on(move_to(m)) != PAWN
         && (  pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
             - pos.midgame_value_of_piece_on(move_to(m)) == Value(0))
-        && !move_promotion(m))
+        && !move_promotion(m)
+        && !move_is_ep(m))
     {
         result += PawnEndgameExtension[pvNode];
         *dangerous = true;
@@ -2262,7 +2270,7 @@ namespace {
     // value of the threatening piece, don't prune move which defend it.
     if (   !PruneDefendingMoves
         && threat != MOVE_NONE
-        && pos.type_of_piece_on(tto) != NO_PIECE_TYPE
+        && pos.move_is_capture(threat)
         && (   pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto)
             || pos.type_of_piece_on(tfrom) == KING)
         && pos.move_attacks_square(m, tto))
@@ -2277,7 +2285,8 @@ namespace {
     if (  !PruneBlockingMoves
         && threat != MOVE_NONE
         && piece_is_slider(pos.piece_on(tfrom))
-        && bit_is_set(squares_between(tfrom, tto), mto) && pos.see(m) >= 0)
+        && bit_is_set(squares_between(tfrom, tto), mto)
+        && pos.see(m) >= 0)
             return false;
 
     return true;