mirror of
https://github.com/official-stockfish/Stockfish.git
synced 2026-07-23 05:07:14 +00:00
Stéphane Nicolet
73018a0337
This patch detects some search explosions (due to double extensions in search.cpp) which can happen in some pathological positions, and takes measures to ensure progress in search even for these pathological situations. While a small number of double extensions can be useful during search (for example to resolve a tactical sequence), a sustained regime of double extensions leads to search explosion and a non-finishing search. See the discussion in https://github.com/official-stockfish/Stockfish/pull/3544 and the issue https://github.com/official-stockfish/Stockfish/issues/3532 . The implemented algorithm is the following: a) at each node during search, store the current depth in the stack. Double extensions are by definition levels of the stack where the depth at ply N is strictly higher than depth at ply N-1. b) during search, calculate for each thread a running average of the number of double extensions in the last 4096 visited nodes. c) if one thread has more than 2% of double extensions for a sustained period of time (6 millions consecutive nodes, or about 4 seconds on my iMac), we decide that this thread is in an explosion state and we calm down this thread by preventing it to do any double extension for the next 6 millions nodes. To calculate the running averages, we also introduced a auxiliary class generalizing the computations of ttHitAverage variable we already had in code. The implementation uses an exponential moving average of period 4096 and resolution 1/1024, and all computations are done with integers for efficiency. ----------- Example where the patch solves a search explosion: ``` ./stockfish ucinewgame position fen 8/Pk6/8/1p6/8/P1K5/8/6B1 w - - 37 130 go infinite ``` This algorithm does not affect search in normal, non-pathological positions. We verified, for instance, that the usual bench is unchanged up to depth 20 at least, and that the node numbers are unchanged for a search of the starting position at depth 32. ------------- See https://github.com/official-stockfish/Stockfish/pull/3714 Bench: 5575265
116 lines
3.1 KiB
C++
116 lines
3.1 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2021 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
|
|
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 <vector>
|
|
|
|
#include "misc.h"
|
|
#include "movepick.h"
|
|
#include "types.h"
|
|
|
|
namespace Stockfish {
|
|
|
|
class Position;
|
|
|
|
namespace Search {
|
|
|
|
/// Threshold used for countermoves based pruning
|
|
constexpr int CounterMovePruneThreshold = 0;
|
|
|
|
|
|
/// 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;
|
|
PieceToHistory* continuationHistory;
|
|
int ply;
|
|
Move currentMove;
|
|
Move excludedMove;
|
|
Move killers[2];
|
|
Value staticEval;
|
|
Depth depth;
|
|
int statScore;
|
|
int moveCount;
|
|
bool inCheck;
|
|
bool ttPv;
|
|
bool ttHit;
|
|
int doubleExtensions;
|
|
};
|
|
|
|
|
|
/// 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 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;
|
|
int selDepth = 0;
|
|
int tbRank = 0;
|
|
Value tbScore;
|
|
std::vector<Move> pv;
|
|
};
|
|
|
|
typedef std::vector<RootMove> RootMoves;
|
|
|
|
|
|
/// 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.
|
|
|
|
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;
|
|
}
|
|
|
|
bool use_time_management() const {
|
|
return time[WHITE] || time[BLACK];
|
|
}
|
|
|
|
std::vector<Move> searchmoves;
|
|
TimePoint time[COLOR_NB], inc[COLOR_NB], npmsec, movetime, startTime;
|
|
int movestogo, depth, mate, perft, infinite;
|
|
int64_t nodes;
|
|
};
|
|
|
|
extern LimitsType Limits;
|
|
|
|
void init();
|
|
void clear();
|
|
|
|
} // namespace Search
|
|
|
|
} // namespace Stockfish
|
|
|
|
#endif // #ifndef SEARCH_H_INCLUDED
|