X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=b38b45058ee474d7c9445d6310248436999b4114;hp=93243ed7488ad512872fc22b6a874c23de49f9a2;hb=1fdb436e78cce2d2128e7ac2117151dab301f4db;hpb=083ed1ce94e7b2b5002c01cc947e56bec884737f diff --git a/src/search.cpp b/src/search.cpp index 93243ed7..b38b4505 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -82,13 +82,13 @@ 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 wake_sleeping_thread(int threadID); void put_threads_to_sleep(); void idle_loop(int threadID, SplitPoint* sp); template void split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue, - Depth depth, Move threatMove, bool mateThreat, int* moveCount, MovePicker* mp, bool pvNode); + Depth depth, Move threatMove, bool mateThreat, int moveCount, MovePicker* mp, bool pvNode); private: friend void poll(); @@ -100,7 +100,7 @@ namespace { Lock MPLock, WaitLock; #if !defined(_MSC_VER) - pthread_cond_t WaitCond; + pthread_cond_t WaitCond[MAX_THREADS]; #else HANDLE SitIdleEvent[MAX_THREADS]; #endif @@ -284,14 +284,16 @@ 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 - Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); + inline Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { + return search(pos, ss, alpha, beta, depth, ply); + } template - void sp_search(SplitPoint* sp, int threadID); + Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); template Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous); @@ -300,7 +302,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); @@ -471,8 +472,9 @@ 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(); + // Wake up needed threads + for (int i = 1; i < newActiveThreads; i++) + ThreadsMgr.wake_sleeping_thread(i); // Set thinking time int myTime = time[pos.side_to_move()]; @@ -712,7 +714,7 @@ namespace { int64_t nodes; Move move; Depth depth, ext, newDepth; - Value value, evalMargin, alpha, beta; + Value value, alpha, beta; bool isCheck, moveIsCheck, captureOrPromotion, dangerous; int researchCountFH, researchCountFL; @@ -731,7 +733,8 @@ namespace { // Step 5. Evaluate the position statically // At root we do this only to get reference value for child nodes - ss->eval = isCheck ? VALUE_NONE : evaluate(pos, evalMargin); + ss->evalMargin = VALUE_NONE; + ss->eval = isCheck ? VALUE_NONE : evaluate(pos, ss->evalMargin); // Step 6. Razoring (omitted at root) // Step 7. Static null move pruning (omitted at root) @@ -955,9 +958,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); @@ -972,14 +980,26 @@ namespace { Key posKey; Move ttMove, move, excludedMove, threatMove; Depth ext, newDepth; - Value bestValue, value, evalMargin, oldAlpha; + Value bestValue, value, 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 (SpNode) + { + sp = ss->sp; + tte = NULL; + ttMove = excludedMove = MOVE_NONE; + threatMove = sp->threatMove; + mateThreat = sp->mateThreat; + goto split_point_start; + } // Step 1. Initialize node and poll. Polling can abort search ThreadsMgr.incrementNodeCounter(threadID); @@ -1034,21 +1054,20 @@ namespace { // Step 5. Evaluate the position statically and // update gain statistics of parent move. - isCheck = pos.is_check(); if (isCheck) - ss->eval = evalMargin = VALUE_NONE; + ss->eval = ss->evalMargin = VALUE_NONE; else if (tte) { assert(tte->static_value() != VALUE_NONE); ss->eval = tte->static_value(); - evalMargin = tte->static_value_margin(); + ss->evalMargin = tte->static_value_margin(); refinedValue = refine_eval(tte, ss->eval, ply); } else { - refinedValue = ss->eval = evaluate(pos, evalMargin); - TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin); + refinedValue = ss->eval = evaluate(pos, ss->evalMargin); + TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin); } // Save gain for the parent non-capture move @@ -1165,18 +1184,28 @@ namespace { if (PvNode) mateThreat = pos.has_mate_threat(); +split_point_start: // At split points actual search starts from here + // Initialize a MovePicker object for the current position - MovePicker mp = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta)); + // 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 = SpNode ? *sp->mp : mpBase; CheckInfo ci(pos); ss->bestMove = MOVE_NONE; - singleEvasion = isCheck && mp.number_of_evasions() == 1; - futilityBase = ss->eval + evalMargin; - singularExtensionNode = depth >= SingularExtensionDepth[PvNode] + singleEvasion = !SpNode && isCheck && mp.number_of_evasions() == 1; + futilityBase = ss->eval + ss->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; + if (SpNode) + { + 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 @@ -1184,6 +1213,12 @@ namespace { && (move = mp.get_next_move()) != MOVE_NONE && !ThreadsMgr.thread_should_stop(threadID)) { + if (SpNode) + { + moveCount = ++sp->moveCount; + lock_release(&(sp->lock)); + } + assert(move_is_ok(move)); if (move == excludedMove) @@ -1235,8 +1270,13 @@ namespace { // Move count based pruning if ( moveCount >= futility_move_count(depth) && !(threatMove && connected_threat(pos, move, threatMove)) - && bestValue > value_mated_in(PLY_MAX)) + && bestValue > value_mated_in(PLY_MAX)) // FIXME bestValue is racy + { + if (SpNode) + lock_grab(&(sp->lock)); + continue; + } // Value based pruning // We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth, @@ -1247,8 +1287,15 @@ namespace { if (futilityValueScaled < beta) { - if (futilityValueScaled > bestValue) + if (SpNode) + { + lock_grab(&(sp->lock)); + if (futilityValueScaled > sp->bestValue) + sp->bestValue = bestValue = futilityValueScaled; + } + else if (futilityValueScaled > bestValue) bestValue = futilityValueScaled; + continue; } } @@ -1258,7 +1305,7 @@ namespace { // Step extra. pv search (only in PV nodes) // The first move in list is the expected PV - if (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 @@ -1271,11 +1318,12 @@ namespace { && !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 = 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); @@ -1291,6 +1339,7 @@ namespace { assert(newDepth - ONE_PLY >= ONE_PLY); ss->reduction = ONE_PLY; + alpha = SpNode ? sp->alpha : alpha; value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1); doFullDepthSearch = (value > alpha); } @@ -1300,6 +1349,7 @@ namespace { // Step 15. Full depth search if (doFullDepthSearch) { + 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); @@ -1318,11 +1368,21 @@ namespace { assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); // Step 17. Check for new best move - if (value > bestValue) + if (SpNode) + { + lock_grab(&(sp->lock)); + bestValue = sp->bestValue; + alpha = sp->alpha; + } + + if (value > bestValue && !(SpNode && ThreadsMgr.thread_should_stop(threadID))) { bestValue = value; if (value > alpha) { + if (SpNode && (!PvNode || value >= beta)) + sp->stopRequest = true; + if (PvNode && value < beta) // We want always alpha < beta alpha = value; @@ -1331,10 +1391,17 @@ namespace { ss->bestMove = move; } + if (SpNode) + { + sp->bestValue = bestValue; + sp->alpha = alpha; + sp->parentSstack->bestMove = ss->bestMove; + } } // Step 18. Check for split - if ( depth >= MinimumSplitDepth + if ( !SpNode + && depth >= MinimumSplitDepth && ThreadsMgr.active_threads() > 1 && bestValue < beta && ThreadsMgr.available_thread_exists(threadID) @@ -1342,7 +1409,15 @@ namespace { && !ThreadsMgr.thread_should_stop(threadID) && Iteration <= 99) ThreadsMgr.split(pos, ss, ply, &alpha, beta, &bestValue, depth, - threatMove, mateThreat, &moveCount, &mp, PvNode); + threatMove, mateThreat, moveCount, &mp, PvNode); + } + + if (SpNode) + { + /* Here we have the lock still grabbed */ + sp->slaves[threadID] = 0; + lock_release(&(sp->lock)); + return bestValue; } // Step 19. Check for mate and stalemate @@ -1360,7 +1435,7 @@ namespace { 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, evalMargin); + TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ss->evalMargin); // Update killers and history only for non capture moves that fails high if ( bestValue >= beta @@ -1546,174 +1621,6 @@ namespace { } - // 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 sp_search(SplitPoint* sp, int threadID) { - - assert(threadID >= 0 && threadID < ThreadsMgr.active_threads()); - assert(ThreadsMgr.active_threads() > 1); - - StateInfo st; - Move move; - Depth ext, newDepth; - Value value; - Value futilityValueScaled; // NonPV specific - bool isCheck, moveIsCheck, captureOrPromotion, dangerous; - int moveCount; - value = -VALUE_INFINITE; - - Position pos(*sp->pos, threadID); - CheckInfo ci(pos); - SearchStack* ss = sp->sstack[threadID] + 1; - 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 < sp->beta - && (move = sp->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 = sp->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(sp->depth) - && !(sp->threatMove && connected_threat(pos, move, sp->threatMove)) - && sp->bestValue > value_mated_in(PLY_MAX)) - { - lock_grab(&(sp->lock)); - continue; - } - - // Value based pruning - Depth predictedDepth = newDepth - reduction(sp->depth, moveCount); - futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount) - + H.gain(pos.piece_on(move_from(move)), move_to(move)); - - if (futilityValueScaled < sp->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(sp->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, sp->ply+1) - : - search(pos, ss+1, -(localAlpha+1), -localAlpha, d, sp->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, sp->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, sp->ply+1) - : - search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, sp->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 < sp->beta) - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -sp->beta, -sp->alpha, DEPTH_ZERO, sp->ply+1) - : - search(pos, ss+1, -sp->beta, -sp->alpha, newDepth, sp->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 (sp->bestValue > sp->alpha) - { - if (!PvNode || value >= sp->beta) - sp->stopRequest = true; - - if (PvNode && value < sp->beta) // This guarantees that always: sp->alpha < sp->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 @@ -1813,17 +1720,6 @@ namespace { } - // 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 @@ -1969,7 +1865,6 @@ namespace { 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); @@ -2151,6 +2046,7 @@ namespace { ss->excludedMove = MOVE_NONE; ss->skipNullMove = false; ss->reduction = DEPTH_ZERO; + ss->sp = NULL; if (i < 3) ss->killers[0] = ss->killers[1] = ss->mateKiller = MOVE_NONE; @@ -2344,7 +2240,7 @@ namespace { #if !defined(_MSC_VER) lock_grab(&WaitLock); if (AllThreadsShouldSleep || threadID >= ActiveThreads) - pthread_cond_wait(&WaitCond, &WaitLock); + pthread_cond_wait(&WaitCond[threadID], &WaitLock); lock_release(&WaitLock); #else WaitForSingleObject(SitIdleEvent[threadID], INFINITE); @@ -2362,10 +2258,16 @@ namespace { threads[threadID].state = THREAD_SEARCHING; - if (threads[threadID].splitPoint->pvNode) - 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 - sp_search(threads[threadID].splitPoint, threadID); + search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); assert(threads[threadID].state == THREAD_SEARCHING); @@ -2412,10 +2314,10 @@ namespace { lock_init(&MPLock); lock_init(&WaitLock); + for (i = 0; i < MAX_THREADS; i++) #if !defined(_MSC_VER) - pthread_cond_init(&WaitCond, NULL); + pthread_cond_init(&WaitCond[i], NULL); #else - for (i = 0; i < MAX_THREADS; i++) SitIdleEvent[i] = CreateEvent(0, FALSE, FALSE, 0); #endif @@ -2463,16 +2365,15 @@ namespace { void ThreadsManager::exit_threads() { - ActiveThreads = MAX_THREADS; // HACK - AllThreadsShouldSleep = true; // HACK - wake_sleeping_threads(); + AllThreadsShouldExit = true; // Let the woken up threads to exit idle_loop() + ActiveThreads = MAX_THREADS; // Avoid any woken up thread comes back to sleep - // This makes the threads to exit idle_loop() - AllThreadsShouldExit = true; - - // 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++) @@ -2492,9 +2393,9 @@ namespace { assert(threadID >= 0 && threadID < ActiveThreads); - SplitPoint* sp; + SplitPoint* sp = threads[threadID].splitPoint; - for (sp = threads[threadID].splitPoint; sp && !sp->stopRequest; sp = sp->parent) {} + for ( ; sp && !sp->stopRequest; sp = sp->parent) {} return sp != NULL; } @@ -2519,12 +2420,9 @@ namespace { // Make a local copy to be sure doesn't change under our feet int localActiveSplitPoints = threads[slave].activeSplitPoints; - if (localActiveSplitPoints == 0) - // No active split points means that the thread is available as - // a slave for any other thread. - return true; - - if (ActiveThreads == 2) + // No active split points means that the thread is available as + // a slave for any other thread. + if (localActiveSplitPoints == 0 || ActiveThreads == 2) return true; // Apply the "helpful master" concept if possible. Use localActiveSplitPoints @@ -2566,7 +2464,7 @@ namespace { template void ThreadsManager::split(const Position& p, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue, Depth depth, Move threatMove, - bool mateThreat, int* moveCount, MovePicker* mp, bool pvNode) { + bool mateThreat, int moveCount, MovePicker* mp, bool pvNode) { assert(p.is_ok()); assert(ply > 0 && ply < PLY_MAX); assert(*bestValue >= -VALUE_INFINITE); @@ -2606,7 +2504,7 @@ namespace { splitPoint.pvNode = pvNode; splitPoint.bestValue = *bestValue; splitPoint.mp = mp; - splitPoint.moveCount = *moveCount; + splitPoint.moveCount = moveCount; splitPoint.pos = &p; splitPoint.parentSstack = ss; for (i = 0; i < ActiveThreads; i++) @@ -2666,28 +2564,23 @@ namespace { } - // 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() { + void ThreadsManager::wake_sleeping_thread(int threadID) { - assert(AllThreadsShouldSleep); - assert(ActiveThreads > 0); + assert(threadID > 0); + assert(threads[threadID].state == THREAD_SLEEPING); - AllThreadsShouldSleep = false; - - if (ActiveThreads == 1) - return; + AllThreadsShouldSleep = false; // Avoid the woken up thread comes back to sleep #if !defined(_MSC_VER) - pthread_mutex_lock(&WaitLock); - pthread_cond_broadcast(&WaitCond); - pthread_mutex_unlock(&WaitLock); + pthread_mutex_lock(&WaitLock); + pthread_cond_signal(&WaitCond[threadID]); + pthread_mutex_unlock(&WaitLock); #else - for (int i = 1; i < MAX_THREADS; i++) - SetEvent(SitIdleEvent[i]); + SetEvent(SitIdleEvent[threadID]); #endif - } @@ -2697,7 +2590,7 @@ namespace { void ThreadsManager::put_threads_to_sleep() { - assert(!AllThreadsShouldSleep); + assert(!AllThreadsShouldSleep || ActiveThreads == 1); // This makes the threads to go to sleep AllThreadsShouldSleep = true; @@ -2716,7 +2609,7 @@ namespace { // Initialize search stack init_ss_array(ss, PLY_MAX_PLUS_2); - ss[0].eval = VALUE_NONE; + ss[0].eval = ss[0].evalMargin = VALUE_NONE; count = 0; // Generate all legal moves