faiss 0.6.4 → 0.6.5

data/vendor/faiss/faiss/impl/pipnn/kernels.cpp

@@ -0,0 +1,326 @@
+/*
+ * 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.
+ */
+
+#include <faiss/impl/pipnn/kernels.h>
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <memory>
+#include <typeinfo>
+#include <vector>
+
+#include <faiss/IndexScalarQuantizer.h>
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/utils/Heap.h>
+
+extern "C" {
+
+// this is to keep the clang syntax checker happy
+#ifndef FINTEGER
+#define FINTEGER int
+#endif
+
+/* declare BLAS functions, see http://www.netlib.org/clapack/cblas/ */
+
+int sgemm_(
+        const char* transa,
+        const char* transb,
+        FINTEGER* m,
+        FINTEGER* n,
+        FINTEGER* k,
+        const float* alpha,
+        const float* a,
+        FINTEGER* lda,
+        const float* b,
+        FINTEGER* ldb,
+        float* beta,
+        float* c,
+        FINTEGER* ldc);
+
+int ssyrk_(
+        const char* uplo,
+        const char* trans,
+        FINTEGER* n,
+        FINTEGER* k,
+        float* alpha,
+        float* a,
+        FINTEGER* lda,
+        float* beta,
+        float* c,
+        FINTEGER* ldc);
+}
+
+namespace faiss {
+namespace pipnn {
+
+namespace {
+
+FINTEGER to_finteger(size_t v, const char* what) {
+    FAISS_THROW_IF_NOT_FMT(
+            v <= size_t(std::numeric_limits<FINTEGER>::max()),
+            "PiPNN kernel: %s=%zu exceeds the BLAS integer range",
+            what,
+            v);
+    return static_cast<FINTEGER>(v);
+}
+
+float nan_to_inf(float v) {
+    return std::isnan(v) ? std::numeric_limits<float>::infinity() : v;
+}
+
+/// Top-k in (dist, index) order on a Faiss max-heap. Empty slots are
+/// (+inf, INT32_MAX), so +inf offers still fill them, in index order.
+using TopK = CMax<float, int32_t>;
+constexpr int32_t kEmpty = std::numeric_limits<int32_t>::max();
+
+void topk_init(float* D, int32_t* I, size_t k) {
+    std::fill(D, D + k, std::numeric_limits<float>::infinity());
+    std::fill(I, I + k, kEmpty);
+}
+
+void topk_offer(float* D, int32_t* I, size_t k, float v, int32_t id) {
+    if (TopK::cmp2(D[0], v, I[0], id)) {
+        heap_replace_top<TopK>(k, D, I, v, id);
+    }
+}
+
+/// Sorts the slots by (dist, index); slots never filled become (+inf, -1).
+void topk_finish(float* D, int32_t* I, size_t k) {
+    heap_reorder<TopK>(k, D, I);
+    std::replace(I, I + k, kEmpty, int32_t(-1));
+}
+
+} // namespace
+
+void stripe_assign(
+        const float* points,
+        size_t S,
+        const float* leaders,
+        const float* leader_norms,
+        size_t L,
+        size_t d,
+        Ranking ranking,
+        int fanout,
+        float* scratch,
+        uint16_t* out) {
+    FAISS_THROW_IF_NOT_FMT(
+            L >= 1 && L <= 65535,
+            "stripe_assign: L=%zu must be in [1, 65535]",
+            L);
+    FAISS_THROW_IF_NOT_FMT(
+            fanout >= 1 && size_t(fanout) <= L,
+            "stripe_assign: fanout=%d must be in [1, L=%zu]",
+            fanout,
+            L);
+    FAISS_THROW_IF_NOT_MSG(d >= 1, "stripe_assign: d must be >= 1");
+    FAISS_THROW_IF_NOT_MSG(
+            ranking == Ranking::IP || leader_norms,
+            "stripe_assign: leader_norms is required for the L2 and Angle rankings");
+    if (S == 0) {
+        return;
+    }
+    FINTEGER li = to_finteger(L, "L");
+    FINTEGER si = to_finteger(S, "S");
+    FINTEGER di = to_finteger(d, "d");
+
+    // Column-major BLAS sees row-major scratch (S x L) as L x S, so "T", "N"
+    // gives scratch[i * L + j] = alpha * p_i.l_j + beta * scratch[i * L + j].
+    float alpha = -1;
+    float beta = 0; // BLAS does not read C when beta == 0
+    if (ranking == Ranking::L2) {
+        for (size_t i = 0; i < S; i++) {
+            std::copy(leader_norms, leader_norms + L, scratch + i * L);
+        }
+        alpha = -2;
+        beta = 1;
+    }
+    sgemm_("T",
+           "N",
+           &li,
+           &si,
+           &di,
+           &alpha,
+           leaders,
+           &di,
+           points,
+           &di,
+           &beta,
+           scratch,
+           &li);
+
+    if (ranking == Ranking::Angle) {
+        // A zero-norm leader has no direction: rank it +inf, not the -inf of
+        // a positive dot product divided by 0.
+        for (size_t i = 0; i < S; i++) {
+            float* row = scratch + i * L;
+            for (size_t j = 0; j < L; j++) {
+                const float len = std::sqrt(leader_norms[j]);
+                row[j] = len > 0 ? row[j] / len
+                                 : std::numeric_limits<float>::infinity();
+            }
+        }
+    }
+
+    const size_t f = size_t(fanout);
+    std::vector<float> D(f);
+    std::vector<int32_t> I(f);
+    for (size_t i = 0; i < S; i++) {
+        topk_init(D.data(), I.data(), f);
+        const float* row = scratch + i * L;
+        for (size_t j = 0; j < L; j++) {
+            topk_offer(D.data(), I.data(), f, nan_to_inf(row[j]), int32_t(j));
+        }
+        topk_finish(D.data(), I.data(), f);
+        // L >= fanout and every offer precedes an empty slot, so all fanout
+        // slots are filled, even when the whole row is +inf.
+        for (size_t r = 0; r < f; r++) {
+            out[i * f + r] = uint16_t(I[r]);
+        }
+    }
+}
+
+namespace {
+
+/// Distance from a Gram entry: L2 max(0, ni + nj - 2g), IP -g. NaN is mapped
+/// to +inf before the L2 clamp, which would otherwise turn it into 0.
+float gram_to_distance(bool is_l2, float ni, float nj, float g) {
+    if (is_l2) {
+        const float v = ni + nj - 2 * g;
+        if (std::isnan(v)) {
+            return std::numeric_limits<float>::infinity();
+        }
+        return v < 0 ? 0 : v;
+    }
+    return nan_to_inf(-g);
+}
+
+/// Lower triangle of X X^T, diagonal included, into row-major gram (s x s);
+/// the strict upper triangle is not written.
+void gram_lower(const float* X, size_t s, size_t d, float* gram) {
+    // Column-major BLAS reads X as A = X^T (d x s); the upper triangle of
+    // C = A^T A ("U", "T") is the row-major lower triangle of gram.
+    FINTEGER si = to_finteger(s, "s");
+    FINTEGER di = to_finteger(d, "d");
+    float one = 1;
+    float zero = 0; // BLAS does not read C when beta == 0
+    ssyrk_("U",
+           "T",
+           &si,
+           &di,
+           &one,
+           const_cast<float*>(X),
+           &di,
+           &zero,
+           gram,
+           &si);
+}
+
+} // namespace
+
+void leaf_knn(
+        const float* X,
+        const float* norms,
+        size_t s,
+        size_t d,
+        MetricType metric,
+        int k,
+        float* gram,
+        int32_t* nn_idx,
+        float* nn_dist) {
+    FAISS_THROW_IF_NOT_MSG(
+            metric == METRIC_L2 || metric == METRIC_INNER_PRODUCT,
+            "leaf_knn: metric must be METRIC_L2 or METRIC_INNER_PRODUCT");
+    FAISS_THROW_IF_NOT_MSG(k >= 1, "leaf_knn: k must be >= 1");
+    FAISS_THROW_IF_NOT_MSG(d >= 1, "leaf_knn: d must be >= 1");
+    FAISS_THROW_IF_NOT_MSG(
+            metric == METRIC_INNER_PRODUCT || norms,
+            "leaf_knn: norms is required for METRIC_L2");
+    const size_t kk = size_t(k);
+    for (size_t i = 0; i < s; i++) {
+        topk_init(nn_dist + i * kk, nn_idx + i * kk, kk);
+    }
+    if (s >= 2) {
+        gram_lower(X, s, d, gram);
+    }
+    const bool is_l2 = metric == METRIC_L2;
+    for (size_t i = 1; i < s; i++) {
+        const float* gi = gram + i * s;
+        const float ni = is_l2 ? norms[i] : 0;
+        for (size_t j = 0; j < i; j++) {
+            const float nj = is_l2 ? norms[j] : 0;
+            const float v = gram_to_distance(is_l2, ni, nj, gi[j]);
+            topk_offer(nn_dist + i * kk, nn_idx + i * kk, kk, v, int32_t(j));
+            topk_offer(nn_dist + j * kk, nn_idx + j * kk, kk, v, int32_t(i));
+        }
+    }
+    for (size_t i = 0; i < s; i++) {
+        topk_finish(nn_dist + i * kk, nn_idx + i * kk, kk);
+    }
+}
+
+void pairwise_distances(
+        const float* X,
+        const float* norms,
+        size_t n,
+        size_t d,
+        MetricType metric,
+        float* out) {
+    FAISS_THROW_IF_NOT_MSG(
+            metric == METRIC_L2 || metric == METRIC_INNER_PRODUCT,
+            "pairwise_distances: metric must be METRIC_L2 or METRIC_INNER_PRODUCT");
+    FAISS_THROW_IF_NOT_MSG(d >= 1, "pairwise_distances: d must be >= 1");
+    FAISS_THROW_IF_NOT_MSG(
+            metric == METRIC_INNER_PRODUCT || norms,
+            "pairwise_distances: norms is required for METRIC_L2");
+    if (n == 0) {
+        return;
+    }
+    // Row i reads only its lower part of the Gram scratch; mirrored writes of
+    // earlier rows go to their strict upper triangle.
+    gram_lower(X, n, d, out);
+    const bool is_l2 = metric == METRIC_L2;
+    for (size_t i = 0; i < n; i++) {
+        float* oi = out + i * n;
+        const float ni = is_l2 ? norms[i] : 0;
+        for (size_t j = 0; j < i; j++) {
+            const float nj = is_l2 ? norms[j] : 0;
+            const float v = gram_to_distance(is_l2, ni, nj, oi[j]);
+            oi[j] = v;
+            out[j * n + i] = v;
+        }
+        oi[i] = gram_to_distance(is_l2, ni, ni, oi[i]);
+    }
+}
+
+void gather_rows(
+        const Index& storage,
+        const int32_t* ids,
+        size_t k,
+        float* out) {
+    const size_t d = static_cast<size_t>(storage.d);
+    if (typeid(storage) == typeid(IndexScalarQuantizer)) {
+        // Not reconstruct: ScalarQuantizer::decode opens an OpenMP region, and
+        // a nested region inside the build's dynamic loops crashes libomp.
+        const auto& sq = static_cast<const IndexScalarQuantizer&>(storage);
+        std::unique_ptr<ScalarQuantizer::SQuantizer> quant(
+                sq.sq.select_quantizer());
+        for (size_t i = 0; i < k; i++) {
+            quant->decode_vector(
+                    sq.codes.data() +
+                            static_cast<size_t>(ids[i]) * sq.code_size,
+                    out + i * d);
+        }
+        return;
+    }
+    for (size_t i = 0; i < k; i++) {
+        storage.reconstruct(ids[i], out + i * d);
+    }
+}
+
+} // namespace pipnn
+} // namespace faiss

