faiss 0.6.2 → 0.6.3

data/vendor/faiss/faiss/impl/scalar_quantizer/quantizers.h

@@ -147,14 +147,13 @@ struct QuantizerTemplate<
 };
 
 /*******************************************************************
- * TurboQuant MSE quantizer
+ * Lloyd-Max scalar quantizer
  *******************************************************************/
 template <int NBits, SIMDLevel SL>
-struct QuantizerTurboQuantMSE;
+struct QuantizerLloydMax;
 
 template <int NBits>
-struct QuantizerTurboQuantMSE<NBits, SIMDLevel::NONE>
-        : ScalarQuantizer::SQuantizer {
+struct QuantizerLloydMax<NBits, SIMDLevel::NONE> : ScalarQuantizer::SQuantizer {
     static_assert(NBits >= 1 && NBits <= 8);
 
     static constexpr size_t kCentroidsCount = size_t(1) << NBits;
@@ -165,7 +164,7 @@ struct QuantizerTurboQuantMSE<NBits, SIMDLevel::NONE>
     const float* centroids;
     const float* boundaries;
 
-    QuantizerTurboQuantMSE(size_t d_in, const std::vector<float>& trained)
+    QuantizerLloydMax(size_t d_in, const std::vector<float>& trained)
             : d(d_in), centroids(nullptr), boundaries(nullptr) {
         FAISS_THROW_IF_NOT(trained.size() == 2 * kCentroidsCount - 1);
         centroids = trained.data();
@@ -221,11 +220,13 @@ struct QuantizerTurboQuantMSE<NBits, SIMDLevel::NONE>
 };
 
 template <int NBits, SIMDLevel SL>
-struct QuantizerTurboQuantMSE : QuantizerTurboQuantMSE<NBits, SIMDLevel::NONE> {
-    using QuantizerTurboQuantMSE<NBits, SIMDLevel::NONE>::
-            QuantizerTurboQuantMSE;
+struct QuantizerLloydMax : QuantizerLloydMax<NBits, SIMDLevel::NONE> {
+    using QuantizerLloydMax<NBits, SIMDLevel::NONE>::QuantizerLloydMax;
 };
 
+template <int NBits, SIMDLevel SL>
+using QuantizerTurboQuantMSE = QuantizerLloydMax<NBits, SL>;
+
 /*******************************************************************
  * FP16 quantizer
  *******************************************************************/

data/vendor/faiss/faiss/impl/scalar_quantizer/sq-avx2.cpp

@@ -232,7 +232,7 @@ struct QuantizerTemplate<
 };
 
 /**********************************************************
- * TurboQuant MSE quantizer
+ * Lloyd-Max scalar quantizer
  **********************************************************/
 
 // 1-bit MSE: boundary is always at centroids midpoint.
@@ -240,11 +240,11 @@ struct QuantizerTemplate<
 // Decode: gather 8 centroids via index unpack.
 // NOLINTNEXTLINE(facebook-hte-MisplacedTemplateSpecialization,facebook-hte-ShadowingClass)
 template <>
-struct QuantizerTurboQuantMSE<1, SIMDLevel::AVX2>
-        : QuantizerTurboQuantMSE<1, SIMDLevel::NONE> {
-    using Base = QuantizerTurboQuantMSE<1, SIMDLevel::NONE>;
+struct QuantizerLloydMax<1, SIMDLevel::AVX2>
+        : QuantizerLloydMax<1, SIMDLevel::NONE> {
+    using Base = QuantizerLloydMax<1, SIMDLevel::NONE>;
 
-    QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained)
+    QuantizerLloydMax(size_t d, const std::vector<float>& trained)
             : Base(d, trained) {
         assert(d % 8 == 0);
     }
@@ -279,11 +279,11 @@ struct QuantizerTurboQuantMSE<1, SIMDLevel::AVX2>
 // Decode: gather via index unpack.
 // NOLINTNEXTLINE(facebook-hte-MisplacedTemplateSpecialization,facebook-hte-ShadowingClass)
 template <>
-struct QuantizerTurboQuantMSE<2, SIMDLevel::AVX2>
-        : QuantizerTurboQuantMSE<2, SIMDLevel::NONE> {
-    using Base = QuantizerTurboQuantMSE<2, SIMDLevel::NONE>;
+struct QuantizerLloydMax<2, SIMDLevel::AVX2>
+        : QuantizerLloydMax<2, SIMDLevel::NONE> {
+    using Base = QuantizerLloydMax<2, SIMDLevel::NONE>;
 
-    QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained)
+    QuantizerLloydMax(size_t d, const std::vector<float>& trained)
             : Base(d, trained) {
         assert(d % 8 == 0);
     }
@@ -334,15 +334,15 @@ struct QuantizerTurboQuantMSE<2, SIMDLevel::AVX2>
     }
 };
 
-// 3-bit and 4-bit MSE: use branchless comparison chain for encode.
+// 3-bit and 4-bit Lloyd-Max: use branchless comparison chain for encode.
 // k boundaries → idx = sum of k-1 comparisons.
-#define DEFINE_TQMSE_AVX2_MULTIBIT(NBITS, UNPACK_EXPR)                       \
+#define DEFINE_LLOYD_MAX_AVX2_MULTIBIT(NBITS, UNPACK_EXPR)                   \
     template <>                                                              \
-    struct QuantizerTurboQuantMSE<NBITS, SIMDLevel::AVX2>                    \
-            : QuantizerTurboQuantMSE<NBITS, SIMDLevel::NONE> {               \
-        using Base = QuantizerTurboQuantMSE<NBITS, SIMDLevel::NONE>;         \
+    struct QuantizerLloydMax<NBITS, SIMDLevel::AVX2>                         \
+            : QuantizerLloydMax<NBITS, SIMDLevel::NONE> {                    \
+        using Base = QuantizerLloydMax<NBITS, SIMDLevel::NONE>;              \
                                                                              \
-        QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained)  \
+        QuantizerLloydMax(size_t d, const std::vector<float>& trained)       \
                 : Base(d, trained) {                                         \
             assert(d % 8 == 0);                                              \
         }                                                                    \
@@ -362,18 +362,18 @@ struct QuantizerTurboQuantMSE<2, SIMDLevel::AVX2>
         }                                                                    \
     }
 
-DEFINE_TQMSE_AVX2_MULTIBIT(3, unpack_8x3bit_to_u32(code, i));
-DEFINE_TQMSE_AVX2_MULTIBIT(4, unpack_8x4bit_to_u32(code, i));
+DEFINE_LLOYD_MAX_AVX2_MULTIBIT(3, unpack_8x3bit_to_u32(code, i));
+DEFINE_LLOYD_MAX_AVX2_MULTIBIT(4, unpack_8x4bit_to_u32(code, i));
 
-#undef DEFINE_TQMSE_AVX2_MULTIBIT
+#undef DEFINE_LLOYD_MAX_AVX2_MULTIBIT
 
-// 8-bit MSE: indices are raw bytes, no bit packing.
+// 8-bit Lloyd-Max: indices are raw bytes, no bit packing.
 template <>
-struct QuantizerTurboQuantMSE<8, SIMDLevel::AVX2>
-        : QuantizerTurboQuantMSE<8, SIMDLevel::NONE> {
-    using Base = QuantizerTurboQuantMSE<8, SIMDLevel::NONE>;
+struct QuantizerLloydMax<8, SIMDLevel::AVX2>
+        : QuantizerLloydMax<8, SIMDLevel::NONE> {
+    using Base = QuantizerLloydMax<8, SIMDLevel::NONE>;
 
-    QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained)
+    QuantizerLloydMax(size_t d, const std::vector<float>& trained)
             : Base(d, trained) {
         assert(d % 8 == 0);
     }
@@ -787,6 +787,68 @@ struct DistanceComputerByte<Similarity, SIMDLevel::AVX2> : SQDistanceComputer {
     }
 };
 
+template <class Similarity>
+struct DistanceComputerByteSigned<Similarity, SIMDLevel::AVX2>
+        : SQDistanceComputer {
+    using Sim = Similarity;
+
+    int d;
+    std::vector<uint8_t> tmp;
+
+    DistanceComputerByteSigned(int d, const std::vector<float>&)
+            : d(d), tmp(d) {}
+
+    int compute_code_distance(const uint8_t* code1, const uint8_t* code2)
+            const {
+        // codes store value + 128. madd_epi16 is signed, so IP unbiases the
+        // bytes before multiplying; for L2 the +128 cancels in the difference.
+        // Only dispatched for d % 16 == 0, so the loop needs no tail.
+        __m256i accu = _mm256_setzero_si256();
+        for (int i = 0; i < d; i += 16) {
+            __m256i c1 = _mm256_cvtepu8_epi16(
+                    _mm_loadu_si128((const __m128i*)(code1 + i)));
+            __m256i c2 = _mm256_cvtepu8_epi16(
+                    _mm_loadu_si128((const __m128i*)(code2 + i)));
+            __m256i prod32;
+            if (Sim::metric_type == METRIC_INNER_PRODUCT) {
+                const __m256i bias = _mm256_set1_epi16(128);
+                c1 = _mm256_sub_epi16(c1, bias);
+                c2 = _mm256_sub_epi16(c2, bias);
+                prod32 = _mm256_madd_epi16(c1, c2);
+            } else {
+                __m256i diff = _mm256_sub_epi16(c1, c2);
+                prod32 = _mm256_madd_epi16(diff, diff);
+            }
+            accu = _mm256_add_epi32(accu, prod32);
+        }
+        __m128i sum = _mm256_extractf128_si256(accu, 0);
+        sum = _mm_add_epi32(sum, _mm256_extractf128_si256(accu, 1));
+        sum = _mm_hadd_epi32(sum, sum);
+        sum = _mm_hadd_epi32(sum, sum);
+        return _mm_cvtsi128_si32(sum);
+    }
+
+    void set_query(const float* x) final {
+        for (int i = 0; i < d; i++) {
+            tmp[i] = uint8_t(int(x[i]) + 128);
+        }
+    }
+
+    int compute_distance(const float* x, const uint8_t* code) {
+        set_query(x);
+        return compute_code_distance(tmp.data(), code);
+    }
+
+    float symmetric_dis(idx_t i, idx_t j) override {
+        return compute_code_distance(
+                codes + i * code_size, codes + j * code_size);
+    }
+
+    float query_to_code(const uint8_t* code) const final {
+        return compute_code_distance(tmp.data(), code);
+    }
+};
+
 /**********************************************************
  * TurboQuant masked_sum AVX2 specialization
  **********************************************************/

data/vendor/faiss/faiss/impl/scalar_quantizer/sq-avx512-impl.h

@@ -241,41 +241,41 @@ struct QuantizerTemplate<
 };
 
 /**********************************************************
- * TurboQuant MSE quantizer
+ * Lloyd-Max scalar quantizer
  **********************************************************/
 
