faiss 0.6.4 → 0.6.5

data/vendor/faiss/faiss/impl/PiPNN.h

@@ -0,0 +1,122 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <vector>
+
+#include <faiss/MetricType.h>
+#include <faiss/impl/maybe_owned_vector.h>
+
+namespace faiss {
+
+struct DistanceComputer;
+struct IDSelector;
+struct Index;
+struct PiPNN;
+struct VisitedTable;
+
+namespace pipnn {
+
+// Internal build pieces, exposed for tests; hidden from SWIG.
+#ifndef SWIG
+
+/// Points per medoid block. It fixes the summation order of the mean, so
+/// changing it changes the entry point.
+constexpr size_t kMedoidBlock = size_t(1) << 16;
+
+/// Throws unless every vector is finite with squared norm <= FLT_MAX / 8, and
+/// returns the L2 medoid: the point closest to the mean, lowest id on ties.
+int32_t medoid_and_validate(const Index& storage, float* norm_cv = nullptr);
+
+/// RobustPrune of x (row 0 of the m x m D) over cand[t] (row 1 + t) in
+/// (D, id) order; writes <= R ids to out, -1 padded. order: m - 1 ints.
+void robust_prune(
+        const float* D,
+        size_t m,
+        const int32_t* cand,
+        MetricType metric,
+        float alpha,
+        int R,
+        int* order,
+        int32_t* out);
+
+namespace detail {
+
+/// PiPNN::build with a given reservoir chunk size, for tests.
+void build_with_chunk(
+        PiPNN& p,
+        const Index& storage,
+        size_t reservoir_chunk,
+        bool verbose);
+
+} // namespace detail
+
+#endif // SWIG
+
+} // namespace pipnn
+
+/// PiPNN graph (Rubel et al., KDD '26, arXiv:2602.21247).
+struct PiPNN {
+    // build parameters
+    int R = 64;              ///< max out-degree
+    int leaf_k = 2;          ///< neighbours each point offers per leaf
+    int hash_bits = 12;      ///< HashPrune keeps one candidate per hash bucket
+    int reservoir_size = 64; ///< candidates kept per point
+    int c_max = 1024;        ///< largest leaf
+    int c_min = 128;         ///< smaller partition children are merged
+    int leader_cap = 1000;   ///< most leaders per split
+    float leader_fraction = 0.005f; ///< leaders per split, fraction of its size
+    float alpha = 0;                ///< 0 = 1.2
+    std::vector<int> fanout = {10, 3}; ///< leaders joined per depth, then 1
+    int64_t seed = 1234;
+    /// IP: rank partition leaders by angle, not inner product
+    bool ip_partition_by_angle = false;
+    /// point instances per partition wave, which bounds memory
+    size_t partition_wave_budget = size_t(1) << 30;
+
+    int search_L = 64; ///< default beam width of search
+
+    // result
+    MaybeOwnedVector<int32_t> graph; ///< ntotal x R, -1 padded
+    /// next higher row with the same code, or -1; empty if all codes differ.
+    /// Such copies have empty graph rows; search returns them with the first.
+    MaybeOwnedVector<int32_t> next_copy;
+    int32_t entry_point = -1; ///< L2 medoid
+    idx_t ntotal = 0;
+
+    PiPNN() = default;
+    explicit PiPNN(int R) : R(R) {}
+
+    float effective_alpha(MetricType metric) const;
+
+    void check_params() const;
+
+#ifndef SWIG
+    /// Builds over the vectors and metric of storage. Strong guarantee: the
+    /// results are unchanged if it throws.
+    void build(const Index& storage, bool verbose = false);
+
+    /// Beam max(L, k); qdis smaller-is-better; vt: ntotal slots, clean in/out.
+    /// Writes the k nearest in sel by (dis, id), padded; sel does not prune.
+    void search(
+            DistanceComputer& qdis,
+            int L,
+            idx_t k,
+            idx_t* I,
+            float* D,
+            VisitedTable& vt,
+            const IDSelector* sel) const;
+#endif
+
+    /// Empties the graph; entry_point = -1, ntotal = 0.
+    void reset();
+};
+
+} // namespace faiss

data/vendor/faiss/faiss/impl/ProductQuantizer.cpp

@@ -9,6 +9,8 @@
 
 #include <faiss/impl/ProductQuantizer.h>
 
+#include <omp.h>
+#include <atomic>
 #include <cstddef>
 #include <cstdio>
 #include <cstring>
