X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=e853b6ee73e2518490c590283ef10b926efea42c;hp=38e445b343d13440803ddd1de84c5182f63d5e0e;hb=dee878082960be198fdb1493940b3d8a2be0bd58;hpb=47f5560e2dccfad9aa64afc7a002ce049b7504d3 diff --git a/src/search.cpp b/src/search.cpp index 38e445b3..e853b6ee 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -84,7 +84,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); @@ -297,8 +297,7 @@ namespace { template Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous); - bool check_is_useless(Position &pos, Move move, Value eval, Value futilityBase, Value beta, Value *bValue); - Bitboard attacks(const Piece P, const Square sq, const Bitboard occ); + bool check_is_dangerous(Position &pos, Move move, Value futilityBase, Value beta, Value *bValue); bool connected_moves(const Position& pos, Move m1, Move m2); bool value_is_mate(Value value); Value value_to_tt(Value v, int ply); @@ -994,7 +993,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; @@ -1007,8 +1007,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 @@ -1146,6 +1148,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; } @@ -1197,7 +1200,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)); @@ -1285,7 +1288,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) @@ -1302,7 +1305,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 { @@ -1314,9 +1317,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; @@ -1368,7 +1373,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; @@ -1377,15 +1382,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; @@ -1404,7 +1409,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); @@ -1420,7 +1425,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 @@ -1469,6 +1474,7 @@ split_point_start: // At split points actual search starts from here Value bestValue, value, evalMargin, futilityValue, futilityBase; bool isCheck, enoughMaterial, moveIsCheck, evasionPrunable; const TTEntry* tte; + Depth ttDepth; Value oldAlpha = alpha; ss->bestMove = ss->currentMove = MOVE_NONE; @@ -1477,21 +1483,18 @@ split_point_start: // At split points actual search starts from here if (pos.is_draw() || ply >= PLY_MAX - 1) return VALUE_DRAW; - // Decide whether or not to include checks + // 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. isCheck = pos.is_check(); - - Depth d; - if (isCheck || depth >= -ONE_PLY) - d = DEPTH_ZERO; - else - d = DEPTH_ZERO - ONE_PLY; + ttDepth = (isCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS : DEPTH_QS_NO_CHECKS); // Transposition table lookup. At PV nodes, we don't use the TT for // pruning, but only for move ordering. tte = TT.retrieve(pos.get_key()); ttMove = (tte ? tte->move() : MOVE_NONE); - if (!PvNode && tte && ok_to_use_TT(tte, d, beta, ply)) + if (!PvNode && tte && ok_to_use_TT(tte, ttDepth, beta, ply)) { ss->bestMove = ttMove; // Can be MOVE_NONE return value_from_tt(tte->value(), ply); @@ -1537,9 +1540,9 @@ split_point_start: // At split points actual search starts from here // 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 == -ONE_PLY - // and we are near beta) will be generated. - MovePicker mp = MovePicker(pos, ttMove, d, H); + // queen promotions and checks (only if depth >= DEPTH_QS_CHECKS) will + // be generated. + MovePicker mp = MovePicker(pos, ttMove, depth, H); CheckInfo ci(pos); // Loop through the moves until no moves remain or a beta cutoff occurs @@ -1588,12 +1591,17 @@ split_point_start: // At split points actual search starts from here // Don't search useless checks if ( !PvNode && !isCheck - && moveIsCheck - && move != ttMove - && !pos.move_is_capture(move) - && !move_is_promotion(move) - && check_is_useless(pos, move, ss->eval, futilityBase, beta, &bestValue)) + && moveIsCheck + && move != ttMove + && !pos.move_is_capture_or_promotion(move) + && ss->eval + PawnValueMidgame / 4 < beta + && !check_is_dangerous(pos, move, futilityBase, beta, &bestValue)) + { + if (ss->eval + PawnValueMidgame / 4 > bestValue) + bestValue = ss->eval + PawnValueMidgame / 4; + continue; + } // Update current move ss->currentMove = move; @@ -1624,101 +1632,70 @@ split_point_start: // At split points actual search starts from here // Update transposition table 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, evalMargin); + TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, ttDepth, ss->bestMove, ss->eval, evalMargin); assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); return bestValue; } - // check_is_useless() tests if a checking move can be pruned in qsearch(). - // bestValue is updated when necesary. - - bool check_is_useless(Position &pos, Move move, Value eval, Value futilityBase, Value beta, Value *bValue) - { - Value bestValue = *bValue; - - /// Rule 1. Using checks to reposition pieces when close to beta - if (eval + PawnValueMidgame / 4 < beta) - { - if (eval + PawnValueMidgame / 4 > bestValue) - bestValue = eval + PawnValueMidgame / 4; - } - else - return false; - - Square from = move_from(move); - Square to = move_to(move); - Color oppColor = opposite_color(pos.side_to_move()); - Square oppKing = pos.king_square(oppColor); - Bitboard occ = pos.occupied_squares() & ~(1ULL << from) & ~(1ULL <(ksq); + pc = pos.piece_on(from); + + occ = pos.occupied_squares() & ~(1ULL << from) & ~(1ULL << ksq); + oldAtt = pos.attacks_from(pc, from, occ); + newAtt = pos.attacks_from(pc, to, occ); + + // Rule 1. Checks which give opponent's king at most one escape square are dangerous + b = kingAtt & ~pos.pieces_of_color(them) & ~newAtt & ~(1ULL << to); + + if (!(b && (b & (b - 1)))) + return true; - /// Rule 3. Queen contact check is very dangerous - if ( pos.type_of_piece_on(from) == QUEEN - && bit_is_set(attacks(WK, oppKing, 0), to)) - return false; + // Rule 2. Queen contact check is very dangerous + if ( type_of_piece(pc) == QUEEN + && bit_is_set(kingAtt, to)) + return true; - /// Rule 4. Creating new double threats with checks - Bitboard newVictims = oppOcc & ~oldAtt & newAtt; + // Rule 3. Creating new double threats with checks + b = pos.pieces_of_color(them) & newAtt & ~oldAtt & ~(1ULL << ksq); - while(newVictims) + while (b) { - Square victimSq = pop_1st_bit(&newVictims); - - Value futilityValue = futilityBase + pos.endgame_value_of_piece_on(victimSq); + victimSq = pop_1st_bit(&b); + futilityValue = futilityBase + pos.endgame_value_of_piece_on(victimSq); // Note that here we generate illegal "double move"! - if (futilityValue >= beta && pos.see_sign(make_move(from, victimSq)) >= 0) - return false; + if ( futilityValue >= beta + && pos.see_sign(make_move(from, victimSq)) >= 0) + return true; - if (futilityValue > bestValue) - bestValue = futilityValue; + if (futilityValue > bv) + bv = futilityValue; } - *bValue = bestValue; - return true; + // Update bestValue only if check is not dangerous (because we will prune the move) + *bestValue = bv; + return false; } - // attacks() returns attacked squares. - - Bitboard attacks(const Piece P, const Square sq, const Bitboard occ) - { - switch(P) - { - case WP: - case BP: - case WN: - case BN: - case WK: - case BK: - return StepAttackBB[P][sq]; - case WB: - case BB: - return bishop_attacks_bb(sq, occ); - case WR: - case BR: - return rook_attacks_bb(sq, occ); - case WQ: - case BQ: - return bishop_attacks_bb(sq, occ) | rook_attacks_bb(sq, occ); - default: - assert(false); - return 0ULL; - } - } // connected_moves() tests whether two moves are 'connected' in the sense // that the first move somehow made the second move possible (for instance @@ -1731,11 +1708,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); @@ -2494,17 +2468,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; } @@ -2603,7 +2577,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;