faiss 0.6.4 → 0.6.5

data/vendor/faiss/faiss/impl/pq_code_distance/pq_code_distance-avx512.h

@@ -18,7 +18,10 @@ namespace pq_code_distance {
 // the AVX2 version, which is somewhat unexpected.
 // This version is kept for completeness.
 //
-// TODO: test for AMD CPUs.
+// On AMD Zen 4/5 (SIMDConfig::scalar_gather) the scalar kernel is up to 48%
+// faster at M >= 16. Below M = 16 this kernel has no gather and its loop is
+// as fast or faster, so it is kept there. The callers select the scalar
+// kernel with use_scalar_8bit_kernel().
 
 // NOLINTNEXTLINE(facebook-hte-MisplacedTemplateSpecialization)
 template <>

data/vendor/faiss/faiss/impl/pq_code_distance/pq_code_distance-generic.cpp

@@ -40,11 +40,16 @@ void pq_scan_8bit(
     });
 }
 
+// NONE: only the files of level SL may instantiate PQCodeDistanceScalar8<SL>.
 float pq_code_distance_8bit_single(
         size_t M,
         const float* sim_table,
         const uint8_t* code) {
     return with_simd_level_with_sve([&]<SIMDLevel SL>() {
+        if (use_scalar_8bit_kernel<SL>(M)) {
+            return PQCodeDistanceScalar8<SIMDLevel::NONE>::distance_single_code(
+                    M, sim_table, code);
+        }
         return pq_code_distance_8bit_single_impl<SL>(M, sim_table, code);
     });
 }