@@ -16,10 +18,12 @@
 #include <type_traits>
 
 #include <algorithm>
+#include <atomic>
 
 #include <faiss/IndexFlat.h>
 #include <faiss/VectorTransform.h>
 #include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/FaissException.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/pq_code_distance/pq_code_distance-inl.h>
 #include <faiss/impl/simd_dispatch.h>
@@ -141,8 +145,8 @@ void ProductQuantizer::train(size_t n, const float* x) {
             }
         }
 
-        std::unique_ptr<float[]> xslice(new float[n * dsub]);
-        for (size_t m = 0; m < M; m++) {
+        const auto train_slice = [&](size_t m) {
+            std::unique_ptr<float[]> xslice(new float[n * dsub]);
             for (size_t j = 0; j < n; j++)
                 memcpy(xslice.get() + j * dsub,
                        x + j * d + m * dsub,
@@ -150,7 +154,6 @@ void ProductQuantizer::train(size_t n, const float* x) {
 
             Clustering clus(dsub, ksub, cp);
 
-            // we have some initialization for the centroids
             if (final_train_type != Train_default) {
                 clus.centroids.resize(dsub * ksub);
             }
@@ -187,6 +190,28 @@ void ProductQuantizer::train(size_t n, const float* x) {
             IndexFlatL2 index(dsub);
             clus.train(n, xslice.get(), assign_index ? *assign_index : index);
             set_params(clus.centroids.data(), m);
+        };
+
+        if (!assign_index && x != centroids.data() && M > 1 &&
+            M * 8 >= static_cast<size_t>(omp_get_max_threads())) {
+            std::exception_ptr ex;
+            std::atomic<bool> failed{false};
+#pragma omp parallel for
+            for (int64_t m = 0; m < static_cast<int64_t>(M); m++) {
+                if (failed) {
+                    continue;
+                }
+                try {
+                    train_slice(m);
+                } catch (...) {
+                    omp_capture_exception(ex, [&] { failed = true; });
+                }
+            }
+            omp_rethrow_if_exception(ex);
+        } else {
+            for (size_t m = 0; m < M; m++) {
+                train_slice(m);
+            }
         }
 
     } else {
@@ -422,10 +447,21 @@ void ProductQuantizer::compute_codes(const float* x, uint8_t* codes, size_t n)
 
     int64_t n_signed = n;
     if (dsub < 16) { // simple direct computation
+        std::exception_ptr ex;
+        std::atomic<bool> interrupt{false};
 
 #pragma omp parallel for
-        for (int64_t i = 0; i < n_signed; i++)
-            compute_code(x + i * d, codes + i * code_size);
+        for (int64_t i = 0; i < n_signed; i++) {
+            if (interrupt.load(std::memory_order_relaxed)) {
+                continue;
+            }
+            try {
+                compute_code(x + i * d, codes + i * code_size);
+            } catch (...) {
+                omp_capture_exception(ex, [&] { interrupt = true; });
+            }
+        }
+        omp_rethrow_if_exception(ex);
 
     } else { // worthwhile to use BLAS
         std::unique_ptr<float[]> dis_tables(new float[n * ksub * M]);
@@ -489,8 +525,12 @@ void ProductQuantizer::compute_distance_tables(
         const float* x,
         float* dis_tables) const {
     int64_t nx_signed = nx;
-#if defined(COMPILE_SIMD_AVX2) || defined(COMPILE_SIMD_ARM_NEON)
-    if (dsub == 2 && nbits < 8) { // interesting for a narrow range of settings
+#if defined(COMPILE_SIMD_AVX2) || defined(COMPILE_SIMD_ARM_NEON) || \
+        defined(COMPILE_SIMD_RISCV_RVV)
+    // The dsub2 kernels help for a narrow range of settings. They require
+    // ksub = 1 << nbits to be a multiple of 8. Therefore nbits must be 3 or
+    // more.
+    if (dsub == 2 && nbits >= 3 && nbits < 8) {
         compute_PQ_dis_tables_dsub2(
                 d, ksub, centroids.data(), nx, x, false, dis_tables);
     } else
@@ -524,8 +564,9 @@ void ProductQuantizer::compute_inner_prod_tables(
         const float* x,
         float* dis_tables) const {
     int64_t nx_signed = nx;
-#if defined(COMPILE_SIMD_AVX2) || defined(COMPILE_SIMD_ARM_NEON)
-    if (dsub == 2 && nbits < 8) {
+#if defined(COMPILE_SIMD_AVX2) || defined(COMPILE_SIMD_ARM_NEON) || \
+        defined(COMPILE_SIMD_RISCV_RVV)
+    if (dsub == 2 && nbits >= 3 && nbits < 8) {
         compute_PQ_dis_tables_dsub2(
                 d, ksub, centroids.data(), nx, x, true, dis_tables);
     } else
@@ -872,8 +913,9 @@ void ProductQuantizer::search_sdc(
             float* heap_dis = res->val + i * k;
             const uint8_t* qcode = qcodes + i * code_size;
 
-            if (init_finalize_heap)
+            if (init_finalize_heap) {
                 maxheap_heapify(k, heap_dis, heap_ids);
+            }
 
             // Precompute per-subquantizer row pointers: q_row[m] points to
             // sdc_table[m*ksub^2 + qcode[m]*ksub], eliminating M
@@ -897,8 +939,9 @@ void ProductQuantizer::search_sdc(
                 bcode += code_size;
             }
 
-            if (init_finalize_heap)
+            if (init_finalize_heap) {
                 maxheap_reorder(k, heap_dis, heap_ids);
+            }
         }
     }
 }

data/vendor/faiss/faiss/impl/RaBitQUtils.h

@@ -353,7 +353,7 @@ inline int extract_code_inline(
  * The multi-bit distance combines the sign bit (1-bit) with additional
  * magnitude bits (ex_bits) to compute a more accurate distance estimate.
  * Uses SIMD-optimized bit-plane decomposition (AVX2+BMI2) for ex_bits 1-7,
- * with scalar fallback for non-x86 or non-BMI2 platforms.
+ * with scalar fallback for non-x86 platforms.
  *
  * @param sign_bits       unpacked sign bits (1-bit codes in standard format)
  * @param ex_code         packed ex-bit codes

data/vendor/faiss/faiss/impl/RaBitQuantizer.cpp

@@ -6,12 +6,14 @@
  */
 
 #include <faiss/impl/RaBitQuantizer.h>
+#include <faiss/utils/prefetch.h>
 
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/IDSelector.h>
 #include <faiss/impl/RaBitQUtils.h>
 #include <faiss/impl/RaBitQuantizerMultiBit.h>
 #include <faiss/impl/ResultHandler.h>
+#include <faiss/impl/platform_macros.h>
 #include <faiss/impl/simd_dispatch.h>
 #include <faiss/invlists/DirectMap.h>
 #include <faiss/utils/distances.h>
@@ -27,6 +29,11 @@ namespace faiss {
 
 RaBitQStats rabitq_stats;
 
+void RaBitQStats::add_atomic(const RaBitQStats& other) {
+    detail::atomic_fetch_add_relaxed(n_1bit, other.n_1bit);
+    detail::atomic_fetch_add_relaxed(n_refine, other.n_refine);
+}
+
 // Import shared utilities from RaBitQUtils
 using rabitq_utils::ExtraBitsFactors;
 using rabitq_utils::QueryFactorsData;
@@ -296,27 +303,10 @@ struct RaBitQDistanceComputerNotQ final : RaBitQDistanceComputer {
     float distance_to_code_1bit_impl(
             const uint8_t* binary_data,
             const SignBitFactors* base_fac) const {
-        // this is the baseline code
-        //
-        // compute <q,o> using floats
-        float dot_qo = 0;
-        // It was a willful decision (after the discussion) to not to pre-cache
-        //   the sum of all bits, just in order to reduce the overhead per
-        //   vector.
-        uint64_t sum_q = 0;
-
-        for (size_t i = 0; i < d; i++) {
-            // Extract i-th bit
-            bool bit = rabitq_utils::extract_bit_standard(binary_data, i);
-            // accumulate dp
-            dot_qo += bit ? rotated_q[i] : 0;
-            // accumulate sum-of-bits
-            sum_q += bit ? 1 : 0;
-        }
+        const float dot_qo = fvec_masked_sum<simd512_level_selector<SL>::value>(
+                rotated_q.data(), binary_data, d);
 
-        // Apply query factors
-        float final_dot =
-                query_fac.c1 * dot_qo + query_fac.c2 * sum_q - query_fac.c34;
+        float final_dot = query_fac.c1 * dot_qo - query_fac.c34;
 
         // pre_dist = ||or - c||^2 + ||qr - c||^2 -
         //     2 * ||or - c|| * ||qr - c|| * <q,o> - (IP ? ||or||^2 : 0)
@@ -418,7 +408,6 @@ struct RaBitQDistanceComputerNotQ final : RaBitQDistanceComputer {
         }
 
         query_fac.c1 = 2 * inv_d;
-        query_fac.c2 = 0;
         query_fac.c34 = sum_q * inv_d;
 
         if (metric_type == MetricType::METRIC_INNER_PRODUCT) {
@@ -475,7 +464,9 @@ struct RaBitQDistanceComputerNotQ final : RaBitQDistanceComputer {
                 const float dis = distance_to_code_full(codes);
                 idx_t id = store_pairs ? lo_build(list_no, j) : ids[j];
 
-                if (handler.add_result(dis, id)) {
+                if ((keep_max ? dis > handler.threshold
+                              : dis < handler.threshold) &&
+                    handler.add_result(dis, id)) {
                     handler.stats.nheap_updates++;
                     nup++;
                 }
@@ -520,8 +511,6 @@ struct RaBitQDistanceComputerQ final : RaBitQDistanceComputer {
         float final_dot = 0;
         if (centered) {
             int64_t int_dot = ((1 << qb) - 1) * d;
-            // See RaBitDistanceComputerNotQ::distance_to_code() for
-            // baseline code.
             int_dot -= 2 *
                     rabitq::bitwise_xor_dot_product<SL>(
                                rearranged_rotated_qq.data(),
@@ -572,6 +561,42 @@ struct RaBitQDistanceComputerQ final : RaBitQDistanceComputer {
         return distance_to_code_1bit_impl(code, base_fac, size);
     }
 
+    void distance_to_code_1bit_batch_4(
+            const uint8_t* const* codes_in,
+            float* distances) final {
+        if (qb != 4 || centered) {
+            RaBitQDistanceComputer::distance_to_code_1bit_batch_4(
+                    codes_in, distances);
+            return;
+        }
+        const size_t size = (d + 7) / 8;
+        const size_t prefix = size +
+                (nb_bits == 1 ? sizeof(SignBitFactors)
+                              : sizeof(SignBitFactorsWithError));
+        for (int i = 0; i < 4; ++i) {
+            for (size_t offset = 0; offset < prefix; offset += 64) {
+                prefetch_L1(codes_in[i] + offset);
+            }
+        }
+        rabitq::BitwiseAndDotProductResult results[4];
+        rabitq::bitwise_q4_batch_4<SL>(
+                rearranged_rotated_qq.data(), codes_in, size, results);
+        for (int i = 0; i < 4; ++i) {
+            const auto* factors =
+                    reinterpret_cast<const SignBitFactors*>(codes_in[i] + size);
+            float final_dot = 0;
+            final_dot += query_fac.c1 * results[i].dot_product;
+            final_dot += query_fac.c2 * results[i].popcount;
+            final_dot -= query_fac.c34;
+            const float pre_dist = factors->or_minus_c_l2sqr +
+                    query_fac.qr_to_c_L2sqr -
+                    2 * factors->dp_multiplier * final_dot;
+            distances[i] = metric_type == METRIC_L2
+                    ? std::max(0.0f, pre_dist)
+                    : -0.5f * (pre_dist - query_fac.qr_norm_L2sqr);
+        }
+    }
+
     // Compute full distance using 1-bit + ex-bits (accurate)
     float distance_to_code_full(const uint8_t* code) final {
         FAISS_ASSERT(code != nullptr);
@@ -660,51 +685,50 @@ struct RaBitQDistanceComputerQ final : RaBitQDistanceComputer {
             bool keep_max,
             ResultHandler& handler) final {
         const size_t code_size_base = (d + 7) / 8;
-        const size_t ex_bits = nb_bits - 1;
-        FAISS_ASSERT(ex_bits > 0);
 
-        // Honor IDSelectorWithContext on the multibit path too, so a RaBitQ
-        // index does not silently lose the context hook once nb_bits >= 2 (the
-        // 1-bit path already routes through run_scan_codes1).
         const IDSelectorContextDispatch sel_dispatch(sel, store_pairs);
 
-        size_t nup = 0;
-        for (size_t j = 0; j < list_size; j++) {
-            if (sel != nullptr) {
-                idx_t id = store_pairs ? lo_build(list_no, j) : ids[j];
-                if (!sel_dispatch.is_member(
-                            id, IDScanContext{ids, list_size, j})) {
-                    codes += code_size;
-                    continue;
+        auto scan = [&](auto multibit) {
+            size_t nup = 0;
+            for (size_t j = 0; j < list_size; j++, codes += code_size) {
+                if (sel != nullptr) {
+                    idx_t id = store_pairs ? lo_build(list_no, j) : ids[j];
+                    if (!sel_dispatch.is_member(
+                                id, IDScanContext{ids, list_size, j})) {
+                        continue;
+                    }
                 }
-            }
 
-            const auto* base_fac =
-                    reinterpret_cast<const SignBitFactorsWithError*>(
-                            codes + code_size_base);
-            const float est_distance =
-                    distance_to_code_1bit_impl(codes, base_fac, code_size_base);
-
-            const bool should_refine = rabitq_utils::should_refine_candidate(
-                    est_distance,
-                    base_fac->f_error,
-                    g_error,
-                    handler.threshold,
-                    keep_max);
-            if (should_refine) {
+                const auto* base_fac =
+                        reinterpret_cast<const SignBitFactorsWithError*>(
+                                codes + code_size_base);
+                float dis = distance_to_code_1bit_impl(
+                        codes, base_fac, code_size_base);
+
+                if constexpr (decltype(multibit)::value) {
+                    if (!rabitq_utils::should_refine_candidate(
+                                dis,
+                                base_fac->f_error,
+                                g_error,
+                                handler.threshold,
+                                keep_max)) {
+                        continue;
+                    }
+                    dis = distance_to_code_full(codes);
+                }
                 handler.stats.scan_cnt++;
-                const float dis = distance_to_code_full(codes);
                 idx_t id = store_pairs ? lo_build(list_no, j) : ids[j];
 
-                if (handler.add_result(dis, id)) {
+                if ((keep_max ? dis > handler.threshold
+                              : dis < handler.threshold) &&
+                    handler.add_result(dis, id)) {
                     handler.stats.nheap_updates++;
                     nup++;
                 }
             }
-            codes += code_size;
-        }
-
-        return nup;
+            return nup;
+        };
+        return nb_bits == 1 ? scan(std::false_type{}) : scan(std::true_type{});
     }
 };
 

data/vendor/faiss/faiss/impl/RaBitQuantizer.h

@@ -40,6 +40,8 @@ struct RaBitQStats {
         n_refine += other.n_refine;
     }
 
+    void add_atomic(const RaBitQStats& other);
+
     double refine_ratio() const {
         return n_1bit ? double(n_refine) / double(n_1bit) : 0.0;
     }
@@ -157,6 +159,19 @@ struct RaBitQDistanceComputer : FlatCodesDistanceComputer {
     // Compute 1-bit distance estimate (fast)
     virtual float distance_to_code_1bit(const uint8_t* code) = 0;
 
+    /// Compute four one-bit estimates in input order. Caller must call
+    /// set_query() first. Each pointer addresses one complete encoded row; rows
+    /// need not be contiguous or distinct. The output holds four floats.
+    /// Does not refine candidates, update thresholds, or increment stats. The
+    /// default calls the single estimate four times.
+    virtual void distance_to_code_1bit_batch_4(
+            const uint8_t* const* codes_in,
+            float* distances) {
+        for (size_t i = 0; i < 4; ++i) {
+            distances[i] = distance_to_code_1bit(codes_in[i]);
+        }
+    }
+
     // Compute full multi-bit distance (accurate)
     virtual float distance_to_code_full(const uint8_t* code) = 0;
 

data/vendor/faiss/faiss/impl/ScalarQuantizer.cpp

@@ -453,6 +453,35 @@ float unit_norm_component_scale(size_t d) {
 
 } // namespace
 
+void ScalarQuantizer::SQDistanceComputer::query_to_codes_batch_4(
+        const uint8_t* code_0,
+        const uint8_t* code_1,
+        const uint8_t* code_2,
+        const uint8_t* code_3,
+        float& dis0,
+        float& dis1,
+        float& dis2,
+        float& dis3) const {
+    dis0 = query_to_code(code_0);
+    dis1 = query_to_code(code_1);
+    dis2 = query_to_code(code_2);
+    dis3 = query_to_code(code_3);
+}
+
+namespace scalar_quantizer {
+
+void IVFCoarseDistanceScanner::set_list(idx_t list_no_in, float coarse_dis_in) {
+    this->list_no = list_no_in;
+    this->coarse_dis = coarse_dis_in;
+}
+
+float IVFCoarseDistanceScanner::distance_to_code(
+        const uint8_t* /*code*/) const {
+    return coarse_dis;
+}
+
+} // namespace scalar_quantizer
+
 /*******************************************************************
  * ScalarQuantizer implementation
  ********************************************************************/

data/vendor/faiss/faiss/impl/ScalarQuantizer.h

@@ -133,12 +133,7 @@ struct ScalarQuantizer : Quantizer {
                 float& dis0,
                 float& dis1,
                 float& dis2,
-                float& dis3) const {
-            dis0 = query_to_code(code_0);
-            dis1 = query_to_code(code_1);
-            dis2 = query_to_code(code_2);
-            dis3 = query_to_code(code_3);
-        }
+                float& dis3) const;
 
         float distance_to_code(const uint8_t* code) final {
             return query_to_code(code);

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

@@ -8,8 +8,6 @@
 // Explicit template instantiations of HeapWithBucketsCMaxFloat and
 // accum_and_*_tab for SIMDLevel::AVX2.
 
-#ifdef COMPILE_SIMD_AVX2
-
 #include <faiss/impl/approx_topk/rq_beam_search_tab-inl.h>
 #include <faiss/impl/approx_topk/simdlib256-inl.h>
 #include <faiss/impl/simdlib/simdlib_avx2.h>
@@ -64,5 +62,3 @@ INSTANTIATE_ACCUM_TAB(8)
 #undef INSTANTIATE_ACCUM_TAB
 
 } // namespace faiss
-
-#endif // COMPILE_SIMD_AVX2

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

@@ -8,8 +8,6 @@
 // Explicit template instantiations of HeapWithBucketsCMaxFloat and
 // accum_and_*_tab for SIMDLevel::ARM_NEON.
 
-#ifdef COMPILE_SIMD_ARM_NEON
-
 #include <faiss/impl/approx_topk/rq_beam_search_tab-inl.h>
 #include <faiss/impl/approx_topk/simdlib256-inl.h>
 #include <faiss/impl/simdlib/simdlib_neon.h>
@@ -64,5 +62,3 @@ INSTANTIATE_ACCUM_TAB(8)
 #undef INSTANTIATE_ACCUM_TAB
 
 } // namespace faiss
-
-#endif // COMPILE_SIMD_ARM_NEON

data/vendor/faiss/faiss/impl/binary_hamming/IndexBinaryHash_impl.h

@@ -139,11 +139,14 @@ void search_single_query_template(
     } while (fe.next());
 }
 
+// A hash type with internal linkage makes the functions of the set local.
+struct ShortlistHash : std::hash<idx_t> {};
+
 template <class HammingComputer, class SearchResults>
 static void verify_shortlist(
         const IndexBinaryFlat* index,
         const uint8_t* q,
-        const std::unordered_set<idx_t>& shortlist,
+        const std::unordered_set<idx_t, ShortlistHash>& shortlist,
         SearchResults& res) {
     size_t code_size = index->code_size;
 
@@ -164,7 +167,7 @@ void search_1_query_multihash(
         size_t& n0,
         size_t& nlist,
         size_t& ndis) {
-    std::unordered_set<idx_t> shortlist;
+    std::unordered_set<idx_t, ShortlistHash> shortlist;
     int b = index.b;
 
     BitstringReader br(xi, index.code_size);

data/vendor/faiss/faiss/impl/binary_hamming/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)
@@ -22,5 +20,3 @@
 #include <faiss/impl/binary_hamming/IndexIVFSpectralHash_impl.h> // IWYU pragma: keep
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/binary_hamming/IndexPQ_impl.h>
-
-#endif // COMPILE_SIMD_AVX2

data/vendor/faiss/faiss/impl/binary_hamming/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)
@@ -22,5 +20,3 @@
 #include <faiss/impl/binary_hamming/IndexIVFSpectralHash_impl.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/binary_hamming/IndexPQ_impl.h>
-
-#endif // COMPILE_SIMD_AVX512

data/vendor/faiss/faiss/impl/binary_hamming/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)
@@ -22,5 +20,3 @@
 #include <faiss/impl/binary_hamming/IndexIVFSpectralHash_impl.h>
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/binary_hamming/IndexPQ_impl.h>
-
-#endif // COMPILE_SIMD_ARM_NEON