X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fsearch.cpp;h=378c3d20f1f693d48ec2df4eba1a5ed68f6fc06e;hb=bd358533a4ac2296a6cf7f89ae0f288d91f68029;hp=097243a0c73b45daa354f14985cc8e1ad12828f4;hpb=b95ba7b37ea278837c83cb65c1b7ad0e71e8d9f2;p=stockfish diff --git a/src/search.cpp b/src/search.cpp index 097243a0..378c3d20 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -185,6 +185,8 @@ namespace { // and near frontier nodes. const Value FutilityMarginQS = Value(0x80); + Value FutilityMargins[2 * PLY_MAX_PLUS_2]; // Initialized at startup. + // Each move futility margin is decreased const Value IncrementalFutilityMargin = Value(0x8); @@ -214,6 +216,9 @@ namespace { IterationInfoType IterationInfo[PLY_MAX_PLUS_2]; int BestMoveChangesByIteration[PLY_MAX_PLUS_2]; + // Search window management + int AspirationDelta; + // MultiPV mode int MultiPV; @@ -234,8 +239,8 @@ namespace { std::ofstream LogFile; // Natural logarithmic lookup table and its getter function - double lnArray[512]; - inline double ln(int i) { return lnArray[i]; } + float lnArray[512]; + inline float ln(int i) { return lnArray[i]; } // MP related variables int ActiveThreads = 1; @@ -266,7 +271,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 +288,8 @@ 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); + void reduction_parameters(float base, float Inhibitor, Depth depth, float& logLimit, float& gradient); + Depth reduction(int moveCount, const float LogLimit, const float BaseRed, const float Gradient); 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); @@ -567,11 +574,19 @@ void init_threads() { // Init our logarithmic lookup table for (i = 0; i < 512; i++) - lnArray[i] = log(double(i)); // log() returns base-e logarithm + lnArray[i] = float(log(double(i))); // log() returns base-e logarithm for (i = 0; i < THREAD_MAX; i++) Threads[i].activeSplitPoints = 0; + // Init futility margins array + FutilityMargins[0] = FutilityMargins[1] = Value(0); + + for (i = 2; i < 2 * PLY_MAX_PLUS_2; i++) + { + FutilityMargins[i] = Value(112 * bitScanReverse32(i * i / 2)); // FIXME: test using log instead of BSR + } + // Initialize global locks lock_init(&MPLock, NULL); lock_init(&IOLock, NULL); @@ -730,7 +745,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 +904,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 +919,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 +963,19 @@ namespace { ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous); newDepth = depth + ext; + value = - VALUE_INFINITE; + + // Precalculate reduction parameters + float LogLimit, Gradient, BaseReduction = 0.5; + reduction_parameters(BaseReduction, 6.0, depth, LogLimit, Gradient); + + 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 +1004,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 = reduction(RootMoveNumber - MultiPV + 1, LogLimit, BaseReduction, Gradient); + 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 +1014,7 @@ namespace { if (doFullDepthSearch) { + ss[0].reduction = Depth(0); value = -search(pos, ss, -alpha, newDepth, 1, true, 0); if (value > alpha) @@ -1000,6 +1031,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 +1165,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; } @@ -1177,6 +1259,10 @@ namespace { CheckInfo ci(pos); MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]); + // Precalculate reduction parameters + float LogLimit, Gradient, BaseReduction = 0.5; + reduction_parameters(BaseReduction, 6.0, depth, LogLimit, Gradient); + // Loop through all legal moves until no moves remain or a beta cutoff // occurs. while ( alpha < beta @@ -1234,14 +1320,13 @@ namespace { && !captureOrPromotion && !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 = reduction(moveCount, LogLimit, BaseReduction, Gradient); + 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 @@ -1392,7 +1477,6 @@ namespace { // Calculate depth dependant futility pruning parameters const int FutilityMoveCountMargin = 3 + (1 << (3 * int(depth) / 8)); - const int PostFutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2); // Evaluate the position statically if (!isCheck) @@ -1406,19 +1490,18 @@ namespace { } ss[ply].eval = staticValue; - futilityValue = staticValue + PostFutilityValueMargin; //FIXME: Remove me, only for split + futilityValue = staticValue + FutilityMargins[int(depth)]; //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; + && allowNullmove + && depth < RazorDepth + && staticValue - FutilityMargins[int(depth)] >= beta) + return staticValue - FutilityMargins[int(depth)]; // Null move search if ( allowNullmove @@ -1498,6 +1581,10 @@ namespace { MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]); CheckInfo ci(pos); + // Precalculate reduction parameters + float LogLimit, Gradient, BaseReduction = 0.5; + reduction_parameters(BaseReduction, 3.0, depth, LogLimit, Gradient); + // Loop through all legal moves until no moves remain or a beta cutoff occurs while ( bestValue < beta && (move = mp.get_next_move()) != MOVE_NONE @@ -1560,10 +1647,16 @@ namespace { int preFutilityValueMargin = 0; if (newDepth >= OnePly) - preFutilityValueMargin = 112 * bitScanReverse32(int(newDepth) * int(newDepth) / 2); + preFutilityValueMargin = FutilityMargins[int(newDepth)]; - if (ss[ply].eval + pos.endgame_value_of_piece_on(move_to(move)) + preFutilityValueMargin + ei.futilityMargin + 90 < beta) + 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 @@ -1582,16 +1675,16 @@ 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 = reduction(moveCount, LogLimit, BaseReduction, Gradient); + if (ss[ply].reduction) + predictedDepth -= ss[ply].reduction; if (predictedDepth < SelectiveDepth) { int preFutilityValueMargin = 0; if (predictedDepth >= OnePly) - preFutilityValueMargin = 112 * bitScanReverse32(int(predictedDepth) * int(predictedDepth) / 2); + preFutilityValueMargin = FutilityMargins[int(predictedDepth)]; preFutilityValueMargin += H.gain(pos.piece_on(move_from(move)), move_from(move), move_to(move)) + 45; @@ -1617,13 +1710,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 = reduction(moveCount, LogLimit, BaseReduction, Gradient); + 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); } @@ -1898,28 +1989,33 @@ 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 + // Precalculate reduction parameters + float LogLimit, Gradient, BaseReduction = 0.5; + reduction_parameters(BaseReduction, 3.0, sp->depth, LogLimit, Gradient); + + 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; @@ -1964,10 +2060,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 = reduction(moveCount, LogLimit, BaseReduction, Gradient); + 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); } @@ -1983,7 +2078,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 @@ -2006,7 +2104,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. @@ -2039,24 +2137,29 @@ namespace { CheckInfo ci(pos); SearchStack* ss = sp->sstack[threadID]; Value value = -VALUE_INFINITE; + int moveCount; Move move; - while ( sp->alpha < sp->beta + // Precalculate reduction parameters + float LogLimit, Gradient, BaseReduction = 0.5; + reduction_parameters(BaseReduction, 6.0, sp->depth, LogLimit, Gradient); + + 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; @@ -2074,11 +2177,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 = reduction(moveCount, LogLimit, BaseReduction, Gradient); + 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); } @@ -2116,7 +2218,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 @@ -2155,7 +2260,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. @@ -2599,6 +2704,35 @@ namespace { return defaultEval; } + + // reduction_parameters() precalculates some parameters used later by reduction. Becasue + // floating point operations are involved we try to recalculate reduction at each move, but + // we do the most consuming computation only once per node. + + void reduction_parameters(float baseReduction, float reductionInhibitor, Depth depth, float& logLimit, float& gradient) + { + // Precalculate some parameters to avoid to calculate the following formula for each move: + // + // red = baseReduction + ln(moveCount) * ln(depth / 2) / reductionInhibitor; + // + logLimit = depth > OnePly ? (1 - baseReduction) * reductionInhibitor / ln(depth / 2) : 1000; + gradient = depth > OnePly ? ln(depth / 2) / reductionInhibitor : 0; + } + + + // reduction() returns reduction in plies based on moveCount and depth. + // Reduction is always at least one ply. + + Depth reduction(int moveCount, float logLimit, float baseReduction, float gradient) { + + if (ln(moveCount) < logLimit) + return Depth(0); + + float red = baseReduction + ln(moveCount) * gradient; + return Depth(int(floor(red * int(OnePly)))); + } + + // update_history() registers a good move that produced a beta-cutoff // in history and marks as failures all the other moves of that ply.