gnushogi/tcontrl.c

   1 /*
   2  * FILE: tcontrl.c
   3  *
   4  * ----------------------------------------------------------------------
   5  * Copyright (c) 1993, 1994, 1995 Matthias Mutz
   6  * Copyright (c) 1999 Michael Vanier and the Free Software Foundation
   7  * Copyright (c) 2008, 2013, 2014 Yann Dirson and the Free Software Foundation
   8  *
   9  * GNU SHOGI is based on GNU CHESS
  10  *
  11  * Copyright (c) 1988, 1989, 1990 John Stanback
  12  * Copyright (c) 1992 Free Software Foundation
  13  *
  14  * This file is part of GNU SHOGI.
  15  *
  16  * GNU Shogi is free software; you can redistribute it and/or modify it
  17  * under the terms of the GNU General Public License as published by the
  18  * Free Software Foundation; either version 3 of the License,
  19  * or (at your option) any later version.
  20  *
  21  * GNU Shogi is distributed in the hope that it will be useful, but WITHOUT
  22  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  23  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  24  * for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License along
  27  * with GNU Shogi; see the file COPYING. If not, see
  28  * <http://www.gnu.org/licenses/>.
  29  * ----------------------------------------------------------------------
  30  *
  31  */
  32
  33
  34 #include "gnushogi.h"
  35 #include <math.h>
  36
  37
  38 /*
  39  * In a networked enviroment gnushogi might be compiled on different hosts
  40  * with different random number generators; that is not acceptable if they
  41  * are going to share the same transposition table.
  42  */
  43
  44 static unsigned long next = 1;
  45
  46 unsigned int
  47 urand(void)
  48 {
  49     next *= 1103515245;
  50     next += 12345;
  51     return ((unsigned int) (next >> 16) & 0xFFFF);
  52 }
  53
  54
  55
  56 void
  57 gsrand(unsigned int seed)
  58 {
  59     next = seed;
  60 }
  61
  62
  63
  64 void
  65 TimeCalc()
  66 {
  67     /* adjust number of moves remaining in gamein games */
  68     int increment = 0;
  69     int topsum = 0;
  70     int tcompsum = 0;
  71     int me, him;
  72     int i;
  73
  74     /* Don't do anything until you have enough numbers. */
  75     if (GameCnt < (MINGAMEIN * 2))
  76         return;
  77
  78     /* Calculate average time in sec for last MINGAMEIN moves. */
  79     for (i = 0; i < MINGAMEIN; i++)
  80     {
  81         tcompsum += timecomp[i];
  82         topsum += timeopp[i];
  83     }
  84
  85     topsum   /= (100 * MINGAMEIN);
  86     tcompsum /= (100 * MINGAMEIN);
  87
  88     /* If I have less time than opponent add another move. */
  89     me  = TimeControl.clock[computer] / 100;
  90     him = TimeControl.clock[opponent] / 100;
  91
  92     if (me < him)
  93         increment += 2;
  94
  95     if (((him - me) > 60) || ((me < him) && (me < 120)))
  96         increment++;
  97
  98     /* If I am losing more time with each move add another. */
  99     /* If (!((me - him) > 60) && tcompsum > topsum) increment++; */
 100
 101     if (tcompsum > topsum)
 102     {
 103         increment += 2;
 104     }
 105     else if ((TimeControl.moves[computer] < MINMOVES) && !increment)
 106     {
 107         /* ... but don't let moves go below MINMOVES. */
 108         increment++;
 109     }
 110     else if ((me > him) && (tcompsum < topsum))
 111     {
 112         /* If I am doing really well use more time per move. */
 113         increment = -1;
 114     }
 115
 116     /* If not fischer clock be careful about time. */
 117     /* CHECKME: what's a fischer clock? */
 118
 119     if ((TCadd == 0) && (increment > 0))
 120         increment += 2;
 121
 122     if ((me == 0) && (increment > 0))
 123         increment += 2;
 124
 125     TimeControl.moves[computer] += increment;
 126 }
 127
 128
 129
 130 /*
 131  * Set ResponseTime, TCcount, and TCleft.
 132  */
 133
 134 void SetResponseTime(short side)
 135 {
 136     bool DetermineTCcount = true;
 137
 138     if (TCflag)
 139     {
 140         TCcount = 0;
 141
 142         if (TimeControl.moves[side] < 1)
 143             TimeControl.moves[side] = 1;
 144
 145         /* special case time per move specified */
 146         if (flag.onemove)
 147         {
 148             ResponseTime = TimeControl.clock[side] - 100;
 149             TCleft = 0;
 150         }
 151         else
 152         {
 153             /* calculate avg time per move remaining */
 154             if (TimeControl.clock[side] <= 0)
 155             {
 156                 ResponseTime = 0;
 157                 TCleft = (long)MINRESPONSETIME / MAXTCCOUNTX;
 158             }
 159             else
 160             {
 161                 short rtf = in_opening_stage ? 8 : 2;
 162                 short tcq = in_opening_stage ? 2 : 4;
 163
 164                 TimeControl.clock[side] += TCadd;
 165                 ResponseTime = (TimeControl.clock[side])
 166                     / (((TimeControl.moves[side]) * rtf) + 1);
 167                 TCleft = (long)ResponseTime / tcq;
 168                 ResponseTime += TCadd / 2;
 169             }
 170
 171             if (TimeControl.moves[side] < 5)
 172             {
 173                 TCcount = MAXTCCOUNTX - 6 - TimeControl.moves[side];
 174
 175                 if (TCcount < 0)
 176                     TCcount = 0;
 177
 178                 DetermineTCcount = false;
 179             }
 180         }
 181
 182         if (ResponseTime < MINRESPONSETIME)
 183         {
 184             ResponseTime = MINRESPONSETIME;
 185             TCcount = MAXTCCOUNTX - 10;
 186
 187             if (TCcount < 0)
 188                 TCcount = 0;
 189
 190             DetermineTCcount = false;
 191         }
 192
 193         if (!hard_time_limit && (ResponseTime < 2 * MINRESPONSETIME))
 194         {
 195             TCcount = MAXTCCOUNTX - 10;
 196
 197             if (TCcount < 0)
 198                 TCcount = 0;
 199
 200             DetermineTCcount = false;
 201         }
 202     }
 203     else
 204     {
 205         TCleft = 0;
 206         ResponseTime = MaxResponseTime;
 207         ElapsedTime(COMPUTE_AND_INIT_MODE);
 208     }
 209
 210     if (DetermineTCcount)
 211     {
 212         if (TCleft )
 213         {
 214             int AllowedCounts
 215                 = ((int)((TimeControl.clock[side] - ResponseTime)) / 2)
 216                 / TCleft;
 217
 218             if (AllowedCounts <= 0)
 219                 TCcount = MAXTCCOUNTX;
 220             else if (AllowedCounts > MAXTCCOUNTX)
 221                 TCcount = 0;
 222             else
 223                 TCcount = MAXTCCOUNTX - AllowedCounts;
 224         }
 225         else
 226         {
 227             TCcount = MAXTCCOUNTX;
 228         }
 229     }
 230
 231     if (ResponseTime < MINRESPONSETIME)
 232         ResponseTime = MINRESPONSETIME;
 233
 234     assert(TCcount <= MAXTCCOUNTX);
 235 }
 236
 237
 238
 239 void
 240 CheckForTimeout(int score, int globalscore, int Jscore, int zwndw)
 241 {
 242     if (flag.musttimeout || (Sdepth >= MaxSearchDepth))
 243         flag.timeout = true;
 244
 245     else if (TCflag && (Sdepth > (MINDEPTH - 1)) && (TCcount < MAXTCCOUNTR))
 246     {
 247         if (killr0[1] != PrVar[1] /* || Killr0[2] != PrVar[2] */)
 248         {
 249             TCcount++;
 250             ExtraTime += TCleft;
 251         }
 252
 253         if ((TCcount < MAXTCCOUNTR)
 254             && (abs(score - globalscore) / Sdepth) > ZDELTA)
 255         {
 256             TCcount++;
 257             ExtraTime += TCleft;
 258         }
 259     }
 260
 261     if ((score > (Jscore - zwndw)) && (score > (Tree[1].score + 250)))
 262         ExtraTime = 0;
 263
 264     ElapsedTime(COMPUTE_MODE);
 265
 266     if (root->flags & exact)
 267         flag.timeout = true;
 268     /*else if (Tree[1].score < -SCORE_LIMIT) flag.timeout = true;
 269      */
 270 #if defined OLDTIME || !defined HAVE_GETTIMEOFDAY
 271     else if (!(Sdepth < MINDEPTH)
 272              && TCflag
 273              && ((4 * et) > (2*ResponseTime + ExtraTime)))
 274         flag.timeout = true;
 275 #else
 276     else if (!(Sdepth < MINDEPTH)
 277              && TCflag
 278              && ((int)(1.93913099l * (pow((double)et, 1.12446928l)))
 279                  > (ResponseTime + ExtraTime)))
 280         flag.timeout = true;
 281 #endif
 282
 283     if (flag.timeout)
 284         dsp->ShowMessage("timeout");
 285 }
 286
 287
 288 /*
 289  * Determine the time that has passed since the search was started. If the
 290  * elapsed time exceeds the target(ResponseTime + ExtraTime) then set timeout
 291  * to true which will terminate the search.
 292  * iop = COMPUTE_MODE calculate et, bump ETnodes
 293  * iop = COMPUTE_AND_INIT_MODE calculate et, set timeout if time exceeded,
 294  *     set reference time
 295  */
 296 void
 297 ElapsedTime(ElapsedTime_mode iop)
 298 {
 299     long current_time;
 300 #ifdef HAVE_GETTIMEOFDAY
 301     struct timeval tv;
 302 #endif
 303
 304     dsp->PollForInput();
 305
 306 #ifdef HAVE_GETTIMEOFDAY
 307     gettimeofday(&tv, NULL);
 308     current_time = tv.tv_sec*100 + (tv.tv_usec/10000);
 309 #else
 310     et = ((current_time = time((long *) 0)) - time0) * 100;
 311 #endif
 312
 313 #ifdef INTERRUPT_TEST
 314     if (iop == INIT_INTERRUPT_MODE)
 315     {
 316         itime0 = current_time;
 317     }
 318     else if (iop == COMPUTE_INTERRUPT_MODE)
 319     {
 320         it = current_time - itime0;
 321     }
 322     else
 323 #endif
 324     {
 325 #ifdef HAVE_GETTIMEOFDAY
 326         et = current_time - time0;
 327 #endif
 328         ETnodes = NodeCnt + znodes;
 329
 330         if (et < 0)
 331         {
 332 #ifdef INTERRUPT_TEST
 333             printf("elapsed time %ld not positive\n", et);
 334 #endif
 335             et = 0;
 336         }
 337
 338         if (iop == COMPUTE_AND_INIT_MODE)
 339         {
 340             if ((et > (ResponseTime + ExtraTime)) && (Sdepth > MINDEPTH))
 341                 flag.timeout = true;
 342
 343             time0 = current_time;
 344         }
 345
 346 #ifdef QUIETBACKGROUND
 347         if (!background)
 348 #endif
 349             dsp->UpdateClocks();
 350     }
 351 }
 352
 353
 354 void
 355 SetTimeControl(void)
 356 {
 357     if (TCflag)
 358     {
 359         TimeControl.moves[black] = TimeControl.moves[white] = TCmoves;
 360         TimeControl.clock[black] += 6000L * TCminutes + TCseconds * 100;
 361         TimeControl.clock[white] += 6000L * TCminutes + TCseconds * 100;
 362     }
 363     else
 364     {
 365         TimeControl.moves[black] = TimeControl.moves[white] = 0;
 366         TimeControl.clock[black] = TimeControl.clock[white] = 0;
 367     }
 368
 369     flag.onemove = (TCmoves == 1);
 370     et = 0;
 371     ElapsedTime(COMPUTE_AND_INIT_MODE);
 372 }