From e56342ed002b2d567fbecd2e4432b881f1b244bc Mon Sep 17 00:00:00 2001 From: Marco Costalba Date: Sun, 8 Apr 2012 11:32:01 +0100 Subject: [PATCH 1/1] Shrink castlePath[] and castleRookSquare[] sizes Shrinking from [16] to [2][2] is able to speedup perft of start position of almost 5% ! No functional change. Signed-off-by: Marco Costalba --- src/movegen.cpp | 11 +++-------- src/position.cpp | 49 ++++++++++++++++++++++++------------------------ src/position.h | 18 +++++++++--------- src/types.h | 5 +++++ 4 files changed, 42 insertions(+), 41 deletions(-) diff --git a/src/movegen.cpp b/src/movegen.cpp index 86ab7ac4..ed204672 100644 --- a/src/movegen.cpp +++ b/src/movegen.cpp @@ -32,27 +32,22 @@ (*mlist++).move = make_move(to - (d), to); } namespace { - enum CastlingSide { KING_SIDE, QUEEN_SIDE }; - template MoveStack* generate_castle(const Position& pos, MoveStack* mlist, Color us) { - const CastleRight CR[] = { Side ? WHITE_OOO : WHITE_OO, - Side ? BLACK_OOO : BLACK_OO }; + CastleRight cr = CastleRight((Side == KING_SIDE ? WHITE_OO : WHITE_OOO) << us); - if (pos.castle_impeded(CR[us]) || !pos.can_castle(CR[us])) + if (pos.castle_impeded(us, Side) || !pos.can_castle(cr)) return mlist; // After castling, the rook and king final positions are the same in Chess960 // as they would be in standard chess. Square kfrom = pos.king_square(us); - Square rfrom = pos.castle_rook_square(CR[us]); Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1); + Square rfrom = pos.castle_rook_square(us, Side); Bitboard enemies = pos.pieces(~us); assert(!pos.in_check()); - assert(pos.piece_on(kfrom) == make_piece(us, KING)); - assert(pos.piece_on(rfrom) == make_piece(us, ROOK)); for (Square s = std::min(kfrom, kto), e = std::max(kfrom, kto); s <= e; s++) if ( s != kfrom // We are not in check diff --git a/src/position.cpp b/src/position.cpp index 318f0f2c..60c5380d 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -239,24 +239,24 @@ void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) { void Position::set_castle_right(Color c, Square rfrom) { Square kfrom = king_square(c); - bool kingSide = kfrom < rfrom; - int cr = (kingSide ? WHITE_OO : WHITE_OOO) << c; + CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE; + int cr = (cs == KING_SIDE ? WHITE_OO : WHITE_OOO) << c; st->castleRights |= cr; castleRightsMask[kfrom] |= cr; castleRightsMask[rfrom] |= cr; - castleRookSquare[cr] = rfrom; + castleRookSquare[c][cs] = rfrom; - Square kto = relative_square(c, kingSide ? SQ_G1 : SQ_C1); - Square rto = relative_square(c, kingSide ? SQ_F1 : SQ_D1); + Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1); + Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1); for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++) if (s != kfrom && s != rfrom) - castlePath[cr] |= s; + castlePath[c][cs] |= s; for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++) if (s != kfrom && s != rfrom) - castlePath[cr] |= s; + castlePath[c][cs] |= s; } @@ -300,16 +300,16 @@ const string Position::to_fen() const { fen << (sideToMove == WHITE ? " w " : " b "); if (can_castle(WHITE_OO)) - fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OO))))) : 'K'); + fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE))))) : 'K'); if (can_castle(WHITE_OOO)) - fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OOO))))) : 'Q'); + fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE))))) : 'Q'); if (can_castle(BLACK_OO)) - fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OO))) : 'k'); + fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE))) : 'k'); if (can_castle(BLACK_OOO)) - fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OOO))) : 'q'); + fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE))) : 'q'); if (st->castleRights == CASTLES_NONE) fen << '-'; @@ -1554,13 +1554,13 @@ void Position::flip() { put_piece(Piece(pos.piece_on(s) ^ 8), ~s); if (pos.can_castle(WHITE_OO)) - set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OO)); + set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, KING_SIDE)); if (pos.can_castle(WHITE_OOO)) - set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OOO)); + set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, QUEEN_SIDE)); if (pos.can_castle(BLACK_OO)) - set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OO)); + set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, KING_SIDE)); if (pos.can_castle(BLACK_OOO)) - set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OOO)); + set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, QUEEN_SIDE)); if (pos.st->epSquare != SQ_NONE) st->epSquare = ~pos.st->epSquare; @@ -1726,17 +1726,18 @@ bool Position::pos_is_ok(int* failedStep) const { if (failedStep) (*failedStep)++; if (debugCastleSquares) - for (CastleRight f = WHITE_OO; f <= BLACK_OOO; f = CastleRight(f << 1)) - { - if (!can_castle(f)) - continue; + for (Color c = WHITE; c <= BLACK; c++) + for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s+1)) + { + CastleRight cr = CastleRight((s == KING_SIDE ? WHITE_OO : WHITE_OOO) << c); - Piece rook = (f & (WHITE_OO | WHITE_OOO) ? W_ROOK : B_ROOK); + if (!can_castle(cr)) + continue; - if ( piece_on(castleRookSquare[f]) != rook - || castleRightsMask[castleRookSquare[f]] != f) - return false; - } + if ( piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK) + || castleRightsMask[castleRookSquare[c][s]] != cr) + return false; + } if (failedStep) *failedStep = 0; return true; diff --git a/src/position.h b/src/position.h index 946608c6..8f11a394 100644 --- a/src/position.h +++ b/src/position.h @@ -113,8 +113,8 @@ public: // Castling bool can_castle(CastleRight f) const; bool can_castle(Color c) const; - bool castle_impeded(CastleRight f) const; - Square castle_rook_square(CastleRight f) const; + bool castle_impeded(Color c, CastlingSide s) const; + Square castle_rook_square(Color c, CastlingSide s) const; // Checking bool in_check() const; @@ -213,9 +213,9 @@ private: int index[64]; // [square] // Other info - int castleRightsMask[64]; // [square] - Square castleRookSquare[16]; // [castleRight] - Bitboard castlePath[16]; // [castleRight] + int castleRightsMask[64]; // [square] + Square castleRookSquare[2][2]; // [color][side] + Bitboard castlePath[2][2]; // [color][side] StateInfo startState; int64_t nodes; int startPosPly; @@ -305,12 +305,12 @@ inline bool Position::can_castle(Color c) const { return st->castleRights & ((WHITE_OO | WHITE_OOO) << c); } -inline bool Position::castle_impeded(CastleRight f) const { - return byTypeBB[ALL_PIECES] & castlePath[f]; +inline bool Position::castle_impeded(Color c, CastlingSide s) const { + return byTypeBB[ALL_PIECES] & castlePath[c][s]; } -inline Square Position::castle_rook_square(CastleRight f) const { - return castleRookSquare[f]; +inline Square Position::castle_rook_square(Color c, CastlingSide s) const { + return castleRookSquare[c][s]; } template diff --git a/src/types.h b/src/types.h index ba25ef6e..a9b95a0a 100644 --- a/src/types.h +++ b/src/types.h @@ -136,6 +136,11 @@ enum CastleRight { ALL_CASTLES = 15 }; +enum CastlingSide { + KING_SIDE, + QUEEN_SIDE +}; + enum ScaleFactor { SCALE_FACTOR_DRAW = 0, SCALE_FACTOR_NORMAL = 64, -- 2.39.2