X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=d03a251fe2d3516a9130868fb3073cce7aee8792;hp=0ccf326698ee3bc9a1a676e8831ba3e8001d39b2;hb=e48c7547c50d56b7aa7fd4a244533daca1ef6a57;hpb=28933a580eeb4b9a2d717f06c789a6c13dfef19c diff --git a/src/search.cpp b/src/search.cpp index 0ccf3266..d03a251f 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -40,7 +40,6 @@ namespace Search { SignalsType Signals; LimitsType Limits; - StateStackPtr SetupStates; } namespace Tablebases { @@ -127,6 +126,35 @@ namespace { Move pv[3]; }; + // Set of rows with half bits set to 1 and half to 0. It is used to allocate + // the search depths across the threads. + typedef std::vector Row; + + const Row HalfDensity[] = { + {0, 1}, + {1, 0}, + {0, 0, 1, 1}, + {0, 1, 1, 0}, + {1, 1, 0, 0}, + {1, 0, 0, 1}, + {0, 0, 0, 1, 1, 1}, + {0, 0, 1, 1, 1, 0}, + {0, 1, 1, 1, 0, 0}, + {1, 1, 1, 0, 0, 0}, + {1, 1, 0, 0, 0, 1}, + {1, 0, 0, 0, 1, 1}, + {0, 0, 0, 0, 1, 1, 1, 1}, + {0, 0, 0, 1, 1, 1, 1, 0}, + {0, 0, 1, 1, 1, 1, 0 ,0}, + {0, 1, 1, 1, 1, 0, 0 ,0}, + {1, 1, 1, 1, 0, 0, 0 ,0}, + {1, 1, 1, 0, 0, 0, 0 ,1}, + {1, 1, 0, 0, 0, 0, 1 ,1}, + {1, 0, 0, 0, 0, 1, 1 ,1}, + }; + + const size_t HalfDensitySize = std::extent::value; + EasyMoveManager EasyMove; Value DrawValue[COLOR_NB]; CounterMoveHistoryStats CounterMoveHistory; @@ -150,22 +178,21 @@ namespace { void Search::init() { - const double K[][2] = {{ 0.799, 2.281 }, { 0.484, 3.023 }}; - - for (int pv = 0; pv <= 1; ++pv) - for (int imp = 0; imp <= 1; ++imp) - for (int d = 1; d < 64; ++d) - for (int mc = 1; mc < 64; ++mc) - { - double r = K[pv][0] + log(d) * log(mc) / K[pv][1]; + for (int imp = 0; imp <= 1; ++imp) + for (int d = 1; d < 64; ++d) + for (int mc = 1; mc < 64; ++mc) + { + double r = log(d) * log(mc) / 2; + if (r < 0.80) + continue; - if (r >= 1.5) - Reductions[pv][imp][d][mc] = int(r) * ONE_PLY; + Reductions[NonPV][imp][d][mc] = int(std::round(r)) * ONE_PLY; + Reductions[PV][imp][d][mc] = std::max(Reductions[NonPV][imp][d][mc] - ONE_PLY, DEPTH_ZERO); - // Increase reduction when eval is not improving - if (!pv && !imp && Reductions[pv][imp][d][mc] >= 2 * ONE_PLY) - Reductions[pv][imp][d][mc] += ONE_PLY; - } + // Increase reduction for non-PV nodes when eval is not improving + if (!imp && Reductions[NonPV][imp][d][mc] >= 2 * ONE_PLY) + Reductions[NonPV][imp][d][mc] += ONE_PLY; + } for (int d = 0; d < 16; ++d) { @@ -256,8 +283,9 @@ void MainThread::search() { } else { - if (TB::Cardinality >= rootPos.count(WHITE) - + rootPos.count(BLACK)) + if ( TB::Cardinality >= rootPos.count(WHITE) + + rootPos.count(BLACK) + && !rootPos.can_castle(ANY_CASTLING)) { // If the current root position is in the tablebases, then RootMoves // contains only moves that preserve the draw or the win. @@ -288,16 +316,8 @@ void MainThread::search() { } for (Thread* th : Threads) - { - th->maxPly = 0; - th->rootDepth = DEPTH_ZERO; if (th != this) - { - th->rootPos = Position(rootPos, th); - th->rootMoves = rootMoves; th->start_searching(); - } - } Thread::search(); // Let's start searching! } @@ -330,7 +350,9 @@ void MainThread::search() { Thread* bestThread = this; if ( !this->easyMovePlayed && Options["MultiPV"] == 1 - && !Skill(Options["Skill Level"]).enabled()) + && !Limits.depth + && !Skill(Options["Skill Level"]).enabled() + && rootMoves[0].pv[0] != MOVE_NONE) { for (Thread* th : Threads) if ( th->completedDepth > bestThread->completedDepth @@ -359,12 +381,12 @@ void MainThread::search() { void Thread::search() { - Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2) + Stack stack[MAX_PLY+7], *ss = stack+5; // To allow referencing (ss-5) and (ss+2) Value bestValue, alpha, beta, delta; Move easyMove = MOVE_NONE; MainThread* mainThread = (this == Threads.main() ? Threads.main() : nullptr); - std::memset(ss-2, 0, 5 * sizeof(Stack)); + std::memset(ss-5, 0, 8 * sizeof(Stack)); bestValue = delta = alpha = -VALUE_INFINITE; beta = VALUE_INFINITE; @@ -390,30 +412,15 @@ void Thread::search() { multiPV = std::min(multiPV, rootMoves.size()); // Iterative deepening loop until requested to stop or the target depth is reached. - while (++rootDepth < DEPTH_MAX && !Signals.stop && (!Limits.depth || rootDepth <= Limits.depth)) + while (++rootDepth < DEPTH_MAX && !Signals.stop && (!Limits.depth || Threads.main()->rootDepth <= Limits.depth)) { // Set up the new depths for the helper threads skipping on average every - // 2nd ply (using a half-density map similar to a Hadamard matrix). + // 2nd ply (using a half-density matrix). if (!mainThread) { - int d = rootDepth + rootPos.game_ply(); - - if (idx <= 6 || idx > 24) - { - if (((d + idx) >> (msb(idx + 1) - 1)) % 2) - continue; - } - else - { - // Table of values of 6 bits with 3 of them set - static const int HalfDensityMap[] = { - 0x07, 0x0b, 0x0d, 0x0e, 0x13, 0x16, 0x19, 0x1a, 0x1c, - 0x23, 0x25, 0x26, 0x29, 0x2c, 0x31, 0x32, 0x34, 0x38 - }; - - if ((HalfDensityMap[idx - 7] >> (d % 6)) & 1) - continue; - } + const Row& row = HalfDensity[(idx - 1) % HalfDensitySize]; + if (row[(rootDepth + rootPos.game_ply()) % row.size()]) + continue; } // Age out PV variability metric @@ -500,7 +507,7 @@ void Thread::search() { std::stable_sort(rootMoves.begin(), rootMoves.begin() + PVIdx + 1); if (!mainThread) - break; + continue; if (Signals.stop) sync_cout << "info nodes " << Threads.nodes_searched() @@ -531,24 +538,21 @@ void Thread::search() { { if (!Signals.stop && !Signals.stopOnPonderhit) { - // Take some extra time if the best move has changed - if (rootDepth > 4 * ONE_PLY && multiPV == 1) - Time.pv_instability(mainThread->bestMoveChanges); - // Stop the search if only one legal move is available, or if all // of the available time has been used, or if we matched an easyMove // from the previous search and just did a fast verification. - const bool F[] = { !mainThread->failedLow, - bestValue >= mainThread->previousScore }; + const int F[] = { mainThread->failedLow, + bestValue - mainThread->previousScore }; - int improvingFactor = 640 - 160*F[0] - 126*F[1] - 124*F[0]*F[1]; + int improvingFactor = std::max(229, std::min(715, 357 + 119 * F[0] - 6 * F[1])); + double unstablePvFactor = 1 + mainThread->bestMoveChanges; bool doEasyMove = rootMoves[0].pv[0] == easyMove && mainThread->bestMoveChanges < 0.03 - && Time.elapsed() > Time.available() * 25 / 206; + && Time.elapsed() > Time.optimum() * 5 / 42; if ( rootMoves.size() == 1 - || Time.elapsed() > Time.available() * improvingFactor / 640 + || Time.elapsed() > Time.optimum() * unstablePvFactor * improvingFactor / 628 || (mainThread->easyMovePlayed = doEasyMove)) { // If we are allowed to ponder do not stop the search now but @@ -602,9 +606,10 @@ namespace { Key posKey; Move ttMove, move, excludedMove, bestMove; Depth extension, newDepth, predictedDepth; - Value bestValue, value, ttValue, eval, nullValue, futilityValue; + Value bestValue, value, ttValue, eval, nullValue; bool ttHit, inCheck, givesCheck, singularExtensionNode, improving; bool captureOrPromotion, doFullDepthSearch; + Piece moved_piece; int moveCount, quietCount; // Step 1. Initialize node @@ -654,6 +659,7 @@ namespace { assert(0 <= ss->ply && ss->ply < MAX_PLY); ss->currentMove = (ss+1)->excludedMove = bestMove = MOVE_NONE; + ss->counterMoves = nullptr; (ss+1)->skipEarlyPruning = false; (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE; @@ -691,7 +697,8 @@ namespace { if ( piecesCnt <= TB::Cardinality && (piecesCnt < TB::Cardinality || depth >= TB::ProbeDepth) - && pos.rule50_count() == 0) + && pos.rule50_count() == 0 + && !pos.can_castle(ANY_CASTLING)) { int found, v = Tablebases::probe_wdl(pos, &found); @@ -776,6 +783,7 @@ namespace { && pos.non_pawn_material(pos.side_to_move())) { ss->currentMove = MOVE_NULL; + ss->counterMoves = nullptr; assert(eval - beta >= 0); @@ -824,13 +832,14 @@ namespace { assert((ss-1)->currentMove != MOVE_NONE); assert((ss-1)->currentMove != MOVE_NULL); - MovePicker mp(pos, ttMove, thisThread->history, PieceValue[MG][pos.captured_piece_type()]); + MovePicker mp(pos, ttMove, PieceValue[MG][pos.captured_piece_type()]); CheckInfo ci(pos); while ((move = mp.next_move()) != MOVE_NONE) if (pos.legal(move, ci.pinned)) { ss->currentMove = move; + ss->counterMoves = &CounterMoveHistory[pos.moved_piece(move)][to_sq(move)]; pos.do_move(move, st, pos.gives_check(move, ci)); value = -search(pos, ss+1, -rbeta, -rbeta+1, rdepth, !cutNode); pos.undo_move(move); @@ -856,10 +865,11 @@ namespace { moves_loop: // When in check search starts from here Square prevSq = to_sq((ss-1)->currentMove); - Move cm = thisThread->counterMoves[pos.piece_on(prevSq)][prevSq]; - const CounterMoveStats& cmh = CounterMoveHistory[pos.piece_on(prevSq)][prevSq]; + const CounterMoveStats* cmh = (ss-1)->counterMoves; + const CounterMoveStats* fmh = (ss-2)->counterMoves; + const CounterMoveStats* fmh2 = (ss-4)->counterMoves; - MovePicker mp(pos, ttMove, depth, thisThread->history, cmh, cm, ss); + MovePicker mp(pos, ttMove, depth, ss); CheckInfo ci(pos); value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc improving = ss->staticEval >= (ss-2)->staticEval @@ -903,6 +913,7 @@ moves_loop: // When in check search starts from here extension = DEPTH_ZERO; captureOrPromotion = pos.capture_or_promotion(move); + moved_piece = pos.moved_piece(move); givesCheck = type_of(move) == NORMAL && !ci.dcCandidates ? ci.checkSquares[type_of(pos.piece_on(from_sq(move)))] & to_sq(move) @@ -949,26 +960,20 @@ moves_loop: // When in check search starts from here && moveCount >= FutilityMoveCounts[improving][depth]) continue; - // History based pruning + // Countermoves based pruning if ( depth <= 4 * ONE_PLY && move != ss->killers[0] - && thisThread->history[pos.moved_piece(move)][to_sq(move)] < VALUE_ZERO - && cmh[pos.moved_piece(move)][to_sq(move)] < VALUE_ZERO) + && (!cmh || (*cmh )[moved_piece][to_sq(move)] < VALUE_ZERO) + && (!fmh || (*fmh )[moved_piece][to_sq(move)] < VALUE_ZERO) + && (!fmh2 || (*fmh2)[moved_piece][to_sq(move)] < VALUE_ZERO || (cmh && fmh))) continue; - predictedDepth = newDepth - reduction(improving, depth, moveCount); + predictedDepth = std::max(newDepth - reduction(improving, depth, moveCount), DEPTH_ZERO); // Futility pruning: parent node - if (predictedDepth < 7 * ONE_PLY) - { - futilityValue = ss->staticEval + futility_margin(predictedDepth) + 256; - - if (futilityValue <= alpha) - { - bestValue = std::max(bestValue, futilityValue); - continue; - } - } + if ( predictedDepth < 7 * ONE_PLY + && ss->staticEval + futility_margin(predictedDepth) + 256 <= alpha) + continue; // Prune moves with negative SEE at low depths if (predictedDepth < 4 * ONE_PLY && pos.see_sign(move) < VALUE_ZERO) @@ -986,6 +991,7 @@ moves_loop: // When in check search starts from here } ss->currentMove = move; + ss->counterMoves = &CounterMoveHistory[moved_piece][to_sq(move)]; // Step 14. Make the move pos.do_move(move, st, givesCheck); @@ -997,27 +1003,27 @@ moves_loop: // When in check search starts from here && !captureOrPromotion) { Depth r = reduction(improving, depth, moveCount); + Value val = thisThread->history[moved_piece][to_sq(move)] + + (cmh ? (*cmh )[moved_piece][to_sq(move)] : VALUE_ZERO) + + (fmh ? (*fmh )[moved_piece][to_sq(move)] : VALUE_ZERO) + + (fmh2 ? (*fmh2)[moved_piece][to_sq(move)] : VALUE_ZERO); - // Increase reduction for cut nodes and moves with a bad history - if ( (!PvNode && cutNode) - || ( thisThread->history[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO - && cmh[pos.piece_on(to_sq(move))][to_sq(move)] <= VALUE_ZERO)) - r += ONE_PLY; - - // Decrease/increase reduction for moves with a good/bad history - int rHist = ( thisThread->history[pos.piece_on(to_sq(move))][to_sq(move)] - + cmh[pos.piece_on(to_sq(move))][to_sq(move)]) / 14980; - r = std::max(DEPTH_ZERO, r - rHist * ONE_PLY); + // Increase reduction for cut nodes + if (!PvNode && cutNode) + r += 2 * ONE_PLY; // Decrease reduction for moves that escape a capture. Filter out // castling moves, because they are coded as "king captures rook" and // hence break make_move(). Also use see() instead of see_sign(), // because the destination square is empty. - if ( r - && type_of(move) == NORMAL - && type_of(pos.piece_on(to_sq(move))) != PAWN - && pos.see(make_move(to_sq(move), from_sq(move))) < VALUE_ZERO) - r = std::max(DEPTH_ZERO, r - ONE_PLY); + else if ( type_of(move) == NORMAL + && type_of(pos.piece_on(to_sq(move))) != PAWN + && pos.see(make_move(to_sq(move), from_sq(move))) < VALUE_ZERO) + r -= 2 * ONE_PLY; + + // Decrease/increase reduction for moves with a good/bad history + int rHist = (val - 10000) / 20000; + r = std::max(DEPTH_ZERO, r - rHist * ONE_PLY); Depth d = std::max(newDepth - r, ONE_PLY); @@ -1147,13 +1153,17 @@ moves_loop: // When in check search starts from here && !bestMove && !inCheck && !pos.captured_piece_type() - && is_ok((ss - 1)->currentMove) - && is_ok((ss - 2)->currentMove)) + && is_ok((ss-1)->currentMove)) { Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + depth / ONE_PLY - 1); - Square prevPrevSq = to_sq((ss - 2)->currentMove); - CounterMoveStats& prevCmh = CounterMoveHistory[pos.piece_on(prevPrevSq)][prevPrevSq]; - prevCmh.update(pos.piece_on(prevSq), prevSq, bonus); + if ((ss-2)->counterMoves) + (ss-2)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus); + + if ((ss-3)->counterMoves) + (ss-3)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus); + + if ((ss-5)->counterMoves) + (ss-5)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus); } tte->save(posKey, value_to_tt(bestValue, ss->ply), @@ -1274,7 +1284,7 @@ moves_loop: // When in check search starts from here // to search the moves. Because the depth is <= 0 here, only captures, // queen promotions and checks (only if depth >= DEPTH_QS_CHECKS) will // be generated. - MovePicker mp(pos, ttMove, depth, pos.this_thread()->history, to_sq((ss-1)->currentMove)); + MovePicker mp(pos, ttMove, depth, to_sq((ss-1)->currentMove)); CheckInfo ci(pos); // Loop through the moves until no moves remain or a beta cutoff occurs @@ -1413,8 +1423,8 @@ moves_loop: // When in check search starts from here } - // update_stats() updates killers, history, countermove and countermove - // history when a new quiet best move is found. + // update_stats() updates killers, history, countermove and countermove plus + // follow-up move history when a new quiet best move is found. void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt) { @@ -1428,34 +1438,51 @@ moves_loop: // When in check search starts from here Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + depth / ONE_PLY - 1); Square prevSq = to_sq((ss-1)->currentMove); - CounterMoveStats& cmh = CounterMoveHistory[pos.piece_on(prevSq)][prevSq]; + CounterMoveStats* cmh = (ss-1)->counterMoves; + CounterMoveStats* fmh = (ss-2)->counterMoves; + CounterMoveStats* fmh2 = (ss-4)->counterMoves; Thread* thisThread = pos.this_thread(); thisThread->history.update(pos.moved_piece(move), to_sq(move), bonus); - if (is_ok((ss-1)->currentMove)) + if (cmh) { thisThread->counterMoves.update(pos.piece_on(prevSq), prevSq, move); - cmh.update(pos.moved_piece(move), to_sq(move), bonus); + cmh->update(pos.moved_piece(move), to_sq(move), bonus); } + if (fmh) + fmh->update(pos.moved_piece(move), to_sq(move), bonus); + + if (fmh2) + fmh2->update(pos.moved_piece(move), to_sq(move), bonus); + // Decrease all the other played quiet moves for (int i = 0; i < quietsCnt; ++i) { thisThread->history.update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus); - if (is_ok((ss-1)->currentMove)) - cmh.update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus); + if (cmh) + cmh->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus); + + if (fmh) + fmh->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus); + + if (fmh2) + fmh2->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus); } // Extra penalty for a quiet TT move in previous ply when it gets refuted - if ( (ss-1)->moveCount == 1 - && !pos.captured_piece_type() - && is_ok((ss-2)->currentMove)) + if ((ss-1)->moveCount == 1 && !pos.captured_piece_type()) { - Square prevPrevSq = to_sq((ss-2)->currentMove); - CounterMoveStats& prevCmh = CounterMoveHistory[pos.piece_on(prevPrevSq)][prevPrevSq]; - prevCmh.update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY); + if ((ss-2)->counterMoves) + (ss-2)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY); + + if ((ss-3)->counterMoves) + (ss-3)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY); + + if ((ss-5)->counterMoves) + (ss-5)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY); } } @@ -1465,7 +1492,7 @@ moves_loop: // When in check search starts from here Move Skill::pick_best(size_t multiPV) { - const Search::RootMoveVector& rootMoves = Threads.main()->rootMoves; + const RootMoves& rootMoves = Threads.main()->rootMoves; static PRNG rng(now()); // PRNG sequence should be non-deterministic // RootMoves are already sorted by score in descending order @@ -1530,7 +1557,7 @@ string UCI::pv(const Position& pos, Depth depth, Value alpha, Value beta) { std::stringstream ss; int elapsed = Time.elapsed() + 1; - const Search::RootMoveVector& rootMoves = pos.this_thread()->rootMoves; + const RootMoves& rootMoves = pos.this_thread()->rootMoves; size_t PVIdx = pos.this_thread()->PVIdx; size_t multiPV = std::min((size_t)Options["MultiPV"], rootMoves.size()); uint64_t nodes_searched = Threads.nodes_searched();