Compile time generation of zobrist hashes

konsolas · konsolas · commit d30b007bbfb8 · 2021-08-28T00:34:18.000+01:00
diff --git a/bb.h b/bb.h
@@ -21,7 +21,7 @@
  * @param square bit to set
  * @return bitboard with the bit at {@code square} set
  */
-inline U64 single_bit(uint8_t square) {
+constexpr U64 single_bit(uint8_t square) {
     return 0x1ull << square;
 }
 
diff --git a/hash.cpp b/hash.cpp
@@ -7,36 +7,6 @@
 #include <cstring>
 #include "hash.h"
 
-/*
- * Concrete fields and initialisation code - see hash.h for more info on Zobrist hashing
- */
-namespace zobrist {
-    const U64 seed = 0xBEEF;
-
-    U64 squares[64][2][6];
-    U64 side;
-    U64 ep[64];
-    U64 castle[2][2];
-
-    void init_hashes() {
-        std::mt19937_64 gen(seed); // NOLINT(cert-msc51-cpp) - constant seed intended
-        std::uniform_int_distribution<U64> dist;
-
-        side = dist(gen);
-        castle[0][0] = dist(gen);
-        castle[0][1] = dist(gen);
-        castle[1][0] = dist(gen);
-        castle[1][1] = dist(gen);
-
-        for (int i = 0; i < 64; i++) {
-            for (int j = 0; j < 2; j++)
-                for (int k = 0; k < 6; k++)
-                    squares[i][j][k] = dist(gen);
-            ep[i] = dist(gen);
-        }
-    }
-}
-
 tt::hash_t::hash_t(size_t size) {
     // Divide size by the sizeof an entry
     size /= (sizeof(tt::entry_t) * bucket_size);
diff --git a/hash.h b/hash.h
@@ -18,15 +18,49 @@
  * e.g. in move and unmove and avoids recomputing the hash.
  */
 namespace zobrist {
-    extern U64 squares[64][2][6];
-    extern U64 side;
-    extern U64 ep[64];
-    extern U64 castle[2][2];
+    // SplitMix64 PRNG (public domain)
+    struct split_mix_64_state { uint64_t x; };
+    constexpr uint64_t split_mix_64(split_mix_64_state &state) {
+        uint64_t z = (state.x += 0x9e3779b97f4a7c15);
+        z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
+        z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
+        return z ^ (z >> 31);
+    }
 
-    /**
-     * Initialise the hash arrays
-     */
-    void init_hashes();
+    // Deterministically generates a random n-dimensional array of uint64_t at compile time
+    // Uses variadic templates and recursion to generate the nested array type
+    template<int Size, int... Rest>
+    constexpr auto random_array(split_mix_64_state &state) {
+        if constexpr (sizeof...(Rest) != 0) {
+            std::array<decltype(random_array<Rest...>(state)), Size> arr = {};
+            for (int i = 0; i < Size; ++i) {
+                arr[i] = random_array<Rest...>(state);
+            }
+            return arr;
+        } else {
+            std::array<uint64_t, Size> arr = {};
+            for (int i = 0; i < Size; ++i) {
+                arr[i] = split_mix_64(state);
+            }
+            return arr;
+        }
+    }
+
+    template<int... Dims>
+    constexpr auto random_array(uint64_t seed) {
+        split_mix_64_state state { seed };
+        return random_array<Dims...>(state);
+    }
+
+    constexpr auto random_uint(uint64_t seed) {
+        split_mix_64_state state { seed };
+        return split_mix_64(state);
+    }
+
+    inline constexpr auto squares = random_array<64, 2, 6>(0);
+    inline constexpr auto side = random_uint(1);
+    inline constexpr auto ep = random_array<64>(2);
+    inline constexpr auto castle = random_array<2, 2>(3);
 }
 
 /**
@@ -59,16 +93,16 @@ class material_data_t {
     }
 
     // Accessors
-    [[nodiscard]] inline int count(Team team, Piece piece) const { return counts[team][piece]; }
-    [[nodiscard]] inline U64 hash() const { return z_hash; }
+    [[nodiscard]] constexpr int count(Team team, Piece piece) const { return counts[team][piece]; }
+    [[nodiscard]] constexpr U64 hash() const { return z_hash; }
 
-    inline void inc(Team team, Piece piece) {
+    constexpr void inc(Team team, Piece piece) {
         // We reuse piece-square hashes for material hashing. The square used corresponds to the count
         // e.g. the first pawn has the hash of a pawn on square 0, the second on square 1, etc.
         z_hash ^= zobrist::squares[counts[team][piece]++][team][piece];
         assert(counts[team][piece] >= 0);
     }
-    inline void dec(Team team, Piece piece) {
+    constexpr void dec(Team team, Piece piece) {
         // Note the prefix instead of postfix operator here.
         z_hash ^= zobrist::squares[--counts[team][piece]][team][piece];
         assert(counts[team][piece] >= 0);
diff --git a/main.cpp b/main.cpp
@@ -14,7 +14,6 @@ U64 perft(board_t &, int);
 int main(int argc, char *argv[]) {
     // Initialise engine
     init_tables();
-    zobrist::init_hashes();
     evaluator_t::eval_init();
 
     // Board
diff --git a/movesort.cpp b/movesort.cpp
@@ -48,7 +48,7 @@ move_t movesort_t::next(GenStage &stage, int &score, bool skip_quiets) {
                     }
                 }
 
-                buf_swap_capt(best_idx, capt_idx);
+                std::swap(capt_buf[best_idx], capt_buf[capt_idx]);
 
                 if (capt_buf[capt_idx] == hash_move) {
                     capt_idx++;
@@ -96,7 +96,8 @@ move_t movesort_t::next(GenStage &stage, int &score, bool skip_quiets) {
                         best_main_idx = i;
                     }
                 }
-                buf_swap_main(best_main_idx, main_idx);
+                std::swap(main_scores[best_main_idx], main_scores[main_idx]);
+                std::swap(main_buf[best_main_idx], main_buf[main_idx]);
 
                 if (main_buf[main_idx] == hash_move) {
                     main_idx++;
@@ -126,22 +127,6 @@ move_t movesort_t::next(GenStage &stage, int &score, bool skip_quiets) {
     }
 }
 
-void movesort_t::buf_swap_main(int a, int b) {
-    move_t temp = main_buf[a];
-    main_buf[a] = main_buf[b];
-    main_buf[b] = temp;
-
-    int score = main_scores[a];
-    main_scores[a] = main_scores[b];
-    main_scores[b] = score;
-}
-
-void movesort_t::buf_swap_capt(int a, int b) {
-    move_t temp = capt_buf[a];
-    capt_buf[a] = capt_buf[b];
-    capt_buf[b] = temp;
-}
-
 move_t *movesort_t::generated_quiets(size_t &count) {
     count = main_idx;
     return main_buf;
diff --git a/movesort.h b/movesort.h
@@ -76,9 +76,6 @@ class movesort_t {
 
     move_t killer_1, killer_2, killer_3;
 
-    void buf_swap_main(int a, int b);
-    void buf_swap_capt(int a, int b);
-
     movegen_t gen;
 
     int main_idx = 0;
diff --git a/testing/runner.cpp b/testing/runner.cpp
@@ -11,7 +11,6 @@
 
 int main(int argc, char* argv[]) {
     init_tables();
-    zobrist::init_hashes();
     evaluator_t::eval_init();
 
     return Catch::Session().run(argc, argv);
diff --git a/texeltuning/main.cpp b/texeltuning/main.cpp
@@ -26,7 +26,6 @@ double get_result(const std::string &result) {
 int main(int argc, char *argv[]) {
     // Initialise engine
     init_tables();
-    zobrist::init_hashes();
     evaluator_t::eval_init();
 
     // Startup
diff --git a/toppletuning/main.cpp b/toppletuning/main.cpp
@@ -10,7 +10,6 @@ void print_params(const eval_params_t &current_params);
 int main(int argc, char *argv[]) {
     // Initialise engine
     init_tables();
-    zobrist::init_hashes();
     evaluator_t::eval_init();
 
     std::cout << "total parameters: " << sizeof(eval_params_t) / sizeof(int) << std::endl;

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@`
`21`	`21`	`* @param square bit to set`
`22`	`22`	`* @return bitboard with the bit at {@code square} set`
`23`	`23`	`*/`
`24`		`-inline U64 single_bit(uint8_t square) {`
	`24`	`+constexpr U64 single_bit(uint8_t square) {`
`25`	`25`	`return 0x1ull << square;`
`26`	`26`	`}`
`27`	`27`