/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, 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
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-
-////
-//// Includes
-////
-
#include <cmath>
+#include <algorithm>
-#include "misc.h"
+#include "search.h"
+#include "timeman.h"
#include "ucioption.h"
-////
-//// Local definitions
-////
-
namespace {
/// Constants
const int MoveHorizon = 50; // Plan time management at most this many moves ahead
- const float MaxRatio = 3.0f; // When in trouble, we can step over reserved time with this ratio
+ const float MaxRatio = 7.0f; // When in trouble, we can step over reserved time with this ratio
const float StealRatio = 0.33f; // However we must not steal time from remaining moves over this ratio
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 2, 2, 2, 2,
2, 1, 1, 1, 1, 1, 1, 1 };
- int move_importance(int ply) { return MoveImportance[Min(ply, 511)]; }
+ int move_importance(int ply) { return MoveImportance[std::min(ply, 511)]; }
/// Function Prototypes
enum TimeType { OptimumTime, MaxTime };
template<TimeType>
- int remaining(int myTime, int movesToGo, int currentPly);
+ int remaining(int myTime, int movesToGo, int fullMoveNumber, int slowMover);
}
-////
-//// Functions
-////
+void TimeManager::pv_instability(float bestMoveChanges) {
+
+ unstablePVExtraTime = int(bestMoveChanges * optimumSearchTime);
+}
+
-void get_search_times(int myTime, int myInc, int movesToGo, int currentPly,
- int* optimumSearchTime, int* maximumSearchTime)
+void TimeManager::init(const Search::LimitsType& limits, int currentPly, Color us)
{
/* We support four different kind of time controls:
- Inc == 0 && movesToGo == 0 means: x basetime [sudden death!]
- Inc == 0 && movesToGo != 0 means: (x moves) / (y minutes)
- Inc > 0 && movesToGo == 0 means: x basetime + z inc.
- Inc > 0 && movesToGo != 0 means: (x moves) / (y minutes) + z inc
+ increment == 0 && movesToGo == 0 means: x basetime [sudden death!]
+ increment == 0 && movesToGo != 0 means: x moves in y minutes
+ increment > 0 && movesToGo == 0 means: x basetime + z increment
+ increment > 0 && movesToGo != 0 means: x moves in y minutes + z increment
Time management is adjusted by following UCI parameters:
- emergencyMoveHorizon :Be prepared to always play at least this many moves
- emergencyBaseTime :Always attempt to keep at least this much time (in ms) at clock
- emergencyMoveTime :Plus attempt to keep at least this much time for each remaining emergency move
- minThinkingTime :No matter what, use at least this much thinking before doing the move
+ emergencyMoveHorizon: Be prepared to always play at least this many moves
+ emergencyBaseTime : Always attempt to keep at least this much time (in ms) at clock
+ emergencyMoveTime : Plus attempt to keep at least this much time for each remaining emergency move
+ minThinkingTime : No matter what, use at least this much thinking before doing the move
*/
- int hypMTG, hypMyTime, mTime, aTime;
+ int hypMTG, hypMyTime, t1, t2;
// Read uci parameters
- int emergencyMoveHorizon = get_option_value_int("Emergency Move Horizon");
- int emergencyBaseTime = get_option_value_int("Emergency Base Time");
- int emergencyMoveTime = get_option_value_int("Emergency Move Time");
- int minThinkingTime = get_option_value_int("Minimum Thinking Time");
+ int emergencyMoveHorizon = Options["Emergency Move Horizon"];
+ int emergencyBaseTime = Options["Emergency Base Time"];
+ int emergencyMoveTime = Options["Emergency Move Time"];
+ int minThinkingTime = Options["Minimum Thinking Time"];
+ int slowMover = Options["Slow Mover"];
- // Initialize variables to maximum values
- *optimumSearchTime = *maximumSearchTime = myTime;
+ // Initialize to maximum values but unstablePVExtraTime that is reset
+ unstablePVExtraTime = 0;
+ optimumSearchTime = maximumSearchTime = limits.time[us];
// We calculate optimum time usage for different hypothetic "moves to go"-values and choose the
// minimum of calculated search time values. Usually the greatest hypMTG gives the minimum values.
- for (hypMTG = 1; hypMTG <= (movesToGo ? Min(movesToGo, MoveHorizon) : MoveHorizon); hypMTG++)
+ for (hypMTG = 1; hypMTG <= (limits.movestogo ? std::min(limits.movestogo, MoveHorizon) : MoveHorizon); hypMTG++)
{
// Calculate thinking time for hypothetic "moves to go"-value
- hypMyTime = Max(myTime + (hypMTG - 1) * myInc - emergencyBaseTime - Min(hypMTG, emergencyMoveHorizon) * emergencyMoveTime, 0);
+ hypMyTime = limits.time[us]
+ + limits.inc[us] * (hypMTG - 1)
+ - emergencyBaseTime
+ - emergencyMoveTime * std::min(hypMTG, emergencyMoveHorizon);
- mTime = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, currentPly);
- aTime = minThinkingTime + remaining<MaxTime>(hypMyTime, hypMTG, currentPly);
+ hypMyTime = std::max(hypMyTime, 0);
- *optimumSearchTime = Min(*optimumSearchTime, mTime);
- *maximumSearchTime = Min(*maximumSearchTime, aTime);
+ t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, currentPly, slowMover);
+ t2 = minThinkingTime + remaining<MaxTime>(hypMyTime, hypMTG, currentPly, slowMover);
+
+ optimumSearchTime = std::min(optimumSearchTime, t1);
+ maximumSearchTime = std::min(maximumSearchTime, t2);
}
+ if (Options["Ponder"])
+ optimumSearchTime += optimumSearchTime / 4;
+
// Make sure that maxSearchTime is not over absoluteMaxSearchTime
- *optimumSearchTime = Min(*optimumSearchTime, *maximumSearchTime);
+ optimumSearchTime = std::min(optimumSearchTime, maximumSearchTime);
}
-////
-//// Local functions
-////
namespace {
template<TimeType T>
- int remaining(int myTime, int movesToGo, int currentPly)
+ int remaining(int myTime, int movesToGo, int currentPly, int slowMover)
{
const float TMaxRatio = (T == OptimumTime ? 1 : MaxRatio);
const float TStealRatio = (T == OptimumTime ? 0 : StealRatio);
- int thisMoveImportance = move_importance(currentPly);
+ int thisMoveImportance = move_importance(currentPly) * slowMover / 100;
int otherMovesImportance = 0;
for (int i = 1; i < movesToGo; i++)
float ratio1 = (TMaxRatio * thisMoveImportance) / float(TMaxRatio * thisMoveImportance + otherMovesImportance);
float ratio2 = (thisMoveImportance + TStealRatio * otherMovesImportance) / float(thisMoveImportance + otherMovesImportance);
- return int(floor(myTime * Min(ratio1, ratio2)));
+ return int(floor(myTime * std::min(ratio1, ratio2)));
}
}
projects / stockfish / blobdiff