// consumed, the user stops the search, or the maximum search depth is reached.
void Thread::search() {
- // Allocate stack with extra size to allow access from (ss-7) to (ss+2):
- // (ss-7) is needed for update_continuation_histories(ss-1) which accesses (ss-6),
- // (ss+2) is needed for initialization of statScore and killers.
+ // Allocate stack with extra size to allow access from (ss - 7) to (ss + 2):
+ // (ss - 7) is needed for update_continuation_histories(ss - 1) which accesses (ss - 6),
+ // (ss + 2) is needed for initialization of cutOffCnt and killers.
Stack stack[MAX_PLY + 10], *ss = stack + 7;
Move pv[MAX_PLY + 1];
Value alpha, beta, delta;
selDepth = 0;
// Reset aspiration window starting size
- Value prev = rootMoves[pvIdx].averageScore;
- delta = Value(10) + int(prev) * prev / 17470;
- alpha = std::max(prev - delta, -VALUE_INFINITE);
- beta = std::min(prev + delta, VALUE_INFINITE);
+ Value avg = rootMoves[pvIdx].averageScore;
+ delta = Value(10) + int(avg) * avg / 17470;
+ alpha = std::max(avg - delta, -VALUE_INFINITE);
+ beta = std::min(avg + delta, VALUE_INFINITE);
- // Adjust optimism based on root move's previousScore (~4 Elo)
- int opt = 113 * prev / (std::abs(prev) + 109);
+ // Adjust optimism based on root move's averageScore (~4 Elo)
+ int opt = 113 * avg / (std::abs(avg) + 109);
optimism[us] = Value(opt);
optimism[~us] = -optimism[us];
int failedHighCnt = 0;
while (true)
{
- // Adjust the effective depth searched, but ensure at least one effective increment for every
- // four searchAgain steps (see issue #2717).
+ // Adjust the effective depth searched, but ensure at least one effective increment
+ // for every four searchAgain steps (see issue #2717).
Depth adjustedDepth =
std::max(1, rootDepth - failedHighCnt - 3 * (searchAgainCounter + 1) / 4);
bestValue = Stockfish::search<Root>(rootPos, ss, alpha, beta, adjustedDepth, false);
// Do we have time for the next iteration? Can we stop searching now?
if (Limits.use_time_management() && !Threads.stop && !mainThread->stopOnPonderhit)
{
- double fallingEval = (69 + 13 * (mainThread->bestPreviousAverageScore - bestValue)
+ double fallingEval = (66 + 14 * (mainThread->bestPreviousAverageScore - bestValue)
+ 6 * (mainThread->iterValue[iterIdx] - bestValue))
- / 619.6;
+ / 583.0;
fallingEval = std::clamp(fallingEval, 0.5, 1.5);
// If the bestMove is stable over several iterations, reduce time accordingly
- timeReduction = lastBestMoveDepth + 8 < completedDepth ? 1.57 : 0.65;
- double reduction = (1.4 + mainThread->previousTimeReduction) / (2.08 * timeReduction);
- double bestMoveInstability = 1 + 1.8 * totBestMoveChanges / Threads.size();
+ timeReduction = lastBestMoveDepth + 8 < completedDepth ? 1.56 : 0.69;
+ double reduction = (1.4 + mainThread->previousTimeReduction) / (2.03 * timeReduction);
+ double bestMoveInstability = 1 + 1.79 * totBestMoveChanges / Threads.size();
double totalTime = Time.optimum() * fallingEval * reduction * bestMoveInstability;
: value_draw(pos.this_thread());
// Step 3. Mate distance pruning. Even if we mate at the next move our score
- // would be at best mate_in(ss->ply+1), but if alpha is already bigger because
+ // would be at best mate_in(ss->ply + 1), but if alpha is already bigger because
// a shorter mate was found upward in the tree then there is no need to search
// because we will never beat the current alpha. Same logic but with reversed
// signs apply also in the opposite condition of being mated instead of giving
if (!ttCapture)
update_quiet_stats(pos, ss, ttMove, stat_bonus(depth));
- // Extra penalty for early quiet moves of the previous ply (~0 Elo on STC, ~2 Elo on LTC)
+ // Extra penalty for early quiet moves of
+ // the previous ply (~0 Elo on STC, ~2 Elo on LTC).
if (prevSq != SQ_NONE && (ss - 1)->moveCount <= 2 && !priorCapture)
update_continuation_histories(ss - 1, pos.piece_on(prevSq), prevSq,
-stat_bonus(depth + 1));
}
else if (excludedMove)
{
- // Providing the hint that this node's accumulator will be used often brings significant Elo gain (~13 Elo)
+ // Providing the hint that this node's accumulator will be used often
+ // brings significant Elo gain (~13 Elo).
Eval::NNUE::hint_common_parent_position(pos);
eval = ss->staticEval;
}
- (ss - 1)->statScore / 321
>= beta
&& eval >= beta && eval < 29462 // smaller than TB wins
- && !(!ttCapture && ttMove))
+ && (!ttMove || ttCapture))
return eval;
// Step 9. Null move search with verification search (~35 Elo)
}
}
- // Step 10. If the position doesn't have a ttMove, decrease depth by 2
- // (or by 4 if the TT entry for the current position was hit and the stored depth is greater than or equal to the current depth).
+ // Step 10. If the position doesn't have a ttMove, decrease depth by 2,
+ // or by 4 if the TT entry for the current position was hit and
+ // the stored depth is greater than or equal to the current depth.
// Use qsearch if depth is equal or below zero (~9 Elo)
if (PvNode && !ttMove)
depth -= 2 + 2 * (ss->ttHit && tte->depth() >= depth);
{
assert(probCutBeta < VALUE_INFINITE);
- MovePicker mp(pos, ttMove, probCutBeta - ss->staticEval, &captureHistory);
+ MovePicker mp(pos, ttMove, probCutBeta - ss->staticEval, &captureHistory,
+ thisThread->pawnHistory);
while ((move = mp.next_move()) != MOVE_NONE)
if (move != excludedMove && pos.legal(move))
prevSq != SQ_NONE ? thisThread->counterMoves[pos.piece_on(prevSq)][prevSq] : MOVE_NONE;
MovePicker mp(pos, ttMove, depth, &thisThread->mainHistory, &captureHistory, contHist,
- countermove, ss->killers);
+ thisThread->pawnHistory, countermove, ss->killers);
value = bestValue;
moveCountPruning = singularQuietLMR = false;
if (capture || givesCheck)
{
// Futility pruning for captures (~2 Elo)
- if (!givesCheck && lmrDepth < 7 && !ss->inCheck
- && ss->staticEval + 188 + 206 * lmrDepth + PieceValue[pos.piece_on(to_sq(move))]
- + captureHistory[movedPiece][to_sq(move)]
- [type_of(pos.piece_on(to_sq(move)))]
- / 7
- < alpha)
- continue;
+ if (!givesCheck && lmrDepth < 7 && !ss->inCheck)
+ {
+ Piece capturedPiece = pos.piece_on(to_sq(move));
+ int futilityEval =
+ ss->staticEval + 239 + 291 * lmrDepth + PieceValue[capturedPiece]
+ + captureHistory[movedPiece][to_sq(move)][type_of(capturedPiece)] / 7;
+ if (futilityEval < alpha)
+ continue;
+ }
// SEE based pruning for captures and checks (~11 Elo)
if (!pos.see_ge(move, Value(-185) * depth))
{
int history = (*contHist[0])[movedPiece][to_sq(move)]
+ (*contHist[1])[movedPiece][to_sq(move)]
- + (*contHist[3])[movedPiece][to_sq(move)];
+ + (*contHist[3])[movedPiece][to_sq(move)]
+ + thisThread->pawnHistory[pawn_structure(pos)][movedPiece][to_sq(move)];
// Continuation history based pruning (~2 Elo)
- if (lmrDepth < 6 && history < -3232 * depth)
+ if (lmrDepth < 6 && history < -3498 * depth)
continue;
history += 2 * thisThread->mainHistory[us][from_to(move)];
- lmrDepth += history / 5793;
+ lmrDepth += history / 7815;
lmrDepth = std::max(lmrDepth, -2);
// Futility pruning: parent node (~13 Elo)
- if (!ss->inCheck && lmrDepth < 13 && ss->staticEval + 115 + 122 * lmrDepth <= alpha)
+ if (!ss->inCheck && lmrDepth < 13 && ss->staticEval + 80 + 122 * lmrDepth <= alpha)
continue;
lmrDepth = std::max(lmrDepth, 0);
// that depth margin and singularBeta margin are known for having non-linear
// scaling. Their values are optimized to time controls of 180+1.8 and longer
// so changing them requires tests at this type of time controls.
- if (!rootNode
+ // Recursive singular search is avoided.
+ if (!rootNode && move == ttMove && !excludedMove
&& depth >= 4 - (thisThread->completedDepth > 24) + 2 * (PvNode && tte->is_pv())
- && move == ttMove && !excludedMove // Avoid recursive singular search
&& abs(ttValue) < VALUE_TB_WIN_IN_MAX_PLY && (tte->bound() & BOUND_LOWER)
&& tte->depth() >= depth - 3)
{
else if (singularBeta >= beta)
return singularBeta;
- // If the eval of ttMove is greater than beta, we reduce it (negative extension) (~7 Elo)
+ // If the eval of ttMove is greater than beta, reduce it (negative extension) (~7 Elo)
else if (ttValue >= beta)
extension = -2 - !PvNode;
else if (cutNode)
extension = depth < 19 ? -2 : -1;
- // If the eval of ttMove is less than value, we reduce it (negative extension) (~1 Elo)
+ // If the eval of ttMove is less than value, reduce it (negative extension) (~1 Elo)
else if (ttValue <= value)
extension = -1;
}
// will be generated.
Square prevSq = is_ok((ss - 1)->currentMove) ? to_sq((ss - 1)->currentMove) : SQ_NONE;
MovePicker mp(pos, ttMove, depth, &thisThread->mainHistory, &thisThread->captureHistory,
- contHist, prevSq);
+ contHist, thisThread->pawnHistory, prevSq);
int quietCheckEvasions = 0;
// Increase stats for the best move in case it was a quiet move
update_quiet_stats(pos, ss, bestMove, bestMoveBonus);
+ thisThread->pawnHistory[pawn_structure(pos)][moved_piece][to_sq(bestMove)]
+ << quietMoveBonus;
// Decrease stats for all non-best quiet moves
for (int i = 0; i < quietCount; ++i)
{
+ thisThread->pawnHistory[pawn_structure(pos)][pos.moved_piece(quietsSearched[i])]
+ [to_sq(quietsSearched[i])]
+ << -bestMoveBonus;
thisThread->mainHistory[us][from_to(quietsSearched[i])] << -bestMoveBonus;
update_continuation_histories(ss, pos.moved_piece(quietsSearched[i]),
to_sq(quietsSearched[i]), -bestMoveBonus);
projects / stockfish / blobdiff