-#define DEFINE_TQMSE_AVX512_SPECIALIZATION(NBITS, INDEX_EXPR)               \
-    template <>                                                             \
-    struct QuantizerTurboQuantMSE<NBITS, SIMDLevel::AVX512>                 \
-            : QuantizerTurboQuantMSE<NBITS, SIMDLevel::NONE> {              \
-        using Base = QuantizerTurboQuantMSE<NBITS, SIMDLevel::NONE>;        \
-                                                                            \
-        QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained) \
-                : Base(d, trained) {                                        \
-            assert(d % 16 == 0);                                            \
-        }                                                                   \
-                                                                            \
-        FAISS_ALWAYS_INLINE simd16float32                                   \
-        reconstruct_16_components(const uint8_t* code, int i) const {       \
-            const __m512i indices = (INDEX_EXPR);                           \
-            return simd16float32(_mm512_i32gather_ps(                       \
-                    indices, this->centroids, sizeof(float)));              \
-        }                                                                   \
-    }
-
-DEFINE_TQMSE_AVX512_SPECIALIZATION(1, unpack_16x1bit_to_u32(code, i));
-DEFINE_TQMSE_AVX512_SPECIALIZATION(2, unpack_16x2bit_to_u32(code, i));
-DEFINE_TQMSE_AVX512_SPECIALIZATION(3, unpack_16x3bit_to_u32(code, i));
-DEFINE_TQMSE_AVX512_SPECIALIZATION(4, unpack_16x4bit_to_u32(code, i));
-
-#undef DEFINE_TQMSE_AVX512_SPECIALIZATION
+#define DEFINE_LLOYD_MAX_AVX512_SPECIALIZATION(NBITS, INDEX_EXPR)      \
+    template <>                                                        \
+    struct QuantizerLloydMax<NBITS, SIMDLevel::AVX512>                 \
+            : QuantizerLloydMax<NBITS, SIMDLevel::NONE> {              \
+        using Base = QuantizerLloydMax<NBITS, SIMDLevel::NONE>;        \
+                                                                       \
+        QuantizerLloydMax(size_t d, const std::vector<float>& trained) \
+                : Base(d, trained) {                                   \
+            assert(d % 16 == 0);                                       \
+        }                                                              \
+                                                                       \
+        FAISS_ALWAYS_INLINE simd16float32                              \
+        reconstruct_16_components(const uint8_t* code, int i) const {  \
+            const __m512i indices = (INDEX_EXPR);                      \
+            return simd16float32(_mm512_i32gather_ps(                  \
+                    indices, this->centroids, sizeof(float)));         \
+        }                                                              \
+    }
+
+DEFINE_LLOYD_MAX_AVX512_SPECIALIZATION(1, unpack_16x1bit_to_u32(code, i));
+DEFINE_LLOYD_MAX_AVX512_SPECIALIZATION(2, unpack_16x2bit_to_u32(code, i));
+DEFINE_LLOYD_MAX_AVX512_SPECIALIZATION(3, unpack_16x3bit_to_u32(code, i));
+DEFINE_LLOYD_MAX_AVX512_SPECIALIZATION(4, unpack_16x4bit_to_u32(code, i));
+
+#undef DEFINE_LLOYD_MAX_AVX512_SPECIALIZATION
 
 template <>
