1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-05-02 01:29:36 +00:00

Last round of search.cpp cleanup

The most interesting thing is a bit of rewrite
and semplification in connected_moves()

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2010-01-04 12:39:13 +01:00
parent 0e15b0f1d3
commit 721d557681
2 changed files with 107 additions and 138 deletions

View file

@ -339,7 +339,7 @@ void Position::copy(const Position& pos) {
/// king) pieces for the given color and for the given pinner type. Or, when /// king) pieces for the given color and for the given pinner type. Or, when
/// template parameter FindPinned is false, the pieces of the given color /// template parameter FindPinned is false, the pieces of the given color
/// candidate for a discovery check against the enemy king. /// candidate for a discovery check against the enemy king.
/// Note that checkersBB bitboard must be already updated. /// Bitboard checkersBB must be already updated when looking for pinners.
template<bool FindPinned> template<bool FindPinned>
Bitboard Position::hidden_checkers(Color c) const { Bitboard Position::hidden_checkers(Color c) const {
@ -373,7 +373,8 @@ Bitboard Position::hidden_checkers(Color c) const {
/// Position:pinned_pieces() returns a bitboard of all pinned (against the /// Position:pinned_pieces() returns a bitboard of all pinned (against the
/// king) pieces for the given color. /// king) pieces for the given color. Note that checkersBB bitboard must
/// be already updated.
Bitboard Position::pinned_pieces(Color c) const { Bitboard Position::pinned_pieces(Color c) const {
@ -383,7 +384,8 @@ Bitboard Position::pinned_pieces(Color c) const {
/// Position:discovered_check_candidates() returns a bitboard containing all /// Position:discovered_check_candidates() returns a bitboard containing all
/// pieces for the given side which are candidates for giving a discovered /// pieces for the given side which are candidates for giving a discovered
/// check. /// check. Contrary to pinned_pieces() here there is no need of checkersBB
/// to be already updated.
Bitboard Position::discovered_check_candidates(Color c) const { Bitboard Position::discovered_check_candidates(Color c) const {

View file

@ -94,8 +94,16 @@ namespace {
struct RootMove { struct RootMove {
RootMove(); RootMove() { nodes = cumulativeNodes = ourBeta = theirBeta = 0ULL; }
bool operator<(const RootMove&) const; // Used to sort
// RootMove::operator<() is the comparison function used when
// sorting the moves. A move m1 is considered to be better
// than a move m2 if it has a higher score, or if the moves
// have equal score but m1 has the higher node count.
bool RootMove::operator<(const RootMove& m) const {
return score != m.score ? score < m.score : theirBeta <= m.theirBeta;
}
Move move; Move move;
Value score; Value score;
@ -111,16 +119,18 @@ namespace {
public: public:
RootMoveList(Position& pos, Move searchMoves[]); RootMoveList(Position& pos, Move searchMoves[]);
inline Move get_move(int moveNum) const;
inline Value get_move_score(int moveNum) const; int move_count() const { return count; }
inline void set_move_score(int moveNum, Value score); Move get_move(int moveNum) const { return moves[moveNum].move; }
inline void set_move_nodes(int moveNum, int64_t nodes); Value get_move_score(int moveNum) const { return moves[moveNum].score; }
inline void set_beta_counters(int moveNum, int64_t our, int64_t their); void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; }
Move get_move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
int64_t get_move_cumulative_nodes(int moveNum) const { return moves[moveNum].cumulativeNodes; }
void set_move_nodes(int moveNum, int64_t nodes);
void set_beta_counters(int moveNum, int64_t our, int64_t their);
void set_move_pv(int moveNum, const Move pv[]); void set_move_pv(int moveNum, const Move pv[]);
inline Move get_move_pv(int moveNum, int i) const; void sort();
inline int64_t get_move_cumulative_nodes(int moveNum) const;
inline int move_count() const;
inline void sort();
void sort_multipv(int n); void sort_multipv(int n);
private: private:
@ -166,12 +176,6 @@ namespace {
// evaluation of the position is more than NullMoveMargin below beta. // evaluation of the position is more than NullMoveMargin below beta.
const Value NullMoveMargin = Value(0x300); const Value NullMoveMargin = Value(0x300);
// Pruning criterions. See the code and comments in ok_to_prune() to
// understand their precise meaning.
const bool PruneEscapeMoves = false;
const bool PruneDefendingMoves = false;
const bool PruneBlockingMoves = false;
// If the TT move is at least SingleReplyMargin better then the // If the TT move is at least SingleReplyMargin better then the
// remaining ones we will extend it. // remaining ones we will extend it.
const Value SingleReplyMargin = Value(0x20); const Value SingleReplyMargin = Value(0x20);
@ -284,7 +288,7 @@ namespace {
bool ok_to_do_nullmove(const Position& pos); bool ok_to_do_nullmove(const Position& pos);
bool ok_to_prune(const Position& pos, Move m, Move threat); bool ok_to_prune(const Position& pos, Move m, Move threat);
bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply); bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
void update_history(const Position& pos, Move m, Depth depth, Move movesSearched[], int moveCount); void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount);
void update_killers(Move m, SearchStack& ss); void update_killers(Move m, SearchStack& ss);
bool fail_high_ply_1(); bool fail_high_ply_1();
@ -2080,30 +2084,9 @@ namespace {
} }
/// The RootMove class
// Constructor
RootMove::RootMove() {
nodes = cumulativeNodes = ourBeta = theirBeta = 0ULL;
}
// RootMove::operator<() is the comparison function used when
// sorting the moves. A move m1 is considered to be better
// than a move m2 if it has a higher score, or if the moves
// have equal score but m1 has the higher node count.
bool RootMove::operator<(const RootMove& m) const {
if (score != m.score)
return (score < m.score);
return theirBeta <= m.theirBeta;
}
/// The RootMoveList class /// The RootMoveList class
// Constructor // RootMoveList c'tor
RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) : count(0) { RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) : count(0) {
@ -2141,56 +2124,37 @@ namespace {
} }
// Simple accessor methods for the RootMoveList class // RootMoveList simple methods definitions
inline Move RootMoveList::get_move(int moveNum) const {
return moves[moveNum].move;
}
inline Value RootMoveList::get_move_score(int moveNum) const {
return moves[moveNum].score;
}
inline void RootMoveList::set_move_score(int moveNum, Value score) {
moves[moveNum].score = score;
}
inline void RootMoveList::set_move_nodes(int moveNum, int64_t nodes) { inline void RootMoveList::set_move_nodes(int moveNum, int64_t nodes) {
moves[moveNum].nodes = nodes; moves[moveNum].nodes = nodes;
moves[moveNum].cumulativeNodes += nodes; moves[moveNum].cumulativeNodes += nodes;
} }
inline void RootMoveList::set_beta_counters(int moveNum, int64_t our, int64_t their) { inline void RootMoveList::set_beta_counters(int moveNum, int64_t our, int64_t their) {
moves[moveNum].ourBeta = our; moves[moveNum].ourBeta = our;
moves[moveNum].theirBeta = their; moves[moveNum].theirBeta = their;
} }
void RootMoveList::set_move_pv(int moveNum, const Move pv[]) { void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
int j; int j;
for (j = 0; pv[j] != MOVE_NONE; j++) for (j = 0; pv[j] != MOVE_NONE; j++)
moves[moveNum].pv[j] = pv[j]; moves[moveNum].pv[j] = pv[j];
moves[moveNum].pv[j] = MOVE_NONE; moves[moveNum].pv[j] = MOVE_NONE;
} }
inline Move RootMoveList::get_move_pv(int moveNum, int i) const {
return moves[moveNum].pv[i];
}
inline int64_t RootMoveList::get_move_cumulative_nodes(int moveNum) const {
return moves[moveNum].cumulativeNodes;
}
inline int RootMoveList::move_count() const {
return count;
}
// RootMoveList::sort() sorts the root move list at the beginning of a new // RootMoveList::sort() sorts the root move list at the beginning of a new
// iteration. // iteration.
inline void RootMoveList::sort() { inline void RootMoveList::sort() {
sort_multipv(count - 1); // all items sort_multipv(count - 1); // Sort all items
} }
@ -2200,20 +2164,22 @@ namespace {
void RootMoveList::sort_multipv(int n) { void RootMoveList::sort_multipv(int n) {
for (int i = 1; i <= n; i++) int i,j;
for (i = 1; i <= n; i++)
{ {
RootMove rm = moves[i]; RootMove rm = moves[i];
int j; for (j = i; j > 0 && moves[j - 1] < rm; j--)
for (j = i; j > 0 && moves[j-1] < rm; j--) moves[j] = moves[j - 1];
moves[j] = moves[j-1];
moves[j] = rm; moves[j] = rm;
} }
} }
// init_node() is called at the beginning of all the search functions // init_node() is called at the beginning of all the search functions
// (search(), search_pv(), qsearch(), and so on) and initializes the search // (search(), search_pv(), qsearch(), and so on) and initializes the
// stack object corresponding to the current node. Once every // search stack object corresponding to the current node. Once every
// NodesBetweenPolls nodes, init_node() also calls poll(), which polls // NodesBetweenPolls nodes, init_node() also calls poll(), which polls
// for user input and checks whether it is time to stop the search. // for user input and checks whether it is time to stop the search.
@ -2234,48 +2200,56 @@ namespace {
} }
} }
ss[ply].init(ply); ss[ply].init(ply);
ss[ply+2].initKillers(); ss[ply + 2].initKillers();
if (Threads[threadID].printCurrentLine) if (Threads[threadID].printCurrentLine)
print_current_line(ss, ply, threadID); print_current_line(ss, ply, threadID);
} }
// update_pv() is called whenever a search returns a value > alpha. It // update_pv() is called whenever a search returns a value > alpha.
// updates the PV in the SearchStack object corresponding to the current // It updates the PV in the SearchStack object corresponding to the
// node. // current node.
void update_pv(SearchStack ss[], int ply) { void update_pv(SearchStack ss[], int ply) {
assert(ply >= 0 && ply < PLY_MAX); assert(ply >= 0 && ply < PLY_MAX);
ss[ply].pv[ply] = ss[ply].currentMove;
int p; int p;
for (p = ply + 1; ss[ply+1].pv[p] != MOVE_NONE; p++)
ss[ply].pv[p] = ss[ply+1].pv[p]; ss[ply].pv[ply] = ss[ply].currentMove;
for (p = ply + 1; ss[ply + 1].pv[p] != MOVE_NONE; p++)
ss[ply].pv[p] = ss[ply + 1].pv[p];
ss[ply].pv[p] = MOVE_NONE; ss[ply].pv[p] = MOVE_NONE;
} }
// sp_update_pv() is a variant of update_pv for use at split points. The // sp_update_pv() is a variant of update_pv for use at split points. The
// difference between the two functions is that sp_update_pv also updates // difference between the two functions is that sp_update_pv also updates
// the PV at the parent node. // the PV at the parent node.
void sp_update_pv(SearchStack* pss, SearchStack ss[], int ply) { void sp_update_pv(SearchStack* pss, SearchStack ss[], int ply) {
assert(ply >= 0 && ply < PLY_MAX); assert(ply >= 0 && ply < PLY_MAX);
ss[ply].pv[ply] = pss[ply].pv[ply] = ss[ply].currentMove;
int p; int p;
for (p = ply + 1; ss[ply+1].pv[p] != MOVE_NONE; p++)
ss[ply].pv[p] = pss[ply].pv[p] = ss[ply+1].pv[p]; ss[ply].pv[ply] = pss[ply].pv[ply] = ss[ply].currentMove;
for (p = ply + 1; ss[ply + 1].pv[p] != MOVE_NONE; p++)
ss[ply].pv[p] = pss[ply].pv[p] = ss[ply + 1].pv[p];
ss[ply].pv[p] = pss[ply].pv[p] = MOVE_NONE; ss[ply].pv[p] = pss[ply].pv[p] = MOVE_NONE;
} }
// connected_moves() tests whether two moves are 'connected' in the sense // connected_moves() tests whether two moves are 'connected' in the sense
// that the first move somehow made the second move possible (for instance // that the first move somehow made the second move possible (for instance
// if the moving piece is the same in both moves). The first move is // if the moving piece is the same in both moves). The first move is assumed
// assumed to be the move that was made to reach the current position, while // to be the move that was made to reach the current position, while the
// the second move is assumed to be a move from the current position. // second move is assumed to be a move from the current position.
bool connected_moves(const Position& pos, Move m1, Move m2) { bool connected_moves(const Position& pos, Move m1, Move m2) {
@ -2305,36 +2279,23 @@ namespace {
&& bit_is_set(squares_between(f2, t2), f1)) && bit_is_set(squares_between(f2, t2), f1))
return true; return true;
// Case 4: The destination square for m2 is attacked by the moving piece in m1 // Case 4: The destination square for m2 is defended by the moving piece in m1
p = pos.piece_on(t1); p = pos.piece_on(t1);
if (bit_is_set(pos.attacks_from(p, t1), t2)) if (bit_is_set(pos.attacks_from(p, t1), t2))
return true; return true;
// Case 5: Discovered check, checking piece is the piece moved in m1 // Case 5: Discovered check, checking piece is the piece moved in m1
if ( piece_is_slider(p) if ( piece_is_slider(p)
&& bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())), f2) && bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())), f2)
&& !bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())), t2)) && !bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())), t2))
{ {
Bitboard occ = pos.occupied_squares(); // discovered_check_candidates() works also if the Position's side to
Color us = pos.side_to_move(); // move is the opposite of the checking piece.
Square ksq = pos.king_square(us); Color them = opposite_color(pos.side_to_move());
clear_bit(&occ, f2); Bitboard dcCandidates = pos.discovered_check_candidates(them);
if (type_of_piece(p) == BISHOP)
{ if (bit_is_set(dcCandidates, f2))
if (bit_is_set(bishop_attacks_bb(ksq, occ), t1)) return true;
return true;
}
else if (type_of_piece(p) == ROOK)
{
if (bit_is_set(rook_attacks_bb(ksq, occ), t1))
return true;
}
else
{
assert(type_of_piece(p) == QUEEN);
if (bit_is_set(queen_attacks_bb(ksq, occ), t1))
return true;
}
} }
return false; return false;
} }
@ -2367,7 +2328,7 @@ namespace {
// extension() decides whether a move should be searched with normal depth, // extension() decides whether a move should be searched with normal depth,
// or with extended depth. Certain classes of moves (checking moves, in // or with extended depth. Certain classes of moves (checking moves, in
// particular) are searched with bigger depth than ordinary moves and in // particular) are searched with bigger depth than ordinary moves and in
// any case are marked as 'dangerous'. Note that also if a move is not // any case are marked as 'dangerous'. Note that also if a move is not
// extended, as example because the corresponding UCI option is set to zero, // extended, as example because the corresponding UCI option is set to zero,
@ -2433,11 +2394,11 @@ namespace {
// ok_to_do_nullmove() looks at the current position and decides whether // ok_to_do_nullmove() looks at the current position and decides whether
// doing a 'null move' should be allowed. In order to avoid zugzwang // doing a 'null move' should be allowed. In order to avoid zugzwang
// problems, null moves are not allowed when the side to move has very // problems, null moves are not allowed when the side to move has very
// little material left. Currently, the test is a bit too simple: Null // little material left. Currently, the test is a bit too simple: Null
// moves are avoided only when the side to move has only pawns left. It's // moves are avoided only when the side to move has only pawns left.
// probably a good idea to avoid null moves in at least some more // It's probably a good idea to avoid null moves in at least some more
// complicated endgames, e.g. KQ vs KR. FIXME // complicated endgames, e.g. KQ vs KR. FIXME
bool ok_to_do_nullmove(const Position& pos) { bool ok_to_do_nullmove(const Position& pos) {
@ -2446,7 +2407,7 @@ namespace {
} }
// ok_to_prune() tests whether it is safe to forward prune a move. Only // ok_to_prune() tests whether it is safe to forward prune a move. Only
// non-tactical moves late in the move list close to the leaves are // non-tactical moves late in the move list close to the leaves are
// candidates for pruning. // candidates for pruning.
@ -2460,6 +2421,11 @@ namespace {
Square mfrom, mto, tfrom, tto; Square mfrom, mto, tfrom, tto;
// Prune if there isn't any threat move and
// is not a castling move (common case).
if (threat == MOVE_NONE && !move_is_castle(m))
return true;
mfrom = move_from(m); mfrom = move_from(m);
mto = move_to(m); mto = move_to(m);
tfrom = move_from(threat); tfrom = move_from(threat);
@ -2470,14 +2436,12 @@ namespace {
return false; return false;
// Case 2: Don't prune moves which move the threatened piece // Case 2: Don't prune moves which move the threatened piece
if (!PruneEscapeMoves && threat != MOVE_NONE && mfrom == tto) if (mfrom == tto)
return false; return false;
// Case 3: If the threatened piece has value less than or equal to the // Case 3: If the threatened piece has value less than or equal to the
// value of the threatening piece, don't prune move which defend it. // value of the threatening piece, don't prune move which defend it.
if ( !PruneDefendingMoves if ( pos.move_is_capture(threat)
&& threat != MOVE_NONE
&& pos.move_is_capture(threat)
&& ( pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto) && ( pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto)
|| pos.type_of_piece_on(tfrom) == KING) || pos.type_of_piece_on(tfrom) == KING)
&& pos.move_attacks_square(m, tto)) && pos.move_attacks_square(m, tto))
@ -2485,9 +2449,7 @@ namespace {
// Case 4: If the moving piece in the threatened move is a slider, don't // Case 4: If the moving piece in the threatened move is a slider, don't
// prune safe moves which block its ray. // prune safe moves which block its ray.
if ( !PruneBlockingMoves if ( piece_is_slider(pos.piece_on(tfrom))
&& threat != MOVE_NONE
&& piece_is_slider(pos.piece_on(tfrom))
&& bit_is_set(squares_between(tfrom, tto), mto) && bit_is_set(squares_between(tfrom, tto), mto)
&& pos.see_sign(m) >= 0) && pos.see_sign(m) >= 0)
return false; return false;
@ -2515,16 +2477,21 @@ namespace {
// update_history() registers a good move that produced a beta-cutoff // update_history() registers a good move that produced a beta-cutoff
// in history and marks as failures all the other moves of that ply. // in history and marks as failures all the other moves of that ply.
void update_history(const Position& pos, Move m, Depth depth, void update_history(const Position& pos, Move move, Depth depth,
Move movesSearched[], int moveCount) { Move movesSearched[], int moveCount) {
H.success(pos.piece_on(move_from(m)), move_to(m), depth); Move m;
H.success(pos.piece_on(move_from(move)), move_to(move), depth);
for (int i = 0; i < moveCount - 1; i++) for (int i = 0; i < moveCount - 1; i++)
{ {
assert(m != movesSearched[i]); m = movesSearched[i];
if (!pos.move_is_capture_or_promotion(movesSearched[i]))
H.failure(pos.piece_on(move_from(movesSearched[i])), move_to(movesSearched[i]), depth); assert(m != move);
if (!pos.move_is_capture_or_promotion(m))
H.failure(pos.piece_on(move_from(m)), move_to(m), depth);
} }
} }
@ -2546,7 +2513,7 @@ namespace {
// fail_high_ply_1() checks if some thread is currently resolving a fail // fail_high_ply_1() checks if some thread is currently resolving a fail
// high at ply 1 at the node below the first root node. This information // high at ply 1 at the node below the first root node. This information
// is used for time managment. // is used for time management.
bool fail_high_ply_1() { bool fail_high_ply_1() {
@ -2770,8 +2737,8 @@ namespace {
if (AllThreadsShouldExit && threadID != 0) if (AllThreadsShouldExit && threadID != 0)
break; break;
// If we are not thinking, wait for a condition to be signaled instead // If we are not thinking, wait for a condition to be signaled
// of wasting CPU time polling for work. // instead of wasting CPU time polling for work.
while (threadID != 0 && (Idle || threadID >= ActiveThreads)) while (threadID != 0 && (Idle || threadID >= ActiveThreads))
{ {
@ -2835,7 +2802,7 @@ namespace {
// thread_should_stop() checks whether the thread with a given threadID has // thread_should_stop() checks whether the thread with a given threadID has
// been asked to stop, directly or indirectly. This can happen if a beta // been asked to stop, directly or indirectly. This can happen if a beta
// cutoff has occured in the thread's currently active split point, or in // cutoff has occurred in the thread's currently active split point, or in
// some ancestor of the current split point. // some ancestor of the current split point.
bool thread_should_stop(int threadID) { bool thread_should_stop(int threadID) {
@ -2883,7 +2850,7 @@ namespace {
if (ActiveThreads == 2) if (ActiveThreads == 2)
return true; return true;
// Apply the "helpful master" concept if possible. // Apply the "helpful master" concept if possible
if (SplitPointStack[slave][Threads[slave].activeSplitPoints - 1].slaves[master]) if (SplitPointStack[slave][Threads[slave].activeSplitPoints - 1].slaves[master])
return true; return true;