X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=ab9bcca3b781376cb1a5cef4dbb9eccfb1bdba9d;hp=22bc0156705121a9a02adfcd8b59c1ff66e21997;hb=80810e4951f9447fd2b92faf56d01b60e6abd1a3;hpb=8a504d36f9b740c6d4c5bba6855148c5be40556e

diff --git a/src/search.cpp b/src/search.cpp
index 22bc0156..ab9bcca3 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -53,23 +53,61 @@ namespace {
 
   /// Types
 
-  // The BetaCounterType class is used to order moves at ply one.
-  // Apart for the first one that has its score, following moves
-  // normally have score -VALUE_INFINITE, so are ordered according
-  // to the number of beta cutoffs occurred under their subtree during
-  // the last iteration. The counters are per thread variables to avoid
-  // concurrent accessing under SMP case.
-
-  struct BetaCounterType {
-
-    BetaCounterType();
-    void clear();
-    void add(Color us, Depth d, int threadID);
-    void read(Color us, int64_t& our, int64_t& their);
+
+  // ThreadsManager class is used to handle all the threads related stuff in search,
+  // init, starting, parking and, the most important, launching a slave thread at a
+  // split point are what this class does. All the access to shared thread data is
+  // done through this class, so that we avoid using global variables instead.
+
+  class ThreadsManager {
+    /* As long as the single ThreadsManager object is defined as a global we don't
+       need to explicitly initialize to zero its data members because variables with
+       static storage duration are automatically set to zero before enter main()
+    */
+  public:
+    void init_threads();
+    void exit_threads();
+
+    int active_threads() const { return ActiveThreads; }
+    void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; }
+    void incrementNodeCounter(int threadID) { threads[threadID].nodes++; }
+    void incrementBetaCounter(Color us, Depth d, int threadID) { threads[threadID].betaCutOffs[us] += unsigned(d); }
+    void print_current_line(SearchStack ss[], int ply, int threadID);
+
+    void resetNodeCounters();
+    void resetBetaCounters();
+    int64_t nodes_searched() const;
+    void get_beta_counters(Color us, int64_t& our, int64_t& their) const;
+    bool available_thread_exists(int master) const;
+    bool thread_is_available(int slave, int master) const;
+    bool thread_should_stop(int threadID) const;
+    void wake_sleeping_threads();
+    void put_threads_to_sleep();
+    void idle_loop(int threadID, SplitPoint* waitSp);
+    bool split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue,
+               const Value futilityValue, Depth depth, int* moves, MovePicker* mp, int master, bool pvNode);
+
+  private:
+    friend void poll();
+
+    int ActiveThreads;
+    volatile bool AllThreadsShouldExit, AllThreadsShouldSleep;
+    Thread threads[MAX_THREADS];
+    SplitPoint SplitPointStack[MAX_THREADS][ACTIVE_SPLIT_POINTS_MAX];
+
+    Lock MPLock, IOLock;
+
+#if !defined(_MSC_VER)
+    pthread_cond_t WaitCond;
+    pthread_mutex_t WaitLock;
+#else
+    HANDLE SitIdleEvent[MAX_THREADS];
+#endif
+
   };
 
 
-  // The RootMove class is used for moves at the root at the tree. For each
+  // RootMove struct is used for moves at the root at the tree. For each
   // root move, we store a score, a node count, and a PV (really a refutation
   // in the case of moves which fail low).
 
