X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=9fc1bd42565e9b90b3800d268279d928c5e1a223;hp=7d9d402c0ac6c5dedc6af55711809293ee69a069;hb=427dc2a82c82c69e964a3f7a2030f9417d0beee9;hpb=c7a932bc744f899f53ce0013cbbbaa86915bb2e8

diff --git a/src/search.cpp b/src/search.cpp
index 7d9d402c..9fc1bd42 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -114,7 +114,7 @@ namespace {
 
   struct RootMove {
 
-    RootMove() : mp_score(0), nodes(0), cumulativeNodes(0) {}
+    RootMove() : mp_score(0), nodes(0) {}
 
     // RootMove::operator<() is the comparison function used when
     // sorting the moves. A move m1 is considered to be better
@@ -128,7 +128,7 @@ namespace {
     Move move;
     Value score;
     int mp_score;
-    int64_t nodes, cumulativeNodes;
+    int64_t nodes;
     Move pv[PLY_MAX_PLUS_2];
   };
 
@@ -146,10 +146,10 @@ namespace {
     Value get_move_score(int moveNum) const { return moves[moveNum].score; }
     void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; }
     Move get_move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
-    int64_t get_move_cumulative_nodes(int moveNum) const { return moves[moveNum].cumulativeNodes; }
+    int64_t get_move_nodes(int moveNum) const { return moves[moveNum].nodes; }
     void score_moves(const Position& pos);
 
-    void set_move_nodes(int moveNum, int64_t nodes);
+    void add_move_nodes(int moveNum, int64_t nodes) { moves[moveNum].nodes += nodes; }
     void set_move_pv(int moveNum, const Move pv[]);
     void sort();
     void sort_multipv(int n);
@@ -629,9 +629,9 @@ namespace {
             int64_t nodes = ThreadsMgr.nodes_searched();
             if (   Iteration >= 8
                 && EasyMove == pv[0]
-                && (  (   rml.get_move_cumulative_nodes(0) > (nodes * 85) / 100
+                && (  (   rml.get_move_nodes(0) > (nodes * 85) / 100
                        && current_search_time() > TimeMgr.available_time() / 16)
-                    ||(   rml.get_move_cumulative_nodes(0) > (nodes * 98) / 100
+                    ||(   rml.get_move_nodes(0) > (nodes * 98) / 100
                        && current_search_time() > TimeMgr.available_time() / 32)))
                 stopSearch = true;
 
@@ -714,7 +714,7 @@ namespace {
 
   Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr) {
 
-    EvalInfo ei;
+    Value margins[2];
     StateInfo st;
     CheckInfo ci(pos);
     int64_t nodes;
@@ -739,7 +739,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, ei);
+    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, margins);
 
     // Step 6. Razoring (omitted at root)
     // Step 7. Static null move pruning (omitted at root)
@@ -883,7 +883,7 @@ namespace {
                 break;
 
             // Remember searched nodes counts for this move
-            rml.set_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
+            rml.add_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
 
             assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
             assert(value < beta);
@@ -975,14 +975,14 @@ namespace {
     assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
 
     Move movesSearched[256];
-    EvalInfo ei;
+    Value margins[2];
     StateInfo st;
     const TTEntry *tte;
     Key posKey;
     Move ttMove, move, excludedMove, threatMove;
     Depth ext, newDepth;
     Value bestValue, value, oldAlpha;
-    Value refinedValue, nullValue, futilityValueScaled; // Non-PV specific
+    Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
     bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
     int moveCount = 0;
@@ -1051,13 +1051,13 @@ namespace {
         assert(tte->static_value() != VALUE_NONE);
 
         ss->eval = tte->static_value();
-        ei.margin[pos.side_to_move()] = tte->static_value_margin();
+        margins[pos.side_to_move()] = tte->static_value_margin();
         refinedValue = refine_eval(tte, ss->eval, ply);
     }
     else
     {
-        refinedValue = ss->eval = evaluate(pos, ei);
-        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ei.margin[pos.side_to_move()]);
+        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()]);
     }
 
     // Save gain for the parent non-capture move
@@ -1182,6 +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()];
     singularExtensionNode =   depth >= SingularExtensionDepth[PvNode]
                            && tte
                            && tte->move()
@@ -1253,7 +1254,7 @@ namespace {
           // We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
           // but fixing this made program slightly weaker.
           Depth predictedDepth = newDepth - reduction<NonPV>(depth, moveCount);
-          futilityValueScaled =  ss->eval + futility_margin(predictedDepth, moveCount)
+          futilityValueScaled =  futilityBase + futility_margin(predictedDepth, moveCount)
                                + H.gain(pos.piece_on(move_from(move)), move_to(move));
 
           if (futilityValueScaled < beta)
@@ -1371,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, ei.margin[pos.side_to_move()]);
+    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, margins[pos.side_to_move()]);
 
     // Update killers and history only for non capture moves that fails high
     if (    bestValue >= beta
@@ -1401,7 +1402,7 @@ namespace {
     assert(ply > 0 && ply < PLY_MAX);
     assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
 
-    EvalInfo ei;
+    Value margins[2];
     StateInfo st;
     Move ttMove, move;
     Value bestValue, value, futilityValue, futilityBase;
@@ -1442,11 +1443,11 @@ namespace {
         {
             assert(tte->static_value() != VALUE_NONE);
 
-            ei.margin[pos.side_to_move()] = tte->static_value_margin();
+            margins[pos.side_to_move()] = tte->static_value_margin();
             bestValue = tte->static_value();
         }
         else
-            bestValue = evaluate(pos, ei);
+            bestValue = evaluate(pos, margins);
 
         ss->eval = bestValue;
         update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
@@ -1455,7 +1456,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, ei.margin[pos.side_to_move()]);
+                TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, margins[pos.side_to_move()]);
 
             return bestValue;
         }
@@ -1467,7 +1468,7 @@ namespace {
         deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
 
         // Futility pruning parameters, not needed when in check
-        futilityBase = bestValue + FutilityMarginQS + ei.margin[pos.side_to_move()];
+        futilityBase = bestValue + FutilityMarginQS + margins[pos.side_to_move()];
         enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
     }
 
@@ -1552,7 +1553,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, ei.margin[pos.side_to_move()]);
+    TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, margins[pos.side_to_move()]);
 
     // Update killers only for checking moves that fails high
     if (    bestValue >= beta
@@ -2242,7 +2243,7 @@ namespace {
     StateInfo st;
     TTEntry* tte;
     Position p(pos, pos.thread());
-    EvalInfo ei;
+    Value margins[2];
     Value v;
 
     for (int i = 0; pv[i] != MOVE_NONE; i++)
@@ -2250,8 +2251,8 @@ namespace {
         tte = TT.retrieve(p.get_key());
         if (!tte || tte->move() != pv[i])
         {
-            v = (p.is_check() ? VALUE_NONE : evaluate(p, ei));
-            TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, ei.margin[pos.side_to_move()]);
+            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()]);
         }
         p.do_move(pv[i], st);
     }
@@ -2784,12 +2785,6 @@ namespace {
 
   // RootMoveList simple methods definitions
 
-  void RootMoveList::set_move_nodes(int moveNum, int64_t nodes) {
-
-    moves[moveNum].nodes = nodes;
-    moves[moveNum].cumulativeNodes += nodes;
-  }
-
   void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
 
     int j;