X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=723d1ba942bb64860ce005ab8e3a1f8033f1f99d;hp=fca542e09278d94cb4ffe08169513075cb78e778;hb=f7722d4de701ad8f58f254cf165cc23c7cf43156;hpb=2feeb206ff3dfa2a8419c4541383afd7eee2e5ed diff --git a/src/search.cpp b/src/search.cpp index fca542e0..723d1ba9 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -88,7 +88,7 @@ namespace { 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(); @@ -284,14 +284,22 @@ 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 + 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(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 sp_search(SplitPoint* sp, int threadID); + 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); @@ -957,7 +965,7 @@ namespace { // search<>() is the main search function for both PV and non-PV nodes - template + template Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE); @@ -980,6 +988,16 @@ namespace { int threadID = pos.thread(); refinedValue = bestValue = value = -VALUE_INFINITE; oldAlpha = alpha; + isCheck = pos.is_check(); + + if (SplitPoint) + { + tte = NULL; + ttMove = excludedMove = MOVE_NONE; + threatMove = ss->sp->threatMove; + mateThreat = ss->sp->mateThreat; + goto split_start; + } // Step 1. Initialize node and poll. Polling can abort search ThreadsMgr.incrementNodeCounter(threadID); @@ -1034,7 +1052,6 @@ 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; else if (tte) @@ -1165,13 +1182,17 @@ namespace { if (PvNode) mateThreat = pos.has_mate_threat(); +split_start: + // Initialize a MovePicker object for the current position - MovePicker mp = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta)); + MovePicker mpBase = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta)); + MovePicker& mp = SplitPoint ? *ss->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 = SplitPoint ? false : isCheck && mp.number_of_evasions() == 1; + futilityBase = SplitPoint ? ss->eval : ss->eval + evalMargin; + singularExtensionNode = !SplitPoint + && depth >= SingularExtensionDepth[PvNode] && tte && tte->move() && !excludedMove // Do not allow recursive singular extension search @@ -1180,10 +1201,22 @@ namespace { // Step 10. Loop through moves // Loop through all legal moves until no moves remain or a beta cutoff occurs + if (SplitPoint) + { + lock_grab(&(ss->sp->lock)); + bestValue = ss->sp->bestValue; + } + while ( bestValue < beta && (move = mp.get_next_move()) != MOVE_NONE && !ThreadsMgr.thread_should_stop(threadID)) { + if (SplitPoint) + { + moveCount = ++ss->sp->moveCount; + lock_release(&(ss->sp->lock)); + } + assert(move_is_ok(move)); if (move == excludedMove) @@ -1235,8 +1268,12 @@ 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 (SplitPoint) + lock_grab(&(ss->sp->lock)); continue; + } // Value based pruning // We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth, @@ -1247,7 +1284,13 @@ namespace { if (futilityValueScaled < beta) { - if (futilityValueScaled > bestValue) + if (SplitPoint) + { + lock_grab(&(ss->sp->lock)); + if (futilityValueScaled > ss->sp->bestValue) + ss->sp->bestValue = futilityValueScaled; + } + else if (futilityValueScaled > bestValue) bestValue = futilityValueScaled; continue; } @@ -1258,7 +1301,7 @@ namespace { // Step extra. pv search (only in PV nodes) // The first move in list is the expected PV - if (PvNode && moveCount == 1) + if (!SplitPoint && 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 @@ -1276,6 +1319,7 @@ namespace { ss->reduction = reduction(depth, moveCount); if (ss->reduction) { + alpha = SplitPoint ? ss->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 +1335,7 @@ namespace { assert(newDepth - ONE_PLY >= ONE_PLY); ss->reduction = ONE_PLY; + alpha = SplitPoint ? ss->sp->alpha : alpha; value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1); doFullDepthSearch = (value > alpha); } @@ -1300,6 +1345,7 @@ namespace { // Step 15. Full depth search if (doFullDepthSearch) { + alpha = SplitPoint ? ss->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 +1364,21 @@ namespace { assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); // Step 17. Check for new best move - if (value > bestValue) + if (SplitPoint) + { + lock_grab(&(ss->sp->lock)); + bestValue = ss->sp->bestValue; + alpha = ss->sp->alpha; + } + + if (value > bestValue && !(SplitPoint && ThreadsMgr.thread_should_stop(threadID))) { bestValue = value; if (value > alpha) { + if (SplitPoint && (!PvNode || value >= beta)) + ss->sp->stopRequest = true; + if (PvNode && value < beta) // We want always alpha < beta alpha = value; @@ -1331,10 +1387,17 @@ namespace { ss->bestMove = move; } + if (SplitPoint) + { + ss->sp->bestValue = bestValue; + ss->sp->alpha = alpha; + ss->sp->parentSstack->bestMove = ss->bestMove; + } } // Step 18. Check for split - if ( depth >= MinimumSplitDepth + if ( !SplitPoint + && depth >= MinimumSplitDepth && ThreadsMgr.active_threads() > 1 && bestValue < beta && ThreadsMgr.available_thread_exists(threadID) @@ -1342,7 +1405,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 (SplitPoint) + { + /* Here we have the lock still grabbed */ + ss->sp->slaves[threadID] = 0; + lock_release(&(ss->sp->lock)); + return bestValue; } // Step 19. Check for mate and stalemate @@ -1555,11 +1626,21 @@ namespace { // care of after we return from the split point. template - void sp_search(SplitPoint* sp, int threadID) { + 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; @@ -1568,18 +1649,20 @@ namespace { 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(); - 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 + while ( sp->bestValue < beta + && (move = mp.get_next_move()) != MOVE_NONE && !ThreadsMgr.thread_should_stop(threadID)) { moveCount = ++sp->moveCount; @@ -1592,7 +1675,7 @@ namespace { // Step 11. Decide the new search depth ext = extension(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous); - newDepth = sp->depth - ONE_PLY + ext; + newDepth = depth - ONE_PLY + ext; // Update current move ss->currentMove = move; @@ -1605,8 +1688,8 @@ namespace { && !move_is_castle(move)) { // Move count based pruning - if ( moveCount >= futility_move_count(sp->depth) - && !(sp->threatMove && connected_threat(pos, move, sp->threatMove)) + if ( moveCount >= futility_move_count(depth) + && !(threatMove && connected_threat(pos, move, threatMove)) && sp->bestValue > value_mated_in(PLY_MAX)) { lock_grab(&(sp->lock)); @@ -1614,11 +1697,11 @@ namespace { } // Value based pruning - Depth predictedDepth = newDepth - reduction(sp->depth, moveCount); + 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 < sp->beta) + if (futilityValueScaled < beta) { lock_grab(&(sp->lock)); @@ -1640,13 +1723,13 @@ namespace { && !move_is_castle(move) && !move_is_killer(move, ss)) { - ss->reduction = reduction(sp->depth, moveCount); + 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, sp->ply+1) - : - search(pos, ss+1, -(localAlpha+1), -localAlpha, d, sp->ply+1); + 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); } @@ -1660,7 +1743,7 @@ namespace { ss->reduction = ONE_PLY; Value localAlpha = sp->alpha; - value = -search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, sp->ply+1); + value = -search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, ply+1); doFullDepthSearch = (value > localAlpha); } ss->reduction = DEPTH_ZERO; // Restore original reduction @@ -1670,15 +1753,15 @@ namespace { 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); + 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 < 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); + 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 @@ -1692,13 +1775,12 @@ namespace { if (value > sp->bestValue && !ThreadsMgr.thread_should_stop(threadID)) { sp->bestValue = value; - - if (sp->bestValue > sp->alpha) + if (value > sp->alpha) { - if (!PvNode || value >= sp->beta) + if (!PvNode || value >= beta) sp->stopRequest = true; - if (PvNode && value < sp->beta) // This guarantees that always: sp->alpha < sp->beta + if (PvNode && value < beta) // We want always sp->alpha < beta sp->alpha = value; sp->parentSstack->bestMove = ss->bestMove = move; @@ -2151,6 +2233,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; @@ -2363,9 +2446,9 @@ namespace { threads[threadID].state = THREAD_SEARCHING; if (threads[threadID].splitPoint->pvNode) - sp_search(threads[threadID].splitPoint, threadID); + do_sp_search(threads[threadID].splitPoint, threadID); else - sp_search(threads[threadID].splitPoint, threadID); + do_sp_search(threads[threadID].splitPoint, threadID); assert(threads[threadID].state == THREAD_SEARCHING); @@ -2384,6 +2467,8 @@ namespace { lock_grab(&(sp->lock)); lock_release(&(sp->lock)); + // In helpful master concept a master can help only a sub-tree, and + // because here is all finished is not possible master is booked. assert(threads[threadID].state == THREAD_AVAILABLE); threads[threadID].state = THREAD_SEARCHING; @@ -2461,13 +2546,11 @@ namespace { void ThreadsManager::exit_threads() { - ActiveThreads = MAX_THREADS; // HACK - AllThreadsShouldSleep = true; // HACK + 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(); - // This makes the threads to exit idle_loop() - AllThreadsShouldExit = true; - // Wait for thread termination for (int i = 1; i < MAX_THREADS; i++) while (threads[i].state != THREAD_TERMINATED) {} @@ -2490,9 +2573,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; } @@ -2517,12 +2600,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 @@ -2564,7 +2644,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); @@ -2604,7 +2684,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++)