X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Ftimeman.cpp;h=88a52bbde894d76e754dfd7e6a64081d0e49b773;hp=fc2a327df253528a77ce9f80f1b286728124f93d;hb=15e21911110f9d459c4fef2bb17903d97345d0b9;hpb=92faa74dfa862fbdef409017a4ccd993c549f723 diff --git a/src/timeman.cpp b/src/timeman.cpp index fc2a327d..88a52bbd 100644 --- a/src/timeman.cpp +++ b/src/timeman.cpp @@ -1,7 +1,7 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2008-2014 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 @@ -18,6 +18,7 @@ */ #include +#include #include #include "search.h" @@ -26,7 +27,7 @@ namespace { - /// Constants + enum TimeType { OptimumTime, MaxTime }; const int MoveHorizon = 50; // Plan time management at most this many moves ahead const double MaxRatio = 7.0; // When in trouble, we can step over reserved time with this ratio @@ -37,42 +38,47 @@ namespace { const double skewfactor = 0.172; - /// move_importance() is a skew-logistic function based on naive statistical - /// analysis of "how many games are still undecided after n half-moves". Game - /// is considered "undecided" as long as neither side has >275cp advantage. - /// Data was extracted from CCRL game database with some simple filtering criteria. + // move_importance() is a skew-logistic function based on naive statistical + // analysis of "how many games are still undecided after n half-moves". Game + // is considered "undecided" as long as neither side has >275cp advantage. + // Data was extracted from CCRL game database with some simple filtering criteria. double move_importance(int ply) { - return 1 / pow((1 + exp((ply - xshift) / xscale)), skewfactor) + 1e-3; // Ensure non-zero + return pow((1 + exp((ply - xshift) / xscale)), -skewfactor) + DBL_MIN; // Ensure non-zero } + template + int remaining(int myTime, int movesToGo, int currentPly, int slowMover) + { + const double TMaxRatio = (T == OptimumTime ? 1 : MaxRatio); + const double TStealRatio = (T == OptimumTime ? 0 : StealRatio); - /// Function Prototypes - - enum TimeType { OptimumTime, MaxTime }; + double thisMoveImportance = (move_importance(currentPly) * slowMover) / 100; + double otherMovesImportance = 0; - template - int remaining(int myTime, int movesToGo, int fullMoveNumber, int slowMover); -} + for (int i = 1; i < movesToGo; ++i) + otherMovesImportance += move_importance(currentPly + 2 * i); + double ratio1 = (TMaxRatio * thisMoveImportance) / (TMaxRatio * thisMoveImportance + otherMovesImportance); + double ratio2 = (thisMoveImportance + TStealRatio * otherMovesImportance) / (thisMoveImportance + otherMovesImportance); -void TimeManager::pv_instability(double bestMoveChanges) { + return int(myTime * std::min(ratio1, ratio2)); + } - unstablePVExtraTime = int(bestMoveChanges * optimumSearchTime / 1.4); -} +} // namespace void TimeManager::init(const Search::LimitsType& limits, int currentPly, Color us) { - /* We support four different kind of time controls: + /* We support four different kinds of time controls: 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: + Time management is adjusted by following 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 @@ -83,15 +89,13 @@ void TimeManager::init(const Search::LimitsType& limits, int currentPly, Color u int hypMTG, hypMyTime, t1, t2; // Read uci parameters - 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"]; + int moveOverhead = Options["Move Overhead"]; + int minThinkingTime = Options["Minimum Thinking Time"]; + int slowMover = Options["Slow Mover"]; - // Initialize all to maximum values but unstablePVExtraTime that is reset - unstablePVExtraTime = 0; - optimumSearchTime = maximumSearchTime = limits.time[us]; + // Initialize unstablePvFactor to 1 and search times to maximum values + unstablePvFactor = 1; + optimumSearchTime = maximumSearchTime = std::max(limits.time[us], minThinkingTime); // We calculate optimum time usage for different hypothetical "moves to go"-values and choose the // minimum of calculated search time values. Usually the greatest hypMTG gives the minimum values. @@ -100,8 +104,7 @@ void TimeManager::init(const Search::LimitsType& limits, int currentPly, Color u // Calculate thinking time for hypothetical "moves to go"-value hypMyTime = limits.time[us] + limits.inc[us] * (hypMTG - 1) - - emergencyBaseTime - - emergencyMoveTime * std::min(hypMTG, emergencyMoveHorizon); + - moveOverhead * (2 + std::min(hypMTG, 40)); hypMyTime = std::max(hypMyTime, 0); @@ -118,25 +121,3 @@ void TimeManager::init(const Search::LimitsType& limits, int currentPly, Color u // Make sure that maxSearchTime is not over absoluteMaxSearchTime optimumSearchTime = std::min(optimumSearchTime, maximumSearchTime); } - - -namespace { - - template - int remaining(int myTime, int movesToGo, int currentPly, int slowMover) - { - const double TMaxRatio = (T == OptimumTime ? 1 : MaxRatio); - const double TStealRatio = (T == OptimumTime ? 0 : StealRatio); - - double thisMoveImportance = (move_importance(currentPly) * slowMover) / 100; - double otherMovesImportance = 0; - - for (int i = 1; i < movesToGo; ++i) - otherMovesImportance += move_importance(currentPly + 2 * i); - - double ratio1 = (TMaxRatio * thisMoveImportance) / (TMaxRatio * thisMoveImportance + otherMovesImportance); - double ratio2 = (thisMoveImportance + TStealRatio * otherMovesImportance) / (thisMoveImportance + otherMovesImportance); - - return int(floor(myTime * std::min(ratio1, ratio2))); - } -}