X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=71a101041404fe00b0c0ded394755632dc937158;hp=6232f0cbf3ab8477ff5bc10f5973a3b1a134341b;hb=548bae80bd1f04526667ddeeaf8f5f065c53b096;hpb=cfe59de27ddc42ac555187ae68879f2bc7bd7936 diff --git a/src/search.cpp b/src/search.cpp index 6232f0cb..71a10104 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -32,7 +32,6 @@ #include "book.h" #include "evaluate.h" #include "history.h" -#include "maxgain.h" #include "misc.h" #include "movegen.h" #include "movepick.h" @@ -215,6 +214,9 @@ namespace { IterationInfoType IterationInfo[PLY_MAX_PLUS_2]; int BestMoveChangesByIteration[PLY_MAX_PLUS_2]; + // Search window management + int AspirationDelta; + // MultiPV mode int MultiPV; @@ -264,13 +266,10 @@ namespace { // History table History H; - // MaxGain table - MaxGain MG; - /// Functions Value id_loop(const Position& pos, Move searchMoves[]); - Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value alpha, Value beta); + Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value& oldAlpha, Value& beta); Value search_pv(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID); Value search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, bool allowNullmove, int threadID, Move excludedMove = MOVE_NONE); Value qsearch(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID); @@ -287,8 +286,10 @@ namespace { bool ok_to_prune(const Position& pos, Move m, Move threat); bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply); Value refine_eval(const TTEntry* tte, Value defaultEval, int ply); + Depth calculate_reduction(double baseReduction, int moveCount, Depth depth, double reductionInhibitor); void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount); void update_killers(Move m, SearchStack& ss); + void update_gains(const Position& pos, Move move, Value before, Value after); bool fail_high_ply_1(); int current_search_time(); @@ -733,7 +734,10 @@ namespace { int prevDelta1 = IterationInfo[Iteration - 1].speculatedValue - IterationInfo[Iteration - 2].speculatedValue; int prevDelta2 = IterationInfo[Iteration - 2].speculatedValue - IterationInfo[Iteration - 3].speculatedValue; - int delta = Max(2 * abs(prevDelta1) + abs(prevDelta2), ProblemMargin); + int delta = Max(abs(prevDelta1) + abs(prevDelta2) / 2, 16); + + delta = (delta + 7) / 8 * 8; // Round to match grainSize + AspirationDelta = delta; alpha = Max(IterationInfo[Iteration - 1].value - delta, -VALUE_INFINITE); beta = Min(IterationInfo[Iteration - 1].value + delta, VALUE_INFINITE); @@ -889,11 +893,23 @@ namespace { // similar to search_pv except that it uses a different move ordering // scheme and prints some information to the standard output. - Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value alpha, Value beta) { + Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value& oldAlpha, Value& beta) { - Value oldAlpha = alpha; - Value value = -VALUE_INFINITE; + Value alpha = oldAlpha; + Value value; CheckInfo ci(pos); + int researchCount = 0; + bool isCheck = pos.is_check(); + + // Evaluate the position statically + EvalInfo ei; + if (!isCheck) + ss[0].eval = evaluate(pos, ei, 0); + else + ss[0].eval = VALUE_NONE; + + while(1) // Fail low loop + { // Loop through all the moves in the root move list for (int i = 0; i < rml.move_count() && !AbortSearch; i++) @@ -936,10 +952,15 @@ namespace { ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous); newDepth = depth + ext; + value = - VALUE_INFINITE; + + while (1) // Fail high loop + { + // Make the move, and search it pos.do_move(move, st, ci, moveIsCheck); - if (i < MultiPV) + if (i < MultiPV || value > alpha) { // Aspiration window is disabled in multi-pv case if (MultiPV > 1) @@ -995,6 +1016,46 @@ namespace { pos.undo_move(move); + if (AbortSearch || value < beta) + break; // We are not failing high + + // We are failing high and going to do a research. It's important to update score + // before research in case we run out of time while researching. + rml.set_move_score(i, value); + update_pv(ss, 0); + TT.extract_pv(pos, ss[0].pv, PLY_MAX); + rml.set_move_pv(i, ss[0].pv); + + // Print search information to the standard output + cout << "info depth " << Iteration + << " score " << value_to_string(value) + << ((value >= beta) ? " lowerbound" : + ((value <= alpha)? " upperbound" : "")) + << " time " << current_search_time() + << " nodes " << nodes_searched() + << " nps " << nps() + << " pv "; + + for (int j = 0; ss[0].pv[j] != MOVE_NONE && j < PLY_MAX; j++) + cout << ss[0].pv[j] << " "; + + cout << endl; + + if (UseLogFile) + { + ValueType type = (value >= beta ? VALUE_TYPE_LOWER + : (value <= alpha ? VALUE_TYPE_UPPER : VALUE_TYPE_EXACT)); + + LogFile << pretty_pv(pos, current_search_time(), Iteration, + nodes_searched(), value, type, ss[0].pv) << endl; + } + + // Prepare for research + researchCount++; + beta = Min(beta + AspirationDelta * (1 << researchCount), VALUE_INFINITE); + + } // End of fail high loop + // Finished searching the move. If AbortSearch is true, the search // was aborted because the user interrupted the search or because we // ran out of time. In this case, the return value of the search cannot @@ -1089,6 +1150,17 @@ namespace { FailLow = (alpha == oldAlpha); } + + if (AbortSearch || alpha > oldAlpha) + break; // End search, we are not failing low + + // Prepare for research + researchCount++; + alpha = Max(alpha - AspirationDelta * (1 << researchCount), -VALUE_INFINITE); + oldAlpha = alpha; + + } // Fail low loop + return alpha; } @@ -1156,9 +1228,18 @@ namespace { tte = TT.retrieve(pos.get_key()); } + isCheck = pos.is_check(); + if (!isCheck) + { + // Update gain statistics of the previous move that lead + // us in this position. + EvalInfo ei; + ss[ply].eval = evaluate(pos, ei, threadID); + update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval); + } + // Initialize a MovePicker object for the current position, and prepare // to search all moves - isCheck = pos.is_check(); mateThreat = pos.has_mate_threat(opposite_color(pos.side_to_move())); CheckInfo ci(pos); MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]); @@ -1334,7 +1415,7 @@ namespace { Move ttMove, move; Depth ext, newDepth; Value bestValue, staticValue, nullValue, value, futilityValue, futilityValueScaled; - bool isCheck, useFutilityPruning, singleEvasion, moveIsCheck, captureOrPromotion, dangerous; + bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous; bool mateThreat = false; int moveCount = 0; futilityValue = staticValue = bestValue = value = -VALUE_INFINITE; @@ -1378,7 +1459,7 @@ namespace { // Calculate depth dependant futility pruning parameters const int FutilityMoveCountMargin = 3 + (1 << (3 * int(depth) / 8)); - const int FutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2); + const int PostFutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2); // Evaluate the position statically if (!isCheck) @@ -1392,10 +1473,20 @@ namespace { } ss[ply].eval = staticValue; - futilityValue = staticValue + FutilityValueMargin; + futilityValue = staticValue + PostFutilityValueMargin; //FIXME: Remove me, only for split staticValue = refine_eval(tte, staticValue, ply); // Enhance accuracy with TT value if possible + update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval); } + // Do a "stand pat". If we are above beta by a good margin then + // return immediately. + // FIXME: test with added condition 'allowNullmove || depth <= OnePly' and !value_is_mate(beta) + // FIXME: test with modified condition 'depth < RazorDepth' + if ( !isCheck + && depth < SelectiveDepth + && staticValue - PostFutilityValueMargin >= beta) + return staticValue - PostFutilityValueMargin; + // Null move search if ( allowNullmove && depth > OnePly @@ -1473,7 +1564,6 @@ namespace { // to search all moves. MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]); CheckInfo ci(pos); - useFutilityPruning = depth < SelectiveDepth && !isCheck; // Loop through all legal moves until no moves remain or a beta cutoff occurs while ( bestValue < beta @@ -1519,10 +1609,41 @@ namespace { // Update current move movesSearched[moveCount++] = ss[ply].currentMove = move; + // Futility pruning for captures + // FIXME: test disabling 'Futility pruning for captures' + // FIXME: test with 'newDepth < RazorDepth' + Color them = opposite_color(pos.side_to_move()); + + if ( !isCheck + && newDepth < SelectiveDepth + && !dangerous + && pos.move_is_capture(move) + && !pos.move_is_check(move, ci) + && !move_is_promotion(move) + && move != ttMove + && !move_is_ep(move) + && (pos.type_of_piece_on(move_to(move)) != PAWN || !pos.pawn_is_passed(them, move_to(move)))) // Do not prune passed pawn captures + { + int preFutilityValueMargin = 0; + + if (newDepth >= OnePly) + preFutilityValueMargin = 112 * bitScanReverse32(int(newDepth) * int(newDepth) / 2); + + Value futilityCaptureValue = ss[ply].eval + pos.endgame_value_of_piece_on(move_to(move)) + preFutilityValueMargin + ei.futilityMargin + 90; + + if (futilityCaptureValue < beta) + { + if (futilityCaptureValue > bestValue) + bestValue = futilityCaptureValue; + continue; + } + } + // Futility pruning - if ( useFutilityPruning + if ( !isCheck && !dangerous && !captureOrPromotion + && !move_is_castle(move) && move != ttMove) { // Move count based pruning @@ -1532,13 +1653,29 @@ namespace { continue; // Value based pruning - futilityValueScaled = futilityValue - moveCount * IncrementalFutilityMargin; + Depth predictedDepth = newDepth; + + //FIXME HACK: awful code duplication + double red = 0.5 + ln(moveCount) * ln(depth / 2) / 3.0; + if (red >= 1.0) + predictedDepth -= int(floor(red * int(OnePly))); - if (futilityValueScaled < beta) + if (predictedDepth < SelectiveDepth) { - if (futilityValueScaled > bestValue) - bestValue = futilityValueScaled; - continue; + int preFutilityValueMargin = 0; + if (predictedDepth >= OnePly) + preFutilityValueMargin = 112 * bitScanReverse32(int(predictedDepth) * int(predictedDepth) / 2); + + preFutilityValueMargin += H.gain(pos.piece_on(move_from(move)), move_from(move), move_to(move)) + 45; + + futilityValueScaled = ss[ply].eval + preFutilityValueMargin - moveCount * IncrementalFutilityMargin; + + if (futilityValueScaled < beta) + { + if (futilityValueScaled > bestValue) + bestValue = futilityValueScaled; + continue; + } } } @@ -1593,7 +1730,7 @@ namespace { && idle_thread_exists(threadID) && !AbortSearch && !thread_should_stop(threadID) - && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, + && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue depth, &moveCount, &mp, threadID, false)) break; } @@ -1685,6 +1822,12 @@ namespace { else staticValue = evaluate(pos, ei, threadID); + if (!isCheck) + { + ss[ply].eval = staticValue; + update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval); + } + // Initialize "stand pat score", and return it immediately if it is // at least beta. bestValue = staticValue; @@ -1828,28 +1971,29 @@ namespace { SearchStack* ss = sp->sstack[threadID]; Value value = -VALUE_INFINITE; Move move; + int moveCount; bool isCheck = pos.is_check(); bool useFutilityPruning = sp->depth < SelectiveDepth && !isCheck; const int FutilityMoveCountMargin = 3 + (1 << (3 * int(sp->depth) / 8)); - while ( sp->bestValue < sp->beta + while ( lock_grab_bool(&(sp->lock)) + && sp->bestValue < sp->beta && !thread_should_stop(threadID) - && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE) + && (move = sp->mp->get_next_move()) != MOVE_NONE) { + moveCount = ++sp->moves; + lock_release(&(sp->lock)); + assert(move_is_ok(move)); bool moveIsCheck = pos.move_is_check(move, ci); bool captureOrPromotion = pos.move_is_capture_or_promotion(move); - lock_grab(&(sp->lock)); - int moveCount = ++sp->moves; - lock_release(&(sp->lock)); - ss[sp->ply].currentMove = move; - // Decide the new search depth. + // Decide the new search depth bool dangerous; Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous); Depth newDepth = sp->depth - OnePly + ext; @@ -1913,7 +2057,10 @@ namespace { assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); if (thread_should_stop(threadID)) + { + lock_grab(&(sp->lock)); break; + } // New best move? if (value > sp->bestValue) // Less then 2% of cases @@ -1936,7 +2083,7 @@ namespace { } } - lock_grab(&(sp->lock)); + /* Here we have the lock still grabbed */ // If this is the master thread and we have been asked to stop because of // a beta cutoff higher up in the tree, stop all slave threads. @@ -1969,24 +2116,25 @@ namespace { CheckInfo ci(pos); SearchStack* ss = sp->sstack[threadID]; Value value = -VALUE_INFINITE; + int moveCount; Move move; - while ( sp->alpha < sp->beta + while ( lock_grab_bool(&(sp->lock)) + && sp->alpha < sp->beta && !thread_should_stop(threadID) - && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE) + && (move = sp->mp->get_next_move()) != MOVE_NONE) { - bool moveIsCheck = pos.move_is_check(move, ci); - bool captureOrPromotion = pos.move_is_capture_or_promotion(move); + moveCount = ++sp->moves; + lock_release(&(sp->lock)); assert(move_is_ok(move)); - lock_grab(&(sp->lock)); - int moveCount = ++sp->moves; - lock_release(&(sp->lock)); + bool moveIsCheck = pos.move_is_check(move, ci); + bool captureOrPromotion = pos.move_is_capture_or_promotion(move); ss[sp->ply].currentMove = move; - // Decide the new search depth. + // Decide the new search depth bool dangerous; Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous); Depth newDepth = sp->depth - OnePly + ext; @@ -2046,7 +2194,10 @@ namespace { assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); if (thread_should_stop(threadID)) + { + lock_grab(&(sp->lock)); break; + } // New best move? if (value > sp->bestValue) // Less then 2% of cases @@ -2085,7 +2236,7 @@ namespace { } } - lock_grab(&(sp->lock)); + /* Here we have the lock still grabbed */ // If this is the master thread and we have been asked to stop because of // a beta cutoff higher up in the tree, stop all slave threads. @@ -2464,9 +2615,8 @@ namespace { Square mfrom, mto, tfrom, tto; - // Prune if there isn't any threat move and - // is not a castling move (common case). - if (threat == MOVE_NONE && !move_is_castle(m)) + // Prune if there isn't any threat move + if (threat == MOVE_NONE) return true; mfrom = move_from(m); @@ -2474,15 +2624,11 @@ namespace { tfrom = move_from(threat); tto = move_to(threat); - // Case 1: Castling moves are never pruned - if (move_is_castle(m)) - return false; - - // Case 2: Don't prune moves which move the threatened piece + // Case 1: Don't prune moves which move the threatened piece if (mfrom == tto) return false; - // Case 3: If the threatened piece has value less than or equal to the + // Case 2: If the threatened piece has value less than or equal to the // value of the threatening piece, don't prune move which defend it. if ( pos.move_is_capture(threat) && ( pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto) @@ -2490,7 +2636,7 @@ namespace { && pos.move_attacks_square(m, tto)) return false; - // Case 4: If the moving piece in the threatened move is a slider, don't + // Case 3: If the moving piece in the threatened move is a slider, don't // prune safe moves which block its ray. if ( piece_is_slider(pos.piece_on(tfrom)) && bit_is_set(squares_between(tfrom, tto), mto) @@ -2534,6 +2680,20 @@ namespace { return defaultEval; } + // calculate_reduction() returns reduction in plies based on + // moveCount and depth. Reduction is always at least one ply. + + Depth calculate_reduction(double baseReduction, int moveCount, Depth depth, double reductionInhibitor) { + + double red = baseReduction + ln(moveCount) * ln(depth / 2) / reductionInhibitor; + + if (red >= 1.0) + return Depth(int(floor(red * int(OnePly)))); + else + return Depth(0); + + } + // update_history() registers a good move that produced a beta-cutoff // in history and marks as failures all the other moves of that ply. @@ -2571,6 +2731,21 @@ namespace { } + // 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() == NO_PIECE_TYPE + && !move_is_castle(m) + && !move_is_promotion(m)) + H.set_gain(pos.piece_on(move_to(m)), move_from(m), move_to(m), -(before + after)); + } + + // fail_high_ply_1() checks if some thread is currently resolving a fail // high at ply 1 at the node below the first root node. This information // is used for time management.