We need just one eval margin in search

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index db08b1c49e22179fee74b556741104ec3c5d1567..82bf7b06908a5db47820f0a52627991da6e2f5c2 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -230,7 +230,7 @@ namespace {
 
   // Function prototypes
   template<bool HasPopCnt>
-  Value do_evaluate(const Position& pos, Value margins[]);
+  Value do_evaluate(const Position& pos, Value& margin);
 
   template<Color Us, bool HasPopCnt>
   void init_eval_info(const Position& pos, EvalInfo& ei);
@@ -239,7 +239,7 @@ namespace {
   Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility);
 
   template<Color Us, bool HasPopCnt>
-  Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]);
+  Score evaluate_king(const Position& pos, EvalInfo& ei, Value& margin);
 
   template<Color Us>
   Score evaluate_threats(const Position& pos, EvalInfo& ei);
@@ -273,16 +273,16 @@ void prefetchPawn(Key key, int threadID) {
 /// evaluate() is the main evaluation function. It always computes two
 /// values, an endgame score and a middle game score, and interpolates
 /// between them based on the remaining material.
-Value evaluate(const Position& pos, Value margins[]) {
+Value evaluate(const Position& pos, Value& margin) {
 
-    return CpuHasPOPCNT ? do_evaluate<true>(pos, margins)
-                        : do_evaluate<false>(pos, margins);
+    return CpuHasPOPCNT ? do_evaluate<true>(pos, margin)
+                        : do_evaluate<false>(pos, margin);
 }
 
 namespace {
 
 template<bool HasPopCnt>
-Value do_evaluate(const Position& pos, Value margins[]) {
+Value do_evaluate(const Position& pos, Value& margin) {
 
   EvalInfo ei;
   ScaleFactor factor[2];
@@ -296,9 +296,9 @@ Value do_evaluate(const Position& pos, Value margins[]) {
   // in the position object (material + piece square tables).
   Score bonus = pos.value();
 
-  // margins[color] is the uncertainty estimation of position's evaluation
+  // margin is the uncertainty estimation of position's evaluation
   // and typically is used by the search for pruning decisions.
-  margins[WHITE] = margins[BLACK] = VALUE_ZERO;
+  margin = VALUE_ZERO;
 
   // Probe the material hash table
   MaterialInfo* mi = MaterialTable[pos.thread()]->get_material_info(pos);
@@ -329,8 +329,8 @@ Value do_evaluate(const Position& pos, Value margins[]) {
 
   // Evaluate kings after all other pieces because we need complete attack
   // information when computing the king safety evaluation.
-  bonus +=  evaluate_king<WHITE, HasPopCnt>(pos, ei, margins)
-          - evaluate_king<BLACK, HasPopCnt>(pos, ei, margins);
+  bonus +=  evaluate_king<WHITE, HasPopCnt>(pos, ei, margin)
+          - evaluate_king<BLACK, HasPopCnt>(pos, ei, margin);
 
   // Evaluate tactical threats, we need full attack information including king
   bonus +=  evaluate_threats<WHITE>(pos, ei)
@@ -663,7 +663,7 @@ namespace {
   // evaluate_king<>() assigns bonuses and penalties to a king of a given color
 
   template<Color Us, bool HasPopCnt>
-  Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]) {
+  Score evaluate_king(const Position& pos, EvalInfo& ei, Value& margin) {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
 
@@ -764,7 +764,8 @@ namespace {
         // be very big, and so capturing a single attacking piece can therefore
         // result in a score change far bigger than the value of the captured piece.
         bonus -= KingDangerTable[Us][attackUnits];
-        margins[Us] += mg_value(KingDangerTable[Us][attackUnits]);
+        if (pos.side_to_move() == Us)
+            margin += mg_value(KingDangerTable[Us][attackUnits]);
     }
     return bonus;
   }

diff --git a/src/evaluate.h b/src/evaluate.h
index 538f982eacb9b27b5f319693d544331ece7714f8..4a04e739d4cc3b6311c7f3d97be9684d97c0dca1 100644 (file)
--- a/src/evaluate.h
+++ b/src/evaluate.h
@@ -26,7 +26,7 @@
 
 class Position;
 
-extern Value evaluate(const Position& pos, Value margins[]);
+extern Value evaluate(const Position& pos, Value& margin);
 extern void init_eval(int threads);
 extern void quit_eval();
 extern void read_weights(Color sideToMove);

diff --git a/src/search.cpp b/src/search.cpp
index 4a5473fcd96b5b92a844e82ab5fe64f05b40c2f0..627a64af2cc5b4ab6da5b31b59a809dcceabd428 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -716,13 +716,12 @@ namespace {
 
   Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr) {
 
-    Value margins[2];
     StateInfo st;
     CheckInfo ci(pos);
     int64_t nodes;
     Move move;
     Depth depth, ext, newDepth;
-    Value value, alpha, beta;
+    Value value, evalMargin, alpha, beta;
     bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
     int researchCountFH, researchCountFL;
 
@@ -741,7 +740,7 @@ namespace {
 
     // Step 5. Evaluate the position statically
     // At root we do this only to get reference value for child nodes
-    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, margins);
+    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, evalMargin);
 
     // Step 6. Razoring (omitted at root)
     // Step 7. Static null move pruning (omitted at root)
@@ -977,13 +976,12 @@ namespace {
     assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
 
     Move movesSearched[MOVES_MAX];
-    Value margins[2];
     StateInfo st;
     const TTEntry *tte;
     Key posKey;
     Move ttMove, move, excludedMove, threatMove;
     Depth ext, newDepth;
-    Value bestValue, value, oldAlpha;
+    Value bestValue, value, evalMargin, oldAlpha;
     Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
     bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
@@ -1047,19 +1045,19 @@ namespace {
     // update gain statistics of parent move.
     isCheck = pos.is_check();
     if (isCheck)
-        ss->eval = VALUE_NONE;
+        ss->eval = evalMargin = VALUE_NONE;
     else if (tte)
     {
         assert(tte->static_value() != VALUE_NONE);
 
         ss->eval = tte->static_value();
-        margins[pos.side_to_move()] = tte->static_value_margin();
+        evalMargin = tte->static_value_margin();
         refinedValue = refine_eval(tte, ss->eval, ply);
     }
     else
     {
-        refinedValue = ss->eval = evaluate(pos, margins);
-        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, margins[pos.side_to_move()]);
+        refinedValue = ss->eval = evaluate(pos, evalMargin);
+        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
     }
 
     // Save gain for the parent non-capture move
@@ -1184,7 +1182,7 @@ namespace {
     CheckInfo ci(pos);
     ss->bestMove = MOVE_NONE;
     singleEvasion = isCheck && mp.number_of_evasions() == 1;
-    futilityBase = ss->eval + margins[pos.side_to_move()];
+    futilityBase = ss->eval + evalMargin;
     singularExtensionNode =   depth >= SingularExtensionDepth[PvNode]
                            && tte
                            && tte->move()
@@ -1374,7 +1372,7 @@ namespace {
 
     ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
     move = (bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove);
-    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, margins[pos.side_to_move()]);
+    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, evalMargin);
 
     // Update killers and history only for non capture moves that fails high
     if (    bestValue >= beta
@@ -1404,10 +1402,9 @@ namespace {
     assert(ply > 0 && ply < PLY_MAX);
     assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
 
-    Value margins[2];
     StateInfo st;
     Move ttMove, move;
-    Value bestValue, value, futilityValue, futilityBase;
+    Value bestValue, value, evalMargin, futilityValue, futilityBase;
     bool isCheck, deepChecks, enoughMaterial, moveIsCheck, evasionPrunable;
     const TTEntry* tte;
     Value oldAlpha = alpha;
@@ -1436,7 +1433,7 @@ namespace {
     if (isCheck)
     {
         bestValue = futilityBase = -VALUE_INFINITE;
-        ss->eval = VALUE_NONE;
+        ss->eval = evalMargin = VALUE_NONE;
         deepChecks = enoughMaterial = false;
     }
     else
@@ -1445,11 +1442,11 @@ namespace {
         {
             assert(tte->static_value() != VALUE_NONE);
 
-            margins[pos.side_to_move()] = tte->static_value_margin();
+            evalMargin = tte->static_value_margin();
             bestValue = tte->static_value();
         }
         else
-            bestValue = evaluate(pos, margins);
+            bestValue = evaluate(pos, evalMargin);
 
         ss->eval = bestValue;
         update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
@@ -1458,7 +1455,7 @@ namespace {
         if (bestValue >= beta)
         {
             if (!tte)
-                TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, margins[pos.side_to_move()]);
+                TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
 
             return bestValue;
         }
@@ -1470,7 +1467,7 @@ namespace {
         deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
 
         // Futility pruning parameters, not needed when in check
-        futilityBase = bestValue + FutilityMarginQS + margins[pos.side_to_move()];
+        futilityBase = bestValue + FutilityMarginQS + evalMargin;
         enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
     }
 
@@ -1555,7 +1552,7 @@ namespace {
     // Update transposition table
     Depth d = (depth == DEPTH_ZERO ? DEPTH_ZERO : DEPTH_ZERO - ONE_PLY);
     ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
-    TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, margins[pos.side_to_move()]);
+    TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, evalMargin);
 
     // Update killers only for checking moves that fails high
     if (    bestValue >= beta
@@ -2245,16 +2242,15 @@ namespace {
     StateInfo st;
     TTEntry* tte;
     Position p(pos, pos.thread());
-    Value margins[2];
-    Value v;
+    Value v, m = VALUE_NONE;
 
     for (int i = 0; pv[i] != MOVE_NONE; i++)
     {
         tte = TT.retrieve(p.get_key());
         if (!tte || tte->move() != pv[i])
         {
-            v = (p.is_check() ? VALUE_NONE : evaluate(p, margins));
-            TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, margins[pos.side_to_move()]);
+            v = (p.is_check() ? VALUE_NONE : evaluate(p, m));
+            TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, m);
         }
         p.do_move(pv[i], st);
     }

diff --git a/src/uci.cpp b/src/uci.cpp
index 0225a85a49c68ba29189e1eb32dd6fc17a3ce93b..5ba31e7050598e44b24192be76640633daf94f5b 100644 (file)
--- a/src/uci.cpp
+++ b/src/uci.cpp
@@ -150,10 +150,10 @@ namespace {
     }
     else if (token == "eval")
     {
-        Value margins[2];
+        Value evalMargin;
         cout << "Incremental mg: "   << mg_value(RootPosition.value())
              << "\nIncremental eg: " << eg_value(RootPosition.value())
-             << "\nFull eval: "      << evaluate(RootPosition, margins) << endl;
+             << "\nFull eval: "      << evaluate(RootPosition, evalMargin) << endl;
     }
     else if (token == "key")
         cout << "key: " << hex << RootPosition.get_key()