X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=3b25b6533db24730049f20f156ebffa6b6e82bd3;hp=473bf46dd4e00a835f7c648c63b37da2852aa4a5;hb=e8e5b9f537a4b8b062b48f584f184f254385b276;hpb=70b1b79264b2a160f72dd2aa92c2f80045e4cd83 diff --git a/src/search.cpp b/src/search.cpp index 473bf46d..3b25b653 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -90,8 +90,7 @@ namespace { size_t MultiPV, UCIMultiPV, PVIdx; TimeManager TimeMgr; int BestMoveChanges; - int SkillLevel; - bool SkillLevelEnabled, Chess960; + bool Chess960; Value DrawValue[COLOR_NB]; History H; @@ -107,9 +106,24 @@ namespace { Value value_to_tt(Value v, int ply); Value value_from_tt(Value v, int ply); bool connected_threat(const Position& pos, Move m, Move threat); - Move do_skill_level(); string uci_pv(const Position& pos, int depth, Value alpha, Value beta); + struct Skill { + Skill(int l) : level(l), best(MOVE_NONE) {} + ~Skill() { + if (enabled()) // Swap best PV line with the sub-optimal one + std::swap(RootMoves[0], *std::find(RootMoves.begin(), + RootMoves.end(), best ? best : pick_move())); + } + + bool enabled() const { return level < 20; } + bool time_to_pick(int depth) const { return depth == 1 + level; } + Move pick_move(); + + int level; + Move best; + }; + } // namespace @@ -209,14 +223,6 @@ void Search::think() { } } - UCIMultiPV = Options["MultiPV"]; - SkillLevel = Options["Skill Level"]; - - // Do we have to play with skill handicap? In this case enable MultiPV that - // we will use behind the scenes to retrieve a set of possible moves. - SkillLevelEnabled = (SkillLevel < 20); - MultiPV = (SkillLevelEnabled ? std::max(UCIMultiPV, (size_t)4) : UCIMultiPV); - if (Options["Use Search Log"]) { Log log(Options["Search Log Filename"]); @@ -287,15 +293,21 @@ namespace { int depth, prevBestMoveChanges; Value bestValue, alpha, beta, delta; bool bestMoveNeverChanged = true; - Move skillBest = MOVE_NONE; memset(ss, 0, 4 * sizeof(Stack)); depth = BestMoveChanges = 0; bestValue = delta = -VALUE_INFINITE; ss->currentMove = MOVE_NULL; // Hack to skip update gains + UCIMultiPV = Options["MultiPV"]; + Skill skill(Options["Skill Level"]); + + // Do we have to play with skill handicap? In this case enable MultiPV that + // we will use behind the scenes to retrieve a set of possible moves. + MultiPV = skill.enabled() ? std::max(UCIMultiPV, (size_t)4) : UCIMultiPV; + // Iterative deepening loop until requested to stop or target depth reached - while (!Signals.stop && ++depth <= MAX_PLY && (!Limits.depth || depth <= Limits.depth)) + while (++depth <= MAX_PLY && !Signals.stop && (!Limits.depth || depth <= Limits.depth)) { // Save last iteration's scores before first PV line is searched and all // the move scores but the (new) PV are set to -VALUE_INFINITE. @@ -337,37 +349,37 @@ namespace { // the already searched PV lines are preserved. sort(RootMoves.begin() + PVIdx, RootMoves.end()); - // In case we have found an exact score and we are going to leave - // the fail high/low loop then reorder the PV moves, otherwise - // leave the last PV move in its position so to be searched again. - // Of course this is needed only in MultiPV search. - if (PVIdx && bestValue > alpha && bestValue < beta) - sort(RootMoves.begin(), RootMoves.begin() + PVIdx); - // Write PV back to transposition table in case the relevant // entries have been overwritten during the search. for (size_t i = 0; i <= PVIdx; i++) RootMoves[i].insert_pv_in_tt(pos); - // If search has been stopped exit the aspiration window loop. - // Sorting and writing PV back to TT is safe becuase RootMoves - // is still valid, although refers to previous iteration. + // If search has been stopped return immediately. Sorting and + // writing PV back to TT is safe becuase RootMoves is still + // valid, although refers to previous iteration. if (Signals.stop) + return; + + // In case of failing high/low increase aspiration window and + // research, otherwise exit the loop. + if (bestValue > alpha && bestValue < beta) break; - // Send full PV info to GUI if we are going to leave the loop or - // if we have a fail high/low and we are deep in the search. - if ((bestValue > alpha && bestValue < beta) || Time::now() - SearchTime > 2000) + // Give some update (without cluttering the UI) before to research + if (Time::now() - SearchTime > 3000) sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl; - // In case of failing high/low increase aspiration window and - // research, otherwise exit the fail high/low loop. - if (bestValue >= beta) + if (abs(bestValue) >= VALUE_KNOWN_WIN) + { + alpha = -VALUE_INFINITE; + beta = VALUE_INFINITE; + } + else if (bestValue >= beta) { beta += delta; delta += delta / 2; } - else if (bestValue <= alpha) + else { Signals.failedLowAtRoot = true; Signals.stopOnPonderhit = false; @@ -375,25 +387,20 @@ namespace { alpha -= delta; delta += delta / 2; } - else - break; - - // Search with full window in case we have a win/mate score - if (abs(bestValue) >= VALUE_KNOWN_WIN) - { - alpha = -VALUE_INFINITE; - beta = VALUE_INFINITE; - } assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE); } + + // Sort the PV lines searched so far and update the GUI + sort(RootMoves.begin(), RootMoves.begin() + PVIdx); + sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl; } - // Skills: Do we need to pick now the best move ? - if (SkillLevelEnabled && depth == 1 + SkillLevel) - skillBest = do_skill_level(); + // Do we need to pick now the sub-optimal best move ? + if (skill.enabled() && skill.time_to_pick(depth)) + skill.pick_move(); - if (!Signals.stop && Options["Use Search Log"]) + if (Options["Use Search Log"]) { Log log(Options["Search Log Filename"]); log << pretty_pv(pos, depth, bestValue, Time::now() - SearchTime, &RootMoves[0].pv[0]) @@ -405,7 +412,7 @@ namespace { bestMoveNeverChanged = false; // Do we have time for the next iteration? Can we stop searching now? - if (!Signals.stop && !Signals.stopOnPonderhit && Limits.use_time_management()) + if (Limits.use_time_management() && !Signals.stopOnPonderhit) { bool stop = false; // Local variable, not the volatile Signals.stop @@ -447,15 +454,6 @@ namespace { } } } - - // When using skills swap best PV line with the sub-optimal one - if (SkillLevelEnabled) - { - if (skillBest == MOVE_NONE) // Still unassigned ? - skillBest = do_skill_level(); - - std::swap(RootMoves[0], *std::find(RootMoves.begin(), RootMoves.end(), skillBest)); - } } @@ -821,8 +819,8 @@ split_point_start: // At split points actual search starts from here // on all the other moves but the ttMove, if result is lower than ttValue minus // a margin then we extend ttMove. if ( singularExtensionNode - && !ext && move == ttMove + && !ext && pos.pl_move_is_legal(move, ci.pinned) && abs(ttValue) < VALUE_KNOWN_WIN) { @@ -1441,9 +1439,9 @@ split_point_start: // At split points actual search starts from here // When playing with strength handicap choose best move among the MultiPV set - // using a statistical rule dependent on SkillLevel. Idea by Heinz van Saanen. + // using a statistical rule dependent on 'level'. Idea by Heinz van Saanen. - Move do_skill_level() { + Move Skill::pick_move() { assert(MultiPV > 1); @@ -1456,9 +1454,9 @@ split_point_start: // At split points actual search starts from here // RootMoves are already sorted by score in descending order size_t size = std::min(MultiPV, RootMoves.size()); int variance = std::min(RootMoves[0].score - RootMoves[size - 1].score, PawnValueMg); - int weakness = 120 - 2 * SkillLevel; + int weakness = 120 - 2 * level; int max_s = -VALUE_INFINITE; - Move best = MOVE_NONE; + best = MOVE_NONE; // Choose best move. For each move score we add two terms both dependent on // weakness, one deterministic and bigger for weaker moves, and one random,