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

  *   on a single cache line rather than being split across two, assuming the   *
  *   structure is 64 bytes or less of course.                                  *
  *                                                                             *
  *******************************************************************************
  */
-void AlignedMalloc(void **pointer, int alignment, size_t size) {
+void AlignedMalloc(void **pointer, uint64_t alignment, size_t size) {
+  uint64_t temp;
   segments[nsegments][0] = malloc(size + alignment - 1);
-  segments[nsegments][1] =
+  segments[nsegments][1] = segments[nsegments][0];
-      (void *) (((uintptr_t) segments[nsegments][0] + alignment -
+  temp = (uint64_t) segments[nsegments][0];
-) & ~(alignment - 1));
+  temp = (temp + alignment - 1) & ~(alignment - 1);
+  segments[nsegments][1] = (void *) temp;
   *pointer = segments[nsegments][1];
   nsegments++;
+}
 /*
  *   AlignedRemalloc() is used to change the size of a memory block that has   *
  *   previously been allocated using AlignedMalloc().                          *
  *                                                                             *
  *******************************************************************************
  */
-void AlignedRemalloc(void **pointer, int alignment, size_t size) {
+void AlignedRemalloc(void **pointer, uint64_t alignment, size_t size) {
+  uint64_t temp;
   int i;
   for (i = 0; i < nsegments; i++)
     if (segments[i][1] == *pointer)
       break;
     Print(4095, "ERROR  AlignedRemalloc() given an invalid pointer\n");
     exit(1);
+  }
   free(segments[i][0]);
   segments[i][0] = malloc(size + alignment - 1);
-  segments[i][1] =
+  temp = (uint64_t) segments[i][0];
-      (void *) (((uintptr_t) segments[i][0] + alignment - 1) & ~(alignment -
+  temp = (temp + alignment - 1) & ~(alignment - 1);
-));
+  segments[i][1] = (void *) temp;
   *pointer = segments[i][1];
+}
 /*
  *******************************************************************************
   int i;
   static int init = 0, pipe;
   static HANDLE inh;
   DWORD dw;
-  if (!xboard && !_isatty(_fileno(stdin))) // Pierre-Marie Baty -- ISO C++ names fix
+  if (!xboard && !isatty(fileno(stdin)))
     return 0;
   if (batch_mode)
     return 0;
   if (strchr(cmd_buffer, '\n'))
     return 1;
  */
 void ClearHashTableScores(void) {
   int i;
   if (hash_table)
-    for (i = 0; i < (int)hash_table_size; i++) { // Pierre-Marie Baty -- added type cast
+    for (i = 0; i < hash_table_size; i++) {
       (hash_table + i)->word2 ^= (hash_table + i)->word1;
       (hash_table + i)->word1 =
           ((hash_table + i)->word1 & mask_clear_entry) | (uint64_t) 65536;
       (hash_table + i)->word2 ^= (hash_table + i)->word1;
+    }
  *                                                                             *
  *******************************************************************************
  */
 char *DisplayEvaluation(int value, int wtm) {
   int tvalue;
-  static char out[10];
+  static char out[20];
   tvalue = (wtm) ? value : -value;
-  if (!MateScore(value))
+  if (!MateScore(value) && !EGTBScore(value))
     sprintf(out, "%7.2f", ((float) tvalue) / 100.0);
   else if (Abs(value) > MATE) {
     if (tvalue < 0)
       sprintf(out, " -infnty");
     else
       sprintf(out, " +infnty");
+  } else {
+    if (EGTBScore(value)) {
+      if (wtm) {
+        if (value == TBWIN)
+          sprintf(out, "   Won ");
+        else if (value == -TBWIN)
+          sprintf(out, "  Lost ");
+      } else {
+        if (value == TBWIN)
+          sprintf(out, "  -Won ");
+        else if (value == -TBWIN)
+          sprintf(out, " -Lost ");
+      }
+    }
+    if (MateScore(value)) {
-  } else if (value == MATE - 2 && wtm)
+      if (value == MATE - 2 && wtm)
-    sprintf(out, "   Mate");
+        sprintf(out, "   Mate");
-  else if (value == MATE - 2 && !wtm)
+      else if (value == MATE - 2 && !wtm)
-    sprintf(out, "  -Mate");
+        sprintf(out, "  -Mate");
-  else if (value == -(MATE - 1) && wtm)
+      else if (value == -(MATE - 1) && wtm)
-    sprintf(out, "  -Mate");
+        sprintf(out, "  -Mate");
-  else if (value == -(MATE - 1) && !wtm)
+      else if (value == -(MATE - 1) && !wtm)
-    sprintf(out, "   Mate");
+        sprintf(out, "   Mate");
-  else if (value > 0 && wtm)
+      else if (value > 0 && wtm)
-    sprintf(out, "  Mat%.2d", (MATE - value) / 2);
+        sprintf(out, "  Mat%.2d", (MATE - value) / 2);
-  else if (value > 0 && !wtm)
+      else if (value > 0 && !wtm)
-    sprintf(out, " -Mat%.2d", (MATE - value) / 2);
+        sprintf(out, " -Mat%.2d", (MATE - value) / 2);
-  else if (wtm)
+      else if (wtm)
-    sprintf(out, " -Mat%.2d", (MATE - Abs(value)) / 2);
+        sprintf(out, " -Mat%.2d", (MATE - Abs(value)) / 2);
-  else
+      else
-    sprintf(out, "  Mat%.2d", (MATE - Abs(value)) / 2);
+        sprintf(out, "  Mat%.2d", (MATE - Abs(value)) / 2);
+    }
+  }
   return out;
+}
 /*
  *******************************************************************************
     wtm = Flip(wtm);
     if (wtm)
       t_move_number++;
+  }
   if (pv->pathh == 1)
-    sprintf(buffer + strlen(buffer), " <HT>             ");
+    sprintf(buffer + strlen(buffer), " <HT>");
   else if (pv->pathh == 2)
-    sprintf(buffer + strlen(buffer), " <EGTB>           ");
+    sprintf(buffer + strlen(buffer), " <3-fold>");
   else if (pv->pathh == 3)
-    sprintf(buffer + strlen(buffer), " <3-fold>         ");
+    sprintf(buffer + strlen(buffer), " <50-move>");
   else if (pv->pathh == 4)
-    sprintf(buffer + strlen(buffer), " <50-move>        ");
+    sprintf(buffer + strlen(buffer), " <EGTB>");
   if (strlen(buffer) < 30)
-    for (i = 0; i < 30 - (int) strlen(buffer); i++) // Pierre-Marie Baty -- added type cast
+    for (i = 0; i < 30 - strlen(buffer); i++)
       strcat(buffer, " ");
   strcpy(kibitz_text, buffer);
   for (i = pv->pathl - 1; i > 0; i--) {
     wtm = Flip(wtm);
     UnmakeMove(tree, i, wtm, pv->path[i]);
+}
 /*
  *******************************************************************************
  *                                                                             *
- *   DisplayFail() is used to display a PV (moves only) during the search.     *
+ *   DisplayFail() is used to display a move that fails high or low during     *
+ *   the search.  Normally disabled.                                           *
  *                                                                             *
  *******************************************************************************
  */
 void DisplayFail(TREE * RESTRICT tree, int type, int level, int wtm, int time,
     int move, int value, int force) {
  *  return immediately.  Otherwise we add the fail high/low *
  *  indicator (++/--) and then display the times.           *
  *                                                          *
  ************************************************************
  */
-  if (time < (int) noise_level) // Pierre-Marie Baty -- added type cast
+  if (time < noise_level)
     return;
   if (type == 1)
     fh_indicator = (wtm) ? "++" : "--";
   else
     fh_indicator = (wtm) ? "--" : "++";
       sprintf(buffer, "%d. (%s)", move_number, ponder_text);
+  }
   sprintf(buffer + strlen(buffer), " %s%c", OutputMove(tree, 1, wtm, move),
       (type == 1) ? '!' : '?');
   strcpy(kibitz_text, buffer);
-  if (time >= (int) noise_level || force) { // Pierre-Marie Baty -- added type cast
+  if (time >= noise_level || force) {
     noise_block = 0;
     Lock(lock_io);
     Print(4, "%s", buffer);
     Unlock(lock_io);
     if (type == 1)
       t_move_number++;
+  }
   if (pv->pathh == 1)
     sprintf(buffer + strlen(buffer), " <HT>");
   else if (pv->pathh == 2)
-    sprintf(buffer + strlen(buffer), " <EGTB>");
-  else if (pv->pathh == 3)
     sprintf(buffer + strlen(buffer), " <3-fold>");
   else if (pv->pathh == 3)
     sprintf(buffer + strlen(buffer), " <50-move>");
+  else if (pv->pathh == 4)
+    sprintf(buffer + strlen(buffer), " <EGTB>");
   if (nskip > 1 && smp_max_threads > 1)
     sprintf(buffer + strlen(buffer), " (s=%d)", nskip);
   if (strlen(buffer) < 30) {
     len = 30 - strlen(buffer);
     for (i = 0; i < len; i++)
       strcat(buffer, " ");
+  }
   strcpy(kibitz_text, buffer);
-  if (time >= (int) noise_level || force) { // Pierre-Marie Baty -- added type cast
+  if (time >= noise_level || force) {
     noise_block = 0;
     Lock(lock_io);
     Print(2, "         ");
     if (level == 6)
       Print(2, "%2i   %s%s   ", pv_depth, Display2Times(time),
           bufftemp = 0;
       if (bufftemp)
         Print(2, "                                     ");
     } while (bufftemp);
     idle_time = 0;
-    for (i = 0; i < (int) smp_max_threads; i++) // Pierre-Marie Baty -- added type cast
+    for (i = 0; i < smp_max_threads; i++)
       idle_time += thread[i].idle;
     busy_percent =
 - Min(100,
 * idle_time / (smp_max_threads * (end_time - start_time) + 1));
     Kibitz(level, twtm, pv_depth, end_time - start_time, pv->pathv,
-        tree->nodes_searched, busy_percent, (int) tree->egtb_hits, kibitz_text); // Pierre-Marie Baty -- added type cast
+        tree->nodes_searched, busy_percent, tree->egtb_hits, kibitz_text);
     Unlock(lock_io);
+  }
   for (i = pv->pathl - 1; i > 0; i--) {
     wtm = Flip(wtm);
     UnmakeMove(tree, i, wtm, pv->path[i]);
       sprintf(tout, "%3u:%02u", ttime / 60, ttime % 60);
+    }
     c = strspn(tout, " ");
     strcat(out, "/");
     strcat(out, tout + c);
-  }
+  } else
+    strcat(out, "       ");
   spaces = 13 - strlen(out);
   for (c = 0; c < spaces; c++)
     strcat(out, " ");
   return out;
+}
     time = time / 100;
     sprintf(out, "%u:%02u", time / 60, time % 60);