-struct QuantizerTurboQuantMSE<8, SIMDLevel::AVX512>
-        : QuantizerTurboQuantMSE<8, SIMDLevel::NONE> {
-    using Base = QuantizerTurboQuantMSE<8, SIMDLevel::NONE>;
+struct QuantizerLloydMax<8, SIMDLevel::AVX512>
+        : QuantizerLloydMax<8, SIMDLevel::NONE> {
+    using Base = QuantizerLloydMax<8, SIMDLevel::NONE>;
 
-    QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained)
+    QuantizerLloydMax(size_t d, const std::vector<float>& trained)
             : Base(d, trained) {
         assert(d % 16 == 0);
     }

data/vendor/faiss/faiss/impl/scalar_quantizer/sq-avx512-spr.cpp

@@ -100,14 +100,13 @@ struct Quantizer8bitDirectSigned<SIMDLevel::AVX512_SPR>
 };
 
 /**********************************************************
- * TurboQuant MSE — inherit AVX512 implementations
+ * Lloyd-Max scalar quantizer - inherit AVX512 implementations
  **********************************************************/
 
 template <int NBits>
-struct QuantizerTurboQuantMSE<NBits, SIMDLevel::AVX512_SPR>
-        : QuantizerTurboQuantMSE<NBits, SIMDLevel::AVX512> {
-    using QuantizerTurboQuantMSE<NBits, SIMDLevel::AVX512>::
-            QuantizerTurboQuantMSE;
+struct QuantizerLloydMax<NBits, SIMDLevel::AVX512_SPR>
+        : QuantizerLloydMax<NBits, SIMDLevel::AVX512> {
+    using QuantizerLloydMax<NBits, SIMDLevel::AVX512>::QuantizerLloydMax;
 };
 
 /**********************************************************

data/vendor/faiss/faiss/impl/scalar_quantizer/sq-avx512.cpp

@@ -250,16 +250,16 @@ struct QuantizerTemplate<
 };
 
 /**********************************************************
- * TurboQuant MSE quantizer
+ * Lloyd-Max scalar quantizer
  **********************************************************/
 
-// 1-bit MSE AVX512: 16 comparisons → 2 bytes via mask compare.
+// 1-bit Lloyd-Max AVX512: 16 comparisons → 2 bytes via mask compare.
 template <>
-struct QuantizerTurboQuantMSE<1, SIMDLevel::AVX512>
-        : QuantizerTurboQuantMSE<1, SIMDLevel::NONE> {
-    using Base = QuantizerTurboQuantMSE<1, SIMDLevel::NONE>;
+struct QuantizerLloydMax<1, SIMDLevel::AVX512>
+        : QuantizerLloydMax<1, SIMDLevel::NONE> {
+    using Base = QuantizerLloydMax<1, SIMDLevel::NONE>;
 
-    QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained)
+    QuantizerLloydMax(size_t d, const std::vector<float>& trained)
             : Base(d, trained) {
         assert(d % 16 == 0);
     }
@@ -291,14 +291,14 @@ struct QuantizerTurboQuantMSE<1, SIMDLevel::AVX512>
     }
 };
 
