X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovepick.cpp;h=4529af7dd73edcca6a8e887799f129e727a1099b;hp=ee747c94525cdee18b9f78ea585abd3854cd23e8;hb=50f92bed06e6416df4b343b121b1ba66500ab842;hpb=8a0dd93c56f63de467190145116ed6c5cfd54bc1 diff --git a/src/movepick.cpp b/src/movepick.cpp index ee747c94..4529af7d 100644 --- a/src/movepick.cpp +++ b/src/movepick.cpp @@ -1,7 +1,7 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008 Marco Costalba + Copyright (C) 2008-2009 Marco Costalba Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -23,6 +23,7 @@ //// Includes //// +#include #include #include "history.h" @@ -45,14 +46,11 @@ namespace { int MainSearchPhaseIndex; int EvasionsPhaseIndex; int QsearchWithChecksPhaseIndex; - int QsearchNoCapturesPhaseIndex; int QsearchWithoutChecksPhaseIndex; - int NoMovesPhaseIndex; } - //// //// Functions //// @@ -65,39 +63,33 @@ namespace { /// search captures, promotions and some checks) and about how important good /// move ordering is at the current node. -MovePicker::MovePicker(const Position& p, bool pv, Move ttm, - const SearchStack& ss, Depth d, EvalInfo* ei) : pos(p) { - pvNode = pv; +MovePicker::MovePicker(const Position& p, Move ttm, Depth d, + const History& h, SearchStack* ss) : pos(p), H(h) { ttMove = ttm; - mateKiller = (ss.mateKiller == ttm)? MOVE_NONE : ss.mateKiller; - killer1 = ss.killers[0]; - killer2 = ss.killers[1]; - depth = d; - movesPicked = 0; - numOfMoves = 0; - numOfBadCaptures = 0; - - // With EvalInfo we are able to know how many captures are possible before - // generating them. So avoid generating in case we know are zero. - Color us = pos.side_to_move(); - Color them = opposite_color(us); - bool noCaptures = ei - && (ei->attackedBy[us][0] & pos.pieces_of_color(them)) == 0 - && !ei->mi->specialized_eval_exists() - && (pos.ep_square() == SQ_NONE) - && !pos.has_pawn_on_7th(us); + if (ss) + { + mateKiller = (ss->mateKiller == ttm)? MOVE_NONE : ss->mateKiller; + killer1 = ss->killers[0]; + killer2 = ss->killers[1]; + } else + mateKiller = killer1 = killer2 = MOVE_NONE; + + movesPicked = numOfMoves = numOfBadCaptures = 0; + checkKillers = checkLegal = finished = false; if (p.is_check()) phaseIndex = EvasionsPhaseIndex; - else if (depth > Depth(0)) + else if (d > Depth(0)) phaseIndex = MainSearchPhaseIndex; - else if (depth == Depth(0)) - phaseIndex = (noCaptures ? QsearchNoCapturesPhaseIndex : QsearchWithChecksPhaseIndex); + else if (d == Depth(0)) + phaseIndex = QsearchWithChecksPhaseIndex; else - phaseIndex = (noCaptures ? NoMovesPhaseIndex : QsearchWithoutChecksPhaseIndex); + phaseIndex = QsearchWithoutChecksPhaseIndex; + + Color us = pos.side_to_move(); dc = p.discovered_check_candidates(us); - pinned = p.pinned_pieces(p.side_to_move()); + pinned = p.pinned_pieces(us); finished = false; } @@ -141,40 +133,58 @@ Move MovePicker::get_next_move() { assert(move_is_ok(mateKiller)); if (move_is_legal(pos, mateKiller, pinned)) return mateKiller; - } - break; + } + break; case PH_GOOD_CAPTURES: numOfMoves = generate_captures(pos, moves); score_captures(); + std::sort(moves, moves + numOfMoves); movesPicked = 0; break; - case PH_BAD_CAPTURES: - badCapturesPicked = 0; + case PH_KILLERS: + movesPicked = numOfMoves = 0; + if (killer1 != MOVE_NONE && move_is_legal(pos, killer1, pinned) && !pos.move_is_capture(killer1)) + moves[numOfMoves++].move = killer1; + if (killer2 != MOVE_NONE && move_is_legal(pos, killer2, pinned) && !pos.move_is_capture(killer2)) + moves[numOfMoves++].move = killer2; break; case PH_NONCAPTURES: + checkKillers = (numOfMoves != 0); // previous phase is PH_KILLERS + checkLegal = true; numOfMoves = generate_noncaptures(pos, moves); score_noncaptures(); + std::sort(moves, moves + numOfMoves); + movesPicked = 0; + break; + + case PH_BAD_CAPTURES: + // Bad captures SEE value is already calculated so just sort them + // to get SEE move ordering. + std::sort(badCaptures, badCaptures + numOfBadCaptures); movesPicked = 0; break; case PH_EVASIONS: assert(pos.is_check()); - numOfMoves = generate_evasions(pos, moves); + numOfMoves = generate_evasions(pos, moves, pinned); score_evasions(); + std::sort(moves, moves + numOfMoves); movesPicked = 0; break; case PH_QCAPTURES: numOfMoves = generate_captures(pos, moves); - score_qcaptures(); + score_captures(); + std::sort(moves, moves + numOfMoves); movesPicked = 0; break; case PH_QCHECKS: - numOfMoves = generate_checks(pos, moves, dc); + // Perhaps we should order moves move here? FIXME + numOfMoves = generate_non_capture_checks(pos, moves, dc); movesPicked = 0; break; @@ -217,38 +227,28 @@ Move MovePicker::get_next_move(Lock &lock) { void MovePicker::score_captures() { // Winning and equal captures in the main search are ordered by MVV/LVA. // Suprisingly, this appears to perform slightly better than SEE based - // move ordering. The reason is probably that in a position with a winning + // move ordering. The reason is probably that in a position with a winning // capture, capturing a more valuable (but sufficiently defended) piece - // first usually doesn't hurt. The opponent will have to recapture, and + // first usually doesn't hurt. The opponent will have to recapture, and // the hanging piece will still be hanging (except in the unusual cases // where it is possible to recapture with the hanging piece). Exchanging // big pieces before capturing a hanging piece probably helps to reduce // the subtree size. - // While scoring captures it moves all captures with negative SEE values - // to the badCaptures[] array. + // In main search we want to push captures with negative SEE values to + // badCaptures[] array, but instead of doing it now we delay till when + // the move has been picked up in pick_move_from_list(), this way we save + // some SEE calls in case we get a cutoff (idea from Pablo Vazquez). Move m; - int seeValue; + // Use MVV/LVA ordering for (int i = 0; i < numOfMoves; i++) { m = moves[i].move; - seeValue = pos.see(m); - if (seeValue >= 0) - { - if (move_promotion(m)) - moves[i].score = QueenValueMidgame; - else - moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m))) - -int(pos.type_of_piece_on(move_from(m))); - } + if (move_is_promotion(m)) + moves[i].score = QueenValueMidgame; else - { - // Losing capture, move it to the badCaptures[] array - assert(numOfBadCaptures < 63); - moves[i].score = seeValue; - badCaptures[numOfBadCaptures++] = moves[i]; - moves[i--] = moves[--numOfMoves]; - } + moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m))) + -int(pos.type_of_piece_on(move_from(m))); } } @@ -256,25 +256,23 @@ void MovePicker::score_noncaptures() { // First score by history, when no history is available then use // piece/square tables values. This seems to be better then a // random choice when we don't have an history for any move. - Move m; + Piece piece; + Square from, to; int hs; for (int i = 0; i < numOfMoves; i++) { - m = moves[i].move; - - if (m == killer1) - hs = HistoryMax + 2; - else if (m == killer2) - hs = HistoryMax + 1; - else - hs = H.move_ordering_score(pos.piece_on(move_from(m)), m); + from = move_from(moves[i].move); + to = move_to(moves[i].move); + piece = pos.piece_on(from); + hs = H.move_ordering_score(piece, to); - // Ensure moves in history are always sorted as first + // Ensure history is always preferred to pst if (hs > 0) hs += 1000; - moves[i].score = hs + pos.mg_pst_delta(m); + // pst based scoring + moves[i].score = hs + pos.pst_delta(piece, from, to); } } @@ -290,81 +288,10 @@ void MovePicker::score_evasions() { int seeScore = pos.see(m); moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore; } else - moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), m); + moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), move_to(m)); } } -void MovePicker::score_qcaptures() { - - // Use MVV/LVA ordering - for (int i = 0; i < numOfMoves; i++) - { - Move m = moves[i].move; - if (move_promotion(m)) - moves[i].score = QueenValueMidgame; - else - moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m))) - -int(pos.type_of_piece_on(move_from(m))); - } -} - - -/// find_best_index() loops across the moves and returns index of -/// the highest scored one. There is also a second version that -/// lowers the priority of moves that attack the same square, -/// so that if the best move that attack a square fails the next -/// move picked attacks a different square if any, not the same one. - -int MovePicker::find_best_index() { - - int bestScore = -10000000, bestIndex = -1; - - for (int i = movesPicked; i < numOfMoves; i++) - if (moves[i].score > bestScore) - { - bestIndex = i; - bestScore = moves[i].score; - } - return bestIndex; -} - -int MovePicker::find_best_index(Bitboard* squares, int values[]) { - - int hs; - Move m; - Square to; - int bestScore = -10000000, bestIndex = -1; - - for (int i = movesPicked; i < numOfMoves; i++) - { - m = moves[i].move; - to = move_to(m); - - if (!bit_is_set(*squares, to)) - { - // Init at first use - set_bit(squares, to); - values[to] = 0; - } - - hs = moves[i].score - values[to]; - if (hs > bestScore) - { - bestIndex = i; - bestScore = hs; - } - } - - if (bestIndex != -1) - { - // Raise value of the picked square, so next attack - // to the same square will get low priority. - to = move_to(moves[bestIndex].move); - values[to] += 0xB00; - } - return bestIndex; -} - /// MovePicker::pick_move_from_list() picks the move with the biggest score /// from a list of generated moves (moves[] or badCaptures[], depending on @@ -373,115 +300,64 @@ int MovePicker::find_best_index(Bitboard* squares, int values[]) { Move MovePicker::pick_move_from_list() { - int bestIndex; - Move move; + assert(movesPicked >= 0); + assert(!pos.is_check() || PhaseTable[phaseIndex] == PH_EVASIONS || PhaseTable[phaseIndex] == PH_STOP); + assert( pos.is_check() || PhaseTable[phaseIndex] != PH_EVASIONS); switch (PhaseTable[phaseIndex]) { - case PH_GOOD_CAPTURES: - assert(!pos.is_check()); - assert(movesPicked >= 0); + case PH_GOOD_CAPTURES: while (movesPicked < numOfMoves) { - bestIndex = find_best_index(); - - if (bestIndex != -1) // Found a good capture + Move move = moves[movesPicked++].move; + if ( move != ttMove + && move != mateKiller + && pos.pl_move_is_legal(move, pinned)) { - move = moves[bestIndex].move; - moves[bestIndex] = moves[movesPicked++]; - if ( move != ttMove - && move != mateKiller - && pos.pl_move_is_legal(move, pinned)) + // Check for a non negative SEE now + int seeValue = pos.see_sign(move); + if (seeValue >= 0) return move; - } - } - break; - case PH_NONCAPTURES: - assert(!pos.is_check()); - assert(movesPicked >= 0); - - while (movesPicked < numOfMoves) - { - // If this is a PV node or we have only picked a few moves, scan - // the entire move list for the best move. If many moves have already - // been searched and it is not a PV node, we are probably failing low - // anyway, so we just pick the first move from the list. - bestIndex = (pvNode || movesPicked < 12) ? find_best_index() : movesPicked; - - if (bestIndex != -1) - { - move = moves[bestIndex].move; - moves[bestIndex] = moves[movesPicked++]; - if ( move != ttMove - && move != mateKiller - && pos.pl_move_is_legal(move, pinned)) - return move; + // Losing capture, move it to the badCaptures[] array, note + // that move has now been already checked for legality. + assert(numOfBadCaptures < 63); + badCaptures[numOfBadCaptures].move = move; + badCaptures[numOfBadCaptures++].score = seeValue; } } break; - - case PH_EVASIONS: - assert(pos.is_check()); - assert(movesPicked >= 0); - + case PH_KILLERS: + case PH_NONCAPTURES: while (movesPicked < numOfMoves) { - bestIndex = find_best_index(); - - if (bestIndex != -1) - { - move = moves[bestIndex].move; - moves[bestIndex] = moves[movesPicked++]; - return move; - } - } - break; - - case PH_BAD_CAPTURES: - assert(!pos.is_check()); - assert(badCapturesPicked >= 0); - // It's probably a good idea to use SEE move ordering here, instead - // of just picking the first move. FIXME - while (badCapturesPicked < numOfBadCaptures) - { - move = badCaptures[badCapturesPicked++].move; + Move move = moves[movesPicked++].move; if ( move != ttMove && move != mateKiller - && pos.pl_move_is_legal(move, pinned)) + && (!checkKillers || (move != killer1 && move != killer2)) + && (!checkLegal || pos.pl_move_is_legal(move, pinned))) return move; } break; - case PH_QCAPTURES: - assert(!pos.is_check()); - assert(movesPicked >= 0); - while (movesPicked < numOfMoves) - { - bestIndex = (movesPicked < 4 ? find_best_index() : movesPicked); + case PH_EVASIONS: + if (movesPicked < numOfMoves) + return moves[movesPicked++].move; + break; - if (bestIndex != -1) - { - move = moves[bestIndex].move; - moves[bestIndex] = moves[movesPicked++]; - // Remember to change the line below if we decide to hash the qsearch! - // Maybe also postpone the legality check until after futility pruning? - if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned)) - return move; - } - } + case PH_BAD_CAPTURES: + if (movesPicked < numOfBadCaptures) + return badCaptures[movesPicked++].move; break; + case PH_QCAPTURES: case PH_QCHECKS: - assert(!pos.is_check()); - assert(movesPicked >= 0); - // Perhaps we should do something better than just picking the first - // move here? FIXME while (movesPicked < numOfMoves) { - move = moves[movesPicked++].move; - // Remember to change the line below if we decide to hash the qsearch! - if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned)) + Move move = moves[movesPicked++].move; + // Maybe postpone the legality check until after futility pruning? + if ( move != ttMove + && pos.pl_move_is_legal(move, pinned)) return move; } break; @@ -493,20 +369,10 @@ Move MovePicker::pick_move_from_list() { } -/// MovePicker::current_move_type() returns the type of the just -/// picked next move. It can be used in search to further differentiate -/// according to the current move type: capture, non capture, escape, etc. -MovePicker::MovegenPhase MovePicker::current_move_type() const { - - return PhaseTable[phaseIndex]; -} - - /// MovePicker::init_phase_table() initializes the PhaseTable[], /// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex -/// QsearchNoCapturesPhaseIndex, QsearchWithoutChecksPhaseIndex and -/// NoMovesPhaseIndex variables. It is only called once during program -/// startup, and never again while the program is running. +/// and QsearchWithoutChecksPhaseIndex. It is only called once during +/// program startup, and never again while the program is running. void MovePicker::init_phase_table() { @@ -517,9 +383,7 @@ void MovePicker::init_phase_table() { PhaseTable[i++] = PH_TT_MOVE; PhaseTable[i++] = PH_MATE_KILLER; PhaseTable[i++] = PH_GOOD_CAPTURES; - // PH_KILLER_1 and PH_KILLER_2 are not yet used. - // PhaseTable[i++] = PH_KILLER_1; - // PhaseTable[i++] = PH_KILLER_2; + PhaseTable[i++] = PH_KILLERS; PhaseTable[i++] = PH_NONCAPTURES; PhaseTable[i++] = PH_BAD_CAPTURES; PhaseTable[i++] = PH_STOP; @@ -531,21 +395,14 @@ void MovePicker::init_phase_table() { // Quiescence search with checks QsearchWithChecksPhaseIndex = i - 1; + PhaseTable[i++] = PH_TT_MOVE; PhaseTable[i++] = PH_QCAPTURES; PhaseTable[i++] = PH_QCHECKS; PhaseTable[i++] = PH_STOP; - // Quiescence search with checks only and no captures - QsearchNoCapturesPhaseIndex = i - 1; - PhaseTable[i++] = PH_QCHECKS; - PhaseTable[i++] = PH_STOP; - // Quiescence search without checks QsearchWithoutChecksPhaseIndex = i - 1; + PhaseTable[i++] = PH_TT_MOVE; PhaseTable[i++] = PH_QCAPTURES; PhaseTable[i++] = PH_STOP; - - // Do not generate any move - NoMovesPhaseIndex = i - 1; - PhaseTable[i++] = PH_STOP; }