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);
void Search::init() {
for (int i = 1; i < MAX_MOVES; ++i)
- Reductions[i] = int(21.3 * std::log(i + 0.25 * std::log(i)));
+ Reductions[i] = int(21.9 * std::log(i));
}
multiPV = std::min(multiPV, rootMoves.size());
ttHitAverage = TtHitAverageWindow * TtHitAverageResolution / 2;
- int ct = int(Options["Contempt"]) * PawnValueEg / 100; // From centipawns
-
- // In analysis mode, adjust contempt in accordance with user preference
- if (Limits.infinite || Options["UCI_AnalyseMode"])
- ct = Options["Analysis Contempt"] == "Off" ? 0
- : Options["Analysis Contempt"] == "Both" ? ct
- : Options["Analysis Contempt"] == "White" && us == BLACK ? -ct
- : Options["Analysis Contempt"] == "Black" && us == WHITE ? -ct
- : ct;
-
- // Evaluation score is from the white point of view
- contempt = (us == WHITE ? make_score(ct, ct / 2)
- : -make_score(ct, ct / 2));
+ trend = SCORE_ZERO;
int searchAgainCounter = 0;
alpha = std::max(prev - delta,-VALUE_INFINITE);
beta = std::min(prev + delta, VALUE_INFINITE);
- // Adjust contempt based on root move's previousScore (dynamic contempt)
- int dct = ct + (113 - ct / 2) * prev / (abs(prev) + 147);
+ // Adjust trend based on root move's previousScore (dynamic contempt)
+ int tr = 113 * prev / (abs(prev) + 147);
- contempt = (us == WHITE ? make_score(dct, dct / 2)
- : -make_score(dct, dct / 2));
+ trend = (us == WHITE ? make_score(tr, tr / 2)
+ : -make_score(tr, tr / 2));
}
// Start with a small aspiration window and, in the case of a fail
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
// 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));
assert(0 <= ss->ply && ss->ply < MAX_PLY);
- (ss+1)->ttPv = false;
+ (ss+1)->ttPv = false;
(ss+1)->excludedMove = bestMove = MOVE_NONE;
- (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
- Square prevSq = to_sq((ss-1)->currentMove);
+ (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
+ ss->doubleExtensions = (ss-1)->doubleExtensions;
+ Square prevSq = to_sq((ss-1)->currentMove);
// Initialize statScore to zero for the grandchildren of the current position.
// So statScore is shared between all grandchildren and only the first grandchild
ss->staticEval = eval = -(ss-1)->staticEval;
// Save static evaluation into transposition table
+ if(!excludedMove)
tte->save(posKey, VALUE_NONE, ss->ttPv, BOUND_NONE, DEPTH_NONE, MOVE_NONE, eval);
}
? ss->staticEval > (ss-4)->staticEval || (ss-4)->staticEval == VALUE_NONE
: ss->staticEval > (ss-2)->staticEval;
- // Step 7. Futility pruning: child node (~50 Elo)
+ // Step 7. Futility pruning: child node (~50 Elo).
+ // The depth condition is important for mate finding.
if ( !PvNode
&& depth < 9
&& eval - futility_margin(depth, improving) >= beta
assert(eval - beta >= 0);
// Null move dynamic reduction based on depth and value
- Depth R = (1090 + 81 * depth) / 256 + std::min(int(eval - beta) / 205, 3);
+ Depth R = std::min(int(eval - beta) / 205, 3) + depth / 3 + 4;
ss->currentMove = MOVE_NULL;
ss->continuationHistory = &thisThread->continuationHistory[0][0][NO_PIECE][0];
&& !ttMove)
depth -= 2;
-moves_loop: // When in check, search starts from here
+moves_loop: // When in check, search starts here
ttCapture = ttMove && pos.capture_or_promotion(ttMove);
value = bestValue;
singularQuietLMR = moveCountPruning = false;
+ bool doubleExtension = false;
// Indicate PvNodes that will probably fail low if the node was searched
// at a depth equal or greater than the current depth, and the result of this search was a fail low.
// Calculate new depth for this move
newDepth = depth - 1;
- // Step 13. Pruning at shallow depth (~200 Elo)
+ // Step 13. Pruning at shallow depth (~200 Elo). Depth conditions are important for mate finding.
if ( !rootNode
&& pos.non_pawn_material(us)
&& bestValue > VALUE_TB_LOSS_IN_MAX_PLY)
{
// Continuation history based pruning (~20 Elo)
if ( lmrDepth < 5
- && (*contHist[0])[movedPiece][to_sq(move)] < CounterMovePruneThreshold
- && (*contHist[1])[movedPiece][to_sq(move)] < CounterMovePruneThreshold)
+ && (*contHist[0])[movedPiece][to_sq(move)] < 23 - 23 * depth * depth
+ && (*contHist[1])[movedPiece][to_sq(move)] < 23 - 23 * depth * depth)
continue;
// Futility pruning: parent node (~5 Elo)
- if ( lmrDepth < 7
- && !ss->inCheck
- && ss->staticEval + 174 + 157 * lmrDepth <= alpha
- && (*contHist[0])[movedPiece][to_sq(move)]
- + (*contHist[1])[movedPiece][to_sq(move)]
- + (*contHist[3])[movedPiece][to_sq(move)]
- + (*contHist[5])[movedPiece][to_sq(move)] / 3 < 28255)
+ if ( !ss->inCheck
+ && lmrDepth < 7
+ && ss->staticEval + 174 + 157 * lmrDepth <= alpha)
continue;
// Prune moves with negative SEE (~20 Elo)
- if (!pos.see_ge(move, Value(-(30 - std::min(lmrDepth, 18)) * lmrDepth * lmrDepth)))
+ if (!pos.see_ge(move, Value(-21 * lmrDepth * lmrDepth - 21 * lmrDepth)))
continue;
}
}
// 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
{
extension = 1;
singularQuietLMR = !ttCapture;
- if (!PvNode && value < singularBeta - 93)
+
+ // Avoid search explosion by limiting the number of double extensions to at most 3
+ if ( !PvNode
+ && value < singularBeta - 93
+ && ss->doubleExtensions < 3)
+ {
extension = 2;
+ doubleExtension = true;
+ }
}
// Multi-cut pruning
// Add extension to new depth
newDepth += extension;
+ ss->doubleExtensions = (ss-1)->doubleExtensions + (extension == 2);
// Speculative prefetch as early as possible
prefetch(TT.first_entry(pos.key_after(move)));
{
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--;
// Increase reduction at root and non-PV nodes when the best move does not change frequently
if ( (rootNode || !PvNode)
- && thisThread->rootDepth > 10
&& thisThread->bestMoveChanges <= 2)
r++;
r--;
// Increase reduction for cut nodes (~3 Elo)
- if (cutNode)
- r += 1 + !captureOrPromotion;
+ if (cutNode && move != ss->killers[0])
+ r += 2;
- if (!captureOrPromotion)
- {
- // Increase reduction if ttMove is a capture (~3 Elo)
- if (ttCapture)
- r++;
-
- ss->statScore = thisThread->mainHistory[us][from_to(move)]
- + (*contHist[0])[movedPiece][to_sq(move)]
- + (*contHist[1])[movedPiece][to_sq(move)]
- + (*contHist[3])[movedPiece][to_sq(move)]
- - 4923;
-
- // Decrease/increase reduction for moves with a good/bad history (~30 Elo)
- if (!ss->inCheck)
- r -= ss->statScore / 14721;
- }
+ // Increase reduction if ttMove is a capture (~3 Elo)
+ if (ttCapture)
+ r++;
+
+ ss->statScore = thisThread->mainHistory[us][from_to(move)]
+ + (*contHist[0])[movedPiece][to_sq(move)]
+ + (*contHist[1])[movedPiece][to_sq(move)]
+ + (*contHist[3])[movedPiece][to_sq(move)]
+ - 4923;
+
+ // Decrease/increase reduction for moves with a good/bad history (~30 Elo)
+ r -= ss->statScore / 14721;
// In general we want to cap the LMR depth search at newDepth. But if
// reductions are really negative and movecount is low, we allow this move
- // to be searched deeper than the first move.
- Depth d = std::clamp(newDepth - r, 1, newDepth + (r < -1 && moveCount <= 5));
+ // to be searched deeper than the first move in specific cases.
+ Depth d = std::clamp(newDepth - r, 1, newDepth + (r < -1 && (moveCount <= 5 || (depth > 6 && PvNode)) && !doubleExtension));
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, true);
// 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));
// Initialize a MovePicker object for the current position, and prepare
// to search the moves. Because the depth is <= 0 here, only captures,
- // queen and checking knight promotions, and other checks(only if depth >= DEPTH_QS_CHECKS)
+ // queen promotions, and other checks (only if depth >= DEPTH_QS_CHECKS)
// will be generated.
MovePicker mp(pos, ttMove, depth, &thisThread->mainHistory,
&thisThread->captureHistory,
{
assert(is_ok(move));
+ // Check for legality
+ if (!pos.legal(move))
+ continue;
+
givesCheck = pos.gives_check(move);
captureOrPromotion = pos.capture_or_promotion(move);
// Speculative prefetch as early as possible
prefetch(TT.first_entry(pos.key_after(move)));
- // Check for legality just before making the move
- if (!pos.legal(move))
- {
- moveCount--;
- continue;
- }
-
ss->currentMove = move;
ss->continuationHistory = &thisThread->continuationHistory[ss->inCheck]
[captureOrPromotion]
// 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);
projects / stockfish / blobdiff