X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=95f1332ed1ddb6e1ca743e006cdf1039bcd034d8;hp=af01050212ceca3ef4c9a4225c4952ede31b683b;hb=d48a304262eb6b96864df11734976b4a57fcc72a;hpb=58aee9a9ea522cd9eb40b6a4cc888e37e2da54c5 diff --git a/src/search.cpp b/src/search.cpp index af010502..95f1332e 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -1,7 +1,7 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2008-2014 Marco Costalba, Joona Kiiski, 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 @@ -19,6 +19,7 @@ #include #include +#include #include #include #include @@ -42,7 +43,7 @@ namespace Search { std::vector RootMoves; Position RootPos; Color RootColor; - Time::point SearchTime; + Time::point SearchTime, IterationTime; StateStackPtr SetupStates; } @@ -50,14 +51,17 @@ using std::string; using Eval::evaluate; using namespace Search; +// Fast wrapper for common case of pos.gives_check() +#define FAST_GIVES_CHECK(pos, m, ci) \ + ((type_of(m) == NORMAL && ci.dcCandidates == 0) \ + ? (ci.checkSq[type_of(pos.piece_on(from_sq(m)))] & to_sq(m)) \ + : pos.gives_check(m, ci)) + namespace { // Set to true to force running with one thread. Used for debugging const bool FakeSplit = false; - // This is the minimum interval in msec between two check_time() calls - const int TimerResolution = 5; - // Different node types, used as template parameter enum NodeType { Root, PV, NonPV, SplitPointRoot, SplitPointPV, SplitPointNonPV }; @@ -65,30 +69,27 @@ 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[32]; // [depth] + 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 - int8_t Reductions[2][64][64]; // [pv][depth][moveNumber] + int8_t Reductions[2][2][64][64]; // [pv][improving][depth][moveNumber] - template inline Depth reduction(Depth d, int mn) { + template inline Depth reduction(bool i, Depth d, int mn) { - return (Depth) Reductions[PvNode][std::min(int(d) / ONE_PLY, 63)][std::min(mn, 63)]; + return (Depth) Reductions[PvNode][i][std::min(int(d) / ONE_PLY, 63)][std::min(mn, 63)]; } size_t PVSize, PVIdx; TimeManager TimeMgr; - int BestMoveChanges; + double BestMoveChanges; Value DrawValue[COLOR_NB]; HistoryStats History; GainsStats Gains; - CountermovesStats Countermoves; + MovesStats Countermoves, Followupmoves; template Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode); @@ -99,9 +100,7 @@ namespace { void id_loop(Position& pos); Value value_to_tt(Value v, int ply); Value value_from_tt(Value v, int ply); - bool check_is_dangerous(const Position& pos, Move move, Value futilityBase, Value beta); - bool allows(const Position& pos, Move first, Move second); - bool refutes(const Position& pos, Move first, Move second); + void update_stats(Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt); string uci_pv(const Position& pos, int depth, Value alpha, Value beta); struct Skill { @@ -132,28 +131,36 @@ void Search::init() { int mc; // moveCount // Init reductions array - for (hd = 1; hd < 64; hd++) for (mc = 1; mc < 64; mc++) + for (hd = 1; hd < 64; ++hd) for (mc = 1; mc < 64; ++mc) { double pvRed = log(double(hd)) * log(double(mc)) / 3.0; double nonPVRed = 0.33 + log(double(hd)) * log(double(mc)) / 2.25; - Reductions[1][hd][mc] = (int8_t) ( pvRed >= 1.0 ? floor( pvRed * int(ONE_PLY)) : 0); - Reductions[0][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(ONE_PLY)) : 0); - } + Reductions[1][1][hd][mc] = (int8_t) ( pvRed >= 1.0 ? floor( pvRed * int(ONE_PLY)) : 0); + Reductions[0][1][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(ONE_PLY)) : 0); - // Init futility margins array - for (d = 1; d < 16; d++) for (mc = 0; mc < 64; mc++) - FutilityMargins[d][mc] = Value(112 * int(log(double(d * d) / 2) / log(2.0) + 1.001) - 8 * mc + 45); + Reductions[1][0][hd][mc] = Reductions[1][1][hd][mc]; + Reductions[0][0][hd][mc] = Reductions[0][1][hd][mc]; + + if (Reductions[0][0][hd][mc] > 2 * ONE_PLY) + Reductions[0][0][hd][mc] += ONE_PLY; + + else if (Reductions[0][0][hd][mc] > 1 * ONE_PLY) + Reductions[0][0][hd][mc] += ONE_PLY / 2; + } // Init futility move count array - for (d = 0; d < 32; d++) - FutilityMoveCounts[d] = int(3.001 + 0.3 * pow(double(d), 1.8)); + for (d = 0; d < 32; ++d) + { + FutilityMoveCounts[0][d] = int(2.4 + 0.222 * pow(d + 0.0, 1.8)); + FutilityMoveCounts[1][d] = int(3.0 + 0.3 * pow(d + 0.98, 1.8)); + } } /// Search::perft() is our utility to verify move generation. All the leaf nodes /// up to the given depth are generated and counted and the sum returned. -size_t Search::perft(Position& pos, Depth depth) { +static size_t perft(Position& pos, Depth depth) { StateInfo st; size_t cnt = 0; @@ -162,13 +169,16 @@ size_t Search::perft(Position& pos, Depth depth) { for (MoveList it(pos); *it; ++it) { - pos.do_move(*it, st, ci, pos.move_gives_check(*it, ci)); - cnt += leaf ? MoveList(pos).size() : perft(pos, depth - ONE_PLY); + pos.do_move(*it, st, ci, pos.gives_check(*it, ci)); + cnt += leaf ? MoveList(pos).size() : ::perft(pos, depth - ONE_PLY); pos.undo_move(*it); } return cnt; } +size_t Search::perft(Position& pos, Depth depth) { + return depth > ONE_PLY ? ::perft(pos, depth) : MoveList(pos).size(); +} /// Search::think() is the external interface to Stockfish's search, and is /// called by the main thread when the program receives the UCI 'go' command. It @@ -212,7 +222,7 @@ void Search::think() { else DrawValue[WHITE] = DrawValue[BLACK] = VALUE_DRAW; - if (Options["Use Search Log"]) + if (Options["Write Search Log"]) { Log log(Options["Search Log Filename"]); log << "\nSearching: " << RootPos.fen() @@ -224,27 +234,20 @@ void Search::think() { << std::endl; } - // Reset the threads, still sleeping: will be wake up at split time - for (size_t i = 0; i < Threads.size(); i++) + // Reset the threads, still sleeping: will wake up at split time + for (size_t i = 0; i < Threads.size(); ++i) Threads[i]->maxPly = 0; - Threads.sleepWhileIdle = Options["Use Sleeping Threads"]; - - // Set best timer interval to avoid lagging under time pressure. Timer is - // used to check for remaining available thinking time. - Threads.timer->msec = - Limits.use_time_management() ? std::min(100, std::max(TimeMgr.available_time() / 16, TimerResolution)) : - Limits.nodes ? 2 * TimerResolution - : 100; - + Threads.sleepWhileIdle = Options["Idle Threads Sleep"]; + Threads.timer->run = true; Threads.timer->notify_one(); // Wake up the recurring timer id_loop(RootPos); // Let's start searching ! - Threads.timer->msec = 0; // Stop the timer + Threads.timer->run = false; // Stop the timer Threads.sleepWhileIdle = true; // Send idle threads to sleep - if (Options["Use Search Log"]) + if (Options["Write Search Log"]) { Time::point elapsed = Time::now() - SearchTime + 1; @@ -265,11 +268,11 @@ 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, - // 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 - // raise Signals.stop). + // When we reach the maximum depth, we can arrive here without a raise of + // Signals.stop. However, if we are pondering or in an infinite search, + // the UCI protocol states that we shouldn't print the best move before the + // GUI sends a "stop" or "ponderhit" command. We therefore simply wait here + // until the GUI sends one of those commands (which also raises Signals.stop). if (!Signals.stop && (Limits.ponder || Limits.infinite)) { Signals.stopOnPonderhit = true; @@ -291,14 +294,15 @@ namespace { void id_loop(Position& pos) { - Stack stack[MAX_PLY_PLUS_2], *ss = stack+1; // To allow referencing (ss-1) - int depth, prevBestMoveChanges; + Stack stack[MAX_PLY_PLUS_6], *ss = stack+2; // To allow referencing (ss-2) + int depth; Value bestValue, alpha, beta, delta; - memset(ss-1, 0, 4 * sizeof(Stack)); + std::memset(ss-2, 0, 5 * sizeof(Stack)); (ss-1)->currentMove = MOVE_NULL; // Hack to skip update gains - depth = BestMoveChanges = 0; + depth = 0; + BestMoveChanges = 0; bestValue = delta = alpha = -VALUE_INFINITE; beta = VALUE_INFINITE; @@ -306,6 +310,7 @@ namespace { History.clear(); Gains.clear(); Countermoves.clear(); + Followupmoves.clear(); PVSize = Options["MultiPV"]; Skill skill(Options["Skill Level"]); @@ -320,16 +325,16 @@ namespace { // Iterative deepening loop until requested to stop or target depth reached while (++depth <= MAX_PLY && !Signals.stop && (!Limits.depth || depth <= Limits.depth)) { - // 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. - for (size_t i = 0; i < RootMoves.size(); i++) - RootMoves[i].prevScore = RootMoves[i].score; + // Age out PV variability metric + BestMoveChanges *= 0.8; - prevBestMoveChanges = BestMoveChanges; // Only sensible when PVSize == 1 - BestMoveChanges = 0; + // Save the last iteration's scores before first PV line is searched and + // all 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) @@ -339,33 +344,40 @@ namespace { beta = std::min(RootMoves[PVIdx].prevScore + delta, VALUE_INFINITE); } - // Start with a small aspiration window and, in case of fail high/low, - // research with bigger window until not failing high/low anymore. + // Start with a small aspiration window and, in the case of a fail + // high/low, re-search with a bigger window until we're not failing + // high/low anymore. while (true) { bestValue = search(pos, ss, alpha, beta, depth * ONE_PLY, false); - // Bring to front the best move. It is critical that sorting is - // done with a stable algorithm because all the values but the first - // and eventually the new best one are set to -VALUE_INFINITE and - // we want to keep the same order for all the moves but the new - // PV that goes to the front. Note that in case of MultiPV search - // the already searched PV lines are preserved. + // Bring the best move to the front. It is critical that sorting + // is done with a stable algorithm because all the values but the + // first and eventually the new best one are set to -VALUE_INFINITE + // and we want to keep the same order for all the moves except the + // new PV that goes to the front. Note that in case of MultiPV + // search the already searched PV lines are preserved. std::stable_sort(RootMoves.begin() + PVIdx, RootMoves.end()); // Write PV back to transposition table in case the relevant // entries have been overwritten during the search. - for (size_t i = 0; i <= PVIdx; i++) + for (size_t i = 0; i <= PVIdx; ++i) RootMoves[i].insert_pv_in_tt(pos); - // If search has been stopped return immediately. Sorting and - // writing PV back to TT is safe becuase RootMoves is still - // valid, although refers to previous iteration. + // If search has been stopped break immediately. Sorting and + // writing PV back to TT is safe because RootMoves is still + // valid, although it refers to previous iteration. if (Signals.stop) - return; + break; + + // When failing high/low give some update (without cluttering + // the UI) before a re-search. + if ( (bestValue <= alpha || bestValue >= beta) + && Time::now() - SearchTime > 3000) + sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl; // In case of failing low/high increase aspiration window and - // research, otherwise exit the loop. + // re-search, otherwise exit the loop. if (bestValue <= alpha) { alpha = std::max(bestValue - delta, -VALUE_INFINITE); @@ -382,10 +394,6 @@ namespace { delta += delta / 2; assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE); - - // Give some update (without cluttering the UI) before to research - if (Time::now() - SearchTime > 3000) - sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl; } // Sort the PV lines searched so far and update the GUI @@ -395,11 +403,13 @@ namespace { sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl; } - // Do we need to pick now the sub-optimal best move ? + IterationTime = Time::now() - SearchTime; + + // If skill levels are enabled and time is up, pick a sub-optimal best move if (skill.enabled() && skill.time_to_pick(depth)) skill.pick_move(); - if (Options["Use Search Log"]) + if (Options["Write Search Log"]) { RootMove& rm = RootMoves[0]; if (skill.best != MOVE_NONE) @@ -410,50 +420,32 @@ 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, prevBestMoveChanges); + TimeMgr.pv_instability(BestMoveChanges); - // Stop search if most of 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) + // Stop the search if only one legal move is available or most + // of the available time has been used. We probably don't have + // enough time to search the first move at the next iteration anyway. + if ( RootMoves.size() == 1 + || IterationTime > (TimeMgr.available_time() * 62) / 100) stop = true; - // Stop search early if one move seems to be much better than others - if ( depth >= 12 - && !stop - && PVSize == 1 - && bestValue > VALUE_MATED_IN_MAX_PLY - && ( RootMoves.size() == 1 - || Time::now() - SearchTime > (TimeMgr.available_time() * 20) / 100)) - { - Value rBeta = bestValue - 2 * PawnValueMg; - ss->excludedMove = RootMoves[0].pv[0]; - ss->skipNullMove = true; - Value v = search(pos, ss, rBeta - 1, rBeta, (depth - 3) * ONE_PLY, true); - ss->skipNullMove = false; - ss->excludedMove = MOVE_NONE; - - if (v < rBeta) - stop = true; - } - if (stop) { // If we are allowed to ponder do not stop the search now but - // keep pondering until GUI sends "ponderhit" or "stop". + // keep pondering until the GUI sends "ponderhit" or "stop". if (Limits.ponder) Signals.stopOnPonderhit = true; else @@ -467,9 +459,9 @@ namespace { // search<>() is the main search function for both PV and non-PV nodes and for // normal and SplitPoint nodes. When called just after a split point the search // is simpler because we have already probed the hash table, done a null move - // search, and searched the first move before splitting, we don't have to repeat - // all this work again. We also don't need to store anything to the hash table - // here: This is taken care of after we return from the split point. + // search, and searched the first move before splitting, so we don't have to + // repeat all this work again. We also don't need to store anything to the hash + // table here: This is taken care of after we return from the split point. template Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode) { @@ -487,24 +479,21 @@ namespace { const TTEntry *tte; SplitPoint* splitPoint; Key posKey; - Move ttMove, move, excludedMove, bestMove, threatMove; - Depth ext, newDepth; - Value bestValue, value, ttValue; - Value eval, nullValue, futilityValue; - bool inCheck, givesCheck, pvMove, singularExtensionNode; + Move ttMove, move, excludedMove, bestMove; + Depth ext, newDepth, predictedDepth; + Value bestValue, value, ttValue, eval, nullValue, futilityValue; + bool inCheck, givesCheck, pvMove, singularExtensionNode, improving; bool captureOrPromotion, dangerous, doFullDepthSearch; int moveCount, quietCount; // Step 1. Initialize node Thread* thisThread = pos.this_thread(); - moveCount = quietCount = 0; inCheck = pos.checkers(); if (SpNode) { splitPoint = ss->splitPoint; bestMove = splitPoint->bestMove; - threatMove = splitPoint->threatMove; bestValue = splitPoint->bestValue; tte = NULL; ttMove = excludedMove = MOVE_NONE; @@ -515,10 +504,10 @@ namespace { goto moves_loop; } + moveCount = quietCount = 0; bestValue = -VALUE_INFINITE; - ss->currentMove = threatMove = (ss+1)->excludedMove = bestMove = MOVE_NONE; + ss->currentMove = ss->ttMove = (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; @@ -535,9 +524,9 @@ namespace { // Step 3. Mate distance pruning. Even if we mate at the next move our score // would be at best mate_in(ss->ply+1), but if alpha is already bigger because // a shorter mate was found upward in the tree then there is no need to search - // further, we will never beat current alpha. Same logic but with reversed signs - // applies also in the opposite condition of being mated instead of giving mate, - // in this case return a fail-high score. + // because we will never beat the current alpha. Same logic but with reversed + // signs applies also in the opposite condition of being mated instead of giving + // mate. In this case return a fail-high score. alpha = std::max(mated_in(ss->ply), alpha); beta = std::min(mate_in(ss->ply+1), beta); if (alpha >= beta) @@ -550,11 +539,11 @@ namespace { excludedMove = ss->excludedMove; posKey = excludedMove ? pos.exclusion_key() : pos.key(); tte = TT.probe(posKey); - ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE; + ss->ttMove = ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE; ttValue = tte ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE; - // At PV nodes we check for exact scores, while at non-PV nodes we check for - // a fail high/low. Biggest advantage at probing at PV nodes is to have a + // At PV nodes we check for exact scores, whilst at non-PV nodes we check for + // a fail high/low. The biggest advantage to probing at PV nodes is to have a // smooth experience in analysis mode. We don't probe at Root nodes otherwise // we should also update RootMoveList to avoid bogus output. if ( !RootNode @@ -568,46 +557,37 @@ namespace { TT.refresh(tte); ss->currentMove = ttMove; // Can be MOVE_NONE - if ( ttValue >= beta - && ttMove - && !pos.is_capture_or_promotion(ttMove) - && ttMove != ss->killers[0]) - { - ss->killers[1] = ss->killers[0]; - ss->killers[0] = ttMove; - } + // If ttMove is quiet, update killers, history, counter move and followup move on TT hit + if (ttValue >= beta && ttMove && !pos.capture_or_promotion(ttMove) && !inCheck) + update_stats(pos, ss, ttMove, depth, NULL, 0); + return ttValue; } // 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) - if ( ((tte->bound() & BOUND_LOWER) && ttValue > eval) - || ((tte->bound() & BOUND_UPPER) && ttValue < eval)) + if (tte->bound() & (ttValue > eval ? BOUND_LOWER : BOUND_UPPER)) eval = ttValue; } 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 @@ -618,94 +598,59 @@ namespace { Gains.update(pos.piece_on(to), to, -(ss-1)->staticEval - ss->staticEval); } - // Step 6. Razoring (is omitted in PV nodes) + // Step 6. Razoring (skipped when in check) if ( !PvNode && depth < 4 * ONE_PLY - && eval + razor_margin(depth) < beta + && eval + razor_margin(depth) <= alpha && ttMove == MOVE_NONE && abs(beta) < VALUE_MATE_IN_MAX_PLY && !pos.pawn_on_7th(pos.side_to_move())) { - Value rbeta = beta - razor_margin(depth); - 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. + Value ralpha = alpha - razor_margin(depth); + Value v = qsearch(pos, ss, ralpha, ralpha+1, DEPTH_ZERO); + if (v <= ralpha) return v; } - // Step 7. Static null move pruning (is omitted in PV nodes) - // 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 && !ss->skipNullMove - && depth > ONE_PLY + && depth >= 2 * ONE_PLY && eval >= beta && abs(beta) < VALUE_MATE_IN_MAX_PLY && pos.non_pawn_material(pos.side_to_move())) { ss->currentMove = MOVE_NULL; - // Null move dynamic reduction based on depth - Depth R = 3 * ONE_PLY + depth / 4; + assert(eval - beta >= 0); - // Null move dynamic reduction based on value - if (eval - PawnValueMg > beta) - R += ONE_PLY; + // Null move dynamic reduction based on depth and value + Depth R = 3 * ONE_PLY + + depth / 4 + + int(eval - beta) / PawnValueMg * ONE_PLY; pos.do_null_move(st); (ss+1)->skipNullMove = true; - nullValue = depth-R < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO) - : - search(pos, ss+1, -beta, -alpha, depth-R, !cutNode); + nullValue = depth-R < ONE_PLY ? -qsearch(pos, ss+1, -beta, -beta+1, DEPTH_ZERO) + : - search(pos, ss+1, -beta, -beta+1, depth-R, !cutNode); (ss+1)->skipNullMove = false; pos.undo_null_move(); - if (nullValue >= beta) - { - // Do not return unproven mate scores - if (nullValue >= VALUE_MATE_IN_MAX_PLY) - nullValue = beta; - - if (depth < 12 * ONE_PLY) - return nullValue; - - // Do verification search at high depths - ss->skipNullMove = true; - Value v = search(pos, ss, alpha, beta, depth-R, false); - ss->skipNullMove = false; - - if (v >= beta) - return nullValue; - } - else - { - // The null move failed low, which means that we may be faced with - // some kind of threat. If the previous move was reduced, check if - // the move that refuted the null move was somehow connected to the - // move which was reduced. If a connection is found, return a fail - // low score (which will cause the reduced move to fail high in the - // parent node, which will trigger a re-search with full depth). - threatMove = (ss+1)->currentMove; - - if ( depth < 5 * ONE_PLY - && (ss-1)->reduction - && threatMove != MOVE_NONE - && allows(pos, (ss-1)->currentMove, threatMove)) - return alpha; - } + if (nullValue >= beta) // Do not return unproven mate scores + return nullValue >= VALUE_MATE_IN_MAX_PLY ? beta : nullValue; } - // Step 9. ProbCut (is omitted in PV nodes) + // Step 9. ProbCut (skipped when in check) // If we have a very good capture (i.e. SEE > seeValues[captured_piece_type]) // and a reduced search returns a value much above beta, we can (almost) safely // prune the previous move. @@ -725,10 +670,10 @@ namespace { CheckInfo ci(pos); while ((move = mp.next_move()) != MOVE_NONE) - if (pos.pl_move_is_legal(move, ci.pinned)) + if (pos.legal(move, ci.pinned)) { ss->currentMove = move; - pos.do_move(move, st, ci, pos.move_gives_check(move, ci)); + pos.do_move(move, st, ci, pos.gives_check(move, ci)); value = -search(pos, ss+1, -rbeta, -rbeta+1, rdepth, !cutNode); pos.undo_move(move); if (value >= rbeta) @@ -736,7 +681,7 @@ namespace { } } - // Step 10. Internal iterative deepening + // Step 10. Internal iterative deepening (skipped when in check) if ( depth >= (PvNode ? 5 * ONE_PLY : 8 * ONE_PLY) && ttMove == MOVE_NONE && (PvNode || ss->staticEval + Value(256) >= beta)) @@ -757,12 +702,20 @@ moves_loop: // When in check and at SpNode search starts from here Move countermoves[] = { Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq].first, Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq].second }; - MovePicker mp(pos, ttMove, depth, History, countermoves, ss, PvNode ? -VALUE_INFINITE : beta); + Square prevOwnMoveSq = to_sq((ss-2)->currentMove); + Move followupmoves[] = { Followupmoves[pos.piece_on(prevOwnMoveSq)][prevOwnMoveSq].first, + Followupmoves[pos.piece_on(prevOwnMoveSq)][prevOwnMoveSq].second }; + + MovePicker mp(pos, ttMove, depth, History, countermoves, followupmoves, ss); CheckInfo ci(pos); value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc + improving = ss->staticEval >= (ss-2)->staticEval + || ss->staticEval == VALUE_NONE + ||(ss-2)->staticEval == VALUE_NONE; + singularExtensionNode = !RootNode && !SpNode - && depth >= (PvNode ? 6 * ONE_PLY : 8 * ONE_PLY) + && depth >= 8 * ONE_PLY && ttMove != MOVE_NONE && !excludedMove // Recursive singular search is not allowed && (tte->bound() & BOUND_LOWER) @@ -778,56 +731,53 @@ moves_loop: // When in check and at SpNode search starts from here continue; // At root obey the "searchmoves" option and skip moves not listed in Root - // Move List, as a consequence any illegal move is also skipped. In MultiPV + // Move List. As a consequence any illegal move is also skipped. In MultiPV // mode we also skip PV moves which have been already searched. if (RootNode && !std::count(RootMoves.begin() + PVIdx, RootMoves.end(), move)) continue; if (SpNode) { - // Shared counter cannot be decremented later if move turns out to be illegal - if (!pos.pl_move_is_legal(move, ci.pinned)) + // Shared counter cannot be decremented later if the move turns out to be illegal + if (!pos.legal(move, ci.pinned)) continue; moveCount = ++splitPoint->moveCount; splitPoint->mutex.unlock(); } else - moveCount++; + ++moveCount; if (RootNode) { Signals.firstRootMove = (moveCount == 1); - if (thisThread == Threads.main_thread() && Time::now() - SearchTime > 3000) + if (thisThread == Threads.main() && Time::now() - SearchTime > 3000) sync_cout << "info depth " << depth / ONE_PLY << " currmove " << move_to_uci(move, pos.is_chess960()) << " currmovenumber " << moveCount + PVIdx << sync_endl; } ext = DEPTH_ZERO; - captureOrPromotion = pos.is_capture_or_promotion(move); - givesCheck = pos.move_gives_check(move, ci); + captureOrPromotion = pos.capture_or_promotion(move); + givesCheck = FAST_GIVES_CHECK(pos, move, ci); dangerous = givesCheck - || pos.is_passed_pawn_push(move) - || type_of(move) == CASTLE; + || type_of(move) != NORMAL + || pos.advanced_pawn_push(move); - // Step 12. Extend checks and, in PV nodes, also dangerous moves - if (PvNode && dangerous) + // Step 12. Extend checks + if (givesCheck && pos.see_sign(move) >= 0) ext = ONE_PLY; - else if (givesCheck && pos.see_sign(move) >= 0) - ext = ONE_PLY / 2; - // Singular extension search. If all moves but one fail low on a search of // (alpha-s, beta-s), and just one fails high on (alpha, beta), then that move // is singular and should be extended. To verify this we do a reduced search - // on all the other moves but the ttMove, if result is lower than ttValue minus - // a margin then we extend ttMove. + // on all the other moves but the ttMove and if the result is lower than + // ttValue minus a margin then we extend the ttMove. if ( singularExtensionNode && move == ttMove && !ext - && pos.pl_move_is_legal(move, ci.pinned) + && pos.legal(move, ci.pinned) && abs(ttValue) < VALUE_KNOWN_WIN) { assert(ttValue != VALUE_NONE); @@ -843,10 +793,10 @@ moves_loop: // When in check and at SpNode search starts from here ext = ONE_PLY; } - // Update current move (this must be done after singular extension search) + // Update the 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 @@ -856,8 +806,7 @@ moves_loop: // When in check and at SpNode search starts from here { // Move count based pruning if ( depth < 16 * ONE_PLY - && moveCount >= FutilityMoveCounts[depth] - && (!threatMove || !refutes(pos, move, threatMove))) + && moveCount >= FutilityMoveCounts[improving][depth] ) { if (SpNode) splitPoint->mutex.lock(); @@ -865,45 +814,40 @@ 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(depth, moveCount); - futilityValue = ss->staticEval + ss->evalMargin + futility_margin(predictedDepth, moveCount) - + Gains[pos.piece_moved(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.pl_move_is_legal(move, ci.pinned)) + // Check for legality just before making the move + if (!RootNode && !SpNode && !pos.legal(move, ci.pinned)) { moveCount--; continue; @@ -917,23 +861,25 @@ moves_loop: // When in check and at SpNode search starts from here // Step 14. Make the move pos.do_move(move, st, ci, givesCheck); - // Step 15. Reduced depth search (LMR). If the move fails high will be + // Step 15. Reduced depth search (LMR). If the move fails high it will be // re-searched at full depth. - if ( depth > 3 * ONE_PLY + if ( depth >= 3 * ONE_PLY && !pvMove && !captureOrPromotion - && !dangerous && move != ttMove && move != ss->killers[0] && move != ss->killers[1]) { - ss->reduction = reduction(depth, moveCount); + ss->reduction = reduction(improving, depth, moveCount); if (!PvNode && cutNode) ss->reduction += ONE_PLY; + else if (History[pos.piece_on(to_sq(move))][to_sq(move)] < 0) + ss->reduction += ONE_PLY / 2; + if (move == countermoves[0] || move == countermoves[1]) - ss->reduction = std::max(DEPTH_ZERO, ss->reduction-ONE_PLY); + ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY); Depth d = std::max(newDepth - ss->reduction, ONE_PLY); if (SpNode) @@ -941,6 +887,13 @@ moves_loop: // When in check and at SpNode search starts from here value = -search(pos, ss+1, -(alpha+1), -alpha, d, true); + // Research at intermediate depth if reduction is very high + if (value > alpha && ss->reduction >= 4 * ONE_PLY) + { + Depth d2 = std::max(newDepth - 2 * ONE_PLY, ONE_PLY); + value = -search(pos, ss+1, -(alpha+1), -alpha, d2, true); + } + doFullDepthSearch = (value > alpha && ss->reduction != DEPTH_ZERO); ss->reduction = DEPTH_ZERO; } @@ -959,9 +912,9 @@ moves_loop: // When in check and at SpNode search starts from here : - search(pos, ss+1, -(alpha+1), -alpha, newDepth, !cutNode); } - // 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. + // For PV nodes only, 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 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) @@ -1001,12 +954,12 @@ moves_loop: // When in check and at SpNode search starts from here // iteration. This information is used for time management: When // the best move changes frequently, we allocate some more time. if (!pvMove) - BestMoveChanges++; + ++BestMoveChanges; } else - // All other moves but the PV are set to the lowest value, this - // is not a problem when sorting becuase sort is stable and move - // position in the list is preserved, just the PV is pushed up. + // All other moves but the PV are set to the lowest value: this is + // not a problem when sorting because the sort is stable and the + // move position in the list is preserved - just the PV is pushed up. rm.score = -VALUE_INFINITE; } @@ -1041,7 +994,7 @@ moves_loop: // When in check and at SpNode search starts from here assert(bestValue < beta); thisThread->split(pos, ss, alpha, beta, &bestValue, &bestMove, - depth, threatMove, moveCount, &mp, NT, cutNode); + depth, moveCount, &mp, NT, cutNode); if (bestValue >= beta) break; } @@ -1056,7 +1009,7 @@ moves_loop: // When in check and at SpNode search starts from here // case of Signals.stop or thread.cutoff_occurred() are set, but this is // harmless because return value is discarded anyhow in the parent nodes. // If we are in a singular extension search then return a fail low score. - // A split node has at least one move, the one tried before to be splitted. + // A split node has at least one move - the one tried before to be splitted. if (!moveCount) return excludedMove ? alpha : inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()]; @@ -1068,32 +1021,11 @@ 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 - && !pos.is_capture_or_promotion(bestMove) - && !inCheck) - { - if (ss->killers[0] != bestMove) - { - ss->killers[1] = ss->killers[0]; - ss->killers[0] = bestMove; - } - - // Increase history value of the cut-off move and decrease all the other - // played non-capture moves. - Value bonus = Value(int(depth) * int(depth)); - History.update(pos.piece_moved(bestMove), to_sq(bestMove), bonus); - for (int i = 0; i < quietCount - 1; i++) - { - Move m = quietsSearched[i]; - History.update(pos.piece_moved(m), to_sq(m), -bonus); - } - - if (is_ok((ss-1)->currentMove)) - Countermoves.update(pos.piece_on(prevMoveSq), prevMoveSq, bestMove); - } + // Quiet best move: update killers, history, countermoves and followupmoves + if (bestValue >= beta && !pos.capture_or_promotion(bestMove) && !inCheck) + update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount - 1); assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); @@ -1121,7 +1053,7 @@ moves_loop: // When in check and at SpNode search starts from here Key posKey; Move ttMove, move, bestMove; Value bestValue, value, ttValue, futilityValue, futilityBase, oldAlpha; - bool givesCheck, enoughMaterial, evasionPrunable; + bool givesCheck, evasionPrunable; Depth ttDepth; // To flag BOUND_EXACT a node with eval above alpha and no available moves @@ -1131,11 +1063,11 @@ moves_loop: // When in check and at SpNode search starts from here ss->currentMove = bestMove = MOVE_NONE; ss->ply = (ss-1)->ply + 1; - // Check for an instant draw or maximum ply reached + // Check for an instant draw or if the maximum ply has been reached if (pos.is_draw() || ss->ply > MAX_PLY) return DrawValue[pos.side_to_move()]; - // Decide whether or not to include checks, this fixes also the type of + // Decide whether or not to include checks: this fixes also the type of // TT entry depth that we are going to use. Note that in qsearch we use // only two types of depth in TT: DEPTH_QS_CHECKS or DEPTH_QS_NO_CHECKS. ttDepth = InCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS @@ -1161,28 +1093,31 @@ 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; - enoughMaterial = false; } else { 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) + if (tte->bound() & (ttValue > bestValue ? BOUND_LOWER : BOUND_UPPER)) + 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; } @@ -1190,8 +1125,7 @@ moves_loop: // When in check and at SpNode search starts from here if (PvNode && bestValue > alpha) alpha = bestValue; - futilityBase = ss->staticEval + ss->evalMargin + Value(128); - enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMg; + futilityBase = bestValue + Value(128); } // Initialize a MovePicker object for the current position, and prepare @@ -1206,20 +1140,19 @@ moves_loop: // When in check and at SpNode search starts from here { assert(is_ok(move)); - givesCheck = pos.move_gives_check(move, ci); + givesCheck = FAST_GIVES_CHECK(pos, move, ci); // Futility pruning if ( !PvNode && !InCheck && !givesCheck && move != ttMove - && enoughMaterial - && type_of(move) != PROMOTION - && !pos.is_passed_pawn_push(move)) + && futilityBase > -VALUE_KNOWN_WIN + && !pos.advanced_pawn_push(move)) { - futilityValue = futilityBase - + PieceValue[EG][pos.piece_on(to_sq(move))] - + (type_of(move) == ENPASSANT ? PawnValueEg : VALUE_ZERO); + assert(type_of(move) != ENPASSANT); // Due to !pos.advanced_pawn_push + + futilityValue = futilityBase + PieceValue[EG][pos.piece_on(to_sq(move))]; if (futilityValue < beta) { @@ -1227,21 +1160,17 @@ moves_loop: // When in check and at SpNode search starts from here continue; } - // Prune moves with negative or equal SEE and also moves with positive - // SEE where capturing piece loses a tempo and SEE < beta - futilityBase. - if ( futilityBase < beta - && pos.see(move, beta - futilityBase) <= 0) + if (futilityBase < beta && pos.see(move) <= 0) { bestValue = std::max(bestValue, futilityBase); continue; } } - // Detect non-capture evasions that are candidate to be pruned - evasionPrunable = !PvNode - && InCheck + // Detect non-capture evasions that are candidates to be pruned + evasionPrunable = InCheck && bestValue > VALUE_MATED_IN_MAX_PLY - && !pos.is_capture(move) + && !pos.capture(move) && !pos.can_castle(pos.side_to_move()); // Don't search moves with negative SEE values @@ -1252,18 +1181,8 @@ moves_loop: // When in check and at SpNode search starts from here && pos.see_sign(move) < 0) continue; - // Don't search useless checks - if ( !PvNode - && !InCheck - && givesCheck - && move != ttMove - && !pos.is_capture_or_promotion(move) - && ss->staticEval + PawnValueMg / 4 < beta - && !check_is_dangerous(pos, move, futilityBase, beta)) - continue; - - // Check for legality only before to do the move - if (!pos.pl_move_is_legal(move, ci.pinned)) + // Check for legality just before making the move + if (!pos.legal(move, ci.pinned)) continue; ss->currentMove = move; @@ -1291,7 +1210,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; } @@ -1306,7 +1225,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); @@ -1316,7 +1235,7 @@ moves_loop: // When in check and at SpNode search starts from here // value_to_tt() adjusts a mate score from "plies to mate from the root" to // "plies to mate from the current position". Non-mate scores are unchanged. - // The function is called before storing a value to the transposition table. + // The function is called before storing a value in the transposition table. Value value_to_tt(Value v, int ply) { @@ -1328,7 +1247,7 @@ moves_loop: // When in check and at SpNode search starts from here // value_from_tt() is the inverse of value_to_tt(): It adjusts a mate score - // from the transposition table (where refers to the plies to mate/be mated + // from the transposition table (which refers to the plies to mate/be mated // from current position) to "plies to mate/be mated from the root". Value value_from_tt(Value v, int ply) { @@ -1339,141 +1258,50 @@ moves_loop: // When in check and at SpNode search starts from here } - // check_is_dangerous() tests if a checking move can be pruned in qsearch() + // update_stats() updates killers, history, countermoves and followupmoves stats after a fail-high + // of a quiet move. - bool check_is_dangerous(const Position& pos, Move move, Value futilityBase, Value beta) - { - Piece pc = pos.piece_moved(move); - Square from = from_sq(move); - Square to = to_sq(move); - Color them = ~pos.side_to_move(); - Square ksq = pos.king_square(them); - Bitboard enemies = pos.pieces(them); - Bitboard kingAtt = pos.attacks_from(ksq); - Bitboard occ = pos.pieces() ^ from ^ ksq; - Bitboard oldAtt = pos.attacks_from(pc, from, occ); - Bitboard newAtt = pos.attacks_from(pc, to, occ); - - // Checks which give opponent's king at most one escape square are dangerous - if (!more_than_one(kingAtt & ~(enemies | newAtt | to))) - return true; - - // Queen contact check is very dangerous - if (type_of(pc) == QUEEN && (kingAtt & to)) - return true; - - // Creating new double threats with checks is dangerous - Bitboard b = (enemies ^ ksq) & newAtt & ~oldAtt; - while (b) + void update_stats(Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt) { + + if (ss->killers[0] != move) { - // Note that here we generate illegal "double move"! - if (futilityBase + PieceValue[EG][pos.piece_on(pop_lsb(&b))] >= beta) - return true; + ss->killers[1] = ss->killers[0]; + ss->killers[0] = move; } - return false; - } - - - // allows() tests whether the 'first' move at previous ply somehow makes the - // 'second' move possible, for instance if the moving piece is the same in - // both moves. Normally the second move is the threat (the best move returned - // from a null search that fails low). - - bool allows(const Position& pos, Move first, Move second) { - - assert(is_ok(first)); - assert(is_ok(second)); - assert(color_of(pos.piece_on(from_sq(second))) == ~pos.side_to_move()); - assert(color_of(pos.piece_on(to_sq(first))) == ~pos.side_to_move()); - - Square m1from = from_sq(first); - Square m2from = from_sq(second); - Square m1to = to_sq(first); - Square m2to = to_sq(second); - - // The piece is the same or second's destination was vacated by the first move - if (m1to == m2from || m2to == m1from) - return true; - - // Second one moves through the square vacated by first one - if (between_bb(m2from, m2to) & m1from) - 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); - if (m1att & m2to) - return true; - - // Second move gives a discovered check through the first's checking piece - if (m1att & pos.king_square(pos.side_to_move())) + // Increase history value of the cut-off move and decrease all the other + // played quiet moves. + Value bonus = Value(int(depth) * int(depth)); + History.update(pos.moved_piece(move), to_sq(move), bonus); + for (int i = 0; i < quietsCnt; ++i) { - assert(between_bb(m1to, pos.king_square(pos.side_to_move())) & m2from); - return true; + Move m = quiets[i]; + History.update(pos.moved_piece(m), to_sq(m), -bonus); } - return false; - } - - - // refutes() tests whether a 'first' move is able to defend against a 'second' - // opponent's move. In this case will not be pruned. Normally the second move - // is the threat (the best move returned from a null search that fails low). - - bool refutes(const Position& pos, Move first, Move second) { - - assert(is_ok(first)); - assert(is_ok(second)); - - Square m1from = from_sq(first); - Square m2from = from_sq(second); - Square m1to = to_sq(first); - Square m2to = to_sq(second); - - // Don't prune moves of the threatened piece - if (m1from == m2to) - return true; - - // If the threatened piece has value less than or equal to the value of the - // threat piece, don't prune moves which defend it. - if ( pos.is_capture(second) - && ( PieceValue[MG][pos.piece_on(m2from)] >= PieceValue[MG][pos.piece_on(m2to)] - || type_of(pos.piece_on(m2from)) == KING)) + if (is_ok((ss-1)->currentMove)) { - // Update occupancy as if the piece and the threat are moving - Bitboard occ = pos.pieces() ^ m1from ^ m1to ^ m2from; - Piece pc = pos.piece_on(m1from); - - // The moved piece attacks the square 'tto' ? - if (pos.attacks_from(pc, m1to, occ) & m2to) - return true; - - // Scan for possible X-ray attackers behind the moved piece - Bitboard xray = (attacks_bb< ROOK>(m2to, occ) & pos.pieces(color_of(pc), QUEEN, ROOK)) - | (attacks_bb(m2to, occ) & pos.pieces(color_of(pc), QUEEN, BISHOP)); - - // Verify attackers are triggered by our move and not already existing - if (xray && (xray ^ (xray & pos.attacks_from(m2to)))) - return true; + Square prevMoveSq = to_sq((ss-1)->currentMove); + Countermoves.update(pos.piece_on(prevMoveSq), prevMoveSq, move); } - // Don't prune safe moves which block the threat path - if ((between_bb(m2from, m2to) & m1to) && pos.see_sign(first) >= 0) - return true; - - return false; + if (is_ok((ss-2)->currentMove) && (ss-1)->currentMove == (ss-1)->ttMove) + { + Square prevOwnMoveSq = to_sq((ss-2)->currentMove); + Followupmoves.update(pos.piece_on(prevOwnMoveSq), prevOwnMoveSq, move); + } } - // When playing with strength handicap choose best move among the MultiPV set - // using a statistical rule dependent on 'level'. Idea by Heinz van Saanen. + // When playing with a strength handicap, choose best move among the MultiPV + // set using a statistical rule dependent on 'level'. Idea by Heinz van Saanen. Move Skill::pick_move() { static RKISS rk; // PRNG sequence should be not deterministic - for (int i = Time::now() % 50; i > 0; i--) + for (int i = Time::now() % 50; i > 0; --i) rk.rand(); // RootMoves are already sorted by score in descending order @@ -1483,9 +1311,9 @@ moves_loop: // When in check and at SpNode search starts from here best = MOVE_NONE; // Choose best move. For each move score we add two terms both dependent on - // weakness, one deterministic and bigger for weaker moves, and one random, + // weakness. One deterministic and bigger for weaker moves, and one random, // then we choose the move with the resulting highest score. - for (size_t i = 0; i < PVSize; i++) + for (size_t i = 0; i < PVSize; ++i) { int s = RootMoves[i].score; @@ -1507,9 +1335,9 @@ moves_loop: // When in check and at SpNode search starts from here } - // uci_pv() formats PV information according to UCI protocol. UCI requires - // to send all the PV lines also if are still to be searched and so refer to - // the previous search score. + // uci_pv() formats PV information according to the UCI protocol. UCI + // requires that all (if any) unsearched PV lines are sent using a previous + // search score. string uci_pv(const Position& pos, int depth, Value alpha, Value beta) { @@ -1518,11 +1346,11 @@ moves_loop: // When in check and at SpNode search starts from here size_t uciPVSize = std::min((size_t)Options["MultiPV"], RootMoves.size()); int selDepth = 0; - for (size_t i = 0; i < Threads.size(); i++) + for (size_t i = 0; i < Threads.size(); ++i) if (Threads[i]->maxPly > selDepth) selDepth = Threads[i]->maxPly; - for (size_t i = 0; i < uciPVSize; i++) + for (size_t i = 0; i < uciPVSize; ++i) { bool updated = (i <= PVIdx); @@ -1544,7 +1372,7 @@ moves_loop: // When in check and at SpNode search starts from here << " multipv " << i + 1 << " pv"; - for (size_t j = 0; RootMoves[i].pv[j] != MOVE_NONE; j++) + for (size_t j = 0; RootMoves[i].pv[j] != MOVE_NONE; ++j) s << " " << move_to_uci(RootMoves[i].pv[j], pos.is_chess960()); } @@ -1555,13 +1383,13 @@ moves_loop: // When in check and at SpNode search starts from here /// RootMove::extract_pv_from_tt() builds a PV by adding moves from the TT table. -/// We consider also failing high nodes and not only BOUND_EXACT nodes so to -/// allow to always have a ponder move even when we fail high at root, and a -/// long PV to print that is important for position analysis. +/// We also consider both failing high nodes and BOUND_EXACT nodes here to +/// ensure that we have a ponder move even when we fail high at root. This +/// results in a long PV to print that is important for position analysis. void RootMove::extract_pv_from_tt(Position& pos) { - StateInfo state[MAX_PLY_PLUS_2], *st = state; + StateInfo state[MAX_PLY_PLUS_6], *st = state; const TTEntry* tte; int ply = 0; Move m = pv[0]; @@ -1577,8 +1405,8 @@ void RootMove::extract_pv_from_tt(Position& pos) { tte = TT.probe(pos.key()); } while ( tte - && pos.is_pseudo_legal(m = tte->move()) // Local copy, TT could change - && pos.pl_move_is_legal(m, pos.pinned_pieces()) + && pos.pseudo_legal(m = tte->move()) // Local copy, TT could change + && pos.legal(m, pos.pinned_pieces(pos.side_to_move())) && ply < MAX_PLY && (!pos.is_draw() || ply < 2)); @@ -1594,7 +1422,7 @@ void RootMove::extract_pv_from_tt(Position& pos) { void RootMove::insert_pv_in_tt(Position& pos) { - StateInfo state[MAX_PLY_PLUS_2], *st = state; + StateInfo state[MAX_PLY_PLUS_6], *st = state; const TTEntry* tte; int ply = 0; @@ -1602,7 +1430,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])); @@ -1619,7 +1447,7 @@ void RootMove::insert_pv_in_tt(Position& pos) { void Thread::idle_loop() { // Pointer 'this_sp' is not null only if we are called from split(), and not - // at the thread creation. So it means we are the split point's master. + // at the thread creation. This means we are the split point's master. SplitPoint* this_sp = splitPointsSize ? activeSplitPoint : NULL; assert(!this_sp || (this_sp->masterThread == this && searching)); @@ -1646,7 +1474,7 @@ void Thread::idle_loop() { break; } - // Do sleep after retesting sleep conditions under lock protection, in + // Do sleep after retesting sleep conditions under lock protection. In // particular we need to avoid a deadlock in case a master thread has, // in the meanwhile, allocated us and sent the notify_one() call before // we had the chance to grab the lock. @@ -1664,14 +1492,15 @@ void Thread::idle_loop() { Threads.mutex.lock(); assert(searching); + assert(activeSplitPoint); SplitPoint* sp = activeSplitPoint; Threads.mutex.unlock(); - Stack stack[MAX_PLY_PLUS_2], *ss = stack+1; // To allow referencing (ss-1) + Stack stack[MAX_PLY_PLUS_6], *ss = stack+2; // To allow referencing (ss-2) Position pos(*sp->pos, this); - memcpy(ss-1, sp->ss-1, 4 * sizeof(Stack)); + std::memcpy(ss-2, sp->ss-2, 5 * sizeof(Stack)); ss->splitPoint = sp; sp->mutex.lock(); @@ -1701,8 +1530,8 @@ void Thread::idle_loop() { sp->slavesMask &= ~(1ULL << idx); sp->nodes += pos.nodes_searched(); - // Wake up master thread so to allow it to return from the idle loop - // in case we are the last slave of the split point. + // Wake up the master thread so to allow it to return from the idle + // loop in case we are the last slave of the split point. if ( Threads.sleepWhileIdle && this != sp->masterThread && !sp->slavesMask) @@ -1711,10 +1540,10 @@ void Thread::idle_loop() { sp->masterThread->notify_one(); } - // After releasing the lock we cannot access anymore any SplitPoint - // related data in a safe way becuase it could have been released under - // our feet by the sp master. Also accessing other Thread objects is - // unsafe because if we are exiting there is a chance are already freed. + // After releasing the lock we can't access any SplitPoint related data + // in a safe way because it could have been released under our feet by + // the sp master. Also accessing other Thread objects is unsafe because + // if we are exiting there is a chance that they are already freed. sp->mutex.unlock(); } @@ -1733,8 +1562,8 @@ void Thread::idle_loop() { /// check_time() is called by the timer thread when the timer triggers. It is -/// used to print debug info and, more important, to detect when we are out of -/// available time and so stop the search. +/// used to print debug info and, more importantly, to detect when we are out of +/// available time and thus stop the search. void check_time() { @@ -1758,8 +1587,8 @@ void check_time() { // Loop across all split points and sum accumulated SplitPoint nodes plus // all the currently active positions nodes. - for (size_t i = 0; i < Threads.size(); i++) - for (int j = 0; j < Threads[i]->splitPointsSize; j++) + for (size_t i = 0; i < Threads.size(); ++i) + for (int j = 0; j < Threads[i]->splitPointsSize; ++j) { SplitPoint& sp = Threads[i]->splitPoints[j]; @@ -1783,9 +1612,11 @@ void check_time() { Time::point elapsed = Time::now() - SearchTime; bool stillAtFirstMove = Signals.firstRootMove && !Signals.failedLowAtRoot - && elapsed > TimeMgr.available_time(); + && ( elapsed > TimeMgr.available_time() + || ( elapsed > (TimeMgr.available_time() * 62) / 100 + && elapsed > IterationTime * 1.4)); - bool noMoreTime = elapsed > TimeMgr.maximum_time() - 2 * TimerResolution + bool noMoreTime = elapsed > TimeMgr.maximum_time() - 2 * TimerThread::Resolution || stillAtFirstMove; if ( (Limits.use_time_management() && noMoreTime)