refactor: simplify core and utils and remove unused Array

CMakeLists.txt

@@ -296,7 +296,7 @@ endif()
 if(RABITQ_BUILD_INDEX)
     install(DIRECTORY include/rabitqlib/index include/rabitqlib/clustering
         DESTINATION "${rabitq_include_dir}")
-    install(FILES include/rabitqlib/utils/array.hpp include/rabitqlib/utils/io.hpp
+    install(FILES include/rabitqlib/utils/io.hpp
         include/rabitqlib/utils/stopw.hpp DESTINATION "${rabitq_include_dir}/utils")
     install(DIRECTORY include/rabitqlib/third/hnswlib
         DESTINATION "${rabitq_include_dir}/third")

include/rabitqlib/core/rotator.hpp

@@ -112,23 +112,23 @@ class MatrixRotator : public Rotator<T> {
     void load(std::ifstream& input) override {
         input.read(
             reinterpret_cast<char*>(rand_mat_.data()),
-            static_cast<std::streamsize>(sizeof(T) * this->dim_ * this->padded_dim_)
+            static_cast<std::streamsize>(MatrixRotator<T>::dump_bytes())
         );
     }
 
     void save(std::ofstream& output) const override {
         output.write(
             reinterpret_cast<const char*>(rand_mat_.data()),
-            (sizeof(T) * this->dim_ * this->padded_dim_)
+            static_cast<std::streamsize>(MatrixRotator<T>::dump_bytes())
         );
     }
 
     void load(const char* data) override {
-        std::memcpy(rand_mat_.data(), data, sizeof(T) * this->dim_ * this->padded_dim_);
+        std::memcpy(rand_mat_.data(), data, MatrixRotator<T>::dump_bytes());
     }
 
     void save(char* data) const override {
-        std::memcpy(data, rand_mat_.data(), sizeof(T) * this->dim_ * this->padded_dim_);
+        std::memcpy(data, rand_mat_.data(), MatrixRotator<T>::dump_bytes());
     }
 
     size_t dump_bytes() const override {
@@ -193,35 +193,28 @@ class FhtKacRotator : public Rotator<float> {
     void load(std::ifstream& input) override {
         input.read(
             reinterpret_cast<char*>(flip_.data()),
-            static_cast<std::streamsize>(sizeof(uint8_t) * flip_.size())
+            static_cast<std::streamsize>(FhtKacRotator::dump_bytes())
         );
     }
 
     void save(std::ofstream& output) const override {
         output.write(
             reinterpret_cast<const char*>(flip_.data()),
-            static_cast<std::streamsize>(sizeof(uint8_t) * flip_.size())
+            static_cast<std::streamsize>(FhtKacRotator::dump_bytes())
         );
     }
 
     void load(const char* data) override {
-        std::memcpy(flip_.data(), data, sizeof(uint8_t) * flip_.size());
+        std::memcpy(flip_.data(), data, FhtKacRotator::dump_bytes());
     }
 
     void save(char* data) const override {
-        std::memcpy(data, flip_.data(), sizeof(uint8_t) * flip_.size());
+        std::memcpy(data, flip_.data(), FhtKacRotator::dump_bytes());
     }
 
     size_t dump_bytes() const override { return sizeof(uint8_t) * flip_.size(); }
 
-    FhtKacRotator& operator=(const FhtKacRotator& other) {
-        this->dim_ = other.dim_;
-        this->padded_dim_ = other.padded_dim_;
-        this->flip_ = other.flip_;
-        this->trunc_dim_ = other.trunc_dim_;
-        this->fac_ = other.fac_;
-        return *this;
-    }
+    FhtKacRotator& operator=(const FhtKacRotator&) = default;
 
     static void kacs_walk(float* data, size_t len) { simd::kacs_walk(data, len); }
 

include/rabitqlib/core/types.hpp

@@ -10,10 +10,6 @@ namespace quant {
 struct RabitqConfig {
     double t_const = -1;
     explicit RabitqConfig() = default;
-    RabitqConfig(RabitqConfig const&) = default;
-    RabitqConfig(RabitqConfig&&) = default;
-    RabitqConfig& operator=(const RabitqConfig&) = default;
-    RabitqConfig& operator=(RabitqConfig&&) = default;
 };
 }  // namespace quant
 }  // namespace rabitqlib

include/rabitqlib/utils/memory.hpp

@@ -151,29 +151,6 @@ class DefaultInitAlignedAllocator : public AlignedAllocator<T, Alignment, HugePa
     }
 };
 
-template <typename T>
-struct Allocator {
-   public:
-    using value_type = T;
-
-    constexpr Allocator() noexcept = default;
-
-    template <typename U>
-    explicit constexpr Allocator(const Allocator<U>&) noexcept {}
-
-    [[nodiscard]] constexpr T* allocate(std::size_t n) { return ::new T[n]; }
-
-    constexpr void deallocate(T* ptr, [[maybe_unused]] size_t n) noexcept {
-        ::delete[] ptr;
-    }
-
-    // Intercept zero-argument construction to do default initialization.
-    template <typename U>
-    void construct(U* ptr) noexcept(std::is_nothrow_default_constructible_v<U>) {
-        ::new (static_cast<void*>(ptr)) U;
-    }
-};
-
 // Use the same size-aware policy as huge-page-enabled STL storage. Advice is
 // best-effort; actual page sizes remain under the operating system's control.
 template <typename T>

include/rabitqlib/utils/space.hpp

@@ -58,29 +58,13 @@ void scalar_quantize_optimized(
     float lo,
     float delta
 ) {
-    scalar_quantize_normal(result, vec0, dim, lo, delta);
-}
-
-template <>
-inline void scalar_quantize_optimized<uint8_t>(
-    uint8_t* __restrict__ result,
-    const float* __restrict__ vec0,
-    size_t dim,
-    float lo,
-    float delta
-) {
-    simd::scalar_quantize_uint8(result, vec0, dim, lo, delta);
-}
-
-template <>
-inline void scalar_quantize_optimized<uint16_t>(
-    uint16_t* __restrict__ result,
-    const float* __restrict__ vec0,
-    size_t dim,
-    float lo,
-    float delta
-) {
-    simd::scalar_quantize_uint16(result, vec0, dim, lo, delta);
+    if constexpr (std::is_same_v<T, uint8_t>) {
+        simd::scalar_quantize_uint8(result, vec0, dim, lo, delta);
+    } else if constexpr (std::is_same_v<T, uint16_t>) {
+        simd::scalar_quantize_uint16(result, vec0, dim, lo, delta);
+    } else {
+        scalar_quantize_normal(result, vec0, dim, lo, delta);
+    }
 }
 }  // namespace scalar_impl
 
