Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
- Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
+ Copyright (C) 2015-2017 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
return Reductions[PvNode][i][std::min(d / ONE_PLY, 63)][std::min(mn, 63)] * ONE_PLY;
}
+ // History and stats update bonus, based on depth
+ Value stat_bonus(Depth depth) {
+ int d = depth / ONE_PLY ;
+ return Value(d * d + 2 * d - 2);
+ }
+
// Skill structure is used to implement strength limit
struct Skill {
Skill(int l) : level(l) {}
{1, 0, 0, 0, 0, 1, 1 ,1},
};
- Value bonus(Depth depth) { int d = depth / ONE_PLY ; return Value(d * d + 2 * d - 2); }
- Value penalty(Depth depth) { int d = depth / ONE_PLY ; return -Value(d * d + 4 * d + 1); }
-
const size_t HalfDensitySize = std::extent<decltype(HalfDensity)>::value;
EasyMoveManager EasyMove;
for (Thread* th : Threads)
{
- th->history.clear();
th->counterMoves.clear();
- th->fromTo.clear();
+ th->history.clear();
th->counterMoveHistory.clear();
th->resetCalls = true;
}
&& rootMoves[0].pv[0] != MOVE_NONE)
{
for (Thread* th : Threads)
- if ( th->completedDepth > bestThread->completedDepth
- && th->rootMoves[0].score > bestThread->rootMoves[0].score)
+ {
+ Depth depthDiff = th->completedDepth - bestThread->completedDepth;
+ Value scoreDiff = th->rootMoves[0].score - bestThread->rootMoves[0].score;
+
+ if (scoreDiff > 0 && depthDiff >= 0)
bestThread = th;
+ }
}
previousScore = bestThread->rootMoves[0].score;
bool doEasyMove = rootMoves[0].pv[0] == easyMove
&& mainThread->bestMoveChanges < 0.03
- && Time.elapsed() > Time.optimum() * 5 / 42;
+ && Time.elapsed() > Time.optimum() * 5 / 44;
if ( rootMoves.size() == 1
|| Time.elapsed() > Time.optimum() * unstablePvFactor * improvingFactor / 628
Key posKey;
Move ttMove, move, excludedMove, bestMove;
Depth extension, newDepth;
- Value bestValue, value, ttValue, eval, nullValue;
+ Value bestValue, value, ttValue, eval;
bool ttHit, inCheck, givesCheck, singularExtensionNode, improving;
bool captureOrPromotion, doFullDepthSearch, moveCountPruning;
Piece moved_piece;
&& (ttValue >= beta ? (tte->bound() & BOUND_LOWER)
: (tte->bound() & BOUND_UPPER)))
{
- // If ttMove is quiet, update killers, history, counter move on TT hit
- if (ttValue >= beta && ttMove)
+ // If ttMove is quiet, update move sorting heuristics on TT hit
+ if (ttMove)
{
- if (!pos.capture_or_promotion(ttMove))
- update_stats(pos, ss, ttMove, nullptr, 0, bonus(depth));
+ if (ttValue >= beta)
+ {
+ if (!pos.capture_or_promotion(ttMove))
+ update_stats(pos, ss, ttMove, nullptr, 0, stat_bonus(depth));
- // Extra penalty for a quiet TT move in previous ply when it gets refuted
- if ((ss-1)->moveCount == 1 && !pos.captured_piece())
- update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, penalty(depth));
+ // Extra penalty for a quiet TT move in previous ply when it gets refuted
+ if ((ss-1)->moveCount == 1 && !pos.captured_piece())
+ update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, -stat_bonus(depth + ONE_PLY));
+ }
+ // Penalty for a quiet ttMove that fails low
+ else if (!pos.capture_or_promotion(ttMove))
+ {
+ Value penalty = -stat_bonus(depth + ONE_PLY);
+ thisThread->history.update(pos.side_to_move(), ttMove, penalty);
+ update_cm_stats(ss, pos.moved_piece(ttMove), to_sq(ttMove), penalty);
+ }
}
return ttValue;
}
Depth R = ((823 + 67 * depth / ONE_PLY) / 256 + std::min((eval - beta) / PawnValueMg, 3)) * ONE_PLY;
pos.do_null_move(st);
- nullValue = depth-R < ONE_PLY ? -qsearch<NonPV, false>(pos, ss+1, -beta, -beta+1)
- : - search<NonPV>(pos, ss+1, -beta, -beta+1, depth-R, !cutNode, true);
+ Value nullValue = depth-R < ONE_PLY ? -qsearch<NonPV, false>(pos, ss+1, -beta, -beta+1)
+ : - search<NonPV>(pos, ss+1, -beta, -beta+1, depth-R, !cutNode, true);
pos.undo_null_move();
if (nullValue >= beta)
moveCountPruning = depth < 16 * ONE_PLY
&& moveCount >= FutilityMoveCounts[improving][depth / ONE_PLY];
- // Step 12. Extend checks
+ // Step 12. Extensions
+ // Extend checks
if ( givesCheck
&& !moveCountPruning
&& pos.see_ge(move, VALUE_ZERO))
extension = ONE_PLY;
}
- // Update the current move (this must be done after singular extension search)
+ // Calculate new depth for this move
newDepth = depth - ONE_PLY + extension;
// Step 13. Pruning at shallow depth
continue;
}
+ // Update the current move (this must be done after singular extension search)
ss->currentMove = move;
ss->counterMoves = &thisThread->counterMoveHistory[moved_piece][to_sq(move)];
&& !pos.see_ge(make_move(to_sq(move), from_sq(move)), VALUE_ZERO))
r -= 2 * ONE_PLY;
- ss->history = thisThread->history[moved_piece][to_sq(move)]
- + (cmh ? (*cmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
- + (fmh ? (*fmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
- + (fmh2 ? (*fmh2)[moved_piece][to_sq(move)] : VALUE_ZERO)
- + thisThread->fromTo.get(~pos.side_to_move(), move)
- - 8000; // Correction factor
+ ss->history = (cmh ? (*cmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
+ + (fmh ? (*fmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
+ + (fmh2 ? (*fmh2)[moved_piece][to_sq(move)] : VALUE_ZERO)
+ + thisThread->history.get(~pos.side_to_move(), move)
+ - 4000; // Correction factor
// Decrease/increase reduction by comparing opponent's stat score
if (ss->history > VALUE_ZERO && (ss-1)->history < VALUE_ZERO)
else if (bestMove)
{
- // Quiet best move: update killers, history and countermoves
+ // Quiet best move: update move sorting heuristics
if (!pos.capture_or_promotion(bestMove))
- update_stats(pos, ss, bestMove, quietsSearched, quietCount, bonus(depth));
+ update_stats(pos, ss, bestMove, quietsSearched, quietCount, stat_bonus(depth));
// Extra penalty for a quiet TT move in previous ply when it gets refuted
if ((ss-1)->moveCount == 1 && !pos.captured_piece())
- update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, penalty(depth));
+ update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, -stat_bonus(depth + ONE_PLY));
}
// Bonus for prior countermove that caused the fail low
else if ( depth >= 3 * ONE_PLY
&& !pos.captured_piece()
&& is_ok((ss-1)->currentMove))
- update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, bonus(depth));
+ update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, stat_bonus(depth));
tte->save(posKey, value_to_tt(bestValue, ss->ply),
bestValue >= beta ? BOUND_LOWER :
}
- // update_stats() updates killers, history, countermove and countermove plus
- // follow-up move history when a new quiet best move is found.
+ // update_stats() updates move sorting heuristics when a new quiet best move is found
void update_stats(const Position& pos, Stack* ss, Move move,
Move* quiets, int quietsCnt, Value bonus) {
Color c = pos.side_to_move();
Thread* thisThread = pos.this_thread();
- thisThread->fromTo.update(c, move, bonus);
- thisThread->history.update(pos.moved_piece(move), to_sq(move), bonus);
+ thisThread->history.update(c, move, bonus);
update_cm_stats(ss, pos.moved_piece(move), to_sq(move), bonus);
if ((ss-1)->counterMoves)
// Decrease all the other played quiet moves
for (int i = 0; i < quietsCnt; ++i)
{
- thisThread->fromTo.update(c, quiets[i], -bonus);
- thisThread->history.update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
+ thisThread->history.update(c, quiets[i], -bonus);
update_cm_stats(ss, pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
}
}
projects / stockfish / blobdiff