@@ -184,7 +222,6 @@ namespace {
 
   // Iteration counters
   int Iteration;
-  BetaCounterType BetaCounter;
 
   // Scores and number of times the best move changed for each iteration
   Value ValueByIteration[PLY_MAX_PLUS_2];
@@ -213,21 +250,9 @@ namespace {
   std::ofstream LogFile;
 
   // MP related variables
-  int ActiveThreads = 1;
   Depth MinimumSplitDepth;
   int MaxThreadsPerSplitPoint;
-  Thread Threads[THREAD_MAX];
-  Lock MPLock;
-  Lock IOLock;
-  bool AllThreadsShouldExit, AllThreadsShouldSleep;
-  SplitPoint SplitPointStack[THREAD_MAX][ACTIVE_SPLIT_POINTS_MAX];
-
-#if !defined(_MSC_VER)
-  pthread_cond_t WaitCond;
-  pthread_mutex_t WaitLock;
-#else
-  HANDLE SitIdleEvent[THREAD_MAX];
-#endif
+  ThreadsManager TM;
 
   // Node counters, used only by thread[0] but try to keep in different
   // cache lines (64 bytes each) from the heavy SMP read accessed variables.
@@ -265,22 +290,9 @@ namespace {
   int nps();
   void poll();
   void ponderhit();
-  void print_current_line(SearchStack ss[], int ply, int threadID);
   void wait_for_stop_or_ponderhit();
   void init_ss_array(SearchStack ss[]);
 
-  void idle_loop(int threadID, SplitPoint* waitSp);
-  void init_split_point_stack();
-  void destroy_split_point_stack();
-  bool thread_should_stop(int threadID);
-  bool thread_is_available(int slave, int master);
-  bool idle_thread_exists(int master);
-  bool split(const Position& pos, SearchStack* ss, int ply,
-             Value *alpha, Value *beta, Value *bestValue,
-             const Value futilityValue, Depth depth, int *moves,
-             MovePicker *mp, int master, bool pvNode);
-  void wake_sleeping_threads();
-
 #if !defined(_MSC_VER)
   void *init_thread(void *threadID);
 #else
@@ -294,6 +306,13 @@ namespace {
 //// Functions
 ////
 
+/// init_threads(), exit_threads() and nodes_searched() are helpers to
+/// give accessibility to some TM methods from outside of current file.
+
+void init_threads() { TM.init_threads(); }
+void exit_threads() { TM.exit_threads(); }
+int64_t nodes_searched() { return TM.nodes_searched(); }
+
 
 /// perft() is our utility to verify move generation is bug free. All the legal
 /// moves up to given depth are generated and counted and the sum returned.
@@ -335,7 +354,7 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
            int maxNodes, int maxTime, Move searchMoves[]) {
 
   // Initialize global search variables
-  AllThreadsShouldSleep = StopOnPonderhit = AbortSearch = Quit = false;
+  StopOnPonderhit = AbortSearch = Quit = false;
   AspirationFailLow = false;
   NodesSincePoll = 0;
   SearchStartTime = get_system_time();
@@ -364,10 +383,7 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
       }
   }
 
-  for (int i = 0; i < THREAD_MAX; i++)
-  {
-      Threads[i].nodes = 0ULL;
-  }
+  TM.resetNodeCounters();
 
   if (button_was_pressed("New Game"))
       loseOnTime = false; // Reset at the beginning of a new game
@@ -413,10 +429,10 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
 
   // Set the number of active threads
   int newActiveThreads = get_option_value_int("Threads");
-  if (newActiveThreads != ActiveThreads)
+  if (newActiveThreads != TM.active_threads())
   {
-      ActiveThreads = newActiveThreads;
-      init_eval(ActiveThreads);
+      TM.set_active_threads(newActiveThreads);
+      init_eval(TM.active_threads());
       // HACK: init_eval() destroys the static castleRightsMask[] array in the
       // Position class. The below line repairs the damage.
       Position p(pos.to_fen());
@@ -424,10 +440,7 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
   }
 
   // Wake up sleeping threads
-  wake_sleeping_threads();
-
-  for (int i = 1; i < ActiveThreads; i++)
-      assert(thread_is_available(i, 0));
+  TM.wake_sleeping_threads();
 
   // Set thinking time
   int myTime = time[side_to_move];
@@ -521,7 +534,8 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
   if (UseLogFile)
       LogFile.close();
 
-  AllThreadsShouldSleep = true;
+  TM.put_threads_to_sleep();
+
   return !Quit;
 }
 
@@ -553,95 +567,6 @@ void init_search() {
 }
 
 
-/// init_threads() is called during startup. It launches all helper threads,
-/// and initializes the split point stack and the global locks and condition
-/// objects.
-
-void init_threads() {
-
-  volatile int i;
-  bool ok;
-
-#if !defined(_MSC_VER)
-  pthread_t pthread[1];
-#endif
-
-  // Initialize global locks
-  lock_init(&MPLock, NULL);
-  lock_init(&IOLock, NULL);
-
-  init_split_point_stack();
-
-#if !defined(_MSC_VER)
-  pthread_mutex_init(&WaitLock, NULL);
-  pthread_cond_init(&WaitCond, NULL);
-#else
-  for (i = 0; i < THREAD_MAX; i++)
-      SitIdleEvent[i] = CreateEvent(0, FALSE, FALSE, 0);
-#endif
-
-  // Will be set just before program exits to properly end the threads
-  AllThreadsShouldExit = false;
-
-  // Threads will be put to sleep as soon as created
-  AllThreadsShouldSleep = true;
-
-  // All threads except the main thread should be initialized to idle state
-  for (i = 1; i < THREAD_MAX; i++)
-      Threads[i].idle = true;
-
-  // Launch the helper threads
-  for (i = 1; i < THREAD_MAX; i++)
-  {
-#if !defined(_MSC_VER)
-      ok = (pthread_create(pthread, NULL, init_thread, (void*)(&i)) == 0);
-#else
-      DWORD iID[1];
-      ok = (CreateThread(NULL, 0, init_thread, (LPVOID)(&i), 0, iID) != NULL);
-#endif
-
-      if (!ok)
-      {
-          cout << "Failed to create thread number " << i << endl;
-          Application::exit_with_failure();
-      }
-
-      // Wait until the thread has finished launching
-      while (!Threads[i].running);
-  }
-}
-
-
-/// stop_threads() is called when the program exits. It makes all the
-/// helper threads exit cleanly.
-
-void stop_threads() {
-
-  ActiveThreads = THREAD_MAX;  // HACK
-  AllThreadsShouldSleep = false;  // HACK
-  wake_sleeping_threads();
-  AllThreadsShouldExit = true;
-  for (int i = 1; i < THREAD_MAX; i++)
-  {
-      Threads[i].stop = true;
-      while (Threads[i].running);
-  }
-  destroy_split_point_stack();
-}
-
-
-/// nodes_searched() returns the total number of nodes searched so far in
-/// the current search.
-
-int64_t nodes_searched() {
-
-  int64_t result = 0ULL;
-  for (int i = 0; i < ActiveThreads; i++)
-      result += Threads[i].nodes;
-  return result;
-}
-
-
 // SearchStack::init() initializes a search stack. Used at the beginning of a
 // new search from the root.
 void SearchStack::init(int ply) {
@@ -688,7 +613,7 @@ namespace {
     cout << "info depth " << 1 << "\ninfo depth " << 1
          << " score " << value_to_string(rml.get_move_score(0))
          << " time " << current_search_time()
-         << " nodes " << nodes_searched()
+         << " nodes " << TM.nodes_searched()
          << " nps " << nps()
          << " pv " << rml.get_move(0) << "\n";
 
@@ -771,7 +696,7 @@ namespace {
                 stopSearch = true;
 
             // Stop search early if one move seems to be much better than the rest
-            int64_t nodes = nodes_searched();
+            int64_t nodes = TM.nodes_searched();
             if (   Iteration >= 8
                 && EasyMove == ss[0].pv[0]
                 && (  (   rml.get_move_cumulative_nodes(0) > (nodes * 85) / 100
@@ -812,7 +737,7 @@ namespace {
         wait_for_stop_or_ponderhit();
     else
         // Print final search statistics
-        cout << "info nodes " << nodes_searched()
+        cout << "info nodes " << TM.nodes_searched()
              << " nps " << nps()
              << " time " << current_search_time()
              << " hashfull " << TT.full() << endl;
@@ -837,7 +762,7 @@ namespace {
         if (dbg_show_hit_rate)
             dbg_print_hit_rate(LogFile);
 
-        LogFile << "\nNodes: " << nodes_searched()
+        LogFile << "\nNodes: " << TM.nodes_searched()
                 << "\nNodes/second: " << nps()
                 << "\nBest move: " << move_to_san(p, ss[0].pv[0]);
 
@@ -888,10 +813,10 @@ namespace {
             RootMoveNumber = i + 1;
 
             // Save the current node count before the move is searched
-            nodes = nodes_searched();
+            nodes = TM.nodes_searched();
 
             // Reset beta cut-off counters
-            BetaCounter.clear();
+            TM.resetBetaCounters();
 
             // Pick the next root move, and print the move and the move number to
             // the standard output.
@@ -972,7 +897,7 @@ namespace {
                      << ((value >= beta) ? " lowerbound" :
                         ((value <= alpha)? " upperbound" : ""))
                      << " time "  << current_search_time()
-                     << " nodes " << nodes_searched()
+                     << " nodes " << TM.nodes_searched()
                      << " nps "   << nps()
                      << " pv ";
 
@@ -987,7 +912,7 @@ namespace {
                                     : (value <= alpha ? VALUE_TYPE_UPPER : VALUE_TYPE_EXACT));
 
                     LogFile << pretty_pv(pos, current_search_time(), Iteration,
-                                         nodes_searched(), value, type, ss[0].pv) << endl;
+                                         TM.nodes_searched(), value, type, ss[0].pv) << endl;
                 }
 
                 // Prepare for a research after a fail high, each time with a wider window
@@ -1007,9 +932,9 @@ namespace {
             // Remember beta-cutoff and searched nodes counts for this move. The
             // info is used to sort the root moves at the next iteration.
             int64_t our, their;
-            BetaCounter.read(pos.side_to_move(), our, their);
+            TM.get_beta_counters(pos.side_to_move(), our, their);
             rml.set_beta_counters(i, our, their);
-            rml.set_move_nodes(i, nodes_searched() - nodes);
+            rml.set_move_nodes(i, TM.nodes_searched() - nodes);
 
             assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
 
@@ -1039,7 +964,7 @@ namespace {
                          << ((value >= beta) ? " lowerbound" :
                             ((value <= alpha)? " upperbound" : ""))
                          << " time "  << current_search_time()
-                         << " nodes " << nodes_searched()
+                         << " nodes " << TM.nodes_searched()
                          << " nps "   << nps()
                          << " pv ";
 
@@ -1054,7 +979,7 @@ namespace {
                                         : (value <= alpha ? VALUE_TYPE_UPPER : VALUE_TYPE_EXACT));
 
                         LogFile << pretty_pv(pos, current_search_time(), Iteration,
-                                             nodes_searched(), value, type, ss[0].pv) << endl;
+                                             TM.nodes_searched(), value, type, ss[0].pv) << endl;
                     }
                     if (value > alpha)
                         alpha = value;
@@ -1068,7 +993,7 @@ namespace {
                              << " score " << value_to_string(rml.get_move_score(j))
                              << " depth " << ((j <= i)? Iteration : Iteration - 1)
                              << " time " << current_search_time()
-                             << " nodes " << nodes_searched()
+                             << " nodes " << TM.nodes_searched()
                              << " nps " << nps()
                              << " pv ";
 
@@ -1112,7 +1037,7 @@ namespace {
     assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
     assert(beta > alpha && beta <= VALUE_INFINITE);
     assert(ply >= 0 && ply < PLY_MAX);
-    assert(threadID >= 0 && threadID < ActiveThreads);
+    assert(threadID >= 0 && threadID < TM.active_threads());
 
     Move movesSearched[256];
     StateInfo st;
@@ -1132,7 +1057,7 @@ namespace {
     init_node(ss, ply, threadID);
 
     // After init_node() that calls poll()
-    if (AbortSearch || thread_should_stop(threadID))
+    if (AbortSearch || TM.thread_should_stop(threadID))
         return Value(0);
 
     if (pos.is_draw() || ply >= PLY_MAX - 1)
@@ -1187,7 +1112,7 @@ namespace {
     // occurs.
     while (   alpha < beta
            && (move = mp.get_next_move()) != MOVE_NONE
-           && !thread_should_stop(threadID))
+           && !TM.thread_should_stop(threadID))
     {
       assert(move_is_ok(move));
 
@@ -1275,15 +1200,15 @@ namespace {
       }
 
       // Split?
-      if (   ActiveThreads > 1
+      if (   TM.active_threads() > 1
           && bestValue < beta
           && depth >= MinimumSplitDepth
           && Iteration <= 99
-          && idle_thread_exists(threadID)
+          && TM.available_thread_exists(threadID)
           && !AbortSearch
-          && !thread_should_stop(threadID)
-          && split(pos, ss, ply, &alpha, &beta, &bestValue, VALUE_NONE,
-                   depth, &moveCount, &mp, threadID, true))
+          && !TM.thread_should_stop(threadID)
+          && TM.split(pos, ss, ply, &alpha, beta, &bestValue, VALUE_NONE,
+                      depth, &moveCount, &mp, threadID, true))
           break;
     }
 
@@ -1294,7 +1219,7 @@ namespace {
 
     // If the search is not aborted, update the transposition table,
     // history counters, and killer moves.
-    if (AbortSearch || thread_should_stop(threadID))
+    if (AbortSearch || TM.thread_should_stop(threadID))
         return bestValue;
 
     if (bestValue <= oldAlpha)
@@ -1302,7 +1227,7 @@ namespace {
 
     else if (bestValue >= beta)
     {
-        BetaCounter.add(pos.side_to_move(), depth, threadID);
+        TM.incrementBetaCounter(pos.side_to_move(), depth, threadID);
         move = ss[ply].pv[ply];
         if (!pos.move_is_capture_or_promotion(move))
         {
@@ -1325,7 +1250,7 @@ namespace {
 
     assert(beta >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
     assert(ply >= 0 && ply < PLY_MAX);
-    assert(threadID >= 0 && threadID < ActiveThreads);
+    assert(threadID >= 0 && threadID < TM.active_threads());
 
     Move movesSearched[256];
     EvalInfo ei;
@@ -1347,7 +1272,7 @@ namespace {
     init_node(ss, ply, threadID);
 
     // After init_node() that calls poll()
-    if (AbortSearch || thread_should_stop(threadID))
+    if (AbortSearch || TM.thread_should_stop(threadID))
         return Value(0);
 
     if (pos.is_draw() || ply >= PLY_MAX - 1)
@@ -1405,7 +1330,7 @@ namespace {
         && !isCheck
         && !value_is_mate(beta)
         &&  ok_to_do_nullmove(pos)
-        &&  staticValue >= beta - NullMoveMargin)
+        &&  staticValue >= beta - (depth >= 4 * OnePly ? NullMoveMargin : 0))
     {
         ss[ply].currentMove = MOVE_NULL;
 
@@ -1480,7 +1405,7 @@ namespace {
     // Loop through all legal moves until no moves remain or a beta cutoff occurs
     while (   bestValue < beta
            && (move = mp.get_next_move()) != MOVE_NONE
-           && !thread_should_stop(threadID))
+           && !TM.thread_should_stop(threadID))
     {
       assert(move_is_ok(move));
 
@@ -1589,15 +1514,15 @@ namespace {
       }
 
       // Split?
-      if (   ActiveThreads > 1
+      if (   TM.active_threads() > 1
           && bestValue < beta
           && depth >= MinimumSplitDepth
           && Iteration <= 99
-          && idle_thread_exists(threadID)
+          && TM.available_thread_exists(threadID)
           && !AbortSearch
-          && !thread_should_stop(threadID)
-          && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue
-                   depth, &moveCount, &mp, threadID, false))
+          && !TM.thread_should_stop(threadID)
+          && TM.split(pos, ss, ply, NULL, beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue
+                      depth, &moveCount, &mp, threadID, false))
           break;
     }
 
@@ -1608,14 +1533,14 @@ namespace {
 
     // If the search is not aborted, update the transposition table,
     // history counters, and killer moves.
-    if (AbortSearch || thread_should_stop(threadID))
+    if (AbortSearch || TM.thread_should_stop(threadID))
         return bestValue;
 
     if (bestValue < beta)
         TT.store(posKey, value_to_tt(bestValue, ply), VALUE_TYPE_UPPER, depth, MOVE_NONE);
     else
     {
-        BetaCounter.add(pos.side_to_move(), depth, threadID);
+        TM.incrementBetaCounter(pos.side_to_move(), depth, threadID);
         move = ss[ply].pv[ply];
         TT.store(posKey, value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, move);
         if (!pos.move_is_capture_or_promotion(move))
@@ -1643,7 +1568,7 @@ namespace {
     assert(beta >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
     assert(depth <= 0);
     assert(ply >= 0 && ply < PLY_MAX);
-    assert(threadID >= 0 && threadID < ActiveThreads);
+    assert(threadID >= 0 && threadID < TM.active_threads());
 
     EvalInfo ei;
     StateInfo st;
@@ -1660,7 +1585,7 @@ namespace {
     init_node(ss, ply, threadID);
 
     // After init_node() that calls poll()
-    if (AbortSearch || thread_should_stop(threadID))
+    if (AbortSearch || TM.thread_should_stop(threadID))
         return Value(0);
 
     if (pos.is_draw() || ply >= PLY_MAX - 1)
@@ -1766,6 +1691,7 @@ namespace {
 
       // Don't search moves with negative SEE values
       if (   (!isCheck || evasionPrunable)
+          && !pvNode
           &&  move != ttMove
           && !move_is_promotion(move)
           &&  pos.see_sign(move) < 0)
@@ -1832,8 +1758,8 @@ namespace {
 
   void sp_search(SplitPoint* sp, int threadID) {
 
-    assert(threadID >= 0 && threadID < ActiveThreads);
-    assert(ActiveThreads > 1);
+    assert(threadID >= 0 && threadID < TM.active_threads());
+    assert(TM.active_threads() > 1);
 
     Position pos(*sp->pos);
     CheckInfo ci(pos);
@@ -1847,7 +1773,7 @@ namespace {
 
     while (    lock_grab_bool(&(sp->lock))
            &&  sp->bestValue < sp->beta
-           && !thread_should_stop(threadID)
+           && !TM.thread_should_stop(threadID)
            && (move = sp->mp->get_next_move()) != MOVE_NONE)
     {
       moveCount = ++sp->moves;
@@ -1922,27 +1848,17 @@ namespace {
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
-      if (thread_should_stop(threadID))
-      {
-          lock_grab(&(sp->lock));
-          break;
-      }
-
       // New best move?
       if (value > sp->bestValue) // Less then 2% of cases
       {
           lock_grab(&(sp->lock));
-          if (value > sp->bestValue && !thread_should_stop(threadID))
+          if (value > sp->bestValue && !TM.thread_should_stop(threadID))
           {
               sp->bestValue = value;
               if (sp->bestValue >= sp->beta)
               {
+                  sp->stopRequest = true;
                   sp_update_pv(sp->parentSstack, ss, sp->ply);
-                  for (int i = 0; i < ActiveThreads; i++)
-                      if (i != threadID && (i == sp->master || sp->slaves[i]))
-                          Threads[i].stop = true;
-
-                  sp->finished = true;
               }
           }
           lock_release(&(sp->lock));
@@ -1951,13 +1867,6 @@ namespace {
 
     /* Here we have the lock still grabbed */
 
-    // If this is the master thread and we have been asked to stop because of
-    // a beta cutoff higher up in the tree, stop all slave threads.
-    if (sp->master == threadID && thread_should_stop(threadID))
-        for (int i = 0; i < ActiveThreads; i++)
-            if (sp->slaves[i])
-                Threads[i].stop = true;
-
     sp->cpus--;
     sp->slaves[threadID] = 0;
 
@@ -1975,8 +1884,8 @@ namespace {
 
   void sp_search_pv(SplitPoint* sp, int threadID) {
 
-    assert(threadID >= 0 && threadID < ActiveThreads);
-    assert(ActiveThreads > 1);
+    assert(threadID >= 0 && threadID < TM.active_threads());
+    assert(TM.active_threads() > 1);
 
     Position pos(*sp->pos);
     CheckInfo ci(pos);
@@ -1987,7 +1896,7 @@ namespace {
 
     while (    lock_grab_bool(&(sp->lock))
            &&  sp->alpha < sp->beta
-           && !thread_should_stop(threadID)
+           && !TM.thread_should_stop(threadID)
            && (move = sp->mp->get_next_move()) != MOVE_NONE)
     {
       moveCount = ++sp->moves;
@@ -2041,37 +1950,25 @@ namespace {
               if (localAlpha < sp->beta)
                   value = -search_pv(pos, ss, -sp->beta, -localAlpha, newDepth, sp->ply+1, threadID);
               else
-                  assert(thread_should_stop(threadID));
+                  assert(TM.thread_should_stop(threadID));
         }
       }
       pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
-      if (thread_should_stop(threadID))
-      {
-          lock_grab(&(sp->lock));
-          break;
-      }
-
       // New best move?
       if (value > sp->bestValue) // Less then 2% of cases
       {
           lock_grab(&(sp->lock));
-          if (value > sp->bestValue && !thread_should_stop(threadID))
+          if (value > sp->bestValue && !TM.thread_should_stop(threadID))
           {
               sp->bestValue = value;
               if (value > sp->alpha)
               {
                   // Ask threads to stop before to modify sp->alpha
                   if (value >= sp->beta)
-                  {
-                      for (int i = 0; i < ActiveThreads; i++)
-                          if (i != threadID && (i == sp->master || sp->slaves[i]))
-                              Threads[i].stop = true;
-
-                      sp->finished = true;
-                  }
+                      sp->stopRequest = true;
 
                   sp->alpha = value;
 
@@ -2086,137 +1983,12 @@ namespace {
 
     /* Here we have the lock still grabbed */
 
-    // If this is the master thread and we have been asked to stop because of
-    // a beta cutoff higher up in the tree, stop all slave threads.
-    if (sp->master == threadID && thread_should_stop(threadID))
-        for (int i = 0; i < ActiveThreads; i++)
-            if (sp->slaves[i])
-                Threads[i].stop = true;
-
     sp->cpus--;
     sp->slaves[threadID] = 0;
 
     lock_release(&(sp->lock));
   }
 
-  /// The BetaCounterType class
-
-  BetaCounterType::BetaCounterType() { clear(); }
-
-  void BetaCounterType::clear() {
-
-    for (int i = 0; i < THREAD_MAX; i++)
-        Threads[i].betaCutOffs[WHITE] = Threads[i].betaCutOffs[BLACK] = 0ULL;
-  }
-
-  void BetaCounterType::add(Color us, Depth d, int threadID) {
-
-    // Weighted count based on depth
-    Threads[threadID].betaCutOffs[us] += unsigned(d);
-  }
-
-  void BetaCounterType::read(Color us, int64_t& our, int64_t& their) {
-
-    our = their = 0UL;
-    for (int i = 0; i < THREAD_MAX; i++)
-    {
-        our += Threads[i].betaCutOffs[us];
-        their += Threads[i].betaCutOffs[opposite_color(us)];
-    }
-  }
-
-
-  /// The RootMoveList class
-
-  // RootMoveList c'tor
-
-  RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) : count(0) {
-
-    SearchStack ss[PLY_MAX_PLUS_2];
-    MoveStack mlist[MaxRootMoves];
-    StateInfo st;
-    bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
-
-    // Generate all legal moves
-    MoveStack* last = generate_moves(pos, mlist);
-
-    // Add each move to the moves[] array
-    for (MoveStack* cur = mlist; cur != last; cur++)
-    {
-        bool includeMove = includeAllMoves;
-
-        for (int k = 0; !includeMove && searchMoves[k] != MOVE_NONE; k++)
-            includeMove = (searchMoves[k] == cur->move);
-
-        if (!includeMove)
-            continue;
-
-        // Find a quick score for the move
-        init_ss_array(ss);
-        pos.do_move(cur->move, st);
-        moves[count].move = cur->move;
-        moves[count].score = -qsearch(pos, ss, -VALUE_INFINITE, VALUE_INFINITE, Depth(0), 1, 0);
-        moves[count].pv[0] = cur->move;
-        moves[count].pv[1] = MOVE_NONE;
-        pos.undo_move(cur->move);
-        count++;
-    }
-    sort();
-  }
-
-
-  // RootMoveList simple methods definitions
-
-  void RootMoveList::set_move_nodes(int moveNum, int64_t nodes) {
-
-    moves[moveNum].nodes = nodes;
-    moves[moveNum].cumulativeNodes += nodes;
-  }
-
-  void RootMoveList::set_beta_counters(int moveNum, int64_t our, int64_t their) {
-
-    moves[moveNum].ourBeta = our;
-    moves[moveNum].theirBeta = their;
-  }
-
-  void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
-
-    int j;
-
-    for (j = 0; pv[j] != MOVE_NONE; j++)
-        moves[moveNum].pv[j] = pv[j];
-
-    moves[moveNum].pv[j] = MOVE_NONE;
-  }
-
-
-  // RootMoveList::sort() sorts the root move list at the beginning of a new
-  // iteration.
-
-  void RootMoveList::sort() {
-
-    sort_multipv(count - 1); // Sort all items
-  }
-
-
-  // RootMoveList::sort_multipv() sorts the first few moves in the root move
-  // list by their scores and depths. It is used to order the different PVs
-  // correctly in MultiPV mode.
-
-  void RootMoveList::sort_multipv(int n) {
-
-    int i,j;
-
-    for (i = 1; i <= n; i++)
-    {
-        RootMove rm = moves[i];
-        for (j = i; j > 0 && moves[j - 1] < rm; j--)
-            moves[j] = moves[j - 1];
-
-        moves[j] = rm;
-    }
-  }
-
 
   // init_node() is called at the beginning of all the search functions
   // (search(), search_pv(), qsearch(), and so on) and initializes the
@@ -2227,9 +1999,9 @@ namespace {
   void init_node(SearchStack ss[], int ply, int threadID) {
 
     assert(ply >= 0 && ply < PLY_MAX);
-    assert(threadID >= 0 && threadID < ActiveThreads);
+    assert(threadID >= 0 && threadID < TM.active_threads());
 
-    Threads[threadID].nodes++;
+    TM.incrementNodeCounter(threadID);
 
     if (threadID == 0)
     {
@@ -2242,9 +2014,7 @@ namespace {
     }
     ss[ply].init(ply);
     ss[ply + 2].initKillers();
-
-    if (Threads[threadID].printCurrentLine)
-        print_current_line(ss, ply, threadID);
+    TM.print_current_line(ss, ply, threadID);
   }
 
 
@@ -2594,7 +2364,7 @@ namespace {
   int nps() {
 
     int t = current_search_time();
-    return (t > 0 ? int((nodes_searched() * 1000) / t) : 0);
+    return (t > 0 ? int((TM.nodes_searched() * 1000) / t) : 0);
   }
 
 
@@ -2644,7 +2414,7 @@ namespace {
     else if (t - lastInfoTime >= 1000)
     {
         lastInfoTime = t;
-        lock_grab(&IOLock);
+        lock_grab(&TM.IOLock);
 
         if (dbg_show_mean)
             dbg_print_mean();
@@ -2652,13 +2422,13 @@ namespace {
         if (dbg_show_hit_rate)
             dbg_print_hit_rate();
 
-        cout << "info nodes " << nodes_searched() << " nps " << nps()
+        cout << "info nodes " << TM.nodes_searched() << " nps " << nps()
              << " time " << t << " hashfull " << TT.full() << endl;
 
-        lock_release(&IOLock);
+        lock_release(&TM.IOLock);
 
         if (ShowCurrentLine)
-            Threads[0].printCurrentLine = true;
+            TM.threads[0].printCurrentLineRequest = true;
     }
 
     // Should we stop the search?
@@ -2674,7 +2444,7 @@ namespace {
 
     if (   (Iteration >= 3 && UseTimeManagement && noMoreTime)
         || (ExactMaxTime && t >= ExactMaxTime)
-        || (Iteration >= 3 && MaxNodes && nodes_searched() >= MaxNodes))
+        || (Iteration >= 3 && MaxNodes && TM.nodes_searched() >= MaxNodes))
         AbortSearch = true;
   }
 
@@ -2700,30 +2470,6 @@ namespace {
   }
 
 
-  // print_current_line() prints the current line of search for a given
-  // thread. Called when the UCI option UCI_ShowCurrLine is 'true'.
-
-  void print_current_line(SearchStack ss[], int ply, int threadID) {
-
-    assert(ply >= 0 && ply < PLY_MAX);
-    assert(threadID >= 0 && threadID < ActiveThreads);
-
-    if (!Threads[threadID].idle)
-    {
-        lock_grab(&IOLock);
-        cout << "info currline " << (threadID + 1);
-        for (int p = 0; p < ply; p++)
-            cout << " " << ss[p].currentMove;
-
-        cout << endl;
-        lock_release(&IOLock);
-    }
-    Threads[threadID].printCurrentLine = false;
-    if (threadID + 1 < ActiveThreads)
-        Threads[threadID + 1].printCurrentLine = true;
-  }
-
-
   // init_ss_array() does a fast reset of the first entries of a SearchStack array
 
   void init_ss_array(SearchStack ss[]) {
@@ -2763,113 +2509,240 @@ namespace {
   }
 
 
+  // init_thread() is the function which is called when a new thread is
+  // launched. It simply calls the idle_loop() function with the supplied
+  // threadID. There are two versions of this function; one for POSIX
+  // threads and one for Windows threads.
+
+#if !defined(_MSC_VER)
+
+  void* init_thread(void *threadID) {
+
+    TM.idle_loop(*(int*)threadID, NULL);
+    return NULL;
+  }
+
+#else
+
+  DWORD WINAPI init_thread(LPVOID threadID) {
+
+    TM.idle_loop(*(int*)threadID, NULL);
+    return NULL;
+  }
+
+#endif
+
+
+  /// The ThreadsManager class
+
+  // resetNodeCounters(), resetBetaCounters(), searched_nodes() and
+  // get_beta_counters() are getters/setters for the per thread
+  // counters used to sort the moves at root.
+
+  void ThreadsManager::resetNodeCounters() {
+
+    for (int i = 0; i < MAX_THREADS; i++)
+        threads[i].nodes = 0ULL;
+  }
+
+  void ThreadsManager::resetBetaCounters() {
+
+    for (int i = 0; i < MAX_THREADS; i++)
+        threads[i].betaCutOffs[WHITE] = threads[i].betaCutOffs[BLACK] = 0ULL;
+  }
+
+  int64_t ThreadsManager::nodes_searched() const {
+
+    int64_t result = 0ULL;
+    for (int i = 0; i < ActiveThreads; i++)
+        result += threads[i].nodes;
+
+    return result;
+  }
+
+  void ThreadsManager::get_beta_counters(Color us, int64_t& our, int64_t& their) const {
+
+    our = their = 0UL;
+    for (int i = 0; i < MAX_THREADS; i++)
+    {
+        our += threads[i].betaCutOffs[us];
+        their += threads[i].betaCutOffs[opposite_color(us)];
+    }
+  }
+
+
   // idle_loop() is where the threads are parked when they have no work to do.
   // The parameter "waitSp", if non-NULL, is a pointer to an active SplitPoint
   // object for which the current thread is the master.
 
-  void idle_loop(int threadID, SplitPoint* waitSp) {
-
-    assert(threadID >= 0 && threadID < THREAD_MAX);
+  void ThreadsManager::idle_loop(int threadID, SplitPoint* waitSp) {
 
-    Threads[threadID].running = true;
+    assert(threadID >= 0 && threadID < MAX_THREADS);
 
-    while (!AllThreadsShouldExit || threadID == 0)
+    while (true)
     {
+        // Slave threads can exit as soon as AllThreadsShouldExit raises,
+        // master should exit as last one.
+        if (AllThreadsShouldExit && !waitSp)
+        {
+            threads[threadID].state = THREAD_TERMINATED;
+            return;
+        }
+
         // If we are not thinking, wait for a condition to be signaled
         // instead of wasting CPU time polling for work.
         while (    threadID != 0
-               && !AllThreadsShouldExit
                && (AllThreadsShouldSleep || threadID >= ActiveThreads))
         {
-
-            Threads[threadID].sleeping = true;
+            threads[threadID].state = THREAD_SLEEPING;
 
 #if !defined(_MSC_VER)
             pthread_mutex_lock(&WaitLock);
-            if (Idle || threadID >= ActiveThreads)
+            if (AllThreadsShouldSleep || threadID >= ActiveThreads)
                 pthread_cond_wait(&WaitCond, &WaitLock);
-
             pthread_mutex_unlock(&WaitLock);
 #else
             WaitForSingleObject(SitIdleEvent[threadID], INFINITE);
 #endif
         }
 
-        // Out of the while loop to avoid races in case thread is woken up but
-        // while condition still holds true so that is put to sleep again.
-        Threads[threadID].sleeping = false;
+        // If thread has just woken up, mark it as available
+        if (threads[threadID].state == THREAD_SLEEPING)
+            threads[threadID].state = THREAD_AVAILABLE;
 
-      // If this thread has been assigned work, launch a search
-      if (Threads[threadID].workIsWaiting)
-      {
-          assert(!Threads[threadID].idle);
+        // If this thread has been assigned work, launch a search
+        if (threads[threadID].state == THREAD_WORKISWAITING)
+        {
+            assert(!AllThreadsShouldExit);
 
-          Threads[threadID].workIsWaiting = false;
-          if (Threads[threadID].splitPoint->pvNode)
-              sp_search_pv(Threads[threadID].splitPoint, threadID);
-          else
-              sp_search(Threads[threadID].splitPoint, threadID);
+            threads[threadID].state = THREAD_SEARCHING;
 
-          Threads[threadID].idle = true;
-      }
+            if (threads[threadID].splitPoint->pvNode)
+                sp_search_pv(threads[threadID].splitPoint, threadID);
+            else
+                sp_search(threads[threadID].splitPoint, threadID);
 
-      // If this thread is the master of a split point and all threads have
-      // finished their work at this split point, return from the idle loop.
-      if (waitSp != NULL && waitSp->cpus == 0)
-          return;
-    }
+            assert(threads[threadID].state == THREAD_SEARCHING);
 
-    Threads[threadID].running = false;
+            threads[threadID].state = THREAD_AVAILABLE;
+        }
+
+        // If this thread is the master of a split point and all threads have
+        // finished their work at this split point, return from the idle loop.
+        if (waitSp != NULL && waitSp->cpus == 0)
+        {
+            assert(threads[threadID].state == THREAD_AVAILABLE);
+
+            threads[threadID].state = THREAD_SEARCHING;
+            return;
+        }
+    }
   }
 
 
-  // init_split_point_stack() is called during program initialization, and
-  // initializes all split point objects.
+  // init_threads() is called during startup. It launches all helper threads,
+  // and initializes the split point stack and the global locks and condition
+  // objects.
 
-  void init_split_point_stack() {
+  void ThreadsManager::init_threads() {
 
-    for (int i = 0; i < THREAD_MAX; i++)
+    volatile int i;
+    bool ok;
+
+#if !defined(_MSC_VER)
+    pthread_t pthread[1];
+#endif
+
+    // Initialize global locks
+    lock_init(&MPLock, NULL);
+    lock_init(&IOLock, NULL);
+
+    // Initialize SplitPointStack locks
+    for (i = 0; i < MAX_THREADS; i++)
         for (int j = 0; j < ACTIVE_SPLIT_POINTS_MAX; j++)
         {
             SplitPointStack[i][j].parent = NULL;
             lock_init(&(SplitPointStack[i][j].lock), NULL);
         }
+
+#if !defined(_MSC_VER)
+    pthread_mutex_init(&WaitLock, NULL);
+    pthread_cond_init(&WaitCond, NULL);
+#else
+    for (i = 0; i < MAX_THREADS; i++)
+        SitIdleEvent[i] = CreateEvent(0, FALSE, FALSE, 0);
+#endif
+
+    // Will be set just before program exits to properly end the threads
+    AllThreadsShouldExit = false;
+
+    // Threads will be put to sleep as soon as created
+    AllThreadsShouldSleep = true;
+
+    // All threads except the main thread should be initialized to THREAD_AVAILABLE
+    ActiveThreads = 1;
+    threads[0].state = THREAD_SEARCHING;
+    for (i = 1; i < MAX_THREADS; i++)
+        threads[i].state = THREAD_AVAILABLE;
+
+    // Launch the helper threads
+    for (i = 1; i < MAX_THREADS; i++)
+    {
+
+#if !defined(_MSC_VER)
+        ok = (pthread_create(pthread, NULL, init_thread, (void*)(&i)) == 0);
+#else
+        DWORD iID[1];
+        ok = (CreateThread(NULL, 0, init_thread, (LPVOID)(&i), 0, iID) != NULL);
+#endif
+
+        if (!ok)
+        {
+            cout << "Failed to create thread number " << i << endl;
+            Application::exit_with_failure();
+        }
+
+        // Wait until the thread has finished launching and is gone to sleep
+        while (threads[i].state != THREAD_SLEEPING);
+    }
   }
 
 
-  // destroy_split_point_stack() is called when the program exits, and
-  // destroys all locks in the precomputed split point objects.
+  // exit_threads() is called when the program exits. It makes all the
+  // helper threads exit cleanly.
+
+  void ThreadsManager::exit_threads() {
+
+    ActiveThreads = MAX_THREADS;  // HACK
+    AllThreadsShouldSleep = true;  // HACK
+    wake_sleeping_threads();
 
-  void destroy_split_point_stack() {
+    // This makes the threads to exit idle_loop()
+    AllThreadsShouldExit = true;
 
-    for (int i = 0; i < THREAD_MAX; i++)
+    // Wait for thread termination
+    for (int i = 1; i < MAX_THREADS; i++)
+        while (threads[i].state != THREAD_TERMINATED);
+
+    // Now we can safely destroy the locks
+    for (int i = 0; i < MAX_THREADS; i++)
         for (int j = 0; j < ACTIVE_SPLIT_POINTS_MAX; j++)
             lock_destroy(&(SplitPointStack[i][j].lock));
   }
 
 
-  // thread_should_stop() checks whether the thread with a given threadID has
-  // been asked to stop, directly or indirectly. This can happen if a beta
-  // cutoff has occurred in the thread's currently active split point, or in
-  // some ancestor of the current split point.
+  // thread_should_stop() checks whether the thread should stop its search.
+  // This can happen if a beta cutoff has occurred in the thread's currently
+  // active split point, or in some ancestor of the current split point.
 
-  bool thread_should_stop(int threadID) {
+  bool ThreadsManager::thread_should_stop(int threadID) const {
 
     assert(threadID >= 0 && threadID < ActiveThreads);
 
     SplitPoint* sp;
 
-    if (Threads[threadID].stop)
-        return true;
-    if (ActiveThreads <= 2)
-        return false;
-    for (sp = Threads[threadID].splitPoint; sp != NULL; sp = sp->parent)
-        if (sp->finished)
-        {
-            Threads[threadID].stop = true;
-            return true;
-        }
-    return false;
+    for (sp = threads[threadID].splitPoint; sp && !sp->stopRequest; sp = sp->parent);
+    return sp != NULL;
   }
 
 
@@ -2881,17 +2754,17 @@ namespace {
   // threads which are busy searching the split point at the top of "slave"'s
   // split point stack (the "helpful master concept" in YBWC terminology).
 
-  bool thread_is_available(int slave, int master) {
+  bool ThreadsManager::thread_is_available(int slave, int master) const {
 
     assert(slave >= 0 && slave < ActiveThreads);
     assert(master >= 0 && master < ActiveThreads);
     assert(ActiveThreads > 1);
 
-    if (!Threads[slave].idle || slave == master)
+    if (threads[slave].state != THREAD_AVAILABLE || slave == master)
         return false;
 
     // Make a local copy to be sure doesn't change under our feet
-    int localActiveSplitPoints = Threads[slave].activeSplitPoints;
+    int localActiveSplitPoints = threads[slave].activeSplitPoints;
 
     if (localActiveSplitPoints == 0)
         // No active split points means that the thread is available as
@@ -2902,7 +2775,7 @@ namespace {
         return true;
 
     // Apply the "helpful master" concept if possible. Use localActiveSplitPoints
-    // that is known to be > 0, instead of Threads[slave].activeSplitPoints that
+    // that is known to be > 0, instead of threads[slave].activeSplitPoints that
     // could have been set to 0 by another thread leading to an out of bound access.
     if (SplitPointStack[slave][localActiveSplitPoints - 1].slaves[master])
         return true;
@@ -2911,10 +2784,10 @@ namespace {
   }
 
 
-  // idle_thread_exists() tries to find an idle thread which is available as
+  // available_thread_exists() tries to find an idle thread which is available as
   // a slave for the thread with threadID "master".
 
-  bool idle_thread_exists(int master) {
+  bool ThreadsManager::available_thread_exists(int master) const {
 
     assert(master >= 0 && master < ActiveThreads);
     assert(ActiveThreads > 1);
@@ -2939,16 +2812,18 @@ namespace {
   // threads have returned from sp_search_pv (or, equivalently, when
   // splitPoint->cpus becomes 0), split() returns true.
 
-  bool split(const Position& p, SearchStack* sstck, int ply,
-             Value* alpha, Value* beta, Value* bestValue, const Value futilityValue,
+  bool ThreadsManager::split(const Position& p, SearchStack* sstck, int ply,
+             Value* alpha, const Value beta, Value* bestValue, const Value futilityValue,
              Depth depth, int* moves, MovePicker* mp, int master, bool pvNode) {
 
     assert(p.is_ok());
     assert(sstck != NULL);
     assert(ply >= 0 && ply < PLY_MAX);
-    assert(*bestValue >= -VALUE_INFINITE && *bestValue <= *alpha);
-    assert(!pvNode || *alpha < *beta);
-    assert(*beta <= VALUE_INFINITE);
+    assert(*bestValue >= -VALUE_INFINITE);
+    assert(   ( pvNode && *bestValue <= *alpha)
+           || (!pvNode && *bestValue <   beta ));
+    assert(!pvNode || *alpha < beta);
+    assert(beta <= VALUE_INFINITE);
     assert(depth > Depth(0));
     assert(master >= 0 && master < ActiveThreads);
     assert(ActiveThreads > 1);
@@ -2959,24 +2834,23 @@ namespace {
 
     // If no other thread is available to help us, or if we have too many
     // active split points, don't split.
-    if (   !idle_thread_exists(master)
-        || Threads[master].activeSplitPoints >= ACTIVE_SPLIT_POINTS_MAX)
+    if (   !available_thread_exists(master)
+        || threads[master].activeSplitPoints >= ACTIVE_SPLIT_POINTS_MAX)
     {
         lock_release(&MPLock);
         return false;
     }
 
     // Pick the next available split point object from the split point stack
-    splitPoint = SplitPointStack[master] + Threads[master].activeSplitPoints;
-    Threads[master].activeSplitPoints++;
+    splitPoint = &SplitPointStack[master][threads[master].activeSplitPoints];
 
     // Initialize the split point object
-    splitPoint->parent = Threads[master].splitPoint;
-    splitPoint->finished = false;
+    splitPoint->parent = threads[master].splitPoint;
+    splitPoint->stopRequest = false;
     splitPoint->ply = ply;
     splitPoint->depth = depth;
-    splitPoint->alpha = pvNode ? *alpha : (*beta - 1);
-    splitPoint->beta = *beta;
+    splitPoint->alpha = pvNode ? *alpha : beta - 1;
+    splitPoint->beta = beta;
     splitPoint->pvNode = pvNode;
     splitPoint->bestValue = *bestValue;
     splitPoint->futilityValue = futilityValue;
@@ -2989,24 +2863,25 @@ namespace {
     for (int i = 0; i < ActiveThreads; i++)
         splitPoint->slaves[i] = 0;
 
-    Threads[master].idle = false;
-    Threads[master].stop = false;
-    Threads[master].splitPoint = splitPoint;
+    threads[master].splitPoint = splitPoint;
+    threads[master].activeSplitPoints++;
 
-    // Allocate available threads setting idle flag to false
+    // If we are here it means we are not available
+    assert(threads[master].state != THREAD_AVAILABLE);
+
+    // Allocate available threads setting state to THREAD_BOOKED
     for (int i = 0; i < ActiveThreads && splitPoint->cpus < MaxThreadsPerSplitPoint; i++)
         if (thread_is_available(i, master))
         {
-            Threads[i].idle = false;
-            Threads[i].stop = false;
-            Threads[i].splitPoint = splitPoint;
+            threads[i].state = THREAD_BOOKED;
+            threads[i].splitPoint = splitPoint;
             splitPoint->slaves[i] = 1;
             splitPoint->cpus++;
         }
 
     assert(splitPoint->cpus > 1);
 
-    // We can release the lock because master and slave threads are already booked
+    // We can release the lock because slave threads are already booked and master is not available
     lock_release(&MPLock);
 
     // Tell the threads that they have work to do. This will make them leave
@@ -3015,12 +2890,15 @@ namespace {
         if (i == master || splitPoint->slaves[i])
         {
             memcpy(splitPoint->sstack[i] + ply - 1, sstck + ply - 1, 4 * sizeof(SearchStack));
-            Threads[i].workIsWaiting = true; // This makes the slave to exit from idle_loop()
+
+            assert(i == master || threads[i].state == THREAD_BOOKED);
+
+            threads[i].state = THREAD_WORKISWAITING; // This makes the slave to exit from idle_loop()
         }
 
     // Everything is set up. The master thread enters the idle loop, from
-    // which it will instantly launch a search, because its workIsWaiting
-    // slot is 'true'.  We send the split point as a second parameter to the
+    // which it will instantly launch a search, because its state is
+    // THREAD_WORKISWAITING.  We send the split point as a second parameter to the
     // idle loop, which means that the main thread will return from the idle
     // loop when all threads have finished their work at this split point
     // (i.e. when splitPoint->cpus == 0).
@@ -3033,12 +2911,9 @@ namespace {
     if (pvNode)
         *alpha = splitPoint->alpha;
 
-    *beta = splitPoint->beta;
     *bestValue = splitPoint->bestValue;
-    Threads[master].stop = false;
-    Threads[master].idle = false;
-    Threads[master].activeSplitPoints--;
-    Threads[master].splitPoint = splitPoint->parent;
+    threads[master].activeSplitPoints--;
+    threads[master].splitPoint = splitPoint->parent;
 
     lock_release(&MPLock);
     return true;
@@ -3048,55 +2923,174 @@ namespace {
   // wake_sleeping_threads() wakes up all sleeping threads when it is time
   // to start a new search from the root.
 
-  void wake_sleeping_threads() {
+  void ThreadsManager::wake_sleeping_threads() {
 
-    if (ActiveThreads > 1)
-    {
-        for (int i = 1; i < ActiveThreads; i++)
-        {
-            assert(Threads[i].sleeping == true);
+    assert(AllThreadsShouldSleep);
+    assert(ActiveThreads > 0);
 
-            Threads[i].idle = true;
-            Threads[i].workIsWaiting = false;
-        }
+    AllThreadsShouldSleep = false;
+
+    if (ActiveThreads == 1)
+        return;
+
+    for (int i = 1; i < ActiveThreads; i++)
+        assert(threads[i].state == THREAD_SLEEPING);
 
 #if !defined(_MSC_VER)
-      pthread_mutex_lock(&WaitLock);
-      pthread_cond_broadcast(&WaitCond);
-      pthread_mutex_unlock(&WaitLock);
+    pthread_mutex_lock(&WaitLock);
+    pthread_cond_broadcast(&WaitCond);
+    pthread_mutex_unlock(&WaitLock);
 #else
-      for (int i = 1; i < THREAD_MAX; i++)
-          SetEvent(SitIdleEvent[i]);
+    for (int i = 1; i < MAX_THREADS; i++)
+        SetEvent(SitIdleEvent[i]);
 #endif
 
-      // Wait for the threads to be all woken up
-      for (int i = 1; i < ActiveThreads; i++)
-           while (Threads[i].sleeping);
+  }
+
+
+  // put_threads_to_sleep() makes all the threads go to sleep just before
+  // to leave think(), at the end of the search. Threads should have already
+  // finished the job and should be idle.
+
+  void ThreadsManager::put_threads_to_sleep() {
+
+    assert(!AllThreadsShouldSleep);
+
+    // This makes the threads to go to sleep
+    AllThreadsShouldSleep = true;
+
+    // Wait for the threads to be all sleeping and reset flags
+    // to a known state.
+    for (int i = 1; i < ActiveThreads; i++)
+    {
+        while (threads[i].state != THREAD_SLEEPING);
+
+        // This flag can be in a random state
+        threads[i].printCurrentLineRequest = false;
     }
   }
 
+  // print_current_line() prints _once_ the current line of search for a
+  // given thread and then setup the print request for the next thread.
+  // Called when the UCI option UCI_ShowCurrLine is 'true'.
 
-  // init_thread() is the function which is called when a new thread is
-  // launched. It simply calls the idle_loop() function with the supplied
-  // threadID. There are two versions of this function; one for POSIX
-  // threads and one for Windows threads.
+  void ThreadsManager::print_current_line(SearchStack ss[], int ply, int threadID) {
 
-#if !defined(_MSC_VER)
+    assert(ply >= 0 && ply < PLY_MAX);
+    assert(threadID >= 0 && threadID < ActiveThreads);
 
-  void* init_thread(void *threadID) {
+    if (!threads[threadID].printCurrentLineRequest)
+        return;
 
-    idle_loop(*(int*)threadID, NULL);
-    return NULL;
+    // One shot only
+    threads[threadID].printCurrentLineRequest = false;
+
+    if (threads[threadID].state == THREAD_SEARCHING)
+    {
+        lock_grab(&IOLock);
+        cout << "info currline " << (threadID + 1);
+        for (int p = 0; p < ply; p++)
+            cout << " " << ss[p].currentMove;
+
+        cout << endl;
+        lock_release(&IOLock);
+    }
+
+    // Setup print request for the next thread ID
+    if (threadID + 1 < ActiveThreads)
+        threads[threadID + 1].printCurrentLineRequest = true;
   }
 
-#else
 
-  DWORD WINAPI init_thread(LPVOID threadID) {
+  /// The RootMoveList class
 
-    idle_loop(*(int*)threadID, NULL);
-    return NULL;
+  // RootMoveList c'tor
+
+  RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) : count(0) {
+
+    SearchStack ss[PLY_MAX_PLUS_2];
+    MoveStack mlist[MaxRootMoves];
+    StateInfo st;
+    bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
+
+    // Generate all legal moves
+    MoveStack* last = generate_moves(pos, mlist);
+
+    // Add each move to the moves[] array
+    for (MoveStack* cur = mlist; cur != last; cur++)
+    {
+        bool includeMove = includeAllMoves;
+
+        for (int k = 0; !includeMove && searchMoves[k] != MOVE_NONE; k++)
+            includeMove = (searchMoves[k] == cur->move);
+
+        if (!includeMove)
+            continue;
+
+        // Find a quick score for the move
+        init_ss_array(ss);
+        pos.do_move(cur->move, st);
+        moves[count].move = cur->move;
+        moves[count].score = -qsearch(pos, ss, -VALUE_INFINITE, VALUE_INFINITE, Depth(0), 1, 0);
+        moves[count].pv[0] = cur->move;
+        moves[count].pv[1] = MOVE_NONE;
+        pos.undo_move(cur->move);
+        count++;
+    }
+    sort();
   }
 
-#endif
 
-}
+  // RootMoveList simple methods definitions
+
+  void RootMoveList::set_move_nodes(int moveNum, int64_t nodes) {
+
+    moves[moveNum].nodes = nodes;
+    moves[moveNum].cumulativeNodes += nodes;
+  }
+
+  void RootMoveList::set_beta_counters(int moveNum, int64_t our, int64_t their) {
+
+    moves[moveNum].ourBeta = our;
+    moves[moveNum].theirBeta = their;
+  }
+
+  void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
+
+    int j;
+
+    for (j = 0; pv[j] != MOVE_NONE; j++)
+        moves[moveNum].pv[j] = pv[j];
+
+    moves[moveNum].pv[j] = MOVE_NONE;
+  }
+
+
+  // RootMoveList::sort() sorts the root move list at the beginning of a new
+  // iteration.
+
+  void RootMoveList::sort() {
+
+    sort_multipv(count - 1); // Sort all items
+  }
+
+
+  // RootMoveList::sort_multipv() sorts the first few moves in the root move
+  // list by their scores and depths. It is used to order the different PVs
+  // correctly in MultiPV mode.
+
+  void RootMoveList::sort_multipv(int n) {
+
+    int i,j;
+
+    for (i = 1; i <= n; i++)
+    {
+        RootMove rm = moves[i];
+        for (j = i; j > 0 && moves[j - 1] < rm; j--)
+            moves[j] = moves[j - 1];
+
+        moves[j] = rm;
+    }
+  }
+
+} // namspace