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

 #include "data.h"
 #include "epdglue.h"
-#if (CPUS > 1)
-/* modified 11/04/15 */
+/* modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   Split() is the driver for the threaded parallel search in Crafty.  The    *
  *   basic idea is that whenever we notice that one (or more) threads are in   *
  *                                                                             *
  *   There are a number of settable options via the command-line or .craftyrc  *
  *   initialization file.  Here's a concise explanation for each option and an *
  *   occasional suggestion for testing/tuning.                                 *
  *                                                                             *
- *   smp_affinity (command = smpaffinity=<n> is used to enable or disable      *
+ *   smp_affinity (command = smpaffinity=<n> <p> is used to enable or disable  *
  *      processor affinity.  -1 disables affinity and lets threads run on any  *
  *      available core.  If you use an integer <n> then thread zero will bind  *
  *      itself to cpu <n> and each additional thread will bind to the next     *
  *      higher cpu number.  This is useful if you try to run two copies of     *
  *      crafty on the same machine, now you can cause one to bind to the first *
  *                                                          *
  ************************************************************
  */
   tstart = ReadClock();
   tree->nprocs = 0;
-  for (tid = 0; tid < (int) smp_max_threads; tid++) // Pierre-Marie Baty -- added type cast
+  for (tid = 0; tid < smp_max_threads; tid++)
     tree->siblings[tid] = 0;
   child = GetBlock(tree, tree->thread_id);
   if (!child)
     return 0;
   CopyFromParent(child);
   if (!tree->joined)
     parallel_splits_wasted++;
   return 1;
