Test one pext

Author: PikaCat-OuO

src/bitboard.cpp

@@ -126,7 +126,7 @@ namespace {
 template<PieceType pt>
 void init_magics(Bitboard table[], Magic magics[] IF_NOT_PEXT(, const Bitboard magicsInit[])) {
 
-    Bitboard edges, b;
+    Bitboard edges, b, mask;
     uint64_t size = 0;
 
     for (Square s = SQ_A0; s <= SQ_I9; ++s)
@@ -139,17 +139,37 @@ void init_magics(Bitboard table[], Magic magics[] IF_NOT_PEXT(, const Bitboard m
         // all the attacks for each possible subset of the mask and so is 2 power
         // the number of 1s of the mask.
         Magic& m = magics[s];
-        m.mask   = pt == ROOK   ? Bitboards::sliding_attack<pt>(s, 0)
-                 : pt == CANNON ? RookMagics[s].mask
-                                : Bitboards::lame_leaper_path<pt>(s);
+        mask     = pt == ROOK || pt == CANNON ? Bitboards::sliding_attack<ROOK>(s, 0)
+                                              : Bitboards::lame_leaper_path<pt>(s);
         if (pt != KNIGHT_TO)
-            m.mask &= ~edges;
+            mask &= ~edges;
+
+        m.mask_lo = (uint64_t) mask;
+        m.mask_hi = (uint64_t) (mask >> 64);
+
+        int best_relative_shift = 0;
+
+        if (m.mask_hi != 0)
+        {
+            int hi_end = msb(m.mask_hi);
+            for (int k = 0; k < (64 - hi_end); ++k)
+            {
+                uint64_t shifted_pattern = m.mask_hi << k;
+
+                if ((m.mask_lo & shifted_pattern) == 0)
+                {
+                    best_relative_shift = k;
+                    break;
+                }
+            }
+        }
+        m.mask = (m.mask_hi << best_relative_shift) | m.mask_lo;
 
 #ifdef USE_PEXT
-        m.shift = popcount(uint64_t(m.mask));
+        m.shift = best_relative_shift;
 #else
         m.magic = magicsInit[s];
-        m.shift = 128 - popcount(m.mask);
+        m.shift = 64 - popcount(m.mask);
 #endif
 
         // Set the offset for the attacks table of the square. We have individual
@@ -166,7 +186,7 @@ void init_magics(Bitboard table[], Magic magics[] IF_NOT_PEXT(, const Bitboard m
                                     : Bitboards::lame_leaper_attack<pt>(s, b);
 
             size++;
-            b = (b - m.mask) & m.mask;
+            b = (b - mask) & mask;
         } while (b);
     }
 }

src/bitboard.h

@@ -82,16 +82,20 @@ extern Bitboard LineBB[SQUARE_NB][SQUARE_NB];
 
 // Magic holds all magic bitboards relevant data for a single square
 struct Magic {
-    Bitboard  mask;
+    uint64_t  mask_lo, mask_hi;
+    uint64_t  mask;
     Bitboard* attacks;
     unsigned  shift;
-    IF_NOT_PEXT(Bitboard magic;)
+    IF_NOT_PEXT(uint64_t magic;)
 
     // Compute the attack's index using the 'magic bitboards' approach
     unsigned index(Bitboard occupied) const {
 
+        uint64_t lo = uint64_t(occupied) & mask_lo;
+        uint64_t hi = uint64_t(occupied >> 64) & mask_hi;
+
 #ifdef USE_PEXT
-        return unsigned(pext(occupied, mask, shift));
+        return unsigned(pext((hi << shift) | lo, mask));
 #else
         return unsigned(((occupied & mask) * magic) >> shift);
 #endif
@@ -314,29 +318,19 @@ inline Square lsb(Bitboard b) {
 #endif
 }
 
-// Returns the most significant bit in a non-zero bitboard.
-inline Square msb(Bitboard b) {
+// Returns the most significant bit in a 64 bit integer.
+inline int msb(uint64_t b) {
     assert(b);
 
 #if defined(_MSC_VER)
 
     unsigned long idx;
-    if (b._Word[1])
-    {
-        _BitScanReverse(&idx, b._Word[1]);
-        return Square(idx);
-    }
-    else
-    {
-        _BitScanReverse(&idx, b._Word[0]);
-        return Square(idx + 64);
-    }
+    _BitScanReverse64(&idx, b);
+    return idx;
 
 #else  // Assumed gcc or compatible compiler
 
-    if (uint64_t(b >> 64))
-        return Square(__builtin_clzll(b));
-    return Square(__builtin_clzll(b) + 64);
+    return 63 ^ __builtin_clzll(b);
 
 #endif
 }

src/types.h

@@ -91,14 +91,9 @@ using __uint128_t = std::_Unsigned128;
 
     #if defined(USE_PEXT)
         #include <immintrin.h>  // Header for _pext_u64() intrinsic
-        #if defined(_MSC_VER) && !defined(__clang__)
-            #define pext(b, m, s) \
-                ((_pext_u64(b._Word[1], m._Word[1]) << s) | _pext_u64(b._Word[0], m._Word[0]))
-        #else
-            #define pext(b, m, s) ((_pext_u64(b >> 64, m >> 64) << s) | _pext_u64(b, m))
-        #endif
+        #define pext(b, m) _pext_u64(b, m)
     #else
-        #define pext(b, m, s) 0
+        #define pext(b, m) 0
     #endif
 
 namespace Stockfish {