X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fsearch.cpp;h=97b7a29ce4dce27735bc8ceb5c5c645bad79757c;hb=0363b5435847e66678cd3fa0d8a94e30b9a91663;hp=239cd3860ab77db1fd4f25c11e81d8250f0a1828;hpb=4aeffc8c9a7ba870702974f62d1d3553ed227c00;p=stockfish diff --git a/src/search.cpp b/src/search.cpp index 239cd386..97b7a29c 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -76,12 +76,9 @@ namespace { int active_threads() const { return ActiveThreads; } void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; } void incrementNodeCounter(int threadID) { threads[threadID].nodes++; } - void incrementBetaCounter(Color us, Depth d, int threadID) { threads[threadID].betaCutOffs[us] += unsigned(d); } void resetNodeCounters(); - void resetBetaCounters(); int64_t nodes_searched() const; - void get_beta_counters(Color us, int64_t& our, int64_t& their) const; bool available_thread_exists(int master) const; bool thread_is_available(int slave, int master) const; bool thread_should_stop(int threadID) const; @@ -117,7 +114,7 @@ namespace { struct RootMove { - RootMove() { nodes = cumulativeNodes = ourBeta = theirBeta = 0ULL; } + RootMove() : mp_score(0), nodes(0), cumulativeNodes(0) {} // RootMove::operator<() is the comparison function used when // sorting the moves. A move m1 is considered to be better @@ -125,12 +122,13 @@ namespace { // have equal score but m1 has the higher beta cut-off count. bool operator<(const RootMove& m) const { - return score != m.score ? score < m.score : theirBeta <= m.theirBeta; + return score != m.score ? score < m.score : mp_score <= m.mp_score; } Move move; Value score; - int64_t nodes, cumulativeNodes, ourBeta, theirBeta; + int mp_score; + int64_t nodes, cumulativeNodes; Move pv[PLY_MAX_PLUS_2]; }; @@ -149,9 +147,9 @@ namespace { void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; } Move get_move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; } int64_t get_move_cumulative_nodes(int moveNum) const { return moves[moveNum].cumulativeNodes; } + void score_moves(const Position& pos); void set_move_nodes(int moveNum, int64_t nodes); - void set_beta_counters(int moveNum, int64_t our, int64_t their); void set_move_pv(int moveNum, const Move pv[]); void sort(); void sort_multipv(int n); @@ -739,6 +737,7 @@ namespace { while (1) { // Sort the moves before to (re)search + rml.score_moves(pos); rml.sort(); // Step 10. Loop through all moves in the root move list @@ -750,9 +749,6 @@ namespace { // Save the current node count before the move is searched nodes = ThreadsMgr.nodes_searched(); - // Reset beta cut-off counters - ThreadsMgr.resetBetaCounters(); - // Pick the next root move, and print the move and the move number to // the standard output. move = ss->currentMove = rml.get_move(i); @@ -824,7 +820,7 @@ namespace { value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1); doFullDepthSearch = (value > alpha); } - ss->reduction = Depth(0); // Restore original reduction + ss->reduction = DEPTH_ZERO; // Restore original reduction } // Step 15. Full depth search @@ -871,11 +867,7 @@ namespace { if (AbortSearch) break; - // Remember beta-cutoff and searched nodes counts for this move. The - // info is used to sort the root moves for the next iteration. - int64_t our, their; - ThreadsMgr.get_beta_counters(pos.side_to_move(), our, their); - rml.set_beta_counters(i, our, their); + // Remember searched nodes counts for this move rml.set_move_nodes(i, ThreadsMgr.nodes_searched() - nodes); assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE); @@ -996,7 +988,7 @@ namespace { // Step 2. Check for aborted search and immediate draw if (AbortSearch || ThreadsMgr.thread_should_stop(threadID)) - return Value(0); + return VALUE_ZERO; if (pos.is_draw() || ply >= PLY_MAX - 1) return VALUE_DRAW; @@ -1067,7 +1059,7 @@ namespace { && !pos.has_pawn_on_7th(pos.side_to_move())) { Value rbeta = beta - razor_margin(depth); - Value v = qsearch(pos, ss, rbeta-1, rbeta, Depth(0), ply); + Value v = qsearch(pos, ss, rbeta-1, rbeta, DEPTH_ZERO, ply); if (v < rbeta) // Logically we should return (v + razor_margin(depth)), but // surprisingly this did slightly weaker in tests. @@ -1110,7 +1102,7 @@ namespace { pos.do_null_move(st); (ss+1)->skipNullMove = true; - nullValue = depth-R*ONE_PLY < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, Depth(0), ply+1) + nullValue = depth-R*ONE_PLY < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1) : - search(pos, ss+1, -beta, -alpha, depth-R*ONE_PLY, ply+1); (ss+1)->skipNullMove = false; pos.undo_null_move(); @@ -1179,7 +1171,7 @@ namespace { && tte && tte->move() && !excludedMove // Do not allow recursive singular extension search - && is_lower_bound(tte->type()) + && (tte->type() & VALUE_TYPE_LOWER) && tte->depth() >= depth - 3 * ONE_PLY; // Step 10. Loop through moves @@ -1263,7 +1255,7 @@ namespace { // Step extra. pv search (only in PV nodes) // The first move in list is the expected PV if (PvNode && moveCount == 1) - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, Depth(0), ply+1) + value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1) : - search(pos, ss+1, -beta, -alpha, newDepth, ply+1); else { @@ -1281,7 +1273,7 @@ namespace { if (ss->reduction) { Depth d = newDepth - ss->reduction; - value = d < ONE_PLY ? -qsearch(pos, ss+1, -(alpha+1), -alpha, Depth(0), ply+1) + value = d < ONE_PLY ? -qsearch(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1) : - search(pos, ss+1, -(alpha+1), -alpha, d, ply+1); doFullDepthSearch = (value > alpha); @@ -1298,20 +1290,20 @@ namespace { value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1); doFullDepthSearch = (value > alpha); } - ss->reduction = Depth(0); // Restore original reduction + ss->reduction = DEPTH_ZERO; // Restore original reduction } // Step 15. Full depth search if (doFullDepthSearch) { - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(alpha+1), -alpha, Depth(0), ply+1) + value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1) : - search(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1); // Step extra. pv search (only in PV nodes) // Search only for possible new PV nodes, if instead value >= beta then // parent node fails low with value <= alpha and tries another move. if (PvNode && value > alpha && value < beta) - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, Depth(0), ply+1) + value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1) : - search(pos, ss+1, -beta, -alpha, newDepth, ply+1); } } @@ -1367,14 +1359,11 @@ namespace { TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ei.kingDanger[pos.side_to_move()]); // Update killers and history only for non capture moves that fails high - if (bestValue >= beta) + if ( bestValue >= beta + && !pos.move_is_capture_or_promotion(move)) { - ThreadsMgr.incrementBetaCounter(pos.side_to_move(), depth, threadID); - if (!pos.move_is_capture_or_promotion(move)) - { update_history(pos, move, depth, movesSearched, moveCount); update_killers(move, ss); - } } assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); @@ -1471,7 +1460,7 @@ namespace { // to search the moves. Because the depth is <= 0 here, only captures, // queen promotions and checks (only if depth == 0 or depth == -ONE_PLY // and we are near beta) will be generated. - MovePicker mp = MovePicker(pos, ttMove, deepChecks ? Depth(0) : depth, H); + MovePicker mp = MovePicker(pos, ttMove, deepChecks ? DEPTH_ZERO : depth, H); CheckInfo ci(pos); // Loop through the moves until no moves remain or a beta cutoff occurs @@ -1493,7 +1482,7 @@ namespace { { futilityValue = futilityBase + pos.endgame_value_of_piece_on(move_to(move)) - + (move_is_ep(move) ? PawnValueEndgame : Value(0)); + + (move_is_ep(move) ? PawnValueEndgame : VALUE_ZERO); if (futilityValue < alpha) { @@ -1546,7 +1535,7 @@ namespace { return value_mated_in(ply); // Update transposition table - Depth d = (depth == Depth(0) ? Depth(0) : Depth(-1)); + Depth d = (depth == DEPTH_ZERO ? DEPTH_ZERO : DEPTH_ZERO - ONE_PLY); ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT); TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, ei.kingDanger[pos.side_to_move()]); @@ -1660,7 +1649,7 @@ namespace { { Value localAlpha = sp->alpha; Depth d = newDepth - ss->reduction; - value = d < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), sp->ply+1) + value = d < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, sp->ply+1) : - search(pos, ss+1, -(localAlpha+1), -localAlpha, d, sp->ply+1); doFullDepthSearch = (value > localAlpha); @@ -1678,21 +1667,21 @@ namespace { value = -search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, sp->ply+1); doFullDepthSearch = (value > localAlpha); } - ss->reduction = Depth(0); // Restore original reduction + ss->reduction = DEPTH_ZERO; // Restore original reduction } // Step 15. Full depth search if (doFullDepthSearch) { Value localAlpha = sp->alpha; - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), sp->ply+1) + value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, sp->ply+1) : - search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, sp->ply+1); // Step extra. pv search (only in PV nodes) // Search only for possible new PV nodes, if instead value >= beta then // parent node fails low with value <= alpha and tries another move. if (PvNode && value > localAlpha && value < sp->beta) - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -sp->beta, -sp->alpha, Depth(0), sp->ply+1) + value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -sp->beta, -sp->alpha, DEPTH_ZERO, sp->ply+1) : - search(pos, ss+1, -sp->beta, -sp->alpha, newDepth, sp->ply+1); } @@ -1851,7 +1840,7 @@ namespace { assert(m != MOVE_NONE); - Depth result = Depth(0); + Depth result = DEPTH_ZERO; *dangerous = moveIsCheck | singleEvasion | mateThreat; if (*dangerous) @@ -1884,7 +1873,7 @@ namespace { if ( captureOrPromotion && pos.type_of_piece_on(move_to(m)) != PAWN && ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) - - pos.midgame_value_of_piece_on(move_to(m)) == Value(0)) + - pos.midgame_value_of_piece_on(move_to(m)) == VALUE_ZERO) && !move_is_promotion(m) && !move_is_ep(m)) { @@ -1957,8 +1946,8 @@ namespace { || v >= Max(value_mate_in(PLY_MAX), beta) || v < Min(value_mated_in(PLY_MAX), beta)) - && ( (is_lower_bound(tte->type()) && v >= beta) - || (is_upper_bound(tte->type()) && v < beta)); + && ( ((tte->type() & VALUE_TYPE_LOWER) && v >= beta) + || ((tte->type() & VALUE_TYPE_UPPER) && v < beta)); } @@ -1971,8 +1960,8 @@ namespace { Value v = value_from_tt(tte->value(), ply); - if ( (is_lower_bound(tte->type()) && v >= defaultEval) - || (is_upper_bound(tte->type()) && v < defaultEval)) + if ( ((tte->type() & VALUE_TYPE_LOWER) && v >= defaultEval) + || ((tte->type() & VALUE_TYPE_UPPER) && v < defaultEval)) return v; return defaultEval; @@ -2165,7 +2154,7 @@ namespace { { ss->excludedMove = MOVE_NONE; ss->skipNullMove = false; - ss->reduction = Depth(0); + ss->reduction = DEPTH_ZERO; if (i < 3) ss->killers[0] = ss->killers[1] = ss->mateKiller = MOVE_NONE; @@ -2320,12 +2309,6 @@ namespace { threads[i].nodes = 0ULL; } - void ThreadsManager::resetBetaCounters() { - - for (int i = 0; i < MAX_THREADS; i++) - threads[i].betaCutOffs[WHITE] = threads[i].betaCutOffs[BLACK] = 0ULL; - } - int64_t ThreadsManager::nodes_searched() const { int64_t result = 0ULL; @@ -2335,16 +2318,6 @@ namespace { return result; } - void ThreadsManager::get_beta_counters(Color us, int64_t& our, int64_t& their) const { - - our = their = 0UL; - for (int i = 0; i < MAX_THREADS; i++) - { - our += threads[i].betaCutOffs[us]; - their += threads[i].betaCutOffs[opposite_color(us)]; - } - } - // idle_loop() is where the threads are parked when they have no work to do. // The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint @@ -2603,7 +2576,7 @@ namespace { assert(*bestValue <= *alpha); assert(*alpha < beta); assert(beta <= VALUE_INFINITE); - assert(depth > Depth(0)); + assert(depth > DEPTH_ZERO); assert(p.thread() >= 0 && p.thread() < ActiveThreads); assert(ActiveThreads > 1); @@ -2767,7 +2740,7 @@ namespace { pos.do_move(cur->move, st); ss[0].currentMove = cur->move; moves[count].move = cur->move; - moves[count].score = -qsearch(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, Depth(0), 1); + moves[count].score = -qsearch(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1); moves[count].pv[0] = cur->move; moves[count].pv[1] = MOVE_NONE; pos.undo_move(cur->move); @@ -2776,6 +2749,23 @@ namespace { 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. + + void RootMoveList::score_moves(const Position& pos) + { + Move move; + int score = 1000; + MovePicker mp = MovePicker(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) + { + moves[i].mp_score = score--; + break; + } + } // RootMoveList simple methods definitions @@ -2785,12 +2775,6 @@ namespace { moves[moveNum].cumulativeNodes += nodes; } - void RootMoveList::set_beta_counters(int moveNum, int64_t our, int64_t their) { - - moves[moveNum].ourBeta = our; - moves[moveNum].theirBeta = their; - } - void RootMoveList::set_move_pv(int moveNum, const Move pv[]) { int j;