+}
-/* modified 12/16/15 */
+/* modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   Join() is called just when we enter the usual spin-loop waiting for work. *
  *   We take a quick look at all active split blocks to see if any look        *
  *  joinable once we acquire the lock, we abort joining     *
  *  since it is futile.  Note that if this happens, we will *
  *  try to find an existing split point we can join three   *
  *  times before we exit, setting split to 1 to ask other   *
  *  threads to produce more candidate split points.         *
+ *                                                          *
+ *  Special case:  We don't want to join a split point that *
+ *  was created by this thread.  While it works, it can add *
+ *  overhead since we can encounter a later split point     *
+ *  that originated at the current split point, and we      *
+ *  would continue searching even though most of the work   *
+ *  has already been completed.  The hash table would help  *
+ *  avoid most (if not all) of this overhead, but there is  *
+ *  no good reason to take the chance of this happening.    *
  *                                                          *
  ************************************************************
  */
   for (pass = 0; pass < 3; pass++) {
     best_interest = -999999;
     join_block = 0;
-    for (current = 0; current <= (int) smp_max_threads * 64; current++) { // Pierre-Marie Baty -- added type cast
+    for (current = 0; current <= smp_max_threads * 64; current++) {
       tree = block[current];
       if (tree->joinable && (tree->ply <= tree->depth / 2 ||
-              tree->nprocs < (int) smp_split_group)) { // Pierre-Marie Baty -- added type cast
+              tree->nprocs < smp_split_group) && tree->thread_id != tid) {
         interest = tree->depth * 2 - tree->searched[0];
         if (interest > best_interest) {
           best_interest = interest;
           join_block = tree;
+        }
  ************************************************************
  */
     if (join_block) {
       Lock(join_block->lock);
       if (join_block->joinable) {
-        child = GetBlock(join_block, (int) tid); // Pierre-Marie Baty -- added type cast
+        child = GetBlock(join_block, tid);
         Unlock(join_block->lock);
         if (child) {
           CopyFromParent(child);
           thread[tid].tree = child;
           parallel_joins++;
  */
   smp_split = 1;
   return 0;
+}
-/* modified 11/04/15 */
+/* modified 08/03/16 */
+/*
+ *******************************************************************************
+ *                                                                             *
+ *   ThreadAffinity() is called to "pin" a thread to a specific processor.  It *
+ *   is a "noop" (no-operation) if Crafty was not compiled with -DAFFINITY, or *
+ *   if smp_affinity is negative (smpaffinity=-1 disables affinity).  It       *
+ *   simply sets the affinity for the current thread to the requested CPU and  *
+ *   returns.  NOTE:  If hyperthreading is enabled, there is no guarantee that *
+ *   this will work as expected and pin one thread per physical core.  It      *
+ *   depends on how the O/S numbers the SMT cores.                             *
+ *                                                                             *
+ *******************************************************************************
+ */
+void ThreadAffinity(int cpu) {
+#if defined(AFFINITY)
+  cpu_set_t cpuset;
+  pthread_t current_thread = pthread_self();
+  if (smp_affinity >= 0) {
+    CPU_ZERO(&cpuset);
+    CPU_SET(smp_affinity_increment * (cpu + smp_affinity), &cpuset);
+    pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset);
+  }
+#endif
+}
+/* modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   ThreadInit() is called after a process is created.  Its main task is to   *
  *   initialize the process local memory so that it will fault in and be       *
  */
 void *STDCALL ThreadInit(void *t) {
   int tid = (int64_t) t;
   ThreadAffinity(tid);
-#  if !defined(UNIX)
+#if !defined(UNIX)
   ThreadMalloc((uint64_t) tid);
-#  endif
+#endif
   thread[tid].blocks = 0xffffffffffffffffull;
   Lock(lock_smp);
   initialized_threads++;
   Unlock(lock_smp);
   WaitForAllThreadsInitialized();
   smp_threads--;
   Unlock(lock_smp);
   return 0;
+}
-/* modified 01/08/15 */
+/* modified 08/03/16 */
-/*
- *******************************************************************************
- *                                                                             *
- *   ThreadAffinity() is called to "pin" a thread to a specific processor.  It *
- *   is a "noop" (no-operation) if Crafty was not compiled with -DAFFINITY, or *
- *   if smp_affinity is negative (smpaffinity=-1 disables affinity).  It       *
- *   simply sets the affinity for the current thread to the requested CPU and  *
- *   returns.  NOTE:  If hyperthreading is enabled, there is no guarantee that *
- *   this will work as expected and pin one thread per physical core.  It      *
- *   depends on how the O/S numbers the SMT cores.                             *
- *                                                                             *
- *******************************************************************************
- */
-void ThreadAffinity(int cpu) {
-#  if defined(AFFINITY)
-  cpu_set_t cpuset;
-  pthread_t current_thread = pthread_self();
-  if (smp_affinity >= 0) {
-    CPU_ZERO(&cpuset);
-    CPU_SET(cpu + smp_affinity, &cpuset);
-    pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset);
-  }
-#  endif
-}
-/* modified 11/04/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   ThreadSplit() is used to determine if we should split at the current ply. *
  *   There are some basic constraints on when splits can be done, such as the  *
  *   thread becomes idle, it will find these split points immediately and not  *
  *   have to wait for a split after the fact.                                  *
  *                                                                             *
  *******************************************************************************
  */
-int ThreadSplit(TREE *RESTRICT tree, int ply, int depth, int alpha, int o_alpha, // Pierre-Marie Baty -- missing keyword
+int ThreadSplit(TREE * tree, int ply, int depth, int alpha, int o_alpha,
     int done) {
   TREE *used;
   int64_t tblocks;
   int temp, unused = 0;
  *  split point, that being that we must not be too far     *
  *  from the root (smp_min_split_depth).                    *
  *                                                          *
  ************************************************************
  */
-  if (depth < (int) smp_min_split_depth) // Pierre-Marie Baty -- added type cast
+  if (depth < smp_min_split_depth)
     return 0;
 /*
  ************************************************************
  *                                                          *
  *  If smp_split is NOT set, we are checking to see if it   *
  *      just add to the overhead with no benefit.           *
  *                                                          *
  ************************************************************
  */
   if (!smp_split) {
-    if (depth < (int) smp_gratuitous_depth || done > 1) // Pierre-Marie Baty -- added type cast
+    if (depth < smp_gratuitous_depth || done > 1)
       return 0;
     tblocks = ~thread[tree->thread_id].blocks;
     while (tblocks) {
       temp = LSB(tblocks);
       used = block[temp + tree->thread_id * 64 + 1];
       if (used->joinable && !used->joined)
         unused++;
       Clear(temp, tblocks);
+    }
-    if (unused > (int) smp_gratuitous_limit) // Pierre-Marie Baty -- added type cast
+    if (unused > smp_gratuitous_limit)
       return 0;
+  }
 /*
  ************************************************************
  *                                                          *
       used = block[temp + tree->thread_id * 64 + 1];
       if (used->joinable && !used->joined)
         unused++;
       Clear(temp, tblocks);
+    }
-    if (unused > (int) smp_gratuitous_limit) // Pierre-Marie Baty -- added type cast
+    if (unused > smp_gratuitous_limit)
       return 0;
+  }
   return 1;
+}
-/* modified 11/04/15 */
+/* modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   ThreadStop() is called from SearchMoveList() when it detects a beta       *
  *   cutoff (fail high) at a node that is being searched in parallel.  We need *
   int proc;
   Lock(tree->lock);
   tree->stop = 1;
   tree->joinable = 0;
-  for (proc = 0; proc < (int) smp_max_threads; proc++) // Pierre-Marie Baty -- added type cast
+  for (proc = 0; proc < smp_max_threads; proc++)
     if (tree->siblings[proc])
       ThreadStop(tree->siblings[proc]);
   Unlock(tree->lock);
+}
-/* modified 11/04/15 */
+/* modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   ThreadTrace() is a debugging tool that simply walks the split block tree  *
  *   and displays interesting data to help debug the parallel search whenever  *
     if (!brief) {
       for (i = 0; i < 4 * depth; i++)
         Print(4095, " ");
       Print(4095, "          parent=%d  sibling threads=",
           FindBlockID(tree->parent));
-      for (proc = 0; proc < (int) smp_max_threads; proc++) // Pierre-Marie Baty -- added type cast
+      for (proc = 0; proc < smp_max_threads; proc++)
         if (tree->siblings[proc])
           Print(4095, " %d(%d)", proc, FindBlockID(tree->siblings[proc]));
       Print(4095, "\n");
     } else {
       if (tree->nprocs > 1) {
         Print(4095, " helping= ");
-        for (proc = 0; proc < (int) smp_max_threads; proc++) // Pierre-Marie Baty -- added type cast
+        for (proc = 0; proc < smp_max_threads; proc++)
           if (tree->siblings[proc]) {
             if (proc == tree->thread_id)
               Print(4095, "[");
             Print(4095, "%d", proc);
             if (proc == tree->thread_id)
         Print(4095, "\n");
+      }
+    }
+  }
   Unlock(lock_io);
-  for (proc = 0; proc < (int) smp_max_threads; proc++) // Pierre-Marie Baty -- added type cast
+  for (proc = 0; proc < smp_max_threads; proc++)
     if (tree->siblings[proc])
       ThreadTrace(tree->siblings[proc], depth, brief);
   Unlock(tree->lock);
+}
-/* modified 11/04/15 */
+/* modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   ThreadWait() is the idle loop for the N threads that are created at the   *
  *   beginning when Crafty searches.  Threads are "parked" here waiting on a   *
  *  falls through the while spin loop below because its     *
  *  "tree" pointer is already non-zero.                     *
  *                                                          *
  ************************************************************
  */
-  while (1) {
+  while (FOREVER) {
     tstart = ReadClock();
     while (!thread[tid].tree && (!waiting || waiting->nprocs) && !Join(tid) &&
-        !thread[tid].terminate)
+        !thread[tid].terminate);
-      Pause();
     tend = ReadClock();
     if (!thread[tid].tree)
       thread[tid].tree = waiting;
     thread[tid].idle += tend - tstart;
     if (thread[tid].tree == waiting || thread[tid].terminate)
     tend = ReadClock();
     thread[tid].idle += tend - tstart;
+  }
+}
-/* modified 11/04/15 */
+/* modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   CopyFromParent() is used to copy data from a parent thread to a child     *
  *   thread.  This only copies the appropriate parts of the TREE structure to  *
   child->position = parent->position;
   for (i = 0; i <= rep_index + parent->ply; i++)
     child->rep_list[i] = parent->rep_list[i];
   for (i = ply - 1; i < MAXPLY; i++)
     child->killers[i] = parent->killers[i];
+  for (i = 0; i < 4096; i++) {
+    child->counter_move[i] = parent->counter_move[i];
+    child->move_pair[i] = parent->move_pair[i];
+  }
   for (i = ply - 1; i <= ply; i++) {
     child->curmv[i] = parent->curmv[i];
     child->pv[i] = parent->pv[i];
+  }
   child->in_check = parent->in_check;
   child->searched = parent->searched;
   strcpy(child->root_move_text, parent->root_move_text);
   strcpy(child->remaining_moves_text, parent->remaining_moves_text);
+}
-/* modified 11/04/15 */
+/* modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   CopyToParent() is used to copy data from a child thread to a parent       *
  *   thread.  This only copies the appropriate parts of the TREE structure to  *
   if (child->nodes_searched && !child->stop && value > parent->value &&
       !abort_search) {
     parent->pv[ply] = child->pv[ply];
     parent->value = value;
     parent->cutmove = child->curmv[ply];
+    for (i = 0; i < 4096; i++) {
+      parent->counter_move[i] = child->counter_move[i];
+      parent->move_pair[i] = child->move_pair[i];
+    }
+  }
   if (child->stop && ply == 1)
     for (which = 0; which < n_root_moves; which++)
       if (root_moves[which].move == child->curmv[ply]) {
         root_moves[which].status &= 7;
+  }
   which = FindBlockID(child) - 64 * child->thread_id - 1;
   Set(which, thread[child->thread_id].blocks);
+}
-/* modified 11/04/15 */
+/* modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   GetBlock() is used to allocate a split block and fill in only SMP-        *
  *   critical information.  The child process will copy the rest of the split  *
  *   means no locks are needed until after the "joinable" flag is set, which   *
  *   exposes this split point to other threads instantly.                      *
  *                                                                             *
  *******************************************************************************
  */
-TREE *GetBlock(TREE * /*RESTRICT*/ parent, int tid) { // Pierre-Marie Baty -- keyword not present in declaration
+TREE *GetBlock(TREE * RESTRICT parent, int tid) {
   TREE *child;
   static int warnings = 0;
   int i, unused;
 /*
  ************************************************************
  *  of processors working here, etc, without any ugly race  *
  *  conditions that would corrupt this critical data.       *
  *                                                          *
  ************************************************************
  */
-  for (i = 0; i < (int) smp_max_threads; i++) // Pierre-Marie Baty -- added type cast
+  for (i = 0; i < smp_max_threads; i++)
     child->siblings[i] = 0;
   child->nprocs = 0;
   child->stop = 0;
   child->joinable = 0;
   child->joined = 0;
  *   invalid memory accesses and crash instantly.                              *
  *                                                                             *
  *******************************************************************************
  */
 void WaitForAllThreadsInitialized(void) {
-  while (initialized_threads < (int) smp_max_threads); /* Do nothing */ // Pierre-Marie Baty -- added type cast
+  while (initialized_threads < smp_max_threads); /* Do nothing */
+}
-#  if !defined (UNIX)
+#if !defined (UNIX)
-/* modified 01/17/09 */
+/* modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   ThreadMalloc() is called from the ThreadInit() function.  It malloc's the *
  *   split blocks in the local memory for the processor associated with the    *
  */
 extern void *WinMalloc(size_t, int);
 void ThreadMalloc(int64_t tid) {
   int i;
-  for (i = (int) tid * 64 + 1; i < (int) tid * 64 + 65; i++) { // Pierre-Marie Baty -- added type casts
+  for (i = tid * 64 + 1; i < tid * 64 + 65; i++) {
     if (block[i] == NULL)
       block[i] =
           (TREE *) ((~(size_t) 127) & (127 + (size_t) WinMalloc(sizeof(TREE) +
-, (int) tid))); // Pierre-Marie Baty -- added type cast
+, tid)));
     block[i]->parent = NULL;
     LockInit(block[i]->lock);
+  }
+}
-#  endif
 #endif

Subversion Repositories Games.Chess Giants

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