Last touches to movegen.cpp
authorMarco Costalba <mcostalba@gmail.com>
Fri, 6 Jan 2012 11:37:33 +0000 (12:37 +0100)
committerMarco Costalba <mcostalba@gmail.com>
Sat, 7 Jan 2012 12:13:28 +0000 (13:13 +0100)
The full movegen patch series shows a speed up of almost
6% (!) on perft, and code is much more readable too.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
src/movegen.cpp

index 5308e45ddfbdd9e6d2dd36f89c8fd91e6c38fa28..272807b9aa4b4444adf81250dba2c90c2d9459bf 100644 (file)
 #include <algorithm>
 #include <cassert>
 
-#include "bitcount.h"
 #include "movegen.h"
 #include "position.h"
 
 /// Simple macro to wrap a very common while loop, no facny, no flexibility,
 /// hardcoded names 'mlist' and 'from'.
-#define SERIALIZE_MOVES(b) while (b) (*mlist++).move = make_move(from, pop_1st_bit(&b))
+#define SERIALIZE(b) while (b) (*mlist++).move = make_move(from, pop_1st_bit(&b))
 
 /// Version used for pawns, where the 'from' square is given as a delta from the 'to' square
-#define SERIALIZE_MOVES_D(b, d) while (b) { to = pop_1st_bit(&b); (*mlist++).move = make_move(to + (d), to); }
-
+#define SERIALIZE_PAWNS(b, d) while (b) { Square to = pop_1st_bit(&b); \
+                                         (*mlist++).move = make_move(to + (d), to); }
 namespace {
 
   enum CastlingSide { KING_SIDE, QUEEN_SIDE };
@@ -100,11 +99,9 @@ namespace {
 
     const Bitboard TFileABB = (   Delta == DELTA_NE
                                || Delta == DELTA_SE ? FileABB : FileHBB);
-    Bitboard b;
-    Square to;
 
-    b = move_pawns<Delta>(pawns) & target & ~TFileABB;
-    SERIALIZE_MOVES_D(b, -Delta);
+    Bitboard b = move_pawns<Delta>(pawns) & target & ~TFileABB;
+    SERIALIZE_PAWNS(b, -Delta);
     return mlist;
   }
 
@@ -114,17 +111,15 @@ namespace {
 
     const Bitboard TFileABB = (   Delta == DELTA_NE
                                || Delta == DELTA_SE ? FileABB : FileHBB);
-    Bitboard b;
-    Square to;
 
-    b = move_pawns<Delta>(pawnsOn7) & target;
+    Bitboard b = move_pawns<Delta>(pawnsOn7) & target;
 
     if (Delta != DELTA_N && Delta != DELTA_S)
         b &= ~TFileABB;
 
     while (b)
     {
-        to = pop_1st_bit(&b);
+        Square to = pop_1st_bit(&b);
 
         if (Type == MV_CAPTURE || Type == MV_EVASION || Type == MV_NON_EVASION)
             (*mlist++).move = make_promotion(to - Delta, to, QUEEN);
@@ -138,9 +133,8 @@ namespace {
 
         // Knight-promotion is the only one that can give a check (direct or
         // discovered) not already included in the queen-promotion.
-        if (   Type == MV_NON_CAPTURE_CHECK
-            && bit_is_set(StepAttacksBB[W_KNIGHT][to], ksq))
-                (*mlist++).move = make_promotion(to - Delta, to, KNIGHT);
+        if (Type == MV_NON_CAPTURE_CHECK && bit_is_set(StepAttacksBB[W_KNIGHT][to], ksq))
+            (*mlist++).move = make_promotion(to - Delta, to, KNIGHT);
         else
             (void)ksq; // Silence a warning under MSVC
     }
@@ -160,12 +154,10 @@ namespace {
     const Square   RIGHT    = (Us == WHITE ? DELTA_NE : DELTA_SW);
     const Square   LEFT     = (Us == WHITE ? DELTA_NW : DELTA_SE);
 
-    Square to;
     Bitboard b1, b2, dc1, dc2, emptySquares;
 
-    Bitboard pawns       = pos.pieces(PAWN, Us);
-    Bitboard pawnsOn7    = pawns &  TRank7BB;
-    Bitboard pawnsNotOn7 = pawns & ~TRank7BB;
+    Bitboard pawnsOn7    = pos.pieces(PAWN, Us) &  TRank7BB;
+    Bitboard pawnsNotOn7 = pos.pieces(PAWN, Us) & ~TRank7BB;
 
     Bitboard enemies = (Type == MV_EVASION ? pos.pieces(Them) & target:
                         Type == MV_CAPTURE ? target : pos.pieces(Them));
@@ -204,8 +196,8 @@ namespace {
             }
         }
 
-        SERIALIZE_MOVES_D(b1, -UP);
-        SERIALIZE_MOVES_D(b2, -UP -UP);
+        SERIALIZE_PAWNS(b1, -UP);
+        SERIALIZE_PAWNS(b2, -UP -UP);
     }
 
     // Promotions and underpromotions
@@ -276,7 +268,7 @@ namespace {
             continue;
 
         b = pos.attacks_from<Pt>(from) & checkSqs;
-        SERIALIZE_MOVES(b);
+        SERIALIZE(b);
 
     } while ((from = *pl++) != SQ_NONE);
 
@@ -287,8 +279,8 @@ namespace {
   template<>
   FORCE_INLINE MoveStack* generate_direct_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
 
-    return (us == WHITE ? generate_pawn_moves<WHITE, MV_NON_CAPTURE_CHECK>(p, m, dc, ksq)
-                        : generate_pawn_moves<BLACK, MV_NON_CAPTURE_CHECK>(p, m, dc, ksq));
+    return us == WHITE ? generate_pawn_moves<WHITE, MV_NON_CAPTURE_CHECK>(p, m, dc, ksq)
+                       : generate_pawn_moves<BLACK, MV_NON_CAPTURE_CHECK>(p, m, dc, ksq);
   }
 
 
@@ -296,8 +288,8 @@ namespace {
   FORCE_INLINE MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us, Bitboard t) {
 
     assert(Pt == PAWN);
-    return (us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m, t, SQ_NONE)
-                        : generate_pawn_moves<BLACK, Type>(p, m, t, SQ_NONE));
+    return us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m, t, SQ_NONE)
+                       : generate_pawn_moves<BLACK, Type>(p, m, t, SQ_NONE);
   }
 
 