data/vendor/faiss/faiss/impl/pipnn/kernels.h

@@ -0,0 +1,92 @@
+/*
+ * 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
+
+#include <faiss/MetricType.h>
+#include <faiss/utils/AlignedTable.h>
+#include <cstddef>
+#include <cstdint>
+
+/*
+ * Each kernel makes one BLAS call (sgemm_ or ssyrk_), and results are bitwise
+ * reproducible across thread counts only if that call runs single-threaded.
+ * So call the kernels inside an OpenMP parallel region, or from serial code
+ * only when omp_get_max_threads() == 1, and keep BLAS from threading on its
+ * own: MKL_NUM_THREADS unset or 1, OPENBLAS_NUM_THREADS=1 for pthreads
+ * OpenBLAS, VECLIB_MAXIMUM_THREADS=1 on macOS, OMP_NUM_THREADS=1 for an
+ * OpenMP BLAS in a Faiss build without OpenMP. Inputs should be 64-byte
+ * aligned: some BLAS round differently on differently aligned buffers.
+ */
+
+namespace faiss {
+
+struct Index;
+
+namespace pipnn {
+
+/// Points per stripe item of the partition kernel. Changing it changes graphs.
+constexpr size_t kStripe = 1024;
+
+enum class Ranking : uint8_t { L2 = 0, IP = 1, Angle = 2 };
+
+/// out (S x fanout): each point's nearest leaders in (rank, index) order, with
+/// rank L2 ||l||^2 - 2 p.l, IP -p.l, Angle -p.l / ||l|| (+inf if ||l|| = 0).
+/// NaN ranks +inf. scratch: S * L floats; leader_norms may be null for IP.
+void stripe_assign(
+        const float* points,
+        size_t S,
+        const float* leaders,
+        const float* leader_norms,
+        size_t L,
+        size_t d,
+        Ranking ranking,
+        int fanout,
+        float* scratch,
+        uint16_t* out);
+
+/// k nearest neighbours (s x k) of each leaf point in (dist, index) order;
+/// unfilled slots are -1 / +inf. gram: s * s floats; norms null for IP only.
+void leaf_knn(
+        const float* X,
+        const float* norms,
+        size_t s,
+        size_t d,
+        MetricType metric,
+        int k,
+        float* gram,
+        int32_t* nn_idx,
+        float* nn_dist);
+
+/// n x n distances (L2 clamped at 0, IP -dot); out is also the Gram scratch.
+/// The L2 diagonal is small and non-negative, but not necessarily 0.
+void pairwise_distances(
+        const float* X,
+        const float* norms,
+        size_t n,
+        size_t d,
+        MetricType metric,
+        float* out);
+
+/// Rows ids[0..k) of `storage` as floats into out (k x d). SQ rows are decoded
+/// directly; other types use reconstruct(), which must not open OpenMP regions.
+void gather_rows(
+        const Index& storage,
+        const int32_t* ids,
+        size_t k,
+        float* out);
+
+/// Grows a per-thread scratch table and never shrinks it: AlignedTable::resize
+/// reallocates whenever the rounded capacity changes, shrinking included.
+inline void ensure_size(AlignedTable<float, 64>& table, size_t n) {
+    if (table.size() < n) {
+        table.resize(n);
+    }
+}
+
+} // namespace pipnn
+} // namespace faiss