-// 2-4 bit MSE AVX512: decode via gather, encode stays scalar.
-#define DEFINE_TQMSE_AVX512_MULTIBIT(NBITS, UNPACK_EXPR)                      \
+// 2-4 bit Lloyd-Max AVX512: decode via gather, encode stays scalar.
+#define DEFINE_LLOYD_MAX_AVX512_MULTIBIT(NBITS, UNPACK_EXPR)                  \
     template <>                                                               \
-    struct QuantizerTurboQuantMSE<NBITS, SIMDLevel::AVX512>                   \
-            : QuantizerTurboQuantMSE<NBITS, SIMDLevel::NONE> {                \
-        using Base = QuantizerTurboQuantMSE<NBITS, SIMDLevel::NONE>;          \
+    struct QuantizerLloydMax<NBITS, SIMDLevel::AVX512>                        \
+            : QuantizerLloydMax<NBITS, SIMDLevel::NONE> {                     \
+        using Base = QuantizerLloydMax<NBITS, SIMDLevel::NONE>;               \
                                                                               \
-        QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained)   \
+        QuantizerLloydMax(size_t d, const std::vector<float>& trained)        \
                 : Base(d, trained) {                                          \
             assert(d % 16 == 0);                                              \
         }                                                                     \
@@ -318,19 +318,19 @@ struct QuantizerTurboQuantMSE<1, SIMDLevel::AVX512>
         }                                                                     \
     }
 
