X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=46e93d071e012ed2e0c0daa4f014638e7c538d48;hp=c54c1269089ed9237558f4adb18595573235b4ea;hb=d490bb99734bd6e2f8a0a352d2f3f1ba264ece66;hpb=e0504ab876a997321102f040ab88203cb893db12 diff --git a/src/search.cpp b/src/search.cpp index c54c1269..46e93d07 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,38 +132,6 @@ 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; - - 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); } - EasyMoveManager EasyMove; Value DrawValue[COLOR_NB]; @@ -212,7 +186,7 @@ void Search::clear() { for (Thread* th : Threads) { th->counterMoves.clear(); - th->fromTo.clear(); + th->history.clear(); th->counterMoveHistory.clear(); th->resetCalls = true; } @@ -334,6 +308,9 @@ void MainThread::search() { std::cout << sync_endl; } +// Sizes and phases of the skip-blocks, used for distributing search depths across the threads. +static int skipsize[20] = {1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4}; +static int phase [20] = {0, 1, 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 7}; // Thread::search() is the main iterative deepening loop. It calls search() // repeatedly with increasing depth until the allocated thinking time has been @@ -347,6 +324,8 @@ void Thread::search() { MainThread* mainThread = (this == Threads.main() ? Threads.main() : nullptr); std::memset(ss-4, 0, 7 * sizeof(Stack)); + for(int i = -4; i < 0; i++) + (ss+i)->counterMoves = &this->counterMoveHistory[NO_PIECE][0]; // use as sentinel. bestValue = delta = alpha = -VALUE_INFINITE; beta = VALUE_INFINITE; @@ -371,19 +350,16 @@ void Thread::search() { multiPV = std::min(multiPV, rootMoves.size()); + int hIdx = (idx - 1) % 20; // helper index, cycle after 20 threads + // Iterative deepening loop until requested to stop or the target depth is reached while ( (rootDepth += ONE_PLY) < DEPTH_MAX && !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 half of the plies in blocks depending on game ply and helper index. + if (idx && ((rootDepth / ONE_PLY + rootPos.game_ply() + phase[hIdx]) / skipsize[hIdx]) % 2) + continue; // Age out PV variability metric if (mainThread) @@ -420,7 +396,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) @@ -502,7 +478,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 @@ -561,7 +537,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; @@ -619,7 +595,7 @@ namespace { assert(0 <= ss->ply && ss->ply < MAX_PLY); ss->currentMove = (ss+1)->excludedMove = bestMove = MOVE_NONE; - ss->counterMoves = nullptr; + ss->counterMoves = &thisThread->counterMoveHistory[NO_PIECE][0]; (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE; Square prevSq = to_sq((ss-1)->currentMove); @@ -642,14 +618,24 @@ namespace { : (tte->bound() & BOUND_UPPER))) { // If ttMove is quiet, update move sorting heuristics on TT hit - if (ttValue >= beta && ttMove) + 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; } @@ -720,7 +706,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) @@ -746,17 +731,18 @@ namespace { && (ss->staticEval >= beta - 35 * (depth / ONE_PLY - 6) || depth >= 13 * ONE_PLY) && pos.non_pawn_material(pos.side_to_move())) { - ss->currentMove = MOVE_NULL; - ss->counterMoves = nullptr; assert(eval - beta >= 0); // Null move dynamic reduction based on depth and value Depth R = ((823 + 67 * depth / ONE_PLY) / 256 + std::min((eval - beta) / PawnValueMg, 3)) * ONE_PLY; + ss->currentMove = MOVE_NULL; + ss->counterMoves = &thisThread->counterMoveHistory[NO_PIECE][0]; + 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) @@ -788,8 +774,7 @@ namespace { Depth rdepth = depth - 4 * ONE_PLY; assert(rdepth >= ONE_PLY); - assert((ss-1)->currentMove != MOVE_NONE); - assert((ss-1)->currentMove != MOVE_NULL); + assert(is_ok((ss-1)->currentMove)); MovePicker mp(pos, ttMove, rbeta - ss->staticEval); @@ -798,6 +783,7 @@ namespace { { ss->currentMove = move; ss->counterMoves = &thisThread->counterMoveHistory[pos.moved_piece(move)][to_sq(move)]; + pos.do_move(move, st); value = -search(pos, ss+1, -rbeta, -rbeta+1, rdepth, !cutNode, false); pos.undo_move(move); @@ -823,6 +809,9 @@ moves_loop: // When in check search starts from here const CounterMoveStats* cmh = (ss-1)->counterMoves; const CounterMoveStats* fmh = (ss-2)->counterMoves; const CounterMoveStats* fmh2 = (ss-4)->counterMoves; + const bool cm_ok = is_ok((ss-1)->currentMove); + const bool fm_ok = is_ok((ss-2)->currentMove); + const bool fm2_ok = is_ok((ss-4)->currentMove); MovePicker mp(pos, ttMove, depth, ss); value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc @@ -875,7 +864,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)) @@ -901,7 +891,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 @@ -910,7 +900,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) @@ -921,9 +911,9 @@ moves_loop: // When in check search starts from here // Countermoves based pruning if ( lmrDepth < 3 - && (!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))) + && (((*cmh )[moved_piece][to_sq(move)] < VALUE_ZERO) || !cm_ok) + && (((*fmh )[moved_piece][to_sq(move)] < VALUE_ZERO) || !fm_ok) + && (((*fmh2)[moved_piece][to_sq(move)] < VALUE_ZERO) || !fm2_ok || (cm_ok && fm_ok))) continue; // Futility pruning: parent node @@ -953,6 +943,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)]; @@ -982,11 +973,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 = (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 )[moved_piece][to_sq(move)] + + (*fmh )[moved_piece][to_sq(move)] + + (*fmh2)[moved_piece][to_sq(move)] + + 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) @@ -1118,17 +1109,17 @@ moves_loop: // When in check search starts from here // 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)); + && cm_ok) + 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 : @@ -1387,18 +1378,9 @@ moves_loop: // When in check search starts from here void update_cm_stats(Stack* ss, Piece pc, Square s, Value bonus) { - CounterMoveStats* cmh = (ss-1)->counterMoves; - CounterMoveStats* fmh1 = (ss-2)->counterMoves; - CounterMoveStats* fmh2 = (ss-4)->counterMoves; - - if (cmh) - cmh->update(pc, s, bonus); - - if (fmh1) - fmh1->update(pc, s, bonus); - - if (fmh2) - fmh2->update(pc, s, bonus); + for (int i : {1, 2, 4}) + if (is_ok((ss-i)->currentMove)) + (ss-i)->counterMoves->update(pc, s, bonus); } @@ -1415,10 +1397,10 @@ 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(c, move, bonus); update_cm_stats(ss, pos.moved_piece(move), to_sq(move), bonus); - if ((ss-1)->counterMoves) + if (is_ok((ss-1)->currentMove)) { Square prevSq = to_sq((ss-1)->currentMove); thisThread->counterMoves.update(pos.piece_on(prevSq), prevSq, move); @@ -1427,7 +1409,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(c, quiets[i], -bonus); update_cm_stats(ss, pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus); } }