X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=ed8d9ff76d19a6327b4093ca6ef4457dedfd301e;hp=205e992723108b2b90c750706235410c7da1baf9;hb=1b5b900a290631f04e4c8683e68eb9a9ba682196;hpb=ce84ab6e9dc64e0c137c2785a36e4a345a8a5a95 diff --git a/src/search.cpp b/src/search.cpp index 205e9927..ed8d9ff7 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -127,7 +127,6 @@ namespace { }; EasyMoveManager EasyMove; - double BestMoveChanges; Value DrawValue[COLOR_NB]; CounterMovesHistoryStats CounterMovesHistory; @@ -220,11 +219,11 @@ uint64_t Search::perft(Position& pos, Depth depth) { template uint64_t Search::perft(Position&, Depth); -/// MainThread::think() is called by the main thread when the program receives +/// MainThread::search() is called by the main thread when the program receives /// the UCI 'go' command. It searches from root position and at the end prints /// the "bestmove" to output. -void MainThread::think() { +void MainThread::search() { Color us = rootPos.side_to_move(); Time.init(Limits, us, rootPos.game_ply()); @@ -290,16 +289,15 @@ void MainThread::think() { { th->maxPly = 0; th->rootDepth = DEPTH_ZERO; - th->searching = true; if (th != this) { th->rootPos = Position(rootPos, th); th->rootMoves = rootMoves; - th->notify_one(); // Wake up the thread and start searching + th->start_searching(); } } - search(true); // Let's start searching! + Thread::search(); // Let's start searching! } // When playing in 'nodes as time' mode, subtract the searched nodes from @@ -324,17 +322,21 @@ void MainThread::think() { // Wait until all threads have finished for (Thread* th : Threads) if (th != this) - th->wait_while(th->searching); + th->wait_for_search_finished(); - // Check if there are threads with a better score than main thread. + // Check if there are threads with a better score than main thread Thread* bestThread = this; - for (Thread* th : Threads) - if ( th->completedDepth > bestThread->completedDepth - && th->rootMoves[0].score > bestThread->rootMoves[0].score) - bestThread = th; + if ( !this->easyMovePlayed + && Options["MultiPV"] == 1 + && !Skill(Options["Skill Level"]).enabled()) + { + for (Thread* th : Threads) + if ( th->completedDepth > bestThread->completedDepth + && th->rootMoves[0].score > bestThread->rootMoves[0].score) + bestThread = th; + } - // Send new PV when needed. - // FIXME: Breaks multiPV, and skill levels + // Send new PV when needed if (bestThread != this) sync_cout << UCI::pv(bestThread->rootPos, bestThread->completedDepth, -VALUE_INFINITE, VALUE_INFINITE) << sync_endl; @@ -351,11 +353,12 @@ void MainThread::think() { // repeatedly with increasing depth until the allocated thinking time has been // consumed, user stops the search, or the maximum search depth is reached. -void Thread::search(bool isMainThread) { +void Thread::search() { Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2) Value bestValue, alpha, beta, delta; Move easyMove = MOVE_NONE; + MainThread* mainThread = (this == Threads.main() ? Threads.main() : nullptr); std::memset(ss-2, 0, 5 * sizeof(Stack)); @@ -363,11 +366,12 @@ void Thread::search(bool isMainThread) { beta = VALUE_INFINITE; completedDepth = DEPTH_ZERO; - if (isMainThread) + if (mainThread) { easyMove = EasyMove.get(rootPos.key()); EasyMove.clear(); - BestMoveChanges = 0; + mainThread->easyMovePlayed = mainThread->failedLow = false; + mainThread->bestMoveChanges = 0; TT.new_search(); } @@ -384,13 +388,33 @@ void Thread::search(bool isMainThread) { // Iterative deepening loop until requested to stop or target depth reached while (++rootDepth < DEPTH_MAX && !Signals.stop && (!Limits.depth || rootDepth <= Limits.depth)) { - // Set up the new depth for the helper threads - if (!isMainThread) - rootDepth = std::min(DEPTH_MAX - ONE_PLY, Threads.main()->rootDepth + Depth(int(2.2 * log(1 + this->idx)))); + // Set up the new depth for the helper threads skipping in average each + // 2nd ply (using a half density map similar to a Hadamard matrix). + if (!mainThread) + { + int d = rootDepth + rootPos.game_ply(); + + if (idx <= 6 || idx > 24) + { + if (((d + idx) >> (msb(idx + 1) - 1)) % 2) + continue; + } + else + { + // Table of values of 6 bits with 3 of them set + static const int HalfDensityMap[] = { + 0x07, 0x0b, 0x0d, 0x0e, 0x13, 0x16, 0x19, 0x1a, 0x1c, + 0x23, 0x25, 0x26, 0x29, 0x2c, 0x31, 0x32, 0x34, 0x38 + }; + + if ((HalfDensityMap[idx - 7] >> (d % 6)) & 1) + continue; + } + } // Age out PV variability metric - if (isMainThread) - BestMoveChanges *= 0.5; + if (mainThread) + mainThread->bestMoveChanges *= 0.505, mainThread->failedLow = false; // Save the last iteration's scores before first PV line is searched and // all the move scores except the (new) PV are set to -VALUE_INFINITE. @@ -436,7 +460,7 @@ void Thread::search(bool isMainThread) { // When failing high/low give some update (without cluttering // the UI) before a re-search. - if ( isMainThread + if ( mainThread && multiPV == 1 && (bestValue <= alpha || bestValue >= beta) && Time.elapsed() > 3000) @@ -449,9 +473,9 @@ void Thread::search(bool isMainThread) { beta = (alpha + beta) / 2; alpha = std::max(bestValue - delta, -VALUE_INFINITE); - if (isMainThread) + if (mainThread) { - Signals.failedLowAtRoot = true; + mainThread->failedLow = true; Signals.stopOnPonderhit = false; } } @@ -471,7 +495,7 @@ void Thread::search(bool isMainThread) { // Sort the PV lines searched so far and update the GUI std::stable_sort(rootMoves.begin(), rootMoves.begin() + PVIdx + 1); - if (!isMainThread) + if (!mainThread) break; if (Signals.stop) @@ -485,7 +509,7 @@ void Thread::search(bool isMainThread) { if (!Signals.stop) completedDepth = rootDepth; - if (!isMainThread) + if (!mainThread) continue; // If skill level is enabled and time is up, pick a sub-optimal best move @@ -505,16 +529,16 @@ void Thread::search(bool isMainThread) { { // Take some extra time if the best move has changed if (rootDepth > 4 * ONE_PLY && multiPV == 1) - Time.pv_instability(BestMoveChanges); + Time.pv_instability(mainThread->bestMoveChanges); // Stop the search if only one legal move is available or all // of the available time has been used or we matched an easyMove // from the previous search and just did a fast verification. if ( rootMoves.size() == 1 - || Time.elapsed() > Time.available() - || ( rootMoves[0].pv[0] == easyMove - && BestMoveChanges < 0.03 - && Time.elapsed() > Time.available() / 10)) + || Time.elapsed() > Time.available() * (mainThread->failedLow ? 641 : 315) / 640 + || (mainThread->easyMovePlayed = ( rootMoves[0].pv[0] == easyMove + && mainThread->bestMoveChanges < 0.03 + && Time.elapsed() > Time.available() / 8))) { // If we are allowed to ponder do not stop the search now but // keep pondering until the GUI sends "ponderhit" or "stop". @@ -532,15 +556,12 @@ void Thread::search(bool isMainThread) { } } - searching = false; - notify_one(); // Wake up main thread if is sleeping waiting for us - - if (!isMainThread) + if (!mainThread) return; // Clear any candidate easy move that wasn't stable for the last search // iterations; the second condition prevents consecutive fast moves. - if (EasyMove.stableCnt < 6 || Time.elapsed() < Time.available()) + if (EasyMove.stableCnt < 6 || mainThread->easyMovePlayed) EasyMove.clear(); // If skill level is enabled, swap best PV line with the sub-optimal one @@ -583,15 +604,15 @@ namespace { ss->ply = (ss-1)->ply + 1; // Check for available remaining time - if (thisThread->resetCallsCnt.load(std::memory_order_relaxed)) + if (thisThread->resetCalls.load(std::memory_order_relaxed)) { - thisThread->resetCallsCnt = false; + thisThread->resetCalls = false; thisThread->callsCnt = 0; } if (++thisThread->callsCnt > 4096) { for (Thread* th : Threads) - th->resetCallsCnt = true; + th->resetCalls = true; check_time(); } @@ -621,8 +642,8 @@ namespace { assert(0 <= ss->ply && ss->ply < MAX_PLY); - ss->currentMove = ss->ttMove = (ss+1)->excludedMove = bestMove = MOVE_NONE; - (ss+1)->skipEarlyPruning = false; (ss+1)->reduction = DEPTH_ZERO; + ss->currentMove = (ss+1)->excludedMove = bestMove = MOVE_NONE; + (ss+1)->skipEarlyPruning = false; (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE; // Step 4. Transposition table lookup. We don't want the score of a partial @@ -632,8 +653,8 @@ namespace { posKey = excludedMove ? pos.exclusion_key() : pos.key(); tte = TT.probe(posKey, ttHit); ttValue = ttHit ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE; - ss->ttMove = ttMove = RootNode ? thisThread->rootMoves[thisThread->PVIdx].pv[0] - : ttHit ? tte->move() : MOVE_NONE; + ttMove = RootNode ? thisThread->rootMoves[thisThread->PVIdx].pv[0] + : ttHit ? tte->move() : MOVE_NONE; // At non-PV nodes we check for an early TT cutoff if ( !PvNode @@ -861,15 +882,10 @@ moves_loop: // When in check search starts from here ss->moveCount = ++moveCount; - if (RootNode && thisThread == Threads.main()) - { - Signals.firstRootMove = (moveCount == 1); - - if (Time.elapsed() > 3000) - sync_cout << "info depth " << depth / ONE_PLY - << " currmove " << UCI::move(move, pos.is_chess960()) - << " currmovenumber " << moveCount + thisThread->PVIdx << sync_endl; - } + if (RootNode && thisThread == Threads.main() && Time.elapsed() > 3000) + sync_cout << "info depth " << depth / ONE_PLY + << " currmove " << UCI::move(move, pos.is_chess960()) + << " currmovenumber " << moveCount + thisThread->PVIdx << sync_endl; if (PvNode) (ss+1)->pv = nullptr; @@ -923,7 +939,8 @@ moves_loop: // When in check search starts from here continue; // History based pruning - if ( depth <= 3 * ONE_PLY + if ( depth <= 4 * ONE_PLY + && move != ss->killers[0] && thisThread->history[pos.moved_piece(move)][to_sq(move)] < VALUE_ZERO && cmh[pos.moved_piece(move)][to_sq(move)] < VALUE_ZERO) continue; @@ -966,36 +983,33 @@ moves_loop: // When in check search starts from here // re-searched at full depth. if ( depth >= 3 * ONE_PLY && moveCount > 1 - && !captureOrPromotion - && move != ss->killers[0] - && move != ss->killers[1]) + && !captureOrPromotion) { - ss->reduction = reduction(improving, depth, moveCount); + Depth r = reduction(improving, depth, moveCount); // Increase reduction for cut nodes and moves with a bad history if ( (!PvNode && cutNode) || ( thisThread->history[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO && cmh[pos.piece_on(to_sq(move))][to_sq(move)] <= VALUE_ZERO)) - ss->reduction += ONE_PLY; + r += ONE_PLY; // Decrease reduction for moves with a good history if ( thisThread->history[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO && cmh[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO) - ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY); + r = std::max(DEPTH_ZERO, r - ONE_PLY); // Decrease reduction for moves that escape a capture - if ( ss->reduction + if ( r && type_of(move) == NORMAL && type_of(pos.piece_on(to_sq(move))) != PAWN && pos.see(make_move(to_sq(move), from_sq(move))) < VALUE_ZERO) - ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY); + r = std::max(DEPTH_ZERO, r - ONE_PLY); - Depth d = std::max(newDepth - ss->reduction, ONE_PLY); + Depth d = std::max(newDepth - r, ONE_PLY); value = -search(pos, ss+1, -(alpha+1), -alpha, d, true); - doFullDepthSearch = (value > alpha && ss->reduction != DEPTH_ZERO); - ss->reduction = DEPTH_ZERO; + doFullDepthSearch = (value > alpha && r != DEPTH_ZERO); } else doFullDepthSearch = !PvNode || moveCount > 1; @@ -1053,7 +1067,7 @@ moves_loop: // When in check search starts from here // iteration. This information is used for time management: When // the best move changes frequently, we allocate some more time. if (moveCount > 1 && thisThread == Threads.main()) - ++BestMoveChanges; + ++static_cast(thisThread)->bestMoveChanges; } else // All other moves but the PV are set to the lowest value: this is @@ -1487,19 +1501,9 @@ moves_loop: // When in check search starts from here if (Limits.ponder) return; - if (Limits.use_time_management()) - { - bool stillAtFirstMove = Signals.firstRootMove.load(std::memory_order_relaxed) - && !Signals.failedLowAtRoot.load(std::memory_order_relaxed) - && elapsed > Time.available() * 3 / 4; - - if (stillAtFirstMove || elapsed > Time.maximum() - 10) - Signals.stop = true; - } - else if (Limits.movetime && elapsed >= Limits.movetime) - Signals.stop = true; - - else if (Limits.nodes && Threads.nodes_searched() >= Limits.nodes) + if ( (Limits.use_time_management() && elapsed > Time.maximum() - 10) + || (Limits.movetime && elapsed >= Limits.movetime) + || (Limits.nodes && Threads.nodes_searched() >= Limits.nodes)) Signals.stop = true; }