X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=d8e60a129317f90acda38e5f6f1ae6b5c6b090bf;hp=5d803949112423dfe4b3ebe1570437d945b6b1c2;hb=af3dd21e9053feaf66ad884fae0a014d85c700f2;hpb=5ea816792175ec53523035673dad703e7be1f662

diff --git a/src/search.cpp b/src/search.cpp
index 5d803949..d8e60a12 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -180,7 +180,7 @@ namespace {
   const Value FutilityMarginQS = Value(0x80);
 
   // Each move futility margin is decreased
-  const Value IncrementalFutilityMargin = Value(0x8);
+  const Value IncrementalFutilityMargin = Value(0x4);
 
   // Remaining depth:                  1 ply         1.5 ply       2 ply         2.5 ply       3 ply         3.5 ply
   const Value FutilityMargins[12] = { Value(0x100), Value(0x120), Value(0x200), Value(0x220), Value(0x250), Value(0x270),
@@ -1121,7 +1121,14 @@ namespace {
         return alpha;
 
     // Transposition table lookup. At PV nodes, we don't use the TT for
-    // pruning, but only for move ordering.
+    // pruning, but only for move ordering. This is to avoid problems in
+    // the following areas:
+    //
+    // * Repetition draw detection
+    // * Fifty move rule detection
+    // * Searching for a mate
+    // * Printing of full PV line
+    //
     tte = TT.retrieve(pos.get_key());
     ttMove = (tte ? tte->move() : MOVE_NONE);
 
@@ -1130,6 +1137,10 @@ namespace {
     {
         search_pv(pos, ss, alpha, beta, depth-2*OnePly, ply, threadID);
         ttMove = ss[ply].pv[ply];
+        tte = TT.retrieve(pos.get_key());
+
+        // If tte->move() != MOVE_NONE then it equals ttMove
+        assert(!(tte && tte->move()) || tte->move() == ttMove);
     }
 
     // Initialize a MovePicker object for the current position, and prepare
@@ -1158,8 +1169,9 @@ namespace {
       // To verify this we do a reduced search on all the other moves but the ttMove,
       // if result is lower then TT value minus a margin then we assume ttMove is the
       // only one playable. It is a kind of relaxed single reply extension.
-      if (   depth >= 8 * OnePly
-          && move == ttMove
+      if (   depth >= 6 * OnePly
+          && tte
+          && move == tte->move()
           && ext < OnePly
           && is_lower_bound(tte->type())
           && tte->depth() >= depth - 3 * OnePly)
@@ -1168,7 +1180,7 @@ namespace {
 
           if (abs(ttValue) < VALUE_KNOWN_WIN)
           {
-              Value excValue = search(pos, ss, ttValue - SingleReplyMargin, depth / 2, ply, false, threadID, ttMove);
+              Value excValue = search(pos, ss, ttValue - SingleReplyMargin, depth / 2, ply, false, threadID, move);
 
               // If search result is well below the foreseen score of the ttMove then we
               // assume ttMove is the only one realistically playable and we extend it.
@@ -1423,6 +1435,7 @@ namespace {
     {
         search(pos, ss, beta, Min(depth/2, depth-2*OnePly), ply, false, threadID);
         ttMove = ss[ply].pv[ply];
+        tte = TT.retrieve(pos.get_key());
     }
 
     // Initialize a MovePicker object for the current position, and prepare
@@ -1439,6 +1452,12 @@ namespace {
     // Move count pruning limit
     const int MCLimit = 3 + (1 << (3*int(depth)/8));
 
+    /*
+    for (int d = 2; d < 16; d++)
+        std::cout << d << " -> " << 56*(0+2*bitScanReverse32(1 * int(d) * int(d) / 2)) << std::endl;
+        //std::cout << d << " -> " << 32*(1+3*bitScanReverse32(1 * int(d) * int(d))) << std::endl;
+    */
+
     // Loop through all legal moves until no moves remain or a beta cutoff occurs
     while (   bestValue < beta
            && (move = mp.get_next_move()) != MOVE_NONE
@@ -1461,8 +1480,9 @@ namespace {
       // if result is lower then TT value minus a margin then we assume ttMove is the
       // only one playable. It is a kind of relaxed single reply extension.
       if (   depth >= 8 * OnePly
-          && !excludedMove // do not allow recursive single-reply search
-          && move == ttMove
+          && tte
+          && move == tte->move()
+          && !excludedMove // Do not allow recursive single-reply search
           && ext < OnePly
           && is_lower_bound(tte->type())
           && tte->depth() >= depth - 3 * OnePly)
@@ -1471,7 +1491,7 @@ namespace {
 
           if (abs(ttValue) < VALUE_KNOWN_WIN)
           {
-              Value excValue = search(pos, ss, ttValue - SingleReplyMargin, depth / 2, ply, false, threadID, ttMove);
+              Value excValue = search(pos, ss, ttValue - SingleReplyMargin, depth / 2, ply, false, threadID, move);
 
               // If search result is well below the foreseen score of the ttMove then we
               // assume ttMove is the only one realistically playable and we extend it.
@@ -1499,10 +1519,10 @@ namespace {
 
           // Value based pruning
           if (approximateEval < beta)
-          {
+          {//dbg_before();
               if (futilityValue == VALUE_NONE)
                   futilityValue =  evaluate(pos, ei, threadID)
-                                 + 64*(2+bitScanReverse32(int(depth) * int(depth)));
+                                 + 56*(0+2*bitScanReverse32(1 * int(depth) * int(depth) / 2));
 
               futilityValueScaled = futilityValue - moveCount * IncrementalFutilityMargin;
 
@@ -1512,6 +1532,7 @@ namespace {
                       bestValue = futilityValueScaled;
                   continue;
               }
+           //dbg_after(); // 36% (inc == 8), 40% (inc == 4), 37%(56)
           }
       }