+  }
   return out;
+}
-/*
- *******************************************************************************
- *                                                                             *
- *   EGTBPV() is used to display the PV for a known EGTB position.  It simply  *
- *   makes moves, looks up the position to find the shortest mate, then it     *
- *   follows that PV.  It appends a "!" to a move that is the only move to     *
- *   preserve the shortest path to mate (all other moves lead to longer mates  *
- *   or even draws.)                                                           *
- *                                                                             *
- *******************************************************************************
- */
-#if !defined(NOEGTB)
-void EGTBPV(TREE * RESTRICT tree, int wtm) {
-  uint64_t hk[1024], phk[1024], pos[1024];
-  unsigned moves[1024], current[256], *last;
-  int value, ply, i, j, nmoves;
-  int t_move_number, best = 0, bestmv = 0, optimal_mv = 0, legal;
-  char buffer[16384], *next;
-/*
- ************************************************************
- *                                                          *
- *  First, see if this is a known EGTB position.  If not,   *
- *  we can bug out right now.                               *
- *                                                          *
- ************************************************************
- */
-  if (!EGTB_setup)
-    return;
-  tree->status[1] = tree->status[0];
-  if (Castle(1, white) + Castle(1, white))
-    return;
-  if (!EGTBProbe(tree, 1, wtm, &value))
-    return;
-  t_move_number = move_number;
-  sprintf(buffer, "%d.", move_number);
-  if (!wtm)
-    sprintf(buffer + strlen(buffer), " ...");
-/*
- ************************************************************
- *                                                          *
- *  The rest is simple, but messy.  Generate all moves,     *
- *  then find the move with the best egtb score and make it *
- *  (note that if there is only one that is optimal, it is  *
- *  flagged as such).  We then repeat this over and over    *
- *  until we reach the end, or until we repeat a move and   *
- *  can call it a repetition.                               *
- *                                                          *
- ************************************************************
- */
-  for (ply = 1; ply < 1024; ply++) {
-    pos[ply] = HashKey;
-    last = GenerateCaptures(tree, 1, wtm, current);
-    last = GenerateNoncaptures(tree, 1, wtm, last);
-    nmoves = last - current;
-    best = -MATE - 1;
-    legal = 0;
-    for (i = 0; i < nmoves; i++) {
-      MakeMove(tree, 1, wtm, current[i]);
-      if (!Check(wtm)) {
-        legal++;
-        if (TotalAllPieces == 2 || EGTBProbe(tree, 2, Flip(wtm), &value)) {
-          if (TotalAllPieces > 2)
-            value = -value;
-          else
-            value = DrawScore(wtm);
-          if (value > best) {
-            best = value;
-            bestmv = current[i];
-            optimal_mv = 1;
-          } else if (value == best)
-            optimal_mv = 0;
-        }
-      }
-      UnmakeMove(tree, 1, wtm, current[i]);
-    }
-    if (best > -MATE - 1) {
-      moves[ply] = bestmv;
-      if (ply > 1 && wtm)
-        sprintf(buffer + strlen(buffer), " %d.", t_move_number);
-      sprintf(buffer + strlen(buffer), " %s", OutputMove(tree, 1, wtm,
-              bestmv));
-      if (!strchr(buffer, '#') && legal > 1 && optimal_mv)
-        sprintf(buffer + strlen(buffer), "!");
-      hk[ply] = HashKey;
-      phk[ply] = PawnHashKey;
-      MakeMove(tree, 1, wtm, bestmv);
-      tree->status[1] = tree->status[2];
-      wtm = Flip(wtm);
-      for (j = 2 - (ply & 1); j < ply; j += 2)
-        if (pos[ply] == pos[j])
-          break;
-      if (j < ply)
-        break;
-      if (wtm)
-        t_move_number++;
-      if (strchr(buffer, '#'))
-        break;
-    } else {
-      ply--;
-      break;
-    }
-  }
-  nmoves = ply;
-  for (; ply > 0; ply--) {
-    wtm = Flip(wtm);
-    tree->save_hash_key[1] = hk[ply];
-    tree->save_pawn_hash_key[1] = phk[ply];
-    UnmakeMove(tree, 1, wtm, moves[ply]);
-    tree->status[2] = tree->status[1];
-  }
-  next = buffer;
-  while (nmoves) {
-    if ((int) strlen(next) > line_length) { // Pierre-Marie Baty -- added type cast
-      int i;
-      for (i = 0; i < 16; i++)
-        if (*(next + 64 + i) == ' ')
-          break;
-      *(next + 64 + i) = 0;
-      printf("%s\n", next);
-      next += 64 + i + 1;
-    } else {
-      printf("%s\n", next);
-      break;
-    }
-  }
-}
-#endif
 /*
  *******************************************************************************
  *                                                                             *
  *   FormatPV() is used to display a PV during the search.  It will also note  *
  */
 unsigned int ReadClock(void) {
 #if defined(UNIX)
   struct timeval timeval;
   struct timezone timezone;
-#else
-  //HANDLE hThread; // Pierre-Marie Baty -- unreferenced variable
-  //FILETIME ftCreate, ftExit, ftKernel, ftUser; // Pierre-Marie Baty -- unreferenced variables
-  //uint64_t tUser64; // Pierre-Marie Baty -- unreferenced variable
 #endif
 #if defined(UNIX)
   gettimeofday(&timeval, &timezone);
   return timeval.tv_sec * 100 + (timeval.tv_usec / 10000);
 #else
  *******************************************************************************
  */
 int FindBlockID(TREE * RESTRICT which) {
   int i;
-  for (i = 0; i <= (int) smp_max_threads * 64; i++) // Pierre-Marie Baty -- added type cast
+  for (i = 0; i <= smp_max_threads * 64; i++)
     if (which == block[i])
       return i;
   return -1;
+}
   pdist = Abs(Rank(pawn) - Rank(queen)) + !ptm;
   kdist = Distance(king, queen);
   return pdist >= kdist;
+}
-/* last modified 02/26/14 */
+/* last modified 07/13/16 */
 /*
  *******************************************************************************
  *                                                                             *
- *   NewGame() is used to initialize the chess position and timing controls to *
+ *   Mated() is used to determine if the game has ended by checkmate.          *
- *   the setup needed to start a new game.                                     *
+ *                                                                             *
+ *   We return 0 if the game doesn't end here, 1 if the side on move is mated  *
+ *   and 2 if the side on move is stalemated.                                  *
  *                                                                             *
  *******************************************************************************
  */
