engine.c

   1 /*
   2  *      This program is free software; you can redistribute it and/or modify
   3  *      it under the terms of the GNU General Public License as published by
   4  *      the Free Software Foundation; either version 2 of the License, or
   5  *      (at your option) any later version.
   6  *
   7  *      This program is distributed in the hope that it will be useful,
   8  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *      GNU General Public License for more details.
  11  *
  12  *      You should have received a copy of the GNU General Public License
  13  *      along with this program; if not, write to the Free Software
  14  *      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  15  */
  16 #include "common.h"
  17 #include "attacks.h"
  18 #include "board.h"
  19 #include "engine.h"
  20 #include "evaluate.h"
  21 #include "move.h"
  22 #include "search.h"
  23 #include "trans.h"
  24
  25 struct engine_t e;                                      /* engine parameters */
  26
  27 int history[2][7][4096];                        /* history for move ordering */
  28 int hash_moves[MAX_PLY];                                /* moves to try first */
  29 struct killers_t killers[MAX_PLY];      /* moves to try after hash moves */
  30
  31 int pv[MAX_PLY][MAX_PLY];                               /* triangular array for PV */
  32 int pv_length[MAX_PLY];
  33
  34 /* initial chess position */
  35 char start_position[] = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq -";
  36 char book_file_name[] = "book.bin";
  37
  38 /* statistic counters */
  39 struct counters_t counters;
  40
  41 /*
  42  * Return variable's value in thread-safe way
  43  */
  44 int
  45 get_engine_value(int *val)
  46 {
  47         int result;
  48
  49         pthread_mutex_lock(&e.mutex);
  50         result = *val;
  51         pthread_mutex_unlock(&e.mutex);
  52
  53         return result;
  54 }
  55
  56 /*
  57  * Set value in thread-safe way
  58  */
  59 void
  60 set_engine_value(int *src, int new_value)
  61 {
  62         pthread_mutex_lock(&e.mutex);
  63         *src = new_value;
  64         pthread_mutex_unlock(&e.mutex);
  65 }
  66
  67 /* time from Epoc in second/100 units - xboard time units */
  68 uint32_t
  69 get_time(void)
  70 {
  71         struct timeval t;
  72         gettimeofday(&t, 0);
  73
  74         return t.tv_sec * 100 + t.tv_usec / 10000;
  75 }
  76
  77 /* check if we should abort search */
  78 int
  79 check_time(int ply)
  80 {
  81         int i;
  82
  83         if (!(counters.searched_nodes & e.chk_time))
  84                 if (get_time() >= get_engine_value((int *)&e.stop_time)) {
  85                         /* takeback all moves in search tree */
  86                         for (i = 0; i < ply; i++)
  87                                 takeback();
  88                         abort_search = TRUE;
  89                         return TRUE;
  90                 }
  91
  92         return FALSE;
  93 }
  94
  95 /* start new game */
  96 void
  97 new_game()
  98 {
  99         srand(get_time());                              /* for opening book randomization */
 100         setup_board(start_position);
 101 }
 102
 103 /* print brief stats to console. used mostly for debugging */
 104 void
 105 print_stats(int timediff)
 106 {
 107         double search_time;
 108         double move_ordering;
 109         int nps;
 110
 111         search_time = timediff / 100.0;
 112         move_ordering = counters.failed_high_total ? \
 113                 (counters.failed_high_first / (double) counters.failed_high_total) * \
 114                 100.0 : -1.0;
 115         nps = counters.searched_nodes / search_time;
 116
 117         fprintf(stdout, "Time: %.2f, nodes: %llu, NPS: %d/sec, MO: %.2f%%\n" \
 118                 "NULL: %llu, delta: %llu, LMR: %llu, razor: %llu, futility: %llu\n" \
 119                 "pawn hash evaluations: %llu, transposition: %llu, evaluations: %llu, phase: %d\n",
 120                 search_time, counters.searched_nodes, nps, move_ordering,
 121                 counters.null_move_prunings, counters.delta_prunings,
 122                 counters.reductions, counters.razorings, counters.futility_prunings,
 123                 counters.pawn_hash_evaluations, counters.transposition,
 124                 counters.evaluations, GAME_PHASE);
 125 }
 126
 127 /* if it's engine's turn to move we should search */
 128 void *
 129 process_turn(void *args)
 130 {
 131         int move;
 132         int move_from_book;
 133         char buf[MAX_STRING];
 134
 135         move_from_book = TRUE;
 136         move = book_move();
 137
 138         if (!move) {
 139                 move_from_book = FALSE;
 140                 set_engine_value(&e.thinking, TRUE);
 141                 move = iterate();
 142                 set_engine_value(&e.thinking, FALSE);
 143         }
 144
 145         if (move == -1) {
 146                 fprintf(stdout, "resign\n");
 147                 if (get_engine_value(&e.side) == WHITE)
 148                         fprintf(stdout, "0-1 {WHITE resigns}\n");
 149                 else
 150                         fprintf(stdout, "1-0 {BLACK resigns}\n");
 151                 set_engine_value(&e.side, NOBODY);
 152
 153                 /* free resources after termination */
 154                 pthread_detach(pthread_self());
 155
 156                 return (void *)0;
 157         }
 158
 159         if (!move || evaluate_draw() || reps() >= 3) {
 160                 if (evaluate_draw()) {
 161                         if (brd.fifty_rule >= 100)
 162                                 fprintf(stdout, "1/2-1/2 {Fifty move rule}\n");
 163                         else
 164                                 fprintf(stdout, "1/2-1/2 {draw}\n");
 165                 } else if (reps() >= 3)
 166                         fprintf(stdout, "1/2-1/2 {draw by repetition}\n");
 167                 else if (IS_CHECKED(WHITE))
 168                         fprintf(stdout, "0-1 {BLACK mates}\n");
 169                 else if (IS_CHECKED(BLACK))
 170                         fprintf(stdout, "1-0 {WHITE mates}\n");
 171                 else
 172                         fprintf(stdout, "1/2-1/2 {Stalemate}\n");
 173                 set_engine_value(&e.side, NOBODY);
 174         } else {
 175                 if (get_engine_value(&e.san_notation) || \
 176                                 !get_engine_value(&e.xboard_mode)) {
 177                         san_move(move, buf);
 178                         make_move(move, FALSE);
 179                         fprintf(stdout, "move %s\n", buf);
 180                 } else {
 181                         make_move(move, FALSE);
 182                         fprintf(stdout, "move %s\n", coord_move(move, buf));
 183                 }
 184
 185                 if (!get_engine_value(&e.xboard_mode) && !move_from_book)
 186                         fprintf(stdout, "[%s]$ ", program_name);
 187         }
 188         /* free resources after termination */
 189         pthread_detach(pthread_self());
 190
 191         return (void *)0;
 192 }
 193
 194 void
 195 start_engine(void)
 196 {
 197         pthread_mutex_init(&e.mutex, 0);
 198
 199         set_engine_value(&e.side, NOBODY);
 200         set_engine_value(&e.force_mode, TRUE);
 201         set_engine_value(&e.post_mode, FALSE);
 202         set_engine_value(&e.xboard_mode, FALSE);
 203         set_engine_value(&e.san_notation, FALSE);
 204
 205         /* set small limits for quick testing */
 206         set_engine_value(&e.max_depth, 9);
 207         set_engine_value(&e.max_time, 10000);
 208
 209         /* check if we should abort search every 1024 nodes */
 210         set_engine_value(&e.chk_time, 1023);
 211
 212         /* use 1/30 of total time for thinking */
 213         set_engine_value(&e.time_div, 30);
 214
 215         set_engine_value(&e.fixed_time, FALSE);
 216         set_engine_value((int *)&e.stop_time, 0);
 217
 218         /* if FALSE we are playing to mate */
 219         set_engine_value(&e.resign, TRUE);
 220         set_engine_value(&e.resign_value, -600);
 221
 222         /* if EPD tests are currently running */
 223         set_engine_value(&e.thinking, FALSE);
 224
 225         /* search options */
 226         set_engine_value(&e.delta_pruning, TRUE);
 227         set_engine_value(&e.futility_pruning, TRUE);
 228         set_engine_value(&e.iid, TRUE);
 229         set_engine_value(&e.null_pruning, TRUE);
 230         set_engine_value(&e.lmr, TRUE);
 231         set_engine_value(&e.razoring, TRUE);
 232
 233         /* used to calculate 'game phase' */
 234         set_engine_value(&e.phase_factor, (piece_value[KNIGHT] * 2 + \
 235                         piece_value[BISHOP] * 2 + piece_value[ROOK] * 2 + \
 236                         piece_value[QUEEN]) / 128);
 237
 238         e.tid =  0;
 239
 240         /* initialize hashtable */
 241         e.pawn_hash_size = 2;
 242         e.main_hash_size = 16;
 243         e.pawn_hash_enabled = TRUE;
 244         e.main_hash_enabled = TRUE;
 245
 246         book_open(book_file_name);
 247         new_game();
 248 }
 249
 250 /* free resources */
 251 void perform_cleanup(void)
 252 {
 253         /* free memory */
 254         if (get_engine_value(&e.pawn_hash_enabled))
 255                 free_pawn_hashtable();
 256
 257         /* destroy engine mutex */
 258         pthread_mutex_destroy(&e.mutex);
 259
 260         /* close book file descriptor */
 261         book_close();
 262 }