X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=d07db40f4d749d852d061f77dab6ed6fdae4757b;hp=4139ef96b707afa81baec5e5d19a7fbf2d7a28c9;hb=e304db9d1ecf6a2318708483c90fadecf4fac4ee;hpb=46c01b5083b30855830ffcfe287c448744f787de diff --git a/src/search.cpp b/src/search.cpp index 4139ef96..d07db40f 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -42,6 +42,7 @@ namespace Search { LimitsType Limits; std::vector RootMoves; Position RootPosition; + Color RootColor; Time::point SearchTime; StateStackPtr SetupStates; } @@ -91,6 +92,7 @@ namespace { int BestMoveChanges; int SkillLevel; bool SkillLevelEnabled, Chess960; + Value DrawValue[COLOR_NB]; History H; template @@ -104,7 +106,6 @@ namespace { bool connected_moves(const Position& pos, Move m1, Move m2); Value value_to_tt(Value v, int ply); Value value_from_tt(Value v, int ply); - bool can_return_tt(const TTEntry* tte, Depth depth, Value ttValue, Value beta); bool connected_threat(const Position& pos, Move m, Move threat); Value refine_eval(const TTEntry* tte, Value ttValue, Value defaultEval); Move do_skill_level(); @@ -136,7 +137,7 @@ void Search::init() { // Init futility move count array for (d = 0; d < 32; d++) - FutilityMoveCounts[d] = int(3.001 + 0.25 * pow(d, 2.0)); + FutilityMoveCounts[d] = int(3.001 + 0.25 * pow(double(d), 2.0)); } @@ -174,9 +175,7 @@ void Search::think() { Position& pos = RootPosition; Chess960 = pos.is_chess960(); - Eval::RootColor = pos.side_to_move(); - Eval::ValueDraw[ Eval::RootColor] = VALUE_DRAW - Eval::ContemptFactor; - Eval::ValueDraw[~Eval::RootColor] = VALUE_DRAW + Eval::ContemptFactor; + RootColor = pos.side_to_move(); TimeMgr.init(Limits, pos.startpos_ply_counter(), pos.side_to_move()); TT.new_search(); H.clear(); @@ -190,6 +189,16 @@ void Search::think() { goto finalize; } + if (Options["Contempt Factor"] && !Options["UCI_AnalyseMode"]) + { + int cf = Options["Contempt Factor"] * PawnValueMg / 100; // In centipawns + cf = cf * MaterialTable::game_phase(pos) / PHASE_MIDGAME; // Scale down with phase + DrawValue[ RootColor] = VALUE_DRAW - Value(cf); + DrawValue[~RootColor] = VALUE_DRAW + Value(cf); + } + else + DrawValue[WHITE] = DrawValue[BLACK] = VALUE_DRAW; + if (Options["OwnBook"] && !Limits.infinite) { Move bookMove = book.probe(pos, Options["Book File"], Options["Best Book Move"]); @@ -516,7 +525,7 @@ namespace { { // Step 2. Check for aborted search and immediate draw if (Signals.stop || pos.is_draw() || ss->ply > MAX_PLY) - return Eval::ValueDraw[pos.side_to_move()]; + return DrawValue[pos.side_to_move()]; // 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 @@ -543,9 +552,14 @@ namespace { // a fail high/low. Biggest advantage at 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 && tte && (PvNode ? tte->depth() >= depth && tte->type() == BOUND_EXACT - : can_return_tt(tte, depth, ttValue, beta))) + if ( !RootNode + && tte && tte->depth() >= depth + && ( PvNode ? tte->type() == BOUND_EXACT + : ttValue >= beta ? (tte->type() & BOUND_LOWER) + : (tte->type() & BOUND_UPPER))) { + assert(ttValue != VALUE_NONE); // Due to depth > DEPTH_NONE + TT.refresh(tte); ss->currentMove = ttMove; // Can be MOVE_NONE @@ -563,6 +577,7 @@ namespace { // Step 5. Evaluate the position statically and update parent's gain statistics if (inCheck) ss->eval = ss->evalMargin = refinedValue = VALUE_NONE; + else if (tte) { assert(tte->static_value() != VALUE_NONE); @@ -574,7 +589,8 @@ namespace { else { refinedValue = ss->eval = evaluate(pos, ss->evalMargin); - TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin); + TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, + ss->eval, ss->evalMargin); } // Update gain for the parent non-capture move given the static position @@ -806,6 +822,8 @@ split_point_start: // At split points actual search starts from here && pos.pl_move_is_legal(move, ci.pinned) && abs(ttValue) < VALUE_KNOWN_WIN) { + assert(ttValue != VALUE_NONE); + Value rBeta = ttValue - int(depth); ss->excludedMove = move; ss->skipNullMove = true; @@ -826,7 +844,8 @@ split_point_start: // At split points actual search starts from here && !inCheck && !dangerous && move != ttMove - && (bestValue > VALUE_MATED_IN_MAX_PLY || bestValue == -VALUE_INFINITE)) + && (bestValue > VALUE_MATED_IN_MAX_PLY || ( bestValue == -VALUE_INFINITE + && alpha > VALUE_MATED_IN_MAX_PLY))) { // Move count based pruning if ( depth < 16 * ONE_PLY @@ -1005,7 +1024,8 @@ split_point_start: // At split points actual search starts from here // 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. if (!moveCount) - return excludedMove ? alpha : inCheck ? mated_in(ss->ply) : VALUE_DRAW; + return excludedMove ? alpha + : inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()]; // If we have pruned all the moves without searching return a fail-low score if (bestValue == -VALUE_INFINITE) @@ -1079,7 +1099,7 @@ split_point_start: // At split points actual search starts from here // Check for an instant draw or maximum ply reached if (pos.is_draw() || ss->ply > MAX_PLY) - return Eval::ValueDraw[pos.side_to_move()]; + return DrawValue[pos.side_to_move()]; // Transposition table lookup. At PV nodes, we don't use the TT for // pruning, but only for move ordering. @@ -1091,10 +1111,15 @@ split_point_start: // At split points actual search starts from here // 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 : DEPTH_QS_NO_CHECKS; - - if (!PvNode && tte && can_return_tt(tte, ttDepth, ttValue, beta)) + ttDepth = inCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS + : DEPTH_QS_NO_CHECKS; + if ( tte && tte->depth() >= ttDepth + && ( PvNode ? tte->type() == BOUND_EXACT + : ttValue >= beta ? (tte->type() & BOUND_LOWER) + : (tte->type() & BOUND_UPPER))) { + assert(ttValue != VALUE_NONE); // Due to ttDepth > DEPTH_NONE + ss->currentMove = ttMove; // Can be MOVE_NONE return ttValue; } @@ -1122,7 +1147,8 @@ split_point_start: // At split points actual search starts from here if (bestValue >= beta) { if (!tte) - TT.store(pos.key(), value_to_tt(bestValue, ss->ply), BOUND_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin); + TT.store(pos.key(), value_to_tt(bestValue, ss->ply), BOUND_LOWER, + DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin); return bestValue; } @@ -1351,13 +1377,10 @@ split_point_start: // At split points actual search starts from here Value value_to_tt(Value v, int ply) { - if (v >= VALUE_MATE_IN_MAX_PLY) - return v + ply; + assert(v != VALUE_NONE); - if (v <= VALUE_MATED_IN_MAX_PLY) - return v - ply; - - return v; + return v >= VALUE_MATE_IN_MAX_PLY ? v + ply + : v <= VALUE_MATED_IN_MAX_PLY ? v - ply : v; } @@ -1367,13 +1390,9 @@ split_point_start: // At split points actual search starts from here Value value_from_tt(Value v, int ply) { - if (v >= VALUE_MATE_IN_MAX_PLY) - return v - ply; - - if (v <= VALUE_MATED_IN_MAX_PLY) - return v + ply; - - return v; + return v == VALUE_NONE ? VALUE_NONE + : v >= VALUE_MATE_IN_MAX_PLY ? v - ply + : v <= VALUE_MATED_IN_MAX_PLY ? v + ply : v; } @@ -1417,26 +1436,14 @@ split_point_start: // At split points actual search starts from here } - // can_return_tt() returns true if a transposition table score can be used to - // cut-off at a given point in search. - - bool can_return_tt(const TTEntry* tte, Depth depth, Value v, Value beta) { - - return ( tte->depth() >= depth - || v >= std::max(VALUE_MATE_IN_MAX_PLY, beta) - || v < std::min(VALUE_MATED_IN_MAX_PLY, beta)) - - && ( ((tte->type() & BOUND_LOWER) && v >= beta) - || ((tte->type() & BOUND_UPPER) && v < beta)); - } - - // refine_eval() returns the transposition table score if possible, otherwise - // falls back on static position evaluation. + // falls back on static position evaluation. Note that we never return VALUE_NONE + // even if v == VALUE_NONE. Value refine_eval(const TTEntry* tte, Value v, Value defaultEval) { assert(tte); + assert(v != VALUE_NONE || !tte->type()); if ( ((tte->type() & BOUND_LOWER) && v >= defaultEval) || ((tte->type() & BOUND_UPPER) && v < defaultEval))