X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=e2006425a3fefac5003f9c4865ed6ee89c2b61ef;hp=b8c6c952eaac5ca3e7e0176b41231e45312a4ea2;hb=f6e11ee2a34fb074ebe588bd44a156b001d9b0d9;hpb=f09266746036b126d06684726fa19e6730d89018

diff --git a/src/search.cpp b/src/search.cpp
index b8c6c952..e2006425 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -82,8 +82,7 @@ namespace {
     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 wake_sleeping_thread(int threadID);
     void idle_loop(int threadID, SplitPoint* sp);
 
     template <bool Fake>
@@ -94,17 +93,10 @@ namespace {
     friend void poll();
 
     int ActiveThreads;
-    volatile bool AllThreadsShouldExit, AllThreadsShouldSleep;
+    volatile bool AllThreadsShouldExit;
     Thread threads[MAX_THREADS];
-
-    Lock MPLock, WaitLock;
-
-#if !defined(_MSC_VER)
-    pthread_cond_t WaitCond;
-#else
-    HANDLE SitIdleEvent[MAX_THREADS];
-#endif
-
+    Lock MPLock;
+    WaitCondition WaitCond[MAX_THREADS];
   };
 
 
@@ -284,7 +276,7 @@ namespace {
   Value id_loop(const Position& pos, Move searchMoves[]);
   Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr);
 
-  template <NodeType PvNode, bool SplitPoint>
+  template <NodeType PvNode, bool SpNode>
   Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply);
 
   template <NodeType PvNode>
@@ -302,7 +294,6 @@ namespace {
   bool value_is_mate(Value value);
   Value value_to_tt(Value v, int ply);
   Value value_from_tt(Value v, int ply);
-  bool move_is_killer(Move m, SearchStack* ss);
   bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
   bool connected_threat(const Position& pos, Move m, Move threat);
   Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
@@ -473,9 +464,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr
       init_eval(ThreadsMgr.active_threads());
   }
 
-  // Wake up sleeping threads
-  ThreadsMgr.wake_sleeping_threads();
-
   // Set thinking time
   int myTime = time[pos.side_to_move()];
   int myIncrement = increment[pos.side_to_move()];
@@ -508,8 +496,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr
   if (UseLogFile)
       LogFile.close();
 
-  ThreadsMgr.put_threads_to_sleep();
-
   return !Quit;
 }
 
@@ -714,7 +700,7 @@ namespace {
     int64_t nodes;
     Move move;
     Depth depth, ext, newDepth;
-    Value value, alpha, beta;
+    Value value, evalMargin, alpha, beta;
     bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
     int researchCountFH, researchCountFL;
 
@@ -733,8 +719,7 @@ namespace {
 
     // Step 5. Evaluate the position statically
     // At root we do this only to get reference value for child nodes
-    ss->evalMargin = VALUE_NONE;
-    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, ss->evalMargin);
+    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, evalMargin);
 
     // Step 6. Razoring (omitted at root)
     // Step 7. Static null move pruning (omitted at root)
@@ -965,7 +950,7 @@ namespace {
   // all this work again. We also don't need to store anything to the hash table
   // here: This is taken care of after we return from the split point.
 
-  template <NodeType PvNode, bool SplitPoint>
+  template <NodeType PvNode, bool SpNode>
   Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) {
 
     assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
@@ -980,22 +965,25 @@ namespace {
     Key posKey;
     Move ttMove, move, excludedMove, threatMove;
     Depth ext, newDepth;
-    Value bestValue, value, oldAlpha;
+    Value bestValue, value, evalMargin, oldAlpha;
     Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
     bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
     int moveCount = 0;
     int threadID = pos.thread();
+    SplitPoint* sp = NULL;
     refinedValue = bestValue = value = -VALUE_INFINITE;
     oldAlpha = alpha;
     isCheck = pos.is_check();
 
-    if (SplitPoint)
+    if (SpNode)
     {
+        sp = ss->sp;
         tte = NULL;
+        evalMargin = VALUE_ZERO;
         ttMove = excludedMove = MOVE_NONE;
-        threatMove = ss->sp->threatMove;
-        mateThreat = ss->sp->mateThreat;
+        threatMove = sp->threatMove;
+        mateThreat = sp->mateThreat;
         goto split_point_start;
     }
 
@@ -1053,19 +1041,19 @@ namespace {
     // Step 5. Evaluate the position statically and
     // update gain statistics of parent move.
     if (isCheck)
-        ss->eval = ss->evalMargin = VALUE_NONE;
+        ss->eval = evalMargin = VALUE_NONE;
     else if (tte)
     {
         assert(tte->static_value() != VALUE_NONE);
 
         ss->eval = tte->static_value();
-        ss->evalMargin = tte->static_value_margin();
+        evalMargin = tte->static_value_margin();
         refinedValue = refine_eval(tte, ss->eval, ply);
     }
     else
     {
-        refinedValue = ss->eval = evaluate(pos, ss->evalMargin);
-        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin);
+        refinedValue = ss->eval = evaluate(pos, evalMargin);
+        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
     }
 
     // Save gain for the parent non-capture move
@@ -1187,35 +1175,34 @@ split_point_start: // At split points actual search starts from here
     // Initialize a MovePicker object for the current position
     // FIXME currently MovePicker() c'tor is needless called also in SplitPoint
     MovePicker mpBase = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta));
