X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fsearch.h;h=37cd5e5a68634a08530495862ea29ca572e7d93a;hb=2d0237db3f0e596fb06e3ffbadba84dcc4e018f6;hp=0c552d39f5058220350e233a0a155af8ad188296;hpb=79232be02a03a5e2225b30f843e9597fd85951dc;p=stockfish diff --git a/src/search.h b/src/search.h index 0c552d39..37cd5e5a 100644 --- a/src/search.h +++ b/src/search.h @@ -1,7 +1,6 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 - Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2014 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2004-2023 The Stockfish developers (see AUTHORS file) Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -20,93 +19,97 @@ #ifndef SEARCH_H_INCLUDED #define SEARCH_H_INCLUDED -#include -#include +#include #include #include "misc.h" -#include "position.h" +#include "movepick.h" #include "types.h" -struct SplitPoint; +namespace Stockfish { + +class Position; namespace Search { -/// The Stack struct keeps track of the information we need to remember from -/// nodes shallower and deeper in the tree during the search. Each search thread -/// has its own array of Stack objects, indexed by the current ply. + +// Stack struct keeps track of the information we need to remember from nodes +// shallower and deeper in the tree during the search. Each search thread has +// its own array of Stack objects, indexed by the current ply. struct Stack { - SplitPoint* splitPoint; - Move* pv; - int ply; - Move currentMove; - Move ttMove; - Move excludedMove; - Move killers[2]; - Depth reduction; - Value staticEval; - bool skipNullMove; + Move* pv; + PieceToHistory* continuationHistory; + int ply; + Move currentMove; + Move excludedMove; + Move killers[2]; + Value staticEval; + int statScore; + int moveCount; + bool inCheck; + bool ttPv; + bool ttHit; + int doubleExtensions; + int cutoffCnt; }; -/// RootMove struct is used for moves at the root of the tree. For each root -/// move we store a score, a node count, and a PV (really a refutation in the -/// case of moves which fail low). Score is normally set at -VALUE_INFINITE for -/// all non-pv moves. -struct RootMove { - - RootMove(Move m) : score(-VALUE_INFINITE), prevScore(-VALUE_INFINITE), pv(1, m) {} - - bool operator<(const RootMove& m) const { return score > m.score; } // Ascending sort - bool operator==(const Move& m) const { return pv[0] == m; } +// RootMove struct is used for moves at the root of the tree. For each root move +// we store a score and a PV (really a refutation in the case of moves which +// fail low). Score is normally set at -VALUE_INFINITE for all non-pv moves. - void insert_pv_in_tt(Position& pos); +struct RootMove { - Value score; - Value prevScore; - std::vector pv; + explicit RootMove(Move m) : + pv(1, m) {} + bool extract_ponder_from_tt(Position& pos); + bool operator==(const Move& m) const { return pv[0] == m; } + bool operator<(const RootMove& m) const { // Sort in descending order + return m.score != score ? m.score < score : m.previousScore < previousScore; + } + + Value score = -VALUE_INFINITE; + Value previousScore = -VALUE_INFINITE; + Value averageScore = -VALUE_INFINITE; + Value uciScore = -VALUE_INFINITE; + bool scoreLowerbound = false; + bool scoreUpperbound = false; + int selDepth = 0; + int tbRank = 0; + Value tbScore; + std::vector pv; }; +using RootMoves = std::vector; -/// 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 -/// or if we have to ponder while it's our opponent's turn to move. -struct LimitsType { - - LimitsType() { // Using memset on a std::vector is undefined behavior - nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = movestogo = - depth = movetime = mate = infinite = ponder = 0; - } - bool use_time_management() const { return !(mate | movetime | depth | nodes | infinite); } +// LimitsType struct stores information sent by GUI about available time to +// search the current move, maximum depth/time, or if we are in analysis mode. - std::vector searchmoves; - int time[COLOR_NB], inc[COLOR_NB], movestogo, depth, movetime, mate, infinite, ponder; - int64_t nodes; -}; +struct LimitsType { + LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC + time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = npmsec = movetime = TimePoint(0); + movestogo = depth = mate = perft = infinite = 0; + nodes = 0; + } -/// The SignalsType struct stores volatile flags updated during the search -/// typically in an async fashion e.g. to stop the search by the GUI. + bool use_time_management() const { return time[WHITE] || time[BLACK]; } -struct SignalsType { - bool stop, stopOnPonderhit, firstRootMove, failedLowAtRoot; + std::vector searchmoves; + TimePoint time[COLOR_NB], inc[COLOR_NB], npmsec, movetime, startTime; + int movestogo, depth, mate, perft, infinite; + int64_t nodes; }; -typedef std::auto_ptr > StateStackPtr; - -extern volatile SignalsType Signals; extern LimitsType Limits; -extern std::vector RootMoves; -extern Position RootPos; -extern Time::point SearchTime; -extern StateStackPtr SetupStates; void init(); -void think(); -template uint64_t perft(Position& pos, Depth depth); +void clear(); + +} // namespace Search -} // namespace Search +} // namespace Stockfish -#endif // #ifndef SEARCH_H_INCLUDED +#endif // #ifndef SEARCH_H_INCLUDED