Subversion Repositories Games.Chess Giants

Rev

Rev 169 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 169 Rev 185
Line 4... Line 4...
4 
  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
 4 
  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
5 
  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 5 
  Copyright (C) 2015-2019 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
6 
 
 6 
 
7 
  Stockfish is free software: you can redistribute it and/or modify
 7 
  Stockfish is free software: you can redistribute it and/or modify
8 
  it under the terms of the GNU General Public License as published by
 8 
  it under the terms of the GNU General Public License as published by
9 
  the Free Software Foundation, either version 3 of the License, or
 9 
  the Free Software Foundation, either version 3 of the License, or
10 
  (at your option) any later version.
 10 
  (at your option) any later version.
Line 30... Line 30...
30 
 
 30 
 
31 
namespace {
 31 
namespace {
32 
 
 32 
 
33 
  enum TimeType { OptimumTime, MaxTime };
 33 
  enum TimeType { OptimumTime, MaxTime };
34 
 
 34 
 
35 
  const int MoveHorizon   = 50;   // Plan time management at most this many moves ahead
 35 
  constexpr int MoveHorizon   = 50;   // Plan time management at most this many moves ahead
36 
  const double MaxRatio   = 7.09; // When in trouble, we can step over reserved time with this ratio
 36 
  constexpr double MaxRatio   = 7.3;  // When in trouble, we can step over reserved time with this ratio
37 
  const double StealRatio = 0.35; // However we must not steal time from remaining moves over this ratio
 37 
  constexpr double StealRatio = 0.34; // However we must not steal time from remaining moves over this ratio
38 
 
 38 
 
39 
 
 39 
 
40 
  // move_importance() is a skew-logistic function based on naive statistical
 40 
  // move_importance() is a skew-logistic function based on naive statistical
41 
  // analysis of "how many games are still undecided after n half-moves". Game
 41 
  // analysis of "how many games are still undecided after n half-moves". Game
42 
  // is considered "undecided" as long as neither side has >275cp advantage.
 42 
  // is considered "undecided" as long as neither side has >275cp advantage.
43 
  // Data was extracted from the CCRL game database with some simple filtering criteria.
 43 
  // Data was extracted from the CCRL game database with some simple filtering criteria.
44 
 
 44 
 
45 
  double move_importance(int ply) {
 45 
  double move_importance(int ply) {
46 
 
 46 
 
47 
    const double XScale = 7.64;
 47 
    constexpr double XScale = 6.85;
48 
    const double XShift = 58.4;
 48 
    constexpr double XShift = 64.5;
49 
    const double Skew   = 0.183;
 49 
    constexpr double Skew   = 0.171;
50 
 
 50 
 
51 
    return pow((1 + exp((ply - XShift) / XScale)), -Skew) + DBL_MIN; // Ensure non-zero
 51 
    return pow((1 + exp((ply - XShift) / XScale)), -Skew) + DBL_MIN; // Ensure non-zero
52 
  }
 52 
  }
53 
 
 53 
 
54 
  template<TimeType T>
 54 
  template<TimeType T>
55 
  int remaining(int myTime, int movesToGo, int ply, int slowMover) {
 55 
  TimePoint remaining(TimePoint myTime, int movesToGo, int ply, TimePoint slowMover) {
56 
 
 56 
 
57 
    const double TMaxRatio   = (T == OptimumTime ? 1 : MaxRatio);
 57 
    constexpr double TMaxRatio   = (T == OptimumTime ? 1.0 : MaxRatio);
58 
    const double TStealRatio = (T == OptimumTime ? 0 : StealRatio);
 58 
    constexpr double TStealRatio = (T == OptimumTime ? 0.0 : StealRatio);
59 
 
 59 
 
60 
    double moveImportance = (move_importance(ply) * slowMover) / 100;
 60 
    double moveImportance = (move_importance(ply) * slowMover) / 100.0;
61 
    double otherMovesImportance = 0;
 61 
    double otherMovesImportance = 0.0;
62 
 
 62 
 
63 
    for (int i = 1; i < movesToGo; ++i)
 63 
    for (int i = 1; i < movesToGo; ++i)
64 
        otherMovesImportance += move_importance(ply + 2 * i);
 64 
        otherMovesImportance += move_importance(ply + 2 * i);
65 
 
 65 
 
66 
    double ratio1 = (TMaxRatio * moveImportance) / (TMaxRatio * moveImportance + otherMovesImportance);
 66 
    double ratio1 = (TMaxRatio * moveImportance) / (TMaxRatio * moveImportance + otherMovesImportance);
67 
    double ratio2 = (moveImportance + TStealRatio * otherMovesImportance) / (moveImportance + otherMovesImportance);
 67 
    double ratio2 = (moveImportance + TStealRatio * otherMovesImportance) / (moveImportance + otherMovesImportance);
68 
 
 68 
 
69 
    return int(myTime * std::min(ratio1, ratio2)); // Intel C++ asks for an explicit cast
 69 
    return TimePoint(myTime * std::min(ratio1, ratio2)); // Intel C++ asks for an explicit cast
70 
  }
 70 
  }
71 
 
 71 
 
72 
} // namespace
 72 
} // namespace
73 
 
 73 
 
