WebSVN – Games.Chess Giants – Diff – /engine-crafty/init.c

 #include <stddef.h>
+#include <math.h>
 #include "chess.h"
 #include "data.h"
 #if defined(UNIX)
 #  include <unistd.h>
 #  include <sys/types.h>
-#  include <sys/stat.h>
 #else
-#  include <fcntl.h>    /* needed for definition of "_O_BINARY" */
+#  include <fcntl.h> /* needed for definition of "_O_BINARY" */
 #endif
 /*
  *******************************************************************************
  *                                                                             *
  *   Initialize() performs routine initialization before anything else is      *
  *   data structures that are needed before the engine can do anything at all. *
  *                                                                             *
  *******************************************************************************
  */
 void Initialize() {
-  int /*i, */major, id; // Pierre-Marie Baty -- unused variable
   TREE *tree;
-  int j;
+  int /*i, */j, v, major, id/*, node*/; // Pierre-Marie Baty -- unreferenced variables
   tree = block[0];
-  for (j = 1; j < MAX_BLOCKS + 1; j++)
+  for (j = 1; j <= MAX_BLOCKS; j++)
     block[j] = NULL;
   InitializeMasks();
   InitializeMagic();
   InitializeSMP();
   InitializeAttackBoards();
   InitializePawnMasks();
   InitializeChessBoard(tree);
   InitializeKillers();
 #if !defined(UNIX)
-  _fmode = _O_BINARY;   /* set file mode binary to avoid text translation */
+  _fmode = _O_BINARY; /* set file mode binary to avoid text translation */
 #endif
 #if defined(EPD)
   EGInit();
 #endif
   tree->last[0] = tree->move_list;
   sprintf(log_filename, "%s/book.bin", book_path);
   book_file = fopen(log_filename, "rb+");
   if (!book_file) {
     book_file = fopen(log_filename, "rb");
     if (!book_file) {
-      Print(128, "unable to open book file [%s/book.bin].\n", book_path);
+      Print(2048, "unable to open book file [%s/book.bin].\n", book_path);
-      Print(128, "book is disabled\n");
+      Print(32, "book is disabled\n");
     } else {
-      Print(128, "unable to open book file [%s/book.bin] for \"write\".\n",
+      Print(2048, "unable to open book file [%s/book.bin] for \"write\".\n",
           book_path);
-      Print(128, "learning is disabled\n");
+      Print(32, "learning is disabled\n");
+    }
+  }
   sprintf(log_filename, "%s/books.bin", book_path);
   normal_bs_file = fopen(log_filename, "rb");
   books_file = normal_bs_file;
   if (!normal_bs_file)
-    Print(128, "unable to open book file [%s/books.bin].\n", book_path);
+    Print(32, "unable to open book file [%s/books.bin].\n", book_path);
   sprintf(log_filename, "%s/bookc.bin", book_path);
   computer_bs_file = fopen(log_filename, "rb");
   if (computer_bs_file)
-    Print(128, "found computer opening book file [%s/bookc.bin].\n",
+    Print(32, "found computer opening book file [%s/bookc.bin].\n",
         book_path);
   if (book_file) {
     int maj_min;
-    fseek(book_file, 0-sizeof(int), SEEK_END); // Pierre-Marie Baty -- fixed signedness warning
+    fseek(book_file, 0-sizeof(int), SEEK_END); // Pierre-Marie Baty -- signedness warning fix
-    fread(&maj_min, 4, 1, book_file);
+    v = fread(&maj_min, 4, 1, book_file);
+    if (v <= 0)
+      perror("Initialize() fread error: ");
     major = BookIn32((unsigned char *) &maj_min);
     major = major >> 16;
     if (major < 23) {
       Print(4095, "\nERROR!  book.bin not made by version 23.0 or later\n");
       fclose(book_file);
   history_file = fopen(history_filename, "w+");
   if (!history_file) {
     printf("ERROR, unable to open game history file, exiting\n");
     CraftyExit(1);
+  }
-  AlignedMalloc((void **) &trans_ref, 64,
+  AlignedMalloc((void *) ((void *) &hash_table), 64,
       sizeof(HASH_ENTRY) * hash_table_size);
-  AlignedMalloc((void **) &hash_path, 64,
+  AlignedMalloc((void *) ((void *) &hash_path), 64,
       sizeof(HPATH_ENTRY) * hash_path_size);
-  AlignedMalloc((void **) &pawn_hash_table, 32,
+  AlignedMalloc((void *) ((void *) &pawn_hash_table), 64,
       sizeof(PAWN_HASH_ENTRY) * pawn_hash_table_size);
+  AlignedMalloc((void *) ((void *) &eval_hash_table), 64,
+      sizeof(uint64_t) * eval_hash_table_size);
-  if (!trans_ref) {
+  if (!hash_table) {
-    Print(128,
+    Print(2048,
         "AlignedMalloc() failed, not enough memory (primary trans/ref table).\n");
     hash_table_size = 0;
-    trans_ref = 0;
+    hash_table = 0;
+  }
   if (!pawn_hash_table) {
-    Print(128,
+    Print(2048,
         "AlignedMalloc() failed, not enough memory (pawn hash table).\n");
     pawn_hash_table_size = 0;
     pawn_hash_table = 0;
+  }
 /*
  *  the correct processor and use local node memory for     *
  *  optimal performance.                                    *
  *                                                          *
  *  If we are using CPU affinity, we need to set this up    *
  *  for thread 0 BEFORE we initialize the split blocks so   *
- *  that they will fault in on the correct node.            *
+ *  that they will page fault in on the correct NUMA node.  *
  *                                                          *
  ************************************************************
  */
-#if defined(AFFINITY)
+#if (CPUS > 1)
-  cpu_set_t cpuset;
-  pthread_t current_thread = pthread_self();
+  ThreadAffinity(smp_affinity);
-  CPU_ZERO(&cpuset);
-  CPU_SET(0, &cpuset);
-  pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset);
-#endif
-#if !defined(UNIX)
+#  if !defined(UNIX)
   ThreadMalloc((int) 0);
-#else
+#  else
   for (i = 0; i < CPUS; i++) {
-    for (j = 0; j < MAX_BLOCKS_PER_CPU; j++) {
+    for (j = 0; j < 64; j++) {
-      AlignedMalloc((void **) &block[i * MAX_BLOCKS_PER_CPU + j + 1], 2048,
+      AlignedMalloc((void **) &block[i * 64 + j + 1], 2048,
           (size_t) sizeof(TREE));
+    }
+  }
-  for (i = 1; i < MAX_BLOCKS_PER_CPU; i++) {
+  for (i = 1; i < 64; i++) {
     memset((void *) block[i], 0, sizeof(TREE));
     LockInit(block[i]->lock);
+  }
+  for (node = 1; node < CPUS; node++) {
+    ThreadAffinity(node);
+    for (i = 0; i < 64; i++) {
+      memset((void *) block[node * 64 + i], 0, sizeof(TREE));
+      LockInit(block[node * 64 + i]->lock);
+    }
+  }
+  ThreadAffinity(smp_affinity);
+#  endif
 #endif
+  thread[0].blocks = 0xffffffffffffffffull;
   initialized_threads++;
-  InitializeHashTables();
+  InitializeHashTables(1);
   InitializeKingSafety();
+  InitializeReductions();
+}
 /*
  *******************************************************************************
  *                                                                             *
  *   deal with what squares a piece attacks.                                   *
  *                                                                             *
  *******************************************************************************
  */
 void InitializeAttackBoards(void) {
-  int i, j, frank, ffile, trank, tfile, nmobility;
+  int i, j, d, s, t, frank, ffile, trank, tfile;
   int sq, lastsq;
   static const int knightsq[8] = { -17, -15, -10, -6, 6, 10, 15, 17 };
   static const int bishopsq[4] = { -9, -7, 7, 9 };
   static const int rooksq[4] = { -8, -1, 1, 8 };
   uint64_t sqs;
       tfile = File(sq);
       if (Abs(frank - trank) > 2 || Abs(ffile - tfile) > 2)
         continue;
       knight_attacks[i] = knight_attacks[i] | (uint64_t) 1 << sq;
+    }
-    nmobility = -lower_n;
-    for (j = 0; j < 4; j++)
-      nmobility +=
-          PopCnt(knight_attacks[i] & mobility_mask_n[j]) *
-          mobility_score_n[j];
-    knight_mobility_table[i] = nmobility;
+  }
 /*
  initialize bishop/queen attack boards and masks
  */
   for (i = 0; i < 64; i++) {
       if (Distance(i, j) == 1)
         king_attacks[i] = king_attacks[i] | SetMask(j);
+    }
+  }
 /*
- direction[sq1][sq2] gives the "move direction" to move from
+ directions[sq1][sq2] gives the "move direction" to move from
  sq1 to sq2.  intervening[sq1][sq2] gives a bit vector that indicates
  which squares must be unoccupied in order for <sq1> to attack <sq2>,
- assuming a sliding piece is involved.  to use this, you simply have
+ assuming a sliding piece is involved.  To use this, you simply have
  to Or(intervening[sq1][sq2],occupied_squares) and if the result is
  "0" then a sliding piece on sq1 would attack sq2 and vice-versa.
  */
   for (i = 0; i < 64; i++) {
     for (j = 0; j < 64; j++)
     while (sqs) {
       j = LSB(sqs);
       directions[i][j] = -9;
       intervening[i][j] = minus9dir[i] ^ minus9dir[j + 9];
       sqs &= sqs - 1;
+    }
+  }
+/*
+  distance_ring[square][distance] has a ring of 1's around "square" with a
+  distance of "distance".  IE for e4, we have a ring of adjacent squares
+  [e4][1], the next ring (2 squares away) for [e4][2], etc.  In this code,
+  s = square being set up, d = distance from square to "ring" and t = target
+  square that is on the ring if distance is correct.
+ */
+  for (s = 0; s < 64; s++) {
+    distance_ring[s][0] = SetMask(s);
+    for (d = 1; d < 8; d++) {
+      distance_ring[s][d] = 0;
+      for (t = 0; t < 64; t++)
+        if (Distance(s, t) == d)
+          distance_ring[s][d] |= SetMask(t);
+    }
+  }
+}
 /*
  *   here before the game actually starts.                                     *
  *                                                                             *
  *******************************************************************************
  */
 void InitializeMagic(void) {
-  int i, j;
+  int i, j, m;
   int initmagicmoves_bitpos64_database[64] = {
 , 0, 58, 1, 59, 47, 53, 2,
 , 39, 48, 27, 54, 33, 42, 3,
 , 51, 37, 40, 49, 18, 28, 20,
 , 30, 34, 11, 43, 14, 22, 4,
     int squares[64];
     int numsquares = 0;
     uint64_t temp = magic_bishop_mask[i];
     while (temp) {
-      uint64_t abit = temp & (0-temp); // Pierre-Marie Baty -- fixed signedness warning
+      uint64_t abit = temp & (0-temp); // Pierre-Marie Baty -- signedness warning fix
       squares[numsquares++] =
           initmagicmoves_bitpos64_database[(abit *
 x07EDD5E59A4E28C2ull) >> 58];
       temp ^= abit;
+    }
     for (temp = 0; temp < (uint64_t) 1 << numsquares; temp++) {
       uint64_t moves;
-      int t = -lower_b;
       uint64_t tempoccupied =
           InitializeMagicOccupied(squares, numsquares, temp);
       moves = InitializeMagicBishop(i, tempoccupied);
       *(magic_bishop_indices[i] +
           (tempoccupied * magic_bishop[i] >> magic_bishop_shift[i])) = moves;
       moves |= SetMask(i);
+      m = -lower_b;
       for (j = 0; j < 4; j++)
-        t += PopCnt(moves & mobility_mask_b[j]) * mobility_score_b[j];
+        m += PopCnt(moves & mobility_mask_b[j]) * mobility_score_b[j];
-      if (t < 0)
+      if (m < 0)
-        t *= 2;
+        m *= 2;
       *(magic_bishop_mobility_indices[i] +
-          (tempoccupied * magic_bishop[i] >> magic_bishop_shift[i])) = t;
+          (tempoccupied * magic_bishop[i] >> magic_bishop_shift[i])) = m;
+    }
+  }
 /*
  Rook attacks and mobility
  */
   for (i = 0; i < 64; i++) {
     int squares[64];
     int numsquares = 0;
-    int t;
     uint64_t temp = magic_rook_mask[i];
     while (temp) {
-      uint64_t abit = temp & (0-temp); // Pierre-Marie Baty -- fixed signedness warning
+      uint64_t abit = temp & (0-temp); // Pierre-Marie Baty -- signedness warning fix
       squares[numsquares++] =
           initmagicmoves_bitpos64_database[(abit *
 x07EDD5E59A4E28C2ull) >> 58];
       temp ^= abit;
           InitializeMagicOccupied(squares, numsquares, temp);
       uint64_t moves = InitializeMagicRook(i, tempoccupied);
       *(magic_rook_indices[i] +
           (tempoccupied * magic_rook[i] >> magic_rook_shift[i])) = moves;
       moves |= SetMask(i);
-      t = -1;
+      m = -1;
       for (j = 0; j < 4; j++)
-        t += PopCnt(moves & mobility_mask_r[j]) * mobility_score_r[j];
+        m += PopCnt(moves & mobility_mask_r[j]) * mobility_score_r[j];
       *(magic_rook_mobility_indices[i] +
           (tempoccupied * magic_rook[i] >> magic_rook_shift[i])) =
-          mob_curve_r[t];
+          mob_curve_r[m];
+    }
+  }
+}
 /*
 /*
  *******************************************************************************
  *                                                                             *
  *   InitializeChessBoard() initializes the chess board to the normal starting *
- *   position.   It then calls SetChessBitboards() to correctly set the usual  *
+ *   position.  It then calls SetChessBitboards() to correctly set the usual   *
  *   occupied-square bitboards to correspond to the starting position.         *
  *                                                                             *
  *******************************************************************************
  */
 void InitializeChessBoard(TREE * tree) {
   int i;
   if (strlen(initial_position)) {
     int nargs;
-    nargs = ReadParse(initial_position, args, " ;");
+    nargs = ReadParse(initial_position, args, " \t;");
     SetBoard(tree, nargs, args, 1);
   } else {
     for (i = 0; i < 64; i++)
       PcOnSq(i) = empty;
     game_wtm = 1;
 /*
  now, set the bit-boards.
  */
     SetChessBitBoards(tree);
+  }
-/*
- clear the caches.
- */
-  for (i = 0; i < 64; i++)
-    tree->cache_n[i] = ~0ull;
 /*
  initialize 50 move counter and repetition list/index.
  */
   Reversible(0) = 0;
-  tree->rep_index = 0;
+  rep_index = 0;
   tree->rep_list[0] = HashKey;
+}
 /*
  *******************************************************************************
     for (piece = knight; piece < king; piece++)
       TotalPieces(side, occupied) +=
           PopCnt(Pieces(side, piece)) * p_vals[piece];
+  }
   TotalAllPieces = PopCnt(OccupiedSquares);
-/*
- initialize major/minor counts.
- */
-  for (side = black; side <= white; side++) {
-    TotalMajors(side) = TotalPieces(side, rook)
-        + 2 * TotalPieces(side, queen);
-    TotalMinors(side) = TotalPieces(side, knight)
-        + TotalPieces(side, bishop);
-  }
-  tree->rep_index = 0;
+  rep_index = 0;
   tree->rep_list[0] = HashKey;
+}
 /*
  *******************************************************************************
  *   in sequence.                                                              *
  *                                                                             *
  *******************************************************************************
  */
 int InitializeGetLogID(void) {
+  int t;
 #if defined(UNIX)
   struct stat *fileinfo = malloc(sizeof(struct stat));
 #endif
-  int t;
   if (!log_id) {
     for (log_id = 1; log_id < 300; log_id++) {
       sprintf(log_filename, "%s/log.%03d", log_path, log_id);
       sprintf(history_filename, "%s/game.%03d", log_path, log_id);
       log_file = fopen(log_filename, "r");
       if (!log_file)
         break;
       fclose(log_file);
+    }
+  }
 #if defined(UNIX)
 /*  a kludge to work around an xboard 4.2.3 problem.  It sends two "quit"
    commands, which causes every other log.nnn file to be empty.  this code
    looks for a very small log.nnn file as the last one, and if it is small,
    then we simply overwrite it to solve this problem temporarily.  this will
    be removed when the nexto xboard version comes out to fix this extra quit
-   problem.                                                               */
+   problem.                                                                  */
-    {
+  {
-      char tfn[128];
+    char tfn[128];
-      FILE *tlog;
+    FILE *tlog;
-      sprintf(tfn, "%s/log.%03d", log_path, log_id - 1);
+    sprintf(tfn, "%s/log.%03d", log_path, log_id - 1);
-      tlog = fopen(tfn, "r+");
+    tlog = fopen(tfn, "r+");
-      if (tlog) {
+    if (tlog) {
-        fstat(fileno(tlog), fileinfo);
+      fstat(fileno(tlog), fileinfo);
-        if (fileinfo->st_size < 1700)
+      if (fileinfo->st_size < 2000)
-          log_id--;
+        log_id--;
-      }
+    }
+  }
 #endif
-  }
   t = log_id++;
   return t;
+}
 /*
  *******************************************************************************
  *                                                                             *
  *   InitializeHashTables() is used to clear all hash entries completely, so   *
  *   that no old information remains to interefere with a new game or test     *
  *   position.                                                                 *
+ *                                                                             *
+ *   Whenever any hash table size is changed, they are initialized by calling  *
+ *   this procedure to make sure that in the case of NUMA hardware, the trick  *
+ *   explained below is always executed.                                       *
+ *                                                                             *
+ *   This code uses the NUMA fix when using MT threads.  It clears size / MT   *
+ *   bytes per cpu, after pinning the current thread to the correct cpu, so    *
+ *   that the data will fault in to the correct NUMA node.  If the size is not *
+ *   perfectly divisible by MT (max threads) it clears the final piece at the  *
+ *   end of each loop.                                                         *
+ *                                                                             *
+ *   Note that if no size has changed, (fault_in = 0) then we skip the NUMA    *
+ *   stuff and just clear the tables, period.                                  *
  *                                                                             *
  *******************************************************************************
  */
-void InitializeHashTables(void) {
+void InitializeHashTables(fault_in) {
-  unsigned int i, side; // Pierre-Marie Baty -- fixed type
+  uint64_t mem_per_node;
+  int node;
   transposition_age = 0;
-  if (!trans_ref)
+  if (fault_in && smp_numa) {
-    return;
-  for (i = 0; i < hash_table_size; i++) {
-    (trans_ref + i)->word1 = 0;
-    (trans_ref + i)->word2 = 0;
-  }
+/*
-  for (i = 0; i < hash_path_size; i++)
+ ************************************************************
-    (hash_path + i)->hash_path_age = -99;
+ *                                                          *
-  if (!pawn_hash_table)
-    return;
-  for (i = 0; i < pawn_hash_table_size; i++) {
+ *  First, initialize the primary transposition/refutation  *
-    (pawn_hash_table + i)->key = 0;
-    (pawn_hash_table + i)->score_mg = 0;
+ *  (hash) table, using the NUMA trick to place part of     *
-    (pawn_hash_table + i)->score_eg = 0;
+ *  the trans/ref on each node of the NUMA system.          *
-    for (side = black; side <= white; side++) {
+ *                                                          *
-      (pawn_hash_table + i)->defects_k[side] = 0;
+ ************************************************************
+ */
-      (pawn_hash_table + i)->defects_e[side] = 0;
+    mem_per_node =
-      (pawn_hash_table + i)->defects_d[side] = 0;
+        hash_table_size * sizeof(HASH_ENTRY) / Max(smp_max_threads, 1);
-      (pawn_hash_table + i)->defects_q[side] = 0;
+    for (node = 0; node < (int) smp_max_threads; node++) { // Pierre-Marie Baty -- added type cast
-      (pawn_hash_table + i)->all[side] = 0;
+      ThreadAffinity(node);
-      (pawn_hash_table + i)->passed[side] = 0;
+      memset((void *) ((size_t) hash_table + node * mem_per_node), 0, (size_t) mem_per_node); // Pierre-Marie Baty -- added type casts + missing critical parentheses!
+    }
+    ThreadAffinity(0);
+    if (mem_per_node * Max(smp_max_threads,
+) < hash_table_size * sizeof(HASH_ENTRY))
+      memset((void *) ((size_t) hash_table + smp_max_threads * mem_per_node), 0, // Pierre-Marie Baty -- added type cast + missing critical parentheses!
+          hash_table_size * sizeof(HASH_ENTRY) -
+          (size_t) mem_per_node * smp_max_threads); // Pierre-Marie Baty -- added type cast
+/*
+ ************************************************************
+ *                                                          *
+ *  Second, initialize the primary hash path table, using   *
+ *  the NUMA trick to place part of the hash path table on  *
+ *  each node of the NUMA system.                           *
+ *                                                          *
+ ************************************************************
+ */
+    mem_per_node =
+        hash_path_size * sizeof(HPATH_ENTRY) / Max(smp_max_threads, 1);
+    for (node = 0; node < (int) smp_max_threads; node++) { // Pierre-Marie Baty -- added type cast
+      ThreadAffinity(node);
+      memset((void *) ((size_t) hash_path + node * mem_per_node), 0, (size_t) mem_per_node); // Pierre-Marie Baty -- added type casts + missing critical parentheses!
+    }
+    ThreadAffinity(1 % Min(1, smp_max_threads));
+    if (mem_per_node * Max(smp_max_threads,
+) < hash_path_size * sizeof(HPATH_ENTRY))
+      memset((void *) ((size_t) hash_path + smp_max_threads * mem_per_node), 0, // Pierre-Marie Baty -- added type cast + missing critical parentheses!
+          hash_path_size * sizeof(HPATH_ENTRY) -
+          (size_t) mem_per_node * smp_max_threads); // Pierre-Marie Baty -- added type cast
+/*
+ ************************************************************
+ *                                                          *
+ *  Third, initialize the primary pawn hash table, using    *
+ *  the NUMA trick to place part of the pawn hash table on  *
+ *  each node of the NUMA system.                           *
+ *                                                          *
+ ************************************************************
+ */
+    mem_per_node =
+        pawn_hash_table_size * sizeof(PAWN_HASH_ENTRY) / Max(smp_max_threads,
+);
+    for (node = 0; node < (int) smp_max_threads; node++) { // Pierre-Marie Baty -- added type cast
+      ThreadAffinity(node);
+      memset((void *) ((size_t) pawn_hash_table + node * mem_per_node), 0, (size_t) mem_per_node); // Pierre-Marie Baty -- added type casts + missing critical parentheses!
+    }
+    ThreadAffinity(4 % Min(4, smp_max_threads));
+    if (mem_per_node * Max(smp_max_threads,
+) < pawn_hash_table_size * sizeof(PAWN_HASH_ENTRY))
+      memset((void *) ((size_t) pawn_hash_table + smp_max_threads * mem_per_node), 0, // Pierre-Marie Baty -- added type cast + missing critical parentheses!
+          pawn_hash_table_size * sizeof(PAWN_HASH_ENTRY) -
+          (size_t) mem_per_node * smp_max_threads); // Pierre-Marie Baty -- added type cast
+/*
+ ************************************************************
+ *                                                          *
+ *  Finally, initialize the eval hash table, using the NUMA *
+ *  trick to place part of the eval hash table on each node *
+ *  of the NUMA system.                                     *
+ *                                                          *
+ ************************************************************
+ */
+    mem_per_node =
+        eval_hash_table_size * sizeof(uint64_t) / Max(smp_max_threads, 1);
+    for (node = 0; node < (int) smp_max_threads; node++) { // Pierre-Marie Baty -- added type cast
+      ThreadAffinity(node);
+      memset((void *) ((size_t) eval_hash_table + node * mem_per_node), 0, (size_t) mem_per_node); // Pierre-Marie Baty -- added type casts + missing critical parentheses!
+    }
+    ThreadAffinity(4 % Min(4, smp_max_threads));
+    if (mem_per_node * Max(smp_max_threads,
+) < eval_hash_table_size * sizeof(uint64_t))
+      memset((void *) ((size_t) eval_hash_table + smp_max_threads * mem_per_node), 0, // Pierre-Marie Baty -- added type cast + missing critical parentheses!
+          eval_hash_table_size * sizeof(uint64_t) -
+          (size_t) mem_per_node * smp_max_threads); // Pierre-Marie Baty -- added type cast
+/*
+ ************************************************************
+ *                                                          *
+ *  Before we return, we need to re-pin this thread to the  *
+ *  correct processor.                                      *
+ *                                                          *
+ ************************************************************
+ */
+    ThreadAffinity(smp_affinity);
+  } else {
+/*
+ ************************************************************
+ *                                                          *
+ *  Otherwise we only need to use memset() to clear the     *
+ *  tables since they have already been faulted in to the   *
+ *  correct NUMA node.                                      *
+ *                                                          *
+ ************************************************************
+ */
+    memset((void *) hash_table, 0, hash_table_size * sizeof(HASH_ENTRY));
+    memset((void *) hash_path, 0, hash_path_size * sizeof(HPATH_ENTRY));
+    memset((void *) pawn_hash_table, 0,
+        pawn_hash_table_size * sizeof(PAWN_HASH_ENTRY));
+    memset((void *) eval_hash_table, 0,
+        eval_hash_table_size * sizeof(uint64_t));
+  }
+}
 /*
  *******************************************************************************
  *                                                                             *
  *   InitializeKillers() is used to zero the killer moves so that old killers  *
- *   don't screw up ordering while processing test suites.                     *
+ *   don't screw up ordering while processing test suites.  Ditto for history  *
+ *   counters.                                                                 *
  *                                                                             *
  *******************************************************************************
  */
 void InitializeKillers(void) {
   int i;
   for (i = 0; i < MAXPLY; i++) {
     block[0]->killers[i].move1 = 0;
     block[0]->killers[i].move2 = 0;
+  }
-}
-/*
- *******************************************************************************
- *                                                                             *
- *   InitializeKingSafety() is used to initialize the king safety matrix.      *
- *   This is set so that the matrix, indexed by king safety pawn structure     *
- *   index and by king safety piece tropism, combines the two indices to       *
- *   produce a single score.  As either index rises, the king safety score     *
- *   tracks along, but as both rise, the king safety score rises much more     *
- *   quickly.                                                                  *
- *                                                                             *
- *******************************************************************************
- */
-void InitializeKingSafety() {
-  int safety, tropism;
-  for (safety = 0; safety < 16; safety++) {
+  for (i = 0; i < 1024; i++)
-    for (tropism = 0; tropism < 16; tropism++) {
-      king_safety[safety][tropism] =
-* ((safety_vector[safety] + 100) * (tropism_vector[tropism] +
-) / 100 - 100) / 100;
-    }
-  }
-/*
-  for (safety = 0; safety < 16; safety++) {
-    for (tropism = 0; tropism < 16; tropism++) {
-      printf("%4d", king_safety[safety][tropism]);
-    }
-    printf("\n");
+    history[i] = 1024;
-  }
-*/
+}
 /*
  *******************************************************************************
  *                                                                             *
   for (i = 1; i < 8; i++)
     file_mask[i] = file_mask[i - 1] << 1;
 /*
  masks to determine if a pawn has nearby neighbors or not.
  */
-  for (i = 8; i < 56; i++) {
-    if (File(i) > 0 && File(i) < 7)
-      mask_pawn_connected[i] =
-          SetMask(i - 1) | SetMask(i + 1) | SetMask(i - 9) | SetMask(i - 7)
-          | SetMask(i + 7) | SetMask(i + 9);
-    else if (File(i) == 0)
-      mask_pawn_connected[i] =
-          SetMask(i + 1) | SetMask(i - 7) | SetMask(i + 9);
-    else if (File(i) == 7)
-      mask_pawn_connected[i] =
-          SetMask(i - 1) | SetMask(i - 9) | SetMask(i + 7);
-  }
 #if !defined(INLINEASM)
   msb[0] = 64;
   lsb[0] = 16;
   for (i = 1; i < 65536; i++) {
     lsb[i] = 16;
       mask_passed[black][i] =
           minus8dir[i - 1] | minus8dir[i] | minus8dir[i + 1];
+    }
+  }
 /*
- initialize hidden passed pawn masks, which are nothing more than 1's on
- squares where the opponent can't have pawns so that our "hidden" passed
+ masks to determine if a pawn has supporting contact with friendly pawns.
- will work (say we have pawns on h6 and g5, and our opponent has a pawn on
- h7.  he can't have pawns at g6 or f7 or we can't play g6 and free up our h
- pawn.
  */
-  for (i = 0; i < 8; i++) {
+  for (i = 8; i < 56; i++) {
-    mask_hidden_left[black][i] = 0;
-    mask_hidden_right[black][i] = 0;
+    if (File(i) > 0 && File(i) < 7) {
-    mask_hidden_left[white][i] = 0;
+      mask_pawn_connected[white][i] =
-    mask_hidden_right[white][i] = 0;
-    if (i > 0) {
-      mask_hidden_left[white][i] |= SetMask(39 + i) | SetMask(47 + i);
+          SetMask(i - 1) | SetMask(i + 1) | SetMask(i - 9) | SetMask(i - 7);
-      mask_hidden_left[black][i] |= SetMask(15 + i) | SetMask(7 + i);
+      mask_pawn_connected[black][i] =
-    }
-    if (i > 1) {
-      mask_hidden_left[white][i] |= SetMask(46 + i) | SetMask(38 + i);
-      mask_hidden_left[black][i] |= SetMask(6 + i) | SetMask(14 + i);
+          SetMask(i - 1) | SetMask(i + 1) | SetMask(i + 9) | SetMask(i + 7);
-    }
-    if (i < 6) {
+    } else if (File(i) == 0) {
-      mask_hidden_right[white][i] |= SetMask(50 + i) | SetMask(42 + i);
+      mask_pawn_connected[white][i] = SetMask(i + 1) | SetMask(i - 7);
-      mask_hidden_right[black][i] |= SetMask(10 + i) | SetMask(18 + i);
+      mask_pawn_connected[black][i] = SetMask(i + 1) | SetMask(i + 9);
-    }
-    if (i < 7) {
+    } else if (File(i) == 7) {
-      mask_hidden_right[white][i] |= SetMask(41 + i) | SetMask(49 + i);
+      mask_pawn_connected[white][i] = SetMask(i - 1) | SetMask(i - 9);
-      mask_hidden_right[black][i] |= SetMask(17 + i) | SetMask(9 + i);
+      mask_pawn_connected[black][i] = SetMask(i - 1) | SetMask(i + 7);
+    }
+  }
 /*
  these masks are used to determine if the other side has any pawns
  that can attack [square].
  */
   for (i = 8; i < 56; i++) {
     if (!File(i)) {
-      mask_no_pattacks[white][i] = minus8dir[i + 1];
+      mask_pattacks[white][i] = minus8dir[i + 1];
-      mask_no_pattacks[black][i] = plus8dir[i + 1];
+      mask_pattacks[black][i] = plus8dir[i + 1];
     } else if (File(i) == 7) {
-      mask_no_pattacks[white][i] = minus8dir[i - 1];
+      mask_pattacks[white][i] = minus8dir[i - 1];
-      mask_no_pattacks[black][i] = plus8dir[i - 1];
+      mask_pattacks[black][i] = plus8dir[i - 1];
     } else {
-      mask_no_pattacks[white][i] = minus8dir[i - 1] | minus8dir[i + 1];
+      mask_pattacks[white][i] = minus8dir[i - 1] | minus8dir[i + 1];
-      mask_no_pattacks[black][i] = plus8dir[i + 1] | plus8dir[i - 1];
+      mask_pattacks[black][i] = plus8dir[i + 1] | plus8dir[i - 1];
+    }
+  }
 /*
  enpassant pawns are on either file adjacent to the current file, and
  on the same rank.
   mask_eptest[A4] = SetMask(B4);
   mask_eptest[H4] = SetMask(G4);
   mask_eptest[A5] = SetMask(B5);
   mask_eptest[H5] = SetMask(G5);
 /*
- initialize masks used to evaluate pawn races.  these masks are
+ Initialize masks used to evaluate pawn races.  These masks are
  used to determine if the opposing king is in a position to stop a
- passed pawn from racing down and queening.  the data is organized
+ passed pawn from racing down and queening.  The data is organized
  as pawn_race[side][onmove][square], where side is black or white,
  and onmove indicates which side is to move for proper tempo
  evaluation.
  */
   for (i = 0; i < 64; i++) {
     pawn_race[white][white][i] = 0;
     pawn_race[white][black][i] = 0;
         if (KingPawnSquare(j, i, File(j), 1))
           pawn_race[black][black][j] |= SetMask(i);
+      }
+    }
+  }
+}
 /*
- is_outside[p][a]
- p=8 bit mask for passed pawns
- a=8 bit mask for all pawns on board
- p must have left-most or right-most bit set when compared to
+ *******************************************************************************
- mask 'a'.  and this bit must be separated from the next bit
+ *                                                                             *
- by at least one file (ie the outside passed pawn is 2 files
+ *   InitializeReductions() is used to initialize the reduction matrix used to *
- from the rest of the pawns, at least.
+ *   set the reduction value for LMR for each move searched.  It is indexed by *
- ppsq = square that contains a (potential) passed pawn.
+ *   depth remaining and # moves searched.                                     *
- psql = leftmost pawn, period.
- psqr = rightmost pawn, period.
--> passed pawn is not 'outside'
+ *                                                                             *
--> passed pawn is 'outside'
--> passed pawn is 'outside' on both sides of board
+ *******************************************************************************
  */
-  for (i = 0; i < 256; i++) {
+void InitializeReductions() {
-    for (j = 0; j < 256; j++) {
-      int ppsq1, ppsq2, psql, psqr;
+  int d, m;
-      is_outside[i][j] = 0;
-      ppsq1 = lsb_8bit[i];
-      if (ppsq1 < 8) {
+  for (d = 0; d < 32; d++)
-        psql = lsb_8bit[j];
+    for (m = 0; m < 64; m++)
-        if (ppsq1 < psql - 1 || psql == 8)
-          is_outside[i][j] += 1;
+      LMR[d][m] = 0;
-      }
-      ppsq2 = msb_8bit[i];
+  for (d = 3; d < 32; d++)
-      if (ppsq2 < 8) {
+    for (m = 1; m < 64; m++) {
-        psqr = msb_8bit[j];
+      LMR[d][m] = (uint8_t) // Pierre-Marie Baty -- added type cast
-        if (ppsq2 > psqr + 1 || psqr == 8)
+          Max(Min(log(d * LMR_db) * log(m * LMR_mb) / LMR_s, LMR_max),
-          is_outside[i][j] += 1;
+          LMR_min);
-      }
-      if (ppsq1 == ppsq2 && is_outside[i][j] > 0)
+      LMR[d][m] = Min(LMR[d][m], Max(d - 1 - LMR_rdepth, 0));
-        is_outside[i][j] = 1;
+    }
-  }
+}
 /*
  *******************************************************************************
  *                                                                             *
  *                                                                             *
  *******************************************************************************
  */
 void InitializeSMP(void) {
   LockInit(lock_smp);
-  LockInit(lock_split);
   LockInit(lock_io);
-  LockInit(lock_root);
   LockInit(block[0]->lock);
 #if defined(UNIX) && (CPUS > 1)
   pthread_attr_init(&attributes);
   pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_DETACHED);
 #endif

Subversion Repositories Games.Chess Giants

Games.Chess Giants/engine-crafty/init.c – Rev 33 → 108