-    MovePicker& mp = SplitPoint ? *ss->sp->mp : mpBase;
+    MovePicker& mp = SpNode ? *sp->mp : mpBase;
     CheckInfo ci(pos);
     ss->bestMove = MOVE_NONE;
-    singleEvasion = !SplitPoint && isCheck && mp.number_of_evasions() == 1;
-    futilityBase = ss->eval + ss->evalMargin;
-    singularExtensionNode =  !SplitPoint
+    singleEvasion = !SpNode && isCheck && mp.number_of_evasions() == 1;
+    futilityBase = ss->eval + evalMargin;
+    singularExtensionNode =  !SpNode
                            && depth >= SingularExtensionDepth[PvNode]
                            && tte
                            && tte->move()
                            && !excludedMove // Do not allow recursive singular extension search
                            && (tte->type() & VALUE_TYPE_LOWER)
                            && tte->depth() >= depth - 3 * ONE_PLY;
-
-    // Step 10. Loop through moves
-    // Loop through all legal moves until no moves remain or a beta cutoff occurs
-    if (SplitPoint)
+    if (SpNode)
     {
-        lock_grab(&(ss->sp->lock));
-        bestValue = ss->sp->bestValue;
+        lock_grab(&(sp->lock));
+        bestValue = sp->bestValue;
     }
 
+    // Step 10. Loop through moves
+    // Loop through all legal moves until no moves remain or a beta cutoff occurs
     while (   bestValue < beta
            && (move = mp.get_next_move()) != MOVE_NONE
            && !ThreadsMgr.thread_should_stop(threadID))
     {
-      if (SplitPoint)
+      if (SpNode)
       {
-          moveCount = ++ss->sp->moveCount;
-          lock_release(&(ss->sp->lock));
+          moveCount = ++sp->moveCount;
+          lock_release(&(sp->lock));
       }
 
       assert(move_is_ok(move));
@@ -1256,7 +1243,10 @@ split_point_start: // At split points actual search starts from here
       newDepth = depth - ONE_PLY + ext;
 
       // Update current move (this must be done after singular extension search)
-      movesSearched[moveCount++] = ss->currentMove = move;
+      movesSearched[moveCount] = ss->currentMove = move;
+
+      if (!SpNode)
+          moveCount++;
 
       // Step 12. Futility pruning (is omitted in PV nodes)
       if (   !PvNode
@@ -1271,8 +1261,9 @@ split_point_start: // At split points actual search starts from here
               && !(threatMove && connected_threat(pos, move, threatMove))
               && bestValue > value_mated_in(PLY_MAX)) // FIXME bestValue is racy
           {
-              if (SplitPoint)
-                  lock_grab(&(ss->sp->lock));
+              if (SpNode)
+                  lock_grab(&(sp->lock));
+
               continue;
           }
 
@@ -1285,14 +1276,15 @@ split_point_start: // At split points actual search starts from here
 
           if (futilityValueScaled < beta)
           {
-              if (SplitPoint)
+              if (SpNode)
               {
-                  lock_grab(&(ss->sp->lock));
-                  if (futilityValueScaled > ss->sp->bestValue)
-                      ss->sp->bestValue = bestValue = futilityValueScaled;
+                  lock_grab(&(sp->lock));
+                  if (futilityValueScaled > sp->bestValue)
+                      sp->bestValue = bestValue = futilityValueScaled;
               }
               else if (futilityValueScaled > bestValue)
                   bestValue = futilityValueScaled;
+
               continue;
           }
       }
@@ -1302,7 +1294,7 @@ split_point_start: // At split points actual search starts from here
 
       // Step extra. pv search (only in PV nodes)
       // The first move in list is the expected PV