data/vendor/faiss/faiss/impl/platform_macros.h

@@ -8,6 +8,7 @@
 #pragma once
 
 // basic int types and size_t
+#include <atomic>
 #include <cstdint>
 #include <cstdio>
 
@@ -146,6 +147,33 @@ inline int __builtin_clzll(uint64_t x) {
 #define FAISS_DEPRECATED(msg)
 #endif // GCC or Clang
 
+// Never inlined, so floating-point results do not depend on the compile
+// flags of the call site (e.g. under LTO).
+#if defined(_MSC_VER)
+#define FAISS_NOINLINE __declspec(noinline)
+#elif defined(__clang__)
+#define FAISS_NOINLINE __attribute__((noinline))
+#elif defined(__GNUC__)
+#define FAISS_NOINLINE __attribute__((noinline, noclone))
+#else
+#define FAISS_NOINLINE
+#endif
+
+namespace faiss {
+namespace detail {
+
+template <typename T>
+inline void atomic_fetch_add_relaxed(T& target, T value) {
+#if defined(__cpp_lib_atomic_ref) && __cpp_lib_atomic_ref >= 201806L
+    std::atomic_ref<T>(target).fetch_add(value, std::memory_order_relaxed);
+#else
+    __atomic_fetch_add(&target, value, __ATOMIC_RELAXED);
+#endif
+}
+
+} // namespace detail
+} // namespace faiss
+
 // Localized enablement of imprecise floating point operations
 // You need to use all 3 macros to cover all compilers.
 #if defined(_MSC_VER)
@@ -226,3 +254,20 @@ inline int __builtin_clzll(uint64_t x) {
 #define FAISS_MAYBE_UNUSED [[maybe_unused]]
 #define FAISS_FINAL final
 #endif
+
+/*******************************************************
+ * OpenMP dynamic scheduling
+ *******************************************************/
+
+// Use as schedule(FAISS_OMP_DYNAMIC) or schedule(FAISS_OMP_DYNAMIC, chunk).
+// OpenMP 5.0 makes schedule(dynamic) nonmonotonic, and libomp 12 runs
+// nonmonotonic dynamic loops with its static-steal scheduler, which crashes
+// intermittently under load (libomp itself keeps it off by default). MSVC's
+// OpenMP 2.0 has no schedule modifiers.
+// clang-format off
+#ifdef _MSC_VER
+#define FAISS_OMP_DYNAMIC dynamic
+#else
+#define FAISS_OMP_DYNAMIC monotonic : dynamic
+#endif
+// clang-format on

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

@@ -7,8 +7,6 @@
 
 // -*- c++ -*-
 
-#ifdef COMPILE_SIMD_AVX512
-
 #include <faiss/impl/PolysemousTraining.h>
 #include <faiss/impl/polysemous_training/dispatch.h>
 #include <faiss/utils/popcount.h>
@@ -280,5 +278,3 @@ double distances_cost_update<SIMDLevel::AVX512>(
 
 } // namespace polysemous_training
 } // namespace faiss
-
-#endif // COMPILE_SIMD_AVX512

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

@@ -11,9 +11,14 @@
 #error "THE_SIMD_LEVEL must be defined before including IVFPQScanner_impl.h"
 #endif
 
+#include <algorithm>
+#include <cstring>
+#include <type_traits>
+
 #include <faiss/IndexIVFPQ.h>
 #include <faiss/impl/IDSelector.h>
 #include <faiss/impl/ResultHandler.h>
+#include <faiss/impl/platform_macros.h>
 #include <faiss/impl/pq_code_distance/IVFPQ_QueryTables.h>
 #include <faiss/impl/pq_code_distance/pq_code_distance-inl.h>
 #include <faiss/impl/simd_dispatch.h>
@@ -70,6 +75,48 @@ struct WrappedSearchResult {
     }
 };
 
