faiss 0.5.2 → 0.6.0

data/vendor/faiss/faiss/IndexFlat.cpp

@@ -12,6 +12,7 @@
 #include <faiss/impl/AuxIndexStructures.h>
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/ResultHandler.h>
+#include <faiss/impl/simd_dispatch.h>
 #include <faiss/utils/Heap.h>
 #include <faiss/utils/distances.h>
 #include <faiss/utils/extra_distances.h>
@@ -19,7 +20,6 @@
 #include <faiss/utils/sorting.h>
 #include <omp.h>
 #include <cstring>
-#include <numeric>
 
 namespace faiss {
 
@@ -44,7 +44,6 @@ void IndexFlat::search(
         float_maxheap_array_t res = {size_t(n), size_t(k), labels, distances};
         knn_L2sqr(x, get_xb(), d, n, ntotal, &res, nullptr, sel);
     } else {
-        FAISS_THROW_IF_NOT(!sel); // TODO implement with selector
         knn_extra_metrics(
                 x,
                 get_xb(),
@@ -55,7 +54,8 @@ void IndexFlat::search(
                 metric_arg,
                 k,
                 distances,
-                labels);
+                labels,
+                sel);
     }
 }
 
@@ -100,6 +100,7 @@ void IndexFlat::compute_distance_subset(
 
 namespace {
 
+template <SIMDLevel SL>
 struct FlatL2Dis : FlatCodesDistanceComputer {
     size_t d;
     idx_t nb;
@@ -109,7 +110,7 @@ struct FlatL2Dis : FlatCodesDistanceComputer {
 
     float distance_to_code(const uint8_t* code) final {
         ndis++;
-        return fvec_L2sqr(q, (float*)code, d);
+        return fvec_L2sqr<SL>(q, (float*)code, d);
     }
 
     float partial_dot_product(
@@ -117,12 +118,12 @@ struct FlatL2Dis : FlatCodesDistanceComputer {
             const uint32_t offset,
             const uint32_t num_components) final override {
         npartial_dot_products++;
-        return fvec_inner_product(
+        return fvec_inner_product<SL>(
                 q + offset, b + i * d + offset, num_components);
     }
 
     float symmetric_dis(idx_t i, idx_t j) override {
-        return fvec_L2sqr(b + j * d, b + i * d, d);
+        return fvec_L2sqr<SL>(b + j * d, b + i * d, d);
     }
 
     explicit FlatL2Dis(const IndexFlat& storage, const float* q = nullptr)
@@ -166,7 +167,7 @@ struct FlatL2Dis : FlatCodesDistanceComputer {
         float dp1 = 0;
         float dp2 = 0;
         float dp3 = 0;
-        fvec_L2sqr_batch_4(q, y0, y1, y2, y3, d, dp0, dp1, dp2, dp3);
+        fvec_L2sqr_batch_4<SL>(q, y0, y1, y2, y3, d, dp0, dp1, dp2, dp3);
         dis0 = dp0;
         dis1 = dp1;
         dis2 = dp2;
@@ -200,7 +201,7 @@ struct FlatL2Dis : FlatCodesDistanceComputer {
         float dp1_ = 0;
         float dp2_ = 0;
         float dp3_ = 0;
-        fvec_inner_product_batch_4(
+        fvec_inner_product_batch_4<SL>(
                 q + offset,
                 y0 + offset,
                 y1 + offset,
@@ -218,6 +219,7 @@ struct FlatL2Dis : FlatCodesDistanceComputer {
     }
 };
 
+template <SIMDLevel SL>
 struct FlatIPDis : FlatCodesDistanceComputer {
     size_t d;
     idx_t nb;
@@ -226,12 +228,12 @@ struct FlatIPDis : FlatCodesDistanceComputer {
     size_t ndis;
 
     float symmetric_dis(idx_t i, idx_t j) final override {
-        return fvec_inner_product(b + j * d, b + i * d, d);
+        return fvec_inner_product<SL>(b + j * d, b + i * d, d);
     }
 
     float distance_to_code(const uint8_t* code) final override {
         ndis++;
-        return fvec_inner_product(q, (const float*)code, d);
+        return fvec_inner_product<SL>(q, (const float*)code, d);
     }
 
     explicit FlatIPDis(const IndexFlat& storage, const float* q = nullptr)
@@ -274,7 +276,8 @@ struct FlatIPDis : FlatCodesDistanceComputer {
         float dp1 = 0;
         float dp2 = 0;
         float dp3 = 0;
-        fvec_inner_product_batch_4(q, y0, y1, y2, y3, d, dp0, dp1, dp2, dp3);
+        fvec_inner_product_batch_4<SL>(
+                q, y0, y1, y2, y3, d, dp0, dp1, dp2, dp3);
         dis0 = dp0;
         dis1 = dp1;
         dis2 = dp2;
@@ -285,14 +288,16 @@ struct FlatIPDis : FlatCodesDistanceComputer {
 } // namespace
 
 FlatCodesDistanceComputer* IndexFlat::get_FlatCodesDistanceComputer() const {
+    FlatCodesDistanceComputer* dc = nullptr;
     if (metric_type == METRIC_L2) {
-        return new FlatL2Dis(*this);
+        with_simd_level([&]<SIMDLevel SL>() { dc = new FlatL2Dis<SL>(*this); });
     } else if (metric_type == METRIC_INNER_PRODUCT) {
-        return new FlatIPDis(*this);
+        with_simd_level([&]<SIMDLevel SL>() { dc = new FlatIPDis<SL>(*this); });
     } else {
-        return get_extra_distance_computer(
+        dc = get_extra_distance_computer(
                 d, metric_type, metric_arg, ntotal, get_xb());
     }
+    return dc;
 }
 
 void IndexFlat::reconstruct(idx_t key, float* recons) const {
@@ -317,6 +322,7 @@ void IndexFlat::sa_decode(idx_t n, const uint8_t* bytes, float* x) const {
  ***************************************************/
 
 namespace {
+template <SIMDLevel SL>
 struct FlatL2WithNormsDis : FlatCodesDistanceComputer {
     size_t d;
     idx_t nb;
@@ -329,7 +335,7 @@ struct FlatL2WithNormsDis : FlatCodesDistanceComputer {
 
     float distance_to_code(const uint8_t* code) final override {
         ndis++;
-        return fvec_L2sqr(q, (float*)code, d);
+        return fvec_L2sqr<SL>(q, (float*)code, d);
     }
 
     float operator()(const idx_t i) final override {
@@ -337,7 +343,7 @@ struct FlatL2WithNormsDis : FlatCodesDistanceComputer {
                 reinterpret_cast<const float*>(codes + i * code_size);
 
         prefetch_L2(l2norms + i);
-        const float dp0 = fvec_inner_product(q, y, d);
+        const float dp0 = fvec_inner_product<SL>(q, y, d);
         return query_l2norm + l2norms[i] - 2 * dp0;
     }
 
@@ -349,7 +355,7 @@ struct FlatL2WithNormsDis : FlatCodesDistanceComputer {
 
         prefetch_L2(l2norms + i);
         prefetch_L2(l2norms + j);
-        const float dp0 = fvec_inner_product(yi, yj, d);
+        const float dp0 = fvec_inner_product<SL>(yi, yj, d);
         return l2norms[i] + l2norms[j] - 2 * dp0;
     }
 
@@ -369,7 +375,7 @@ struct FlatL2WithNormsDis : FlatCodesDistanceComputer {
 
     void set_query(const float* x) override {
         q = x;
-        query_l2norm = fvec_norm_L2sqr(q, d);
+        query_l2norm = fvec_norm_L2sqr<SL>(q, d);
     }
 
     // compute four distances
@@ -403,7 +409,8 @@ struct FlatL2WithNormsDis : FlatCodesDistanceComputer {
         float dp1 = 0;
         float dp2 = 0;
         float dp3 = 0;
-        fvec_inner_product_batch_4(q, y0, y1, y2, y3, d, dp0, dp1, dp2, dp3);
+        fvec_inner_product_batch_4<SL>(
+                q, y0, y1, y2, y3, d, dp0, dp1, dp2, dp3);
         dis0 = query_l2norm + l2norms[idx0] - 2 * dp0;
         dis1 = query_l2norm + l2norms[idx1] - 2 * dp1;
         dis2 = query_l2norm + l2norms[idx2] - 2 * dp2;
@@ -430,7 +437,11 @@ void IndexFlatL2::clear_l2norms() {
 FlatCodesDistanceComputer* IndexFlatL2::get_FlatCodesDistanceComputer() const {
     if (metric_type == METRIC_L2) {
         if (!cached_l2norms.empty()) {
-            return new FlatL2WithNormsDis(*this);
+            FlatCodesDistanceComputer* dc = nullptr;
+            with_simd_level([&]<SIMDLevel SL>() {
+                dc = new FlatL2WithNormsDis<SL>(*this);
+            });
+            return dc;
         }
     }
 
@@ -583,7 +594,17 @@ void IndexFlat1D::search(
 
 namespace {
 
-template <bool use_radius, typename BlockHandler>
+template <typename Fn>
+inline auto dispatch_metric_compare(MetricType metric, Fn&& fn) {
+    if (is_similarity_metric(metric)) {
+        using C = CMin<float, int64_t>;
+        return fn.template operator()<C>();
+    }
+    using C = CMax<float, int64_t>;
+    return fn.template operator()<C>();
+}
+
+template <bool use_radius, typename C, typename BlockHandler>
 inline void flat_pano_search_core(
         const IndexFlatPanorama& index,
         BlockHandler& handler,
@@ -627,22 +648,23 @@ inline void flat_pano_search_core(
                     threshold = res.heap_dis[0];
                 }
 
-                size_t num_active =
-                        index.pano
-                                .progressive_filter_batch<CMax<float, int64_t>>(
-                                        index.codes.data(),
-                                        index.cum_sums.data(),
-                                        xi,
-                                        query_cum_norms.data(),
-                                        batch_no,
-                                        index.ntotal,
-                                        sel,
-                                        nullptr,
-                                        use_sel,
-                                        active_indices,
-                                        exact_distances,
-                                        threshold,
-                                        local_stats);
+                size_t num_active = with_metric_type(
+                        index.metric_type, [&]<MetricType M>() {
+                            return index.pano.progressive_filter_batch<C, M>(
+                                    index.codes.data(),
+                                    index.cum_sums.data(),
+                                    xi,
+                                    query_cum_norms.data(),
+                                    batch_no,
+                                    index.ntotal,
+                                    sel,
+                                    nullptr,
+                                    use_sel,
+                                    active_indices,
+                                    exact_distances,
+                                    threshold,
+                                    local_stats);
+                        });
 
                 for (size_t j = 0; j < num_active; j++) {
                     res.add_result(
@@ -686,10 +708,11 @@ void IndexFlatPanorama::search(
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(batch_size >= k);
 
-    HeapBlockResultHandler<CMax<float, int64_t>, false> handler(
-            size_t(n), distances, labels, size_t(k), nullptr);
-
-    flat_pano_search_core<false>(*this, handler, n, x, 0.0f, params);
+    dispatch_metric_compare(metric_type, [&]<typename C>() {
+        HeapBlockResultHandler<C, false> handler(
+                size_t(n), distances, labels, size_t(k), nullptr);
+        flat_pano_search_core<false, C>(*this, handler, n, x, 0.0f, params);
+    });
 }
 
 void IndexFlatPanorama::range_search(
@@ -698,10 +721,11 @@ void IndexFlatPanorama::range_search(
         float radius,
         RangeSearchResult* result,
         const SearchParameters* params) const {
-    RangeSearchBlockResultHandler<CMax<float, int64_t>, false> handler(
-            result, radius, nullptr);
-
-    flat_pano_search_core<true>(*this, handler, n, x, radius, params);
+    dispatch_metric_compare(metric_type, [&]<typename C>() {
+        RangeSearchBlockResultHandler<C, false> handler(
+                result, radius, nullptr);
+        flat_pano_search_core<true, C>(*this, handler, n, x, radius, params);
+    });
 }
 
 void IndexFlatPanorama::reset() {
@@ -790,103 +814,136 @@ void IndexFlatPanorama::search_subset(
         idx_t k,
         float* distances,
         idx_t* labels) const {
-    using SingleResultHandler =
-            HeapBlockResultHandler<CMax<float, int64_t>, false>::
-                    SingleResultHandler;
-    HeapBlockResultHandler<CMax<float, int64_t>, false> handler(
-            size_t(n), distances, labels, size_t(k), nullptr);
-
-    FAISS_THROW_IF_NOT(k > 0);
-    FAISS_THROW_IF_NOT(batch_size == 1);
-
-    [[maybe_unused]] int nt = std::min(int(n), omp_get_max_threads());
+    with_simd_level([&]<SIMDLevel SL>() {
+        with_metric_type(metric_type, [&]<MetricType M>() {
+            constexpr bool is_sim = is_similarity_metric(M);
+            using C = std::conditional_t<
+                    is_sim,
+                    CMin<float, int64_t>,
+                    CMax<float, int64_t>>;
+            using SingleResultHandler =
+                    typename HeapBlockResultHandler<C, false>::
+                            SingleResultHandler;
+            HeapBlockResultHandler<C, false> handler(
+                    size_t(n), distances, labels, size_t(k), nullptr);
+
+            FAISS_THROW_IF_NOT(k > 0);
+            FAISS_THROW_IF_NOT(batch_size == 1);
+
+            [[maybe_unused]] int nt = std::min(int(n), omp_get_max_threads());
 
 #pragma omp parallel num_threads(nt)
-    {
-        SingleResultHandler res(handler);
-
-        std::vector<float> query_cum_norms(n_levels + 1);
-
-        // Panorama's optimized point-wise refinement (Algorithm 2):
-        // Batch-wise Panorama, as implemented in Panorama.h, incurs overhead
-        // from maintaining active_indices and exact_distances. This optimized
-        // implementation has minimal overhead and is thus preferred for
-        // IndexRefine's use case.
-        // 1. Initialize exact distance as ||y||^2 + ||x||^2.
-        // 2. For each level, refine distance incrementally:
-        //    - Compute dot product for current level: exact_dist -= 2*<x,y>.
-        //    - Use Cauchy-Schwarz bound on remaining levels to get lower bound.
-        //    - If there are less than k points in the heap, add the point to
-        //    the heap.
-        //    - Else, prune if lower bound exceeds k-th best distance.
-        // 3. After all levels, update heap if the point survived.
+            {
+                SingleResultHandler res(handler);
+
+                std::vector<float> query_cum_norms(n_levels + 1);
+
+                // Panorama's optimized point-wise refinement (Algorithm 2):
+                // Batch-wise Panorama, as implemented in Panorama.h, incurs
+                // overhead from maintaining active_indices and exact_distances.
+                // This optimized implementation has minimal overhead and is
+                // thus preferred for IndexRefine's use case.
+                // 1. Initialize exact distance as ||y||^2 + ||x||^2.
+                // 2. For each level, refine distance incrementally:
+                //    - Compute dot product for current level: exact_dist -=
+                //    2*<x,y>.
+                //    - Use Cauchy-Schwarz bound on remaining levels to get
+                //    lower bound.
+                //    - If there are less than k points in the heap, add the
+                //    point to the heap.
+                //    - Else, prune if lower bound exceeds k-th best distance.
+                // 3. After all levels, update heap if the point survived.
 #pragma omp for
-        for (idx_t i = 0; i < n; i++) {
-            const idx_t* __restrict idsi = base_labels + i * k_base;
-            const float* xi = x + i * d;
-
-            PanoramaStats local_stats;
-            local_stats.reset();
-
-            pano.compute_query_cum_sums(xi, query_cum_norms.data());
-            float query_cum_norm = query_cum_norms[0] * query_cum_norms[0];
-
-            res.begin(i);
-
-            for (size_t j = 0; j < k_base; j++) {
-                idx_t idx = idsi[j];
-
-                if (idx < 0) {
-                    continue;
-                }
-
-                size_t cum_sum_offset = (n_levels + 1) * idx;
-                float cum_sum = cum_sums[cum_sum_offset];
-                float exact_distance = cum_sum * cum_sum + query_cum_norm;
-                cum_sum_offset++;
-
-                const float* x_ptr = xi;
-                const float* p_ptr =
-                        reinterpret_cast<const float*>(codes.data()) + d * idx;
-
-                local_stats.total_dims += d;
-
-                bool pruned = false;
-                for (size_t level = 0; level < n_levels; level++) {
-                    local_stats.total_dims_scanned += pano.level_width_floats;
-
-                    // Refine distance
-                    size_t actual_level_width = std::min(
-                            pano.level_width_floats,
-                            d - level * pano.level_width_floats);
-                    float dot_product = fvec_inner_product(
-                            x_ptr, p_ptr, actual_level_width);
-                    exact_distance -= 2 * dot_product;
-
-                    float cum_sum = cum_sums[cum_sum_offset];
-                    float cauchy_schwarz_bound =
-                            2.0f * cum_sum * query_cum_norms[level + 1];
-                    float lower_bound = exact_distance - cauchy_schwarz_bound;
-
-                    // Prune using Cauchy-Schwarz bound
-                    if (lower_bound > res.heap_dis[0]) {
-                        pruned = true;
-                        break;
+                for (idx_t i = 0; i < n; i++) {
+                    const idx_t* __restrict idsi = base_labels + i * k_base;
+                    const float* xi = x + i * d;
+
+                    PanoramaStats local_stats;
+                    local_stats.reset();
+
+                    pano.compute_query_cum_sums(xi, query_cum_norms.data());
+                    float query_cum_norm =
+                            query_cum_norms[0] * query_cum_norms[0];
+
+                    res.begin(i);
+
+                    for (size_t j = 0; j < k_base; j++) {
+                        idx_t idx = idsi[j];
+
+                        if (idx < 0) {
+                            continue;
+                        }
+
+                        size_t cum_sum_offset = (n_levels + 1) * idx;
+                        float cum_sum = cum_sums[cum_sum_offset];
+                        float exact_distance = 0.0f;
+                        if constexpr (!is_sim) {
+                            exact_distance = cum_sum * cum_sum + query_cum_norm;
+                        }
+                        cum_sum_offset++;
+
+                        const float* x_ptr = xi;
+                        const float* p_ptr =
+                                reinterpret_cast<const float*>(codes.data()) +
+                                d * idx;
+
+                        local_stats.total_dims += d;
+
+                        bool pruned = false;
+                        for (size_t level = 0; level < n_levels; level++) {
+                            local_stats.total_dims_scanned +=
+                                    pano.level_width_floats;
+
+                            // Refine distance
+                            size_t actual_level_width = std::min(
+                                    pano.level_width_floats,
+                                    d - level * pano.level_width_floats);
+                            float dot_product = fvec_inner_product<SL>(
+                                    x_ptr, p_ptr, actual_level_width);
+                            if constexpr (is_sim) {
+                                exact_distance += dot_product;
+                            } else {
+                                exact_distance -= 2 * dot_product;
+                            }
+
+                            float level_cum_sum = cum_sums[cum_sum_offset];
+                            float cauchy_schwarz_bound;
+                            if constexpr (is_sim) {
+                                cauchy_schwarz_bound = -level_cum_sum *
+                                        query_cum_norms[level + 1];
+                            } else {
+                                cauchy_schwarz_bound = 2.0f * level_cum_sum *
+                                        query_cum_norms[level + 1];
+                            }
+                            float bound = exact_distance - cauchy_schwarz_bound;
+
+                            // Prune using Cauchy-Schwarz bound
+                            bool should_prune = false;
+                            if constexpr (is_sim) {
+                                should_prune = bound < res.heap_dis[0];
+                            } else {
+                                should_prune = bound > res.heap_dis[0];
+                            }
+                            if (should_prune) {
+                                pruned = true;
+                                break;
+                            }
+
+                            cum_sum_offset++;
+                            x_ptr += pano.level_width_floats;
+                            p_ptr += pano.level_width_floats;
+                        }
+
+                        if (!pruned) {
+                            res.add_result(exact_distance, idx);
+                        }
                     }
 
-                    cum_sum_offset++;
-                    x_ptr += pano.level_width_floats;
-                    p_ptr += pano.level_width_floats;
-                }
-
-                if (!pruned) {
-                    res.add_result(exact_distance, idx);
+                    res.end();
+                    indexPanorama_stats.add(local_stats);
                 }
             }
-
-            res.end();
-            indexPanorama_stats.add(local_stats);
-        }
-    }
+        });
+    });
 }
 } // namespace faiss

data/vendor/faiss/faiss/IndexFlat.h

@@ -121,7 +121,8 @@ struct IndexFlatPanorama : IndexFlat {
               batch_size(batch_size),
               n_levels(n_levels),
               pano(code_size, n_levels, batch_size) {
-        FAISS_THROW_IF_NOT(metric == METRIC_L2);
+        FAISS_THROW_IF_NOT(
+                metric == METRIC_L2 || metric == METRIC_INNER_PRODUCT);
     }
 
     void add(idx_t n, const float* x) override;
@@ -179,6 +180,20 @@ struct IndexFlatL2Panorama : IndexFlatPanorama {
             : IndexFlatPanorama(d, METRIC_L2, n_levels, batch_size) {}
 };
 
+struct IndexFlatIPPanorama : IndexFlatPanorama {
+    /**
+     * @param d dimensionality of the input vectors
+     * @param n_levels number of Panorama levels
+     * @param batch_size batch size for Panorama storage
+     */
+    explicit IndexFlatIPPanorama(
+            idx_t d,
+            size_t n_levels,
+            size_t batch_size = 512)
+            : IndexFlatPanorama(d, METRIC_INNER_PRODUCT, n_levels, batch_size) {
+    }
+};
+
 /// optimized version for 1D "vectors".
 struct IndexFlat1D : IndexFlatL2 {
     bool continuous_update = true; ///< is the permutation updated continuously?

data/vendor/faiss/faiss/IndexFlatCodes.cpp

@@ -182,15 +182,6 @@ struct GenericFlatCodesDistanceComputer : FlatCodesDistanceComputer {
     }
 };
 
-struct Run_get_distance_computer {
-    using T = FlatCodesDistanceComputer*;
-
-    template <class VD>
-    FlatCodesDistanceComputer* f(const VD& vd, const IndexFlatCodes* codec) {
-        return new GenericFlatCodesDistanceComputer<VD>(codec, vd);
-    }
-};
-
 template <class BlockResultHandler>
 struct Run_search_with_decompress {
     using T = void;
@@ -231,17 +222,15 @@ struct Run_search_with_decompress {
 struct Run_search_with_decompress_res {
     using T = void;
 
-    template <class ResultHandler>
-    void f(ResultHandler& res, const IndexFlatCodes* index, const float* xq) {
-        Run_search_with_decompress<ResultHandler> r;
-        dispatch_VectorDistance(
-                index->d,
-                index->metric_type,
-                index->metric_arg,
-                r,
-                index,
-                xq,
-                res);
+    template <class BlockResultHandler>
+    void f(BlockResultHandler& res,
+           const IndexFlatCodes* index,
+           const float* xq) {
+        with_VectorDistance(
+                index->d, index->metric_type, index->metric_arg, [&](auto vd) {
+                    Run_search_with_decompress<BlockResultHandler> r;
+                    r.template f<decltype(vd)>(vd, index, xq, res);
+                });
     }
 };
 
@@ -249,8 +238,14 @@ struct Run_search_with_decompress_res {
 
 FlatCodesDistanceComputer* IndexFlatCodes::get_FlatCodesDistanceComputer()
         const {
-    Run_get_distance_computer r;
-    return dispatch_VectorDistance(d, metric_type, metric_arg, r, this);
+    return with_VectorDistance(
+            d,
+            metric_type,
+            metric_arg,
+            [&](auto vd) -> FlatCodesDistanceComputer* {
+                return new GenericFlatCodesDistanceComputer<decltype(vd)>(
+                        this, vd);
+            });
 }
 
 void IndexFlatCodes::search(
@@ -277,4 +272,33 @@ void IndexFlatCodes::range_search(
     dispatch_range_ResultHandler(result, radius, metric_type, sel, r, this, x);
 }
 
+void IndexFlatCodes::search1(
+        const float* x,
+        ResultHandler& handler,
+        SearchParameters* params) const {
+    const IDSelector* sel = params ? params->sel : nullptr;
+    Run_search_with_decompress_res r;
+    if (sel) {
+        if (is_similarity_metric(metric_type)) {
+            SingleQueryBlockResultHandler<CMin<float, idx_t>, true> res(
+                    handler, sel);
+            r.f(res, this, x);
+        } else {
+            SingleQueryBlockResultHandler<CMax<float, idx_t>, true> res(
+                    handler, sel);
+            r.f(res, this, x);
+        }
+    } else {
+        if (is_similarity_metric(metric_type)) {
+            SingleQueryBlockResultHandler<CMin<float, idx_t>, false> res(
+                    handler);
+            r.f(res, this, x);
+        } else {
+            SingleQueryBlockResultHandler<CMax<float, idx_t>, false> res(
+                    handler);
+            r.f(res, this, x);
+        }
+    }
+}
+
 } // namespace faiss

data/vendor/faiss/faiss/IndexFlatCodes.h

@@ -55,7 +55,8 @@ struct IndexFlatCodes : Index {
         return get_FlatCodesDistanceComputer();
     }
 
-    /** Search implemented by decoding */
+    /** Search implemented by decoding (most index types will have a faster
+     * implementation) */
     void search(
             idx_t n,
             const float* x,
@@ -71,6 +72,11 @@ struct IndexFlatCodes : Index {
             RangeSearchResult* result,
             const SearchParameters* params = nullptr) const override;
 
+    virtual void search1(
+            const float* x,
+            ResultHandler& handler,
+            SearchParameters* params = nullptr) const override;
+
     // returns a new instance of a CodePacker
     CodePacker* get_CodePacker() const;