Reformat stats update
authorMarco Costalba <mcostalba@gmail.com>
Wed, 24 Aug 2016 14:52:05 +0000 (16:52 +0200)
committerMarco Costalba <mcostalba@gmail.com>
Thu, 25 Aug 2016 07:51:50 +0000 (09:51 +0200)
Rewritten in a way to have explicit in the search
the bonus/penalty we apply: hopefully this will lead
to further simplification/fix of current rather messy
stats update code.

No functional change.

src/search.cpp

index 15f0885..0358cd2 100644 (file)
@@ -168,7 +168,8 @@ namespace {
   Value value_to_tt(Value v, int ply);
   Value value_from_tt(Value v, int ply);
   void update_pv(Move* pv, Move move, Move* childPv);
-  void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt);
+  void update_stats(const Position& pos, Stack* ss, Move move, Move* quiets, int quietsCnt, Value bonus);
+  void update_opponent_stats(const Position& pos, Stack* ss, Value bonus);
   void check_time();
 
 } // namespace
@@ -637,8 +638,22 @@ namespace {
 
         // If ttMove is quiet, update killers, history, counter move on TT hit
         if (ttValue >= beta && ttMove)
-            update_stats(pos, ss, ttMove, depth, nullptr, 0);
+        {
+            int d = depth / ONE_PLY;
 
+            if (!pos.capture_or_promotion(ttMove))
+            {
+                Value bonus = Value(d * d + 2 * d - 2);
+                update_stats(pos, ss, ttMove, nullptr, 0, bonus);
+            }
+
+            // Extra penalty for a quiet TT move in previous ply when it gets refuted
+            if ((ss-1)->moveCount == 1 && !pos.captured_piece_type())
+            {
+                Value penalty = Value(d * d + 4 * d + 1);
+                update_opponent_stats(pos, ss, -penalty);
+            }
+        }
         return ttValue;
     }
 
@@ -1111,26 +1126,32 @@ moves_loop: // When in check search starts from here
     if (!moveCount)
         bestValue = excludedMove ? alpha
                    :     inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()];
-
-    // Quiet best move: update killers, history and countermoves
     else if (bestMove)
-        update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount);
+    {
+        int d = depth / ONE_PLY;
 
+        // Quiet best move: update killers, history and countermoves
+        if (!pos.capture_or_promotion(bestMove))
+        {
+            Value bonus = Value(d * d + 2 * d - 2);
+            update_stats(pos, ss, bestMove, quietsSearched, quietCount, bonus);
+        }
+
+        // Extra penalty for a quiet TT move in previous ply when it gets refuted
+        if ((ss-1)->moveCount == 1 && !pos.captured_piece_type())
+        {
+            Value penalty = Value(d * d + 4 * d + 1);
+            update_opponent_stats(pos, ss, -penalty);
+        }
+    }
     // Bonus for prior countermove that caused the fail low
     else if (    depth >= 3 * ONE_PLY
              && !pos.captured_piece_type()
              && is_ok((ss-1)->currentMove))
     {
-        Square prevSq = to_sq((ss-1)->currentMove);
-        Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + 2 * depth / ONE_PLY - 2);
-        if ((ss-2)->counterMoves)
-            (ss-2)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus);
-
-        if ((ss-3)->counterMoves)
-            (ss-3)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus);
-
-        if ((ss-5)->counterMoves)
-            (ss-5)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus);
+        int d = depth / ONE_PLY;
+        Value bonus = Value(d * d + 2 * d - 2);
+        update_opponent_stats(pos, ss, bonus);
     }
 
     tte->save(posKey, value_to_tt(bestValue, ss->ply),
@@ -1390,34 +1411,33 @@ moves_loop: // When in check search starts from here
   }
 
 
-  // update_stats() updates killers, history, countermove and countermove plus
-  // follow-up move history when a new quiet best move is found.
+  // update_opponent_stats() updates countermoves for prior opponent move, i.e.
+  // (ss-1)->currentMove. Called for both capture and non-capture moves.
 
-  void update_stats(const Position& pos, Stack* ss, Move move,
-                    Depth depth, Move* quiets, int quietsCnt) {
+  void update_opponent_stats(const Position& pos, Stack* ss, Value bonus) {
 
-    Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + 2 * depth / ONE_PLY - 2);
     Square prevSq = to_sq((ss-1)->currentMove);
 
-    // Extra penalty for a quiet TT move in previous ply when it gets refuted
-    if ((ss-1)->moveCount == 1 && !pos.captured_piece_type())
-    {
-        CounterMoveStats* fmh   = (ss-2)->counterMoves;
-        CounterMoveStats* cmh2  = (ss-3)->counterMoves;
-        CounterMoveStats* cmh3  = (ss-5)->counterMoves;
+    CounterMoveStats* cmh  = (ss-2)->counterMoves;
+    CounterMoveStats* fmh1 = (ss-3)->counterMoves;
+    CounterMoveStats* fmh2 = (ss-5)->counterMoves;
 
-        if (fmh)
-            fmh->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
+    if (cmh)
+        cmh->update(pos.piece_on(prevSq), prevSq, bonus);
 
-        if (cmh2)
-            cmh2->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
+    if (fmh1)
+        fmh1->update(pos.piece_on(prevSq), prevSq, bonus);
 
-        if (cmh3)
-            cmh3->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
-    }
+    if (fmh2)
+        fmh2->update(pos.piece_on(prevSq), prevSq, bonus);
+  }
 
-    if (pos.capture_or_promotion(move))
-        return;
+
+  // update_stats() updates killers, history, countermove and countermove plus
+  // follow-up move history when a new quiet best move is found.
+
+  void update_stats(const Position& pos, Stack* ss, Move move,
+                    Move* quiets, int quietsCnt, Value bonus) {
 
     if (ss->killers[0] != move)
     {
@@ -1426,22 +1446,23 @@ moves_loop: // When in check search starts from here
     }
 
     CounterMoveStats* cmh  = (ss-1)->counterMoves;
-    CounterMoveStats* fmh  = (ss-2)->counterMoves;
+    CounterMoveStats* fmh1 = (ss-2)->counterMoves;
     CounterMoveStats* fmh2 = (ss-4)->counterMoves;
+
     Color c = pos.side_to_move();
     Thread* thisThread = pos.this_thread();
-
     thisThread->history.update(pos.moved_piece(move), to_sq(move), bonus);
     thisThread->fromTo.update(c, move, bonus);
 
     if (cmh)
     {
+        Square prevSq = to_sq((ss-1)->currentMove);
         thisThread->counterMoves.update(pos.piece_on(prevSq), prevSq, move);
         cmh->update(pos.moved_piece(move), to_sq(move), bonus);
     }
 
-    if (fmh)
-        fmh->update(pos.moved_piece(move), to_sq(move), bonus);
+    if (fmh1)
+        fmh1->update(pos.moved_piece(move), to_sq(move), bonus);
 
     if (fmh2)
         fmh2->update(pos.moved_piece(move), to_sq(move), bonus);
@@ -1455,8 +1476,8 @@ moves_loop: // When in check search starts from here
         if (cmh)
             cmh->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
 
-        if (fmh)
-            fmh->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
+        if (fmh1)
+            fmh1->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
 
         if (fmh2)
             fmh2->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);