-      if (!SplitPoint && PvNode && moveCount == 1)
+      if (!SpNode && PvNode && moveCount == 1)
           value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1)
                                      : - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1);
       else
@@ -1315,12 +1307,12 @@ split_point_start: // At split points actual search starts from here
               && !captureOrPromotion
               && !dangerous
               && !move_is_castle(move)
-              && !move_is_killer(move, ss))
+              && !(ss->killers[0] == move || ss->killers[1] == move))
           {
               ss->reduction = reduction<PvNode>(depth, moveCount);
               if (ss->reduction)
               {
-                  alpha = SplitPoint ? ss->sp->alpha : alpha;
+                  alpha = SpNode ? sp->alpha : alpha;
                   Depth d = newDepth - ss->reduction;
                   value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1)
                                       : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, ply+1);
@@ -1336,7 +1328,7 @@ split_point_start: // At split points actual search starts from here
                   assert(newDepth - ONE_PLY >= ONE_PLY);
 
                   ss->reduction = ONE_PLY;
-                  alpha = SplitPoint ? ss->sp->alpha : alpha;
+                  alpha = SpNode ? sp->alpha : alpha;
                   value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1);
                   doFullDepthSearch = (value > alpha);
               }
@@ -1346,7 +1338,7 @@ split_point_start: // At split points actual search starts from here
           // Step 15. Full depth search
           if (doFullDepthSearch)
           {
-              alpha = SplitPoint ? ss->sp->alpha : alpha;
+              alpha = SpNode ? sp->alpha : alpha;
               value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1)
                                          : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1);
 
@@ -1365,39 +1357,44 @@ split_point_start: // At split points actual search starts from here
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
       // Step 17. Check for new best move
-      if (SplitPoint)
+      if (SpNode)
       {
-          lock_grab(&(ss->sp->lock));
-          bestValue = ss->sp->bestValue;
-          alpha = ss->sp->alpha;
+          lock_grab(&(sp->lock));
+          bestValue = sp->bestValue;
+          alpha = sp->alpha;
       }
 
-      if (value > bestValue && !(SplitPoint && ThreadsMgr.thread_should_stop(threadID)))
+      if (value > bestValue && !(SpNode && ThreadsMgr.thread_should_stop(threadID)))
       {
           bestValue = value;
+
+          if (SpNode)
+              sp->bestValue = value;
+
           if (value > alpha)
           {
-              if (SplitPoint && (!PvNode || value >= beta))
-                  ss->sp->stopRequest = true;
+              if (SpNode && (!PvNode || value >= beta))
+                  sp->stopRequest = true;
 
               if (PvNode && value < beta) // We want always alpha < beta
+              {
                   alpha = value;
+                  if (SpNode)
+                      sp->alpha = value;
+              }
 
-              if (value == value_mate_in(ply + 1))
+              if (!SpNode && value == value_mate_in(ply + 1))
                   ss->mateKiller = move;
 
               ss->bestMove = move;
-          }
-          if (SplitPoint)
-          {
-              ss->sp->bestValue = bestValue;
-              ss->sp->alpha = alpha;
-              ss->sp->parentSstack->bestMove = ss->bestMove;
+
+              if (SpNode)
+                  sp->parentSstack->bestMove = move;
           }
       }
 
       // Step 18. Check for split
-      if (   !SplitPoint
+      if (   !SpNode
           && depth >= MinimumSplitDepth
           && ThreadsMgr.active_threads() > 1
           && bestValue < beta
@@ -1409,11 +1406,11 @@ split_point_start: // At split points actual search starts from here
                                       threatMove, mateThreat, moveCount, &mp, PvNode);
     }
 
-    if (SplitPoint)
+    if (SpNode)
     {
         /* Here we have the lock still grabbed */
-        ss->sp->slaves[threadID] = 0;
-        lock_release(&(ss->sp->lock));
+        sp->slaves[threadID] = 0;
+        lock_release(&(sp->lock));
         return bestValue;
     }
 
@@ -1432,7 +1429,7 @@ split_point_start: // At split points actual search starts from here
 
     ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
     move = (bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove);
-    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ss->evalMargin);
+    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, evalMargin);
 
     // Update killers and history only for non capture moves that fails high
     if (    bestValue >= beta
@@ -1717,17 +1714,6 @@ split_point_start: // At split points actual search starts from here
   }
 
 
-  // move_is_killer() checks if the given move is among the killer moves
-
-  bool move_is_killer(Move m, SearchStack* ss) {
-
-      if (ss->killers[0] == m || ss->killers[1] == m)
-          return true;
-
-      return false;
-  }
-
-
   // extension() decides whether a move should be searched with normal depth,
   // or with extended depth. Certain classes of moves (checking moves, in
   // particular) are searched with bigger depth than ordinary moves and in
