From: Marco Costalba Date: Mon, 11 Apr 2016 14:45:36 +0000 (+0200) Subject: StateInfo is usually allocated on the stack by search() X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=7eaea3848c9e8a388c0b79cee6fba6bf3cd32108 StateInfo is usually allocated on the stack by search() And passed in do_move(), this ensures maximum efficiency and speed and at the same time unlimited move numbers. The draw back is that to handle Position init we need to reserve a StateInfo inside Position itself and use at init time and when copying from another Position. After lazy SMP we don't need anymore this gimmick and we can get rid of this special case and always pass an external StateInfo to Position object. Also rewritten and simplified Position constructors. Verified it does not regress with a 3 threads SMP test: ELO: -0.00 +-12.7 (95%) LOS: 50.0% Total: 1000 W: 173 L: 173 D: 654 No functional change. --- diff --git a/src/benchmark.cpp b/src/benchmark.cpp index 6d69541f..2978f346 100644 --- a/src/benchmark.cpp +++ b/src/benchmark.cpp @@ -144,10 +144,12 @@ void benchmark(const Position& current, istream& is) { uint64_t nodes = 0; TimePoint elapsed = now(); + Position pos; for (size_t i = 0; i < fens.size(); ++i) { - Position pos(fens[i], Options["UCI_Chess960"], Threads.main()); + StateListPtr states(new std::vector(1)); + pos.set(fens[i], Options["UCI_Chess960"], &states->back(), Threads.main()); cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl; @@ -156,9 +158,8 @@ void benchmark(const Position& current, istream& is) { else { - Search::StateStackPtr st; limits.startTime = now(); - Threads.start_thinking(pos, limits, st); + Threads.start_thinking(pos, states, limits); Threads.main()->wait_for_search_finished(); nodes += Threads.nodes_searched(); } diff --git a/src/endgame.cpp b/src/endgame.cpp index cc663043..04469e87 100644 --- a/src/endgame.cpp +++ b/src/endgame.cpp @@ -99,7 +99,8 @@ namespace { string fen = sides[0] + char(8 - sides[0].length() + '0') + "/8/8/8/8/8/8/" + sides[1] + char(8 - sides[1].length() + '0') + " w - - 0 10"; - return Position(fen, false, nullptr).material_key(); + StateInfo st; + return Position().set(fen, false, &st, nullptr).material_key(); } } // namespace diff --git a/src/position.cpp b/src/position.cpp index f42377de..6e8b03d1 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -155,42 +155,11 @@ void Position::init() { } -/// Position::operator=() creates a copy of 'pos' but detaching the state pointer -/// from the source to be self-consistent and not depending on any external data. - -Position& Position::operator=(const Position& pos) { - - std::memcpy(this, &pos, sizeof(Position)); - std::memcpy(&startState, st, sizeof(StateInfo)); - st = &startState; - nodes = 0; - - assert(pos_is_ok()); - - return *this; -} - - -/// Position::clear() erases the position object to a pristine state, with an -/// empty board, white to move, and no castling rights. - -void Position::clear() { - - std::memset(this, 0, sizeof(Position)); - startState.epSquare = SQ_NONE; - st = &startState; - - for (int i = 0; i < PIECE_TYPE_NB; ++i) - for (int j = 0; j < 16; ++j) - pieceList[WHITE][i][j] = pieceList[BLACK][i][j] = SQ_NONE; -} - - /// Position::set() initializes the position object with the given FEN string. /// This function is not very robust - make sure that input FENs are correct, /// this is assumed to be the responsibility of the GUI. -void Position::set(const string& fenStr, bool isChess960, Thread* th) { +Position& Position::set(const string& fenStr, bool isChess960, StateInfo* si, Thread* th) { /* A FEN string defines a particular position using only the ASCII character set. @@ -230,7 +199,11 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { Square sq = SQ_A8; std::istringstream ss(fenStr); - clear(); + std::memset(this, 0, sizeof(Position)); + std::memset(si, 0, sizeof(StateInfo)); + std::fill_n(&pieceList[0][0][0], sizeof(pieceList) / sizeof(Square), SQ_NONE); + st = si; + ss >> std::noskipws; // 1. Piece placement @@ -291,6 +264,8 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { if (!(attackers_to(st->epSquare) & pieces(sideToMove, PAWN))) st->epSquare = SQ_NONE; } + else + st->epSquare = SQ_NONE; // 5-6. Halfmove clock and fullmove number ss >> std::skipws >> st->rule50 >> gamePly; @@ -304,6 +279,8 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { set_state(st); assert(pos_is_ok()); + + return *this; } @@ -1108,7 +1085,7 @@ void Position::flip() { std::getline(ss, token); // Half and full moves f += token; - set(f, is_chess960(), this_thread()); + set(f, is_chess960(), st, this_thread()); assert(pos_is_ok()); } diff --git a/src/position.h b/src/position.h index 1070236b..d44ed009 100644 --- a/src/position.h +++ b/src/position.h @@ -23,7 +23,9 @@ #include #include // For offsetof() +#include // For std::unique_ptr #include +#include #include "bitboard.h" #include "types.h" @@ -75,6 +77,8 @@ struct StateInfo { StateInfo* previous; }; +typedef std::unique_ptr> StateListPtr; + /// Position class stores information regarding the board representation as /// pieces, side to move, hash keys, castling info, etc. Important methods are @@ -86,14 +90,12 @@ class Position { public: static void init(); - Position() = default; // To define the global object RootPos + Position() = default; Position(const Position&) = delete; - Position(const Position& pos, Thread* th) { *this = pos; thisThread = th; } - Position(const std::string& f, bool c960, Thread* th) { set(f, c960, th); } - Position& operator=(const Position&); // To assign RootPos from UCI + Position& operator=(const Position&) = delete; // FEN string input/output - void set(const std::string& fenStr, bool isChess960, Thread* th); + Position& set(const std::string& fenStr, bool isChess960, StateInfo* si, Thread* th); const std::string fen() const; // Position representation @@ -178,7 +180,6 @@ public: private: // Initialization helpers (used while setting up a position) - void clear(); void set_castling_right(Color c, Square rfrom); void set_state(StateInfo* si) const; @@ -200,7 +201,6 @@ private: int castlingRightsMask[SQUARE_NB]; Square castlingRookSquare[CASTLING_RIGHT_NB]; Bitboard castlingPath[CASTLING_RIGHT_NB]; - StateInfo startState; uint64_t nodes; int gamePly; Color sideToMove; diff --git a/src/search.cpp b/src/search.cpp index 10d491c0..31764533 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -40,7 +40,6 @@ namespace Search { SignalsType Signals; LimitsType Limits; - StateStackPtr SetupStates; } namespace Tablebases { @@ -317,16 +316,8 @@ void MainThread::search() { } for (Thread* th : Threads) - { - th->maxPly = 0; - th->rootDepth = DEPTH_ZERO; if (th != this) - { - th->rootPos = Position(rootPos, th); - th->rootMoves = rootMoves; th->start_searching(); - } - } Thread::search(); // Let's start searching! } @@ -1488,7 +1479,7 @@ moves_loop: // When in check search starts from here Move Skill::pick_best(size_t multiPV) { - const Search::RootMoveVector& rootMoves = Threads.main()->rootMoves; + const RootMoves& rootMoves = Threads.main()->rootMoves; static PRNG rng(now()); // PRNG sequence should be non-deterministic // RootMoves are already sorted by score in descending order @@ -1553,7 +1544,7 @@ string UCI::pv(const Position& pos, Depth depth, Value alpha, Value beta) { std::stringstream ss; int elapsed = Time.elapsed() + 1; - const Search::RootMoveVector& rootMoves = pos.this_thread()->rootMoves; + const RootMoves& rootMoves = pos.this_thread()->rootMoves; size_t PVIdx = pos.this_thread()->PVIdx; size_t multiPV = std::min((size_t)Options["MultiPV"], rootMoves.size()); uint64_t nodes_searched = Threads.nodes_searched(); diff --git a/src/search.h b/src/search.h index 84420373..d722af1e 100644 --- a/src/search.h +++ b/src/search.h @@ -22,8 +22,6 @@ #define SEARCH_H_INCLUDED #include -#include // For std::unique_ptr -#include #include #include "misc.h" @@ -65,7 +63,7 @@ struct RootMove { std::vector pv; }; -typedef std::vector RootMoveVector; +typedef std::vector RootMoves; /// 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 @@ -74,8 +72,8 @@ typedef std::vector RootMoveVector; struct LimitsType { LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC - nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = npmsec = movestogo = - depth = movetime = mate = infinite = ponder = 0; + nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = + npmsec = movestogo = depth = movetime = mate = infinite = ponder = 0; } bool use_time_management() const { @@ -95,11 +93,8 @@ struct SignalsType { std::atomic_bool stop, stopOnPonderhit; }; -typedef std::unique_ptr> StateStackPtr; - extern SignalsType Signals; extern LimitsType Limits; -extern StateStackPtr SetupStates; void init(); void clear(); diff --git a/src/syzygy/tbprobe.cpp b/src/syzygy/tbprobe.cpp index 14d34e79..e07cd1bc 100644 --- a/src/syzygy/tbprobe.cpp +++ b/src/syzygy/tbprobe.cpp @@ -688,7 +688,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, Search::RootMoveVector& rootMoves, Value& score) +bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves, Value& score) { int success; @@ -795,7 +795,7 @@ bool Tablebases::root_probe(Position& pos, Search::RootMoveVector& rootMoves, Va // // 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, Search::RootMoveVector& rootMoves, Value& score) +bool Tablebases::root_probe_wdl(Position& pos, Search::RootMoves& rootMoves, Value& score) { int success; diff --git a/src/syzygy/tbprobe.h b/src/syzygy/tbprobe.h index 4233e1aa..2bcc0834 100644 --- a/src/syzygy/tbprobe.h +++ b/src/syzygy/tbprobe.h @@ -10,8 +10,8 @@ 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, Search::RootMoveVector& rootMoves, Value& score); -bool root_probe_wdl(Position& pos, Search::RootMoveVector& rootMoves, Value& score); +bool root_probe(Position& pos, Search::RootMoves& rootMoves, Value& score); +bool root_probe_wdl(Position& pos, Search::RootMoves& rootMoves, Value& score); } diff --git a/src/thread.cpp b/src/thread.cpp index 440b8bf0..dc4ec05e 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -26,8 +26,6 @@ #include "thread.h" #include "uci.h" -using namespace Search; - ThreadPool Threads; // Global object /// Thread constructor launches the thread and then waits until it goes to sleep @@ -171,26 +169,34 @@ int64_t ThreadPool::nodes_searched() { /// ThreadPool::start_thinking() wakes up the main thread sleeping in idle_loop() /// and starts a new search, then returns immediately. -void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits, - StateStackPtr& states) { +void ThreadPool::start_thinking(const Position& pos, StateListPtr& states, + const Search::LimitsType& limits) { main()->wait_for_search_finished(); - Signals.stopOnPonderhit = Signals.stop = false; - - main()->rootMoves.clear(); - main()->rootPos = pos; - Limits = limits; - if (states.get()) // If we don't set a new position, preserve current state - { - SetupStates = std::move(states); // Ownership transfer here - assert(!states.get()); - } + Search::Signals.stopOnPonderhit = Search::Signals.stop = false; + Search::Limits = limits; + Search::RootMoves rootMoves; for (const auto& m : MoveList(pos)) if ( limits.searchmoves.empty() || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m)) - main()->rootMoves.push_back(RootMove(m)); + rootMoves.push_back(Search::RootMove(m)); + + // After ownership transfer 'states' becomes empty, so if we stop the search + // and call 'go' again without setting a new position states.get() == NULL. + assert(states.get() || setupStates.get()); + + if (states.get()) + setupStates = std::move(states); // Ownership transfer, states is now empty + + for (Thread* th : Threads) + { + th->maxPly = 0; + th->rootDepth = DEPTH_ZERO; + th->rootMoves = rootMoves; + th->rootPos.set(pos.fen(), pos.is_chess960(), &setupStates->back(), th); + } main()->start_searching(); } diff --git a/src/thread.h b/src/thread.h index 43ddfbb7..0b112de9 100644 --- a/src/thread.h +++ b/src/thread.h @@ -64,7 +64,7 @@ public: int maxPly, callsCnt; Position rootPos; - Search::RootMoveVector rootMoves; + Search::RootMoves rootMoves; Depth rootDepth; HistoryStats history; MoveStats counterMoves; @@ -94,9 +94,12 @@ struct ThreadPool : public std::vector { void exit(); // be initialized and valid during the whole thread lifetime. MainThread* main() { return static_cast(at(0)); } - void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&); + void start_thinking(const Position&, StateListPtr&, const Search::LimitsType&); void read_uci_options(); int64_t nodes_searched(); + +private: + StateListPtr setupStates; }; extern ThreadPool Threads; diff --git a/src/timeman.cpp b/src/timeman.cpp index bc9c2e5b..c7c19f47 100644 --- a/src/timeman.cpp +++ b/src/timeman.cpp @@ -33,7 +33,7 @@ namespace { enum TimeType { OptimumTime, MaxTime }; const int MoveHorizon = 50; // Plan time management at most this many moves ahead - const double MaxRatio = 7.09; // When in trouble, we can step over reserved time with this ratio + const double MaxRatio = 7.09; // When in trouble, we can step over reserved time with this ratio const double StealRatio = 0.35; // However we must not steal time from remaining moves over this ratio diff --git a/src/uci.cpp b/src/uci.cpp index 4d12ca40..cfd253b1 100644 --- a/src/uci.cpp +++ b/src/uci.cpp @@ -39,10 +39,10 @@ namespace { // FEN string of the initial position, normal chess const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"; - // Stack to keep track of the position states along the setup moves (from the + // A list to keep track of the position states along the setup moves (from the // start position to the position just before the search starts). Needed by // 'draw by repetition' detection. - Search::StateStackPtr SetupStates; + StateListPtr States(new std::vector(1)); // position() is called when engine receives the "position" UCI command. @@ -68,14 +68,14 @@ namespace { else return; - pos.set(fen, Options["UCI_Chess960"], Threads.main()); - SetupStates = Search::StateStackPtr(new std::stack); + States = StateListPtr(new std::vector(1)); + pos.set(fen, Options["UCI_Chess960"], &States->back(), Threads.main()); // Parse move list (if any) while (is >> token && (m = UCI::to_move(pos, token)) != MOVE_NONE) { - SetupStates->push(StateInfo()); - pos.do_move(m, SetupStates->top(), pos.gives_check(m, CheckInfo(pos))); + States->push_back(StateInfo()); + pos.do_move(m, States->back(), pos.gives_check(m, CheckInfo(pos))); } } @@ -132,7 +132,7 @@ namespace { else if (token == "infinite") limits.infinite = 1; else if (token == "ponder") limits.ponder = 1; - Threads.start_thinking(pos, limits, SetupStates); + Threads.start_thinking(pos, States, limits); } } // namespace @@ -146,9 +146,11 @@ namespace { void UCI::loop(int argc, char* argv[]) { - Position pos(StartFEN, false, Threads.main()); // The root position + Position pos; string token, cmd; + pos.set(StartFEN, false, &States->back(), Threads.main()); + for (int i = 1; i < argc; ++i) cmd += std::string(argv[i]) + " ";