-DEFINE_TQMSE_AVX512_MULTIBIT(2, unpack_16x2bit_to_u32(code, i));
-DEFINE_TQMSE_AVX512_MULTIBIT(3, unpack_16x3bit_to_u32(code, i));
-DEFINE_TQMSE_AVX512_MULTIBIT(4, unpack_16x4bit_to_u32(code, i));
+DEFINE_LLOYD_MAX_AVX512_MULTIBIT(2, unpack_16x2bit_to_u32(code, i));
+DEFINE_LLOYD_MAX_AVX512_MULTIBIT(3, unpack_16x3bit_to_u32(code, i));
+DEFINE_LLOYD_MAX_AVX512_MULTIBIT(4, unpack_16x4bit_to_u32(code, i));
 
-#undef DEFINE_TQMSE_AVX512_MULTIBIT
+#undef DEFINE_LLOYD_MAX_AVX512_MULTIBIT
 
-// 8-bit MSE AVX512
+// 8-bit Lloyd-Max AVX512
 template <>
-struct QuantizerTurboQuantMSE<8, SIMDLevel::AVX512>
-        : QuantizerTurboQuantMSE<8, SIMDLevel::NONE> {
-    using Base = QuantizerTurboQuantMSE<8, SIMDLevel::NONE>;
+struct QuantizerLloydMax<8, SIMDLevel::AVX512>
+        : QuantizerLloydMax<8, SIMDLevel::NONE> {
+    using Base = QuantizerLloydMax<8, SIMDLevel::NONE>;
 
-    QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained)
+    QuantizerLloydMax(size_t d, const std::vector<float>& trained)
             : Base(d, trained) {
         assert(d % 16 == 0);
     }
@@ -677,24 +677,36 @@ struct DistanceComputerByte<Similarity, SIMDLevel::AVX512>
 
     int compute_code_distance(const uint8_t* code1, const uint8_t* code2)
             const {
-        // compute 16 lanes of 32-bit products (16-bytes) at once for
+        // compute 32 lanes of 16-bit products (32-bytes) at once for
         // the supported metrics
         __m512i accu = _mm512_setzero_si512();
-        constexpr int kLanes = 16;
-        for (int i = 0; i < d; i += kLanes) {
-            __m128i c1 = _mm_loadu_si128((__m128i*)(code1 + i));
-            __m128i c2 = _mm_loadu_si128((__m128i*)(code2 + i));
-            __m512i c1i = _mm512_cvtepu8_epi32(c1);
-            __m512i c2i = _mm512_cvtepu8_epi32(c2);
-
-            __m512i v;
+        constexpr int kLanes = 32;
+        int i = 0;
+        for (; i + kLanes <= d; i += kLanes) {
+            __m256i c1 = _mm256_loadu_epi8(code1 + i);
+            __m256i c2 = _mm256_loadu_epi8(code2 + i);
+            __m512i c1i16 = _mm512_cvtepu8_epi16(c1);
+            __m512i c2i16 = _mm512_cvtepu8_epi16(c2);
             if (Sim::metric_type == METRIC_INNER_PRODUCT) {
-                v = _mm512_mullo_epi32(c1i, c2i);
+                accu = _mm512_add_epi32(accu, _mm512_madd_epi16(c1i16, c2i16));
             } else {
-                __m512i diff = _mm512_sub_epi32(c1i, c2i);
-                v = _mm512_mullo_epi32(diff, diff);
+                __m512i diff = _mm512_sub_epi16(c1i16, c2i16);
+                accu = _mm512_add_epi32(accu, _mm512_madd_epi16(diff, diff));
+            }
+        }
+        // tail handling for dimensions not divisible by 32
+        if (i < d) {
+            __mmask32 mask = (__mmask32)((1ULL << (d - i)) - 1ULL);
+            __m256i c1 = _mm256_maskz_loadu_epi8(mask, code1 + i);
+            __m256i c2 = _mm256_maskz_loadu_epi8(mask, code2 + i);
+            __m512i c1i16 = _mm512_cvtepu8_epi16(c1);
+            __m512i c2i16 = _mm512_cvtepu8_epi16(c2);
+            if (Sim::metric_type == METRIC_INNER_PRODUCT) {
+                accu = _mm512_add_epi32(accu, _mm512_madd_epi16(c1i16, c2i16));
+            } else {
+                __m512i diff = _mm512_sub_epi16(c1i16, c2i16);
+                accu = _mm512_add_epi32(accu, _mm512_madd_epi16(diff, diff));
             }
-            accu = _mm512_add_epi32(accu, v);
         }
         return _mm512_reduce_add_epi32(accu);
     }
@@ -720,6 +732,61 @@ struct DistanceComputerByte<Similarity, SIMDLevel::AVX512>
     }
 };
 