@@ -313,7 +305,7 @@ namespace {
         do {
             from = *pl;
             b = pos.attacks_from<Pt>(from) & target;
-            SERIALIZE_MOVES(b);
+            SERIALIZE(b);
         } while (*++pl != SQ_NONE);
     }
     return mlist;
@@ -323,11 +315,9 @@ namespace {
   template<>
   FORCE_INLINE MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
 
-    Bitboard b;
     Square from = pos.king_square(us);
-
-    b = pos.attacks_from<KING>(from) & target;
-    SERIALIZE_MOVES(b);
+    Bitboard b = pos.attacks_from<KING>(from) & target;
+    SERIALIZE(b);
     return mlist;
   }
 
@@ -398,7 +388,6 @@ MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist)
 
   assert(pos.piece_on(ksq) == make_piece(flip(us), KING));
 
-  // Discovered non-capture checks
   b = dc = pos.discovered_check_candidates();
 
   while (b)
@@ -414,10 +403,9 @@ MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist)
      if (pt == KING)
          b &= ~QueenPseudoAttacks[ksq];
 
-     SERIALIZE_MOVES(b);
+     SERIALIZE(b);
   }
 
-  // Direct non-capture checks
   mlist = generate_direct_checks<PAWN>(pos, mlist, us, dc, ksq);
   mlist = generate_direct_checks<KNIGHT>(pos, mlist, us, dc, ksq);
   mlist = generate_direct_checks<BISHOP>(pos, mlist, us, dc, ksq);
@@ -444,9 +432,8 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
   assert(pos.piece_on(ksq) == make_piece(us, KING));
   assert(checkers);
 
-  // Find squares attacked by slider checkers, we will remove
-  // them from the king evasions set so to early skip known
-  // illegal moves and avoid an useless legality check later.
+  // Find squares attacked by slider checkers, we will remove them from the king
+  // evasions set so to skip known illegal moves and avoid to do legality check later.
   b = checkers;
   do
   {
@@ -479,14 +466,13 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
   // Generate evasions for king, capture and non capture moves
   b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
   from = ksq;
-  SERIALIZE_MOVES(b);
+  SERIALIZE(b);
 
-  // Generate evasions for other pieces only if not double check
+  // Generate evasions for other pieces only if not under a double check
   if (checkersCnt > 1)
       return mlist;
 
-  // Find squares where a blocking evasion or a capture of the
-  // checker piece is possible.
+  // Target for blocking evasions or captures of the checking piece
   target = squares_between(checksq, ksq) | checkers;
 
   mlist = generate_piece_moves<PAWN, MV_EVASION>(pos, mlist, us, target);
@@ -497,7 +483,7 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
 }
 
 
-/// generate<MV_LEGAL> generates all legal moves in the current position
+/// generate<MV_LEGAL> generates all the legal moves in the given position
 
 template<>
 MoveStack* generate<MV_LEGAL>(const Position& pos, MoveStack* mlist) {
@@ -507,8 +493,6 @@ MoveStack* generate<MV_LEGAL>(const Position& pos, MoveStack* mlist) {
 
   last = pos.in_check() ? generate<MV_EVASION>(pos, mlist)
                         : generate<MV_NON_EVASION>(pos, mlist);
-
-  // Remove illegal moves from the list
   while (cur != last)
       if (!pos.pl_move_is_legal(cur->move, pinned))
           cur->move = (--last)->move;