diff --git a/src/search.cpp b/src/search.cpp index b945c5cf..5ea00331 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -39,7 +39,7 @@ namespace Search { volatile SignalsType Signals; LimitsType Limits; - std::vector RootMoves; + RootMoveVector RootMoves; Position RootPos; Time::point SearchTime; StateStackPtr SetupStates; @@ -206,9 +206,9 @@ void Search::think() { TB::Cardinality = Options["SyzygyProbeLimit"]; // Skip TB probing when no TB found: !TBLargest -> !TB::Cardinality - if (TB::Cardinality > TB::TBLargest) + if (TB::Cardinality > TB::MaxCardinality) { - TB::Cardinality = TB::TBLargest; + TB::Cardinality = TB::MaxCardinality; TB::ProbeDepth = DEPTH_ZERO; } @@ -226,7 +226,7 @@ void Search::think() { { // If the current root position is in the tablebases then RootMoves // contains only moves that preserve the draw or win. - TB::RootInTB = Tablebases::root_probe(RootPos, TB::Score); + TB::RootInTB = Tablebases::root_probe(RootPos, RootMoves, TB::Score); if (TB::RootInTB) TB::Cardinality = 0; // Do not probe tablebases during the search @@ -234,7 +234,7 @@ void Search::think() { else // If DTZ tables are missing, use WDL tables as a fallback { // Filter out moves that do not preserve a draw or win - TB::RootInTB = Tablebases::root_probe_wdl(RootPos, TB::Score); + TB::RootInTB = Tablebases::root_probe_wdl(RootPos, RootMoves, TB::Score); // Only probe during search if winning if (TB::Score <= VALUE_DRAW) diff --git a/src/search.h b/src/search.h index 0c552d39..71b4b8a8 100644 --- a/src/search.h +++ b/src/search.h @@ -68,6 +68,7 @@ struct RootMove { std::vector pv; }; +typedef std::vector RootMoveVector; /// The LimitsType struct stores information sent by GUI about available time /// to search the current move, maximum depth/time, if we are in analysis mode @@ -98,7 +99,7 @@ typedef std::auto_ptr > StateStackPtr; extern volatile SignalsType Signals; extern LimitsType Limits; -extern std::vector RootMoves; +extern RootMoveVector RootMoves; extern Position RootPos; extern Time::point SearchTime; extern StateStackPtr SetupStates; diff --git a/src/syzygy/tbcore.cpp b/src/syzygy/tbcore.cpp index 79be1680..4e0f356e 100644 --- a/src/syzygy/tbcore.cpp +++ b/src/syzygy/tbcore.cpp @@ -223,8 +223,8 @@ static void init_tb(char *str) entry->num += pcs[i]; entry->symmetric = (key == key2); entry->has_pawns = (pcs[TB_WPAWN] + pcs[TB_BPAWN] > 0); - if (entry->num > Tablebases::TBLargest) - Tablebases::TBLargest = entry->num; + if (entry->num > Tablebases::MaxCardinality) + Tablebases::MaxCardinality = entry->num; if (entry->has_pawns) { struct TBEntry_pawn *ptr = (struct TBEntry_pawn *)entry; @@ -301,7 +301,7 @@ void Tablebases::init(const std::string& path) LOCK_INIT(TB_mutex); TBnum_piece = TBnum_pawn = 0; - TBLargest = 0; + MaxCardinality = 0; for (i = 0; i < (1 << TBHASHBITS); i++) for (j = 0; j < HSHMAX; j++) { diff --git a/src/syzygy/tbprobe.cpp b/src/syzygy/tbprobe.cpp index de437d70..3276be9e 100644 --- a/src/syzygy/tbprobe.cpp +++ b/src/syzygy/tbprobe.cpp @@ -22,7 +22,7 @@ namespace Zobrist { extern Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; } -int Tablebases::TBLargest = 0; +int Tablebases::MaxCardinality = 0; // Given a position with 6 or fewer pieces, produce a text string // of the form KQPvKRP, where "KQP" represents the white pieces if @@ -32,7 +32,7 @@ static void prt_str(Position& pos, char *str, int mirror) Color color; PieceType pt; int i; - + color = !mirror ? WHITE : BLACK; for (pt = KING; pt >= PAWN; --pt) for (i = popcount(pos.pieces(color, pt)); i > 0; i--) @@ -681,7 +681,7 @@ static Value wdl_to_Value[5] = { // // A return value false indicates that not all probes were successful and that // no moves were filtered out. -bool Tablebases::root_probe(Position& pos, Value& TBScore) +bool Tablebases::root_probe(Position& pos, Search::RootMoveVector& rootMoves, Value& score) { int success; @@ -692,8 +692,8 @@ bool Tablebases::root_probe(Position& pos, Value& TBScore) CheckInfo ci(pos); // Probe each move. - for (size_t i = 0; i < Search::RootMoves.size(); i++) { - Move move = Search::RootMoves[i].pv[0]; + for (size_t i = 0; i < rootMoves.size(); i++) { + Move move = rootMoves[i].pv[0]; pos.do_move(move, st, ci, pos.gives_check(move, ci)); int v = 0; if (pos.checkers() && dtz > 0) { @@ -713,7 +713,7 @@ bool Tablebases::root_probe(Position& pos, Value& TBScore) } pos.undo_move(move); if (!success) return false; - Search::RootMoves[i].score = (Value)v; + rootMoves[i].score = (Value)v; } // Obtain 50-move counter for the root position. @@ -729,21 +729,21 @@ bool Tablebases::root_probe(Position& pos, Value& TBScore) wdl = (-dtz + cnt50 <= 100) ? -2 : -1; // Determine the score to report to the user. - TBScore = wdl_to_Value[wdl + 2]; + score = wdl_to_Value[wdl + 2]; // If the position is winning or losing, but too few moves left, adjust the // score to show how close it is to winning or losing. // NOTE: int(PawnValueEg) is used as scaling factor in score_to_uci(). if (wdl == 1 && dtz <= 100) - TBScore = (Value)(((200 - dtz - cnt50) * int(PawnValueEg)) / 200); + score = (Value)(((200 - dtz - cnt50) * int(PawnValueEg)) / 200); else if (wdl == -1 && dtz >= -100) - TBScore = -(Value)(((200 + dtz - cnt50) * int(PawnValueEg)) / 200); + score = -(Value)(((200 + dtz - cnt50) * int(PawnValueEg)) / 200); // Now be a bit smart about filtering out moves. size_t j = 0; if (dtz > 0) { // winning (or 50-move rule draw) int best = 0xffff; - for (size_t i = 0; i < Search::RootMoves.size(); i++) { - int v = Search::RootMoves[i].score; + for (size_t i = 0; i < rootMoves.size(); i++) { + int v = rootMoves[i].score; if (v > 0 && v < best) best = v; } @@ -752,33 +752,33 @@ bool Tablebases::root_probe(Position& pos, Value& TBScore) // that stay safely within the 50-move budget, if there are any. if (!has_repeated(st.previous) && best + cnt50 <= 99) max = 99 - cnt50; - for (size_t i = 0; i < Search::RootMoves.size(); i++) { - int v = Search::RootMoves[i].score; + for (size_t i = 0; i < rootMoves.size(); i++) { + int v = rootMoves[i].score; if (v > 0 && v <= max) - Search::RootMoves[j++] = Search::RootMoves[i]; + rootMoves[j++] = rootMoves[i]; } } else if (dtz < 0) { // losing (or 50-move rule draw) int best = 0; - for (size_t i = 0; i < Search::RootMoves.size(); i++) { - int v = Search::RootMoves[i].score; + for (size_t i = 0; i < rootMoves.size(); i++) { + int v = rootMoves[i].score; if (v < best) best = v; } // Try all moves, unless we approach or have a 50-move rule draw. if (-best * 2 + cnt50 < 100) return true; - for (size_t i = 0; i < Search::RootMoves.size(); i++) { - if (Search::RootMoves[i].score == best) - Search::RootMoves[j++] = Search::RootMoves[i]; + for (size_t i = 0; i < rootMoves.size(); i++) { + if (rootMoves[i].score == best) + rootMoves[j++] = rootMoves[i]; } } else { // drawing // Try all moves that preserve the draw. - for (size_t i = 0; i < Search::RootMoves.size(); i++) { - if (Search::RootMoves[i].score == 0) - Search::RootMoves[j++] = Search::RootMoves[i]; + for (size_t i = 0; i < rootMoves.size(); i++) { + if (rootMoves[i].score == 0) + rootMoves[j++] = rootMoves[i]; } } - Search::RootMoves.resize(j, Search::RootMove(MOVE_NONE)); + rootMoves.resize(j, Search::RootMove(MOVE_NONE)); return true; } @@ -788,13 +788,13 @@ bool Tablebases::root_probe(Position& pos, Value& TBScore) // // A return value false indicates that not all probes were successful and that // no moves were filtered out. -bool Tablebases::root_probe_wdl(Position& pos, Value& TBScore) +bool Tablebases::root_probe_wdl(Position& pos, Search::RootMoveVector& rootMoves, Value& score) { int success; int wdl = Tablebases::probe_wdl(pos, &success); if (!success) return false; - TBScore = wdl_to_Value[wdl + 2]; + score = wdl_to_Value[wdl + 2]; StateInfo st; CheckInfo ci(pos); @@ -802,23 +802,23 @@ bool Tablebases::root_probe_wdl(Position& pos, Value& TBScore) int best = -2; // Probe each move. - for (size_t i = 0; i < Search::RootMoves.size(); i++) { - Move move = Search::RootMoves[i].pv[0]; + for (size_t i = 0; i < rootMoves.size(); i++) { + Move move = rootMoves[i].pv[0]; pos.do_move(move, st, ci, pos.gives_check(move, ci)); int v = -Tablebases::probe_wdl(pos, &success); pos.undo_move(move); if (!success) return false; - Search::RootMoves[i].score = (Value)v; + rootMoves[i].score = (Value)v; if (v > best) best = v; } size_t j = 0; - for (size_t i = 0; i < Search::RootMoves.size(); i++) { - if (Search::RootMoves[i].score == best) - Search::RootMoves[j++] = Search::RootMoves[i]; + for (size_t i = 0; i < rootMoves.size(); i++) { + if (rootMoves[i].score == best) + rootMoves[j++] = rootMoves[i]; } - Search::RootMoves.resize(j, Search::RootMove(MOVE_NONE)); + rootMoves.resize(j, Search::RootMove(MOVE_NONE)); return true; } diff --git a/src/syzygy/tbprobe.h b/src/syzygy/tbprobe.h index 9ed6f0a3..4233e1aa 100644 --- a/src/syzygy/tbprobe.h +++ b/src/syzygy/tbprobe.h @@ -1,15 +1,17 @@ #ifndef TBPROBE_H #define TBPROBE_H +#include "../search.h" + namespace Tablebases { -extern int TBLargest; +extern int MaxCardinality; void init(const std::string& path); int probe_wdl(Position& pos, int *success); int probe_dtz(Position& pos, int *success); -bool root_probe(Position& pos, Value& TBScore); -bool root_probe_wdl(Position& pos, Value& TBScore); +bool root_probe(Position& pos, Search::RootMoveVector& rootMoves, Value& score); +bool root_probe_wdl(Position& pos, Search::RootMoveVector& rootMoves, Value& score); }