X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=b8b325e57202f885ee24ee727f35fb11d59d1898;hp=39e4be3d8ae0bb1f8958b8647704a4deb0875858;hb=f026517e5ee4db8dca5eb2bfd9ce7078a9d39725;hpb=917944e9c5324cc9659e630570e1852270b22bd4 diff --git a/src/search.cpp b/src/search.cpp index 39e4be3d..b8b325e5 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -263,11 +263,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; @@ -322,8 +322,8 @@ namespace { // Age out PV variability metric BestMoveChanges *= 0.8; - // Save last iteration's scores before first PV line is searched and all - // the move scores but the (new) PV are set to -VALUE_INFINITE. + // 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; @@ -338,16 +338,17 @@ 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 + // 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 but 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()); @@ -358,19 +359,19 @@ namespace { RootMoves[i].insert_pv_in_tt(pos); // If search has been stopped break immediately. Sorting and - // writing PV back to TT is safe becuase RootMoves is still - // valid, although refers to previous iteration. + // writing PV back to TT is safe because RootMoves is still + // valid, although it refers to previous iteration. if (Signals.stop) break; // When failing high/low give some update (without cluttering - // the UI) before to research. + // 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); @@ -396,7 +397,7 @@ namespace { sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl; } - // Do we need to pick now the sub-optimal best move ? + // 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(); @@ -411,7 +412,7 @@ 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) @@ -422,17 +423,17 @@ namespace { { bool stop = false; // Local variable, not the volatile Signals.stop - // Take in account some extra time if the best move has changed + // Take some extra time if the best move has changed if (depth > 4 && depth < 50 && PVSize == 1) TimeMgr.pv_instability(BestMoveChanges); - // Stop search if most of available time is already consumed. We + // Stop the search if 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 (Time::now() - SearchTime > (TimeMgr.available_time() * 62) / 100) stop = true; - // Stop search early if one move seems to be much better than others + // Stop the search early if one move seems to be much better than others if ( depth >= 12 && BestMoveChanges <= DBL_EPSILON && !stop @@ -455,7 +456,7 @@ namespace { 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 @@ -469,9 +470,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) { @@ -484,6 +485,7 @@ namespace { assert(PvNode || (alpha == beta - 1)); assert(depth > DEPTH_ZERO); + Move quietsSearched[64]; StateInfo st; const TTEntry *tte; SplitPoint* splitPoint; @@ -493,7 +495,7 @@ namespace { Value bestValue, value, ttValue, eval, nullValue, futilityValue; bool inCheck, givesCheck, pvMove, singularExtensionNode, improving; bool captureOrPromotion, dangerous, doFullDepthSearch; - int moveCount; + int moveCount, quietCount; // Step 1. Initialize node Thread* thisThread = pos.this_thread(); @@ -514,7 +516,7 @@ namespace { goto moves_loop; } - moveCount = 0; + moveCount = quietCount = 0; bestValue = -VALUE_INFINITE; ss->currentMove = threatMove = (ss+1)->excludedMove = bestMove = MOVE_NONE; ss->ply = (ss-1)->ply + 1; @@ -534,9 +536,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) @@ -552,8 +554,8 @@ namespace { 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 @@ -624,7 +626,7 @@ namespace { Value v = qsearch(pos, ss, rbeta-1, rbeta, DEPTH_ZERO); if (v < rbeta) // Logically we should return (v + razor_margin(depth)), but - // surprisingly this did slightly weaker in tests. + // surprisingly this performed slightly weaker in tests. return v; } @@ -781,7 +783,7 @@ moves_loop: // When in check and at SpNode search starts from here if (SpNode) { - // Shared counter cannot be decremented later if move turns out to be illegal + // Shared counter cannot be decremented later if the move turns out to be illegal if (!pos.legal(move, ci.pinned)) continue; @@ -805,8 +807,8 @@ moves_loop: // When in check and at SpNode search starts from here captureOrPromotion = pos.capture_or_promotion(move); givesCheck = pos.gives_check(move, ci); dangerous = givesCheck - || pos.passed_pawn_push(move) - || type_of(move) == CASTLE; + || type_of(move) != NORMAL + || pos.advanced_pawn_push(move); // Step 12. Extend checks if (givesCheck && pos.see_sign(move) >= 0) @@ -815,8 +817,8 @@ moves_loop: // When in check and at SpNode search starts from here // 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 @@ -836,7 +838,7 @@ 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. Pruning at shallow depth (exclude PV nodes) @@ -888,10 +890,9 @@ moves_loop: // When in check and at SpNode search starts from here continue; } - } - // Check for legality only before to do the move + // Check for legality just before making the move if (!RootNode && !SpNode && !pos.legal(move, ci.pinned)) { moveCount--; @@ -900,6 +901,8 @@ moves_loop: // When in check and at SpNode search starts from here pvMove = PvNode && moveCount == 1; ss->currentMove = move; + if (!SpNode && !captureOrPromotion && quietCount < 64) + quietsSearched[quietCount++] = move; // Step 14. Make the move pos.do_move(move, st, ci, givesCheck); @@ -948,9 +951,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) @@ -993,9 +996,9 @@ moves_loop: // When in check and at SpNode search starts from here ++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; } @@ -1045,7 +1048,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()]; @@ -1074,9 +1077,11 @@ moves_loop: // When in check and at SpNode search starts from here // played non-capture moves. Value bonus = Value(int(depth) * int(depth)); History.update(pos.moved_piece(bestMove), to_sq(bestMove), bonus); - - for (const ExtMove* em = mp.quiet_moves(); em && em->move != bestMove; ++em) - History.update(pos.moved_piece(em->move), to_sq(em->move), -bonus); + for (int i = 0; i < quietCount - 1; ++i) + { + Move m = quietsSearched[i]; + History.update(pos.moved_piece(m), to_sq(m), -bonus); + } if (is_ok((ss-1)->currentMove)) Countermoves.update(pos.piece_on(prevMoveSq), prevMoveSq, bestMove); @@ -1118,11 +1123,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 @@ -1202,13 +1207,12 @@ moves_loop: // When in check and at SpNode search starts from here && !InCheck && !givesCheck && move != ttMove - && type_of(move) != PROMOTION && futilityBase > -VALUE_KNOWN_WIN - && !pos.passed_pawn_push(move)) + && !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) { @@ -1226,7 +1230,7 @@ moves_loop: // When in check and at SpNode search starts from here } } - // Detect non-capture evasions that are candidate to be pruned + // Detect non-capture evasions that are candidates to be pruned evasionPrunable = InCheck && bestValue > VALUE_MATED_IN_MAX_PLY && !pos.capture(move) @@ -1240,7 +1244,7 @@ moves_loop: // When in check and at SpNode search starts from here && pos.see_sign(move) < 0) continue; - // Check for legality only before to do the move + // Check for legality just before making the move if (!pos.legal(move, ci.pinned)) continue; @@ -1294,7 +1298,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) { @@ -1306,7 +1310,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) { @@ -1318,23 +1322,23 @@ moves_loop: // When in check and at SpNode search starts from here // 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). + // 'second' move possible e.g. 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(type_of(first) == CASTLE || color_of(pos.piece_on(to_sq(first))) == ~pos.side_to_move()); + assert(type_of(first) == CASTLING || color_of(pos.piece_on(to_sq(first))) == ~pos.side_to_move()); Square m1from = from_sq(first); Square m2from = from_sq(second); 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 + // The piece is the same or second's destination was vacated by the first move. // We exclude the trivial case where a sliding piece does in two moves what // it could do in one move: eg. Ra1a2, Ra2a3. if ( m2to == m1from @@ -1346,7 +1350,7 @@ moves_loop: // When in check and at SpNode search starts from here return true; // Second's destination is defended by the first move's piece - Bitboard m1att = pos.attacks_from(pos.piece_on(m1to), m1to, pos.pieces() ^ m2from); + Bitboard m1att = attacks_bb(pos.piece_on(m1to), m1to, pos.pieces() ^ m2from); if (m1att & m2to) return true; @@ -1379,8 +1383,8 @@ moves_loop: // When in check and at SpNode search starts from here 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 the threatened piece has a value less than or equal to the value of + // the threat piece, don't prune moves which defend it. if ( pos.capture(second) && ( PieceValue[MG][pos.piece_on(m2from)] >= PieceValue[MG][pos.piece_on(m2to)] || type_of(pos.piece_on(m2from)) == KING)) @@ -1389,15 +1393,15 @@ moves_loop: // When in check and at SpNode search starts from here 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) + // Does the moved piece attack the square 'm2to' ? + if (attacks_bb(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 + // Verify attackers are triggered by our move and not already exist if (unlikely(xray) && (xray & ~pos.attacks_from(m2to))) return true; } @@ -1410,8 +1414,8 @@ moves_loop: // When in check and at SpNode search starts from here } - // 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() { @@ -1428,7 +1432,7 @@ 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) { @@ -1452,9 +1456,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) { @@ -1500,9 +1504,9 @@ 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) { @@ -1564,7 +1568,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)); @@ -1591,7 +1595,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. @@ -1647,8 +1651,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) @@ -1657,10 +1661,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(); } @@ -1679,8 +1683,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() {