X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=11ba939a95153384267210921f8032ffbf5199cb;hp=44eb4ccc39d6168e3835601e6579fb4901641828;hb=4509eb1342fe282d08bd90340efaff4df5947a87;hpb=7ebb872409d23b7c745d71ce5c21bea786d81aa0 diff --git a/src/search.cpp b/src/search.cpp index 44eb4ccc..11ba939a 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -57,7 +57,7 @@ namespace { inline Value razor_margin(Depth d) { return Value(512 + 32 * d); } // Futility lookup tables (initialized at startup) and their access functions - int FutilityMoveCounts[2][32]; // [improving][depth] + int FutilityMoveCounts[2][16]; // [improving][depth] inline Value futility_margin(Depth d) { return Value(200 * d); @@ -87,8 +87,9 @@ namespace { void id_loop(Position& pos); Value value_to_tt(Value v, int ply); Value value_from_tt(Value v, int ply); + void update_pv(Move* pv, Move move, Move* childPv); void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt); - string uci_pv(const Position& pos, int depth, Value alpha, Value beta); + string uci_pv(const Position& pos, Depth depth, Value alpha, Value beta); struct Skill { Skill(int l, size_t rootSize) : level(l), @@ -101,7 +102,7 @@ namespace { } size_t candidates_size() const { return candidates; } - bool time_to_pick(int depth) const { return depth == 1 + level; } + bool time_to_pick(Depth depth) const { return depth == 1 + level; } Move pick_move(); int level; @@ -116,28 +117,26 @@ namespace { void Search::init() { - int d; // depth (ONE_PLY == 2) - int hd; // half depth (ONE_PLY == 1) - int mc; // moveCount - // Init reductions array - for (hd = 1; hd < 64; ++hd) for (mc = 1; mc < 64; ++mc) - { - double pvRed = 0.00 + log(double(hd)) * log(double(mc)) / 3.00; - double nonPVRed = 0.33 + log(double(hd)) * log(double(mc)) / 2.25; + for (int d = 1; d < 64; ++d) + for (int mc = 1; mc < 64; ++mc) + { + double pvRed = 0.00 + log(double(d)) * log(double(mc)) / 3.00; + double nonPVRed = 0.33 + log(double(d)) * log(double(mc)) / 2.25; - Reductions[1][1][hd][mc] = int8_t( pvRed >= 1.0 ? pvRed + 0.5: 0); - Reductions[0][1][hd][mc] = int8_t(nonPVRed >= 1.0 ? nonPVRed + 0.5: 0); + Reductions[1][1][d][mc] = int8_t( pvRed >= 1.0 ? pvRed + 0.5: 0); + Reductions[0][1][d][mc] = int8_t(nonPVRed >= 1.0 ? nonPVRed + 0.5: 0); - Reductions[1][0][hd][mc] = Reductions[1][1][hd][mc]; - Reductions[0][0][hd][mc] = Reductions[0][1][hd][mc]; + Reductions[1][0][d][mc] = Reductions[1][1][d][mc]; + Reductions[0][0][d][mc] = Reductions[0][1][d][mc]; - if (Reductions[0][0][hd][mc] >= 2) - Reductions[0][0][hd][mc] += 1; - } + // Increase reduction when eval is not improving + if (Reductions[0][0][d][mc] >= 2) + Reductions[0][0][d][mc] += 1; + } // Init futility move count array - for (d = 0; d < 32; ++d) + for (int d = 0; d < 16; ++d) { FutilityMoveCounts[0][d] = int(2.4 + 0.773 * pow(d + 0.00, 1.8)); FutilityMoveCounts[1][d] = int(2.9 + 1.045 * pow(d + 0.49, 1.8)); @@ -193,26 +192,19 @@ void Search::think() { sync_cout << "info depth 0 score " << UCI::format_value(RootPos.checkers() ? -VALUE_MATE : VALUE_DRAW) << sync_endl; - - goto finalize; } + else + { + for (size_t i = 0; i < Threads.size(); ++i) + Threads[i]->maxPly = 0; - // Reset the threads, still sleeping: will wake up at split time - for (size_t i = 0; i < Threads.size(); ++i) - Threads[i]->maxPly = 0; - - Threads.timer->run = true; - Threads.timer->notify_one(); // Wake up the recurring timer - - id_loop(RootPos); // Let's start searching ! - - Threads.timer->run = false; // Stop the timer + Threads.timer->run = true; + Threads.timer->notify_one(); // Wake up the recurring timer -finalize: + id_loop(RootPos); // Let's start searching ! - // When search is stopped this info is not printed - sync_cout << "info nodes " << RootPos.nodes_searched() - << " time " << Time::now() - SearchTime + 1 << sync_endl; + Threads.timer->run = false; + } // When we reach the maximum depth, we can arrive here without a raise of // Signals.stop. However, if we are pondering or in an infinite search, @@ -225,10 +217,12 @@ finalize: RootPos.this_thread()->wait_for(Signals.stop); } - // Best move could be MOVE_NONE when searching on a stalemate position - sync_cout << "bestmove " << UCI::format_move(RootMoves[0].pv[0], RootPos.is_chess960()) - << " ponder " << UCI::format_move(RootMoves[0].pv[1], RootPos.is_chess960()) - << sync_endl; + sync_cout << "bestmove " << UCI::format_move(RootMoves[0].pv[0], RootPos.is_chess960()); + + if (RootMoves[0].pv.size() > 1) + std::cout << " ponder " << UCI::format_move(RootMoves[0].pv[1], RootPos.is_chess960()); + + std::cout << sync_endl; } @@ -241,12 +235,12 @@ namespace { void id_loop(Position& pos) { Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2) - int depth; + Depth depth; Value bestValue, alpha, beta, delta; std::memset(ss-2, 0, 5 * sizeof(Stack)); - depth = 0; + depth = DEPTH_ZERO; BestMoveChanges = 0; bestValue = delta = alpha = -VALUE_INFINITE; beta = VALUE_INFINITE; @@ -265,7 +259,7 @@ namespace { multiPV = std::max(multiPV, skill.candidates_size()); // Iterative deepening loop until requested to stop or target depth reached - while (++depth < MAX_PLY && !Signals.stop && (!Limits.depth || depth <= Limits.depth)) + while (++depth < DEPTH_MAX && !Signals.stop && (!Limits.depth || depth <= Limits.depth)) { // Age out PV variability metric BestMoveChanges *= 0.5; @@ -279,7 +273,7 @@ namespace { for (PVIdx = 0; PVIdx < std::min(multiPV, RootMoves.size()) && !Signals.stop; ++PVIdx) { // Reset aspiration window starting size - if (depth >= 5) + if (depth >= 5 * ONE_PLY) { delta = Value(16); alpha = std::max(RootMoves[PVIdx].prevScore - delta,-VALUE_INFINITE); @@ -291,7 +285,7 @@ namespace { // high/low anymore. while (true) { - bestValue = search(pos, ss, alpha, beta, depth * ONE_PLY, false); + bestValue = search(pos, ss, alpha, beta, depth, false); // Bring the best move to the front. It is critical that sorting // is done with a stable algorithm because all the values but the @@ -322,18 +316,21 @@ namespace { // re-search, otherwise exit the loop. if (bestValue <= alpha) { + beta = (alpha + beta) / 2; alpha = std::max(bestValue - delta, -VALUE_INFINITE); Signals.failedLowAtRoot = true; Signals.stopOnPonderhit = false; } else if (bestValue >= beta) + { + alpha = (alpha + beta) / 2; beta = std::min(bestValue + delta, VALUE_INFINITE); - + } else break; - delta += 3 * delta / 8; + delta += delta / 2; assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE); } @@ -341,9 +338,12 @@ namespace { // Sort the PV lines searched so far and update the GUI std::stable_sort(RootMoves.begin(), RootMoves.begin() + PVIdx + 1); - if ( !Signals.stop - && ( PVIdx + 1 == std::min(multiPV, RootMoves.size()) - || Time::now() - SearchTime > 3000)) + if (Signals.stop) + sync_cout << "info nodes " << RootPos.nodes_searched() + << " time " << Time::now() - SearchTime << sync_endl; + + else if ( PVIdx + 1 == std::min(multiPV, RootMoves.size()) + || Time::now() - SearchTime > 3000) sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl; } @@ -361,7 +361,7 @@ namespace { if (Limits.use_time_management() && !Signals.stop && !Signals.stopOnPonderhit) { // Take some extra time if the best move has changed - if (depth > 4 && multiPV == 1) + if (depth > 4 * ONE_PLY && multiPV == 1) TimeMgr.pv_instability(BestMoveChanges); // Stop the search if only one legal move is available or all @@ -398,7 +398,7 @@ namespace { assert(PvNode || (alpha == beta - 1)); assert(depth > DEPTH_ZERO); - Move quietsSearched[64]; + Move pv[MAX_PLY+1], quietsSearched[64]; StateInfo st; const TTEntry *tte; SplitPoint* splitPoint; @@ -406,7 +406,7 @@ namespace { Move ttMove, move, excludedMove, bestMove; Depth ext, newDepth, predictedDepth; Value bestValue, value, ttValue, eval, nullValue, futilityValue; - bool inCheck, givesCheck, pvMove, singularExtensionNode, improving; + bool inCheck, givesCheck, singularExtensionNode, improving; bool captureOrPromotion, dangerous, doFullDepthSearch; int moveCount, quietCount; @@ -469,17 +469,13 @@ namespace { ss->ttMove = ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE; ttValue = tte ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE; - // At PV nodes we check for exact scores, whilst at non-PV nodes we check for - // a fail high/low. The biggest advantage to probing at PV nodes is to have a - // smooth experience in analysis mode. We don't probe at Root nodes otherwise - // we should also update RootMoveList to avoid bogus output. - if ( !RootNode + // At non-PV nodes we check for a fail high/low. We don't probe at PV nodes + if ( !PvNode && tte && tte->depth() >= depth && ttValue != VALUE_NONE // Only in case of TT access race - && ( PvNode ? tte->bound() == BOUND_EXACT - : ttValue >= beta ? (tte->bound() & BOUND_LOWER) - : (tte->bound() & BOUND_UPPER))) + && (ttValue >= beta ? (tte->bound() & BOUND_LOWER) + : (tte->bound() & BOUND_UPPER))) { ss->currentMove = ttMove; // Can be MOVE_NONE @@ -703,6 +699,9 @@ moves_loop: // When in check and at SpNode search starts from here << " currmovenumber " << moveCount + PVIdx << sync_endl; } + if (PvNode) + (ss+1)->pv = NULL; + ext = DEPTH_ZERO; captureOrPromotion = pos.capture_or_promotion(move); @@ -801,7 +800,6 @@ moves_loop: // When in check and at SpNode search starts from here continue; } - pvMove = PvNode && moveCount == 1; ss->currentMove = move; if (!SpNode && !captureOrPromotion && quietCount < 64) quietsSearched[quietCount++] = move; @@ -850,7 +848,7 @@ moves_loop: // When in check and at SpNode search starts from here ss->reduction = DEPTH_ZERO; } else - doFullDepthSearch = !pvMove; + doFullDepthSearch = !PvNode || moveCount > 1; // Step 16. Full depth search, when LMR is skipped or fails high if (doFullDepthSearch) @@ -867,11 +865,17 @@ moves_loop: // When in check and at SpNode search starts from here // For PV nodes only, do a full PV search on the first move or after a fail // high (in the latter case search only if value < beta), otherwise let the // parent node fail low with value <= alpha and to try another move. - if (PvNode && (pvMove || (value > alpha && (RootNode || value < beta)))) + if (PvNode && (moveCount == 1 || (value > alpha && (RootNode || value < beta)))) + { + (ss+1)->pv = pv; + (ss+1)->pv[0] = MOVE_NONE; + value = newDepth < ONE_PLY ? givesCheck ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO) : -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO) : - search(pos, ss+1, -beta, -alpha, newDepth, false); + } + // Step 17. Undo move pos.undo_move(move); @@ -896,15 +900,20 @@ moves_loop: // When in check and at SpNode search starts from here RootMove& rm = *std::find(RootMoves.begin(), RootMoves.end(), move); // PV move or new best move ? - if (pvMove || value > alpha) + if (moveCount == 1 || value > alpha) { rm.score = value; - rm.extract_pv_from_tt(pos); + rm.pv.resize(1); + + assert((ss+1)->pv); + + for (Move* m = (ss+1)->pv; *m != MOVE_NONE; ++m) + rm.pv.push_back(*m); // We record how often the best move has been changed in each // iteration. This information is used for time management: When // the best move changes frequently, we allocate some more time. - if (!pvMove) + if (moveCount > 1) ++BestMoveChanges; } else @@ -922,6 +931,9 @@ moves_loop: // When in check and at SpNode search starts from here { bestMove = SpNode ? splitPoint->bestMove = move : move; + if (PvNode && !RootNode) // Update pv even in fail-high case + update_pv(SpNode ? splitPoint->ss->pv : ss->pv, move, (ss+1)->pv); + if (PvNode && value < beta) // Update alpha! Always alpha < beta alpha = SpNode ? splitPoint->alpha = value : value; else @@ -1006,6 +1018,7 @@ moves_loop: // When in check and at SpNode search starts from here assert(PvNode || (alpha == beta - 1)); assert(depth <= DEPTH_ZERO); + Move pv[MAX_PLY+1]; StateInfo st; const TTEntry* tte; Key posKey; @@ -1014,9 +1027,12 @@ moves_loop: // When in check and at SpNode search starts from here bool givesCheck, evasionPrunable; Depth ttDepth; - // To flag BOUND_EXACT a node with eval above alpha and no available moves if (PvNode) - oldAlpha = alpha; + { + oldAlpha = alpha; // To flag BOUND_EXACT when eval above alpha and no available moves + (ss+1)->pv = pv; + ss->pv[0] = MOVE_NONE; + } ss->currentMove = bestMove = MOVE_NONE; ss->ply = (ss-1)->ply + 1; @@ -1039,12 +1055,12 @@ moves_loop: // When in check and at SpNode search starts from here ttMove = tte ? tte->move() : MOVE_NONE; ttValue = tte ? value_from_tt(tte->value(),ss->ply) : VALUE_NONE; - if ( tte + if ( !PvNode + && tte && tte->depth() >= ttDepth && ttValue != VALUE_NONE // Only in case of TT access race - && ( PvNode ? tte->bound() == BOUND_EXACT - : ttValue >= beta ? (tte->bound() & BOUND_LOWER) - : (tte->bound() & BOUND_UPPER))) + && (ttValue >= beta ? (tte->bound() & BOUND_LOWER) + : (tte->bound() & BOUND_UPPER))) { ss->currentMove = ttMove; // Can be MOVE_NONE return ttValue; @@ -1166,6 +1182,9 @@ moves_loop: // When in check and at SpNode search starts from here if (value > alpha) { + if (PvNode) // Update pv even in fail-high case + update_pv(ss->pv, move, (ss+1)->pv); + if (PvNode && value < beta) // Update alpha here! Always alpha < beta { alpha = value; @@ -1222,6 +1241,15 @@ moves_loop: // When in check and at SpNode search starts from here } + // update_pv() adds current move and appends child pv[] + + void update_pv(Move* pv, Move move, Move* childPv) { + + for (*pv++ = move; childPv && *childPv != MOVE_NONE; ) + *pv++ = *childPv++; + *pv = MOVE_NONE; + } + // update_stats() updates killers, history, countermoves and followupmoves stats after a fail-high // of a quiet move. @@ -1235,7 +1263,7 @@ moves_loop: // When in check and at SpNode search starts from here // Increase history value of the cut-off move and decrease all the other // played quiet moves. - Value bonus = Value(4 * int(depth) * int(depth)); + Value bonus = Value(int(depth) * int(depth)); History.update(pos.moved_piece(move), to_sq(move), bonus); for (int i = 0; i < quietsCnt; ++i) { @@ -1303,7 +1331,7 @@ moves_loop: // When in check and at SpNode search starts from here // requires that all (if any) unsearched PV lines are sent using a previous // search score. - string uci_pv(const Position& pos, int depth, Value alpha, Value beta) { + string uci_pv(const Position& pos, Depth depth, Value alpha, Value beta) { std::stringstream ss; Time::point elapsed = Time::now() - SearchTime + 1; @@ -1321,13 +1349,13 @@ moves_loop: // When in check and at SpNode search starts from here if (depth == 1 && !updated) continue; - int d = updated ? depth : depth - 1; + Depth d = updated ? depth : depth - ONE_PLY; Value v = updated ? RootMoves[i].score : RootMoves[i].prevScore; if (ss.rdbuf()->in_avail()) // Not at first line ss << "\n"; - ss << "info depth " << d + ss << "info depth " << d / ONE_PLY << " seldepth " << selDepth << " multipv " << i + 1 << " score " << (i == PVIdx ? UCI::format_value(v, alpha, beta) : UCI::format_value(v)) @@ -1336,7 +1364,7 @@ moves_loop: // When in check and at SpNode search starts from here << " time " << elapsed << " pv"; - for (size_t j = 0; RootMoves[i].pv[j] != MOVE_NONE; ++j) + for (size_t j = 0; j < RootMoves[i].pv.size(); ++j) ss << " " << UCI::format_move(RootMoves[i].pv[j], pos.is_chess960()); } @@ -1346,43 +1374,6 @@ moves_loop: // When in check and at SpNode search starts from here } // namespace -/// RootMove::extract_pv_from_tt() builds a PV by adding moves from the TT table. -/// We also consider both failing high nodes and BOUND_EXACT nodes here to -/// ensure that we have a ponder move even when we fail high at root. This -/// results in a long PV to print that is important for position analysis. - -void RootMove::extract_pv_from_tt(Position& pos) { - - StateInfo state[MAX_PLY], *st = state; - const TTEntry* tte; - int ply = 1; // At root ply is 1... - Move m = pv[0]; // ...instead pv[] array starts from 0 - Value expectedScore = score; - - pv.clear(); - - do { - pv.push_back(m); - - assert(MoveList(pos).contains(pv[ply - 1])); - - pos.do_move(pv[ply++ - 1], *st++); - tte = TT.probe(pos.key()); - expectedScore = -expectedScore; - - } while ( tte - && expectedScore == value_from_tt(tte->value(), ply) - && pos.pseudo_legal(m = tte->move()) // Local copy, TT could change - && pos.legal(m, pos.pinned_pieces(pos.side_to_move())) - && ply < MAX_PLY - && (!pos.is_draw() || ply <= 2)); - - pv.push_back(MOVE_NONE); // Must be zero-terminating - - while (--ply) pos.undo_move(pv[ply - 1]); -} - - /// RootMove::insert_pv_in_tt() is called at the end of a search iteration, and /// inserts the PV back into the TT. This makes sure the old PV moves are searched /// first, even if the old TT entries have been overwritten. @@ -1391,9 +1382,10 @@ void RootMove::insert_pv_in_tt(Position& pos) { StateInfo state[MAX_PLY], *st = state; const TTEntry* tte; - int idx = 0; // Ply starts from 1, we need to start from 0 + size_t idx = 0; - do { + for ( ; idx < pv.size(); ++idx) + { tte = TT.probe(pos.key()); if (!tte || tte->move() != pv[idx]) // Don't overwrite correct entries @@ -1401,9 +1393,8 @@ void RootMove::insert_pv_in_tt(Position& pos) { assert(MoveList(pos).contains(pv[idx])); - pos.do_move(pv[idx++], *st++); - - } while (pv[idx] != MOVE_NONE); + pos.do_move(pv[idx], *st++); + } while (idx) pos.undo_move(pv[--idx]); } @@ -1545,7 +1536,11 @@ void check_time() { dbg_print(); } - if (Limits.use_time_management() && !Limits.ponder) + // An engine may not stop pondering until told so by the GUI + if (Limits.ponder) + return; + + if (Limits.use_time_management()) { bool stillAtFirstMove = Signals.firstRootMove && !Signals.failedLowAtRoot