X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=b56a83dcbeab820f136a08be65cfc1529f41ab1b;hp=c0a982363403ccae483d2fc5a00796e2323a06f6;hb=500b9b0eb3b20ef58ff1280a089ab2ef1e3c6436;hpb=d34bb889b185e6796bbebb9bb3c2b85c8132d7cb diff --git a/src/search.cpp b/src/search.cpp index c0a98236..b56a83dc 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -63,13 +63,10 @@ namespace { inline Value razor_margin(Depth d) { return Value(512 + 16 * int(d)); } // Futility lookup tables (initialized at startup) and their access functions - Value FutilityMargins[16][64]; // [depth][moveNumber] int FutilityMoveCounts[2][32]; // [improving][depth] - inline Value futility_margin(Depth d, int mn) { - - return d < 7 * ONE_PLY ? FutilityMargins[std::max(int(d), 1)][std::min(mn, 63)] - : 2 * VALUE_INFINITE; + inline Value futility_margin(Depth d) { + return Value(100 * int(d)); } // Reduction lookup tables (initialized at startup) and their access function @@ -146,10 +143,6 @@ void Search::init() { Reductions[0][0][hd][mc] += ONE_PLY / 2; } - // Init futility margins array - for (d = 1; d < 16; ++d) for (mc = 0; mc < 64; ++mc) - FutilityMargins[d][mc] = Value(112 * int(2.9 * log(double(d))) - 8 * mc + 45); - // Init futility move count array for (d = 0; d < 32; ++d) { @@ -270,7 +263,7 @@ finalize: sync_cout << "info nodes " << RootPos.nodes_searched() << " time " << Time::now() - SearchTime + 1 << sync_endl; - // When we reach max depth we arrive here even without Signals.stop is raised, + // When we reach max depth we arrive here even without Signals.stop being raised, // but if we are pondering or in infinite search, according to UCI protocol, // we shouldn't print the best move before the GUI sends a "stop" or "ponderhit" // command. We simply wait here until GUI sends one of those commands (that @@ -330,12 +323,12 @@ namespace { BestMoveChanges *= 0.8; // 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. + // the move scores except the (new) PV are set to -VALUE_INFINITE. for (size_t i = 0; i < RootMoves.size(); ++i) RootMoves[i].prevScore = RootMoves[i].score; // MultiPV loop. We perform a full root search for each PV line - for (PVIdx = 0; PVIdx < PVSize; ++PVIdx) + for (PVIdx = 0; PVIdx < PVSize && !Signals.stop; ++PVIdx) { // Reset aspiration window starting size if (depth >= 5) @@ -364,11 +357,11 @@ namespace { for (size_t i = 0; i <= PVIdx; ++i) RootMoves[i].insert_pv_in_tt(pos); - // If search has been stopped return immediately. Sorting and + // If search has been stopped break immediately. Sorting and // writing PV back to TT is safe becuase RootMoves is still // valid, although refers to previous iteration. if (Signals.stop) - return; + break; // When failing high/low give some update (without cluttering // the UI) before to research. @@ -403,7 +396,7 @@ namespace { sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl; } - // Do we need to pick now the sub-optimal best move ? + // Do we now need to pick now the sub-optimal best move ? if (skill.enabled() && skill.time_to_pick(depth)) skill.pick_move(); @@ -418,22 +411,22 @@ namespace { << std::endl; } - // Do we have found a "mate in x"? + // Have we found a "mate in x"? if ( Limits.mate && bestValue >= VALUE_MATE_IN_MAX_PLY && VALUE_MATE - bestValue <= 2 * Limits.mate) Signals.stop = true; // Do we have time for the next iteration? Can we stop searching now? - if (Limits.use_time_management() && !Signals.stopOnPonderhit) + if (Limits.use_time_management() && !Signals.stop && !Signals.stopOnPonderhit) { bool stop = false; // Local variable, not the volatile Signals.stop - // Take in account some extra time if the best move has changed + // Take some extra time if the best move has changed if (depth > 4 && depth < 50 && PVSize == 1) TimeMgr.pv_instability(BestMoveChanges); - // Stop search if most of available time is already consumed. We + // Stop search if most of the available time is already consumed. We // probably don't have enough time to search the first move at the // next iteration anyway. if (Time::now() - SearchTime > (TimeMgr.available_time() * 62) / 100) @@ -497,9 +490,8 @@ namespace { SplitPoint* splitPoint; Key posKey; Move ttMove, move, excludedMove, bestMove, threatMove; - Depth ext, newDepth; - Value bestValue, value, ttValue; - Value eval, nullValue, futilityValue; + Depth ext, newDepth, predictedDepth; + Value bestValue, value, ttValue, eval, nullValue, futilityValue; bool inCheck, givesCheck, pvMove, singularExtensionNode, improving; bool captureOrPromotion, dangerous, doFullDepthSearch; int moveCount, quietCount; @@ -527,7 +519,6 @@ namespace { bestValue = -VALUE_INFINITE; ss->currentMove = threatMove = (ss+1)->excludedMove = bestMove = MOVE_NONE; ss->ply = (ss-1)->ply + 1; - ss->futilityMoveCount = 0; (ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO; (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE; @@ -591,16 +582,15 @@ namespace { // Step 5. Evaluate the position statically and update parent's gain statistics if (inCheck) { - ss->staticEval = ss->evalMargin = eval = VALUE_NONE; + ss->staticEval = eval = VALUE_NONE; goto moves_loop; } else if (tte) { // Never assume anything on values stored in TT - if ( (ss->staticEval = eval = tte->eval_value()) == VALUE_NONE - ||(ss->evalMargin = tte->eval_margin()) == VALUE_NONE) - eval = ss->staticEval = evaluate(pos, ss->evalMargin); + if ((ss->staticEval = eval = tte->eval_value()) == VALUE_NONE) + eval = ss->staticEval = evaluate(pos); // Can ttValue be used as a better position evaluation? if (ttValue != VALUE_NONE) @@ -609,13 +599,10 @@ namespace { } else { - eval = ss->staticEval = evaluate(pos, ss->evalMargin); - TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, - ss->staticEval, ss->evalMargin); + eval = ss->staticEval = evaluate(pos); + TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, ss->staticEval); } - // Update gain for the parent non-capture move given the static position - // evaluation before and after the move. if ( !pos.captured_piece_type() && ss->staticEval != VALUE_NONE && (ss-1)->staticEval != VALUE_NONE @@ -638,21 +625,19 @@ namespace { Value v = qsearch(pos, ss, rbeta-1, rbeta, DEPTH_ZERO); if (v < rbeta) // Logically we should return (v + razor_margin(depth)), but - // surprisingly this did slightly weaker in tests. + // surprisingly this performed slightly weaker in tests. return v; } - // Step 7. Static null move pruning (skipped when in check) - // We're betting that the opponent doesn't have a move that will reduce - // the score by more than futility_margin(depth) if we do a null move. + // Step 7. Futility pruning: child node (skipped when in check) if ( !PvNode && !ss->skipNullMove - && depth < 4 * ONE_PLY - && eval - futility_margin(depth, (ss-1)->futilityMoveCount) >= beta + && depth < 7 * ONE_PLY + && eval - futility_margin(depth) >= beta && abs(beta) < VALUE_MATE_IN_MAX_PLY && abs(eval) < VALUE_KNOWN_WIN && pos.non_pawn_material(pos.side_to_move())) - return eval - futility_margin(depth, (ss-1)->futilityMoveCount); + return eval - futility_margin(depth); // Step 8. Null move search with verification search (is omitted in PV nodes) if ( !PvNode @@ -822,7 +807,7 @@ moves_loop: // When in check and at SpNode search starts from here givesCheck = pos.gives_check(move, ci); dangerous = givesCheck || pos.passed_pawn_push(move) - || type_of(move) == CASTLE; + || type_of(move) == CASTLING; // Step 12. Extend checks if (givesCheck && pos.see_sign(move) >= 0) @@ -855,7 +840,7 @@ moves_loop: // When in check and at SpNode search starts from here // Update current move (this must be done after singular extension search) newDepth = depth - ONE_PLY + ext; - // Step 13. Futility pruning (is omitted in PV nodes) + // Step 13. Pruning at shallow depth (exclude PV nodes) if ( !PvNode && !captureOrPromotion && !inCheck @@ -874,47 +859,42 @@ moves_loop: // When in check and at SpNode search starts from here continue; } - // Value based pruning - // We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth, - // but fixing this made program slightly weaker. - Depth predictedDepth = newDepth - reduction(improving, depth, moveCount); - futilityValue = ss->staticEval + ss->evalMargin + futility_margin(predictedDepth, moveCount) - + Gains[pos.moved_piece(move)][to_sq(move)]; + predictedDepth = newDepth - reduction(improving, depth, moveCount); - if (futilityValue < beta) + // Futility pruning: parent node + if (predictedDepth < 7 * ONE_PLY) { - bestValue = std::max(bestValue, futilityValue); + futilityValue = ss->staticEval + futility_margin(predictedDepth) + + Value(128) + Gains[pos.moved_piece(move)][to_sq(move)]; - if (SpNode) + if (futilityValue <= alpha) { - splitPoint->mutex.lock(); - if (bestValue > splitPoint->bestValue) - splitPoint->bestValue = bestValue; + bestValue = std::max(bestValue, futilityValue); + + if (SpNode) + { + splitPoint->mutex.lock(); + if (bestValue > splitPoint->bestValue) + splitPoint->bestValue = bestValue; + } + continue; } - continue; } // Prune moves with negative SEE at low depths - if ( predictedDepth < 4 * ONE_PLY - && pos.see_sign(move) < 0) + if (predictedDepth < 4 * ONE_PLY && pos.see_sign(move) < 0) { if (SpNode) splitPoint->mutex.lock(); continue; } - - // We have not pruned the move that will be searched, but remember how - // far in the move list we are to be more aggressive in the child node. - ss->futilityMoveCount = moveCount; } - else - ss->futilityMoveCount = 0; // Check for legality only before to do the move if (!RootNode && !SpNode && !pos.legal(move, ci.pinned)) { - --moveCount; + moveCount--; continue; } @@ -972,7 +952,7 @@ moves_loop: // When in check and at SpNode search starts from here // Only for PV nodes do a full PV search on the first move or after a fail // high, in the latter case search only if value < beta, otherwise let the - // parent node to fail low with value <= alpha and to try another move. + // parent node fail low with value <= alpha and to try another move. if (PvNode && (pvMove || (value > alpha && (RootNode || value < beta)))) value = newDepth < ONE_PLY ? givesCheck ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO) @@ -1079,7 +1059,7 @@ moves_loop: // When in check and at SpNode search starts from here TT.store(posKey, value_to_tt(bestValue, ss->ply), bestValue >= beta ? BOUND_LOWER : PvNode && bestMove ? BOUND_EXACT : BOUND_UPPER, - depth, bestMove, ss->staticEval, ss->evalMargin); + depth, bestMove, ss->staticEval); // Quiet best move: update killers, history and countermoves if ( bestValue >= beta @@ -1172,7 +1152,7 @@ moves_loop: // When in check and at SpNode search starts from here // Evaluate the position statically if (InCheck) { - ss->staticEval = ss->evalMargin = VALUE_NONE; + ss->staticEval = VALUE_NONE; bestValue = futilityBase = -VALUE_INFINITE; } else @@ -1180,9 +1160,8 @@ moves_loop: // When in check and at SpNode search starts from here if (tte) { // Never assume anything on values stored in TT - if ( (ss->staticEval = bestValue = tte->eval_value()) == VALUE_NONE - ||(ss->evalMargin = tte->eval_margin()) == VALUE_NONE) - ss->staticEval = bestValue = evaluate(pos, ss->evalMargin); + if ((ss->staticEval = bestValue = tte->eval_value()) == VALUE_NONE) + ss->staticEval = bestValue = evaluate(pos); // Can ttValue be used as a better position evaluation? if (ttValue != VALUE_NONE) @@ -1190,14 +1169,14 @@ moves_loop: // When in check and at SpNode search starts from here bestValue = ttValue; } else - ss->staticEval = bestValue = evaluate(pos, ss->evalMargin); + ss->staticEval = bestValue = evaluate(pos); // Stand pat. Return immediately if static value is at least beta if (bestValue >= beta) { if (!tte) TT.store(pos.key(), value_to_tt(bestValue, ss->ply), BOUND_LOWER, - DEPTH_NONE, MOVE_NONE, ss->staticEval, ss->evalMargin); + DEPTH_NONE, MOVE_NONE, ss->staticEval); return bestValue; } @@ -1205,7 +1184,7 @@ moves_loop: // When in check and at SpNode search starts from here if (PvNode && bestValue > alpha) alpha = bestValue; - futilityBase = bestValue + ss->evalMargin + Value(128); + futilityBase = bestValue + Value(128); } // Initialize a MovePicker object for the current position, and prepare @@ -1294,7 +1273,7 @@ moves_loop: // When in check and at SpNode search starts from here else // Fail high { TT.store(posKey, value_to_tt(value, ss->ply), BOUND_LOWER, - ttDepth, move, ss->staticEval, ss->evalMargin); + ttDepth, move, ss->staticEval); return value; } @@ -1309,7 +1288,7 @@ moves_loop: // When in check and at SpNode search starts from here TT.store(posKey, value_to_tt(bestValue, ss->ply), PvNode && bestValue > oldAlpha ? BOUND_EXACT : BOUND_UPPER, - ttDepth, bestMove, ss->staticEval, ss->evalMargin); + ttDepth, bestMove, ss->staticEval); assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); @@ -1352,7 +1331,7 @@ moves_loop: // When in check and at SpNode search starts from here assert(is_ok(first)); assert(is_ok(second)); assert(color_of(pos.piece_on(from_sq(second))) == ~pos.side_to_move()); - assert(type_of(first) == CASTLE || color_of(pos.piece_on(to_sq(first))) == ~pos.side_to_move()); + assert(type_of(first) == CASTLING || color_of(pos.piece_on(to_sq(first))) == ~pos.side_to_move()); Square m1from = from_sq(first); Square m2from = from_sq(second); @@ -1363,7 +1342,7 @@ moves_loop: // When in check and at SpNode search starts from here // We exclude the trivial case where a sliding piece does in two moves what // it could do in one move: eg. Ra1a2, Ra2a3. if ( m2to == m1from - || (m1to == m2from && !squares_aligned(m1from, m2from, m2to))) + || (m1to == m2from && !aligned(m1from, m2from, m2to))) return true; // Second one moves through the square vacated by first one @@ -1371,7 +1350,7 @@ moves_loop: // When in check and at SpNode search starts from here return true; // Second's destination is defended by the first move's piece - Bitboard m1att = pos.attacks_from(pos.piece_on(m1to), m1to, pos.pieces() ^ m2from); + Bitboard m1att = attacks_bb(pos.piece_on(m1to), m1to, pos.pieces() ^ m2from); if (m1att & m2to) return true; @@ -1415,7 +1394,7 @@ moves_loop: // When in check and at SpNode search starts from here Piece pc = pos.piece_on(m1from); // The moved piece attacks the square 'tto' ? - if (pos.attacks_from(pc, m1to, occ) & m2to) + if (attacks_bb(pc, m1to, occ) & m2to) return true; // Scan for possible X-ray attackers behind the moved piece @@ -1548,7 +1527,7 @@ void RootMove::extract_pv_from_tt(Position& pos) { } while ( tte && pos.pseudo_legal(m = tte->move()) // Local copy, TT could change - && pos.legal(m, pos.pinned_pieces()) + && pos.legal(m, pos.pinned_pieces(pos.side_to_move())) && ply < MAX_PLY && (!pos.is_draw() || ply < 2)); @@ -1572,7 +1551,7 @@ void RootMove::insert_pv_in_tt(Position& pos) { tte = TT.probe(pos.key()); if (!tte || tte->move() != pv[ply]) // Don't overwrite correct entries - TT.store(pos.key(), VALUE_NONE, BOUND_NONE, DEPTH_NONE, pv[ply], VALUE_NONE, VALUE_NONE); + TT.store(pos.key(), VALUE_NONE, BOUND_NONE, DEPTH_NONE, pv[ply], VALUE_NONE); assert(MoveList(pos).contains(pv[ply]));