@@ -1873,7 +1859,6 @@ split_point_start: // At split points actual search starts from here
 
   void update_history(const Position& pos, Move move, Depth depth,
                       Move movesSearched[], int moveCount) {
-
     Move m;
 
     H.success(pos.piece_on(move_from(move)), move_to(move), depth);
@@ -2240,44 +2225,51 @@ split_point_start: // At split points actual search starts from here
 
         // If we are not thinking, wait for a condition to be signaled
         // instead of wasting CPU time polling for work.
-        while (AllThreadsShouldSleep || threadID >= ActiveThreads)
+        while (   threadID >= ActiveThreads
+               || threads[threadID].state == THREAD_INITIALIZING
+               || (!sp && threads[threadID].state == THREAD_AVAILABLE))
         {
             assert(!sp);
             assert(threadID != 0);
-            threads[threadID].state = THREAD_SLEEPING;
 
-#if !defined(_MSC_VER)
-            lock_grab(&WaitLock);
-            if (AllThreadsShouldSleep || threadID >= ActiveThreads)
-                pthread_cond_wait(&WaitCond, &WaitLock);
-            lock_release(&WaitLock);
-#else
-            WaitForSingleObject(SitIdleEvent[threadID], INFINITE);
-#endif
-        }
+            if (AllThreadsShouldExit)
+                break;
+
+            lock_grab(&MPLock);
+
+            // Retest condition under lock protection
+            if (!(   threadID >= ActiveThreads
+                  || threads[threadID].state == THREAD_INITIALIZING
+                  || (!sp && threads[threadID].state == THREAD_AVAILABLE)))
+            {
+                lock_release(&MPLock);
+                continue;
+            }
 
-        // If thread has just woken up, mark it as available
-        if (threads[threadID].state == THREAD_SLEEPING)
+            // Put thread to sleep
             threads[threadID].state = THREAD_AVAILABLE;
+            cond_wait(&WaitCond[threadID], &MPLock);
+            lock_release(&MPLock);
+        }
 
         // If this thread has been assigned work, launch a search
         if (threads[threadID].state == THREAD_WORKISWAITING)
         {
-            assert(!AllThreadsShouldExit && !AllThreadsShouldSleep);
+            assert(!AllThreadsShouldExit);
 
             threads[threadID].state = THREAD_SEARCHING;
 
             // Here we call search() with SplitPoint template parameter set to true
-            SplitPoint* sp = threads[threadID].splitPoint;
-            Position pos(*sp->pos, threadID);
-            SearchStack* ss = sp->sstack[threadID] + 1;
-            ss->sp = sp;
-
-            if (sp->pvNode)
-                search<PV, true>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->ply);
-            else
-                search<NonPV, true>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->ply);
-
+            SplitPoint* tsp = threads[threadID].splitPoint;
+            Position pos(*tsp->pos, threadID);
+            SearchStack* ss = tsp->sstack[threadID] + 1;
+            ss->sp = tsp;
+
+            if (tsp->pvNode)
+                search<PV, true>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
+            else {
+                search<NonPV, true>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
+            }
             assert(threads[threadID].state == THREAD_SEARCHING);
 
             threads[threadID].state = THREAD_AVAILABLE;
@@ -2315,20 +2307,11 @@ split_point_start: // At split points actual search starts from here
     volatile int i;
     bool ok;
 
-#if !defined(_MSC_VER)
-    pthread_t pthread[1];
-#endif
-
     // Initialize global locks
     lock_init(&MPLock);
-    lock_init(&WaitLock);
 
-#if !defined(_MSC_VER)
-    pthread_cond_init(&WaitCond, NULL);
-#else
     for (i = 0; i < MAX_THREADS; i++)
-        SitIdleEvent[i] = CreateEvent(0, FALSE, FALSE, 0);
-#endif
+        cond_init(&WaitCond[i]);
 
     // Initialize splitPoints[] locks
     for (i = 0; i < MAX_THREADS; i++)
@@ -2338,20 +2321,20 @@ split_point_start: // At split points actual search starts from here
     // 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
+    // Threads will be put all threads to sleep as soon as created
     ActiveThreads = 1;
+
+    // All threads except the main thread should be initialized to THREAD_INITIALIZING
     threads[0].state = THREAD_SEARCHING;
     for (i = 1; i < MAX_THREADS; i++)
