Refactor ThreadsManager::set_size() functionality

Split the data allocation, now done (mostly once)
in read_uci_options(), from the wake up and sleeping
of the slave threads upon entering/exiting the search.

No functional change.

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

diff --git a/src/search.cpp b/src/search.cpp
index fb5d375..cc82af7 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -298,7 +298,7 @@ void Search::think() {
           << endl;
   }
 
-  Threads.set_size(Options["Threads"]);
+  Threads.wake_up();
 
   // Set best timer interval to avoid lagging under time pressure. Timer is
   // used to check for remaining available thinking time.
@@ -312,7 +312,7 @@ void Search::think() {
 
   // Stop timer and send all the slaves to sleep, if not already sleeping
   Threads.set_timer(0);
-  Threads.set_size(1);
+  Threads.sleep();
 
   if (Options["Use Search Log"])
   {

diff --git a/src/thread.cpp b/src/thread.cpp
index 5c23aa5..1913aee 100644 (file)
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -173,35 +173,35 @@ void ThreadsManager::read_uci_options() {
   maxThreadsPerSplitPoint = Options["Max Threads per Split Point"];
   minimumSplitDepth       = Options["Min Split Depth"] * ONE_PLY;
   useSleepingThreads      = Options["Use Sleeping Threads"];
-}
-
-
-// set_size() changes the number of active threads and raises do_sleep flag for
-// all the unused threads that will go immediately to sleep.
-
-void ThreadsManager::set_size(int cnt) {
-
-  assert(cnt > 0 && cnt < MAX_THREADS);
-
-  activeThreads = cnt;
+  activeThreads           = Options["Threads"];
 
+  // Dynamically allocate pawn and material hash tables according to the
+  // number of active threads. This avoids preallocating memory for all
+  // possible threads if only few are used.
   for (int i = 0; i < MAX_THREADS; i++)
       if (i < activeThreads)
       {
-          // Dynamically allocate pawn and material hash tables according to the
-          // number of active threads. This avoids preallocating memory for all
-          // possible threads if only few are used.
           threads[i].pawnTable.init();
           threads[i].materialTable.init();
           threads[i].maxPly = 0;
+      }
+}
 
-          threads[i].do_sleep = false;
 
-          if (!useSleepingThreads)
-              threads[i].wake_up();
-      }
-      else
-          threads[i].do_sleep = true;
+void ThreadsManager::wake_up() {
+
+  for (int i = 0; i < activeThreads; i++)
+  {
+      threads[i].do_sleep = false;
+      threads[i].wake_up();
+  }
+}
+
+
+void ThreadsManager::sleep() {
+
+  for (int i = 0; i < activeThreads; i++)
+      threads[i].do_sleep = true;
 }
 
 

diff --git a/src/thread.h b/src/thread.h
index e71db83..6f23136 100644 (file)
--- a/src/thread.h
+++ b/src/thread.h
@@ -108,7 +108,8 @@ public:
   int min_split_depth() const { return minimumSplitDepth; }
   int size() const { return activeThreads; }
 
-  void set_size(int cnt);
+  void wake_up();
+  void sleep();
   void read_uci_options();
   bool available_slave_exists(int master) const;
   void set_timer(int msec);

diff --git a/src/ucioption.cpp b/src/ucioption.cpp
index df73670..4be580f 100644 (file)
--- a/src/ucioption.cpp
+++ b/src/ucioption.cpp
@@ -73,7 +73,7 @@ OptionsMap::OptionsMap() {
   o["Cowardice"]                   = UCIOption(100, 0, 200, on_eval);
   o["Min Split Depth"]             = UCIOption(msd, 4, 7, on_threads);
   o["Max Threads per Split Point"] = UCIOption(5, 4, 8, on_threads);
-  o["Threads"]                     = UCIOption(cpus, 1, MAX_THREADS);
+  o["Threads"]                     = UCIOption(cpus, 1, MAX_THREADS, on_threads);
   o["Use Sleeping Threads"]        = UCIOption(true, on_threads);
   o["Hash"]                        = UCIOption(32, 4, 8192, on_hash_size);
   o["Clear Hash"]                  = UCIOption(on_clear_hash);