+/** For each sub-quantizer, a block of codes reads one 1 KB table slice, which
+ * stays in L1; code by code, a table larger than L1 makes every lookup an L1
+ * miss. SL as in PQCodeDistanceScalar. */
+template <SIMDLevel SL>
+void pq_distances_8bit_by_block(
+        size_t M,
+        const float* sim_table,
+        float dis0,
+        size_t n,
+        const uint8_t* codes,
+        float* distances) {
+    constexpr size_t kBlock = 64;
+    constexpr size_t ksub = PQCodeDistanceScalar8<SL>::ksub;
+    for (size_t j0 = 0; j0 < n; j0 += kBlock) {
+        const size_t nb = std::min(kBlock, n - j0);
+        const uint8_t* block = codes + j0 * M;
+        float* acc = distances + j0;
+        std::fill(acc, acc + nb, 0.0f);
+        const float* tab = sim_table;
+        size_t m = 0;
+        for (; m + 4 <= M; m += 4, tab += 4 * ksub) {
+            const uint8_t* c = block + m;
+            for (size_t b = 0; b < nb; b++) {
+                uint32_t w;
+                memcpy(&w, c + b * M, sizeof(w));
+                acc[b] += (tab[w & 255] + tab[ksub + ((w >> 8) & 255)]) +
+                        (tab[2 * ksub + ((w >> 16) & 255)] +
+                         tab[3 * ksub + (w >> 24)]);
+            }
+        }
+        for (; m < M; m++, tab += ksub) {
+            const uint8_t* c = block + m;
+            for (size_t b = 0; b < nb; b++) {
+                acc[b] += tab[c[b * M]];
+            }
+        }
+        for (size_t b = 0; b < nb; b++) {
+            acc[b] += dis0;
+        }
+    }
+}
+
 /*****************************************************
  * Scaning the codes.
  * The scanning functions call their favorite precompute_*
@@ -411,10 +458,8 @@ struct IVFPQScannerT : QueryTables {
             }
         }
 
-#pragma omp critical
-        {
-            indexIVFPQ_stats.n_hamming_pass += n_hamming_pass;
-        }
+        detail::atomic_fetch_add_relaxed(
+                indexIVFPQ_stats.n_hamming_pass, n_hamming_pass);
     }
 
     template <class SearchResultType>
@@ -487,6 +532,29 @@ struct IVFPQScanner : IVFPQScannerT<idx_t, METRIC_TYPE, PQCodeDist>,
                         this->pq.M, this->pq.nbits, this->sim_table, code);
     }
 
+    void distances_to_codes(size_t n, const uint8_t* codes, float* distances)
+            const override {
+        // Where gathers are fast (Intel), the block kernel is faster at
+        // M <= 64, and the per-code gather kernels are faster at M = 128
+        // unless all cores are busy.
+        if constexpr (
+                has_scalar_8bit_kernel<THE_SIMD_LEVEL>() &&
+                std::is_same_v<typename PQCodeDist::PQDecoder, PQDecoder8>) {
+            if (precompute_mode == 2 &&
+                (SIMDConfig::scalar_gather || this->pq.M <= 64)) {
+                pq_distances_8bit_by_block<THE_SIMD_LEVEL>(
+                        this->pq.M,
+                        this->sim_table,
+                        this->dis0,
+                        n,
+                        codes,
+                        distances);
+                return;
+            }
+        }
+        InvertedListScanner::distances_to_codes(n, codes, distances);
+    }
+
     size_t scan_codes(
             size_t ncode,
             const uint8_t* codes,
@@ -560,6 +628,13 @@ InvertedListScanner* make_IVFPQInvertedListScanner<THE_SIMD_LEVEL>(
 
     auto with_decoder = [&]<bool use_sel>() -> InvertedListScanner* {
         if (ivfpq.pq.nbits == 8) {
+            if constexpr (has_scalar_8bit_kernel<THE_SIMD_LEVEL>()) {
+                if (use_scalar_8bit_kernel<THE_SIMD_LEVEL>(ivfpq.pq.M)) {
+                    return make.template operator()<
+                            PQCodeDistanceScalar8Dist<THE_SIMD_LEVEL>,
+                            use_sel>();
+                }
+            }
             return make.template
             operator()<PQCodeDistance<PQDecoder8, THE_SIMD_LEVEL>, use_sel>();
         } else if (ivfpq.pq.nbits == 16) {

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

@@ -102,6 +102,12 @@ template <>
 FlatCodesDistanceComputer* get_PQFlatCodesDistanceComputer<THE_SIMD_LEVEL>(
         const IndexPQ& index) {
     if (index.pq.nbits == 8) {
+        if constexpr (has_scalar_8bit_kernel<THE_SIMD_LEVEL>()) {
+            if (use_scalar_8bit_kernel<THE_SIMD_LEVEL>(index.pq.M)) {
+                return new PQDistanceComputer<
+                        PQCodeDistanceScalar8Dist<THE_SIMD_LEVEL>>(index);
+            }
+        }
         return new PQDistanceComputer<
                 PQCodeDistance<PQDecoder8, THE_SIMD_LEVEL>>(index);
     } else if (index.pq.nbits == 16) {

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

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifdef COMPILE_SIMD_AVX2
-
 #define THE_SIMD_LEVEL SIMDLevel::AVX2
 
 // NOLINTNEXTLINE(facebook-hte-InlineHeader,facebook-unused-include-check)
@@ -19,5 +17,3 @@
 #include <faiss/impl/pq_code_distance/PQDistanceComputer_impl.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader,facebook-unused-include-check)
 #include <faiss/impl/pq_code_distance/IVFPQScanner_impl.h>
-
-#endif // COMPILE_SIMD_AVX2

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

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifdef COMPILE_SIMD_AVX512
-
 #define THE_SIMD_LEVEL SIMDLevel::AVX512
 
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
@@ -19,5 +17,3 @@
 #include <faiss/impl/pq_code_distance/PQDistanceComputer_impl.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/pq_code_distance/IVFPQScanner_impl.h>
-
-#endif // COMPILE_SIMD_AVX512

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

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#ifdef COMPILE_SIMD_ARM_NEON
-
 #define THE_SIMD_LEVEL SIMDLevel::ARM_NEON
 
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
@@ -19,5 +17,3 @@
 #include <faiss/impl/pq_code_distance/PQDistanceComputer_impl.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/pq_code_distance/IVFPQScanner_impl.h>
-
-#endif // COMPILE_SIMD_ARM_NEON

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

@@ -160,6 +160,10 @@ inline void distance_four_codes_avx2_pqdecoder8_m8(
 namespace faiss {
 namespace pq_code_distance {
 
+// On AMD Zen 3/4/5 (SIMDConfig::scalar_gather) the scalar kernel is 0-48%
+// faster than these gathers at M = 8-384; on Intel the gathers are faster.
+// The callers select it with use_scalar_8bit_kernel().
+
 // NOLINTNEXTLINE(facebook-hte-MisplacedTemplateSpecialization)
 template <>
 float pq_code_distance_8bit_single_impl<SIMDLevel::AVX2>(