namespace {
// Different node types, used as a template parameter
- enum NodeType { NonPV, PV };
+ enum NodeType { NonPV, PV, Root };
constexpr uint64_t TtHitAverageWindow = 4096;
constexpr uint64_t TtHitAverageResolution = 1024;
Move best = MOVE_NONE;
};
- template <NodeType NT>
+ template <NodeType nodeType>
Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode);
- template <NodeType NT>
+ template <NodeType nodeType>
Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth = 0);
Value value_to_tt(Value v, int ply);
while (true)
{
Depth adjustedDepth = std::max(1, rootDepth - failedHighCnt - searchAgainCounter);
- bestValue = Stockfish::search<PV>(rootPos, ss, alpha, beta, adjustedDepth, false);
+ bestValue = Stockfish::search<Root>(rootPos, ss, alpha, beta, adjustedDepth, false);
// Bring the best move to the front. It is critical that sorting
// is done with a stable algorithm because all the values but the
totBestMoveChanges += th->bestMoveChanges;
th->bestMoveChanges = 0;
}
- double bestMoveInstability = 1 + 2 * totBestMoveChanges / Threads.size();
-
+ double bestMoveInstability = 1.073 + std::max(1.0, 2.25 - 9.9 / rootDepth)
+ * totBestMoveChanges / Threads.size();
double totalTime = Time.optimum() * fallingEval * reduction * bestMoveInstability;
// Cap used time in case of a single legal move for a better viewer experience in tournaments
// search<>() is the main search function for both PV and non-PV nodes
- template <NodeType NT>
+ template <NodeType nodeType>
Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode) {
- constexpr bool PvNode = NT == PV;
- const bool rootNode = PvNode && ss->ply == 0;
+ constexpr bool PvNode = nodeType != NonPV;
+ constexpr bool rootNode = nodeType == Root;
const Depth maxNextDepth = rootNode ? depth : depth + 1;
// Check if we have an upcoming move which draws by repetition, or
// if the opponent had an alternative move earlier to this position.
- if ( pos.rule50_count() >= 3
+ if ( !rootNode
+ && pos.rule50_count() >= 3
&& alpha < VALUE_DRAW
- && !rootNode
&& pos.has_game_cycle(ss->ply))
{
alpha = value_draw(pos.this_thread());
// Dive into quiescence search when the depth reaches zero
if (depth <= 0)
- return qsearch<NT>(pos, ss, alpha, beta);
+ return qsearch<PvNode ? PV : NonPV>(pos, ss, alpha, beta);
assert(-VALUE_INFINITE <= alpha && alpha < beta && beta <= VALUE_INFINITE);
assert(PvNode || (alpha == beta - 1));
// then that move is singular and should be extended. To verify this we do
// a reduced search on all the other moves but the ttMove and if the
// result is lower than ttValue minus a margin, then we will extend the ttMove.
- if ( depth >= 7
+ if ( !rootNode
+ && depth >= 7
&& move == ttMove
- && !rootNode
&& !excludedMove // Avoid recursive singular search
/* && ttValue != VALUE_NONE Already implicit in the next condition */
&& abs(ttValue) < VALUE_KNOWN_WIN
{
Depth r = reduction(improving, depth, moveCount);
+ if (PvNode)
+ r--;
+
// Decrease reduction if the ttHit running average is large (~0 Elo)
if (thisThread->ttHitAverage > 537 * TtHitAverageResolution * TtHitAverageWindow / 1024)
r--;
// qsearch() is the quiescence search function, which is called by the main search
// function with zero depth, or recursively with further decreasing depth per call.
- template <NodeType NT>
+ template <NodeType nodeType>
Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth) {
- constexpr bool PvNode = NT == PV;
+ static_assert(nodeType != Root);
+ constexpr bool PvNode = nodeType == PV;
assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);
assert(PvNode || (alpha == beta - 1));
// Make and search the move
pos.do_move(move, st, givesCheck);
- value = -qsearch<NT>(pos, ss+1, -beta, -alpha, depth - 1);
+ value = -qsearch<nodeType>(pos, ss+1, -beta, -alpha, depth - 1);
pos.undo_move(move);
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);