// Different node types, used as a template parameter
enum NodeType { NonPV, PV };
- // Sizes and phases of the skip-blocks, used for distributing search depths across the threads
- constexpr int SkipSize[] = { 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
- constexpr int SkipPhase[] = { 0, 1, 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 7 };
-
// Razor and futility margins
constexpr int RazorMargin = 600;
Value futility_margin(Depth d, bool improving) {
MainThread* mainThread = (this == Threads.main() ? Threads.main() : nullptr);
double timeReduction = 1.0;
Color us = rootPos.side_to_move();
- bool failedLow;
std::memset(ss-7, 0, 10 * sizeof(Stack));
for (int i = 7; i > 0; i--)
beta = VALUE_INFINITE;
if (mainThread)
- mainThread->bestMoveChanges = 0, failedLow = false;
+ mainThread->bestMoveChanges = 0;
size_t multiPV = Options["MultiPV"];
Skill skill(Options["Skill Level"]);
&& !Threads.stop
&& !(Limits.depth && mainThread && rootDepth / ONE_PLY > Limits.depth))
{
- // Distribute search depths across the helper threads
- if (idx > 0)
- {
- int i = (idx - 1) % 20;
- if (((rootDepth / ONE_PLY + SkipPhase[i]) / SkipSize[i]) % 2)
- continue; // Retry with an incremented rootDepth
- }
-
// Age out PV variability metric
if (mainThread)
- mainThread->bestMoveChanges *= 0.517, failedLow = false;
+ mainThread->bestMoveChanges *= 0.517;
// Save the last iteration's scores before first PV line is searched and
// all the move scores except the (new) PV are set to -VALUE_INFINITE.
if (mainThread)
{
failedHighCnt = 0;
- failedLow = true;
mainThread->stopOnPonderhit = false;
}
}
&& !Threads.stop
&& !mainThread->stopOnPonderhit)
{
- double fallingEval = (306 + 119 * failedLow + 6 * (mainThread->previousScore - bestValue)) / 581.0;
+ double fallingEval = (306 + 9 * (mainThread->previousScore - bestValue)) / 581.0;
fallingEval = std::max(0.5, std::min(1.5, fallingEval));
// If the bestMove is stable over several iterations, reduce time accordingly
timeReduction = lastBestMoveDepth + 10 * ONE_PLY < completedDepth ? 1.95 : 1.0;
+ double reduction = std::pow(mainThread->previousTimeReduction, 0.528) / timeReduction;
// Use part of the gained time from a previous stable move for the current move
double bestMoveInstability = 1.0 + mainThread->bestMoveChanges;
- bestMoveInstability *= std::pow(mainThread->previousTimeReduction, 0.528) / timeReduction;
// Stop the search if we have only one legal move, or if available time elapsed
if ( rootMoves.size() == 1
- || Time.elapsed() > Time.optimum() * bestMoveInstability * fallingEval)
+ || Time.elapsed() > Time.optimum() * fallingEval * reduction * bestMoveInstability)
{
// If we are allowed to ponder do not stop the search now but
// keep pondering until the GUI sends "ponderhit" or "stop".
&& move == ttMove
&& !rootNode
&& !excludedMove // Avoid recursive singular search
- && ttValue != VALUE_NONE
+ /* && ttValue != VALUE_NONE Already implicit in the next condition */
+ && abs(ttValue) < VALUE_KNOWN_WIN
&& (tte->bound() & BOUND_LOWER)
&& tte->depth() >= depth - 3 * ONE_PLY
&& pos.legal(move))
{
- Value singularBeta = std::max(ttValue - 2 * depth / ONE_PLY, -VALUE_MATE);
+ Value singularBeta = ttValue - 2 * depth / ONE_PLY;
ss->excludedMove = move;
value = search<NonPV>(pos, ss, singularBeta - 1, singularBeta, depth / 2, cutNode);
ss->excludedMove = MOVE_NONE;
if (!pos.see_ge(move, Value(-29 * lmrDepth * lmrDepth)))
continue;
}
- else if ( !extension // (~20 Elo)
- && !pos.see_ge(move, -PawnValueEg * (depth / ONE_PLY)))
+ else if (!pos.see_ge(move, -PawnValueEg * (depth / ONE_PLY))) // (~20 Elo)
continue;
}