X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=7d9d402c0ac6c5dedc6af55711809293ee69a069;hp=652893282ca35bc51767bcee3d535aa2328ff10f;hb=c7a932bc744f899f53ce0013cbbbaa86915bb2e8;hpb=252537fd9c8cb60f765ea390d2464a42adeafc0a diff --git a/src/search.cpp b/src/search.cpp index 65289328..7d9d402c 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); @@ -163,12 +161,27 @@ namespace { }; + // When formatting a move for std::cout we must know if we are in Chess960 + // or not. To keep using the handy operator<<() on the move the trick is to + // embed this flag in the stream itself. Function-like named enum set960 is + // used as a custom manipulator and the stream internal general-purpose array, + // accessed through ios_base::iword(), is used to pass the flag to the move's + // operator<<() that will use it to properly format castling moves. + enum set960 {}; + + std::ostream& operator<< (std::ostream& os, const set960& m) { + + os.iword(0) = int(m); + return os; + } + + /// Adjustments // Step 6. Razoring // Maximum depth for razoring - const Depth RazorDepth = 4 * OnePly; + const Depth RazorDepth = 4 * ONE_PLY; // Dynamic razoring margin based on depth inline Value razor_margin(Depth d) { return Value(0x200 + 0x10 * int(d)); } @@ -180,12 +193,12 @@ namespace { const Value NullMoveMargin = Value(0x200); // Maximum depth for use of dynamic threat detection when null move fails low - const Depth ThreatDepth = 5 * OnePly; + const Depth ThreatDepth = 5 * ONE_PLY; // Step 9. Internal iterative deepening // Minimum depth for use of internal iterative deepening - const Depth IIDDepth[2] = { 8 * OnePly /* non-PV */, 5 * OnePly /* PV */}; + const Depth IIDDepth[2] = { 8 * ONE_PLY /* non-PV */, 5 * ONE_PLY /* PV */}; // At Non-PV nodes we do an internal iterative deepening search // when the static evaluation is bigger then beta - IIDMargin. @@ -199,7 +212,7 @@ namespace { Depth PassedPawnExtension[2], PawnEndgameExtension[2], MateThreatExtension[2]; // Minimum depth for use of singular extension - const Depth SingularExtensionDepth[2] = { 7 * OnePly /* non-PV */, 6 * OnePly /* PV */}; + const Depth SingularExtensionDepth[2] = { 8 * ONE_PLY /* non-PV */, 6 * ONE_PLY /* PV */}; // If the TT move is at least SingularExtensionMargin better then the // remaining ones we will extend it. @@ -214,8 +227,8 @@ namespace { int32_t FutilityMarginsMatrix[16][64]; // [depth][moveNumber] int FutilityMoveCountArray[32]; // [depth] - inline Value futility_margin(Depth d, int mn) { return Value(d < 7 * OnePly ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE); } - inline int futility_move_count(Depth d) { return d < 16 * OnePly ? FutilityMoveCountArray[d] : 512; } + inline Value futility_margin(Depth d, int mn) { return Value(d < 7 * ONE_PLY ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE); } + inline int futility_move_count(Depth d) { return d < 16 * ONE_PLY ? FutilityMoveCountArray[d] : 512; } // Step 14. Reduced search @@ -228,7 +241,7 @@ namespace { // Common adjustments // Search depth at iteration 1 - const Depth InitialDepth = OnePly; + const Depth InitialDepth = ONE_PLY; // Easy move margin. An easy move candidate must be at least this much // better than the second best move. @@ -338,8 +351,8 @@ int64_t nodes_searched() { return ThreadsMgr.nodes_searched(); } void init_search() { - int d; // depth (OnePly == 2) - int hd; // half depth (OnePly == 1) + int d; // depth (ONE_PLY == 2) + int hd; // half depth (ONE_PLY == 1) int mc; // moveCount // Init reductions array @@ -347,8 +360,8 @@ void init_search() { { double pvRed = 0.33 + log(double(hd)) * log(double(mc)) / 4.5; double nonPVRed = 0.33 + log(double(hd)) * log(double(mc)) / 2.25; - ReductionMatrix[PV][hd][mc] = (int8_t) ( pvRed >= 1.0 ? floor( pvRed * int(OnePly)) : 0); - ReductionMatrix[NonPV][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(OnePly)) : 0); + ReductionMatrix[PV][hd][mc] = (int8_t) ( pvRed >= 1.0 ? floor( pvRed * int(ONE_PLY)) : 0); + ReductionMatrix[NonPV][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(ONE_PLY)) : 0); } // Init futility margins array @@ -376,7 +389,7 @@ int perft(Position& pos, Depth depth) // If we are at the last ply we don't need to do and undo // the moves, just to count them. - if (depth <= OnePly) + if (depth <= ONE_PLY) return int(last - mlist); // Loop through all legal moves @@ -385,7 +398,7 @@ int perft(Position& pos, Depth depth) { m = cur->move; pos.do_move(m, st, ci, pos.move_is_check(m, ci)); - sum += perft(pos, depth - OnePly); + sum += perft(pos, depth - ONE_PLY); pos.undo_move(m); } return sum; @@ -447,10 +460,9 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr MateThreatExtension[1] = Depth(get_option_value_int("Mate Threat Extension (PV nodes)")); MateThreatExtension[0] = Depth(get_option_value_int("Mate Threat Extension (non-PV nodes)")); - MinimumSplitDepth = get_option_value_int("Minimum Split Depth") * OnePly; + MinimumSplitDepth = get_option_value_int("Minimum Split Depth") * ONE_PLY; MaxThreadsPerSplitPoint = get_option_value_int("Maximum Number of Threads per Split Point"); MultiPV = get_option_value_int("MultiPV"); - Chess960 = get_option_value_bool("UCI_Chess960"); UseLogFile = get_option_value_bool("Use Search Log"); if (UseLogFile) @@ -536,7 +548,8 @@ namespace { // Print RootMoveList startup scoring to the standard output, // so to output information also for iteration 1. - cout << "info depth " << 1 + cout << set960(p.is_chess960()) // Is enough to set once at the beginning + << "info depth " << 1 << "\ninfo depth " << 1 << " score " << value_to_uci(rml.get_move_score(0)) << " time " << current_search_time() @@ -715,7 +728,7 @@ namespace { alpha = *alphaPtr; beta = *betaPtr; isCheck = pos.is_check(); - depth = (Iteration - 2) * OnePly + InitialDepth; + depth = (Iteration - 2) * ONE_PLY + InitialDepth; // Step 1. Initialize node (polling is omitted at root) ss->currentMove = ss->bestMove = MOVE_NONE; @@ -739,6 +752,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 +764,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); @@ -798,7 +809,7 @@ namespace { // if the move fails high will be re-searched at full depth bool doFullDepthSearch = true; - if ( depth >= 3 * OnePly + if ( depth >= 3 * ONE_PLY && !dangerous && !captureOrPromotion && !move_is_castle(move)) @@ -806,7 +817,7 @@ namespace { ss->reduction = reduction(depth, i - MultiPV + 2); if (ss->reduction) { - assert(newDepth-ss->reduction >= OnePly); + assert(newDepth-ss->reduction >= ONE_PLY); // Reduced depth non-pv search using alpha as upperbound value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1); @@ -816,15 +827,15 @@ namespace { // 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 * OnePly) + if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY) { - assert(newDepth - OnePly >= OnePly); + assert(newDepth - ONE_PLY >= ONE_PLY); - ss->reduction = OnePly; + ss->reduction = ONE_PLY; 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 +882,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); @@ -970,7 +977,7 @@ namespace { Move movesSearched[256]; EvalInfo ei; StateInfo st; - const TTEntry *tte, *ttx; + const TTEntry *tte; Key posKey; Move ttMove, move, excludedMove, threatMove; Depth ext, newDepth; @@ -996,7 +1003,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; @@ -1028,7 +1035,7 @@ namespace { if (!PvNode && tte && ok_to_use_TT(tte, depth, beta, ply)) { // Refresh tte entry to avoid aging - TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove, tte->static_value(), tte->king_danger()); + TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove, tte->static_value(), tte->static_value_margin()); ss->bestMove = ttMove; // Can be MOVE_NONE return value_from_tt(tte->value(), ply); @@ -1044,13 +1051,13 @@ namespace { assert(tte->static_value() != VALUE_NONE); ss->eval = tte->static_value(); - ei.kingDanger[pos.side_to_move()] = tte->king_danger(); + ei.margin[pos.side_to_move()] = tte->static_value_margin(); refinedValue = refine_eval(tte, ss->eval, ply); } else { refinedValue = ss->eval = evaluate(pos, ei); - TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ei.kingDanger[pos.side_to_move()]); + TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ei.margin[pos.side_to_move()]); } // Save gain for the parent non-capture move @@ -1067,7 +1074,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. @@ -1092,16 +1099,16 @@ namespace { // NullMoveMargin under beta. if ( !PvNode && !ss->skipNullMove - && depth > OnePly + && depth > ONE_PLY && !isCheck - && refinedValue >= beta - (depth >= 4 * OnePly ? NullMoveMargin : 0) + && refinedValue >= beta - (depth >= 4 * ONE_PLY ? NullMoveMargin : 0) && !value_is_mate(beta) && pos.non_pawn_material(pos.side_to_move())) { ss->currentMove = MOVE_NULL; // Null move dynamic reduction based on depth - int R = 3 + (depth >= 5 * OnePly ? depth / 8 : 0); + int R = 3 + (depth >= 5 * ONE_PLY ? depth / 8 : 0); // Null move dynamic reduction based on value if (refinedValue - beta > PawnValueMidgame) @@ -1110,8 +1117,8 @@ namespace { pos.do_null_move(st); (ss+1)->skipNullMove = true; - nullValue = depth-R*OnePly < OnePly ? -qsearch(pos, ss+1, -beta, -alpha, Depth(0), ply+1) - : - search(pos, ss+1, -beta, -alpha, depth-R*OnePly, 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(); @@ -1121,12 +1128,12 @@ namespace { if (nullValue >= value_mate_in(PLY_MAX)) nullValue = beta; - if (depth < 6 * OnePly) + if (depth < 6 * ONE_PLY) return nullValue; // Do verification search at high depths ss->skipNullMove = true; - Value v = search(pos, ss, alpha, beta, depth-R*OnePly, ply); + Value v = search(pos, ss, alpha, beta, depth-R*ONE_PLY, ply); ss->skipNullMove = false; if (v >= beta) @@ -1156,7 +1163,7 @@ namespace { && ttMove == MOVE_NONE && (PvNode || (!isCheck && ss->eval >= beta - IIDMargin))) { - Depth d = (PvNode ? depth - 2 * OnePly : depth / 2); + Depth d = (PvNode ? depth - 2 * ONE_PLY : depth / 2); ss->skipNullMove = true; search(pos, ss, alpha, beta, d, ply); @@ -1179,8 +1186,8 @@ namespace { && tte && tte->move() && !excludedMove // Do not allow recursive singular extension search - && is_lower_bound(tte->type()) - && tte->depth() >= depth - 3 * OnePly; + && (tte->type() & VALUE_TYPE_LOWER) + && tte->depth() >= depth - 3 * ONE_PLY; // Step 10. Loop through moves // Loop through all legal moves until no moves remain or a beta cutoff occurs @@ -1205,24 +1212,11 @@ namespace { // lower then ttValue minus a margin then we extend ttMove. if ( singularExtensionNode && move == tte->move() - && ext < OnePly) + && ext < ONE_PLY) { - // Avoid to do an expensive singular extension search on nodes where - // such search have already been done in the past, so assume the last - // singular extension search result is still valid. - if ( !PvNode - && depth < SingularExtensionDepth[PvNode] + 5 * OnePly - && (ttx = TT.retrieve(pos.get_exclusion_key())) != NULL) - { - if (is_upper_bound(ttx->type())) - ext = OnePly; - - singularExtensionNode = false; - } - Value ttValue = value_from_tt(tte->value(), ply); - if (singularExtensionNode && abs(ttValue) < VALUE_KNOWN_WIN) + if (abs(ttValue) < VALUE_KNOWN_WIN) { Value b = ttValue - SingularExtensionMargin; ss->excludedMove = move; @@ -1232,11 +1226,11 @@ namespace { ss->excludedMove = MOVE_NONE; ss->bestMove = MOVE_NONE; if (v < b) - ext = OnePly; + ext = ONE_PLY; } } - newDepth = depth - OnePly + ext; + newDepth = depth - ONE_PLY + ext; // Update current move (this must be done after singular extension search) movesSearched[moveCount++] = ss->currentMove = move; @@ -1256,7 +1250,7 @@ namespace { continue; // Value based pruning - // We illogically ignore reduction condition depth >= 3*OnePly for predicted depth, + // 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); futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount) @@ -1276,15 +1270,15 @@ namespace { // Step extra. pv search (only in PV nodes) // The first move in list is the expected PV if (PvNode && moveCount == 1) - value = newDepth < OnePly ? -qsearch(pos, ss+1, -beta, -alpha, Depth(0), ply+1) - : - search(pos, ss+1, -beta, -alpha, newDepth, 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 { // Step 14. Reduced depth search // If the move fails high will be re-searched at full depth. bool doFullDepthSearch = true; - if ( depth >= 3 * OnePly + if ( depth >= 3 * ONE_PLY && !captureOrPromotion && !dangerous && !move_is_castle(move) @@ -1294,8 +1288,8 @@ namespace { if (ss->reduction) { Depth d = newDepth - ss->reduction; - value = d < OnePly ? -qsearch(pos, ss+1, -(alpha+1), -alpha, Depth(0), ply+1) - : - search(pos, ss+1, -(alpha+1), -alpha, d, 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); } @@ -1303,29 +1297,29 @@ namespace { // 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 * OnePly) + if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY) { - assert(newDepth - OnePly >= OnePly); + assert(newDepth - ONE_PLY >= ONE_PLY); - ss->reduction = OnePly; + ss->reduction = ONE_PLY; 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 < OnePly ? -qsearch(pos, ss+1, -(alpha+1), -alpha, Depth(0), ply+1) - : - search(pos, ss+1, -(alpha+1), -alpha, newDepth, 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 < OnePly ? -qsearch(pos, ss+1, -beta, -alpha, Depth(0), ply+1) - : - search(pos, ss+1, -beta, -alpha, newDepth, 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); } } @@ -1377,17 +1371,14 @@ namespace { ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT); move = (bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove); - TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ei.kingDanger[pos.side_to_move()]); + TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ei.margin[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); @@ -1398,7 +1389,7 @@ namespace { // qsearch() is the quiescence search function, which is called by the main // search function when the remaining depth is zero (or, to be more precise, - // less than OnePly). + // less than ONE_PLY). template Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { @@ -1451,7 +1442,7 @@ namespace { { assert(tte->static_value() != VALUE_NONE); - ei.kingDanger[pos.side_to_move()] = tte->king_danger(); + ei.margin[pos.side_to_move()] = tte->static_value_margin(); bestValue = tte->static_value(); } else @@ -1464,7 +1455,7 @@ namespace { if (bestValue >= beta) { if (!tte) - TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, ei.kingDanger[pos.side_to_move()]); + TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, ei.margin[pos.side_to_move()]); return bestValue; } @@ -1473,18 +1464,18 @@ namespace { alpha = bestValue; // If we are near beta then try to get a cutoff pushing checks a bit further - deepChecks = (depth == -OnePly && bestValue >= beta - PawnValueMidgame / 8); + deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8); // Futility pruning parameters, not needed when in check - futilityBase = bestValue + FutilityMarginQS + ei.kingDanger[pos.side_to_move()]; + futilityBase = bestValue + FutilityMarginQS + ei.margin[pos.side_to_move()]; enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame; } // Initialize a MovePicker object for the current position, and prepare // to search the moves. Because the depth is <= 0 here, only captures, - // queen promotions and checks (only if depth == 0 or depth == -OnePly + // 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 @@ -1506,7 +1497,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) { @@ -1536,7 +1527,7 @@ namespace { // Make and search the move pos.do_move(move, st, ci, moveIsCheck); - value = -qsearch(pos, ss+1, -beta, -alpha, depth-OnePly, ply+1); + value = -qsearch(pos, ss+1, -beta, -alpha, depth-ONE_PLY, ply+1); pos.undo_move(move); assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); @@ -1559,9 +1550,9 @@ 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()]); + TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, ei.margin[pos.side_to_move()]); // Update killers only for checking moves that fails high if ( bestValue >= beta @@ -1620,7 +1611,7 @@ namespace { // Step 11. Decide the new search depth ext = extension(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous); - newDepth = sp->depth - OnePly + ext; + newDepth = sp->depth - ONE_PLY + ext; // Update current move ss->currentMove = move; @@ -1673,8 +1664,8 @@ namespace { { Value localAlpha = sp->alpha; Depth d = newDepth - ss->reduction; - value = d < OnePly ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), sp->ply+1) - : - search(pos, ss+1, -(localAlpha+1), -localAlpha, d, 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); } @@ -1682,31 +1673,31 @@ namespace { // 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 * OnePly) + if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY) { - assert(newDepth - OnePly >= OnePly); + assert(newDepth - ONE_PLY >= ONE_PLY); - ss->reduction = OnePly; + ss->reduction = ONE_PLY; Value localAlpha = sp->alpha; 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 < OnePly ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), sp->ply+1) - : - search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, 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 < OnePly ? -qsearch(pos, ss+1, -sp->beta, -sp->alpha, Depth(0), sp->ply+1) - : - search(pos, ss+1, -sp->beta, -sp->alpha, newDepth, 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); } // Step 16. Undo move @@ -1864,7 +1855,7 @@ namespace { assert(m != MOVE_NONE); - Depth result = Depth(0); + Depth result = DEPTH_ZERO; *dangerous = moveIsCheck | singleEvasion | mateThreat; if (*dangerous) @@ -1897,7 +1888,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)) { @@ -1910,11 +1901,11 @@ namespace { && pos.type_of_piece_on(move_to(m)) != PAWN && pos.see_sign(m) >= 0) { - result += OnePly/2; + result += ONE_PLY / 2; *dangerous = true; } - return Min(result, OnePly); + return Min(result, ONE_PLY); } @@ -1970,8 +1961,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)); } @@ -1984,8 +1975,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; @@ -2056,7 +2047,7 @@ namespace { std::stringstream s; - if (abs(v) < VALUE_MATE - PLY_MAX * OnePly) + if (abs(v) < VALUE_MATE - PLY_MAX * ONE_PLY) s << "cp " << int(v) * 100 / int(PawnValueMidgame); // Scale to pawn = 100 else s << "mate " << (v > 0 ? (VALUE_MATE - v + 1) / 2 : -(VALUE_MATE + v) / 2 ); @@ -2178,7 +2169,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; @@ -2260,7 +2251,7 @@ namespace { if (!tte || tte->move() != pv[i]) { v = (p.is_check() ? VALUE_NONE : evaluate(p, ei)); - TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, ei.kingDanger[pos.side_to_move()]); + TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, ei.margin[pos.side_to_move()]); } p.do_move(pv[i], st); } @@ -2333,12 +2324,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; @@ -2348,16 +2333,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 @@ -2616,7 +2591,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); @@ -2780,7 +2755,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); @@ -2789,6 +2764,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 @@ -2798,12 +2790,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;