X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=e2006425a3fefac5003f9c4865ed6ee89c2b61ef;hp=723d1ba942bb64860ce005ab8e3a1f8033f1f99d;hb=f6e11ee2a34fb074ebe588bd44a156b001d9b0d9;hpb=f7722d4de701ad8f58f254cf165cc23c7cf43156 diff --git a/src/search.cpp b/src/search.cpp index 723d1ba9..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 @@ -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 + template Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); template @@ -292,15 +284,9 @@ namespace { return search(pos, ss, alpha, beta, depth, ply); } - template - void sp_search(Position& pos, SearchStack* ss, Value dumy, Value beta, Depth depth, int ply); - template Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); - template - void do_sp_search(SplitPoint* sp, int threadID); - template Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous); @@ -308,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); @@ -479,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()]; @@ -514,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; } @@ -963,9 +943,14 @@ namespace { } - // search<>() is the main search function for both PV and non-PV nodes + // search<>() is the main search function for both PV and non-PV nodes and for + // normal and SplitPoint nodes. When called just after a split point the search + // is simpler because we have already probed the hash table, done a null move + // search, and searched the first move before splitting, we don't have to repeat + // 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 + template Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE); @@ -986,17 +971,20 @@ namespace { 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; - goto split_start; + threatMove = sp->threatMove; + mateThreat = sp->mateThreat; + goto split_point_start; } // Step 1. Initialize node and poll. Polling can abort search @@ -1182,39 +1170,39 @@ namespace { if (PvNode) mateThreat = pos.has_mate_threat(); -split_start: +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 ? false : isCheck && mp.number_of_evasions() == 1; - futilityBase = SplitPoint ? ss->eval : ss->eval + 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)); @@ -1255,7 +1243,10 @@ split_start: 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 @@ -1270,8 +1261,9 @@ split_start: && !(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; } @@ -1284,14 +1276,15 @@ split_start: if (futilityValueScaled < beta) { - if (SplitPoint) + if (SpNode) { - lock_grab(&(ss->sp->lock)); - if (futilityValueScaled > ss->sp->bestValue) - ss->sp->bestValue = futilityValueScaled; + lock_grab(&(sp->lock)); + if (futilityValueScaled > sp->bestValue) + sp->bestValue = bestValue = futilityValueScaled; } else if (futilityValueScaled > bestValue) bestValue = futilityValueScaled; + continue; } } @@ -1301,7 +1294,7 @@ split_start: // 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(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1) : - search(pos, ss+1, -beta, -alpha, newDepth, ply+1); else @@ -1314,12 +1307,12 @@ split_start: && !captureOrPromotion && !dangerous && !move_is_castle(move) - && !move_is_killer(move, ss)) + && !(ss->killers[0] == move || ss->killers[1] == move)) { ss->reduction = reduction(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(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1) : - search(pos, ss+1, -(alpha+1), -alpha, d, ply+1); @@ -1335,7 +1328,7 @@ split_start: assert(newDepth - ONE_PLY >= ONE_PLY); ss->reduction = ONE_PLY; - alpha = SplitPoint ? ss->sp->alpha : alpha; + alpha = SpNode ? sp->alpha : alpha; value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1); doFullDepthSearch = (value > alpha); } @@ -1345,7 +1338,7 @@ split_start: // Step 15. Full depth search if (doFullDepthSearch) { - alpha = SplitPoint ? ss->sp->alpha : alpha; + alpha = SpNode ? sp->alpha : alpha; value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1) : - search(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1); @@ -1364,39 +1357,44 @@ split_start: 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 @@ -1408,11 +1406,11 @@ split_start: 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; } @@ -1617,185 +1615,6 @@ split_start: } - // sp_search() is used to search from a split point. This function is called - // by each thread working at the split point. It is similar to the normal - // search() function, but simpler. Because we have already probed the hash - // table, done a null move search, and searched the first move before - // splitting, we don't have to repeat all this work in sp_search(). 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 - void do_sp_search(SplitPoint* sp, int threadID) { - - assert(threadID >= 0 && threadID < ThreadsMgr.active_threads()); - assert(ThreadsMgr.active_threads() > 1); - - Position pos(*sp->pos, threadID); - SearchStack* ss = sp->sstack[threadID] + 1; - ss->sp = sp; - - search(pos, ss, sp->alpha, sp->beta, sp->depth, sp->ply); - } - - template - void sp_search(Position& pos, SearchStack* ss, Value, Value beta, Depth depth, int ply) { - - StateInfo st; - Move move; - Depth ext, newDepth; - Value value; - Value futilityValueScaled; // NonPV specific - bool isCheck, moveIsCheck, captureOrPromotion, dangerous; - int moveCount; - value = -VALUE_INFINITE; - SplitPoint* sp = ss->sp; - Move threatMove = sp->threatMove; - MovePicker& mp = *sp->mp; - int threadID = pos.thread(); - - CheckInfo ci(pos); - isCheck = pos.is_check(); - - // Step 10. Loop through moves - // Loop through all legal moves until no moves remain or a beta cutoff occurs - lock_grab(&(sp->lock)); - - while ( sp->bestValue < beta - && (move = mp.get_next_move()) != MOVE_NONE - && !ThreadsMgr.thread_should_stop(threadID)) - { - moveCount = ++sp->moveCount; - lock_release(&(sp->lock)); - - assert(move_is_ok(move)); - - moveIsCheck = pos.move_is_check(move, ci); - captureOrPromotion = pos.move_is_capture_or_promotion(move); - - // Step 11. Decide the new search depth - ext = extension(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous); - newDepth = depth - ONE_PLY + ext; - - // Update current move - ss->currentMove = move; - - // Step 12. Futility pruning (is omitted in PV nodes) - if ( !PvNode - && !captureOrPromotion - && !isCheck - && !dangerous - && !move_is_castle(move)) - { - // Move count based pruning - if ( moveCount >= futility_move_count(depth) - && !(threatMove && connected_threat(pos, move, threatMove)) - && sp->bestValue > value_mated_in(PLY_MAX)) - { - lock_grab(&(sp->lock)); - continue; - } - - // Value based pruning - Depth predictedDepth = newDepth - reduction(depth, moveCount); - futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount) - + H.gain(pos.piece_on(move_from(move)), move_to(move)); - - if (futilityValueScaled < beta) - { - lock_grab(&(sp->lock)); - - if (futilityValueScaled > sp->bestValue) - sp->bestValue = futilityValueScaled; - continue; - } - } - - // Step 13. Make the move - pos.do_move(move, st, ci, moveIsCheck); - - // Step 14. Reduced search - // If the move fails high will be re-searched at full depth. - bool doFullDepthSearch = true; - - if ( !captureOrPromotion - && !dangerous - && !move_is_castle(move) - && !move_is_killer(move, ss)) - { - ss->reduction = reduction(depth, moveCount); - if (ss->reduction) - { - Value localAlpha = sp->alpha; - Depth d = newDepth - ss->reduction; - value = d < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -(localAlpha+1), -localAlpha, d, ply+1); - - doFullDepthSearch = (value > localAlpha); - } - - // The move failed high, but if reduction is very big we could - // face a false positive, retry with a less aggressive reduction, - // if the move fails high again then go with full depth search. - if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY) - { - assert(newDepth - ONE_PLY >= ONE_PLY); - - ss->reduction = ONE_PLY; - Value localAlpha = sp->alpha; - value = -search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, ply+1); - doFullDepthSearch = (value > localAlpha); - } - ss->reduction = DEPTH_ZERO; // Restore original reduction - } - - // Step 15. Full depth search - if (doFullDepthSearch) - { - Value localAlpha = sp->alpha; - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, ply+1); - - // Step extra. pv search (only in PV nodes) - // Search only for possible new PV nodes, if instead value >= beta then - // parent node fails low with value <= alpha and tries another move. - if (PvNode && value > localAlpha && value < beta) - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -sp->alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -beta, -sp->alpha, newDepth, ply+1); - } - - // Step 16. Undo move - pos.undo_move(move); - - assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); - - // Step 17. Check for new best move - lock_grab(&(sp->lock)); - - if (value > sp->bestValue && !ThreadsMgr.thread_should_stop(threadID)) - { - sp->bestValue = value; - if (value > sp->alpha) - { - if (!PvNode || value >= beta) - sp->stopRequest = true; - - if (PvNode && value < beta) // We want always sp->alpha < beta - sp->alpha = value; - - sp->parentSstack->bestMove = ss->bestMove = move; - } - } - } - - /* Here we have the lock still grabbed */ - - sp->slaves[threadID] = 0; - - lock_release(&(sp->lock)); - } - - // connected_moves() tests whether two moves are 'connected' in the sense // that the first move somehow made the second move possible (for instance // if the moving piece is the same in both moves). The first move is assumed @@ -1895,17 +1714,6 @@ split_start: } - // 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 @@ -2051,7 +1859,6 @@ split_start: 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); @@ -2418,38 +2225,51 @@ split_start: // 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); - // If thread has just woken up, mark it as available - if (threads[threadID].state == THREAD_SLEEPING) + // Retest condition under lock protection + if (!( threadID >= ActiveThreads + || threads[threadID].state == THREAD_INITIALIZING + || (!sp && threads[threadID].state == THREAD_AVAILABLE))) + { + lock_release(&MPLock); + continue; + } + + // 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; - if (threads[threadID].splitPoint->pvNode) - do_sp_search(threads[threadID].splitPoint, threadID); - else - do_sp_search(threads[threadID].splitPoint, threadID); + // Here we call search() with SplitPoint template parameter set to true + SplitPoint* tsp = threads[threadID].splitPoint; + Position pos(*tsp->pos, threadID); + SearchStack* ss = tsp->sstack[threadID] + 1; + ss->sp = tsp; + if (tsp->pvNode) + search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); + else { + search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); + } assert(threads[threadID].state == THREAD_SEARCHING); threads[threadID].state = THREAD_AVAILABLE; @@ -2487,20 +2307,11 @@ split_start: 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++) @@ -2510,20 +2321,20 @@ split_start: // 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); @@ -2536,7 +2347,7 @@ split_start: } // Wait until the thread has finished launching and is gone to sleep - while (threads[i].state != THREAD_SLEEPING) {} + while (threads[i].state == THREAD_INITIALIZING) {} } } @@ -2546,22 +2357,25 @@ split_start: 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]); } @@ -2637,9 +2451,8 @@ split_start: // 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 void ThreadsManager::split(const Position& p, SearchStack* ss, int ply, Value* alpha, @@ -2722,6 +2535,8 @@ split_start: 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 @@ -2744,43 +2559,17 @@ split_start: } - // 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