X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=e3030490863f4289df4439ce287a4306bc297262;hp=4139ef96b707afa81baec5e5d19a7fbf2d7a28c9;hb=10184748533195e4a76a7283b9f9048db05c6fc4;hpb=46c01b5083b30855830ffcfe287c448744f787de diff --git a/src/search.cpp b/src/search.cpp index 4139ef96..e3030490 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -91,6 +91,7 @@ namespace { int BestMoveChanges; int SkillLevel; bool SkillLevelEnabled, Chess960; + Value DrawValue[2]; History H; template @@ -104,7 +105,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 +136,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)); } @@ -175,8 +175,6 @@ 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; TimeMgr.init(Limits, pos.startpos_ply_counter(), pos.side_to_move()); TT.new_search(); H.clear(); @@ -190,6 +188,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[ Eval::RootColor] = VALUE_DRAW - Value(cf); + DrawValue[~Eval::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 +524,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 +551,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 +576,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 +588,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 +821,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 +843,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 @@ -1079,7 +1097,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 +1109,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 +1145,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 +1375,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 +1388,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 +1434,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))