-void NewGame(int save) {
-  TREE *const tree = block[0];
+int Mated(TREE * RESTRICT tree, int ply, int wtm) {
-  static int save_book_selection_width = 5, save_kibitz = 0;
+  unsigned int rmoves[256], *mvp, *lastm;
-  static int save_resign = 0, save_resign_count = 0, save_draw_count = 0;
-  static int save_learning = 0, save_learn = 0, save_accept_draws = 0;
-  int id;
+  int temp = 0;
-  new_game = 0;
-  if (save) {
+/*
-    save_book_selection_width = book_selection_width;
+ ************************************************************
-    save_kibitz = kibitz;
-    save_resign = resign;
-    save_resign_count = resign_count;
+ *                                                          *
-    save_draw_count = draw_count;
+ *   first, use GenerateMoves() to generate the set of      *
-    save_learning = learning;
+ *   legal moves from the root position, after making the   *
-    save_learn = learn;
-    save_accept_draws = accept_draws;
+ *   test move passed in.                                   *
-  } else {
-    if (learn && moves_out_of_book) {
+ *                                                          *
-      learn_value =
-          (crafty_is_white) ? last_search_value : -last_search_value;
+ ************************************************************
-      LearnBook();
-    }
+ */
-    if (xboard) {
-      printf("tellicsnoalias set 1 Crafty v%s (%d cpus)\n", version, Max(1,
+  lastm = GenerateCaptures(tree, ply, wtm, rmoves);
-              smp_max_threads));
+  lastm = GenerateNoncaptures(tree, ply, wtm, lastm);
-    }
+/*
-    over = 0;
-    moves_out_of_book = 0;
-    learn_positions_count = 0;
-    learn_value = 0;
-    ponder_move = 0;
-    last_search_value = 0;
-    last_pv.pathd = 0;
-    last_pv.pathl = 0;
-    strcpy(initial_position, "");
-    InitializeChessBoard(tree);
-    InitializeHashTables(0);
-    force = 0;
-    books_file = normal_bs_file;
-    draw_score[0] = 0;
-    draw_score[1] = 0;
-    game_wtm = 1;
-    move_number = 1;
-    tc_time_remaining[white] = tc_time;
-    tc_time_remaining[black] = tc_time;
-    tc_moves_remaining[white] = tc_moves;
-    tc_moves_remaining[black] = tc_moves;
+ ************************************************************
-    if (move_actually_played) {
-      if (log_file) {
-        fclose(log_file);
-        fclose(history_file);
-        id = InitializeGetLogID();
-        sprintf(log_filename, "%s/log.%03d", log_path, id);
+ *                                                          *
-        sprintf(history_filename, "%s/game.%03d", log_path, id);
+ *   now make each move and use eliminate any that leave    *
-        log_file = fopen(log_filename, "w");
+ *   king in check (which makes those moves illegal.)       *
-        history_file = fopen(history_filename, "w+");
+ *                                                          *
-        if (!history_file) {
-          printf("ERROR, unable to open game history file, exiting\n");
+ ************************************************************
-          CraftyExit(1);
-        }
-      }
-    }
+ */
-    move_actually_played = 0;
+  for (mvp = rmoves; mvp < lastm; mvp++) {
-    book_selection_width = save_book_selection_width;
-    kibitz = save_kibitz;
+    MakeMove(tree, ply, wtm, *mvp);
-    resign = save_resign;
+    temp = Check(wtm);
-    resign_count = save_resign_count;
-    resign_counter = 0;
-    draw_count = save_draw_count;
+    UnmakeMove(tree, ply, wtm, *mvp);
-    accept_draws = save_accept_draws;
-    draw_counter = 0;
-    usage_level = 0;
-    learning = save_learning;
-    learn = save_learn;
-    predicted = 0;
+    if (!temp)
-    kibitz_depth = 0;
+      break;
-    tree->nodes_searched = 0;
-    kibitz_text[0] = 0;
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *   if there is one move that did not leave us in check,   *
+ *   then it can't be checkmate/stalemate.                  *
+ *                                                          *
+ ************************************************************
+ */
+  if (!temp)
+    return 0;
+/*
+ ************************************************************
+ *                                                          *
+ *   No legal moves.  If we are in check, we have been      *
+ *   checkmated, otherwise we are stalemated.               *
+ *                                                          *
+ ************************************************************
+ */
+  if (Check(wtm))
+    return 1;
+  return 2;
+}
 /*
  *******************************************************************************
  *                                                                             *
 int ReadInput(void) {
   int bytes;
   char buffer[4096], *end;
   do
-    bytes = _read(_fileno(input_stream), buffer, 2048); // Pierre-Marie Baty -- POSIX/ISO C++ names fixes
+    bytes = read(fileno(input_stream), buffer, 2048);
   while (bytes < 0 && errno == EINTR);
   if (bytes == 0) {
     if (input_stream != stdin)
       fclose(input_stream);
     input_stream = stdin;
  *  If we don't have any data in the buffer, the first step *
  *  is to read the next line.                               *
  *                                                          *
  ************************************************************
  */
-  while (1) {
+  while (FOREVER) {
     if (!data) {
       eof = fgets(input_buffer, 4096, input);
       if (!eof)
         return -1;
       if (strchr(input_buffer, '\n'))
  ************************************************************
  */
       last_good_line = lines_read;
       analysis_move[0] = 0;
       if (strchr(buffer, '{') || strchr(buffer, '('))
-        while (1) {
+        while (FOREVER) {
           char *skip, *ch;
           analysis = 1;
           while ((ch = strpbrk(buffer, "(){}[]"))) {
             if (*ch == '(') {
     else
       sprintf(prefix, "whisper");
     switch (level) {
       case 1:
         if ((kibitz & 15) >= 1) {
-          if (value > 0) {
+          if (value > 0)
             printf("%s mate in %d moves.\n\n", prefix, value);
-          }
-          if (value < 0) {
+          if (value < 0)
             printf("%s mated in %d moves.\n\n", prefix, -value);
-          }
+        }
         break;
       case 2:
-        if ((kibitz & 15) >= 2)
+        if ((kibitz & 15) >= 2) {
-          printf("%s ply=%d; eval=%s; nps=%s; time=%s(%d%%); egtb=%d\n",
+          printf("%s ply=%d; eval=%s; nps=%s; time=%s(%d%%)", prefix, depth,
-              prefix, depth, DisplayEvaluationKibitz(value, wtm),
+              DisplayEvaluationKibitz(value, wtm), DisplayKMB(nps, 0),
-              DisplayKMB(nps, 0), DisplayTimeKibitz(time), ip, tb_hits);
+              DisplayTimeKibitz(time), ip);
+          printf("; egtb=%s\n", DisplayKMB(tb_hits, 0));
+        }
+        break;
       case 3:
         if ((kibitz & 15) >= 3 && (nodes > 5000 || level == 2))
           printf("%s %s\n", prefix, pv);
         break;
       case 4:
         if ((kibitz & 15) >= 5 && nodes > 5000) {
           printf("%s d%d-> %s/s %s(%d%%) %s %s ", prefix, depth,
               DisplayKMB(nps, 0), DisplayTimeKibitz(time), ip,
               DisplayEvaluationKibitz(value, wtm), pv);
           if (tb_hits)
-            printf("egtb=%d", tb_hits);
+            printf("egtb=%s", DisplayKMB(tb_hits, 0));
           printf("\n");
+        }
         break;
+    }
     value = (wtm) ? value : -value;
       if (tree->pv[1].path[1] == root_moves[i].move)
         break;
     root_moves[i].path = tree->pv[1];
     root_moves[i].bm_age = 4;
+  }
-}
-/*
- *******************************************************************************
- *                                                                             *
- *   SortRootMoves() is used to sort the root move list based on the value     *
- *   saved for each move.  After a fail high or fail low, we always re-sort    *
- *   the root move list so that the best move found so far is first in the     *
- *   list.  This is primarily intended as a defense against getting a score    *
- *   for the first root move, and then getting a fail-high on the second move, *
- *   which should move this move to the front of the moves.  But if the move   *
- *   then fails low, we want to move it back down since a deeper/less-reduced  *
- *   search did not verify the fail-high.                                      *
- *                                                                             *
- *******************************************************************************
- */
-void SortRootMoves() {
-  ROOT_MOVE rtemp;
-  int mvp, done;
-  do {
-    done = 1;
-    for (mvp = 0; mvp < n_root_moves - 1; mvp++) {
-      if (root_moves[mvp].path.pathv < root_moves[mvp + 1].path.pathv) {
-        rtemp = root_moves[mvp];
-        root_moves[mvp] = root_moves[mvp + 1];
-        root_moves[mvp + 1] = rtemp;
-        done = 0;
-      }
-    }
-  } while (!done);
+}
 /*
  *******************************************************************************
  *                                                                             *
  *******************************************************************************
  */
 int StrCnt(char *string, char testchar) {
   int count = 0, i;
-  for (i = 0; i < (int) strlen(string); i++) // Pierre-Marie Baty -- added type cast
+  for (i = 0; i < strlen(string); i++)
     if (string[i] == testchar)
       count++;
   return count;
+}
  */
     case pawn:
       if (((wtm) ? To(move) - From(move) : From(move) - To(move)) < 0)
         return 0;
       if (Abs(From(move) - To(move)) == 8)
-        return (PcOnSq(To(move))) ? 0 : 1;
+        return PcOnSq(To(move)) ? 0 : 1;
       if (Abs(From(move) - To(move)) == 16)
         return (PcOnSq(To(move)) || PcOnSq(To(move) + epdir[wtm])) ? 0 : 1;
       if (!Captured(move))
         return 0;
 /*
 static ULONG ulNumaNodes;
 static ULONG ulNumaNode = 0;
 // Get NUMA-related information from Windows
 static void WinNumaInit(void) {
-  //DWORD_PTR dwMask; // Pierre-Marie Baty -- unreferenced variable
   HMODULE hModule;
   ULONG ulCPU, ulNode;
   ULONGLONG ullMask;
   DWORD dwCPU;
       if (pGetNumaHighestNodeNumber && pGetNumaNodeProcessorMask &&
           pGetNumaHighestNodeNumber(&ulNumaNodes) && (ulNumaNodes > 0)) {
         fSystemIsNUMA = TRUE;
         if (ulNumaNodes > 255)
           ulNumaNodes = 255;
-        printf("System is NUMA. %d nodes reported by Windows\n",
+        printf("System is NUMA. " PRId64 " nodes reported by Windows\n",
             ulNumaNodes + 1);
         for (ulNode = 0; ulNode <= ulNumaNodes; ulNode++) {
           pGetNumaNodeProcessorMask((UCHAR) ulNode,
               &ullProcessorMask[ulNode]);
-          printf("Node %d CPUs: ", ulNode);
+          printf("Node " PRId64 " CPUs: ", ulNode);
           ullMask = ullProcessorMask[ulNode];
           if (0 == ullMask)
             fSystemIsNUMA = FALSE;
           else {
             ulCPU = 0;
             do {
               if (ullMask & 1)
-                printf("%d ", ulCPU);
+                printf("" PRId64 " ", ulCPU);
               ulCPU++;
               ullMask >>= 1;
             } while (ullMask);
+          }
           printf("\n");
+        }
 // Thread 0 was already started on some CPU. To simplify things further,
-// exchange ullProcessorMask[0] and ullProcessorMask[node for that CPU],
+// exchange ProcessorMask[0] and ProcessorMask[node for that CPU],
-// so ullProcessorMask[0] would always be node for thread 0
+// so ProcessorMask[0] would always be node for thread 0
         dwCPU =
             pSetThreadIdealProcessor(GetCurrentThread(), MAXIMUM_PROCESSORS);
-        printf("Current ideal CPU is %u\n", dwCPU);
+        printf("Current ideal CPU is %llu\n", dwCPU);
         pSetThreadIdealProcessor(GetCurrentThread(), dwCPU);
         if ((((DWORD) - 1) != dwCPU) && (MAXIMUM_PROCESSORS != dwCPU)
-            && !(ullProcessorMask[0] & (1uLL << dwCPU))) { // Pierre-Marie Baty -- added type cast
+            && !(ullProcessorMask[0] & (1u << dwCPU))) {
           for (ulNode = 1; ulNode <= ulNumaNodes; ulNode++) {
-            if (ullProcessorMask[ulNode] & (1uLL << dwCPU)) { // Pierre-Marie Baty -- added type cast
+            if (ullProcessorMask[ulNode] & (1u << dwCPU)) {
-              printf("Exchanging nodes 0 and %d\n", ulNode);
+              printf("Exchanging nodes 0 and " PRId64 "\n", ulNode);
               ullMask = ullProcessorMask[ulNode];
               ullProcessorMask[ulNode] = ullProcessorMask[0];
               ullProcessorMask[0] = ullMask;
               break;
+            }
   if (fSystemIsNUMA) {
     ulNumaNode++;
     if (ulNumaNode > ulNumaNodes)
       ulNumaNode = 0;
     ullMask = ullProcessorMask[ulNumaNode];
-    printf("Starting thread on node %d CPU mask %I64d\n", ulNumaNode,
+    printf("Starting thread on node " PRId64 " CPU mask %I64d\n", ulNumaNode,
         ullMask);
     SetThreadAffinityMask(GetCurrentThread(), (DWORD_PTR) ullMask);
     hThread = (HANDLE) _beginthreadex(0, 0, func, args, CREATE_SUSPENDED, 0);
     SetThreadAffinityMask(hThread, (DWORD_PTR) ullMask);
     ResumeThread(hThread);
-    SetThreadAffinityMask(GetCurrentThread(), (DWORD_PTR) ullProcessorMask[0]); // Pierre-Marie Baty -- added type cast
+    SetThreadAffinityMask(GetCurrentThread(), ullProcessorMask[0]);
   } else
     hThread = (HANDLE) _beginthreadex(0, 0, func, args, 0, 0);
   return hThread;
+}
 #  endif
   WinNumaInit();
   if (fSystemIsNUMA) {
     ulNode = iThread % (ulNumaNodes + 1);
     hThread = GetCurrentThread();
-    dwAffinityMask = SetThreadAffinityMask(hThread, (DWORD_PTR) ullProcessorMask[ulNode]); // Pierre-Marie Baty -- added type cast
+    dwAffinityMask = SetThreadAffinityMask(hThread, ullProcessorMask[ulNode]);
     pBytes = VirtualAlloc(NULL, cbBytes, MEM_COMMIT, PAGE_READWRITE);
     if (pBytes == NULL)
       ExitProcess(GetLastError());
     memset(pBytes, 0, cbBytes);
     SetThreadAffinityMask(hThread, dwAffinityMask);
     dwStep = dwPageSize * cThreads;
     pEnd = pBase + cbBytes;
     for (iThread = 0; iThread < cThreads; iThread++) {
       ulNode = iThread % (ulNumaNodes + 1);
       dwAffinityMask =
-          SetThreadAffinityMask(hThread, (DWORD_PTR) ullProcessorMask[ulNode]); // Pierre-Marie Baty -- added type cast
+          SetThreadAffinityMask(hThread, ullProcessorMask[ulNode]);
       for (pch = pBase + iThread * dwPageSize; pch < pEnd; pch += dwStep) {
         lpvResult = VirtualAlloc(pch, // next page to commit
             dwPageSize, // page size, in bytes
             MEM_COMMIT, // allocate a committed page
             PAGE_READWRITE); // read/write access

Subversion Repositories Games.Chess Giants

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