From e5ffe9959c40a5ec6c4bca83a5a48070cae7fa5b Mon Sep 17 00:00:00 2001
From: Marco Costalba <mcostalba@gmail.com>
Date: Mon, 8 Aug 2011 23:07:09 +0100
Subject: [PATCH] Retire ThreadsManager::init_hash_tables()

Allocation of pawn and material hash tables should
be strictly bounded to the change of the number of
activeThreads, so move the code inside set_size().

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
---
 src/search.cpp |  4 +---
 src/thread.cpp | 36 +++++++++++++++---------------------
 src/thread.h   |  1 -
 3 files changed, 16 insertions(+), 25 deletions(-)

diff --git a/src/search.cpp b/src/search.cpp
index 9992049e..4cce6a91 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -409,9 +409,7 @@ bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]) {
   read_evaluation_uci_options(pos.side_to_move());
   Threads.read_uci_options();
 
-  // Allocate pawn and material hash tables if number of active threads
-  // increased and set a new TT size if changed.
-  Threads.init_hash_tables();
+  // Set a new TT size if changed
   TT.set_size(Options["Hash"].value<int>());
 
   if (Options["Clear Hash"].value<bool>())
diff --git a/src/thread.cpp b/src/thread.cpp
index a8e26b9f..1f01537f 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -27,7 +27,7 @@ ThreadsManager Threads; // Global object definition
 namespace { extern "C" {
 
  // start_routine() is the C function which is called when a new thread
- // is launched. It simply calls idle_loop() with the supplied threadID.
+ // is launched. It simply calls idle_loop() of the supplied threadID.
  // There are two versions of this function; one for POSIX threads and
  // one for Windows threads.
 
@@ -126,7 +126,20 @@ void ThreadsManager::set_size(int cnt) {
   activeThreads = cnt;
 
   for (int i = 0; i < MAX_THREADS; i++)
-      threads[i].do_sleep = !(i < activeThreads);
+      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 as, for instance, on mobile
+          // devices where memory is scarce and allocating for MAX_THREADS could
+          // even result in a crash.
+          threads[i].pawnTable.init();
+          threads[i].materialTable.init();
+
+          threads[i].do_sleep = false;
+      }
+      else
+          threads[i].do_sleep = true;
 }
 
 
@@ -140,9 +153,6 @@ void ThreadsManager::init() {
   threads[0].state = Thread::SEARCHING;
   threads[0].threadID = 0;
 
-  // Allocate pawn and material hash tables for main thread
-  init_hash_tables();
-
   // Initialize threads lock, used when allocating slaves during splitting
   lock_init(&threadsLock);
 
@@ -211,22 +221,6 @@ void ThreadsManager::exit() {
 }
 
 
-// init_hash_tables() dynamically allocates 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 as, for instance,
-// on mobile devices where memory is scarce and allocating for MAX_THREADS
-// threads could even result in a crash.
-
-void ThreadsManager::init_hash_tables() {
-
-  for (int i = 0; i < activeThreads; i++)
-  {
-      threads[i].pawnTable.init();
-      threads[i].materialTable.init();
-  }
-}
-
-
 // available_slave_exists() tries to find an idle thread which is available as
 // a slave for the thread with threadID "master".
 
diff --git a/src/thread.h b/src/thread.h
index 5325debe..574c5964 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -111,7 +111,6 @@ public:
   Thread& operator[](int threadID) { return threads[threadID]; }
   void init();
   void exit();
-  void init_hash_tables();
 
   bool use_sleeping_threads() const { return useSleepingThreads; }
   int min_split_depth() const { return minimumSplitDepth; }
-- 
2.39.2