X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=851797dd22d49abf8e62d414f35289fcaf8f86fa;hp=c163e8eac590cade95af87ccab64189b38c0a677;hb=4a3b162c8cf16b2dee5f6a0899e94e018b19f483;hpb=e7cfe42d3f5bf385bcfafebeabd9eb887f0f21ce diff --git a/src/search.cpp b/src/search.cpp index c163e8ea..851797dd 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -24,6 +24,7 @@ #include #include #include +#include #include "book.h" #include "evaluate.h" @@ -128,7 +129,7 @@ namespace { inline Value futility_margin(Depth d, int mn) { - return d < 7 * ONE_PLY ? FutilityMargins[Max(d, 1)][Min(mn, 63)] + return d < 7 * ONE_PLY ? FutilityMargins[std::max(int(d), 1)][std::min(mn, 63)] : 2 * VALUE_INFINITE; } @@ -144,7 +145,7 @@ namespace { template inline Depth reduction(Depth d, int mn) { - return (Depth) Reductions[PvNode][Min(d / ONE_PLY, 63)][Min(mn, 63)]; + return (Depth) Reductions[PvNode][std::min(int(d) / ONE_PLY, 63)][std::min(mn, 63)]; } // Easy move margin. An easy move candidate must be at least this much @@ -196,7 +197,6 @@ namespace { bool connected_threat(const Position& pos, Move m, Move threat); Value refine_eval(const TTEntry* tte, Value defaultEval, int ply); void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount); - void update_gains(const Position& pos, Move move, Value before, Value after); void do_skill_level(Move* best, Move* ponder); int current_search_time(int set = 0); @@ -284,14 +284,14 @@ namespace { if ( captureOrPromotion && type_of(pos.piece_on(move_to(m))) != PAWN && ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) - - piece_value_midgame(pos.piece_on(move_to(m))) == VALUE_ZERO) + - PieceValueMidgame[pos.piece_on(move_to(m))] == VALUE_ZERO) && !is_special(m)) { result += PawnEndgameExtension[PvNode]; *dangerous = true; } - return Min(result, ONE_PLY); + return std::min(result, ONE_PLY); } } // namespace @@ -373,7 +373,7 @@ bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]) { // Set best NodesBetweenPolls interval to avoid lagging under time pressure if (Limits.maxNodes) - NodesBetweenPolls = Min(Limits.maxNodes, 30000); + NodesBetweenPolls = std::min(Limits.maxNodes, 30000); else if (Limits.time && Limits.time < 1000) NodesBetweenPolls = 1000; else if (Limits.time && Limits.time < 5000) @@ -417,7 +417,7 @@ bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]) { // 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 ? Max(UCIMultiPV, 4) : UCIMultiPV); + MultiPV = (SkillLevelEnabled ? std::max(UCIMultiPV, 4) : UCIMultiPV); // Wake up needed threads and reset maxPly counter for (int i = 0; i < Threads.size(); i++) @@ -503,7 +503,7 @@ namespace { *ponderMove = bestMove = easyMove = skillBest = skillPonder = MOVE_NONE; depth = aspirationDelta = 0; value = alpha = -VALUE_INFINITE, beta = VALUE_INFINITE; - ss->currentMove = MOVE_NULL; // Hack to skip update_gains() + ss->currentMove = MOVE_NULL; // Hack to skip update gains // Moves to search are verified and copied Rml.init(pos, searchMoves); @@ -527,7 +527,7 @@ namespace { Rml.bestMoveChanges = 0; // MultiPV loop. We perform a full root search for each PV line - for (MultiPVIdx = 0; MultiPVIdx < Min(MultiPV, (int)Rml.size()); MultiPVIdx++) + for (MultiPVIdx = 0; MultiPVIdx < std::min(MultiPV, (int)Rml.size()); MultiPVIdx++) { // Calculate dynamic aspiration window based on previous iterations if (depth >= 5 && abs(Rml[MultiPVIdx].prevScore) < VALUE_KNOWN_WIN) @@ -535,11 +535,11 @@ namespace { int prevDelta1 = bestValues[depth - 1] - bestValues[depth - 2]; int prevDelta2 = bestValues[depth - 2] - bestValues[depth - 3]; - aspirationDelta = Min(Max(abs(prevDelta1) + abs(prevDelta2) / 2, 16), 24); + aspirationDelta = std::min(std::max(abs(prevDelta1) + abs(prevDelta2) / 2, 16), 24); aspirationDelta = (aspirationDelta + 7) / 8 * 8; // Round to match grainSize - alpha = Max(Rml[MultiPVIdx].prevScore - aspirationDelta, -VALUE_INFINITE); - beta = Min(Rml[MultiPVIdx].prevScore + aspirationDelta, VALUE_INFINITE); + alpha = std::max(Rml[MultiPVIdx].prevScore - aspirationDelta, -VALUE_INFINITE); + beta = std::min(Rml[MultiPVIdx].prevScore + aspirationDelta, VALUE_INFINITE); } else { @@ -551,7 +551,7 @@ namespace { // research with bigger window until not failing high/low anymore. do { // Search starts from ss+1 to allow referencing (ss-1). This is - // needed by update_gains() and ss copy when splitting at Root. + // needed by update gains and ss copy when splitting at Root. value = search(pos, ss+1, alpha, beta, depth * ONE_PLY); // Bring to front the best move. It is critical that sorting is @@ -585,7 +585,7 @@ namespace { // protocol requires to send all the PV lines also if are still // to be searched and so refer to the previous search's score. if ((value > alpha && value < beta) || current_search_time() > 2000) - for (int i = 0; i < Min(UCIMultiPV, (int)Rml.size()); i++) + for (int i = 0; i < std::min(UCIMultiPV, (int)Rml.size()); i++) { bool updated = (i <= MultiPVIdx); @@ -607,7 +607,7 @@ namespace { // research, otherwise exit the fail high/low loop. if (value >= beta) { - beta = Min(beta + aspirationDelta, VALUE_INFINITE); + beta = std::min(beta + aspirationDelta, VALUE_INFINITE); aspirationDelta += aspirationDelta / 2; } else if (value <= alpha) @@ -615,7 +615,7 @@ namespace { AspirationFailLow = true; StopOnPonderhit = false; - alpha = Max(alpha - aspirationDelta, -VALUE_INFINITE); + alpha = std::max(alpha - aspirationDelta, -VALUE_INFINITE); aspirationDelta += aspirationDelta / 2; } else @@ -767,8 +767,8 @@ namespace { // Step 3. Mate distance pruning if (!RootNode) { - alpha = Max(value_mated_in(ss->ply), alpha); - beta = Min(value_mate_in(ss->ply+1), beta); + alpha = std::max(value_mated_in(ss->ply), alpha); + beta = std::min(value_mate_in(ss->ply+1), beta); if (alpha >= beta) return alpha; } @@ -820,8 +820,17 @@ namespace { TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin); } - // Save gain for the parent non-capture move - update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval); + // Update gain for the parent non-capture move given the static position + // evaluation before and after the move. + if ( (move = (ss-1)->currentMove) != MOVE_NULL + && (ss-1)->eval != VALUE_NONE + && ss->eval != VALUE_NONE + && pos.captured_piece_type() == PIECE_TYPE_NONE + && !is_special(move)) + { + Square to = move_to(move); + H.update_gain(pos.piece_on(to), to, -(ss-1)->eval - ss->eval); + } // Step 6. Razoring (is omitted in PV nodes) if ( !PvNode @@ -870,12 +879,12 @@ namespace { if (refinedValue - PawnValueMidgame > beta) R++; - pos.do_null_move(st); + pos.do_null_move(st); (ss+1)->skipNullMove = true; nullValue = depth-R*ONE_PLY < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO) : - search(pos, ss+1, -beta, -alpha, depth-R*ONE_PLY); (ss+1)->skipNullMove = false; - pos.undo_null_move(); + pos.do_null_move(st); if (nullValue >= beta) { @@ -1244,9 +1253,11 @@ split_point_start: // At split points actual search starts from here } // Step 20. Check for mate and stalemate - // All legal moves have been searched and if there are - // no legal moves, it must be mate or stalemate. - // If one move was excluded return fail low score. + // All legal moves have been searched and if there are no legal moves, it + // must be mate or stalemate. Note that we can have a false positive in + // case of StopRequest or thread.cutoff_occurred() are set, but this is + // harmless because return value is discarded anyhow in the parent nodes. + // If we are in a singular extension search then return a fail low score. if (!SpNode && !moveCount) return excludedMove ? oldAlpha : inCheck ? value_mated_in(ss->ply) : VALUE_DRAW; @@ -1397,7 +1408,7 @@ split_point_start: // At split points actual search starts from here && !pos.is_passed_pawn_push(move)) { futilityValue = futilityBase - + piece_value_endgame(pos.piece_on(move_to(move))) + + PieceValueEndgame[pos.piece_on(move_to(move))] + (is_enpassant(move) ? PawnValueEndgame : VALUE_ZERO); if (futilityValue < beta) @@ -1530,7 +1541,7 @@ split_point_start: // At split points actual search starts from here while (b) { victimSq = pop_1st_bit(&b); - futilityValue = futilityBase + piece_value_endgame(pos.piece_on(victimSq)); + futilityValue = futilityBase + PieceValueEndgame[pos.piece_on(victimSq)]; // Note that here we generate illegal "double move"! if ( futilityValue >= beta @@ -1654,7 +1665,7 @@ split_point_start: // At split points actual search starts from here // Case 2: If the threatened piece has value less than or equal to the // value of the threatening piece, don't prune moves which defend it. if ( pos.is_capture(threat) - && ( piece_value_midgame(pos.piece_on(tfrom)) >= piece_value_midgame(pos.piece_on(tto)) + && ( PieceValueMidgame[pos.piece_on(tfrom)] >= PieceValueMidgame[pos.piece_on(tto)] || type_of(pos.piece_on(tfrom)) == KING) && pos.move_attacks_square(m, tto)) return true; @@ -1678,8 +1689,8 @@ split_point_start: // At split points actual search starts from here Value v = value_from_tt(tte->value(), ply); return ( tte->depth() >= depth - || v >= Max(VALUE_MATE_IN_PLY_MAX, beta) - || v < Min(VALUE_MATED_IN_PLY_MAX, beta)) + || v >= std::max(VALUE_MATE_IN_PLY_MAX, beta) + || v < std::min(VALUE_MATED_IN_PLY_MAX, beta)) && ( ((tte->type() & VALUE_TYPE_LOWER) && v >= beta) || ((tte->type() & VALUE_TYPE_UPPER) && v < beta)); @@ -1724,20 +1735,6 @@ split_point_start: // At split points actual search starts from here } - // update_gains() updates the gains table of a non-capture move given - // the static position evaluation before and after the move. - - void update_gains(const Position& pos, Move m, Value before, Value after) { - - if ( m != MOVE_NULL - && before != VALUE_NONE - && after != VALUE_NONE - && pos.captured_piece_type() == PIECE_TYPE_NONE - && !is_special(m)) - H.update_gain(pos.piece_on(move_to(m)), move_to(m), -(before + after)); - } - - // current_search_time() returns the number of milliseconds which have passed // since the beginning of the current search. @@ -2013,9 +2010,9 @@ split_point_start: // At split points actual search starts from here // Rml list is already sorted by score in descending order int s; int max_s = -VALUE_INFINITE; - int size = Min(MultiPV, (int)Rml.size()); + int size = std::min(MultiPV, (int)Rml.size()); int max = Rml[0].score; - int var = Min(max - Rml[size - 1].score, PawnValueMidgame); + int var = std::min(max - Rml[size - 1].score, int(PawnValueMidgame)); int wk = 120 - 2 * SkillLevel; // PRNG sequence should be non deterministic