From 5ba85ef441fb12738732824092f74aa49149fcf9 Mon Sep 17 00:00:00 2001 From: Marco Costalba Date: Sat, 16 Apr 2011 11:24:30 +0100 Subject: [PATCH 1/1] Remove one indentation level in get_next_move() Small renaming and fix some comments. No functional and no speed change. Signed-off-by: Marco Costalba --- src/movegen.h | 1 + src/movepick.cpp | 188 +++++++++++++++++++++++------------------------ src/movepick.h | 11 +-- 3 files changed, 99 insertions(+), 101 deletions(-) diff --git a/src/movegen.h b/src/movegen.h index 32fae483..6a04248a 100644 --- a/src/movegen.h +++ b/src/movegen.h @@ -20,6 +20,7 @@ #if !defined(MOVEGEN_H_INCLUDED) #define MOVEGEN_H_INCLUDED +#include "move.h" #include "position.h" enum MoveType { diff --git a/src/movepick.cpp b/src/movepick.cpp index 95310bd8..c6c25d7b 100644 --- a/src/movepick.cpp +++ b/src/movepick.cpp @@ -20,7 +20,6 @@ #include -#include "history.h" #include "movegen.h" #include "movepick.h" #include "search.h" @@ -29,22 +28,22 @@ namespace { enum MovegenPhase { - PH_TT_MOVES, // Transposition table move and mate killer - PH_GOOD_CAPTURES, // Queen promotions and captures with SEE values >= 0 - PH_KILLERS, // Killer moves from the current ply - PH_NONCAPTURES, // Non-captures and underpromotions - PH_BAD_CAPTURES, // Queen promotions and captures with SEE values < 0 - PH_EVASIONS, // Check evasions - PH_QCAPTURES, // Captures in quiescence search - PH_QCHECKS, // Non-capture checks in quiescence search + PH_TT_MOVES, // Transposition table move and mate killer + PH_GOOD_CAPTURES, // Queen promotions and captures with SEE values >= 0 + PH_KILLERS, // Killer moves from the current ply + PH_NONCAPTURES, // Non-captures and underpromotions + PH_BAD_CAPTURES, // Queen promotions and captures with SEE values < 0 + PH_EVASIONS, // Check evasions + PH_QCAPTURES, // Captures in quiescence search + PH_QCHECKS, // Non-capture checks in quiescence search PH_STOP }; CACHE_LINE_ALIGNMENT - const uint8_t MainSearchPhaseTable[] = { PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP}; - const uint8_t EvasionsPhaseTable[] = { PH_TT_MOVES, PH_EVASIONS, PH_STOP}; - const uint8_t QsearchWithChecksPhaseTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_QCHECKS, PH_STOP}; - const uint8_t QsearchWithoutChecksPhaseTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_STOP}; + const uint8_t MainSearchTable[] = { PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP }; + const uint8_t EvasionTable[] = { PH_TT_MOVES, PH_EVASIONS, PH_STOP }; + const uint8_t QsearchWithChecksTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_QCHECKS, PH_STOP }; + const uint8_t QsearchWithoutChecksTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_STOP }; } @@ -69,7 +68,7 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h, if (p.is_check()) { ttMoves[1].move = killers[0].move = killers[1].move = MOVE_NONE; - phasePtr = EvasionsPhaseTable; + phasePtr = EvasionTable; } else { @@ -83,7 +82,7 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h, if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * ONE_PLY) badCaptureThreshold = -PawnValueMidgame; - phasePtr = MainSearchPhaseTable; + phasePtr = MainSearchTable; } phasePtr += int(!searchTT) - 1; @@ -101,12 +100,12 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h) pinned = p.pinned_pieces(pos.side_to_move()); if (p.is_check()) - phasePtr = EvasionsPhaseTable; + phasePtr = EvasionTable; else if (d >= DEPTH_QS_CHECKS) - phasePtr = QsearchWithChecksPhaseTable; + phasePtr = QsearchWithChecksTable; else { - phasePtr = QsearchWithoutChecksPhaseTable; + phasePtr = QsearchWithoutChecksTable; // Skip TT move if is not a capture or a promotion, this avoids // qsearch tree explosion due to a possible perpetual check or @@ -173,7 +172,7 @@ void MovePicker::go_next_phase() { return; case PH_STOP: - lastMove = curMove + 1; // Avoids another go_next_phase() call + lastMove = curMove + 1; // Avoid another go_next_phase() call return; default: @@ -259,11 +258,10 @@ void MovePicker::score_evasions() { /// MovePicker::get_next_move() is the most important method of the MovePicker /// class. It returns a new legal move every time it is called, until there -/// are no more moves left. -/// It picks the move with the biggest score from a list of generated moves taking -/// care not to return the tt move if has already been searched previously. -/// Note that this function is not thread safe so should be lock protected by -/// caller when accessed through a shared MovePicker object. +/// are no more moves left. It picks the move with the biggest score from a list +/// of generated moves taking care not to return the tt move if has already been +/// searched previously. Note that this function is not thread safe so should be +/// lock protected by caller when accessed through a shared MovePicker object. Move MovePicker::get_next_move() { @@ -271,87 +269,85 @@ Move MovePicker::get_next_move() { while (true) { - while (curMove != lastMove) - { - switch (phase) { - - case PH_TT_MOVES: - move = (curMove++)->move; - if ( move != MOVE_NONE - && pos.move_is_legal(move, pinned)) - return move; - break; - - case PH_GOOD_CAPTURES: - move = pick_best(curMove++, lastMove).move; - if ( move != ttMoves[0].move - && move != ttMoves[1].move - && pos.pl_move_is_legal(move, pinned)) - { - // Check for a non negative SEE now - int seeValue = pos.see_sign(move); - if (seeValue >= badCaptureThreshold) - return move; - - // Losing capture, move it to the tail of the array, note - // that move has now been already checked for legality. - (--badCaptures)->move = move; - badCaptures->score = seeValue; - } - break; - - case PH_KILLERS: - move = (curMove++)->move; - if ( move != MOVE_NONE - && pos.move_is_legal(move, pinned) - && move != ttMoves[0].move - && move != ttMoves[1].move - && !pos.move_is_capture(move)) - return move; - break; - - case PH_NONCAPTURES: + while (curMove == lastMove) + go_next_phase(); - // Sort negative scored moves only when we get there - if (curMove == lastGoodNonCapture) - insertion_sort(lastGoodNonCapture, lastMove); + switch (phase) { - move = (curMove++)->move; - if ( move != ttMoves[0].move - && move != ttMoves[1].move - && move != killers[0].move - && move != killers[1].move - && pos.pl_move_is_legal(move, pinned)) + case PH_TT_MOVES: + move = (curMove++)->move; + if ( move != MOVE_NONE + && pos.move_is_legal(move, pinned)) + return move; + break; + + case PH_GOOD_CAPTURES: + move = pick_best(curMove++, lastMove).move; + if ( move != ttMoves[0].move + && move != ttMoves[1].move + && pos.pl_move_is_legal(move, pinned)) + { + // Check for a non negative SEE now + int seeValue = pos.see_sign(move); + if (seeValue >= badCaptureThreshold) return move; - break; - case PH_BAD_CAPTURES: - move = pick_best(curMove++, lastMove).move; + // Losing capture, move it to the tail of the array, note + // that move has now been already checked for legality. + (--badCaptures)->move = move; + badCaptures->score = seeValue; + } + break; + + case PH_KILLERS: + move = (curMove++)->move; + if ( move != MOVE_NONE + && pos.move_is_legal(move, pinned) + && move != ttMoves[0].move + && move != ttMoves[1].move + && !pos.move_is_capture(move)) + return move; + break; + + case PH_NONCAPTURES: + // Sort negative scored moves only when we get there + if (curMove == lastGoodNonCapture) + insertion_sort(lastGoodNonCapture, lastMove); + + move = (curMove++)->move; + if ( move != ttMoves[0].move + && move != ttMoves[1].move + && move != killers[0].move + && move != killers[1].move + && pos.pl_move_is_legal(move, pinned)) return move; + break; - case PH_EVASIONS: - case PH_QCAPTURES: - move = pick_best(curMove++, lastMove).move; - if ( move != ttMoves[0].move - && pos.pl_move_is_legal(move, pinned)) - return move; - break; + case PH_BAD_CAPTURES: + move = pick_best(curMove++, lastMove).move; + return move; - case PH_QCHECKS: - move = (curMove++)->move; - if ( move != ttMoves[0].move - && pos.pl_move_is_legal(move, pinned)) - return move; - break; + case PH_EVASIONS: + case PH_QCAPTURES: + move = pick_best(curMove++, lastMove).move; + if ( move != ttMoves[0].move + && pos.pl_move_is_legal(move, pinned)) + return move; + break; - case PH_STOP: - return MOVE_NONE; + case PH_QCHECKS: + move = (curMove++)->move; + if ( move != ttMoves[0].move + && pos.pl_move_is_legal(move, pinned)) + return move; + break; - default: - assert(false); - break; - } + case PH_STOP: + return MOVE_NONE; + + default: + assert(false); + break; } - go_next_phase(); } } diff --git a/src/movepick.h b/src/movepick.h index 04e5fb5e..adae851d 100644 --- a/src/movepick.h +++ b/src/movepick.h @@ -21,6 +21,7 @@ #define MOVEPICK_H_INCLUDED #include "history.h" +#include "move.h" #include "position.h" #include "types.h" @@ -29,18 +30,18 @@ struct SearchStack; /// MovePicker is a class which is used to pick one legal move at a time from /// the current position. It is initialized with a Position object and a few /// moves we have reason to believe are good. The most important method is -/// MovePicker::pick_next_move(), which returns a new legal move each time it +/// MovePicker::get_next_move(), which returns a new legal move each time it /// is called, until there are no legal moves left, when MOVE_NONE is returned. /// In order to improve the efficiency of the alpha beta algorithm, MovePicker -/// attempts to return the moves which are most likely to be strongest first. +/// attempts to return the moves which are most likely to get a cut-off first. class MovePicker { - MovePicker& operator=(const MovePicker&); // silence a warning under MSVC + MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC public: - MovePicker(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss, Value beta); - MovePicker(const Position& p, Move ttm, Depth d, const History& h); + MovePicker(const Position&, Move, Depth, const History&, SearchStack*, Value); + MovePicker(const Position&, Move, Depth, const History&); Move get_next_move(); private: -- 2.39.2