Merge branch 'remove_double_memcpy_acc_table'

Luecx · Luecx · commit a89906b672af · 2023-01-27T18:31:05.000+01:00
bench: 4271540
diff --git a/src_files/eval.cpp b/src_files/eval.cpp
@@ -104,6 +104,28 @@ inline int32_t sumRegisterEpi32(avx_register_type_32& reg) {
 #endif
 }
 
+template<bool V>
+inline void addWeightsToAccumulator(const int idx, int16_t* accumulator){
+    const auto wgt = (avx_register_type_16*) (nn::inputWeights[idx]);
+    const auto sum = (avx_register_type_16*) (accumulator);
+    if constexpr (V) {
+        for (int i = 0; i < HIDDEN_SIZE / STRIDE_16_BIT / 4; i++) {
+            sum[i * 4 + 0] = avx_add_epi16(sum[i * 4 + 0], wgt[i * 4 + 0]);
+            sum[i * 4 + 1] = avx_add_epi16(sum[i * 4 + 1], wgt[i * 4 + 1]);
+            sum[i * 4 + 2] = avx_add_epi16(sum[i * 4 + 2], wgt[i * 4 + 2]);
+            sum[i * 4 + 3] = avx_add_epi16(sum[i * 4 + 3], wgt[i * 4 + 3]);
+        }
+    } else {
+        for (int i = 0; i < HIDDEN_SIZE / STRIDE_16_BIT / 4; i++) {
+            sum[i * 4 + 0] = avx_sub_epi16(sum[i * 4 + 0], wgt[i * 4 + 0]);
+            sum[i * 4 + 1] = avx_sub_epi16(sum[i * 4 + 1], wgt[i * 4 + 1]);
+            sum[i * 4 + 2] = avx_sub_epi16(sum[i * 4 + 2], wgt[i * 4 + 2]);
+            sum[i * 4 + 3] = avx_sub_epi16(sum[i * 4 + 3], wgt[i * 4 + 3]);
+        }
+    }
+}
+
+
 void nn::init() {
     int memoryIndex = 0;
     std::memcpy(inputWeights, &gEvalData[memoryIndex], INPUT_SIZE * HIDDEN_SIZE * sizeof(int16_t));
@@ -162,30 +184,6 @@ int nn::kingSquareIndex(bb::Square relativeKingSquare, bb::Color kingColor) {
     return indices[relativeKingSquare];
 }
 
-void nn::AccumulatorTable::put(bb::Color view, Board* board, nn::Accumulator& accumulator) {
-    const bb::Square king_sq   = bb::bitscanForward(board->getPieceBB(view, bb::KING));
-    const bool       king_side = bb::fileIndex(king_sq) > 3;
-    const int        ks_index  = kingSquareIndex(king_sq, view);
-
-    // use a different entry if the king crossed the half but it would technically
-    // still be within the same bucket
-    const int entry_idx = king_side * 16 + ks_index;
-
-    // get the entry
-    AccumulatorTableEntry& entry = entries[view][entry_idx];
-
-    // store the accumulator data
-    std::memcpy(entry.accumulator.summation[view], accumulator.summation[view],
-                sizeof(int16_t) * HIDDEN_SIZE);
-
-    // store the piece data
-    for (bb::Color c : {bb::WHITE, bb::BLACK}) {
-        for (bb::PieceType pt : {bb::PAWN, bb::KNIGHT, bb::BISHOP, bb::ROOK, bb::QUEEN, bb::KING}) {
-            bb::U64 bb             = board->getPieceBB(c, pt);
-            entry.piece_occ[c][pt] = bb;
-        }
-    }
-}
 
 void nn::AccumulatorTable::use(bb::Color view, Board* board, nn::Evaluator& evaluator) {
     const bb::Square king_sq   = bb::bitscanForward(board->getPieceBB(view, bb::KING));
@@ -198,12 +196,9 @@ void nn::AccumulatorTable::use(bb::Color view, Board* board, nn::Evaluator& eval
 
     // get the entry
     AccumulatorTableEntry& entry = entries[view][entry_idx];
-
-    // first retrieve the accumulator from the table and put that into the evaluator
-    std::memcpy(evaluator.history.back().summation[view], entry.accumulator.summation[view],
-                sizeof(int16_t) * HIDDEN_SIZE);
-
+    
     // go through each piece and compute the difference.
+    // and update the accumulator table entry inplace to only use a single memcpy
     for (bb::Color c : {bb::WHITE, bb::BLACK}) {
         for (bb::PieceType pt : {bb::PAWN, bb::KNIGHT, bb::BISHOP, bb::ROOK, bb::QUEEN, bb::KING}) {
 
@@ -219,20 +214,23 @@ void nn::AccumulatorTable::use(bb::Color view, Board* board, nn::Evaluator& eval
             // go through both sets and call the evaluator to update the accumulator
             while (to_set) {
                 bb::Square sq = bb::bitscanForward(to_set);
-                evaluator.setPieceOnSquareAccumulator<true>(view, pt, c, sq, king_sq);
+                addWeightsToAccumulator<true>(nn::index(pt, c, sq, view, king_sq), entry.accumulator.summation[view]);
                 to_set = bb::lsbReset(to_set);
             }
 
             while (to_unset) {
                 bb::Square sq = bb::bitscanForward(to_unset);
-                evaluator.setPieceOnSquareAccumulator<false>(view, pt, c, sq, king_sq);
+                addWeightsToAccumulator<false>(nn::index(pt, c, sq, view, king_sq), entry.accumulator.summation[view]);
                 to_unset = bb::lsbReset(to_unset);
             }
+            
+            // store the piece data
+            entry.piece_occ[c][pt] = board_bb;
         }
     }
-    // this set has most likely been done on a reset. its handy to just put the new state
-    // into the table
-    put(view, board, evaluator.history.back());
+    
+    std::memcpy(evaluator.history.back().summation[view], entry.accumulator.summation[view],sizeof(int16_t) * HIDDEN_SIZE);
+
 }
 
 void nn::AccumulatorTable::reset() {
@@ -258,25 +256,7 @@ void nn::Evaluator::setPieceOnSquareAccumulator(bb::Color side, bb::PieceType pi
                                                 bb::Color pieceColor, bb::Square square,
                                                 bb::Square kingSquare) {
     const int  idx = index(pieceType, pieceColor, square, side, kingSquare);
-
-    const auto wgt = (avx_register_type_16*) (inputWeights[idx]);
-    const auto sum = (avx_register_type_16*) (history.back().summation[side]);
-    if constexpr (value) {
-        for (int i = 0; i < HIDDEN_SIZE / STRIDE_16_BIT / 4; i++) {
-            sum[i * 4 + 0] = avx_add_epi16(sum[i * 4 + 0], wgt[i * 4 + 0]);
-            sum[i * 4 + 1] = avx_add_epi16(sum[i * 4 + 1], wgt[i * 4 + 1]);
-            sum[i * 4 + 2] = avx_add_epi16(sum[i * 4 + 2], wgt[i * 4 + 2]);
-            sum[i * 4 + 3] = avx_add_epi16(sum[i * 4 + 3], wgt[i * 4 + 3]);
-        }
-    } else {
-        for (int i = 0; i < HIDDEN_SIZE / STRIDE_16_BIT / 4; i++) {
-            sum[i * 4 + 0] = avx_sub_epi16(sum[i * 4 + 0], wgt[i * 4 + 0]);
-            sum[i * 4 + 1] = avx_sub_epi16(sum[i * 4 + 1], wgt[i * 4 + 1]);
-            sum[i * 4 + 2] = avx_sub_epi16(sum[i * 4 + 2], wgt[i * 4 + 2]);
-            sum[i * 4 + 3] = avx_sub_epi16(sum[i * 4 + 3], wgt[i * 4 + 3]);
-        }
-    }
-    
+    addWeightsToAccumulator<value>(idx, history.back().summation[side]);
 }
 
 void nn::Evaluator::reset(Board* board) {
diff --git a/src_files/eval.h b/src_files/eval.h
@@ -65,6 +65,7 @@ void init();
 // also takes the view from with we view at the board as well as the king square of the view side
 [[nodiscard]] int index(bb::PieceType pieceType, bb::Color pieceColor, bb::Square square,
                         bb::Color view, bb::Square kingSquare);
+
 // the index is based on a king bucketing system. the relevant king bucket can be retrieved using
 // the function below
 [[nodiscard]] int kingSquareIndex(bb::Square kingSquare, bb::Color kingColor);
@@ -96,9 +97,6 @@ struct AccumulatorTableEntry {
 // used but is the fastest solution.
 struct AccumulatorTable {
     AccumulatorTableEntry entries[bb::N_COLORS][32] {};
-
-    // sets the specific accumulator to store the specified accumulator
-    void put(bb::Color view, Board* board, Accumulator& accumulator);
     
     void use(bb::Color view, Board* board, Evaluator& evaluator);
     