+template <class Similarity>
+struct DistanceComputerByteSigned<Similarity, SIMDLevel::AVX512>
+        : SQDistanceComputer {
+    using Sim = Similarity;
+
+    int d;
+    std::vector<uint8_t> tmp;
+
+    DistanceComputerByteSigned(int d, const std::vector<float>&)
+            : d(d), tmp(d) {}
+
+    int compute_code_distance(const uint8_t* code1, const uint8_t* code2)
+            const {
+        // codes store value + 128. madd_epi16 is signed, so IP unbiases the
+        // bytes before multiplying; for L2 the +128 cancels in the difference.
+        // Only dispatched for d % 32 == 0, so the loop needs no tail.
+        __m512i accu = _mm512_setzero_si512();
+        constexpr int kLanes = 32;
+        for (int i = 0; i + kLanes <= d; i += kLanes) {
+            __m512i c1 = _mm512_cvtepu8_epi16(_mm256_loadu_epi8(code1 + i));
+            __m512i c2 = _mm512_cvtepu8_epi16(_mm256_loadu_epi8(code2 + i));
+            if (Sim::metric_type == METRIC_INNER_PRODUCT) {
+                const __m512i bias = _mm512_set1_epi16(128);
+                c1 = _mm512_sub_epi16(c1, bias);
+                c2 = _mm512_sub_epi16(c2, bias);
+                accu = _mm512_add_epi32(accu, _mm512_madd_epi16(c1, c2));
+            } else {
+                __m512i diff = _mm512_sub_epi16(c1, c2);
+                accu = _mm512_add_epi32(accu, _mm512_madd_epi16(diff, diff));
+            }
+        }
+        return _mm512_reduce_add_epi32(accu);
+    }
+
+    void set_query(const float* x) final {
+        for (int i = 0; i < d; i++) {
+            tmp[i] = uint8_t(int(x[i]) + 128);
+        }
+    }
+
+    int compute_distance(const float* x, const uint8_t* code) {
+        set_query(x);
+        return compute_code_distance(tmp.data(), code);
+    }
+
+    float symmetric_dis(idx_t i, idx_t j) override {
+        return compute_code_distance(
+                codes + i * code_size, codes + j * code_size);
+    }
+
+    float query_to_code(const uint8_t* code) const final {
+        return compute_code_distance(tmp.data(), code);
+    }
+};
+
 /**********************************************************
  * TurboQuant masked_sum AVX512 specialization
  **********************************************************/

