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 <mcostalba@gmail.com>

src/movegen.cpp

@@ -32,27 +32,22 @@
                                          (*mlist++).move = make_move(to - (d), to); }
 namespace {
 
-  enum CastlingSide { KING_SIDE, QUEEN_SIDE };
-
   template<CastlingSide Side, bool OnlyChecks>
   MoveStack* generate_castle(const Position& pos, MoveStack* mlist, Color us) {
 
-    const CastleRight CR[] = { Side ? WHITE_OOO : WHITE_OO,
+    CastleRight cr = CastleRight((Side == KING_SIDE ? WHITE_OO : WHITE_OOO) << us);
-                               Side ? BLACK_OOO : BLACK_OO };
 
-    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

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;
+  CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
-  int cr = (kingSide ? WHITE_OO : WHITE_OOO) << c;
+  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 kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
-  Square rto = relative_square(c, kingSide ? SQ_F1 : SQ_D1);
+  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))
+      for (Color c = WHITE; c <= BLACK; c++)
-      {
+          for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s+1))
-          if (!can_castle(f))
+          {
-              continue;
+              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
+              if (   piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK)
-              || castleRightsMask[castleRookSquare[f]] != f)
+                  || castleRightsMask[castleRookSquare[c][s]] != cr)
-              return false;
+                  return false;
-      }
+          }
 
   if (failedStep) *failedStep = 0;
   return true;

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;
+  bool castle_impeded(Color c, CastlingSide s) const;
-  Square castle_rook_square(CastleRight f) 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]
+  int castleRightsMask[64];      // [square]
-  Square castleRookSquare[16]; // [castleRight]
+  Square castleRookSquare[2][2]; // [color][side]
-  Bitboard castlePath[16];     // [castleRight]
+  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 {
+inline bool Position::castle_impeded(Color c, CastlingSide s) const {
-  return byTypeBB[ALL_PIECES] & castlePath[f];
+  return byTypeBB[ALL_PIECES] & castlePath[c][s];
 }
 
-inline Square Position::castle_rook_square(CastleRight f) const {
+inline Square Position::castle_rook_square(Color c, CastlingSide s) const {
-  return castleRookSquare[f];
+  return castleRookSquare[c][s];
 }
 
 template<PieceType Pt>

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,