Ablation for bloom filter

Author: PikaCat-OuO

src/position.cpp

@@ -450,9 +450,6 @@ DirtyPiece Position::do_move(Move                      m,
     assert(m.is_ok());
     assert(&newSt != st);
 
-    // Update the bloom filter
-    ++filter[st->key];
-
     Key k = st->key ^ Zobrist::side;
 
     // Copy some fields of the old state to our new StateInfo object except the
@@ -585,6 +582,27 @@ DirtyPiece Position::do_move(Move                      m,
     if (tt)
         prefetch(tt->first_entry(key()));
 
+    // Calculate the repetition info. It is the ply distance from the first
+    // occurrence of the same position, or zero if the position was not repeated.
+    st->repetition = 0;
+    // Restore rule 60 by adding back the checks
+    int end = std::min(st->rule60 + std::max(0, st->check10[WHITE] - 10)
+                         + std::max(0, st->check10[BLACK] - 10),
+                       st->pliesFromNull);
+    if (end >= 4)
+    {
+        StateInfo* stp = st->previous->previous;
+        for (int i = 4; i <= end; i += 2)
+        {
+            stp = stp->previous->previous;
+            if (stp->key == st->key)
+            {
+                st->repetition = stp->repetition ? -(stp->repetition + i) : i;
+                break;
+            }
+        }
+    }
+
     assert(pos_is_ok());
 
     assert(dp.pc != NO_PIECE);
@@ -621,9 +639,6 @@ void Position::undo_move(Move m) {
     st = st->previous;
     --gamePly;
 
-    // Update the bloom filter
-    --filter[st->key];
-
     assert(pos_is_ok());
 }
 
@@ -635,9 +650,6 @@ void Position::do_null_move(StateInfo& newSt, const TranspositionTable& tt) {
     assert(!checkers());
     assert(&newSt != st);
 
-    // Update the bloom filter
-    ++filter[st->key];
-
     std::memcpy(&newSt, st, sizeof(StateInfo));
 
     newSt.previous = st;
@@ -663,9 +675,6 @@ void Position::undo_null_move() {
 
     st         = st->previous;
     sideToMove = ~sideToMove;
-
-    // Update the bloom filter
-    --filter[st->key];
 }
 
 
@@ -976,65 +985,50 @@ Value Position::detect_chases(int d, int ply) {
 // perpetual check repetition or perpetual chase repetition that allows a player to claim a game result.
 bool Position::rule_judge(Value& result, int ply) {
 
-    // Restore rule 60 by adding back the checks
-    int end = std::min(st->rule60 + std::max(0, st->check10[WHITE] - 10)
-                         + std::max(0, st->check10[BLACK] - 10),
-                       st->pliesFromNull);
-
-    if (end >= 4 && filter[st->key] >= 1)
+    // Return a score if a position repeats once earlier but strictly
+    // after the root, or repeats twice before or at the root.
+    if (st->repetition && ply > st->repetition)
     {
-        int        cnt       = 0;
+        int        length    = std::abs(st->repetition);
         StateInfo* stp       = st->previous->previous;
         bool       checkThem = st->checkersBB && stp->checkersBB;
         bool       checkUs   = st->previous->checkersBB && stp->previous->checkersBB;
 
-        for (int i = 4; i <= end; i += 2)
+        for (int i = 4; i <= length; i += 2)
         {
             stp = stp->previous->previous;
             checkThem &= bool(stp->checkersBB);
+            if (i + 1 <= length)
+                checkUs &= bool(stp->previous->checkersBB);
+        }
 
-            // Return a score if a position repeats once earlier but strictly
-            // after the root, or repeats twice before or at the root.
-            if (stp->key == st->key && (++cnt == 2 || ply > i))
-            {
-                if (!checkThem && !checkUs)
-                {
-                    // Copy the current position to a rollback struct, so we don't need to do those moves again
-                    Position rollback;
-                    memcpy((void*) &rollback, (const void*) this, offsetof(Position, filter));
-
-                    // Chasing detection
-                    result = rollback.detect_chases(i, ply);
-                }
-                else
-                    // Checking detection
-                    result = !checkUs ? mate_in(ply) : !checkThem ? mated_in(ply) : VALUE_DRAW;
+        if (!checkThem && !checkUs)
+        {
+            // Copy the current position to a rollback struct, so we don't need to do those moves again
+            Position rollback;
+            memcpy((void*) &rollback, (const void*) this, offsetof(Position, idBoard));
 
-                // 3 folds and 2 fold draws can be judged immediately
-                if (result == VALUE_DRAW || cnt == 2)
-                    return true;
+            // Chasing detection
+            result = rollback.detect_chases(length, ply);
+        }
+        else
+            // Checking detection
+            result = !checkUs ? mate_in(ply) : !checkThem ? mated_in(ply) : VALUE_DRAW;
 
-                // 2 fold mates need further investigations
-                if (filter[st->key] <= 1)
-                {
-                    // Not exceeding rule 60 and have the same previous step
-                    if (st->rule60 < 120 && st->previous->key == stp->previous->key)
-                    {
-                        // Even if we entering this loop again, it will not lead to a 3 fold repetition
-                        StateInfo* prev = st->previous;
-                        while ((prev = prev->previous) != stp)
-                            if (filter[prev->key] > 1)
-                                break;
-                        if (prev == stp)
-                            return true;
-                    }
-                    // We know there can't be another fold
+        // 3 folds and 2 fold draws can be judged immediately
+        if (result == VALUE_DRAW || st->repetition < 0)
+            return true;
+        // 2 fold mates need further investigations
+        // Not exceeding rule 60 and have the same previous step
+        else if (st->rule60 < 120 && st->previous->key == stp->previous->key)
+        {
+            // Even if we entering this loop again, it will not lead to a 3 fold repetition
+            StateInfo* prev = st->previous;
+            while ((prev = prev->previous) != stp)
+                if (prev->repetition)
                     break;
-                }
-            }
-
-            if (i + 1 <= end)
-                checkUs &= bool(stp->previous->checkersBB);
+            if (prev == stp)
+                return true;
         }
     }
 

src/position.h

@@ -61,6 +61,7 @@ struct StateInfo {
     Bitboard   checkSquares[PIECE_TYPE_NB];
     bool       needSlowCheck;
     Piece      capturedPiece;
+    int        repetition;
     Move       move;
 };
 
@@ -85,7 +86,6 @@ class Position {
 
     // FEN string input/output
     Position&   set(const std::string& fenStr, StateInfo* si);
-    Position&   set(const Position& pos, StateInfo* si);
     std::string fen() const;
 
     // Position representation
@@ -187,9 +187,6 @@ class Position {
     int        gamePly;
     Color      sideToMove;
 
-    // Bloom filter for fast repetition filtering
-    BloomFilter filter;
-
     // Board for chasing detection
     int idBoard[SQUARE_NB];
 };
@@ -266,7 +263,7 @@ inline Key Position::key() const { return adjust_key60(st->key); }
 
 inline Key Position::adjust_key60(Key k) const {
     return (st->rule60 < 14 ? k : k ^ make_key((st->rule60 - 14) / 8))
-         ^ (filter[st->key] ? make_key(14) : 0);
+         ^ (st->repetition ? make_key(14) : 0);
 }
 
 inline Key Position::pawn_key() const { return st->pawnKey; }
@@ -335,16 +332,6 @@ inline void Position::do_move(Move m, StateInfo& newSt, const TranspositionTable
 
 inline StateInfo* Position::state() const { return st; }
 
-inline Position& Position::set(const Position& pos, StateInfo* si) {
-
-    set(pos.fen(), si);
-
-    // Special cares for bloom filter
-    std::memcpy(&filter, &pos.filter, sizeof(BloomFilter));
-
-    return *this;
-}
-
 }  // namespace Stockfish
 
 #endif  // #ifndef POSITION_H_INCLUDED

src/thread.cpp

@@ -277,7 +277,7 @@ void ThreadPool::start_thinking(Position& pos, StateListPtr& states, Search::Lim
             th->worker->nodes = th->worker->nmpMinPly = th->worker->bestMoveChanges = 0;
             th->worker->rootDepth = th->worker->completedDepth = 0;
             th->worker->rootMoves                              = rootMoves;
-            th->worker->rootPos.set(pos, &th->worker->rootState);
+            th->worker->rootPos.set(pos.fen(), &th->worker->rootState);
             th->worker->rootState = setupStates->back();
         });
     }