-        threads[i].state = THREAD_AVAILABLE;
+        threads[i].state = THREAD_INITIALIZING;
 
     // Launch the helper threads
     for (i = 1; i < MAX_THREADS; i++)
     {
 
 #if !defined(_MSC_VER)
+        pthread_t pthread[1];
         ok = (pthread_create(pthread, NULL, init_thread, (void*)(&i)) == 0);
 #else
         ok = (CreateThread(NULL, 0, init_thread, (LPVOID)(&i), 0, NULL) != NULL);
@@ -2364,7 +2347,7 @@ split_point_start: // At split points actual search starts from here
         }
 
         // Wait until the thread has finished launching and is gone to sleep
-        while (threads[i].state != THREAD_SLEEPING) {}
+        while (threads[i].state == THREAD_INITIALIZING) {}
     }
   }
 
@@ -2374,22 +2357,25 @@ split_point_start: // At split points actual search starts from here
 
   void ThreadsManager::exit_threads() {
 
-    ActiveThreads = MAX_THREADS;  // Wake up all the threads
-    AllThreadsShouldExit = true;  // Let the woken up threads to exit idle_loop()
-    AllThreadsShouldSleep = true; // Avoid an assert in wake_sleeping_threads()
-    wake_sleeping_threads();
+    AllThreadsShouldExit = true; // Let the woken up threads to exit idle_loop()
 
-    // Wait for thread termination
+    // Wake up all the threads and waits for termination
     for (int i = 1; i < MAX_THREADS; i++)
+    {
+        wake_sleeping_thread(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 < MAX_ACTIVE_SPLIT_POINTS; j++)
             lock_destroy(&(threads[i].splitPoints[j].lock));
 
-    lock_destroy(&WaitLock);
     lock_destroy(&MPLock);
+
+    // Now we can safely destroy the wait conditions
+    for (int i = 0; i < MAX_THREADS; i++)
+        cond_destroy(&WaitCond[i]);
   }
 
 
@@ -2465,9 +2451,8 @@ split_point_start: // At split points actual search starts from here
   // split point objects), the function immediately returns. If splitting is
   // possible, a SplitPoint object is initialized with all the data that must be
   // copied to the helper threads and we tell our helper threads that they have
-  // been assigned work. This will cause them to instantly leave their idle loops
-  // and call sp_search(). When all threads have returned from sp_search() then
-  // split() returns.
+  // been assigned work. This will cause them to instantly leave their idle loops and
+  // call search().When all threads have returned from search() then split() returns.
 
   template <bool Fake>
   void ThreadsManager::split(const Position& p, SearchStack* ss, int ply, Value* alpha,
@@ -2550,6 +2535,8 @@ split_point_start: // At split points actual search starts from here
             assert(i == master || threads[i].state == THREAD_BOOKED);
 
             threads[i].state = THREAD_WORKISWAITING; // This makes the slave to exit from idle_loop()
+            if (i != master)
+                wake_sleeping_thread(i);
         }
 
     // Everything is set up. The master thread enters the idle loop, from
@@ -2572,43 +2559,17 @@ split_point_start: // At split points actual search starts from here
   }
 
 
-  // wake_sleeping_threads() wakes up all sleeping threads when it is time
+  // wake_sleeping_thread() wakes up all sleeping threads when it is time
   // to start a new search from the root.
 
-  void ThreadsManager::wake_sleeping_threads() {
-
-    assert(AllThreadsShouldSleep);
-    assert(ActiveThreads > 0);
-
-    AllThreadsShouldSleep = false;
-
-    if (ActiveThreads == 1)
-        return;
-
-#if !defined(_MSC_VER)
-    pthread_mutex_lock(&WaitLock);
-    pthread_cond_broadcast(&WaitCond);
-    pthread_mutex_unlock(&WaitLock);
-#else
-    for (int i = 1; i < MAX_THREADS; i++)
-        SetEvent(SitIdleEvent[i]);
-#endif
+  void ThreadsManager::wake_sleeping_thread(int threadID) {
 
+     lock_grab(&MPLock);
+     cond_signal(&WaitCond[threadID]);
+     lock_release(&MPLock);
   }
 
 
-  // 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;
-  }
-
   /// The RootMoveList class
 
   // RootMoveList c'tor
@@ -2622,7 +2583,7 @@ split_point_start: // At split points actual search starts from here
 
     // Initialize search stack
     init_ss_array(ss, PLY_MAX_PLUS_2);
-    ss[0].eval = ss[0].evalMargin = VALUE_NONE;
+    ss[0].eval = VALUE_NONE;
     count = 0;
 
     // Generate all legal moves