@@ -61,6 +66,20 @@ void pq_code_distance_8bit_four(
         float& result2,
         float& result3) {
     with_simd_level_with_sve([&]<SIMDLevel SL>() {
+        if (use_scalar_8bit_kernel<SL>(M)) {
+            PQCodeDistanceScalar8<SIMDLevel::NONE>::distance_four_codes(
+                    M,
+                    sim_table,
+                    code0,
+                    code1,
+                    code2,
+                    code3,
+                    result0,
+                    result1,
+                    result2,
+                    result3);
+            return;
+        }
         pq_code_distance_8bit_four_impl<SL>(
                 M,
                 sim_table,

data/vendor/faiss/faiss/impl/pq_code_distance/pq_code_distance-generic.h

@@ -20,8 +20,8 @@ inline float pq_code_distance_8bit_single_impl<SIMDLevel::NONE>(
         size_t M,
         const float* sim_table,
         const uint8_t* code) {
-    return PQCodeDistanceScalar<PQDecoder8>::distance_single_code(
-            M, 8, sim_table, code);
+    return PQCodeDistanceScalar<PQDecoder8, SIMDLevel::NONE>::
+            distance_single_code(M, 8, sim_table, code);
 }
 
 // NOLINTNEXTLINE(facebook-hte-MisplacedTemplateSpecialization)
@@ -37,7 +37,7 @@ inline void pq_code_distance_8bit_four_impl<SIMDLevel::NONE>(
         float& result1,
         float& result2,
         float& result3) {
-    PQCodeDistanceScalar<PQDecoder8>::distance_four_codes(
+    PQCodeDistanceScalar<PQDecoder8, SIMDLevel::NONE>::distance_four_codes(
             M,
             8,
             sim_table,
@@ -60,8 +60,8 @@ inline float pq_code_distance_8bit_single_impl<SIMDLevel::ARM_NEON>(
         size_t M,
         const float* sim_table,
         const uint8_t* code) {
-    return PQCodeDistanceScalar<PQDecoder8>::distance_single_code(
-            M, 8, sim_table, code);
+    return PQCodeDistanceScalar<PQDecoder8, SIMDLevel::ARM_NEON>::
+            distance_single_code(M, 8, sim_table, code);
 }
 
 // NOLINTNEXTLINE(facebook-hte-MisplacedTemplateSpecialization)
@@ -77,7 +77,7 @@ inline void pq_code_distance_8bit_four_impl<SIMDLevel::ARM_NEON>(
         float& result1,
         float& result2,
         float& result3) {
-    PQCodeDistanceScalar<PQDecoder8>::distance_four_codes(
+    PQCodeDistanceScalar<PQDecoder8, SIMDLevel::ARM_NEON>::distance_four_codes(
             M,
             8,
             sim_table,

data/vendor/faiss/faiss/impl/pq_code_distance/pq_code_distance-inl.h

@@ -23,6 +23,7 @@
 #include <faiss/impl/ProductQuantizer.h>
 #include <faiss/impl/platform_macros.h>
 #include <faiss/impl/simd_dispatch.h>
+#include <faiss/utils/simd_levels.h>
 
 namespace faiss {
 namespace pq_code_distance {
@@ -62,10 +63,14 @@ namespace pq_code_distance {
  *********************************************************************/
 
 /// Scalar PQ code distance implementation.
-/// Templated only on decoder type, independent of SIMD level.
 /// Used directly by non-PQDecoder8 decoders (PQDecoder16,
 /// PQDecoderGeneric) and as fallback for PQDecoder8 at NONE/NEON.
-template <typename PQDecoderT>
+// SL keeps each SIMD-level TU's instantiation a distinct symbol. Without it
+// the linker merges them and may keep one compiled with -mavx512*, which
+// then runs on the AVX2 path and raises SIGILL on CPUs without AVX512.
+// The default keeps callers outside faiss that name only the decoder (e.g.
+// unicorn/features/encoders/PQFSTable.h) compiling; faiss passes SL itself.
+template <typename PQDecoderT, SIMDLevel SL = SIMDLevel::NONE>
 struct PQCodeDistanceScalar {
     using PQDecoder = PQDecoderT;
 
@@ -124,6 +129,125 @@ struct PQCodeDistanceScalar {
     }
 };
 
+/// 8-bit scalar kernel with four partial sums (one running sum serializes on
+/// add latency). Used instead of the gather kernels where
+/// SIMDConfig::scalar_gather is set. Both functions use the same per-code
+/// summation order (partial sum m % 4, tail into the first), so single-code
+/// and four-code results are bit-identical. SL as in PQCodeDistanceScalar.
+template <SIMDLevel SL>
+struct PQCodeDistanceScalar8 {
+    static constexpr size_t ksub = 256;
+
+    static float distance_single_code(
+            size_t M,
+            const float* tab,
+            const uint8_t* code) {
+        float a[4] = {};
+        size_t m = 0;
+        for (; m + 4 <= M; m += 4, tab += 4 * ksub) {
+            for (size_t j = 0; j < 4; j++) {
+                a[j] += tab[j * ksub + code[m + j]];
+            }
+        }
+        for (; m < M; m++, tab += ksub) {
+            a[0] += tab[code[m]];
+        }
+        return (a[0] + a[1]) + (a[2] + a[3]);
+    }
+
+    static void distance_four_codes(
+            size_t M,
+            const float* tab,
+            const uint8_t* __restrict code0,
+            const uint8_t* __restrict code1,
+            const uint8_t* __restrict code2,
+            const uint8_t* __restrict code3,
+            float& result0,
+            float& result1,
+            float& result2,
+            float& result3) {
+        const uint8_t* codes[4] = {code0, code1, code2, code3};
+        float a[4][4] = {};
+        size_t m = 0;
+        for (; m + 4 <= M; m += 4, tab += 4 * ksub) {
+            for (size_t j = 0; j < 4; j++) {
+                for (size_t c = 0; c < 4; c++) {
+                    a[c][j] += tab[j * ksub + codes[c][m + j]];
+                }
+            }
+        }
+        for (; m < M; m++, tab += ksub) {
+            for (size_t c = 0; c < 4; c++) {
+                a[c][0] += tab[codes[c][m]];
+            }
+        }
+        float* out[4] = {&result0, &result1, &result2, &result3};
+        for (size_t c = 0; c < 4; c++) {
+            *out[c] = (a[c][0] + a[c][1]) + (a[c][2] + a[c][3]);
+        }
+    }
+};
+
+/// SIMDConfig::scalar_gather is set and the gather kernel of level SL is
+/// slower than PQCodeDistanceScalar8: the AVX2 kernel at any M, the AVX-512
+/// kernel at M >= 16. The callers check this once per scan, not per code.
+template <SIMDLevel SL>
+inline bool use_scalar_8bit_kernel(size_t M) {
+    if constexpr (SL == SIMDLevel::AVX2) {
+        return SIMDConfig::scalar_gather;
+    } else if constexpr (SL == SIMDLevel::AVX512) {
+        return SIMDConfig::scalar_gather && M >= 16;
+    } else {
+        return false;
+    }
+}
+
+template <SIMDLevel SL>
+constexpr bool has_scalar_8bit_kernel() {
+    return SL == SIMDLevel::AVX2 || SL == SIMDLevel::AVX512;
+}
+
+/// PQCodeDistance interface of PQCodeDistanceScalar8.
+template <SIMDLevel SL>
+struct PQCodeDistanceScalar8Dist {
+    using PQDecoder = PQDecoder8;
+    static constexpr SIMDLevel simd_level = SL;
+
+    static float distance_single_code(
+            size_t M,
+            size_t /* nbits */,
+            const float* sim_table,
+            const uint8_t* code) {
+        return PQCodeDistanceScalar8<SL>::distance_single_code(
+                M, sim_table, code);
+    }
+
+    static void distance_four_codes(
+            size_t M,
+            size_t /* nbits */,
+            const float* sim_table,
+            const uint8_t* __restrict code0,
+            const uint8_t* __restrict code1,
+            const uint8_t* __restrict code2,
+            const uint8_t* __restrict code3,
+            float& result0,
+            float& result1,
+            float& result2,
+            float& result3) {
+        PQCodeDistanceScalar8<SL>::distance_four_codes(
+                M,
+                sim_table,
+                code0,
+                code1,
+                code2,
+                code3,
+                result0,
+                result1,
+                result2,
+                result3);
+    }
+};
+
 /*********************************************************************
  * Dispatch bridge — function templates for PQDecoder8 SIMD dispatch.
  *
@@ -168,7 +292,7 @@ struct PQCodeDistance {
         if constexpr (std::is_same_v<PQDecoderT, PQDecoder8>) {
             return pq_code_distance_8bit_single_impl<SL>(M, sim_table, code);
         } else {
-            return PQCodeDistanceScalar<PQDecoderT>::distance_single_code(
+            return PQCodeDistanceScalar<PQDecoderT, SL>::distance_single_code(
                     M, nbits, sim_table, code);
         }
     }
@@ -198,7 +322,7 @@ struct PQCodeDistance {
                     result2,
                     result3);
         } else {
-            PQCodeDistanceScalar<PQDecoderT>::distance_four_codes(
+            PQCodeDistanceScalar<PQDecoderT, SL>::distance_four_codes(
                     M,
                     nbits,
                     sim_table,
@@ -250,8 +374,9 @@ FAISS_API void pq_code_distance_8bit_four(
  *
  * Scans all ncodes PQ codes against a precomputed distance table,
  * maintaining a k-nearest-neighbor heap. Uses the SIMD PQ distance
- * kernels (AVX2 gathers, etc.) for the inner loop, with the SIMD
- * gathers inlined into the scan loop in each per-SIMD TU.
+ * kernels (AVX2 gathers, etc.), or PQCodeDistanceScalar8 where
+ * use_scalar_8bit_kernel() selects it, inlined into the scan loop in
+ * each per-SIMD TU.
  *
  * Definitions are in pq_scan_impl.h (per-SIMD TUs) and
  * pq_code_distance-generic.cpp (dispatch wrapper).

data/vendor/faiss/faiss/impl/pq_code_distance/pq_code_distance-sve.cpp

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifdef COMPILE_SIMD_ARM_SVE
-
 #include <arm_sve.h>
 
 #include <faiss/impl/pq_code_distance/pq_code_distance-inl.h>
@@ -351,5 +349,3 @@ void pq_code_distance_8bit_four_impl<SIMDLevel::ARM_SVE>(
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/pq_code_distance/pq_scan_impl.h>
 #undef THE_SIMD_LEVEL
-
-#endif // COMPILE_SIMD_ARM_SVE

data/vendor/faiss/faiss/impl/pq_code_distance/pq_rvv_kernel.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+/* 8-bit product-quantizer code distance for RISC-V Vector.
+ *
+ * Free-standing (no exceptions, heap or threads), so a freestanding RISC-V
+ * target can compile it. pq_code_distance/rvv.cpp calls it; no Buck target
+ * here builds that RISC-V CPU path.
+ *
+ * PQDecoder8 fixes nbits = 8, so ksub = 256 and the scalar loop is
+ *
+ *     for (m = 0; m < M; m++) result += sim_table[m * 256 + code[m]];
+ *
+ * That is a gather, not a contiguous read. RVV issues one vluxei32 per strip:
+ * build the element offset m * 256 + code[m] across the lanes, scale it to
+ * bytes, then index sim_table.
+ *
+ * The offset stays inside uint32 while M * 256 * 4 bytes does. At M = 1024
+ * that is 1 MiB, so no PQ shape in Faiss overflows it.
+ *
+ * The accumulator is LMUL 4, as in utils/simd_impl/distances_rvv_kernel.h.
+ * The lanes add the M terms in a different order than the scalar loop, so
+ * the last bits can differ.
+ */
+
+#include <cstddef>
+#include <cstdint>
+
+#include <riscv_vector.h>
+
+namespace faiss {
+namespace pq_rvv_kernel {
+
+/// Element offsets into sim_table for subquantizers [m, m + vl).
+inline vuint32m4_t row_offsets(size_t m, size_t vl) {
+    // (m + lane) * 256
+    vuint32m4_t row = __riscv_vadd_vx_u32m4(__riscv_vid_v_u32m4(vl), m, vl);
+    return __riscv_vsll_vx_u32m4(row, 8, vl);
+}
+
+/// Byte offsets for one code, given the precomputed row offsets.
+inline vuint32m4_t byte_offsets(
+        vuint32m4_t row_off,
+        const uint8_t* code,
+        size_t m,
+        size_t vl) {
+    vuint8m1_t cb = __riscv_vle8_v_u8m1(code + m, vl);
+    vuint32m4_t idx = __riscv_vzext_vf4_u32m4(cb, vl);
+    // (row + code) * sizeof(float)
+    return __riscv_vsll_vx_u32m4(
+            __riscv_vadd_vv_u32m4(row_off, idx, vl), 2, vl);
+}
+
+inline float reduce(vfloat32m4_t acc, size_t vlmax) {
+    vfloat32m1_t zero = __riscv_vfmv_v_f_f32m1(0.0f, 1);
+    vfloat32m1_t sum = __riscv_vfredusum_vs_f32m4_f32m1(acc, zero, vlmax);
+    return __riscv_vfmv_f_s_f32m1_f32(sum);
+}
+
+/// Distance between a query and one 8-bit PQ code.
+/// @param sim_table  M * 256 floats, laid out (M, ksub)
+inline float distance_8bit(
+        size_t M,
+        const float* sim_table,
+        const uint8_t* code) {
+    const size_t vlmax = __riscv_vsetvlmax_e32m4();
+    vfloat32m4_t acc = __riscv_vfmv_v_f_f32m4(0.0f, vlmax);
+
+    size_t m = 0;
+    while (m < M) {
+        const size_t vl = __riscv_vsetvl_e32m4(M - m);
+        vuint32m4_t off = byte_offsets(row_offsets(m, vl), code, m, vl);
+        vfloat32m4_t v = __riscv_vluxei32_v_f32m4(sim_table, off, vl);
+        // Tail-undisturbed: lanes past vl keep earlier partial sums, and the
+        // final reduction covers vlmax.
+        acc = __riscv_vfadd_vv_f32m4_tu(acc, acc, v, vl);
+        m += vl;
+    }
+    return reduce(acc, vlmax);
+}
+
+} // namespace pq_rvv_kernel
+} // namespace faiss

data/vendor/faiss/faiss/impl/pq_code_distance/pq_scan_impl.h

@@ -19,7 +19,7 @@ namespace pq_code_distance {
 
 namespace {
 
-template <class C>
+template <class C, class PQCodeDist>
 void pq_scan_8bit_at_level(
         size_t M,
         const float* dis_table,
@@ -33,8 +33,9 @@ void pq_scan_8bit_at_level(
     size_t j = 0;
     for (; j + 3 < ncodes; j += 4) {
         float d0, d1, d2, d3;
-        pq_code_distance_8bit_four_impl<THE_SIMD_LEVEL>( // NOLINT(facebook-modularize-issue-check)
+        PQCodeDist::distance_four_codes(
                 M,
+                8,
                 dis_table,
                 codes + j * code_size,
                 codes + (j + 1) * code_size,
@@ -60,8 +61,8 @@ void pq_scan_8bit_at_level(
     }
 
     for (; j < ncodes; j++) {
-        float dis = pq_code_distance_8bit_single_impl<THE_SIMD_LEVEL>( // NOLINT(facebook-modularize-issue-check)
-                M, dis_table, codes + j * code_size);
+        float dis = PQCodeDist::distance_single_code(
+                M, 8, dis_table, codes + j * code_size);
         if (C::cmp(heap_dis[0], dis)) {
             heap_replace_top<C>(k, heap_dis, heap_ids, dis, j);
         }
@@ -92,13 +93,23 @@ void pq_scan_8bit_impl<THE_SIMD_LEVEL>(
         float* heap_dis,
         int64_t* heap_ids,
         bool max_heap) {
-    if (max_heap) {
-        pq_scan_8bit_at_level<CMax<float, int64_t>>(
-                M, dis_table, codes, ncodes, k, heap_dis, heap_ids);
-    } else {
-        pq_scan_8bit_at_level<CMin<float, int64_t>>(
-                M, dis_table, codes, ncodes, k, heap_dis, heap_ids);
+    auto scan = [&]<class PQCodeDist>() {
+        if (max_heap) {
+            pq_scan_8bit_at_level<CMax<float, int64_t>, PQCodeDist>(
+                    M, dis_table, codes, ncodes, k, heap_dis, heap_ids);
+        } else {
+            pq_scan_8bit_at_level<CMin<float, int64_t>, PQCodeDist>(
+                    M, dis_table, codes, ncodes, k, heap_dis, heap_ids);
+        }
+    };
+    if constexpr (has_scalar_8bit_kernel<THE_SIMD_LEVEL>()) {
+        if (use_scalar_8bit_kernel<THE_SIMD_LEVEL>(M)) {
+            scan.template
+            operator()<PQCodeDistanceScalar8Dist<THE_SIMD_LEVEL>>();
+            return;
+        }
     }
+    scan.template operator()<PQCodeDistance<PQDecoder8, THE_SIMD_LEVEL>>();
 }
 
 } // namespace pq_code_distance

data/vendor/faiss/faiss/impl/pq_code_distance/rvv.cpp

@@ -5,14 +5,15 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifdef COMPILE_SIMD_RISCV_RVV
+#include <riscv_vector.h>
 
 #include <faiss/impl/pq_code_distance/pq_code_distance-inl.h>
+#include <faiss/impl/pq_code_distance/pq_rvv_kernel.h>
 
 namespace faiss {
 namespace pq_code_distance {
 
-// RISCV_RVV: no RVV-optimized PQ code distance exists yet. Use scalar.
+// The kernel lives in pq_rvv_kernel.h. See that header for the gather layout.
 
 // NOLINTNEXTLINE(facebook-hte-MisplacedTemplateSpecialization)
 template <>
@@ -20,8 +21,7 @@ float pq_code_distance_8bit_single_impl<SIMDLevel::RISCV_RVV>(
         size_t M,
         const float* sim_table,
         const uint8_t* code) {
-    return PQCodeDistanceScalar<PQDecoder8>::distance_single_code(
-            M, 8, sim_table, code);
+    return pq_rvv_kernel::distance_8bit(M, sim_table, code);
 }
 
 // NOLINTNEXTLINE(facebook-hte-MisplacedTemplateSpecialization)
@@ -37,18 +37,47 @@ void pq_code_distance_8bit_four_impl<SIMDLevel::RISCV_RVV>(
         float& result1,
         float& result2,
         float& result3) {
-    PQCodeDistanceScalar<PQDecoder8>::distance_four_codes(
-            M,
-            8,
-            sim_table,
-            code0,
-            code1,
-            code2,
-            code3,
-            result0,
-            result1,
-            result2,
-            result3);
+    const size_t vlmax = __riscv_vsetvlmax_e32m4();
+    vfloat32m4_t acc0 = __riscv_vfmv_v_f_f32m4(0.0f, vlmax);
+    vfloat32m4_t acc1 = __riscv_vfmv_v_f_f32m4(0.0f, vlmax);
+    vfloat32m4_t acc2 = __riscv_vfmv_v_f_f32m4(0.0f, vlmax);
+    vfloat32m4_t acc3 = __riscv_vfmv_v_f_f32m4(0.0f, vlmax);
+
+    size_t m = 0;
+    while (m < M) {
+        const size_t vl = __riscv_vsetvl_e32m4(M - m);
+        // The row term is the same for all four codes, so compute it once.
+        vuint32m4_t row_off = pq_rvv_kernel::row_offsets(m, vl);
+
+        vfloat32m4_t v0 = __riscv_vluxei32_v_f32m4(
+                sim_table,
+                pq_rvv_kernel::byte_offsets(row_off, code0, m, vl),
+                vl);
+        vfloat32m4_t v1 = __riscv_vluxei32_v_f32m4(
+                sim_table,
+                pq_rvv_kernel::byte_offsets(row_off, code1, m, vl),
+                vl);
+        vfloat32m4_t v2 = __riscv_vluxei32_v_f32m4(
+                sim_table,
+                pq_rvv_kernel::byte_offsets(row_off, code2, m, vl),
+                vl);
+        vfloat32m4_t v3 = __riscv_vluxei32_v_f32m4(
+                sim_table,
+                pq_rvv_kernel::byte_offsets(row_off, code3, m, vl),
+                vl);
+
+        acc0 = __riscv_vfadd_vv_f32m4_tu(acc0, acc0, v0, vl);
+        acc1 = __riscv_vfadd_vv_f32m4_tu(acc1, acc1, v1, vl);
+        acc2 = __riscv_vfadd_vv_f32m4_tu(acc2, acc2, v2, vl);
+        acc3 = __riscv_vfadd_vv_f32m4_tu(acc3, acc3, v3, vl);
+
+        m += vl;
+    }
+
+    result0 = pq_rvv_kernel::reduce(acc0, vlmax);
+    result1 = pq_rvv_kernel::reduce(acc1, vlmax);
+    result2 = pq_rvv_kernel::reduce(acc2, vlmax);
+    result3 = pq_rvv_kernel::reduce(acc3, vlmax);
 }
 
 } // namespace pq_code_distance
@@ -66,5 +95,3 @@ void pq_code_distance_8bit_four_impl<SIMDLevel::RISCV_RVV>(
 #include <faiss/impl/pq_code_distance/IVFPQScanner_impl.h>
 
 #undef THE_SIMD_LEVEL
-
-#endif // COMPILE_SIMD_RISCV_RVV

data/vendor/faiss/faiss/impl/residual_quantizer_encode_steps.cpp

@@ -17,6 +17,7 @@
 
 #include <faiss/impl/approx_topk/approx_topk.h>
 #include <faiss/impl/approx_topk/rq_beam_search_tab.h>
+#include <faiss/impl/platform_macros.h>
 
 extern "C" {
 
@@ -367,7 +368,7 @@ void beam_search_encode_step_tab(
 
     // Resolve SIMD level once, not per iteration of the n-parallel loop.
     with_simd_level_256bit([&]<SIMDLevel SL>() {
-#pragma omp parallel for if (n > 100) schedule(dynamic)
+#pragma omp parallel for if (n > 100) schedule(FAISS_OMP_DYNAMIC)
         for (int64_t i = 0; i < static_cast<int64_t>(n); i++) {
             std::vector<float> cent_distances(beam_size * K);
             std::vector<float> cd_common(K);

data/vendor/faiss/faiss/impl/result_handler/avx2.cpp

@@ -8,8 +8,6 @@
 // AVX2 specialisation of Top1 add_results (8-wide branchless argmin/argmax).
 // Reservoir stays on the NONE path — VPCOMPRESSPS requires AVX512F.
 
-#ifdef COMPILE_SIMD_AVX2
-
 #include <faiss/impl/ResultHandler.h>
 
 #include <immintrin.h>
@@ -129,5 +127,3 @@ void top1_add_results_tpl<CMin<float, int64_t>, true, SIMDLevel::AVX2>(
 }
 
 } // namespace faiss
-
-#endif // COMPILE_SIMD_AVX2

data/vendor/faiss/faiss/impl/result_handler/avx512.cpp

@@ -11,8 +11,6 @@
 // Reservoir: VPCOMPRESSPS / VPCOMPRESSD bulk-insert of passing elements,
 //            eliminating the per-element threshold branch entirely.
 
-#ifdef COMPILE_SIMD_AVX512
-
 #include <faiss/impl/ResultHandler.h>
 #include <faiss/utils/popcount.h>
 
@@ -277,5 +275,3 @@ void reservoir_add_results_tpl<CMin<float, int64_t>, true, SIMDLevel::AVX512>(
 }
 
 } // namespace faiss
-
-#endif // COMPILE_SIMD_AVX512

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

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifdef COMPILE_SIMD_AVX2
-
 #include <faiss/impl/EDENQuantizer.h>
 #include <faiss/impl/simdlib/simdlib_avx2.h>
 
@@ -68,5 +66,3 @@ void compute_code_dot_lut_batch_8_avx2(
 } // namespace eden_distance
 
 } // namespace faiss
-
-#endif

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

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifdef COMPILE_SIMD_AVX512
-
 #include <faiss/impl/EDENQuantizer.h>
 #include <faiss/impl/simdlib/simdlib_avx2.h>
 #include <faiss/impl/simdlib/simdlib_avx512.h>
@@ -224,5 +222,3 @@ void compute_code_dot_lut_batch_16_avx512(
 } // namespace eden_distance
 
 } // namespace faiss
-
-#endif

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

@@ -22,7 +22,11 @@ using SQDistanceComputer = ScalarQuantizer::SQDistanceComputer;
  * code-to-vector or code-to-code comparisons
  *******************************************************************/
 
-template <class Quantizer, class Similarity, SIMDLevel SL>
+template <
+        class Quantizer,
+        class Similarity,
+        SIMDLevel SL,
+        bool four_acc = false>
 struct DCTemplate : SQDistanceComputer {};
 
 template <class Quantizer, class Similarity>