X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=45e91e591ad768e213d7b003dd7dad5f4ffc3137;hp=defe00d6f16fde3353b1cdf9c99840d796b8b166;hb=62b43130e27e4322c5edde976d0827840b9deee4;hpb=54b3d44194fb0d36a2b4c3cd6d473ec50a4c1ef1

diff --git a/src/search.cpp b/src/search.cpp
index defe00d6..45e91e59 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -32,7 +32,6 @@
 #include "book.h"
 #include "evaluate.h"
 #include "history.h"
-#include "maxgain.h"
 #include "misc.h"
 #include "movegen.h"
 #include "movepick.h"
@@ -264,9 +263,6 @@ namespace {
   // History table
   History H;
 
-  // MaxGain table
-  MaxGain MG;
-
   /// Functions
 
   Value id_loop(const Position& pos, Move searchMoves[]);
@@ -704,7 +700,6 @@ namespace {
     // Initialize
     TT.new_search();
     H.clear();
-    MG.clear();
     init_ss_array(ss);
     IterationInfo[1] = IterationInfoType(rml.get_move_score(0), rml.get_move_score(0));
     Iteration = 1;
@@ -1416,9 +1411,14 @@ namespace {
         update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
     }
 
-    // Post futility pruning
-    if (depth < SelectiveDepth && staticValue - PostFutilityValueMargin >= beta)
-        return (staticValue - PostFutilityValueMargin);
+    // Do a "stand pat". If we are above beta by a good margin then
+    // return immediately.
+    // FIXME: test with added condition 'allowNullmove || depth <= OnePly' and !value_is_mate(beta)
+    // FIXME: test with modified condition 'depth < RazorDepth'
+    if (  !isCheck
+        && depth < SelectiveDepth
+        && staticValue - PostFutilityValueMargin >= beta)
+        return staticValue - PostFutilityValueMargin;
 
     // Null move search
     if (    allowNullmove
@@ -1543,6 +1543,8 @@ namespace {
       movesSearched[moveCount++] = ss[ply].currentMove = move;
 
       // Futility pruning for captures
+      // FIXME: test disabling 'Futility pruning for captures'
+      // FIXME: test with 'newDepth < RazorDepth'
       Color them = opposite_color(pos.side_to_move());
 
       if (   !isCheck
@@ -1560,11 +1562,16 @@ namespace {
           if (newDepth >= OnePly)
               preFutilityValueMargin = 112 * bitScanReverse32(int(newDepth) * int(newDepth) / 2);
 
-          if (ss[ply].eval + pos.endgame_value_of_piece_on(move_to(move)) + preFutilityValueMargin + ei.futilityMargin + 90 < beta)
+          Value futilityCaptureValue = ss[ply].eval + pos.endgame_value_of_piece_on(move_to(move)) + preFutilityValueMargin + ei.futilityMargin + 90;
+
+          if (futilityCaptureValue < beta)
+          {
+              if (futilityCaptureValue > bestValue)
+                  bestValue = futilityCaptureValue;
               continue;
+          }
       }
 
-
       // Futility pruning
       if (   !isCheck
           && !dangerous
@@ -1592,7 +1599,7 @@ namespace {
               if (predictedDepth >= OnePly)
                   preFutilityValueMargin = 112 * bitScanReverse32(int(predictedDepth) * int(predictedDepth) / 2);
 
-              preFutilityValueMargin += MG.retrieve(pos.piece_on(move_from(move)), move_from(move), move_to(move)) + 45;
+              preFutilityValueMargin += H.gain(pos.piece_on(move_from(move)), move_from(move), move_to(move)) + 45;
 
               futilityValueScaled = ss[ply].eval + preFutilityValueMargin - moveCount * IncrementalFutilityMargin;
 
@@ -1897,28 +1904,29 @@ namespace {
     SearchStack* ss = sp->sstack[threadID];
     Value value = -VALUE_INFINITE;
     Move move;
+    int moveCount;
     bool isCheck = pos.is_check();
     bool useFutilityPruning =     sp->depth < SelectiveDepth
                               && !isCheck;
 
     const int FutilityMoveCountMargin = 3 + (1 << (3 * int(sp->depth) / 8));
 
-    while (    sp->bestValue < sp->beta
+    while (    lock_grab_bool(&(sp->lock))
+           &&  sp->bestValue < sp->beta
            && !thread_should_stop(threadID)
-           && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
+           && (move = sp->mp->get_next_move()) != MOVE_NONE)
     {
+      moveCount = ++sp->moves;
+      lock_release(&(sp->lock));
+
       assert(move_is_ok(move));
 
       bool moveIsCheck = pos.move_is_check(move, ci);
       bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
-      lock_grab(&(sp->lock));
-      int moveCount = ++sp->moves;
-      lock_release(&(sp->lock));
-
       ss[sp->ply].currentMove = move;
 
-      // Decide the new search depth.
+      // Decide the new search depth
       bool dangerous;
       Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
       Depth newDepth = sp->depth - OnePly + ext;
@@ -1982,7 +1990,10 @@ namespace {
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
       if (thread_should_stop(threadID))
+      {
+          lock_grab(&(sp->lock));
           break;
+      }
 
       // New best move?
       if (value > sp->bestValue) // Less then 2% of cases
@@ -2005,7 +2016,7 @@ namespace {
       }
     }
 
-    lock_grab(&(sp->lock));
+    /* Here we have the lock still grabbed */
 
     // 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.
@@ -2038,24 +2049,25 @@ namespace {
     CheckInfo ci(pos);
     SearchStack* ss = sp->sstack[threadID];
     Value value = -VALUE_INFINITE;
+    int moveCount;
     Move move;
 
-    while (    sp->alpha < sp->beta
+    while (    lock_grab_bool(&(sp->lock))
+           &&  sp->alpha < sp->beta
            && !thread_should_stop(threadID)
-           && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
+           && (move = sp->mp->get_next_move()) != MOVE_NONE)
     {
-      bool moveIsCheck = pos.move_is_check(move, ci);
-      bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
+      moveCount = ++sp->moves;
+      lock_release(&(sp->lock));
 
       assert(move_is_ok(move));
 
-      lock_grab(&(sp->lock));
-      int moveCount = ++sp->moves;
-      lock_release(&(sp->lock));
+      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.
+      // Decide the new search depth
       bool dangerous;
       Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
       Depth newDepth = sp->depth - OnePly + ext;
@@ -2115,7 +2127,10 @@ namespace {
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
       if (thread_should_stop(threadID))
+      {
+          lock_grab(&(sp->lock));
           break;
+      }
 
       // New best move?
       if (value > sp->bestValue) // Less then 2% of cases
@@ -2154,7 +2169,7 @@ namespace {
       }
     }
 
-    lock_grab(&(sp->lock));
+    /* Here we have the lock still grabbed */
 
     // 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.
@@ -2646,7 +2661,7 @@ namespace {
         && pos.captured_piece() == NO_PIECE_TYPE
         && !move_is_castle(m)
         && !move_is_promotion(m))
-        MG.store(pos.piece_on(move_to(m)), move_from(m), move_to(m), -(before + after));
+        H.set_gain(pos.piece_on(move_to(m)), move_from(m), move_to(m), -(before + after));
   }