@@ -197,7 +181,7 @@ template <typename T, typename TD>
 void scalar_quantize(
     T* __restrict__ result, const TD* __restrict__ vec0, size_t dim, TD lo, TD delta
 ) {
-    assert_integral<T>();
+    static_assert(std::is_integral_v<T>, "T must be an integral type");
     scalar_impl::scalar_quantize_optimized(result, vec0, dim, lo, delta);
 }
 

include/rabitqlib/utils/tools.hpp

@@ -46,12 +46,23 @@ inline T rand_integer(T min, T max) {
     return distribution(generator);
 }
 
+template <typename T>
+constexpr T div_round_up(T x, T divisor) {
+    static_assert(std::is_integral_v<T>, "T must be an integral type");
+    return (x / divisor) + static_cast<T>((x % divisor) != 0);
+}
+
 constexpr size_t div_round_up(size_t val, size_t div) {
-    return (val / div) + static_cast<size_t>((val % div) != 0);
+    return div_round_up<size_t>(val, div);
 }
 
 constexpr size_t round_up_to_multiple(size_t val, size_t multiple_of) {
-    return multiple_of * (div_round_up(val, multiple_of));
+    return multiple_of * div_round_up(val, multiple_of);
+}
+
+template <typename T>
+constexpr T round_up_to_multiple_of(size_t x, size_t multiple_of) {
+    return round_up_to_multiple(x, multiple_of);
 }
 
 inline size_t floor_log2(size_t x) {
@@ -70,17 +81,6 @@ inline size_t ceil_log2(size_t x) {
 
 inline bool is_powerof2(size_t n) { return n > 0 && (n & (n - 1)) == 0; }
 
-template <typename T>
-constexpr T div_round_up(T x, T divisor) {
-    static_assert(std::is_integral_v<T>, "T must be an integral type");
-    return (x / divisor) + static_cast<T>((x % divisor) != 0);
-}
-
-template <typename T>
-constexpr T round_up_to_multiple_of(size_t x, size_t multiple_of) {
-    return multiple_of * (div_round_up(x, multiple_of));
-}
-
 // Available logical CPUs in the calling context, with a hardware-count fallback.
 size_t total_threads();