Retire update_gains()

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index 438a01be6c8ed7defbf765430f0404c3a0f37ca1..30e0502086fddb09cd0b9d41222855f478c4e178 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -196,7 +196,6 @@ namespace {
   bool connected_threat(const Position& pos, Move m, Move threat);
   Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
   void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount);
-  void update_gains(const Position& pos, Move move, Value before, Value after);
   void do_skill_level(Move* best, Move* ponder);
 
   int current_search_time(int set = 0);
@@ -284,7 +283,7 @@ namespace {
     if (   captureOrPromotion
         && type_of(pos.piece_on(move_to(m))) != PAWN
         && (  pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
-            - piece_value_midgame(pos.piece_on(move_to(m))) == VALUE_ZERO)
+            - PieceValueMidgame[pos.piece_on(move_to(m))] == VALUE_ZERO)
         && !is_special(m))
     {
         result += PawnEndgameExtension[PvNode];
@@ -503,7 +502,7 @@ namespace {
     *ponderMove = bestMove = easyMove = skillBest = skillPonder = MOVE_NONE;
     depth = aspirationDelta = 0;
     value = alpha = -VALUE_INFINITE, beta = VALUE_INFINITE;
-    ss->currentMove = MOVE_NULL; // Hack to skip update_gains()
+    ss->currentMove = MOVE_NULL; // Hack to skip update gains
 
     // Moves to search are verified and copied
     Rml.init(pos, searchMoves);
@@ -551,7 +550,7 @@ namespace {
             // research with bigger window until not failing high/low anymore.
             do {
                 // Search starts from ss+1 to allow referencing (ss-1). This is
-                // needed by update_gains() and ss copy when splitting at Root.
+                // needed by update gains and ss copy when splitting at Root.
                 value = search<Root>(pos, ss+1, alpha, beta, depth * ONE_PLY);
 
                 // Bring to front the best move. It is critical that sorting is
@@ -820,8 +819,17 @@ namespace {
         TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin);
     }
 
-    // Save gain for the parent non-capture move
-    update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
+    // Update gain for the parent non-capture move given the static position
+    // evaluation before and after the move.
+    if (   (move = (ss-1)->currentMove) != MOVE_NULL
+        && (ss-1)->eval != VALUE_NONE
+        && ss->eval != VALUE_NONE
+        && pos.captured_piece_type() == PIECE_TYPE_NONE
+        && !is_special(move))
+    {
+        Square to = move_to(move);
+        H.update_gain(pos.piece_on(to), to, -(ss-1)->eval - ss->eval);
+    }
 
     // Step 6. Razoring (is omitted in PV nodes)
     if (   !PvNode
@@ -870,12 +878,12 @@ namespace {
         if (refinedValue - PawnValueMidgame > beta)
             R++;
 
-        pos.do_null_move(st);
+        pos.do_null_move<true>(st);
         (ss+1)->skipNullMove = true;
         nullValue = depth-R*ONE_PLY < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -beta, -alpha, DEPTH_ZERO)
                                               : - search<NonPV>(pos, ss+1, -beta, -alpha, depth-R*ONE_PLY);
         (ss+1)->skipNullMove = false;
-        pos.undo_null_move();
+        pos.do_null_move<false>(st);
 
         if (nullValue >= beta)
         {
@@ -1399,7 +1407,7 @@ split_point_start: // At split points actual search starts from here
           && !pos.is_passed_pawn_push(move))
       {
           futilityValue =  futilityBase
-                         + piece_value_endgame(pos.piece_on(move_to(move)))
+                         + PieceValueEndgame[pos.piece_on(move_to(move))]
                          + (is_enpassant(move) ? PawnValueEndgame : VALUE_ZERO);
 
           if (futilityValue < beta)
@@ -1532,7 +1540,7 @@ split_point_start: // At split points actual search starts from here
     while (b)
     {
         victimSq = pop_1st_bit(&b);
-        futilityValue = futilityBase + piece_value_endgame(pos.piece_on(victimSq));
+        futilityValue = futilityBase + PieceValueEndgame[pos.piece_on(victimSq)];
 
         // Note that here we generate illegal "double move"!
         if (   futilityValue >= beta
@@ -1656,7 +1664,7 @@ split_point_start: // At split points actual search starts from here
     // Case 2: If the threatened piece has value less than or equal to the
     // value of the threatening piece, don't prune moves which defend it.
     if (   pos.is_capture(threat)
-        && (   piece_value_midgame(pos.piece_on(tfrom)) >= piece_value_midgame(pos.piece_on(tto))
+        && (   PieceValueMidgame[pos.piece_on(tfrom)] >= PieceValueMidgame[pos.piece_on(tto)]
             || type_of(pos.piece_on(tfrom)) == KING)
         && pos.move_attacks_square(m, tto))
         return true;
@@ -1726,20 +1734,6 @@ split_point_start: // At split points actual search starts from here
   }
 
 
-  // update_gains() updates the gains table of a non-capture move given
-  // the static position evaluation before and after the move.
-
-  void update_gains(const Position& pos, Move m, Value before, Value after) {
-
-    if (   m != MOVE_NULL
-        && before != VALUE_NONE
-        && after != VALUE_NONE
-        && pos.captured_piece_type() == PIECE_TYPE_NONE
-        && !is_special(m))
-        H.update_gain(pos.piece_on(move_to(m)), move_to(m), -(before + after));
-  }
-
-
   // current_search_time() returns the number of milliseconds which have passed
   // since the beginning of the current search.