X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fsearch.cpp;h=b75b6fa850f7d359d269faeac62b58258c55b3c2;hb=58c6e64069cc2d278756fb2e73f54ca5346ec35d;hp=9b1921f207a30a799bfcaefd569dcdb613dd8115;hpb=d55a5a4d81b613e5a82e428770347b06fbd2d9a8;p=stockfish diff --git a/src/search.cpp b/src/search.cpp index 9b1921f2..b75b6fa8 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -28,6 +28,7 @@ #include #include #include +#include #include "book.h" #include "evaluate.h" @@ -84,7 +85,7 @@ namespace { void read_uci_options(); bool available_thread_exists(int master) const; bool thread_is_available(int slave, int master) const; - bool thread_should_stop(int threadID) const; + bool cutoff_at_splitpoint(int threadID) const; void wake_sleeping_thread(int threadID); void idle_loop(int threadID, SplitPoint* sp); @@ -104,55 +105,73 @@ namespace { }; - // RootMove struct is used for moves at the root at the tree. For each - // root move, we store a score, a node count, and a PV (really a refutation - // in the case of moves which fail low). + // RootMove struct is used for moves at the root at the tree. For each root + // move, we store two scores, a node count, and a PV (really a refutation + // in the case of moves which fail low). Value pv_score is normally set at + // -VALUE_INFINITE for all non-pv moves, while non_pv_score is computed + // according to the order in which moves are returned by MovePicker. struct RootMove { - RootMove() : mp_score(0), nodes(0) {} + RootMove(); + RootMove(const RootMove& rm) { *this = rm; } + RootMove& operator=(const RootMove& rm); // RootMove::operator<() is the comparison function used when // sorting the moves. A move m1 is considered to be better - // than a move m2 if it has a higher score, or if the moves - // have equal score but m1 has the higher beta cut-off count. + // than a move m2 if it has an higher pv_score, or if it has + // equal pv_score but m1 has the higher non_pv_score. In this + // way we are guaranteed that PV moves are always sorted as first. bool operator<(const RootMove& m) const { - - return score != m.score ? score < m.score : mp_score <= m.mp_score; + return pv_score != m.pv_score ? pv_score < m.pv_score + : non_pv_score <= m.non_pv_score; } + void set_pv(const Move newPv[]); - Move move; - Value score; - int mp_score; int64_t nodes; + Value pv_score; + Value non_pv_score; + Move move; Move pv[PLY_MAX_PLUS_2]; }; + RootMove::RootMove() { - // The RootMoveList class is essentially an array of RootMove objects, with - // a handful of methods for accessing the data in the individual moves. + nodes = 0; + pv_score = non_pv_score = -VALUE_INFINITE; + move = pv[0] = MOVE_NONE; + } - class RootMoveList { + RootMove& RootMove::operator=(const RootMove& rm) { - public: - RootMoveList(Position& pos, Move searchMoves[]); + nodes = rm.nodes; + pv_score = rm.pv_score; + non_pv_score = rm.non_pv_score; + move = rm.move; + set_pv(rm.pv); // Skip costly full pv[] copy + return *this; + } - Move move(int moveNum) const { return moves[moveNum].move; } - Move move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; } - int move_count() const { return count; } - Value move_score(int moveNum) const { return moves[moveNum].score; } - int64_t move_nodes(int moveNum) const { return moves[moveNum].nodes; } - void add_move_nodes(int moveNum, int64_t nodes) { moves[moveNum].nodes += nodes; } - void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; } + void RootMove::set_pv(const Move newPv[]) { - void set_move_pv(int moveNum, const Move pv[]); - void score_moves(const Position& pos); - void sort(); - void sort_multipv(int n); + Move* p = pv; - private: - RootMove moves[MOVES_MAX]; - int count; + do *p++ = *newPv; while (*newPv++ != MOVE_NONE); + } + + + // RootMoveList struct is essentially a std::vector<> of RootMove objects, + // with an handful of methods above the standard ones. + + struct RootMoveList : public std::vector { + + typedef std::vector Base; + + RootMoveList(Position& pos, Move searchMoves[]); + void set_non_pv_scores(const Position& pos); + + void sort() { insertion_sort(begin(), end()); } + void sort_multipv(int n) { insertion_sort(begin(), begin() + n); } }; @@ -527,7 +546,7 @@ namespace { RootMoveList rml(pos, searchMoves); // Handle special case of searching on a mate/stale position - if (rml.move_count() == 0) + if (rml.size() == 0) { if (PonderSearch) wait_for_stop_or_ponderhit(); @@ -540,24 +559,24 @@ namespace { cout << set960(pos.is_chess960()) // Is enough to set once at the beginning << "info depth " << 1 << "\ninfo depth " << 1 - << " score " << value_to_uci(rml.move_score(0)) + << " score " << value_to_uci(rml[0].pv_score) << " time " << current_search_time() << " nodes " << pos.nodes_searched() << " nps " << nps(pos) - << " pv " << rml.move(0) << "\n"; + << " pv " << rml[0].move << "\n"; // Initialize TT.new_search(); H.clear(); init_ss_array(ss, PLY_MAX_PLUS_2); pv[0] = pv[1] = MOVE_NONE; - ValueByIteration[1] = rml.move_score(0); + ValueByIteration[1] = rml[0].pv_score; Iteration = 1; // Is one move significantly better than others after initial scoring ? - if ( rml.move_count() == 1 - || rml.move_score(0) > rml.move_score(1) + EasyMoveMargin) - EasyMove = rml.move(0); + if ( rml.size() == 1 + || rml[0].pv_score > rml[1].pv_score + EasyMoveMargin) + EasyMove = rml[0].move; // Iterative deepening loop while (Iteration < PLY_MAX) @@ -605,7 +624,7 @@ namespace { // Stop search early if there is only a single legal move, // we search up to Iteration 6 anyway to get a proper score. - if (Iteration >= 6 && rml.move_count() == 1) + if (Iteration >= 6 && rml.size() == 1) stopSearch = true; // Stop search early when the last two iterations returned a mate score @@ -617,9 +636,9 @@ namespace { // Stop search early if one move seems to be much better than the others if ( Iteration >= 8 && EasyMove == pv[0] - && ( ( rml.move_nodes(0) > (pos.nodes_searched() * 85) / 100 + && ( ( rml[0].nodes > (pos.nodes_searched() * 85) / 100 && current_search_time() > TimeMgr.available_time() / 16) - ||( rml.move_nodes(0) > (pos.nodes_searched() * 98) / 100 + ||( rml[0].nodes > (pos.nodes_searched() * 98) / 100 && current_search_time() > TimeMgr.available_time() / 32))) stopSearch = true; @@ -660,7 +679,7 @@ namespace { // Print the best move and the ponder move to the standard output if (pv[0] == MOVE_NONE || MultiPV > 1) { - pv[0] = rml.move(0); + pv[0] = rml[0].move; pv[1] = MOVE_NONE; } @@ -691,7 +710,7 @@ namespace { << move_to_san(pos, pv[1]) // Works also with MOVE_NONE << endl; } - return rml.move_score(0); + return rml[0].pv_score; } @@ -740,11 +759,11 @@ namespace { while (1) { // Sort the moves before to (re)search - rml.score_moves(pos); + rml.set_non_pv_scores(pos); rml.sort(); // Step 10. Loop through all moves in the root move list - for (int i = 0; i < rml.move_count() && !AbortSearch; i++) + for (int i = 0; i < (int)rml.size() && !AbortSearch; i++) { // This is used by time management FirstRootMove = (i == 0); @@ -754,7 +773,7 @@ namespace { // Pick the next root move, and print the move and the move number to // the standard output. - move = ss->currentMove = rml.move(i); + move = ss->currentMove = rml[i].move; if (current_search_time() >= 1000) cout << "info currmove " << move @@ -772,7 +791,7 @@ namespace { // Step extra. Fail high loop // If move fails high, we research with bigger window until we are not failing // high anymore. - value = - VALUE_INFINITE; + value = -VALUE_INFINITE; while (1) { @@ -811,18 +830,6 @@ namespace { value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1); doFullDepthSearch = (value > alpha); } - - // The move failed high, but if reduction is very big we could - // face a false positive, retry with a less aggressive reduction, - // if the move fails high again then go with full depth search. - if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY) - { - assert(newDepth - ONE_PLY >= ONE_PLY); - - ss->reduction = ONE_PLY; - value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1); - doFullDepthSearch = (value > alpha); - } ss->reduction = DEPTH_ZERO; // Restore original reduction } @@ -848,10 +855,10 @@ namespace { // We are failing high and going to do a research. It's important to update // the score before research in case we run out of time while researching. - rml.set_move_score(i, value); + rml[i].pv_score = value; ss->bestMove = move; extract_pv_from_tt(pos, move, pv); - rml.set_move_pv(i, pv); + rml[i].set_pv(pv); // Print information to the standard output print_pv_info(pos, pv, alpha, beta, value); @@ -871,23 +878,23 @@ namespace { break; // Remember searched nodes counts for this move - rml.add_move_nodes(i, pos.nodes_searched() - nodes); + rml[i].nodes += pos.nodes_searched() - nodes; assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE); assert(value < beta); // Step 17. Check for new best move if (value <= alpha && i >= MultiPV) - rml.set_move_score(i, -VALUE_INFINITE); + rml[i].pv_score = -VALUE_INFINITE; else { // PV move or new best move! // Update PV - rml.set_move_score(i, value); + rml[i].pv_score = value; ss->bestMove = move; extract_pv_from_tt(pos, move, pv); - rml.set_move_pv(i, pv); + rml[i].set_pv(pv); if (MultiPV == 1) { @@ -907,22 +914,22 @@ namespace { else // MultiPV > 1 { rml.sort_multipv(i); - for (int j = 0; j < Min(MultiPV, rml.move_count()); j++) + for (int j = 0; j < Min(MultiPV, (int)rml.size()); j++) { cout << "info multipv " << j + 1 - << " score " << value_to_uci(rml.move_score(j)) + << " score " << value_to_uci(rml[j].pv_score) << " depth " << (j <= i ? Iteration : Iteration - 1) << " time " << current_search_time() << " nodes " << pos.nodes_searched() << " nps " << nps(pos) << " pv "; - for (int k = 0; rml.move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++) - cout << rml.move_pv(j, k) << " "; + for (int k = 0; rml[j].pv[k] != MOVE_NONE && k < PLY_MAX; k++) + cout << rml[j].pv[k] << " "; cout << endl; } - alpha = rml.move_score(Min(i, MultiPV - 1)); + alpha = rml[Min(i, MultiPV - 1)].pv_score; } } // PV move or new best move @@ -993,7 +1000,8 @@ namespace { threatMove = sp->threatMove; mateThreat = sp->mateThreat; goto split_point_start; - } else {} // Hack to fix icc's "statement is unreachable" warning + } + else {} // Hack to fix icc's "statement is unreachable" warning // Step 1. Initialize node and poll. Polling can abort search ss->currentMove = ss->bestMove = threatMove = MOVE_NONE; @@ -1006,8 +1014,10 @@ namespace { } // Step 2. Check for aborted search and immediate draw - if ( AbortSearch || ThreadsMgr.thread_should_stop(threadID) - || pos.is_draw() || ply >= PLY_MAX - 1) + if ( AbortSearch + || ThreadsMgr.cutoff_at_splitpoint(threadID) + || pos.is_draw() + || ply >= PLY_MAX - 1) return VALUE_DRAW; // Step 3. Mate distance pruning @@ -1145,6 +1155,7 @@ namespace { threatMove = (ss+1)->bestMove; if ( depth < ThreatDepth && (ss-1)->reduction + && threatMove != MOVE_NONE && connected_moves(pos, (ss-1)->currentMove, threatMove)) return beta - 1; } @@ -1196,7 +1207,7 @@ split_point_start: // At split points actual search starts from here // Loop through all legal moves until no moves remain or a beta cutoff occurs while ( bestValue < beta && (move = mp.get_next_move()) != MOVE_NONE - && !ThreadsMgr.thread_should_stop(threadID)) + && !ThreadsMgr.cutoff_at_splitpoint(threadID)) { assert(move_is_ok(move)); @@ -1284,7 +1295,7 @@ split_point_start: // At split points actual search starts from here continue; } - // Prune neg. see moves at low depths + // Prune moves with negative SEE at low depths if ( predictedDepth < 2 * ONE_PLY && bestValue > value_mated_in(PLY_MAX) && pos.see_sign(move) < 0) @@ -1301,7 +1312,7 @@ split_point_start: // At split points actual search starts from here // Step extra. pv search (only in PV nodes) // The first move in list is the expected PV - if (!SpNode && PvNode && moveCount == 1) + if (PvNode && moveCount == 1) value = -search(pos, ss+1, -beta, -alpha, newDepth, ply+1); else { @@ -1313,9 +1324,11 @@ split_point_start: // At split points actual search starts from here && !captureOrPromotion && !dangerous && !move_is_castle(move) - && !(ss->killers[0] == move || ss->killers[1] == move)) + && ss->killers[0] != move + && ss->killers[1] != move) { ss->reduction = reduction(depth, moveCount); + if (ss->reduction) { alpha = SpNode ? sp->alpha : alpha; @@ -1324,19 +1337,6 @@ split_point_start: // At split points actual search starts from here doFullDepthSearch = (value > alpha); } - - // The move failed high, but if reduction is very big we could - // face a false positive, retry with a less aggressive reduction, - // if the move fails high again then go with full depth search. - if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY) - { - assert(newDepth - ONE_PLY >= ONE_PLY); - - ss->reduction = ONE_PLY; - alpha = SpNode ? sp->alpha : alpha; - value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1); - doFullDepthSearch = (value > alpha); - } ss->reduction = DEPTH_ZERO; // Restore original reduction } @@ -1367,7 +1367,7 @@ split_point_start: // At split points actual search starts from here alpha = sp->alpha; } - if (value > bestValue && !(SpNode && ThreadsMgr.thread_should_stop(threadID))) + if (value > bestValue && !(SpNode && ThreadsMgr.cutoff_at_splitpoint(threadID))) { bestValue = value; @@ -1376,15 +1376,15 @@ split_point_start: // At split points actual search starts from here if (value > alpha) { - if (SpNode && (!PvNode || value >= beta)) - sp->stopRequest = true; - if (PvNode && value < beta) // We want always alpha < beta { alpha = value; + if (SpNode) sp->alpha = value; } + else if (SpNode) + sp->betaCutoff = true; if (value == value_mate_in(ply + 1)) ss->mateKiller = move; @@ -1403,7 +1403,7 @@ split_point_start: // At split points actual search starts from here && bestValue < beta && ThreadsMgr.available_thread_exists(threadID) && !AbortSearch - && !ThreadsMgr.thread_should_stop(threadID) + && !ThreadsMgr.cutoff_at_splitpoint(threadID) && Iteration <= 99) ThreadsMgr.split(pos, ss, ply, &alpha, beta, &bestValue, depth, threatMove, mateThreat, moveCount, &mp, PvNode); @@ -1419,7 +1419,7 @@ split_point_start: // At split points actual search starts from here // Step 20. Update tables // If the search is not aborted, update the transposition table, // history counters, and killer moves. - if (!SpNode && !AbortSearch && !ThreadsMgr.thread_should_stop(threadID)) + if (!SpNode && !AbortSearch && !ThreadsMgr.cutoff_at_splitpoint(threadID)) { move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove; vt = bestValue <= oldAlpha ? VALUE_TYPE_UPPER @@ -1536,7 +1536,7 @@ split_point_start: // At split points actual search starts from here // to search the moves. Because the depth is <= 0 here, only captures, // queen promotions and checks (only if depth >= DEPTH_QS_CHECKS) will // be generated. - MovePicker mp = MovePicker(pos, ttMove, depth, H); + MovePicker mp(pos, ttMove, depth, H); CheckInfo ci(pos); // Loop through the moves until no moves remain or a beta cutoff occurs @@ -1702,11 +1702,8 @@ split_point_start: // At split points actual search starts from here Square f1, t1, f2, t2; Piece p; - assert(move_is_ok(m1)); - assert(move_is_ok(m2)); - - if (m2 == MOVE_NONE) - return false; + assert(m1 && move_is_ok(m1)); + assert(m2 && move_is_ok(m2)); // Case 1: The moving piece is the same in both moves f2 = move_from(m2); @@ -2465,17 +2462,17 @@ split_point_start: // At split points actual search starts from here } - // thread_should_stop() checks whether the thread should stop its search. - // This can happen if a beta cutoff has occurred in the thread's currently - // active split point, or in some ancestor of the current split point. + // cutoff_at_splitpoint() checks whether a beta cutoff has occurred in + // the thread's currently active split point, or in some ancestor of + // the current split point. - bool ThreadsManager::thread_should_stop(int threadID) const { + bool ThreadsManager::cutoff_at_splitpoint(int threadID) const { assert(threadID >= 0 && threadID < activeThreads); SplitPoint* sp = threads[threadID].splitPoint; - for ( ; sp && !sp->stopRequest; sp = sp->parent) {} + for ( ; sp && !sp->betaCutoff; sp = sp->parent) {} return sp != NULL; } @@ -2574,7 +2571,7 @@ split_point_start: // At split points actual search starts from here // Initialize the split point object splitPoint.parent = masterThread.splitPoint; splitPoint.master = master; - splitPoint.stopRequest = false; + splitPoint.betaCutoff = false; splitPoint.ply = ply; splitPoint.depth = depth; splitPoint.threatMove = threatMove; @@ -2662,101 +2659,62 @@ split_point_start: // At split points actual search starts from here /// The RootMoveList class - // RootMoveList c'tor - RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) { SearchStack ss[PLY_MAX_PLUS_2]; MoveStack mlist[MOVES_MAX]; StateInfo st; - bool includeAllMoves = (searchMoves[0] == MOVE_NONE); + Move* sm; // Initialize search stack init_ss_array(ss, PLY_MAX_PLUS_2); ss[0].eval = ss[0].evalMargin = VALUE_NONE; - count = 0; // Generate all legal moves MoveStack* last = generate_moves(pos, mlist); - // Add each move to the moves[] array + // Add each move to the RootMoveList's vector for (MoveStack* cur = mlist; cur != last; cur++) { - bool includeMove = includeAllMoves; + // If we have a searchMoves[] list then verify cur->move + // is in the list before to add it. + for (sm = searchMoves; *sm && *sm != cur->move; sm++) {} - for (int k = 0; !includeMove && searchMoves[k] != MOVE_NONE; k++) - includeMove = (searchMoves[k] == cur->move); - - if (!includeMove) + if (searchMoves[0] && *sm != cur->move) continue; - // Find a quick score for the move - moves[count].move = ss[0].currentMove = moves[count].pv[0] = cur->move; - moves[count].pv[1] = MOVE_NONE; + // Find a quick score for the move and add to the list pos.do_move(cur->move, st); - moves[count].score = -qsearch(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1); + + RootMove rm; + rm.move = ss[0].currentMove = rm.pv[0] = cur->move; + rm.pv[1] = MOVE_NONE; + rm.pv_score = -qsearch(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1); + push_back(rm); + pos.undo_move(cur->move); - count++; } sort(); } // Score root moves using the standard way used in main search, the moves // are scored according to the order in which are returned by MovePicker. + // This is the second order score that is used to compare the moves when + // the first order pv scores of both moves are equal. - void RootMoveList::score_moves(const Position& pos) + void RootMoveList::set_non_pv_scores(const Position& pos) { Move move; - int score = 1000; - MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H); + Value score = VALUE_ZERO; + MovePicker mp(pos, MOVE_NONE, ONE_PLY, H); while ((move = mp.get_next_move()) != MOVE_NONE) - for (int i = 0; i < count; i++) - if (moves[i].move == move) + for (Base::iterator it = begin(); it != end(); ++it) + if (it->move == move) { - moves[i].mp_score = score--; + it->non_pv_score = score--; break; } } - // RootMoveList simple methods definitions - - void RootMoveList::set_move_pv(int moveNum, const Move pv[]) { - - int j; - - for (j = 0; pv[j] != MOVE_NONE; j++) - moves[moveNum].pv[j] = pv[j]; - - moves[moveNum].pv[j] = MOVE_NONE; - } - - - // RootMoveList::sort() sorts the root move list at the beginning of a new - // iteration. - - void RootMoveList::sort() { - - sort_multipv(count - 1); // Sort all items - } - - - // RootMoveList::sort_multipv() sorts the first few moves in the root move - // list by their scores and depths. It is used to order the different PVs - // correctly in MultiPV mode. - - void RootMoveList::sort_multipv(int n) { - - int i,j; - - for (i = 1; i <= n; i++) - { - RootMove rm = moves[i]; - for (j = i; j > 0 && moves[j - 1] < rm; j--) - moves[j] = moves[j - 1]; - - moves[j] = rm; - } - } - } // namespace