int MultiPV, UCIMultiPV, MultiPVIdx;
// Time management variables
- bool StopOnPonderhit, FirstRootMove, StopRequest, QuitRequest, AspirationFailLow;
+ volatile bool StopOnPonderhit, FirstRootMove, StopRequest, QuitRequest, AspirationFailLow;
TimeManager TimeMgr;
SearchLimits Limits;
pos.undo_move(bestMove); // Return from think() with unchanged position
}
- // If we are pondering or in infinite search, we shouldn't print the best move
+ // When we reach max depth we arrive here even without a StopRequest, but if
+ // we are pondering or in infinite search, we shouldn't print the best move
// before we are told to do so.
- if (Limits.ponder || Limits.infinite)
+ if (!StopRequest && (Limits.ponder || Limits.infinite))
wait_for_stop_or_ponderhit();
// Could be MOVE_NONE when searching on a stalemate position
if (depth > 2 && bestMoveChanges[depth])
bestMoveNeverChanged = false;
- // Check for some early stop condition
- if (!StopRequest && Limits.useTimeManagement())
+ // Do we have time for the next iteration? Can we stop searching now?
+ if (!StopRequest && !StopOnPonderhit && Limits.useTimeManagement())
{
// Take in account some extra time if the best move has changed
if (depth > 4 && depth < 50)
}
// If we are allowed to ponder do not stop the search now but keep pondering
- if (StopRequest && Limits.ponder)
+ if (StopRequest && Limits.ponder) // FIXME Limits.ponder is racy
{
StopRequest = false;
StopOnPonderhit = true;
ValueType vt;
Value bestValue, value, oldAlpha;
Value refinedValue, nullValue, futilityBase, futilityValue;
- bool isPvMove, inCheck, singularExtensionNode, givesCheck, captureOrPromotion, dangerous;
+ bool isPvMove, inCheck, singularExtensionNode, givesCheck;
+ bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount = 0, playedMoveCount = 0;
Thread& thread = Threads[pos.thread()];
SplitPoint* sp = NULL;
Value rBeta = ttValue - int(depth);
ss->excludedMove = move;
ss->skipNullMove = true;
- Value v = search<NonPV>(pos, ss, rBeta - 1, rBeta, depth / 2);
+ value = search<NonPV>(pos, ss, rBeta - 1, rBeta, depth / 2);
ss->skipNullMove = false;
ss->excludedMove = MOVE_NONE;
ss->bestMove = MOVE_NONE;
- if (v < rBeta)
+ if (value < rBeta)
ext = ONE_PLY;
}
}
// Step 14. Make the move
pos.do_move(move, st, ci, givesCheck);
- // Step extra. pv search (only in PV nodes)
- // The first move in list is the expected PV
- if (isPvMove)
- value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -alpha, DEPTH_ZERO)
- : - search<PV>(pos, ss+1, -beta, -alpha, newDepth);
- else
+ // Step 15. Reduced depth search (LMR). If the move fails high will be
+ // re-searched at full depth.
+ if ( depth > 3 * ONE_PLY
+ && !isPvMove
+ && !captureOrPromotion
+ && !dangerous
+ && !is_castle(move)
+ && ss->killers[0] != move
+ && ss->killers[1] != move)
{
- // Step 15. Reduced depth search
- // If the move fails high will be re-searched at full depth.
- bool doFullDepthSearch = true;
-
- if ( depth > 3 * ONE_PLY
- && !captureOrPromotion
- && !dangerous
- && !is_castle(move)
- && ss->killers[0] != move
- && ss->killers[1] != move
- && (ss->reduction = reduction<PvNode>(depth, moveCount)) != DEPTH_ZERO)
- {
- Depth d = newDepth - ss->reduction;
- alpha = SpNode ? sp->alpha : alpha;
+ ss->reduction = reduction<PvNode>(depth, moveCount);
+ Depth d = newDepth - ss->reduction;
+ alpha = SpNode ? sp->alpha : alpha;
- value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO)
- : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d);
+ value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO)
+ : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d);
- ss->reduction = DEPTH_ZERO;
- doFullDepthSearch = (value > alpha);
- }
+ doFullDepthSearch = (value > alpha && ss->reduction != DEPTH_ZERO);
+ ss->reduction = DEPTH_ZERO;
+ }
+ else
+ doFullDepthSearch = !isPvMove;
- // Step 16. Full depth search
- if (doFullDepthSearch)
- {
- alpha = SpNode ? sp->alpha : alpha;
- value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO)
- : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth);
-
- // Step extra. pv search (only in PV nodes)
- // Search only for possible new PV nodes, if instead value >= beta then
- // parent node fails low with value <= alpha and tries another move.
- if (PvNode && value > alpha && (RootNode || value < beta))
- value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -alpha, DEPTH_ZERO)
- : - search<PV>(pos, ss+1, -beta, -alpha, newDepth);
- }
+ // Step 16. Full depth search, when LMR is skipped or fails high
+ if (doFullDepthSearch)
+ {
+ alpha = SpNode ? sp->alpha : alpha;
+ value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO)
+ : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth);
}
+ // Only for PV nodes do a full PV search on the first move or after a fail
+ // high, in the latter case search only if value < beta, otherwise let the
+ // parent node to fail low with value <= alpha and to try another move.
+ if (PvNode && (isPvMove || (value > alpha && (RootNode || value < beta))))
+ value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -alpha, DEPTH_ZERO)
+ : - search<PV>(pos, ss+1, -beta, -alpha, newDepth);
+
// Step 17. Undo move
pos.undo_move(move);
static int lastInfoTime;
int e = elapsed_search_time();
- // Print debug information every second
- if (get_system_time() - lastInfoTime >= 1000)
+ // Print debug information every one second
+ if (!lastInfoTime || get_system_time() - lastInfoTime >= 1000)
{
lastInfoTime = get_system_time();