74 
 
 74 
 
Line 81... Line 81...
81 
///  inc >  0 && movestogo == 0 means: x basetime + z increment
 81 
///  inc >  0 && movestogo == 0 means: x basetime + z increment
82 
///  inc >  0 && movestogo != 0 means: x moves in y minutes + z increment
 82 
///  inc >  0 && movestogo != 0 means: x moves in y minutes + z increment
83 
 
 83 
 
84 
void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) {
 84 
void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) {
85 
 
 85 
 
86 
  int minThinkingTime = Options["Minimum Thinking Time"];
 86 
  TimePoint minThinkingTime = Options["Minimum Thinking Time"];
87 
  int moveOverhead    = Options["Move Overhead"];
 87 
  TimePoint moveOverhead    = Options["Move Overhead"];
88 
  int slowMover       = Options["Slow Mover"];
 88 
  TimePoint slowMover       = Options["Slow Mover"];
89 
  int npmsec          = Options["nodestime"];
 89 
  TimePoint npmsec          = Options["nodestime"];
- 
 
 90 
  TimePoint hypMyTime;
90 
 
 91 
 
91 
  // If we have to play in 'nodes as time' mode, then convert from time
 92 
  // If we have to play in 'nodes as time' mode, then convert from time
92 
  // to nodes, and use resulting values in time management formulas.
 93 
  // to nodes, and use resulting values in time management formulas.
93 
  // WARNING: Given npms (nodes per millisecond) must be much lower then
 94 
  // WARNING: to avoid time losses, the given npmsec (nodes per millisecond)
94 
  // the real engine speed to avoid time losses.
 95 
  // must be much lower than the real engine speed.
95 
  if (npmsec)
 96 
  if (npmsec)
96 
  {
 97 
  {
97 
      if (!availableNodes) // Only once at game start
 98 
      if (!availableNodes) // Only once at game start
98 
          availableNodes = npmsec * limits.time[us]; // Time is in msec
 99 
          availableNodes = npmsec * limits.time[us]; // Time is in msec
99 
 
 100 
 
100 
      // Convert from millisecs to nodes
 101 
      // Convert from milliseconds to nodes
101 
      limits.time[us] = (int)availableNodes;
 102 
      limits.time[us] = TimePoint(availableNodes);
102 
      limits.inc[us] *= npmsec;
 103 
      limits.inc[us] *= npmsec;
103 
      limits.npmsec = npmsec;
 104 
      limits.npmsec = npmsec;
104 
  }
 105 
  }
105 
 
 106 
 
106 
  startTime = limits.startTime;
 107 
  startTime = limits.startTime;
107 
  optimumTime = maximumTime = std::max(limits.time[us], minThinkingTime);
 108 
  optimumTime = maximumTime = std::max(limits.time[us], minThinkingTime);
108 
 
 109 
 
109 
  const int MaxMTG = limits.movestogo ? std::min(limits.movestogo, MoveHorizon) : MoveHorizon;
 110 
  const int maxMTG = limits.movestogo ? std::min(limits.movestogo, MoveHorizon) : MoveHorizon;
110 
 
 111 
 
111 
  // We calculate optimum time usage for different hypothetical "moves to go"-values
 112 
  // We calculate optimum time usage for different hypothetical "moves to go" values
112 
  // and choose the minimum of calculated search time values. Usually the greatest
 113 
  // and choose the minimum of calculated search time values. Usually the greatest
113 
  // hypMTG gives the minimum values.
 114 
  // hypMTG gives the minimum values.
114 
  for (int hypMTG = 1; hypMTG <= MaxMTG; ++hypMTG)
 115 
  for (int hypMTG = 1; hypMTG <= maxMTG; ++hypMTG)
115 
  {
 116 
  {
116 
      // Calculate thinking time for hypothetical "moves to go"-value
 117 
      // Calculate thinking time for hypothetical "moves to go"-value
117 
      int hypMyTime =  limits.time[us]
 118 
      hypMyTime =  limits.time[us]
118 
                     + limits.inc[us] * (hypMTG - 1)
 119 
                 + limits.inc[us] * (hypMTG - 1)
119 
                     - moveOverhead * (2 + std::min(hypMTG, 40));
 120 
                 - moveOverhead * (2 + std::min(hypMTG, 40));
120 
 
 121 
 
121 
      hypMyTime = std::max(hypMyTime, 0);
 122 
      hypMyTime = std::max(hypMyTime, TimePoint(0));
122 
 
 123 
 
123 
      int t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, ply, slowMover);
 124 
      TimePoint t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, ply, slowMover);
124 
      int t2 = minThinkingTime + remaining<MaxTime    >(hypMyTime, hypMTG, ply, slowMover);
 125 
      TimePoint t2 = minThinkingTime + remaining<MaxTime    >(hypMyTime, hypMTG, ply, slowMover);
125 
 
 126 
 
126 
      optimumTime = std::min(t1, optimumTime);
 127 
      optimumTime = std::min(t1, optimumTime);
127 
      maximumTime = std::min(t2, maximumTime);
 128 
      maximumTime = std::min(t2, maximumTime);
128 
  }
 129 
  }
129 
 
 130