// Different node types, used as a template parameter
enum NodeType { NonPV, PV };
- constexpr uint64_t ttHitAverageWindow = 4096;
- constexpr uint64_t ttHitAverageResolution = 1024;
+ constexpr uint64_t TtHitAverageWindow = 4096;
+ constexpr uint64_t TtHitAverageResolution = 1024;
// Razor and futility margins
constexpr int RazorMargin = 531;
multiPV = std::max(multiPV, (size_t)4);
multiPV = std::min(multiPV, rootMoves.size());
- ttHitAverage = ttHitAverageWindow * ttHitAverageResolution / 2;
+ ttHitAverage = TtHitAverageWindow * TtHitAverageResolution / 2;
int ct = int(Options["Contempt"]) * PawnValueEg / 100; // From centipawns
Move ttMove, move, excludedMove, bestMove;
Depth extension, newDepth;
Value bestValue, value, ttValue, eval, maxValue;
- bool ttHit, ttPv, formerPv, inCheck, givesCheck, improving, didLMR, priorCapture;
+ bool ttHit, ttPv, formerPv, givesCheck, improving, didLMR, priorCapture;
bool captureOrPromotion, doFullDepthSearch, moveCountPruning, ttCapture, singularLMR;
Piece movedPiece;
int moveCount, captureCount, quietCount;
// Step 1. Initialize node
Thread* thisThread = pos.this_thread();
- inCheck = pos.checkers();
+ ss->inCheck = pos.checkers();
priorCapture = pos.captured_piece();
Color us = pos.side_to_move();
moveCount = captureCount = quietCount = ss->moveCount = 0;
if ( Threads.stop.load(std::memory_order_relaxed)
|| pos.is_draw(ss->ply)
|| ss->ply >= MAX_PLY)
- return (ss->ply >= MAX_PLY && !inCheck) ? evaluate(pos)
+ return (ss->ply >= MAX_PLY && !ss->inCheck) ? evaluate(pos)
: value_draw(pos.this_thread());
// Step 3. Mate distance pruning. Even if we mate at the next move our score
thisThread->lowPlyHistory[ss->ply - 1][from_to((ss-1)->currentMove)] << stat_bonus(depth - 5);
// thisThread->ttHitAverage can be used to approximate the running average of ttHit
- thisThread->ttHitAverage = (ttHitAverageWindow - 1) * thisThread->ttHitAverage / ttHitAverageWindow
- + ttHitAverageResolution * ttHit;
+ thisThread->ttHitAverage = (TtHitAverageWindow - 1) * thisThread->ttHitAverage / TtHitAverageWindow
+ + TtHitAverageResolution * ttHit;
// At non-PV nodes we check for an early TT cutoff
if ( !PvNode
CapturePieceToHistory& captureHistory = thisThread->captureHistory;
// Step 6. Static evaluation of the position
- if (inCheck)
+ if (ss->inCheck)
{
ss->staticEval = eval = VALUE_NONE;
improving = false;
probCutCount++;
ss->currentMove = move;
- ss->continuationHistory = &thisThread->continuationHistory[inCheck]
+ ss->continuationHistory = &thisThread->continuationHistory[ss->inCheck]
[captureOrPromotion]
[pos.moved_piece(move)]
[to_sq(move)];
// Futility pruning: parent node (~5 Elo)
if ( lmrDepth < 6
- && !inCheck
+ && !ss->inCheck
&& ss->staticEval + 235 + 172 * lmrDepth <= alpha
&& (*contHist[0])[movedPiece][to_sq(move)]
+ (*contHist[1])[movedPiece][to_sq(move)]
&& captureHistory[movedPiece][to_sq(move)][type_of(pos.piece_on(to_sq(move)))] < 0)
continue;
+ // Futility pruning for captures
+ if ( !givesCheck
+ && lmrDepth < 6
+ && !ss->inCheck
+ && ss->staticEval + 270 + 384 * lmrDepth + PieceValue[MG][type_of(pos.piece_on(to_sq(move)))] <= alpha)
+ continue;
+
// See based pruning
if (!pos.see_ge(move, Value(-194) * depth)) // (~25 Elo)
continue;
// Update the current move (this must be done after singular extension search)
ss->currentMove = move;
- ss->continuationHistory = &thisThread->continuationHistory[inCheck]
+ ss->continuationHistory = &thisThread->continuationHistory[ss->inCheck]
[captureOrPromotion]
[movedPiece]
[to_sq(move)];
|| moveCountPruning
|| ss->staticEval + PieceValue[EG][pos.captured_piece()] <= alpha
|| cutNode
- || thisThread->ttHitAverage < 375 * ttHitAverageResolution * ttHitAverageWindow / 1024))
+ || thisThread->ttHitAverage < 375 * TtHitAverageResolution * TtHitAverageWindow / 1024))
{
Depth r = reduction(improving, depth, moveCount);
// Decrease reduction if the ttHit running average is large
- if (thisThread->ttHitAverage > 500 * ttHitAverageResolution * ttHitAverageWindow / 1024)
+ if (thisThread->ttHitAverage > 500 * TtHitAverageResolution * TtHitAverageWindow / 1024)
r--;
// Reduction if other threads are searching this position.
// must be a mate or a stalemate. If we are in a singular extension search then
// return a fail low score.
- assert(moveCount || !inCheck || excludedMove || !MoveList<LEGAL>(pos).size());
+ assert(moveCount || !ss->inCheck || excludedMove || !MoveList<LEGAL>(pos).size());
if (!moveCount)
bestValue = excludedMove ? alpha
- : inCheck ? mated_in(ss->ply) : VALUE_DRAW;
+ : ss->inCheck ? mated_in(ss->ply) : VALUE_DRAW;
else if (bestMove)
update_all_stats(pos, ss, bestMove, bestValue, beta, prevSq,
Move ttMove, move, bestMove;
Depth ttDepth;
Value bestValue, value, ttValue, futilityValue, futilityBase, oldAlpha;
- bool ttHit, pvHit, inCheck, givesCheck, captureOrPromotion;
+ bool ttHit, pvHit, givesCheck, captureOrPromotion;
int moveCount;
if (PvNode)
Thread* thisThread = pos.this_thread();
(ss+1)->ply = ss->ply + 1;
bestMove = MOVE_NONE;
- inCheck = pos.checkers();
+ ss->inCheck = pos.checkers();
moveCount = 0;
// Check for an immediate draw or maximum ply reached
if ( pos.is_draw(ss->ply)
|| ss->ply >= MAX_PLY)
- return (ss->ply >= MAX_PLY && !inCheck) ? evaluate(pos) : VALUE_DRAW;
+ return (ss->ply >= MAX_PLY && !ss->inCheck) ? evaluate(pos) : VALUE_DRAW;
assert(0 <= ss->ply && ss->ply < MAX_PLY);
// Decide whether or not to include checks: this fixes also the type of
// TT entry depth that we are going to use. Note that in qsearch we use
// only two types of depth in TT: DEPTH_QS_CHECKS or DEPTH_QS_NO_CHECKS.
- ttDepth = inCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS
+ ttDepth = ss->inCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS
: DEPTH_QS_NO_CHECKS;
// Transposition table lookup
posKey = pos.key();
return ttValue;
// Evaluate the position statically
- if (inCheck)
+ if (ss->inCheck)
{
ss->staticEval = VALUE_NONE;
bestValue = futilityBase = -VALUE_INFINITE;
moveCount++;
// Futility pruning
- if ( !inCheck
+ if ( !ss->inCheck
&& !givesCheck
&& futilityBase > -VALUE_KNOWN_WIN
&& !pos.advanced_pawn_push(move))
}
// Don't search moves with negative SEE values
- if ( !inCheck && !pos.see_ge(move))
+ if ( !ss->inCheck && !pos.see_ge(move))
continue;
// Speculative prefetch as early as possible
}
ss->currentMove = move;
- ss->continuationHistory = &thisThread->continuationHistory[inCheck]
+ ss->continuationHistory = &thisThread->continuationHistory[ss->inCheck]
[captureOrPromotion]
[pos.moved_piece(move)]
[to_sq(move)];
// All legal moves have been searched. A special case: If we're in check
// and no legal moves were found, it is checkmate.
- if (inCheck && bestValue == -VALUE_INFINITE)
+ if (ss->inCheck && bestValue == -VALUE_INFINITE)
return mated_in(ss->ply); // Plies to mate from the root
tte->save(posKey, value_to_tt(bestValue, ss->ply), pvHit,
void update_continuation_histories(Stack* ss, Piece pc, Square to, int bonus) {
for (int i : {1, 2, 4, 6})
+ {
+ if (ss->inCheck && i > 2)
+ break;
if (is_ok((ss-i)->currentMove))
(*(ss-i)->continuationHistory)[pc][to] << bonus;
+ }
}