X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=31e8b0b661f46392453d097c39e137ba52bead57;hp=3387091363212dc40b0d88c17e210cdd44d5db8b;hb=3627348e2b4633604a878b0e5397acb6218a6afc;hpb=b7b9d7c9c72a987bb497ec2b629d885a06238aa2 diff --git a/src/search.cpp b/src/search.cpp index 33870913..31e8b0b6 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -2,7 +2,7 @@ Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad - Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad + Copyright (C) 2015-2017 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -75,6 +75,12 @@ namespace { return Reductions[PvNode][i][std::min(d / ONE_PLY, 63)][std::min(mn, 63)] * ONE_PLY; } + // History and stats update bonus, based on depth + Value stat_bonus(Depth depth) { + int d = depth / ONE_PLY ; + return Value(d * d + 2 * d - 2); + } + // Skill structure is used to implement strength limit struct Skill { Skill(int l) : level(l) {} @@ -126,37 +132,18 @@ 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}, - }; + // skip half of the plies in blocks depending on the helper thread idx. + bool skip_ply(int idx, int ply) { - Value bonus(Depth depth) { int d = depth / ONE_PLY ; return Value(d * d + 2 * d - 2); } - Value penalty(Depth depth) { int d = depth / ONE_PLY ; return -Value(d * d + 4 * d + 1); } + idx = (idx - 1) % 20 + 1; // cycle after 20 threads. - const size_t HalfDensitySize = std::extent::value; + // number of successive plies to skip, depending on idx. + int ones = 1; + while (ones * (ones + 1) < idx) + ones++; + + return ((ply + idx - 1) / ones - ones) % 2 == 0; + } EasyMoveManager EasyMove; Value DrawValue[COLOR_NB]; @@ -211,9 +198,8 @@ void Search::clear() { for (Thread* th : Threads) { - th->history.clear(); th->counterMoves.clear(); - th->fromTo.clear(); + th->history.clear(); th->counterMoveHistory.clear(); th->resetCalls = true; } @@ -312,9 +298,13 @@ void MainThread::search() { && rootMoves[0].pv[0] != MOVE_NONE) { for (Thread* th : Threads) - if ( th->completedDepth > bestThread->completedDepth - && th->rootMoves[0].score > bestThread->rootMoves[0].score) + { + Depth depthDiff = th->completedDepth - bestThread->completedDepth; + Value scoreDiff = th->rootMoves[0].score - bestThread->rootMoves[0].score; + + if (scoreDiff > 0 && depthDiff >= 0) bestThread = th; + } } previousScore = bestThread->rootMoves[0].score; @@ -373,14 +363,9 @@ void Thread::search() { && !Signals.stop && (!Limits.depth || Threads.main()->rootDepth / ONE_PLY <= Limits.depth)) { - // Set up the new depths for the helper threads skipping on average every - // 2nd ply (using a half-density matrix). - if (!mainThread) - { - const Row& row = HalfDensity[(idx - 1) % HalfDensitySize]; - if (row[(rootDepth / ONE_PLY + rootPos.game_ply()) % row.size()]) - continue; - } + // skip plies for helper threads + if (idx && skip_ply(idx, rootDepth / ONE_PLY + rootPos.game_ply())) + continue; // Age out PV variability metric if (mainThread) @@ -417,7 +402,7 @@ void Thread::search() { // search the already searched PV lines are preserved. std::stable_sort(rootMoves.begin() + PVIdx, rootMoves.end()); - // If search has been stopped, break immediately. Sorting and + // If search has been stopped, we break immediately. Sorting and // writing PV back to TT is safe because RootMoves is still // valid, although it refers to the previous iteration. if (Signals.stop) @@ -499,7 +484,7 @@ void Thread::search() { bool doEasyMove = rootMoves[0].pv[0] == easyMove && mainThread->bestMoveChanges < 0.03 - && Time.elapsed() > Time.optimum() * 5 / 42; + && Time.elapsed() > Time.optimum() * 5 / 44; if ( rootMoves.size() == 1 || Time.elapsed() > Time.optimum() * unstablePvFactor * improvingFactor / 628 @@ -558,7 +543,7 @@ namespace { Key posKey; Move ttMove, move, excludedMove, bestMove; Depth extension, newDepth; - Value bestValue, value, ttValue, eval, nullValue; + Value bestValue, value, ttValue, eval; bool ttHit, inCheck, givesCheck, singularExtensionNode, improving; bool captureOrPromotion, doFullDepthSearch, moveCountPruning; Piece moved_piece; @@ -638,15 +623,25 @@ namespace { && (ttValue >= beta ? (tte->bound() & BOUND_LOWER) : (tte->bound() & BOUND_UPPER))) { - // If ttMove is quiet, update killers, history, counter move on TT hit - if (ttValue >= beta && ttMove) + // If ttMove is quiet, update move sorting heuristics on TT hit + if (ttMove) { - if (!pos.capture_or_promotion(ttMove)) - update_stats(pos, ss, ttMove, nullptr, 0, bonus(depth)); + if (ttValue >= beta) + { + if (!pos.capture_or_promotion(ttMove)) + update_stats(pos, ss, ttMove, nullptr, 0, stat_bonus(depth)); - // Extra penalty for a quiet TT move in previous ply when it gets refuted - if ((ss-1)->moveCount == 1 && !pos.captured_piece()) - update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, penalty(depth)); + // Extra penalty for a quiet TT move in previous ply when it gets refuted + if ((ss-1)->moveCount == 1 && !pos.captured_piece()) + update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, -stat_bonus(depth + ONE_PLY)); + } + // Penalty for a quiet ttMove that fails low + else if (!pos.capture_or_promotion(ttMove)) + { + Value penalty = -stat_bonus(depth + ONE_PLY); + thisThread->history.update(pos.side_to_move(), ttMove, penalty); + update_cm_stats(ss, pos.moved_piece(ttMove), to_sq(ttMove), penalty); + } } return ttValue; } @@ -717,7 +712,6 @@ namespace { // Step 6. Razoring (skipped when in check) if ( !PvNode && depth < 4 * ONE_PLY - && ttMove == MOVE_NONE && eval + razor_margin[depth / ONE_PLY] <= alpha) { if (depth <= ONE_PLY) @@ -752,8 +746,8 @@ namespace { Depth R = ((823 + 67 * depth / ONE_PLY) / 256 + std::min((eval - beta) / PawnValueMg, 3)) * ONE_PLY; pos.do_null_move(st); - nullValue = depth-R < ONE_PLY ? -qsearch(pos, ss+1, -beta, -beta+1) - : - search(pos, ss+1, -beta, -beta+1, depth-R, !cutNode, true); + Value nullValue = depth-R < ONE_PLY ? -qsearch(pos, ss+1, -beta, -beta+1) + : - search(pos, ss+1, -beta, -beta+1, depth-R, !cutNode, true); pos.undo_null_move(); if (nullValue >= beta) @@ -872,7 +866,8 @@ moves_loop: // When in check search starts from here moveCountPruning = depth < 16 * ONE_PLY && moveCount >= FutilityMoveCounts[improving][depth / ONE_PLY]; - // Step 12. Extend checks + // Step 12. Extensions + // Extend checks if ( givesCheck && !moveCountPruning && pos.see_ge(move, VALUE_ZERO)) @@ -898,7 +893,7 @@ moves_loop: // When in check search starts from here extension = ONE_PLY; } - // Update the current move (this must be done after singular extension search) + // Calculate new depth for this move newDepth = depth - ONE_PLY + extension; // Step 13. Pruning at shallow depth @@ -907,7 +902,7 @@ moves_loop: // When in check search starts from here { if ( !captureOrPromotion && !givesCheck - && !pos.advanced_pawn_push(move)) + && (!pos.advanced_pawn_push(move) || pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 5000)) { // Move count based pruning if (moveCountPruning) @@ -950,6 +945,7 @@ moves_loop: // When in check search starts from here continue; } + // Update the current move (this must be done after singular extension search) ss->currentMove = move; ss->counterMoves = &thisThread->counterMoveHistory[moved_piece][to_sq(move)]; @@ -979,12 +975,11 @@ moves_loop: // When in check search starts from here && !pos.see_ge(make_move(to_sq(move), from_sq(move)), VALUE_ZERO)) r -= 2 * ONE_PLY; - ss->history = 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) - + thisThread->fromTo.get(~pos.side_to_move(), move) - - 8000; // Correction factor + ss->history = (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) + + thisThread->history.get(~pos.side_to_move(), move) + - 4000; // Correction factor // Decrease/increase reduction by comparing opponent's stat score if (ss->history > VALUE_ZERO && (ss-1)->history < VALUE_ZERO) @@ -1114,19 +1109,19 @@ moves_loop: // When in check search starts from here else if (bestMove) { - // Quiet best move: update killers, history and countermoves + // Quiet best move: update move sorting heuristics if (!pos.capture_or_promotion(bestMove)) - update_stats(pos, ss, bestMove, quietsSearched, quietCount, bonus(depth)); + update_stats(pos, ss, bestMove, quietsSearched, quietCount, stat_bonus(depth)); // Extra penalty for a quiet TT move in previous ply when it gets refuted if ((ss-1)->moveCount == 1 && !pos.captured_piece()) - update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, penalty(depth)); + update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, -stat_bonus(depth + ONE_PLY)); } // Bonus for prior countermove that caused the fail low else if ( depth >= 3 * ONE_PLY && !pos.captured_piece() && is_ok((ss-1)->currentMove)) - update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, bonus(depth)); + update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, stat_bonus(depth)); tte->save(posKey, value_to_tt(bestValue, ss->ply), bestValue >= beta ? BOUND_LOWER : @@ -1400,8 +1395,7 @@ moves_loop: // When in check search starts from here } - // update_stats() updates killers, history, countermove and countermove plus - // follow-up move history when a new quiet best move is found. + // update_stats() updates move sorting heuristics when a new quiet best move is found void update_stats(const Position& pos, Stack* ss, Move move, Move* quiets, int quietsCnt, Value bonus) { @@ -1414,8 +1408,7 @@ moves_loop: // When in check search starts from here Color c = pos.side_to_move(); Thread* thisThread = pos.this_thread(); - thisThread->fromTo.update(c, move, bonus); - thisThread->history.update(pos.moved_piece(move), to_sq(move), bonus); + thisThread->history.update(c, move, bonus); update_cm_stats(ss, pos.moved_piece(move), to_sq(move), bonus); if ((ss-1)->counterMoves) @@ -1427,8 +1420,7 @@ moves_loop: // When in check search starts from here // Decrease all the other played quiet moves for (int i = 0; i < quietsCnt; ++i) { - thisThread->fromTo.update(c, quiets[i], -bonus); - thisThread->history.update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus); + thisThread->history.update(c, quiets[i], -bonus); update_cm_stats(ss, pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus); } }