Remove some code unused in the current network architecture

No functional change.

src/nnue/features/feature_set.h

@@ -21,48 +21,6 @@ namespace Eval::NNUE::Features {
         kValues = {{First, Remaining...}};
   };
 
-  template <typename T, T First, T... Remaining>
-  constexpr std::array<T, sizeof...(Remaining) + 1>
-      CompileTimeList<T, First, Remaining...>::kValues;
-
-  template <typename T>
-  struct CompileTimeList<T> {
-    static constexpr bool Contains(T /*value*/) {
-      return false;
-    }
-    static constexpr std::array<T, 0> kValues = {{}};
-  };
-
-  // Class template that adds to the beginning of the list
-  template <typename T, typename ListType, T Value>
-  struct AppendToList;
-
-  template <typename T, T... Values, T AnotherValue>
-  struct AppendToList<T, CompileTimeList<T, Values...>, AnotherValue> {
-    using Result = CompileTimeList<T, AnotherValue, Values...>;
-  };
-
-  // Class template for adding to a sorted, unique list
-  template <typename T, typename ListType, T Value>
-  struct InsertToSet;
-
-  template <typename T, T First, T... Remaining, T AnotherValue>
-  struct InsertToSet<T, CompileTimeList<T, First, Remaining...>, AnotherValue> {
-    using Result = std::conditional_t<
-        CompileTimeList<T, First, Remaining...>::Contains(AnotherValue),
-        CompileTimeList<T, First, Remaining...>,
-        std::conditional_t<(AnotherValue <First),
-            CompileTimeList<T, AnotherValue, First, Remaining...>,
-            typename AppendToList<T, typename InsertToSet<
-                T, CompileTimeList<T, Remaining...>, AnotherValue>::Result,
-                First>::Result>>;
-  };
-
-  template <typename T, T Value>
-  struct InsertToSet<T, CompileTimeList<T>, Value> {
-    using Result = CompileTimeList<T, Value>;
-  };
-
   // Base class of feature set
   template <typename Derived>
   class FeatureSetBase {
@@ -91,22 +49,10 @@ namespace Eval::NNUE::Features {
       for (Color perspective : { WHITE, BLACK }) {
         reset[perspective] = false;
         switch (trigger) {
-          case TriggerEvent::kNone:
-            break;
           case TriggerEvent::kFriendKingMoved:
             reset[perspective] =
                 dp.pieceId[0] == PIECE_ID_KING + perspective;
             break;
-          case TriggerEvent::kEnemyKingMoved:
-            reset[perspective] =
-                dp.pieceId[0] == PIECE_ID_KING + ~perspective;
-            break;
-          case TriggerEvent::kAnyKingMoved:
-            reset[perspective] = dp.pieceId[0] >= PIECE_ID_KING;
-            break;
-          case TriggerEvent::kAnyPieceMoved:
-            reset[perspective] = true;
-            break;
           default:
             assert(false);
             break;
@@ -123,80 +69,6 @@ namespace Eval::NNUE::Features {
     }
   };
 
-  // Class template that represents the feature set
-  // do internal processing in reverse order of template arguments in order to linearize the amount of calculation at runtime
-  template <typename FirstFeatureType, typename... RemainingFeatureTypes>
-  class FeatureSet<FirstFeatureType, RemainingFeatureTypes...> :
-      public FeatureSetBase<
-          FeatureSet<FirstFeatureType, RemainingFeatureTypes...>> {
-
-   private:
-    using Head = FirstFeatureType;
-    using Tail = FeatureSet<RemainingFeatureTypes...>;
-
-   public:
-    // Hash value embedded in the evaluation function file
-    static constexpr std::uint32_t kHashValue =
-        Head::kHashValue ^ (Tail::kHashValue << 1) ^ (Tail::kHashValue >> 31);
-    // number of feature dimensions
-    static constexpr IndexType kDimensions =
-        Head::kDimensions + Tail::kDimensions;
-    // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
-    static constexpr IndexType kMaxActiveDimensions =
-        Head::kMaxActiveDimensions + Tail::kMaxActiveDimensions;
-    // List of timings to perform all calculations instead of difference calculation
-    using SortedTriggerSet = typename InsertToSet<TriggerEvent,
-        typename Tail::SortedTriggerSet, Head::kRefreshTrigger>::Result;
-    static constexpr auto kRefreshTriggers = SortedTriggerSet::kValues;
-
-    // Get the feature quantity name
-    static std::string GetName() {
-      return std::string(Head::kName) + "+" + Tail::GetName();
-    }
-
-   private:
-    // Get a list of indices with a value of 1 among the features
-    template <typename IndexListType>
-    static void CollectActiveIndices(
-        const Position& pos, const TriggerEvent trigger, const Color perspective,
-        IndexListType* const active) {
-
-      Tail::CollectActiveIndices(pos, trigger, perspective, active);
-      if (Head::kRefreshTrigger == trigger) {
-        const auto start = active->size();
-        Head::AppendActiveIndices(pos, perspective, active);
-        for (auto i = start; i < active->size(); ++i) {
-          (*active)[i] += Tail::kDimensions;
-        }
-      }
-    }
-
-    // Get a list of indices whose values ​​have changed from the previous one in the feature quantity
-    template <typename IndexListType>
-    static void CollectChangedIndices(
-        const Position& pos, const TriggerEvent trigger, const Color perspective,
-        IndexListType* const removed, IndexListType* const added) {
-
-      Tail::CollectChangedIndices(pos, trigger, perspective, removed, added);
-      if (Head::kRefreshTrigger == trigger) {
-        const auto start_removed = removed->size();
-        const auto start_added = added->size();
-        Head::AppendChangedIndices(pos, perspective, removed, added);
-        for (auto i = start_removed; i < removed->size(); ++i) {
-          (*removed)[i] += Tail::kDimensions;
-        }
-        for (auto i = start_added; i < added->size(); ++i) {
-          (*added)[i] += Tail::kDimensions;
-        }
-      }
-    }
-
-    // Make the base class and the class template that recursively uses itself a friend
-    friend class FeatureSetBase<FeatureSet>;
-    template <typename... FeatureTypes>
-    friend class FeatureSet;
-  };
-
   // Class template that represents the feature set
   // Specialization with one template argument
   template <typename FeatureType>

src/nnue/features/features_common.h

@@ -17,19 +17,12 @@ namespace Eval::NNUE::Features {
 
   // Type of timing to perform all calculations instead of difference calculation
   enum class TriggerEvent {
-
+    kFriendKingMoved // calculate all when own king moves
-    kNone, // Calculate the difference whenever possible
-    kFriendKingMoved, // calculate all when own king moves
-    kEnemyKingMoved, // do all calculations when enemy king moves
-    kAnyKingMoved, // do all calculations if either king moves
-    kAnyPieceMoved, // always do all calculations
   };
 
   // turn side or other side
   enum class Side {
-
+    kFriend // turn side
-    kFriend, // turn side
-    kEnemy, // opponent
   };
 
 }  // namespace Eval::NNUE::Features

src/nnue/features/half_kp.cpp

@@ -70,6 +70,5 @@ namespace Eval::NNUE::Features {
   }
 
   template class HalfKP<Side::kFriend>;
-  template class HalfKP<Side::kEnemy>;
 
 }  // namespace Eval::NNUE::Features

src/nnue/features/half_kp.h

@@ -26,9 +26,7 @@ namespace Eval::NNUE::Features {
     // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
     static constexpr IndexType kMaxActiveDimensions = PIECE_ID_KING;
     // Timing of full calculation instead of difference calculation
-    static constexpr TriggerEvent kRefreshTrigger =
+    static constexpr TriggerEvent kRefreshTrigger = TriggerEvent::kFriendKingMoved;
-        (AssociatedKing == Side::kFriend) ?
-        TriggerEvent::kFriendKingMoved : TriggerEvent::kEnemyKingMoved;
 
     // Get a list of indices with a value of 1 among the features
     static void AppendActiveIndices(const Position& pos, Color perspective,

src/nnue/nnue_feature_transformer.h

@@ -121,12 +121,6 @@ namespace Eval::NNUE {
 
             (&reinterpret_cast<const __m256i*>(
               accumulation[perspectives[p]][0])[j * 2 + 1]);
-          for (IndexType i = 1; i < kRefreshTriggers.size(); ++i) {
-            sum0 = _mm256_add_epi16(sum0, reinterpret_cast<const __m256i*>(
-                accumulation[perspectives[p]][i])[j * 2 + 0]);
-            sum1 = _mm256_add_epi16(sum1, reinterpret_cast<const __m256i*>(
-                accumulation[perspectives[p]][i])[j * 2 + 1]);
-          }
 
   #if defined(__MINGW32__) || defined(__MINGW64__)
           _mm256_storeu_si256
@@ -145,12 +139,6 @@ namespace Eval::NNUE {
               accumulation[perspectives[p]][0])[j * 2 + 0]);
           __m128i sum1 = _mm_load_si128(&reinterpret_cast<const __m128i*>(
               accumulation[perspectives[p]][0])[j * 2 + 1]);
-          for (IndexType i = 1; i < kRefreshTriggers.size(); ++i) {
-            sum0 = _mm_add_epi16(sum0, reinterpret_cast<const __m128i*>(
-                accumulation[perspectives[p]][i])[j * 2 + 0]);
-            sum1 = _mm_add_epi16(sum1, reinterpret_cast<const __m128i*>(
-                accumulation[perspectives[p]][i])[j * 2 + 1]);
-          }
       const __m128i packedbytes = _mm_packs_epi16(sum0, sum1);
 
           _mm_store_si128(&out[j],
@@ -169,19 +157,12 @@ namespace Eval::NNUE {
         for (IndexType j = 0; j < kNumChunks; ++j) {
           int16x8_t sum = reinterpret_cast<const int16x8_t*>(
               accumulation[perspectives[p]][0])[j];
-          for (IndexType i = 1; i < kRefreshTriggers.size(); ++i) {
-            sum = vaddq_s16(sum, reinterpret_cast<const int16x8_t*>(
-                accumulation[perspectives[p]][i])[j]);
-          }
           out[j] = vmax_s8(vqmovn_s16(sum), kZero);
         }
 
   #else
         for (IndexType j = 0; j < kHalfDimensions; ++j) {
           BiasType sum = accumulation[static_cast<int>(perspectives[p])][0][j];
-          for (IndexType i = 1; i < kRefreshTriggers.size(); ++i) {
-            sum += accumulation[static_cast<int>(perspectives[p])][i][j];
-          }
           output[offset + j] = static_cast<OutputType>(
               std::max<int>(0, std::min<int>(127, sum)));
         }
@@ -194,18 +175,13 @@ namespace Eval::NNUE {
     // Calculate cumulative value without using difference calculation
     void RefreshAccumulator(const Position& pos) const {
       auto& accumulator = pos.state()->accumulator;
-      for (IndexType i = 0; i < kRefreshTriggers.size(); ++i) {
+      IndexType i = 0;
       Features::IndexList active_indices[2];
       RawFeatures::AppendActiveIndices(pos, kRefreshTriggers[i],
                                        active_indices);
       for (Color perspective : { WHITE, BLACK }) {
-          if (i == 0) {
         std::memcpy(accumulator.accumulation[perspective][i], biases_,
                    kHalfDimensions * sizeof(BiasType));
-          } else {
-            std::memset(accumulator.accumulation[perspective][i], 0,
-                        kHalfDimensions * sizeof(BiasType));
-          }
         for (const auto index : active_indices[perspective]) {
           const IndexType offset = kHalfDimensions * index;
 
@@ -248,7 +224,6 @@ namespace Eval::NNUE {
 
         }
       }
-      }
 
       accumulator.computed_accumulation = true;
       accumulator.computed_score = false;
@@ -258,7 +233,7 @@ namespace Eval::NNUE {
     void UpdateAccumulator(const Position& pos) const {
       const auto prev_accumulator = pos.state()->previous->accumulator;
       auto& accumulator = pos.state()->accumulator;
-      for (IndexType i = 0; i < kRefreshTriggers.size(); ++i) {
+      IndexType i = 0;
       Features::IndexList removed_indices[2], added_indices[2];
       bool reset[2];
       RawFeatures::AppendChangedIndices(pos, kRefreshTriggers[i],
@@ -282,13 +257,8 @@ namespace Eval::NNUE {
   #endif
 
         if (reset[perspective]) {
-            if (i == 0) {
           std::memcpy(accumulator.accumulation[perspective][i], biases_,
                       kHalfDimensions * sizeof(BiasType));
-            } else {
-              std::memset(accumulator.accumulation[perspective][i], 0,
-                          kHalfDimensions * sizeof(BiasType));
-            }
         } else {// Difference calculation for the feature amount changed from 1 to 0
           std::memcpy(accumulator.accumulation[perspective][i],
                       prev_accumulator.accumulation[perspective][i],
@@ -355,7 +325,6 @@ namespace Eval::NNUE {
           }
         }
       }
-      }
 
       accumulator.computed_accumulation = true;
       accumulator.computed_score = false;