Revert store of distinct upper and lower bounds

Test by Joona prooves the new feature don't value 70 added lines of code.

Grand totals after 10040 games (crashes: 0) for tt_both

master_9edc7 - 6a93488_6a934: 1756 - 1688 - 6596 ELO +2 (+- 2.7)

Confirmed by test of Gary:

After 8680 games:
ELO: 0.80 +- 99%: 9.62 95%: 7.31
LOS: 65.38%
Wins: 1288 Losses: 1268 Draws: 6130

Thanks a lot to both for testing it !!!

bench 5149248

diff --git a/src/search.cpp b/src/search.cpp
index 98f3e3fdf0ca44553b279ff9e024cd7c7cb746ed..f6c2233b1519b8887f19919c789059e603e019d7 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -482,7 +482,7 @@ namespace {
     Key posKey;
     Move ttMove, move, excludedMove, bestMove, threatMove;
     Depth ext, newDepth;
-    Value bestValue, value, ttValue, ttValueUpper;
+    Value bestValue, value, ttValue;
     Value eval, nullValue, futilityValue;
     bool inCheck, givesCheck, pvMove, singularExtensionNode;
     bool captureOrPromotion, dangerous, doFullDepthSearch;
@@ -544,43 +544,31 @@ namespace {
     tte = TT.probe(posKey);
     ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
     ttValue = tte ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE;
-    ttValueUpper = tte ? value_from_tt(tte->value_upper(), ss->ply) : VALUE_NONE;
 
     // At PV nodes we check for exact scores, while at non-PV nodes we check for
     // a fail high/low. Biggest advantage at probing at PV nodes is to have a
     // smooth experience in analysis mode. We don't probe at Root nodes otherwise
     // we should also update RootMoveList to avoid bogus output.
-    if (!RootNode && tte)
+    if (   !RootNode
+        && tte
+        && tte->depth() >= depth
+        && ttValue != VALUE_NONE // Only in case of TT access race
+        && (           PvNode ?  tte->type() == BOUND_EXACT
+            : ttValue >= beta ? (tte->type() & BOUND_LOWER)
+                              : (tte->type() & BOUND_UPPER)))
     {
-        // Fail High
-        if (  (tte->type() & BOUND_LOWER)
-            && ttValue >= beta
-            && tte->depth() >= depth
-            && ttValue != VALUE_NONE) // Only in case of TT access race
-        {
-            // Update killers, we assume ttMove caused a cut-off
-            if (    ttMove
-                && !pos.is_capture_or_promotion(ttMove)
-                &&  ttMove != ss->killers[0])
-            {
-                ss->killers[1] = ss->killers[0];
-                ss->killers[0] = ttMove;
-            }
-            TT.refresh(tte);
-            ss->currentMove = ttMove; // Can be MOVE_NONE
-            return ttValue;
-        }
+        TT.refresh(tte);
+        ss->currentMove = ttMove; // Can be MOVE_NONE
 
-        // Fail Low
-        if (  (tte->type() & BOUND_UPPER)
-            && ttValueUpper <= alpha
-            && tte->depth_upper() >= depth
-            && ttValueUpper != VALUE_NONE) // Only in case of TT access race
+        if (    ttValue >= beta
+            &&  ttMove
+            && !pos.is_capture_or_promotion(ttMove)
+            &&  ttMove != ss->killers[0])
         {
-            TT.refresh(tte);
-            ss->currentMove = ttMove; // Can be MOVE_NONE
-            return ttValueUpper;
+            ss->killers[1] = ss->killers[0];
+            ss->killers[0] = ttMove;
         }
+        return ttValue;
     }
 
     // Step 5. Evaluate the position statically and update parent's gain statistics
@@ -1101,7 +1089,7 @@ split_point_start: // At split points actual search starts from here
     const TTEntry* tte;
     Key posKey;
     Move ttMove, move, bestMove;
-    Value bestValue, value, ttValue, ttValueUpper, futilityValue, futilityBase, oldAlpha;
+    Value bestValue, value, ttValue, futilityValue, futilityBase, oldAlpha;
     bool givesCheck, enoughMaterial, evasionPrunable, fromNull;
     Depth ttDepth;
 
@@ -1123,34 +1111,21 @@ split_point_start: // At split points actual search starts from here
     tte = TT.probe(posKey);
     ttMove = tte ? tte->move() : MOVE_NONE;
     ttValue = tte ? value_from_tt(tte->value(),ss->ply) : VALUE_NONE;
-    ttValueUpper = tte ? value_from_tt(tte->value_upper(),ss->ply) : VALUE_NONE;
 
     // Decide whether or not to include checks, this fixes also the type of
     // TT entry depth that we are going to use. Note that in qsearch we use
     // only two types of depth in TT: DEPTH_QS_CHECKS or DEPTH_QS_NO_CHECKS.
     ttDepth = InCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS
                                                   : DEPTH_QS_NO_CHECKS;
-    if (tte)
+    if (   tte
+        && tte->depth() >= ttDepth
+        && ttValue != VALUE_NONE // Only in case of TT access race
+        && (           PvNode ?  tte->type() == BOUND_EXACT
+            : ttValue >= beta ? (tte->type() & BOUND_LOWER)
+                              : (tte->type() & BOUND_UPPER)))
     {
-        // Fail High
-        if (  (tte->type() & BOUND_LOWER)
-            && ttValue >= beta
-            && tte->depth() >= ttDepth
-            && ttValue != VALUE_NONE) // Only in case of TT access race
-        {
-            ss->currentMove = ttMove; // Can be MOVE_NONE
-            return ttValue;
-        }
-
-        // Fail Low
-        if (  (tte->type() & BOUND_UPPER)
-            && ttValueUpper <= alpha
-            && tte->depth_upper() >= ttDepth
-            && ttValueUpper != VALUE_NONE) // Only in case of TT access race
-        {
-            ss->currentMove = ttMove; // Can be MOVE_NONE
-            return ttValueUpper;
-        }
+        ss->currentMove = ttMove; // Can be MOVE_NONE
+        return ttValue;
     }
 
     // Evaluate the position statically

diff --git a/src/tt.cpp b/src/tt.cpp
index 8a66812a79c1eda84909dc20d09ead945a1c89de..40dca0d3b2524b221d14f0d2a7fccf2049d3a64a 100644 (file)
--- a/src/tt.cpp
+++ b/src/tt.cpp
@@ -82,7 +82,7 @@ void TranspositionTable::clear() {
 /// more valuable than a TTEntry t2 if t1 is from the current search and t2 is from
 /// a previous search, or if the depth of t1 is bigger than the depth of t2.
 
-void TranspositionTable::store(const Key posKey, Value v, Bound b, Depth d, Move m) {
+void TranspositionTable::store(const Key posKey, Value v, Bound t, Depth d, Move m) {
 
   int c1, c2, c3;
   TTEntry *tte, *replace;
@@ -92,16 +92,13 @@ void TranspositionTable::store(const Key posKey, Value v, Bound b, Depth d, Move
 
   for (int i = 0; i < ClusterSize; i++, tte++)
   {
-      if (!tte->key())
-          tte->save(posKey32, v, b, d, m, generation);
-
-      if (tte->key() == posKey32)
+      if (!tte->key() || tte->key() == posKey32) // Empty or overwrite old
       {
           // Preserve any existing ttMove
           if (m == MOVE_NONE)
               m = tte->move();
 
-          tte->update(v, b, d, m, generation);
+          tte->save(posKey32, v, t, d, m, generation);
           return;
       }
 
@@ -113,7 +110,7 @@ void TranspositionTable::store(const Key posKey, Value v, Bound b, Depth d, Move
       if (c1 + c2 + c3 > 0)
           replace = tte;
   }
-  replace->save(posKey32, v, b, d, m, generation);
+  replace->save(posKey32, v, t, d, m, generation);
 }
 
 

diff --git a/src/tt.h b/src/tt.h
index c41f231e2a251ec8f3035a5509abdca3e6232635..719f178d59e8956dbe3467eb44a397de15bd61be 100644 (file)
--- a/src/tt.h
+++ b/src/tt.h
@@ -46,61 +46,19 @@ class TTEntry {
 public:
   void save(uint32_t k, Value v, Bound b, Depth d, Move m, int g) {
 
-    key32       = (uint32_t)k;
-    move16      = (uint16_t)m;
-    bound       = (uint8_t)b;
-    generation8 = (uint8_t)g;
-    valueUpper = (int16_t)(b & BOUND_UPPER ? v : VALUE_NONE);
-    depthUpper = (int16_t)(b & BOUND_UPPER ? d : DEPTH_NONE);
-    valueLower = (int16_t)(b & BOUND_LOWER ? v : VALUE_NONE);
-    depthLower = (int16_t)(b & BOUND_LOWER ? d : DEPTH_NONE);
+    key32        = (uint32_t)k;
+    move16       = (uint16_t)m;
+    bound        = (uint8_t)b;
+    generation8  = (uint8_t)g;
+    value16      = (int16_t)v;
+    depth16      = (int16_t)d;
   }
-
-  void update(Value v, Bound b, Depth d, Move m, int g) {
-
-    move16      = (uint16_t)m;
-    generation8 = (uint8_t)g;
-
-    if (bound == BOUND_EXACT)
-        bound = BOUND_UPPER | BOUND_LOWER; // Drop 'EXACT' flag
-
-    if (b & BOUND_UPPER)
-    {
-        valueUpper = (int16_t)v;
-        depthUpper = (int16_t)d;
-
-        if ((bound & BOUND_LOWER) && v < valueLower)
-        {
-            bound ^= BOUND_LOWER;
-            valueLower = VALUE_NONE;
-            depthLower = DEPTH_NONE;
-        }
-    }
-
-    if (b & BOUND_LOWER)
-    {
-        valueLower = (int16_t)v;
-        depthLower = (int16_t)d;
-
-        if ((bound & BOUND_UPPER) && v > valueUpper)
-        {
-            bound ^= BOUND_UPPER;
-            valueUpper = VALUE_NONE;
-            depthUpper = DEPTH_NONE;
-        }
-    }
-
-    bound |= (uint8_t)b;
-  }
-
   void set_generation(int g) { generation8 = (uint8_t)g; }
 
   uint32_t key() const              { return key32; }
-  Depth depth() const               { return (Depth)depthLower; }
-  Depth depth_upper() const         { return (Depth)depthUpper; }
+  Depth depth() const               { return (Depth)depth16; }
   Move move() const                 { return (Move)move16; }
-  Value value() const               { return (Value)valueLower; }
-  Value value_upper() const         { return (Value)valueUpper; }
+  Value value() const               { return (Value)value16; }
   Bound type() const                { return (Bound)bound; }
   int generation() const            { return (int)generation8; }
 
@@ -108,7 +66,7 @@ private:
   uint32_t key32;
   uint16_t move16;
   uint8_t bound, generation8;
-  int16_t valueLower, depthLower, valueUpper, depthUpper;
+  int16_t value16, depth16;
 };
 
 
@@ -138,7 +96,7 @@ public:
   ~TranspositionTable();
   void set_size(size_t mbSize);
   void clear();
-  void store(const Key posKey, Value v, Bound b, Depth d, Move m);
+  void store(const Key posKey, Value v, Bound type, Depth d, Move m);
   TTEntry* probe(const Key posKey) const;
   void new_search();
   TTEntry* first_entry(const Key posKey) const;

diff --git a/src/types.h b/src/types.h
index 785d98986ea39e1cbcab7bbb8e65562ace65efe7..99567bd7e22a608de7ca91a16d81058112661624 100644 (file)
--- a/src/types.h
+++ b/src/types.h
@@ -164,7 +164,7 @@ enum Bound {
   BOUND_NONE  = 0,
   BOUND_UPPER = 1,
   BOUND_LOWER = 2,
-  BOUND_EXACT = BOUND_UPPER | BOUND_LOWER | 4
+  BOUND_EXACT = BOUND_UPPER | BOUND_LOWER
 };
 
 enum Value {