faiss 0.6.4 → 0.6.5

data/vendor/faiss/faiss/IVFlib.cpp

@@ -8,6 +8,7 @@
 #include <faiss/IVFlib.h>
 #include <omp.h>
 
+#include <algorithm>
 #include <memory>
 
 #include <faiss/IndexAdditiveQuantizer.h>
@@ -20,6 +21,7 @@
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/simd_dispatch.h>
 #include <faiss/index_io.h>
+#include <faiss/utils/Heap.h>
 #include <faiss/utils/distances.h>
 #include <faiss/utils/hamming.h>
 #include <faiss/utils/utils.h>
@@ -407,6 +409,103 @@ void search_with_parameters(
     }
 }
 
+namespace {
+
+template <class C>
+void scan_one_query_per_code(
+        const IndexIVF& index_ivf,
+        InvertedListScanner& scanner,
+        const idx_t* keys,
+        const float* coarse_dis,
+        size_t nprobe,
+        idx_t k,
+        float* distances,
+        idx_t* labels) {
+    heap_heapify<C>(k, distances, labels);
+    const InvertedLists* invlists = index_ivf.invlists;
+    for (size_t j = 0; j < nprobe; j++) {
+        const idx_t key = keys[j];
+        if (key < 0) {
+            continue;
+        }
+        scanner.set_list(key, coarse_dis[j]);
+        const size_t list_size = invlists->list_size(key);
+        InvertedLists::ScopedCodes codes(invlists, key);
+        InvertedLists::ScopedIds ids(invlists, key);
+        const uint8_t* code = codes.get();
+        for (size_t i = 0; i < list_size; i++, code += index_ivf.code_size) {
+            const float dis = scanner.distance_to_code(code);
+            if (C::cmp(distances[0], dis)) {
+                heap_replace_top<C>(k, distances, labels, dis, ids[i]);
+            }
+        }
+    }
+    heap_reorder<C>(k, distances, labels);
+}
+
+} // namespace
+
+void search_with_distance_to_code(
+        const Index* index,
+        idx_t n,
+        const float* x,
+        idx_t k,
+        float* distances,
+        idx_t* labels,
+        size_t nprobe) {
+    std::unique_ptr<const float[]> del;
+    if (auto ip = dynamic_cast<const IndexPreTransform*>(index)) {
+        const float* xt = ip->apply_chain(n, x);
+        if (xt != x) {
+            del.reset(xt);
+        }
+        x = xt;
+        index = ip->index;
+    }
+    const IndexIVF* index_ivf = dynamic_cast<const IndexIVF*>(index);
+    FAISS_THROW_IF_NOT(index_ivf);
+    nprobe = std::min(nprobe, index_ivf->nlist);
+
+    std::vector<idx_t> Iq(nprobe * n);
+    std::vector<float> Dq(nprobe * n);
+    index_ivf->quantizer->search(n, x, nprobe, Dq.data(), Iq.data());
+
+#pragma omp parallel
+    {
+        std::unique_ptr<InvertedListScanner> scanner(
+                index_ivf->get_InvertedListScanner());
+#pragma omp for
+        for (idx_t q = 0; q < n; q++) {
+            scanner->set_query(x + q * index_ivf->d);
+            const idx_t* keys = Iq.data() + q * nprobe;
+            const float* coarse_dis = Dq.data() + q * nprobe;
+            float* D = distances + q * k;
+            idx_t* I = labels + q * k;
+            if (scanner->keep_max) {
+                scan_one_query_per_code<CMin<float, idx_t>>(
+                        *index_ivf,
+                        *scanner,
+                        keys,
+                        coarse_dis,
+                        nprobe,
+                        k,
+                        D,
+                        I);
+            } else {
+                scan_one_query_per_code<CMax<float, idx_t>>(
+                        *index_ivf,
+                        *scanner,
+                        keys,
+                        coarse_dis,
+                        nprobe,
+                        k,
+                        D,
+                        I);
+            }
+        }
+    }
+}
+
 void range_search_with_parameters(
         const Index* index,
         idx_t n,

data/vendor/faiss/faiss/IVFlib.h

@@ -136,6 +136,21 @@ void search_with_parameters(
         size_t* nb_dis = nullptr,
         double* ms_per_stage = nullptr);
 
+/** search an IndexIVF, possibly embedded in an IndexPreTransform, scoring
+ * every code with InvertedListScanner::distance_to_code, one call per code,
+ * as callers that run their own scan loop do (search() uses scan_codes,
+ * which batches codes). Meant for benchmarking that path. Each query is
+ * scanned by one thread; queries run in parallel.
+ */
+void search_with_distance_to_code(
+        const Index* index,
+        idx_t n,
+        const float* x,
+        idx_t k,
+        float* distances,
+        idx_t* labels,
+        size_t nprobe);
+
 /** same as search_with_parameters but for range search */
 void range_search_with_parameters(
         const Index* index,

data/vendor/faiss/faiss/Index.cpp

@@ -13,8 +13,11 @@
 #include <faiss/impl/DistanceComputer.h>
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/distances.h>
+#include <faiss/utils/utils.h>
 
+#include <algorithm>
 #include <cstring>
+#include <vector>
 
 namespace faiss {
 
@@ -24,6 +27,14 @@ void Index::train(idx_t /*n*/, const float* /*x*/) {
     // does nothing by default
 }
 
+void Index::train(const gpu::Dataset&) {
+    FAISS_THROW_MSG("Dataset training not implemented for this type of index");
+}
+
+void Index::add(const gpu::Dataset&) {
+    FAISS_THROW_MSG("Dataset addition not implemented for this type of index");
+}
+
 void Index::train_with_queries(
         idx_t /*n*/,
         const float* /*x*/,
@@ -123,6 +134,39 @@ void Index::search_subset(
     FAISS_THROW_MSG("search_subset not implemented for this type of index");
 }
 
+void Index::search_ex(
+        idx_t n,
+        const void* x,
+        NumericType numeric_type,
+        idx_t k,
+        float* distances,
+        idx_t* labels,
+        const SearchParameters* params) const {
+    if (numeric_type == NumericType::Float32) {
+        search(n, static_cast<const float*>(x), k, distances, labels, params);
+        return;
+    }
+    FAISS_THROW_IF_NOT_MSG(
+            numeric_type == NumericType::Float16,
+            "Index::search: unsupported numeric type");
+    FAISS_THROW_IF_NOT(d > 0);
+    // widen blocks of at most 64 MiB of fp32 queries
+    const idx_t bs = std::max<idx_t>(
+            1, idx_t(64) * 1024 * 1024 / (sizeof(float) * idx_t(d)));
+    const uint16_t* x16 = static_cast<const uint16_t*>(x);
+    std::vector<float> buffer(size_t(std::min(n, bs)) * d);
+    for (idx_t i0 = 0; i0 < n; i0 += bs) {
+        const idx_t i1 = std::min(n, i0 + bs);
+        fp16_to_fp32(size_t(i1 - i0) * d, x16 + i0 * d, buffer.data());
+        search(i1 - i0,
+               buffer.data(),
+               k,
+               distances + i0 * k,
+               labels + i0 * k,
+               params);
+    }
+}
+
 void Index::search1(const float*, ResultHandler&, SearchParameters*) const {
     FAISS_THROW_MSG("search1 not implemented for this type of index");
 }

data/vendor/faiss/faiss/Index.h

@@ -16,8 +16,8 @@
 #include <cstdio>
 
 #define FAISS_VERSION_MAJOR 1
-#define FAISS_VERSION_MINOR 15
-#define FAISS_VERSION_PATCH 1
+#define FAISS_VERSION_MINOR 16
+#define FAISS_VERSION_PATCH 0
 
 // Macro to combine the version components into a single string
 #ifndef FAISS_STRINGIFY
@@ -49,6 +49,10 @@
 
 namespace faiss {
 
+namespace gpu {
+class Dataset;
+}
+
 /// Forward declarations see impl/AuxIndexStructures.h, impl/IDSelector.h
 /// and impl/DistanceComputer.h
 struct IDSelector;
@@ -131,6 +135,9 @@ struct Index {
      */
     virtual void train(idx_t n, const float* x);
 
+    /// Train from caller-controlled storage. Unsupported by default.
+    virtual void train(const gpu::Dataset& dataset);
+
     /** Perform training on a representative set of vectors and a representative
      * set of queries
      *
@@ -163,6 +170,9 @@ struct Index {
      */
     virtual void add(idx_t n, const float* x) = 0;
 
+    /// Add caller-controlled storage. Unsupported by default.
+    virtual void add(const gpu::Dataset& dataset);
+
     virtual void add_ex(idx_t n, const void* x, NumericType numeric_type) {
         if (numeric_type == NumericType::Float32) {
             add(n, static_cast<const float*>(x));
@@ -212,6 +222,12 @@ struct Index {
             idx_t* labels,
             const SearchParameters* params = nullptr) const = 0;
 
+    /** search() for queries of the given numeric type
+     *
+     * Float32 calls search(). By default, Float16 queries (packed IEEE
+     * binary16, size n * d) are widened to fp32 in bounded blocks and passed
+     * to search(); indexes with a native fp16 search override this.
+     */
     virtual void search_ex(
             idx_t n,
             const void* x,
@@ -219,18 +235,7 @@ struct Index {
             idx_t k,
             float* distances,
             idx_t* labels,
-            const SearchParameters* params = nullptr) const {
-        if (numeric_type == NumericType::Float32) {
-            search(n,
-                   static_cast<const float*>(x),
-                   k,
-                   distances,
-                   labels,
-                   params);
-        } else {
-            FAISS_THROW_MSG("Index::search: unsupported numeric type");
-        }
-    }
+            const SearchParameters* params = nullptr) const;
 
     /** search one vector with a custom result handler */
     virtual void search1(

data/vendor/faiss/faiss/IndexBinary.cpp

@@ -29,6 +29,14 @@ void IndexBinary::train(idx_t, const uint8_t*) {
     // Does nothing by default.
 }
 
+void IndexBinary::train(const gpu::Dataset&) {
+    FAISS_THROW_MSG("Dataset training not implemented for this type of index");
+}
+
+void IndexBinary::add(const gpu::Dataset&) {
+    FAISS_THROW_MSG("Dataset addition not implemented for this type of index");
+}
+
 void IndexBinary::range_search(
         idx_t,
         const uint8_t*,

data/vendor/faiss/faiss/IndexBinary.h

@@ -52,6 +52,10 @@ struct IndexBinary {
      * @param x      training vectors, size n * d / 8
      */
     virtual void train(idx_t n, const uint8_t* x);
+
+    /// Train from caller-controlled storage. Unsupported by default.
+    virtual void train(const gpu::Dataset& dataset);
+
     virtual void train_ex(idx_t n, const void* x, NumericType numeric_type) {
         if (numeric_type == NumericType::UInt8) {
             train(n, static_cast<const uint8_t*>(x));
@@ -66,6 +70,10 @@ struct IndexBinary {
      * @param x      input matrix, size n * d / 8
      */
     virtual void add(idx_t n, const uint8_t* x) = 0;
+
+    /// Add caller-controlled storage. Unsupported by default.
+    virtual void add(const gpu::Dataset& dataset);
+
     virtual void add_ex(idx_t n, const void* x, NumericType numeric_type) {
         if (numeric_type == NumericType::UInt8) {
             add(n, static_cast<const uint8_t*>(x));

data/vendor/faiss/faiss/IndexBinaryHNSW.cpp

@@ -24,6 +24,7 @@
 #include <faiss/impl/VisitedTable.h>
 #include <faiss/utils/Heap.h>
 #include <faiss/utils/random.h>
+#include <faiss/utils/utils.h>
 
 #include <faiss/impl/simd_dispatch.h>
 
@@ -121,7 +122,9 @@ void IndexBinaryHNSW::search(
         }
     }
 
-    hnsw_stats.combine({n1, n2, ndis, nhops});
+    if (get_search_stats_enabled()) {
+        hnsw_stats.combine_atomic({n1, n2, ndis, nhops});
+    }
 
 #pragma omp parallel for
     for (idx_t i = 0; i < n * k; ++i) {
@@ -173,6 +176,81 @@ DistanceComputer* IndexBinaryHNSW::get_distance_computer() const {
     });
 }
 
+namespace {
+
+// The sample of an IndexBinaryHNSW. Hamming distances are integers, so a
+// nearer node has a strictly smaller distance.
+struct BinaryLinkSample : HNSWLinkSampleSearch {
+    const IndexBinaryHNSW& index;
+    const uint8_t* x;
+
+    BinaryLinkSample(const IndexBinaryHNSW& index, idx_t n, const uint8_t* x)
+            : index(index), x(x) {
+        this->n = n;
+    }
+
+    std::vector<uint8_t> gather(size_t m, const idx_t* ids) const {
+        const size_t cs = index.code_size;
+        std::vector<uint8_t> rows(m * cs);
+        for (size_t j = 0; j < m; j++) {
+            memcpy(rows.data() + j * cs, x + ids[j] * cs, cs);
+        }
+        return rows;
+    }
+
+    void search(
+            const SearchParametersHNSW* params,
+            size_t m,
+            const idx_t* ids,
+            idx_t* labels) const override {
+        std::vector<int32_t> distances(m);
+        if (!ids) {
+            index.search(m, x, 1, distances.data(), labels, params);
+            return;
+        }
+        index.search(
+                m, gather(m, ids).data(), 1, distances.data(), labels, params);
+    }
+
+    void search_exact(
+            size_t m,
+            const idx_t* ids,
+            const idx_t* found,
+            idx_t* exact,
+            uint8_t* nearer) const override {
+        const size_t cs = index.code_size;
+        const std::vector<uint8_t> rows = gather(m, ids);
+        std::vector<int32_t> distances(m);
+        index.storage->search(m, rows.data(), 1, distances.data(), exact);
+#pragma omp parallel
+        {
+            std::unique_ptr<DistanceComputer> dis(
+                    index.get_distance_computer());
+#pragma omp for schedule(static)
+            for (int64_t j = 0; j < static_cast<int64_t>(m); j++) {
+                if (exact[j] < 0 || exact[j] == found[j]) {
+                    continue;
+                }
+                dis->set_query(
+                        reinterpret_cast<const float*>(rows.data() + j * cs));
+                nearer[j] = (*dis)(exact[j]) < (*dis)(found[j]);
+            }
+        }
+    }
+};
+
+} // namespace
+
+HNSWLevel0LinkStats IndexBinaryHNSW::add_level_0_links_from_sample(
+        idx_t n,
+        const uint8_t* x,
+        const HNSWLevel0LinkParameters& params) {
+    const BinaryLinkSample sample(*this, n, x);
+    std::unique_ptr<DistanceComputer> dis(get_distance_computer());
+    return hnsw_add_level_0_links_from_sample(
+            hnsw, ntotal, *dis, false, sample, params);
+}
+
 /**************************************************************
  * IndexBinaryHNSWCagra implementation
  **************************************************************/
@@ -269,10 +347,10 @@ void IndexBinaryHNSWCagra::search(
                         params);
 
                 res.end();
+                vt->advance();
             }
-#pragma omp critical
-            {
-                hnsw_stats.combine(search_stats);
+            if (get_search_stats_enabled()) {
+                hnsw_stats.combine_atomic(search_stats);
             }
         }
 

data/vendor/faiss/faiss/IndexBinaryHNSW.h

@@ -40,6 +40,14 @@ struct IndexBinaryHNSW : IndexBinary {
     // used when GpuIndexBinaryCagra::copyFrom(IndexBinaryHNSW*) is called.
     bool keep_max_size_level0 = false;
 
+    // When this index is the coarse quantizer of an IndexBinaryIVF,
+    // IndexBinaryIVF::train() calls add_level_0_links_from_sample() after it
+    // adds the centroids. The sample is the first
+    // min(n, level_0_link_samples_per_node * ntotal) training vectors. 0
+    // disables the call. Training does not call it when the quantizer is
+    // already trained. The index format does not store this value.
+    int level_0_link_samples_per_node = 3;
+
     explicit IndexBinaryHNSW();
     explicit IndexBinaryHNSW(int d, int M = 32);
     explicit IndexBinaryHNSW(IndexBinary* storage, int M = 32);
@@ -65,6 +73,17 @@ struct IndexBinaryHNSW : IndexBinary {
     void reconstruct(idx_t key, uint8_t* recons) const override;
 
     void reset() override;
+
+    /** Adds level-0 links so that the search no longer stops at "sinks":
+     * nodes where it stops for many vectors whose nearest node is elsewhere.
+     * See IndexHNSW::add_level_0_links_from_sample(). x holds n binary
+     * vectors. Call this function after the last add().
+     */
+    HNSWLevel0LinkStats add_level_0_links_from_sample(
+            idx_t n,
+            const uint8_t* x,
+            const HNSWLevel0LinkParameters& params =
+                    HNSWLevel0LinkParameters());
 };
 
 struct IndexBinaryHNSWCagra : IndexBinaryHNSW {

data/vendor/faiss/faiss/IndexBinaryIVF.cpp

@@ -17,6 +17,7 @@
 #include <limits>
 #include <memory>
 
+#include <faiss/IndexBinaryHNSW.h>
 #include <faiss/IndexFlat.h>
 #include <faiss/IndexLSH.h>
 #include <faiss/impl/AuxIndexStructures.h>
@@ -254,6 +255,21 @@ void IndexBinaryIVF::reconstruct_from_offset(
         idx_t list_no,
         idx_t offset,
         uint8_t* recons) const {
+    FAISS_THROW_IF_NOT_FMT(
+            list_no >= 0 &&
+                    static_cast<uint64_t>(list_no) <
+                            static_cast<uint64_t>(nlist),
+            "Invalid list_no %" PRId64 " (nlist=%zd)",
+            list_no,
+            nlist);
+    FAISS_THROW_IF_NOT_FMT(
+            offset >= 0 &&
+                    static_cast<uint64_t>(offset) <
+                            static_cast<uint64_t>(invlists->list_size(list_no)),
+            "Invalid offset %" PRId64 " for list %" PRId64 " (size=%zd)",
+            offset,
+            list_no,
+            invlists->list_size(list_no));
     memcpy(recons,
            InvertedLists::ScopedCodes(invlists, list_no, offset).get(),
            code_size);
@@ -308,6 +324,24 @@ void IndexBinaryIVF::train(idx_t n, const uint8_t* x) {
 
         quantizer->add(clus.k, x_b.get());
         quantizer->is_trained = true;
+
+        auto* hnsw = dynamic_cast<IndexBinaryHNSW*>(quantizer);
+        if (hnsw && hnsw->level_0_link_samples_per_node > 0) {
+            const idx_t samples = std::min<idx_t>(
+                    n, idx_t(hnsw->level_0_link_samples_per_node) * nlist);
+            const HNSWLevel0LinkStats stats =
+                    hnsw->add_level_0_links_from_sample(samples, x);
+            if (verbose) {
+                printf("HNSW quantizer level-0 links from %" PRId64
+                       " samples: %zd sinks found, %zd remaining, %zd links "
+                       "added, %zd replaced\n",
+                       samples,
+                       stats.n_sinks_found,
+                       stats.n_sinks_remaining,
+                       stats.n_links_added,
+                       stats.n_links_replaced);
+            }
+        }
     }
 
     is_trained = true;

data/vendor/faiss/faiss/IndexFastScan.cpp

@@ -55,7 +55,7 @@ IndexFastScan::IndexFastScan()
 
 void IndexFastScan::reset() {
     codes.resize(0);
-    ntotal = 0;
+    ntotal = ntotal2 = 0;
 }
 
 void IndexFastScan::add(idx_t n, const float* x) {
@@ -267,15 +267,16 @@ void IndexFastScan::search(
         float* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     FAISS_THROW_IF_NOT(k > 0);
+    const IDSelector* sel = params ? params->sel : nullptr;
 
     FastScanDistancePostProcessing empty_context{};
     if (metric_type == METRIC_L2) {
-        search_dispatch_implem<true>(n, x, k, distances, labels, empty_context);
+        search_dispatch_implem<true>(
+                n, x, k, distances, labels, empty_context, sel);
     } else {
         search_dispatch_implem<false>(
-                n, x, k, distances, labels, empty_context);
+                n, x, k, distances, labels, empty_context, sel);
     }
 }
 
@@ -286,7 +287,8 @@ void IndexFastScan::search_dispatch_implem(
         idx_t k,
         float* distances,
         idx_t* labels,
-        const FastScanDistancePostProcessing& context) const {
+        const FastScanDistancePostProcessing& context,
+        const IDSelector* sel) const {
     using Cfloat = typename std::conditional<
             is_max,
             CMax<float, int64_t>,
@@ -317,6 +319,10 @@ void IndexFastScan::search_dispatch_implem(
         FAISS_THROW_MSG("not implemented");
     } else if (implem == 2 || implem == 3 || implem == 4) {
         FAISS_THROW_IF_NOT(orig_codes);
+        FAISS_THROW_IF_MSG(
+                sel,
+                "IDSelector is not supported by implem 2/3/4; leave implem at "
+                "0 so a selector-aware kernel is chosen");
         search_implem_234<Cfloat>(n, x, k, distances, labels, context);
     } else if (impl >= 12 && impl <= 15) {
         FAISS_THROW_IF_NOT(ntotal < INT_MAX);
@@ -328,9 +334,11 @@ void IndexFastScan::search_dispatch_implem(
         // - OpenMP disabled (omp_get_max_threads() = 1)
         if (nt < 2) {
             if (impl == 12 || impl == 13) {
-                search_implem_12<C>(n, x, k, distances, labels, impl, context);
+                search_implem_12<C>(
+                        n, x, k, distances, labels, impl, context, sel);
             } else {
-                search_implem_14<C>(n, x, k, distances, labels, impl, context);
+                search_implem_14<C>(
+                        n, x, k, distances, labels, impl, context, sel);
             }
         } else {
             // explicitly slice over threads
@@ -355,7 +363,8 @@ void IndexFastScan::search_dispatch_implem(
                             dis_i,
                             lab_i,
                             impl,
-                            thread_context);
+                            thread_context,
+                            sel);
                 } else {
                     search_implem_14<C>(
                             i1 - i0,
@@ -364,7 +373,8 @@ void IndexFastScan::search_dispatch_implem(
                             dis_i,
                             lab_i,
                             impl,
-                            thread_context);
+                            thread_context,
+                            sel);
                 }
             }
         }
@@ -440,7 +450,8 @@ void IndexFastScan::search_implem_12(
         float* distances,
         idx_t* labels,
         int impl,
-        const FastScanDistancePostProcessing& context) const {
+        const FastScanDistancePostProcessing& context,
+        const IDSelector* sel) const {
     FAISS_THROW_IF_NOT(bbs == 32);
 
     // handle qbs2 blocking by recursive call
@@ -460,7 +471,8 @@ void IndexFastScan::search_implem_12(
                     distances + i0 * k,
                     labels + i0 * k,
                     impl,
-                    sub_context);
+                    sub_context,
+                    sel);
         }
         return;
     }
@@ -492,7 +504,7 @@ void IndexFastScan::search_implem_12(
     FAISS_THROW_IF_NOT(LUT_nq == n);
 
     auto scanner = make_knn_scanner(
-            C::is_max, n, k, ntotal, distances, labels, nullptr, impl, context);
+            C::is_max, n, k, ntotal, distances, labels, sel, impl, context);
     auto* rh = scanner->handler();
     rh->normalizers = normalizers.get();
     // Note: skip & 2 previously set handler->disable (run kernel,
@@ -525,7 +537,8 @@ void IndexFastScan::search_implem_14(
         float* distances,
         idx_t* labels,
         int impl,
-        const FastScanDistancePostProcessing& context) const {
+        const FastScanDistancePostProcessing& context,
+        const IDSelector* sel) const {
     FAISS_THROW_IF_NOT(bbs % 32 == 0);
 
     // The accumulate loop dispatch table only instantiates certain
@@ -553,7 +566,8 @@ void IndexFastScan::search_implem_14(
                     distances + i0 * k,
                     labels + i0 * k,
                     impl,
-                    sub_context);
+                    sub_context,
+                    sel);
         }
         return;
     }
@@ -577,7 +591,7 @@ void IndexFastScan::search_implem_14(
             LUT.get());
 
     auto scanner = make_knn_scanner(
-            C::is_max, n, k, ntotal, distances, labels, nullptr, impl, context);
+            C::is_max, n, k, ntotal, distances, labels, sel, impl, context);
     auto* rh = scanner->handler();
     rh->normalizers = normalizers.get();
     // Note: skip & 2 previously set handler->disable (run kernel,
@@ -606,7 +620,8 @@ template void IndexFastScan::search_dispatch_implem<true>(
         idx_t k,
         float* distances,
         idx_t* labels,
-        const FastScanDistancePostProcessing& context) const;
+        const FastScanDistancePostProcessing& context,
+        const IDSelector* sel) const;
 
 template void IndexFastScan::search_dispatch_implem<false>(
         idx_t n,
@@ -614,7 +629,8 @@ template void IndexFastScan::search_dispatch_implem<false>(
         idx_t k,
         float* distances,
         idx_t* labels,
-        const FastScanDistancePostProcessing& context) const;
+        const FastScanDistancePostProcessing& context,
+        const IDSelector* sel) const;
 
 void IndexFastScan::reconstruct(idx_t key, float* recons) const {
     FAISS_THROW_IF_NOT_FMT(