data/vendor/faiss/faiss/impl/scalar_quantizer/sq-dispatch.h

@@ -416,6 +416,34 @@ ScalarQuantizer::SQuantizer* sq_select_quantizer<THE_LEVEL_TO_DISPATCH>(
             return new QuantizerTurboQuantMSE<4, SL>(d, trained);
         case ScalarQuantizer::QT_8bit_tqmse:
             return new QuantizerTurboQuantMSE<8, SL>(d, trained);
+        case ScalarQuantizer::QT_1bit_eden:
+            return new QuantizerLloydMax<1, SL>(d, trained);
+        case ScalarQuantizer::QT_2bit_eden:
+            return new QuantizerLloydMax<2, SL>(d, trained);
+        case ScalarQuantizer::QT_3bit_eden:
+            return new QuantizerLloydMax<3, SL>(d, trained);
+        case ScalarQuantizer::QT_4bit_eden:
+            return new QuantizerLloydMax<4, SL>(d, trained);
+        case ScalarQuantizer::QT_5bit_eden:
+            if constexpr (SL != SIMDLevel::NONE) {
+                return nullptr;
+            } else {
+                return new QuantizerLloydMax<5, SL>(d, trained);
+            }
+        case ScalarQuantizer::QT_6bit_eden:
+            if constexpr (SL != SIMDLevel::NONE) {
+                return nullptr;
+            } else {
+                return new QuantizerLloydMax<6, SL>(d, trained);
+            }
+        case ScalarQuantizer::QT_7bit_eden:
+            if constexpr (SL != SIMDLevel::NONE) {
+                return nullptr;
+            } else {
+                return new QuantizerLloydMax<7, SL>(d, trained);
+            }
+        case ScalarQuantizer::QT_8bit_eden:
+            return new QuantizerLloydMax<8, SL>(d, trained);
         case ScalarQuantizer::QT_2bit_tq:
             return new QuantizerTurboQuantFull<2, SL>(d, trained);
         case ScalarQuantizer::QT_3bit_tq:
@@ -518,6 +546,16 @@ SQDistanceComputer* select_distance_computer_body(
                     return new DistanceComputerByteSigned<Sim, SL2>(
                             static_cast<int>(d), trained);
                 }
+            } else if constexpr (SL2 == SIMDLevel::AVX512) {
+                if (d % 32 == 0) {
+                    return new DistanceComputerByteSigned<Sim, SL2>(
+                            static_cast<int>(d), trained);
+                }
+            } else if constexpr (SL2 == SIMDLevel::AVX2) {
+                if (d % 16 == 0) {
+                    return new DistanceComputerByteSigned<Sim, SL2>(
+                            static_cast<int>(d), trained);
+                }
             }
             return new DCTemplate<Quantizer8bitDirectSigned<SL2>, Sim, SL2>(
                     d, trained);
