Small renaming in Thread struct

Should be a bit more clear the meaning of the
single variables.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/search.cpp b/src/search.cpp
index d4826946fb043b98b5e8ec4cc2d77d1e0e5315d8..73050bdf12534065495807d016753debd2e8ca3b 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -1865,7 +1865,7 @@ void Thread::idle_loop(SplitPoint* sp_master) {
           lock_grab(Threads.splitLock);
 
           assert(is_searching);
           lock_grab(Threads.splitLock);
 
           assert(is_searching);

-          SplitPoint* sp = splitPoint;
+          SplitPoint* sp = curSplitPoint;

 
           lock_release(Threads.splitLock);
 
 
           lock_release(Threads.splitLock);
 

diff --git a/src/thread.cpp b/src/thread.cpp
index 3b87a72415ddd0fd3fc57ba345a55c3af78fbc97..7507ded119e5329f5df4cb9170ce5e79769c54d1 100644 (file)
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -141,7 +141,7 @@ void Thread::wait_for_stop_or_ponderhit() {
 
 bool Thread::cutoff_occurred() const {
 
 
 bool Thread::cutoff_occurred() const {
 

-  for (SplitPoint* sp = splitPoint; sp; sp = sp->parent)
+  for (SplitPoint* sp = curSplitPoint; sp; sp = sp->parent)

       if (sp->cutoff)
           return true;
 
       if (sp->cutoff)
           return true;
 


@@ -163,11 +163,11 @@ bool Thread::is_available_to(int master) const {
 
   // Make a local copy to be sure doesn't become zero under our feet while
   // testing next condition and so leading to an out of bound access.
 
   // Make a local copy to be sure doesn't become zero under our feet while
   // testing next condition and so leading to an out of bound access.

-  int sp_count = activeSplitPoints;
+  int spCnt = splitPointsCnt;

 
   // No active split points means that the thread is available as a slave for any
   // other thread otherwise apply the "helpful master" concept if possible.
 
   // No active split points means that the thread is available as a slave for any
   // other thread otherwise apply the "helpful master" concept if possible.

-  return !sp_count || (splitPoints[sp_count - 1].slavesMask & (1ULL << master));
+  return !spCnt || (splitPoints[spCnt - 1].slavesMask & (1ULL << master));

 }
 
 
 }
 
 


@@ -224,7 +224,7 @@ void ThreadsManager::init() {
       lock_init(threads[i].sleepLock);
       cond_init(threads[i].sleepCond);
 
       lock_init(threads[i].sleepLock);
       cond_init(threads[i].sleepCond);
 

-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
+      for (int j = 0; j < MAX_SPLITPOINTS_PER_THREAD; j++)

           lock_init(threads[i].splitPoints[j].lock);
   }
 
           lock_init(threads[i].splitPoints[j].lock);
   }
 


@@ -264,7 +264,7 @@ void ThreadsManager::exit() {
       lock_destroy(threads[i].sleepLock);
       cond_destroy(threads[i].sleepCond);
 
       lock_destroy(threads[i].sleepLock);
       cond_destroy(threads[i].sleepCond);
 

-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
+      for (int j = 0; j < MAX_SPLITPOINTS_PER_THREAD; j++)

           lock_destroy(threads[i].splitPoints[j].lock);
   }
 
           lock_destroy(threads[i].splitPoints[j].lock);
   }
 


@@ -313,13 +313,13 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
   int master = pos.thread();
   Thread& masterThread = threads[master];
 
   int master = pos.thread();
   Thread& masterThread = threads[master];
 

-  if (masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS)
+  if (masterThread.splitPointsCnt >= MAX_SPLITPOINTS_PER_THREAD)

       return bestValue;
 
   // Pick the next available split point from the split point stack
       return bestValue;
 
   // Pick the next available split point from the split point stack

-  SplitPoint* sp = &masterThread.splitPoints[masterThread.activeSplitPoints];
+  SplitPoint* sp = &masterThread.splitPoints[masterThread.splitPointsCnt];

 
 

-  sp->parent = masterThread.splitPoint;
+  sp->parent = masterThread.curSplitPoint;

   sp->master = master;
   sp->cutoff = false;
   sp->slavesMask = 1ULL << master;
   sp->master = master;
   sp->cutoff = false;
   sp->slavesMask = 1ULL << master;


@@ -349,7 +349,7 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
       if (threads[i].is_available_to(master))
       {
           sp->slavesMask |= 1ULL << i;
       if (threads[i].is_available_to(master))
       {
           sp->slavesMask |= 1ULL << i;

-          threads[i].splitPoint = sp;
+          threads[i].curSplitPoint = sp;

           threads[i].is_searching = true; // Slave leaves idle_loop()
 
           if (useSleepingThreads)
           threads[i].is_searching = true; // Slave leaves idle_loop()
 
           if (useSleepingThreads)


@@ -359,8 +359,8 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
               break;
       }
 
               break;
       }
 

-  masterThread.splitPoint = sp;
-  masterThread.activeSplitPoints++;
+  masterThread.curSplitPoint = sp;
+  masterThread.splitPointsCnt++;

 
   lock_release(splitLock);
   lock_release(sp->lock);
 
   lock_release(splitLock);
   lock_release(sp->lock);


@@ -380,8 +380,8 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
   lock_grab(splitLock);
 
   masterThread.is_searching = true;
   lock_grab(splitLock);
 
   masterThread.is_searching = true;

-  masterThread.activeSplitPoints--;
-  masterThread.splitPoint = sp->parent;
+  masterThread.splitPointsCnt--;
+  masterThread.curSplitPoint = sp->parent;

   pos.set_nodes_searched(pos.nodes_searched() + sp->nodes);
 
   lock_release(splitLock);
   pos.set_nodes_searched(pos.nodes_searched() + sp->nodes);
 
   lock_release(splitLock);

diff --git a/src/thread.h b/src/thread.h
index dea9d79720112ed77902696b8b45877d77ffd5c0..e863d3269237b66fab96108422926eb3b9669eb0 100644 (file)
--- a/src/thread.h
+++ b/src/thread.h
@@ -30,7 +30,7 @@
 #include "search.h"
 
 const int MAX_THREADS = 32;
 #include "search.h"
 
 const int MAX_THREADS = 32;

-const int MAX_ACTIVE_SPLIT_POINTS = 8;
+const int MAX_SPLITPOINTS_PER_THREAD = 8;

 
 struct SplitPoint {
 
 
 struct SplitPoint {
 


@@ -73,7 +73,7 @@ struct Thread {
   void timer_loop();
   void wait_for_stop_or_ponderhit();
 
   void timer_loop();
   void wait_for_stop_or_ponderhit();
 

-  SplitPoint splitPoints[MAX_ACTIVE_SPLIT_POINTS];
+  SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD];

   MaterialInfoTable materialTable;
   PawnInfoTable pawnTable;
   int threadID;
   MaterialInfoTable materialTable;
   PawnInfoTable pawnTable;
   int threadID;


@@ -81,8 +81,8 @@ struct Thread {
   Lock sleepLock;
   WaitCondition sleepCond;
   ThreadHandle handle;
   Lock sleepLock;
   WaitCondition sleepCond;
   ThreadHandle handle;

-  SplitPoint* volatile splitPoint;
-  volatile int activeSplitPoints;
+  SplitPoint* volatile curSplitPoint;
+  volatile int splitPointsCnt;

   volatile bool is_searching;
   volatile bool do_sleep;
   volatile bool do_exit;
   volatile bool is_searching;
   volatile bool do_sleep;
   volatile bool do_exit;