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

 #include "data.h"
 #include "epdglue.h"
-/* last modified 04/24/14 */
+/* last modified 05/12/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   Iterate() is the routine used to drive the iterated search.  It           *
  *   repeatedly calls search, incrementing the search depth after each call,   *
  *                                                                             *
  *******************************************************************************
  */
 int Iterate(int wtm, int search_type, int root_list_done) {
   TREE *const tree = block[0];
+  ROOT_MOVE temp_rm;
-  int i, root_alpha, old_root_alpha, old_root_beta;
+  int i, alpha, beta, current_rm = 0, force_print = 0;
-  int value = 0, twtm, correct, correct_count;
+  int value = 0, twtm, correct, correct_count, npc, cpl, max;
-  char *fl_indicator, *fh_indicator;
+  unsigned int idle_time;
+  char buff[32];
 #if (CPUS > 1)
-#ifdef UNIX // Pierre-Marie Baty -- this variable is only used on UNIX
+# if defined(UNIX) // Pierre-Marie Baty -- missing conditional macro
   pthread_t pt;
-#endif // UNIX
+# endif
 #endif
 /*
  ************************************************************
  *                                                          *
  *  we don't know whether we are searching for black or     *
  *  white until we get to this point.                       *
  *                                                          *
  ************************************************************
  */
-  if (wtm) {
-    draw_score[0] = -abs_draw_score;
+  draw_score[black] = (wtm) ? -abs_draw_score : abs_draw_score;
-    draw_score[1] = abs_draw_score;
-  } else {
-    draw_score[0] = abs_draw_score;
-    draw_score[1] = -abs_draw_score;
+  draw_score[white] = (wtm) ? abs_draw_score : -abs_draw_score;
-  }
 #if defined(NODES)
   temp_search_nodes = search_nodes;
 #endif
 /*
  ************************************************************
  *                                                          *
  *  Initialize statistical counters and such.               *
  *                                                          *
  ************************************************************
  */
-  idle_time = 0;
-  tree->curmv[0] = 0;
   abort_search = 0;
   book_move = 0;
   program_start_time = ReadClock();
   start_time = ReadClock();
   root_wtm = wtm;
   kibitz_depth = 0;
   tree->nodes_searched = 0;
   tree->fail_highs = 0;
   tree->fail_high_first_move = 0;
   parallel_splits = 0;
+  parallel_splits_wasted = 0;
   parallel_aborts = 0;
+  parallel_joins = 0;
+  for (i = 0; i < (int) smp_max_threads; i++) { // Pierre-Marie Baty -- added type cast
+    thread[i].max_blocks = 0;
+    thread[i].tree = 0;
+    thread[i].idle = 0;
+    thread[i].terminate = 0;
+  }
+  thread[0].tree = block[0];
   correct_count = 0;
   burp = 15 * 100;
   transposition_age = (transposition_age + 1) & 0x1ff;
   next_time_check = nodes_between_time_checks;
   tree->evaluations = 0;
   tree->egtb_probes = 0;
-  tree->egtb_probes_successful = 0;
+  tree->egtb_hits = 0;
   tree->extensions_done = 0;
   tree->qchecks_done = 0;
-  tree->reductions_done = 0;
   tree->moves_fpruned = 0;
+  tree->moves_mpruned = 0;
+  for (i = 0; i < 16; i++) {
+    tree->LMR_done[i] = 0;
+    tree->null_done[i] = 0;
+  }
   root_wtm = wtm;
 /*
  ************************************************************
  *                                                          *
  *  We do a quick check to see if this position has a known *
  *  (based on a normal search / evaluation but with a lower *
  *  time limit) from the book moves given.                  *
  *                                                          *
  ************************************************************
  */
+  if (!root_list_done)
+    RootMoveList(wtm);
-  if (booking || !Book(tree, wtm, root_list_done))
+  if (booking || !Book(tree, wtm))
     do {
       if (abort_search)
         break;
 #if !defined(NOEGTB)
       if (EGTB_draw && !puzzling && swindle_mode)
         EGTB_use = 0;
       else
         EGTB_use = EGTBlimit;
       if (EGTBlimit && !EGTB_use)
-        Print(128, "Drawn at root, trying for swindle.\n");
+        Print(32, "Drawn at root, trying for swindle.\n");
 #endif
 /*
  ************************************************************
  *                                                          *
  *  The first action for a real search is to generate the   *
  *  book random 0) which would have already inserted just   *
  *  the moves that should be searched.                      *
  *                                                          *
  ************************************************************
  */
-      if (!root_list_done)
-        RootMoveList(wtm);
       if (n_root_moves == 0) {
         program_end_time = ReadClock();
         tree->pv[0].pathl = 0;
         tree->pv[0].pathd = 0;
         if (Check(wtm))
           value = -(MATE - 1);
         else
           value = DrawScore(wtm);
-        Print(6, "        depth     time       score   variation\n");
+        Print(2, "        depth     time       score   variation\n");
-        Print(6, "                                     (no moves)\n");
+        Print(2, "                                     (no moves)\n");
         tree->nodes_searched = 1;
         if (!puzzling)
           last_root_value = value;
         return value;
+      }
  *  by search.                                              *
  *                                                          *
  ************************************************************
  */
       TimeSet(search_type);
-      iteration_depth = 1;
+      iteration = 1;
       noise_block = 0;
+      force_print = 0;
       if (last_pv.pathd > 1) {
-        iteration_depth = last_pv.pathd + 1;
+        iteration = last_pv.pathd + 1;
         value = last_root_value;
         tree->pv[0] = last_pv;
+        root_moves[0].path = tree->pv[0];
         noise_block = 1;
+        force_print = 1;
       } else
         difficulty = 100;
-      Print(6, "        depth     time       score   variation (%d)\n",
+      Print(2, "        depth     time       score   variation (%d)\n",
-          iteration_depth);
+          iteration);
       abort_search = 0;
 /*
  ************************************************************
  *                                                          *
  *  Set the initial search bounds based on the last search  *
  *  or default values.                                      *
  *                                                          *
  ************************************************************
  */
       tree->pv[0] = last_pv;
-      if (iteration_depth > 1) {
+      if (iteration > 1) {
-        root_alpha = Max(-MATE, last_value - 16);
+        alpha = Max(-MATE, last_value - 16);
-        root_beta = Min(MATE, last_value + 16);
+        beta = Min(MATE, last_value + 16);
       } else {
-        root_alpha = -MATE;
+        alpha = -MATE;
-        root_beta = MATE;
+        beta = MATE;
+      }
 /*
  ************************************************************
  *                                                          *
  *  If we are using multiple threads, and they have not     *
  *  been started yet, then start them now as the search is  *
  *  ready to begin.                                         *
+ *                                                          *
+ *  If we are using CPU affinity, we need to set this up    *
+ *  for thread 0 since it could have changed since we       *
+ *  initialized everything.                                 *
  *                                                          *
  ************************************************************
  */
 #if (CPUS > 1)
-      if (smp_max_threads > smp_idle + 1) {
+      if ((int) smp_max_threads > smp_threads + 1) { // Pierre-Marie Baty -- added type cast
         long proc;
         initialized_threads = 1;
-        Print(128, "starting thread");
+        Print(32, "starting thread");
-        for (proc = smp_threads + 1; proc < smp_max_threads; proc++) {
+        for (proc = smp_threads + 1; proc < (int) smp_max_threads; proc++) { // Pierre-Marie Baty -- added type cast
-          Print(128, " %d", proc);
+          Print(32, " %d", proc);
-          thread[proc].tree = 0;
 #  if defined(UNIX)
           pthread_create(&pt, &attributes, ThreadInit, (void *) proc);
 #  else
           NumaStartThread(ThreadInit, (void *) proc);
 #  endif
           smp_threads++;
+        }
-        Print(128, " <done>\n");
+        Print(32, " <done>\n");
+      }
       WaitForAllThreadsInitialized();
+      ThreadAffinity(smp_affinity);
 #endif
       if (search_nodes)
-        nodes_between_time_checks = search_nodes;
+        nodes_between_time_checks = (unsigned int) search_nodes; // Pierre-Marie Baty -- added type cast
-      for (; iteration_depth <= MAXPLY - 5; iteration_depth++) {
 /*
  ************************************************************
  *                                                          *
+ *  Main iterative-deepening loop starts here.  We either   *
+ *  start at depth = 1, or if we are pondering and have a   *
+ *  PV from the previous search, we use that to set the     *
+ *  starting depth.                                         *
+ *                                                          *
- *  Now install the old PV into the hash table so that      *
+ *  First install the old PV into the hash table so that    *
- *  these moves will be followed first.  We do this since   *
+ *  these moves will be searched first.  We do this since   *
  *  the last iteration done could have overwritten the PV   *
  *  as the last few root moves were searched.               *
  *                                                          *
  ************************************************************
  */
+      for (; iteration <= MAXPLY - 5; iteration++) {
         twtm = wtm;
         for (i = 1; i < (int) tree->pv[0].pathl; i++) {
           if (!VerifyMove(tree, i, twtm, tree->pv[0].path[i])) {
-            Print(4095, "ERROR, not installing bogus pv info at ply=%d\n", i);
+            Print(2048, "ERROR, not installing bogus pv info at ply=%d\n", i);
-            Print(4095, "not installing from=%d  to=%d  piece=%d\n",
+            Print(2048, "not installing from=%d  to=%d  piece=%d\n",
                 From(tree->pv[0].path[i]), To(tree->pv[0].path[i]),
                 Piece(tree->pv[0].path[i]));
-            Print(4095, "pathlen=%d\n", tree->pv[0].pathl);
+            Print(2048, "pathlen=%d\n", tree->pv[0].pathl);
             break;
+          }
           HashStorePV(tree, twtm, i);
-          MakeMove(tree, i, tree->pv[0].path[i], twtm);
+          MakeMove(tree, i, twtm, tree->pv[0].path[i]);
           twtm = Flip(twtm);
+        }
         for (i--; i > 0; i--) {
           twtm = Flip(twtm);
-          UnmakeMove(tree, i, tree->pv[0].path[i], twtm);
+          UnmakeMove(tree, i, twtm, tree->pv[0].path[i]);
+        }
 /*
  ************************************************************
  *                                                          *
  *  Now we call Search() and start the next search          *
  *  of the clock unnecessarily.                             *
  *                                                          *
  ************************************************************
  */
         if (trace_level) {
-          printf("==================================\n");
+          Print(32, "==================================\n");
-          printf("=      search iteration %2d       =\n", iteration_depth);
+          Print(32, "=      search iteration %2d       =\n", iteration);
-          printf("==================================\n");
+          Print(32, "==================================\n");
+        }
         if (tree->nodes_searched) {
-          nodes_between_time_checks = nodes_per_second / 10;
+          nodes_between_time_checks =
+              nodes_per_second / (10 * Max(smp_max_threads, 1));
           if (!analyze_mode) {
-            if (time_limit > 300);
+            if (time_limit < 1000)
+              nodes_between_time_checks /= 10;
-            else if (time_limit > 50)
+            if (time_limit < 100)
               nodes_between_time_checks /= 10;
-            else
-              nodes_between_time_checks /= 100;
           } else
             nodes_between_time_checks = Min(nodes_per_second, 1000000);
-#if defined(SKILL)
-          if (skill > 50)
-            nodes_between_time_checks = Max(nodes_between_time_checks, 10000);
-#endif
+        }
         if (search_nodes)
-          nodes_between_time_checks = search_nodes - (unsigned int) tree->nodes_searched; // Pierre-Marie Baty -- added type cast (FIXME: either stay on 32 bits, or port correctly!)
+          nodes_between_time_checks = (unsigned int) (search_nodes - tree->nodes_searched); // Pierre-Marie Baty -- added type cast
         nodes_between_time_checks =
             Min(nodes_between_time_checks, MAX_TC_NODES);
         next_time_check = nodes_between_time_checks;
 /*
  ************************************************************
  *                                                          *
  ************************************************************
  */
         failhi_delta = 16;
         faillo_delta = 16;
+        for (i = 0; i < n_root_moves; i++) {
+          if (i || iteration == 1)
+            root_moves[i].path.pathv = -99999999;
+          root_moves[i].status &= 4;
+        }
         while (1) {
-          thread[0].tree = block[0];
-          tree->inchk[1] = Check(wtm);
           if (smp_max_threads > 1)
             smp_split = 1;
-          tree->rep_index--;
+          rep_index--;
-          value =
-              Search(tree, root_alpha, root_beta, wtm, iteration_depth, 1, 0);
+          value = Search(tree, 1, iteration, wtm, alpha, beta, Check(wtm), 0);
-          tree->rep_index++;
+          rep_index++;
           end_time = ReadClock();
           if (abort_search)
             break;
+          for (current_rm = 0; current_rm < n_root_moves; current_rm++)
-          old_root_alpha = root_alpha;
+            if (tree->pv[0].path[1] == root_moves[current_rm].move)
-          old_root_beta = root_beta;
+              break;
 /*
  ************************************************************
  *                                                          *
  *  Check for the case where we get a score back that is    *
  *  greater than or equal to beta.  This is called a fail   *
  *  mind at the root.  (If we are failing high on the first *
  *  root move we skip this update.)                         *
  *                                                          *
  ************************************************************
  */
-          if (value >= root_beta) {
+          if (value >= beta) {
-            root_beta = Min(old_root_beta + failhi_delta, MATE);
+            beta = Min(beta + failhi_delta, MATE);
             failhi_delta *= 2;
             if (failhi_delta > 10 * PAWN_VALUE)
               failhi_delta = 99999;
-            root_moves[0].status &= 0xf7;
+            root_moves[current_rm].status &= 7;
+            root_moves[current_rm].bm_age = 4;
-            if ((root_moves[0].status & 2) == 0)
+            if ((root_moves[current_rm].status & 2) == 0)
               difficulty = ComputeDifficulty(difficulty, +1);
-            root_moves[0].status |= 2;
+            root_moves[current_rm].status |= 2;
-            if (tree->nodes_searched > noise_level) {
-              fh_indicator = (wtm) ? "++" : "--";
-              Print(2, "         %2i   %s     %2s   ", iteration_depth,
+            DisplayFail(tree, 1, 5, wtm, end_time - start_time,
-                  Display2Times(end_time - start_time), fh_indicator);
+                root_moves[current_rm].move, value, force_print);
-              if (display_options & 64)
-                Print(2, "%d. ", move_number);
+            temp_rm = root_moves[current_rm];
-              if ((display_options & 64) && !wtm)
-                Print(2, "... ");
-              Print(2, "%s! ", OutputMove(tree, tree->pv[1].path[1], 1, wtm));
-              Print(2, "(%c%s)                  \n", (wtm) ? '>' : '<',
-                  DisplayEvaluationKibitz(old_root_beta, wtm));
-              kibitz_text[0] = 0;
+            for (i = current_rm; i > 0; i--)
-              if (display_options & 64)
+              root_moves[i] = root_moves[i - 1];
-                sprintf_s(kibitz_text, sizeof (kibitz_text), " %d.", move_number); // Pierre-Marie Baty -- use safe version
-              if ((display_options & 64) && !wtm)
-                strcat_s(kibitz_text, sizeof (kibitz_text), " ..."); // Pierre-Marie Baty -- use safe version
-              sprintf(kibitz_text + strlen(kibitz_text), " %s!",
-                  OutputMove(tree, tree->pv[1].path[1], 1, wtm));
-              idle_percent =
-- Min(100,
+            root_moves[0] = temp_rm;
-* idle_time / (smp_max_threads * (end_time -
-                          start_time) + 1));
-              Kibitz(6, wtm, iteration_depth, end_time - start_time, value,
-                  tree->nodes_searched, idle_percent,
-                  tree->egtb_probes_successful, kibitz_text);
-            }
+          }
 /*
  ************************************************************
  *                                                          *
  *  Check for the case where we get a score back that is    *
  *  less than or equal to alpha.  This is called a fail     *
  *  the first move at the root, and we don't want to stop   *
  *  before we have a chance to find a better one.           *
  *                                                          *
  ************************************************************
  */
-          } else if (value <= root_alpha) {
+          else if (value <= alpha) {
-            root_alpha = Max(old_root_alpha - faillo_delta, -MATE);
+            alpha = Max(alpha - faillo_delta, -MATE);
             faillo_delta *= 2;
             if (faillo_delta > 10 * PAWN_VALUE)
               faillo_delta = 99999;
-            root_moves[0].status &= 0xf7;
+            root_moves[current_rm].status &= 7;
-            if ((root_moves[0].status & 1) == 0)
+            if ((root_moves[current_rm].status & 1) == 0)
               difficulty = ComputeDifficulty(Max(100, difficulty), -1);
-            root_moves[0].status |= 1;
+            root_moves[current_rm].status |= 1;
-            if (tree->nodes_searched > noise_level && !abort_search) {
-              fl_indicator = (wtm) ? "--" : "++";
-              Print(4, "         %2i   %s     %2s   ", iteration_depth,
-                  Display2Times(ReadClock() - start_time), fl_indicator);
+            DisplayFail(tree, 2, 5, wtm, end_time - start_time,
-              if (display_options & 64)
-                Print(4, "%d. ", move_number);
+                root_moves[current_rm].move, value, force_print);
-              if ((display_options & 64) && !wtm)
-                Print(4, "... ");
-              Print(4, "%s? ", OutputMove(tree, root_moves[0].move, 1, wtm));
-              Print(4, "(%c%s)                  \n", (Flip(wtm)) ? '>' : '<',
-                  DisplayEvaluationKibitz(old_root_alpha, wtm));
-            }
           } else
             break;
+        }
-        if (value > root_alpha && value < root_beta)
+        if (value > alpha && value < beta)
           last_root_value = value;
 /*
  ************************************************************
  *                                                          *
  *  If we are running a test suite, check to see if we can  *
         correct = solution_type;
         for (i = 0; i < number_of_solutions; i++) {
           if (!solution_type) {
             if (solutions[i] == tree->pv[0].path[1])
               correct = 1;
-          } else if (solutions[i] == tree->pv[0].path[1])
+          } else if (solutions[i] == root_moves[current_rm].move)
             correct = 0;
+        }
         if (correct)
           correct_count++;
         else
  *  those since they are potential best moves again.        *
  *                                                          *
  ************************************************************
  */
         for (i = 0; i < n_root_moves; i++) {
+          root_moves[i].status &= 3;
           if (root_moves[i].bm_age)
             root_moves[i].bm_age--;
           if (root_moves[i].bm_age)
-            root_moves[i].status &= 0xfb;
-          else
             root_moves[i].status |= 4;
+        }
+        SortRootMoves();
         difficulty = ComputeDifficulty(difficulty, 0);
 /*
  ************************************************************
  *                                                          *
  *  If requested, print the ply=1 move list along with the  *
  *  flags for each move.  Once we print this (if requested) *
  *  we can then clear all of the status flags (except the   *
- *  "ok to search in parallel or reduce" flag) to prepare   *
+ *  "do not search in parallel or reduce" flag) to prepare  *
  *  for the start of the next iteration, since that is the  *
  *  only flag that needs to be carried forward to the next  *
  *  iteration.                                              *
  *                                                          *
  ************************************************************
  */
-        if (display_options & 256) {
+        if (display_options & 64) {
-          Print(128, "       move  age  R ! ?\n");
+          Print(64, "      rmove   score    age  S ! ?\n");
           for (i = 0; i < n_root_moves; i++) {
-            Print(128, " %10s   %d   %d %d %d\n", OutputMove(tree,
+            Print(64, " %10s ", OutputMove(tree, 1, wtm, root_moves[i].move));
+            if (root_moves[i].path.pathv > -MATE)
+              Print(64, "%s", DisplayEvaluation(root_moves[i].path.pathv,
+                      wtm));
+            else
+              Print(64, "  -----");
-                    root_moves[i].move, 1, wtm), root_moves[i].bm_age,
+            Print(64, "     %d   %d %d %d\n", root_moves[i].bm_age,
                 (root_moves[i].status & 4) != 0,
                 (root_moves[i].status & 2) != 0,
                 (root_moves[i].status & 1) != 0);
+          }
+        }
-        for (i = 0; i < n_root_moves; i++)
-          root_moves[i].status &= 4;
 /*
  ************************************************************
  *                                                          *
  *  Here we simply display the PV from the current search   *
  *  iteration, and then set the aspiration for the next     *
  *  iteration to the current score +/- 16.                  *
  *                                                          *
  ************************************************************
  */
         if (end_time - start_time > 10)
-          nodes_per_second =
+          nodes_per_second = (unsigned int) // Pierre-Marie Baty -- added type cast
-              (unsigned int) (tree->nodes_searched * 100 / (end_time - start_time)); // Pierre-Marie Baty -- added type cast (FIXME: either stay on 32 bits, or port correctly!)
+              (tree->nodes_searched * 100 / (uint64_t) (end_time - start_time));
         else
           nodes_per_second = 1000000;
+        tree->pv[0] = root_moves[0].path;
         if (!abort_search && value != -(MATE - 1)) {
-          if (tree->nodes_searched > noise_level) {
+          if (end_time - start_time >= noise_level) {
-            DisplayPV(tree, 5, wtm, end_time - start_time, &tree->pv[0]);
+            DisplayPV(tree, 5, wtm, end_time - start_time, &tree->pv[0],
+                force_print);
             noise_block = 0;
-          }
+          } else
+            noise_block = 1;
+        }
-        root_alpha = Max(-MATE, value - 16);
+        alpha = Max(-MATE, value - 16);
-        root_beta = Min(MATE, value + 16);
+        beta = Min(MATE, value + 16);
 /*
  ************************************************************
  *                                                          *
  *  There are multiple termination criteria that are used.  *
  *  The first and most obvious is that we have exceeded the *
  *                                                          *
  ************************************************************
  */
         if (TimeCheck(tree, 0))
           break;
-        if (iteration_depth > 3 && value > 32000 &&
+        if (iteration > 3 && value > 32000 && value >= (MATE - iteration + 3)
-            value >= (MATE - iteration_depth + 3)
             && value > last_mate_score)
           break;
-        if ((iteration_depth >= search_depth) && search_depth)
+        if ((iteration >= search_depth) && search_depth)
           break;
         if (abort_search)
           break;
         end_time = ReadClock() - start_time;
         if (correct_count >= early_exit)
           break;
 #if !defined(NOEGTB)
-        if (iteration_depth > 10 && TotalAllPieces <= EGTBlimit && EGTB_use &&
+        if (iteration > EGTB_depth + 10 && TotalAllPieces <= EGTBlimit &&
-            !EGTB_search && EGTBProbe(tree, 1, wtm, &i))
+            EGTB_use && EGTBProbe(tree, 1, wtm, &i))
           break;
 #endif
         if (search_nodes && tree->nodes_searched >= search_nodes)
           break;
+      }
  *                                                          *
  ************************************************************
  */
       end_time = ReadClock();
       if (end_time > 10)
-        nodes_per_second =
+        nodes_per_second = (unsigned int) // Pierre-Marie Baty -- added type cast
-            (unsigned int) (tree->nodes_searched * 100 / (end_time -
+            ((uint64_t) tree->nodes_searched * 100 / Max((uint64_t) end_time -
-            start_time + 1)); // Pierre-Marie Baty -- added type cast (FIXME: either stay on 32 bits, or port correctly!)
+            start_time, 1));
       if (abort_search != 2 && !puzzling) {
         if (noise_block)
-          DisplayPV(tree, 5, wtm, end_time - start_time, &tree->pv[0]);
+          DisplayPV(tree, 5, wtm, end_time - start_time, &tree->pv[0], 1);
         tree->evaluations = (tree->evaluations) ? tree->evaluations : 1;
         tree->fail_highs++;
         tree->fail_high_first_move++;
+        idle_time = 0;
+        for (i = 0; i < (int) smp_max_threads; i++) // Pierre-Marie Baty -- added type cast
+          idle_time += thread[i].idle;
-        idle_percent =
+        busy_percent =
 - Min(100,
 * idle_time / (smp_max_threads * (end_time - start_time) +
 ));
         Print(8, "        time=%s(%d%%)",
-            DisplayTimeKibitz(end_time - start_time), idle_percent);
+            DisplayTimeKibitz(end_time - start_time), busy_percent);
-        Print(8, "  n=%" PRIu64, tree->nodes_searched);
+        Print(8, "  nodes=%" PRIu64 "(%s)", tree->nodes_searched,
+            DisplayKMB(tree->nodes_searched, 0));
         Print(8, "  fh1=%d%%",
             tree->fail_high_first_move * 100 / tree->fail_highs);
+        Print(8, "  pred=%d", predicted);
+        Print(8, "  nps=%s\n", DisplayKMB(nodes_per_second, 0));
+        Print(8, "        chk=%s", DisplayKMB(tree->extensions_done, 0));
+        Print(8, "  qchk=%s", DisplayKMB(tree->qchecks_done, 0));
+        Print(8, "  fp=%s", DisplayKMB(tree->moves_fpruned, 0));
+        Print(8, "  mcp=%s", DisplayKMB(tree->moves_mpruned, 0));
         Print(8, "  50move=%d", Reversible(0));
+        if (tree->egtb_hits)
-        Print(8, "  nps=%s\n", DisplayKMB(nodes_per_second));
+          Print(8, "  egtb=%s", DisplayKMB(tree->egtb_hits, 0));
+        Print(8, "\n");
-        Print(16, "        ext=%s", DisplayKMB(tree->extensions_done));
+        Print(8, "        LMReductions:");
+        npc = 21;
+        cpl = 75;
+        for (i = 1; i < 16; i++)
+          if (tree->LMR_done[i]) {
-        Print(16, "  red=%s", DisplayKMB(tree->reductions_done));
+            sprintf(buff, "%d/%s", i, DisplayKMB(tree->LMR_done[i], 0));
+            if (npc + (int)strlen(buff) > cpl) { // Pierre-Marie Baty -- added type cast
+              Print(8, "\n            ");
+              npc = 12;
+            }
+            Print(8, "  %s", buff);
+            npc += strlen(buff) + 2;
+          }
+        if (npc)
+          Print(8, "\n");
+        npc = 24;
+        cpl = 75;
+        if (tree->null_done[null_depth])
-        Print(16, "  pruned=%s", DisplayKMB(tree->moves_fpruned));
+          Print(8, "        null-move (R):");
+        for (i = null_depth; i < 16; i++)
+          if (tree->null_done[i]) {
-        Print(16, "  qchks=%s", DisplayKMB(tree->qchecks_done));
+            sprintf(buff, "%d/%s", i, DisplayKMB(tree->null_done[i], 0));
+            if (npc + (int)strlen(buff) > cpl) { // Pierre-Marie Baty -- added type cast
+              Print(8, "\n            ");
+              npc = 12;
+            }
-        Print(16, "  pred=%d\n", predicted);
+            Print(8, "  %s", buff);
+            npc += strlen(buff) + 2;
+          }
+        if (npc)
+          Print(8, "\n");
+        if (parallel_splits) {
+          max = 0;
+          for (i = 0; i < (int) smp_max_threads; i++) { // Pierre-Marie Baty -- added type cast
+            max = Max(max, PopCnt(thread[i].max_blocks));
+            game_max_blocks |= thread[i].max_blocks;
+          }
-        Print(16, "        splits=%s", DisplayKMB(parallel_splits));
+          Print(8, "        splits=%s", DisplayKMB(parallel_splits, 0));
-        Print(16, "  aborts=%s", DisplayKMB(parallel_aborts));
+          Print(8, "(%s)", DisplayKMB(parallel_splits_wasted, 0));
-        Print(16, "  data=%d%%", 100 * max_split_blocks / Max(MAX_BLOCKS, 1));
+          Print(8, "  aborts=%s", DisplayKMB(parallel_aborts, 0));
-        Print(16, "  probes=%s", DisplayKMB(tree->egtb_probes));
+          Print(8, "  joins=%s", DisplayKMB(parallel_joins, 0));
-        Print(16, "  hits=%s\n", DisplayKMB(tree->egtb_probes_successful));
+          Print(8, "  data=%d%%(%d%%)\n", 100 * max / 64,
+* PopCnt(game_max_blocks) / 64);
+        }
+      }
     } while (0);
 /*
  ************************************************************
  *                                                          *
  */
   else {
     last_root_value = 0;
     value = 0;
     book_move = 1;
-    tree->pv[0] = tree->pv[1];
     if (analyze_mode)
       Kibitz(4, wtm, 0, 0, 0, 0, 0, 0, kibitz_text);
+  }
 /*
  ************************************************************
  *                                                          *
  ************************************************************
  */
   if (smp_nice && ponder == 0 && smp_threads) {
     int proc;
-    Print(128, "terminating SMP processes.\n");
+    Print(64, "terminating SMP processes.\n");
     for (proc = 1; proc < CPUS; proc++)
-      thread[proc].tree = (TREE *) - 1;
+      thread[proc].terminate = 1;
     while (smp_threads);
-    smp_idle = 0;
     smp_split = 0;
+  }
   program_end_time = ReadClock();
   search_move = 0;
   if (quit)

Subversion Repositories Games.Chess Giants

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