X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=e205db6fa163d56b5dfccc5efbb8692b6c22a8cf;hp=c3c2925fcf70f5dfff640875fd1295be5d924606;hb=27393ebae2e689c86f77777d3ba9aae39b9c89b8;hpb=bb968fd42a6e3c14755332f5a4c4829faaf4f9de diff --git a/src/search.cpp b/src/search.cpp index c3c2925f..e205db6f 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -214,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; @@ -266,7 +269,7 @@ namespace { /// 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); @@ -283,6 +286,7 @@ 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); @@ -730,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); @@ -886,11 +893,12 @@ 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 @@ -900,6 +908,9 @@ namespace { 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++) { @@ -941,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) @@ -973,10 +989,9 @@ namespace { && !captureOrPromotion && !move_is_castle(move)) { - double red = 0.5 + ln(RootMoveNumber - MultiPV + 1) * ln(depth / 2) / 6.0; - if (red >= 1.0) + ss[0].reduction = calculate_reduction(0.5, RootMoveNumber - MultiPV + 1, depth, 6.0); + if (ss[0].reduction) { - ss[0].reduction = Depth(int(floor(red * int(OnePly)))); value = -search(pos, ss, -alpha, newDepth-ss[0].reduction, 1, true, 0); doFullDepthSearch = (value > alpha); } @@ -984,6 +999,7 @@ namespace { if (doFullDepthSearch) { + ss[0].reduction = Depth(0); value = -search(pos, ss, -alpha, newDepth, 1, true, 0); if (value > alpha) @@ -1000,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 @@ -1094,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; } @@ -1235,13 +1302,12 @@ namespace { && !move_is_castle(move) && !move_is_killer(move, ss[ply])) { - double red = 0.5 + ln(moveCount) * ln(depth / 2) / 6.0; - if (red >= 1.0) - { - ss[ply].reduction = Depth(int(floor(red * int(OnePly)))); - value = -search(pos, ss, -alpha, newDepth-ss[ply].reduction, ply+1, true, threadID); - doFullDepthSearch = (value > alpha); - } + ss[ply].reduction = calculate_reduction(0.5, moveCount, depth, 6.0); + if (ss[ply].reduction) + { + value = -search(pos, ss, -alpha, newDepth-ss[ply].reduction, ply+1, true, threadID); + doFullDepthSearch = (value > alpha); + } } if (doFullDepthSearch) // Go with full depth non-pv search @@ -1542,6 +1608,36 @@ 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 ( !isCheck && !dangerous @@ -1558,10 +1654,10 @@ namespace { // Value based pruning 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))); + //FIXME: We are ignoring condition: depth >= 3*OnePly, BUG?? + ss[ply].reduction = calculate_reduction(0.5, moveCount, depth, 3.0); + if (ss[ply].reduction) + predictedDepth -= ss[ply].reduction; if (predictedDepth < SelectiveDepth) { @@ -1593,13 +1689,11 @@ namespace { && !dangerous && !captureOrPromotion && !move_is_castle(move) - && !move_is_killer(move, ss[ply]) - /* && move != ttMove*/) + && !move_is_killer(move, ss[ply])) { - double red = 0.5 + ln(moveCount) * ln(depth / 2) / 3.0; - if (red >= 1.0) + ss[ply].reduction = calculate_reduction(0.5, moveCount, depth, 3.0); + if (ss[ply].reduction) { - ss[ply].reduction = Depth(int(floor(red * int(OnePly)))); value = -search(pos, ss, -(beta-1), newDepth-ss[ply].reduction, ply+1, true, threadID); doFullDepthSearch = (value >= beta); } @@ -1941,10 +2035,9 @@ namespace { && !move_is_castle(move) && !move_is_killer(move, ss[sp->ply])) { - double red = 0.5 + ln(moveCount) * ln(sp->depth / 2) / 3.0; - if (red >= 1.0) + ss[sp->ply].reduction = calculate_reduction(0.5, moveCount, sp->depth, 3.0); + if (ss[sp->ply].reduction) { - ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly)))); value = -search(pos, ss, -(sp->beta-1), newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID); doFullDepthSearch = (value >= sp->beta); } @@ -1960,7 +2053,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 @@ -2052,11 +2148,10 @@ namespace { && !move_is_castle(move) && !move_is_killer(move, ss[sp->ply])) { - double red = 0.5 + ln(moveCount) * ln(sp->depth / 2) / 6.0; - if (red >= 1.0) + ss[sp->ply].reduction = calculate_reduction(0.5, moveCount, sp->depth, 6.0); + if (ss[sp->ply].reduction) { Value localAlpha = sp->alpha; - ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly)))); value = -search(pos, ss, -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID); doFullDepthSearch = (value > localAlpha); } @@ -2094,7 +2189,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 @@ -2577,6 +2675,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.