Precalculate FutilityMargins

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index c44d150f7008826abd9fe08ac4c1b0c4798e4985..671a23cf5a6b14e8ef20eb84a088e485eead727a 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -185,6 +185,8 @@ namespace {
   // and near frontier nodes.
   const Value FutilityMarginQS = Value(0x80);
 
+  Value FutilityMargins[2 * PLY_MAX_PLUS_2]; // Initialized at startup.
+
   // Each move futility margin is decreased
   const Value IncrementalFutilityMargin = Value(0x8);
 
@@ -576,6 +578,14 @@ void init_threads() {
   for (i = 0; i < THREAD_MAX; i++)
       Threads[i].activeSplitPoints = 0;
 
+  // Init futility margins array
+  FutilityMargins[0] = FutilityMargins[1] = Value(0);
+
+  for (i = 2; i < 2 * PLY_MAX_PLUS_2; i++)
+  {
+      FutilityMargins[i] = Value(112 * bitScanReverse32(i * i / 2)); // FIXME: test using log instead of BSR
+  }
+
   // Initialize global locks
   lock_init(&MPLock, NULL);
   lock_init(&IOLock, NULL);
@@ -989,10 +999,9 @@ namespace {
                 && !captureOrPromotion
                 && !move_is_castle(move))
             {
-                double red = 0.5 + ln(RootMoveNumber - MultiPV + 1) * ln(depth / 2) / 6.0;
-                if (red >= 1.0)
+                ss[0].reduction = calculate_reduction(0.5, RootMoveNumber - MultiPV + 1, depth, 6.0);
+                if (ss[0].reduction)
                 {
-                    ss[0].reduction = Depth(int(floor(red * int(OnePly))));
                     value = -search(pos, ss, -alpha, newDepth-ss[0].reduction, 1, true, 0);
                     doFullDepthSearch = (value > alpha);
                 }
@@ -1303,13 +1312,12 @@ namespace {
             && !move_is_castle(move)
             && !move_is_killer(move, ss[ply]))
         {
-          double red = 0.5 + ln(moveCount) * ln(depth / 2) / 6.0;
-          if (red >= 1.0)
-          {
-              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);
-          }
+            ss[ply].reduction = calculate_reduction(0.5, moveCount, depth, 6.0);
+            if (ss[ply].reduction)
+            {
+                value = -search(pos, ss, -alpha, newDepth-ss[ply].reduction, ply+1, true, threadID);
+                doFullDepthSearch = (value > alpha);
+            }
         }
 
         if (doFullDepthSearch) // Go with full depth non-pv search
@@ -1460,7 +1468,7 @@ namespace {
 
     // Calculate depth dependant futility pruning parameters
     const int FutilityMoveCountMargin = 3 + (1 << (3 * int(depth) / 8));
-    const int PostFutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2);
+    const int PostFutilityValueMargin = FutilityMargins[int(depth)];
 
     // Evaluate the position statically
     if (!isCheck)
@@ -1628,7 +1636,7 @@ namespace {
           int preFutilityValueMargin = 0;
 
           if (newDepth >= OnePly)
-              preFutilityValueMargin = 112 * bitScanReverse32(int(newDepth) * int(newDepth) / 2);
+              preFutilityValueMargin = FutilityMargins[int(newDepth)];
 
           Value futilityCaptureValue = ss[ply].eval + pos.endgame_value_of_piece_on(move_to(move)) + preFutilityValueMargin + ei.futilityMargin + 90;
 
@@ -1656,16 +1664,16 @@ namespace {
           // Value based pruning
           Depth predictedDepth = newDepth;
 
-          //FIXME HACK: awful code duplication
-          double red = 0.5 + ln(moveCount) * ln(depth / 2) / 3.0;
-          if (red >= 1.0)
-              predictedDepth -= int(floor(red * int(OnePly)));
+          //FIXME: We are ignoring condition: depth >= 3*OnePly, BUG??
+          ss[ply].reduction = calculate_reduction(0.5, moveCount, depth, 3.0);
+          if (ss[ply].reduction)
+              predictedDepth -= ss[ply].reduction;
 
           if (predictedDepth < SelectiveDepth)
           {
               int preFutilityValueMargin = 0;
               if (predictedDepth >= OnePly)
-                  preFutilityValueMargin = 112 * bitScanReverse32(int(predictedDepth) * int(predictedDepth) / 2);
+                  preFutilityValueMargin = FutilityMargins[int(predictedDepth)];
 
               preFutilityValueMargin += H.gain(pos.piece_on(move_from(move)), move_from(move), move_to(move)) + 45;
 
@@ -1691,13 +1699,11 @@ namespace {
           && !dangerous
           && !captureOrPromotion
           && !move_is_castle(move)
-          && !move_is_killer(move, ss[ply])
-          /* && move != ttMove*/)
+          && !move_is_killer(move, ss[ply]))
       {
-          double red = 0.5 + ln(moveCount) * ln(depth / 2) / 3.0;
-          if (red >= 1.0)
+          ss[ply].reduction = calculate_reduction(0.5, moveCount, depth, 3.0);
+          if (ss[ply].reduction)
           {
-              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);
           }
@@ -2039,10 +2045,9 @@ namespace {
           && !move_is_castle(move)
           && !move_is_killer(move, ss[sp->ply]))
       {
-          double red = 0.5 + ln(moveCount) * ln(sp->depth / 2) / 3.0;
-          if (red >= 1.0)
+          ss[sp->ply].reduction = calculate_reduction(0.5, moveCount, sp->depth, 3.0);
+          if (ss[sp->ply].reduction)
           {
-              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);
           }
@@ -2153,11 +2158,10 @@ namespace {
           && !move_is_castle(move)
           && !move_is_killer(move, ss[sp->ply]))
       {
-          double red = 0.5 + ln(moveCount) * ln(sp->depth / 2) / 6.0;
-          if (red >= 1.0)
+          ss[sp->ply].reduction = calculate_reduction(0.5, moveCount, sp->depth, 6.0);
+          if (ss[sp->ply].reduction)
           {
               Value localAlpha = sp->alpha;
-              ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly))));
               value = -search(pos, ss, -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
               doFullDepthSearch = (value > localAlpha);
           }