// Threads.stop. However, if we are pondering or in an infinite search,
// the UCI protocol states that we shouldn't print the best move before the
// GUI sends a "stop" or "ponderhit" command. We therefore simply wait here
- // until the GUI sends one of those commands (which also raises Threads.stop).
- Threads.stopOnPonderhit = true;
+ // until the GUI sends one of those commands.
- while (!Threads.stop && (Threads.ponder || Limits.infinite))
+ while (!Threads.stop && (ponder || Limits.infinite))
{} // Busy wait for a stop or a ponder reset
// Stop the threads if not already stopped (also raise the stop if
{
failedHighCnt = 0;
failedLow = true;
- Threads.stopOnPonderhit = false;
+ mainThread->stopOnPonderhit = false;
}
}
else if (bestValue >= beta)
// Do we have time for the next iteration? Can we stop searching now?
if ( Limits.use_time_management()
&& !Threads.stop
- && !Threads.stopOnPonderhit)
+ && !mainThread->stopOnPonderhit)
{
double fallingEval = (306 + 119 * failedLow + 6 * (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 = 1.0;
- for (int i : {3, 4, 5})
- if (lastBestMoveDepth * i < completedDepth)
- timeReduction *= 1.25;
+ timeReduction = lastBestMoveDepth + 10 * ONE_PLY < completedDepth ? 1.95 : 1.0;
// Use part of the gained time from a previous stable move for the current move
double bestMoveInstability = 1.0 + mainThread->bestMoveChanges;
{
// If we are allowed to ponder do not stop the search now but
// keep pondering until the GUI sends "ponderhit" or "stop".
- if (Threads.ponder)
- Threads.stopOnPonderhit = true;
+ if (mainThread->ponder)
+ mainThread->stopOnPonderhit = true;
else
Threads.stop = true;
}
Depth extension, newDepth;
Value bestValue, value, ttValue, eval, maxValue, pureStaticEval;
bool ttHit, pvHit, inCheck, givesCheck, improving;
- bool captureOrPromotion, doFullDepthSearch, moveCountPruning, skipQuiets, ttCapture, pvExact;
+ bool captureOrPromotion, doFullDepthSearch, moveCountPruning, skipQuiets, ttCapture;
Piece movedPiece;
int moveCount, captureCount, quietCount;
ttValue = ttHit ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE;
ttMove = rootNode ? thisThread->rootMoves[thisThread->pvIdx].pv[0]
: ttHit ? tte->move() : MOVE_NONE;
- pvHit = ttHit && tte->pv_hit();
+ pvHit = (ttHit && tte->pv_hit()) || (PvNode && depth > 4 * ONE_PLY);
// At non-PV nodes we check for an early TT cutoff
if ( !PvNode
return ttValue;
}
- if ( depth > 6 * ONE_PLY
- && !excludedMove
- && PvNode)
- pvHit = true;
-
// Step 5. Tablebases probe
if (!rootNode && TB::Cardinality)
{
skipQuiets = false;
ttCapture = ttMove && pos.capture_or_promotion(ttMove);
- pvExact = PvNode && ttHit && tte->bound() == BOUND_EXACT;
// Step 12. Loop through all pseudo-legal moves until no moves remain
// or a beta cutoff occurs.
Depth r = reduction<PvNode>(improving, depth, moveCount);
// Decrease reduction if position is or has been on the PV
- if (pvHit && !PvNode)
+ if (pvHit)
r -= ONE_PLY;
// Decrease reduction if opponent's move count is high (~10 Elo)
if (!captureOrPromotion)
{
- // Decrease reduction for exact PV nodes (~0 Elo)
- if (pvExact)
- r -= ONE_PLY;
-
// Increase reduction if ttMove is a capture (~0 Elo)
if (ttCapture)
r += ONE_PLY;
}
// We should not stop pondering until told so by the GUI
- if (Threads.ponder)
+ if (ponder)
return;
- if ( (Limits.use_time_management() && elapsed > Time.maximum() - 10)
+ if ( (Limits.use_time_management() && (elapsed > Time.maximum() - 10 || stopOnPonderhit))
|| (Limits.movetime && elapsed >= Limits.movetime)
|| (Limits.nodes && Threads.nodes_searched() >= (uint64_t)Limits.nodes))
Threads.stop = true;