mirror of
https://github.com/HChaZZY/Stockfish.git
synced 2025-12-21 17:46:26 +08:00
926f215061
When running more games in parallel, or simply when running a game with a background process, due to how OS scheduling works, there is no guarantee that the CPU resources allocated evenly between the two players. This introduces noise in the result that leads to unreliable result and in the worst cases can even invalidate the result. For instance in SF test framework we avoid running from clouds virtual machines because are a known source of very unstable CPU speed. To overcome this issue, without requiring changes to the GUI, the idea is to use searched nodes instead of time, and to convert time to available nodes upfront, at the beginning of the game. When nodestime UCI option is set at a given nodes per milliseconds (npmsec), at the beginning of the game (and only once), the engine reads the available time to think, sent by the GUI with 'go wtime x' UCI command. Then it translates time in available nodes (nodes = npmsec * x), then feeds available nodes instead of time to the time management logic and starts the search. During the search the engine checks the searched nodes against the available ones in such a way that all the time management logic still fully applies, and the game mimics a real one played on real time. When the search finishes, before returning best move, the total available nodes are updated, subtracting the real searched nodes. After the first move, the time information sent by the GUI is ignored, and the engine fully relies on the updated total available nodes to feed time management. To avoid time losses, the speed of the engine (npms) must be set to a value lower than real speed so that if the real TC is for instance 30 secs, and npms is half of the real speed, the game will last on average 15 secs, so much less than the TC limit, providing for a safety 'time buffer'. There are 2 main limitations with this mode. 1. Engine speed should be the same for both players, and this limits the approach to mainly parameter tuning patches. 2. Because npms is fixed while, in real engines, the speed increases toward endgame, this introduces an artifact that is equivalent to an altered time management. Namely it is like the time management gives less available time than what should be in standard case. May be the second limitation could be mitigated in a future with a smarter 'dynamic npms' approach. Tests shows that the standard deviation of the results with 'nodestime' is lower than in standard TC, as is expected because now all the introduced noise due the random speed variability of the engines during the game is fully removed. Original NIT idea by Michael Hoffman that shows how to play in NIT mode without requiring changes to the GUI. This implementation goes a bit further, the key difference is that we read TC from GUI only once upfront instead of re-reading after every move as in Michael's implementation. No functional change.
114 lines
3.4 KiB
C++
114 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 <memory> // For std::auto_ptr
|
|
#include <stack>
|
|
#include <vector>
|
|
|
|
#include "misc.h"
|
|
#include "position.h"
|
|
#include "types.h"
|
|
|
|
struct SplitPoint;
|
|
|
|
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 {
|
|
SplitPoint* splitPoint;
|
|
Move* pv;
|
|
int ply;
|
|
Move currentMove;
|
|
Move ttMove;
|
|
Move excludedMove;
|
|
Move killers[2];
|
|
Depth reduction;
|
|
Value staticEval;
|
|
bool skipEarlyPruning;
|
|
};
|
|
|
|
/// 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;
|
|
};
|
|
|
|
/// The SignalsType struct stores volatile flags updated during the search
|
|
/// typically in an async fashion e.g. to stop the search by the GUI.
|
|
|
|
struct SignalsType {
|
|
bool stop, stopOnPonderhit, firstRootMove, failedLowAtRoot;
|
|
};
|
|
|
|
typedef std::unique_ptr<std::stack<StateInfo>> StateStackPtr;
|
|
|
|
extern volatile SignalsType Signals;
|
|
extern LimitsType Limits;
|
|
extern RootMoveVector RootMoves;
|
|
extern Position RootPos;
|
|
extern StateStackPtr SetupStates;
|
|
|
|
void init();
|
|
void think();
|
|
template<bool Root> uint64_t perft(Position& pos, Depth depth);
|
|
|
|
} // namespace Search
|
|
|
|
#endif // #ifndef SEARCH_H_INCLUDED
|