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

  *                                                                             *
  *******************************************************************************
  */
 void Initialize() {
   TREE *tree;
-  int /*i, */j, v, major, id/*, node*/; // Pierre-Marie Baty -- unreferenced variables
+  int j, v, major, id;
+#if defined(UNIX)
+  int i, node;
+#endif
   tree = block[0];
   for (j = 1; j <= MAX_BLOCKS; j++)
     block[j] = NULL;
   InitializeMasks();
   if (computer_bs_file)
     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 -- signedness warning fix
+    fseek(book_file, - (long) sizeof(int), SEEK_END);
     v = fread(&maj_min, 4, 1, book_file);
     if (v <= 0)
       perror("Initialize() fread error: ");
     major = BookIn32((unsigned char *) &maj_min);
     major = major >> 16;
   history_file = fopen(history_filename, "w+");
   if (!history_file) {
     printf("ERROR, unable to open game history file, exiting\n");
     CraftyExit(1);
+  }
-  AlignedMalloc((void *) ((void *) &hash_table), 64,
+  AlignedMalloc((void *) &hash_table, 64,
       sizeof(HASH_ENTRY) * hash_table_size);
-  AlignedMalloc((void *) ((void *) &hash_path), 64,
+  AlignedMalloc((void *) &hash_path, 64,
       sizeof(HPATH_ENTRY) * hash_path_size);
-  AlignedMalloc((void *) ((void *) &pawn_hash_table), 64,
+  AlignedMalloc((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 (!hash_table) {
     Print(2048,
         "AlignedMalloc() failed, not enough memory (primary trans/ref table).\n");
     hash_table_size = 0;
     hash_table = 0;
       AlignedMalloc((void **) &block[i * 64 + j + 1], 2048,
           (size_t) sizeof(TREE));
+    }
+  }
   for (i = 1; i < 64; i++) {
-    memset((void *) block[i], 0, sizeof(TREE));
+    memset((char *) 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));
+      memset((char *) block[node * 64 + i], 0, sizeof(TREE));
       LockInit(block[node * 64 + i]->lock);
+    }
+  }
-  ThreadAffinity(smp_affinity);
+  ThreadAffinity(0);
 #  endif
 #endif
   thread[0].blocks = 0xffffffffffffffffull;
   initialized_threads++;
   InitializeHashTables(1);
   InitializeKingSafety();
+  InitializeLMP();
-  InitializeReductions();
+  InitializeLMR();
+}
 /*
  *******************************************************************************
  *                                                                             *
     int squares[64];
     int numsquares = 0;
     uint64_t temp = magic_bishop_mask[i];
     while (temp) {
-      uint64_t abit = temp & (0-temp); // Pierre-Marie Baty -- signedness warning fix
+      uint64_t abit = temp & -temp;
       squares[numsquares++] =
           initmagicmoves_bitpos64_database[(abit *
 x07EDD5E59A4E28C2ull) >> 58];
       temp ^= abit;
     int squares[64];
     int numsquares = 0;
     uint64_t temp = magic_rook_mask[i];
     while (temp) {
-      uint64_t abit = temp & (0-temp); // Pierre-Marie Baty -- signedness warning fix
+      uint64_t abit = temp & -temp;
       squares[numsquares++] =
           initmagicmoves_bitpos64_database[(abit *
 x07EDD5E59A4E28C2ull) >> 58];
       temp ^= abit;
  *   in sequence.                                                              *
  *                                                                             *
  *******************************************************************************
  */
 int InitializeGetLogID(void) {
-  int t;
+  int t, total_files = 0;
 #if defined(UNIX)
   struct stat *fileinfo = malloc(sizeof(struct stat));
 #endif
-  if (!log_id) {
-    for (log_id = 1; log_id < 300; log_id++) {
+  for (; total_files < 300; log_id++) {
-      sprintf(log_filename, "%s/log.%03d", log_path, log_id);
+    sprintf(log_filename, "%s/log.%03d", log_path, log_id);
-      sprintf(history_filename, "%s/game.%03d", log_path, log_id);
+    sprintf(history_filename, "%s/game.%03d", log_path, log_id);
-      log_file = fopen(log_filename, "r");
+    log_file = fopen(log_filename, "r");
-      if (!log_file)
+    if (!log_file)
-        break;
+      break;
-      fclose(log_file);
+    fclose(log_file);
-    }
+    total_files++;
+  }
 #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,
  *   Note that if no size has changed, (fault_in = 0) then we skip the NUMA    *
  *   stuff and just clear the tables, period.                                  *
  *                                                                             *
  *******************************************************************************
  */
-void InitializeHashTables(fault_in) {
+void InitializeHashTables(int fault_in) {
   uint64_t mem_per_node;
   int node;
   transposition_age = 0;
   if (fault_in && smp_numa) {
  *                                                          *
  ************************************************************
  */
     mem_per_node =
         hash_table_size * sizeof(HASH_ENTRY) / Max(smp_max_threads, 1);
-    for (node = 0; node < (int) smp_max_threads; node++) { // Pierre-Marie Baty -- added type cast
+    for (node = 0; node < smp_max_threads; node++) {
       ThreadAffinity(node);
-      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!
+      memset((char *) hash_table + node * mem_per_node, 0, mem_per_node);
+    }
     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!
+      memset((char *) hash_table + smp_max_threads * mem_per_node, 0,
           hash_table_size * sizeof(HASH_ENTRY) -
-          (size_t) mem_per_node * smp_max_threads); // Pierre-Marie Baty -- added type cast
+          mem_per_node * smp_max_threads);
 /*
  ************************************************************
  *                                                          *
  *  Second, initialize the primary hash path table, using   *
  *  the NUMA trick to place part of the hash path table on  *
  *                                                          *
  ************************************************************
  */
     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
+    for (node = 0; node < smp_max_threads; node++) {
       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!
+      memset((char *) hash_path + node * mem_per_node, 0, mem_per_node);
+    }
-    ThreadAffinity(1 % Min(1, smp_max_threads));
+    ThreadAffinity(0);
     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!
+      memset((char *) hash_path + smp_max_threads * mem_per_node, 0,
           hash_path_size * sizeof(HPATH_ENTRY) -
-          (size_t) mem_per_node * smp_max_threads); // Pierre-Marie Baty -- added type cast
+          mem_per_node * smp_max_threads);
 /*
  ************************************************************
  *                                                          *
- *  Third, initialize the primary pawn hash table, using    *
+ *  Finally, 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
+    for (node = 0; node < smp_max_threads; node++) {
       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!
+      memset((char *) pawn_hash_table + node * mem_per_node, 0, mem_per_node);
+    }
-    ThreadAffinity(4 % Min(4, smp_max_threads));
+    ThreadAffinity(0);
     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!
+      memset((char *) pawn_hash_table + smp_max_threads * mem_per_node, 0,
           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,
+          mem_per_node * 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.                                      *
  *  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((char *) hash_table, 0, hash_table_size * sizeof(HASH_ENTRY));
-    memset((void *) hash_path, 0, hash_path_size * sizeof(HPATH_ENTRY));
+    memset((char *) hash_path, 0, hash_path_size * sizeof(HPATH_ENTRY));
-    memset((void *) pawn_hash_table, 0,
+    memset((char *) 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));
+  }
+}
 /*
  *******************************************************************************
+}
 /*
  *******************************************************************************
  *                                                                             *
+ *   InitializeLMP() is used to initialize the LMP thresholds used to decide   *
+ *   when to stop searching additional branches near the tips of the tree.     *
+ *                                                                             *
+ *******************************************************************************
+ */
+void InitializeLMP() {
+  int i;
+  for (i = 0; i < LMP_depth; i++)
+    LMP[i] = LMP_base + pow(i + .5, LMP_scale);
+}
+/*
+ *******************************************************************************
+ *                                                                             *
- *   InitializeReductions() is used to initialize the reduction matrix used to *
+ *   InitializeLMR() is used to initialize the reduction matrix used to set    *
- *   set the reduction value for LMR for each move searched.  It is indexed by *
+ *   the reduction value for LMR for each move searched.  It is indexed by     *
  *   depth remaining and # moves searched.                                     *
  *                                                                             *
  *******************************************************************************
  */
-void InitializeReductions() {
+void InitializeLMR() {
   int d, m;
   for (d = 0; d < 32; d++)
     for (m = 0; m < 64; m++)
       LMR[d][m] = 0;
   for (d = 3; d < 32; d++)
     for (m = 1; m < 64; m++) {
-      LMR[d][m] = (uint8_t) // Pierre-Marie Baty -- added type cast
+      LMR[d][m] =
           Max(Min(log(d * LMR_db) * log(m * LMR_mb) / LMR_s, LMR_max),
           LMR_min);
       LMR[d][m] = Min(LMR[d][m], Max(d - 1 - LMR_rdepth, 0));
+    }
+}

Subversion Repositories Games.Chess Giants

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