mirror of
https://github.com/HChaZZY/Stockfish.git
synced 2025-12-24 19:16:49 +08:00
9c9205860c
Unfortunately std::condition_variable::wait_for() is not accurate in general case and the timer thread can wake up also after tens or even hundreds of millisecs after time has elapsded. CPU load, process priorities, number of concurrent threads, even from other processes, will have effect upon it. Even official documentation says: "This function may block for longer than timeout_duration due to scheduling or resource contention delays." So retire timer and use a polling scheme based on a local thread counter that counts search() calls and a small trick to keep polling frequency constant, independently from the number of threads. Tested for no regression at very fast TC 2+0.05 th 7: LLR: 2.96 (-2.94,2.94) [-3.00,1.00] Total: 32969 W: 6720 L: 6620 D: 19629 TC 2+0.05 th 1: LLR: 2.95 (-2.94,2.94) [-3.00,1.00] Total: 7765 W: 1917 L: 1765 D: 4083 And at STC TC, both single thread LLR: 2.96 (-2.94,2.94) [-3.00,1.00] Total: 15587 W: 3036 L: 2905 D: 9646 And with 7 threads LLR: 2.95 (-2.94,2.94) [-3.00,1.00] Total: 8149 W: 1367 L: 1227 D: 5555 bench: 8639247
112 lines
3.4 KiB
C++
112 lines
3.4 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
|
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
|
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef SEARCH_H_INCLUDED
|
|
#define SEARCH_H_INCLUDED
|
|
|
|
#include <atomic>
|
|
#include <memory> // For std::unique_ptr
|
|
#include <stack>
|
|
#include <vector>
|
|
|
|
#include "misc.h"
|
|
#include "position.h"
|
|
#include "types.h"
|
|
|
|
namespace Search {
|
|
|
|
/// 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 {
|
|
Move* pv;
|
|
int ply;
|
|
Move currentMove;
|
|
Move ttMove;
|
|
Move excludedMove;
|
|
Move killers[2];
|
|
Depth reduction;
|
|
Value staticEval;
|
|
bool skipEarlyPruning;
|
|
int moveCount;
|
|
};
|
|
|
|
/// 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.
|
|
|
|
struct RootMove {
|
|
|
|
explicit RootMove(Move m) : 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; }
|
|
void insert_pv_in_tt(Position& pos);
|
|
bool extract_ponder_from_tt(Position& pos);
|
|
|
|
Value score = -VALUE_INFINITE;
|
|
Value previousScore = -VALUE_INFINITE;
|
|
std::vector<Move> pv;
|
|
};
|
|
|
|
typedef std::vector<RootMove> RootMoveVector;
|
|
|
|
/// 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() { // 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;
|
|
}
|
|
|
|
bool use_time_management() const {
|
|
return !(mate | movetime | depth | nodes | infinite);
|
|
}
|
|
|
|
std::vector<Move> searchmoves;
|
|
int time[COLOR_NB], inc[COLOR_NB], npmsec, movestogo, depth, movetime, mate, infinite, ponder;
|
|
int64_t nodes;
|
|
TimePoint startTime;
|
|
};
|
|
|
|
/// The SignalsType struct stores atomic flags updated during the search
|
|
/// typically in an async fashion e.g. to stop the search by the GUI.
|
|
|
|
struct SignalsType {
|
|
std::atomic_bool stop, stopOnPonderhit, firstRootMove, failedLowAtRoot;
|
|
};
|
|
|
|
typedef std::unique_ptr<std::stack<StateInfo>> StateStackPtr;
|
|
|
|
extern SignalsType Signals;
|
|
extern LimitsType Limits;
|
|
extern StateStackPtr SetupStates;
|
|
|
|
void init();
|
|
void clear();
|
|
template<bool Root = true> uint64_t perft(Position& pos, Depth depth);
|
|
|
|
} // namespace Search
|
|
|
|
#endif // #ifndef SEARCH_H_INCLUDED
|