@@ -539,6 +577,42 @@ SQDistanceComputer* select_distance_computer_body(
         case ScalarQuantizer::QT_8bit_tqmse:
             return new DCTemplate<QuantizerTurboQuantMSE<8, SL2>, Sim, SL2>(
                     d, trained);
+        case ScalarQuantizer::QT_1bit_eden:
+            return new DCTemplate<QuantizerLloydMax<1, SL2>, Sim, SL2>(
+                    d, trained);
+        case ScalarQuantizer::QT_2bit_eden:
+            return new DCTemplate<QuantizerLloydMax<2, SL2>, Sim, SL2>(
+                    d, trained);
+        case ScalarQuantizer::QT_3bit_eden:
+            return new DCTemplate<QuantizerLloydMax<3, SL2>, Sim, SL2>(
+                    d, trained);
+        case ScalarQuantizer::QT_4bit_eden:
+            return new DCTemplate<QuantizerLloydMax<4, SL2>, Sim, SL2>(
+                    d, trained);
+        case ScalarQuantizer::QT_5bit_eden:
+            if constexpr (SL2 != SIMDLevel::NONE) {
+                return nullptr;
+            } else {
+                return new DCTemplate<QuantizerLloydMax<5, SL2>, Sim, SL2>(
+                        d, trained);
+            }
+        case ScalarQuantizer::QT_6bit_eden:
+            if constexpr (SL2 != SIMDLevel::NONE) {
+                return nullptr;
+            } else {
+                return new DCTemplate<QuantizerLloydMax<6, SL2>, Sim, SL2>(
+                        d, trained);
+            }
+        case ScalarQuantizer::QT_7bit_eden:
+            if constexpr (SL2 != SIMDLevel::NONE) {
+                return nullptr;
+            } else {
+                return new DCTemplate<QuantizerLloydMax<7, SL2>, Sim, SL2>(
+                        d, trained);
+            }
+        case ScalarQuantizer::QT_8bit_eden:
+            return new DCTemplate<QuantizerLloydMax<8, SL2>, Sim, SL2>(
+                    d, trained);
         case ScalarQuantizer::QT_2bit_tq:
             // FRICTION: bypasses DCTemplate entirely — custom DC
             // that doesn't fit the Quantizer+Similarity decomposition
@@ -686,6 +760,16 @@ InvertedListScanner* sq_select_InvertedListScanner<THE_LEVEL_TO_DISPATCH>(
                         return scan.template operator()<
                                 DistanceComputerByteSigned<Similarity, SL2>>();
                     }
+                } else if constexpr (SL2 == SIMDLevel::AVX512) {
+                    if (d % 32 == 0) {
+                        return scan.template operator()<
+                                DistanceComputerByteSigned<Similarity, SL2>>();
+                    }
+                } else if constexpr (SL2 == SIMDLevel::AVX2) {
+                    if (d % 16 == 0) {
+                        return scan.template operator()<
+                                DistanceComputerByteSigned<Similarity, SL2>>();
+                    }
                 }
                 return scan.template operator()<DCTemplate<
                         Quantizer8bitDirectSigned<SL2>,
@@ -719,6 +803,58 @@ InvertedListScanner* sq_select_InvertedListScanner<THE_LEVEL_TO_DISPATCH>(
                         QuantizerTurboQuantMSE<8, SL2>,
                         Similarity,
                         SL2>>();
+            case ScalarQuantizer::QT_1bit_eden:
+                return scan.template operator()<DCTemplate<
+                        QuantizerLloydMax<1, SL2>,
+                        Similarity,
+                        SL2>>();
+            case ScalarQuantizer::QT_2bit_eden:
+                return scan.template operator()<DCTemplate<
+                        QuantizerLloydMax<2, SL2>,
+                        Similarity,
+                        SL2>>();
+            case ScalarQuantizer::QT_3bit_eden:
+                return scan.template operator()<DCTemplate<
+                        QuantizerLloydMax<3, SL2>,
+                        Similarity,
+                        SL2>>();
+            case ScalarQuantizer::QT_4bit_eden:
+                return scan.template operator()<DCTemplate<
+                        QuantizerLloydMax<4, SL2>,
+                        Similarity,
+                        SL2>>();
+            case ScalarQuantizer::QT_5bit_eden:
+                if constexpr (SL2 != SIMDLevel::NONE) {
+                    return nullptr;
+                } else {
+                    return scan.template operator()<DCTemplate<
+                            QuantizerLloydMax<5, SL2>,
+                            Similarity,
+                            SL2>>();
+                }
+            case ScalarQuantizer::QT_6bit_eden:
+                if constexpr (SL2 != SIMDLevel::NONE) {
+                    return nullptr;
+                } else {
+                    return scan.template operator()<DCTemplate<
+                            QuantizerLloydMax<6, SL2>,
+                            Similarity,
+                            SL2>>();
+                }
+            case ScalarQuantizer::QT_7bit_eden:
+                if constexpr (SL2 != SIMDLevel::NONE) {
+                    return nullptr;
+                } else {
+                    return scan.template operator()<DCTemplate<
+                            QuantizerLloydMax<7, SL2>,
+                            Similarity,
+                            SL2>>();
+                }
+            case ScalarQuantizer::QT_8bit_eden:
+                return scan.template operator()<DCTemplate<
+                        QuantizerLloydMax<8, SL2>,
+                        Similarity,
+                        SL2>>();
             case ScalarQuantizer::QT_2bit_tq:
                 return scan.template
                 operator()<DCTurboQuantFull<2, Similarity, SL2>>();