How does Stockfish determine how long to think on moves?

[Clausable]

I'm just running a chess engine tournament on my computer just for fun, and I was wondering how does Stockfish determine how long to think on moves? I noticed that sometimes Stockfish thinks like 5 seconds on the first move during 1+0 time control, and then starts spending less than a second on the next several moves. Why and how does Stockfish do this?

[Sopel97]

It's complicated

Stockfish/src/timeman.cpp

Lines 37 to 103 in c2d5070

	void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) {
	TimePoint moveOverhead = TimePoint(Options["Move Overhead"]);
	TimePoint slowMover = TimePoint(Options["Slow Mover"]);
	TimePoint npmsec = TimePoint(Options["nodestime"]);
	// optScale is a percentage of available time to use for the current move.
	// maxScale is a multiplier applied to optimumTime.
	double optScale, maxScale;
	// If we have to play in 'nodes as time' mode, then convert from time
	// to nodes, and use resulting values in time management formulas.
	// WARNING: to avoid time losses, the given npmsec (nodes per millisecond)
	// must be much lower than the real engine speed.
	if (npmsec)
	{
	if (!availableNodes) // Only once at game start
	availableNodes = npmsec * limits.time[us]; // Time is in msec
	// Convert from milliseconds to nodes
	limits.time[us] = TimePoint(availableNodes);
	limits.inc[us] *= npmsec;
	limits.npmsec = npmsec;
	}
	startTime = limits.startTime;
	// Maximum move horizon of 50 moves
	int mtg = limits.movestogo ? std::min(limits.movestogo, 50) : 50;
	// Make sure timeLeft is > 0 since we may use it as a divisor
	TimePoint timeLeft = std::max(TimePoint(1),
	limits.time[us] + limits.inc[us] * (mtg - 1) - moveOverhead * (2 + mtg));
	// Use extra time with larger increments
	double optExtra = std::clamp(1.0 + 12.0 * limits.inc[us] / limits.time[us], 1.0, 1.12);
	// A user may scale time usage by setting UCI option "Slow Mover"
	// Default is 100 and changing this value will probably lose elo.
	timeLeft = slowMover * timeLeft / 100;
	// x basetime (+ z increment)
	// If there is a healthy increment, timeLeft can exceed actual available
	// game time for the current move, so also cap to 20% of available game time.
	if (limits.movestogo == 0)
	{
	optScale = std::min(0.0120 + std::pow(ply + 3.0, 0.45) * 0.0039,
	0.2 * limits.time[us] / double(timeLeft))
	* optExtra;
	maxScale = std::min(7.0, 4.0 + ply / 12.0);
	}
	// x moves in y seconds (+ z increment)
	else
	{
	optScale = std::min((0.88 + ply / 116.4) / mtg,
	0.88 * limits.time[us] / double(timeLeft));
	maxScale = std::min(6.3, 1.5 + 0.11 * mtg);
	}
	// Never use more than 80% of the available time for this move
	optimumTime = TimePoint(optScale * timeLeft);
	maximumTime = TimePoint(std::min(0.8 * limits.time[us] - moveOverhead, maxScale * optimumTime));
	if (Options["Ponder"])
	optimumTime += optimumTime / 4;
	}

Stockfish/src/search.cpp

Lines 458 to 494 in c2d5070

	if ( Limits.use_time_management()
	&& !Threads.stop
	&& !mainThread->stopOnPonderhit)
	{
	double fallingEval = (71 + 12 * (mainThread->bestPreviousAverageScore - bestValue)
	+ 6 * (mainThread->iterValue[iterIdx] - bestValue)) / 656.7;
	fallingEval = std::clamp(fallingEval, 0.5, 1.5);
	// If the bestMove is stable over several iterations, reduce time accordingly
	timeReduction = lastBestMoveDepth + 9 < completedDepth ? 1.37 : 0.65;
	double reduction = (1.4 + mainThread->previousTimeReduction) / (2.15 * timeReduction);
	double bestMoveInstability = 1 + 1.7 * totBestMoveChanges / Threads.size();
	int complexity = mainThread->complexityAverage.value();
	double complexPosition = std::min(1.0 + (complexity - 261) / 1738.7, 1.5);
	double totalTime = Time.optimum() * fallingEval * reduction * bestMoveInstability * complexPosition;
	// Cap used time in case of a single legal move for a better viewer experience in tournaments
	// yielding correct scores and sufficiently fast moves.
	if (rootMoves.size() == 1)
	totalTime = std::min(500.0, totalTime);
	// Stop the search if we have exceeded the totalTime
	if (Time.elapsed() > totalTime)
	{
	// If we are allowed to ponder do not stop the search now but
	// keep pondering until the GUI sends "ponderhit" or "stop".
	if (mainThread->ponder)
	mainThread->stopOnPonderhit = true;
	else
	Threads.stop = true;
	}
	else if ( !mainThread->ponder
	&& Time.elapsed() > totalTime * 0.53)
	Threads.increaseDepth = false;
	else
	Threads.increaseDepth = true;

and a few more places in search

[vondele]

A relatively simple scheme establishes the base time (more or less a fraction of the available time), and all kind of factors such as bestmove stability, complexity of the position, stability of the evaluation, etc. influence how much this base time is adjusted to the needs of the position.