faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/IndexIVFFastScan.h

@@ -8,12 +8,12 @@
 #pragma once
 
 #include <faiss/IndexIVF.h>
-#include <faiss/impl/FastScanDistancePostProcessing.h>
+#include <faiss/impl/fast_scan/FastScanDistancePostProcessing.h>
+#include <faiss/impl/fast_scan/fast_scan.h>
 #include <faiss/utils/AlignedTable.h>
 
 namespace faiss {
 
-struct NormTableScaler;
 struct SIMDResultHandlerToFloat;
 struct Quantizer;
 
@@ -41,14 +41,14 @@ struct Quantizer;
 
 struct IndexIVFFastScan : IndexIVF {
     // size of the kernel
-    int bbs; // set at build time
+    int bbs = 0; // set at build time
 
-    size_t M;
-    size_t nbits;
-    size_t ksub;
+    size_t M = 0;
+    size_t nbits = 0;
+    size_t ksub = 0;
 
     // M rounded up to a multiple of 2
-    size_t M2;
+    size_t M2 = 0;
 
     // search-time implementation
     int implem = 0;
@@ -156,7 +156,7 @@ struct IndexIVFFastScan : IndexIVF {
      * @param context       processing context containing query factors
      * processor
      */
-    void compute_LUT_uint8(
+    virtual void compute_LUT_uint8(
             size_t n,
             const float* x,
             const CoarseQuantized& cq,
@@ -222,45 +222,31 @@ struct IndexIVFFastScan : IndexIVF {
             RangeSearchResult* result,
             const SearchParameters* params = nullptr) const override;
 
-    /** Create a KNN handler for this index type
+    /** Create a SIMD-dispatched scanner for knn search (IVF variant).
      *
-     * This method can be overridden by derived classes to provide
-     * specialized handlers (e.g., IVFRaBitQHeapHandler for RaBitQ indexes).
-     * Base implementation creates standard handlers based on k and impl.
+     * Returns a FastScanCodeScanner that bundles handler + accumulation
+     * kernel behind the SIMD dispatch boundary. ntotal is not passed
+     * because IVF sets it per-list via handler->ntotal.
+     * Derived classes override this to provide custom handlers
+     * (e.g. RaBitQ).
      *
-     * @param is_max        true for max-heap (inner product), false for
-     *                      min-heap (L2 distance)
-     * @param impl          implementation number:
-     *                      - even (10, 12, 14): use heap for top-k
-     *                      - odd (11, 13, 15): use reservoir sampling
-     * @param n             number of queries
-     * @param k             number of neighbors to find per query
-     * @param distances     output array for distances (n * k), will be
-     *                      populated by handler
-     * @param labels        output array for result IDs (n * k), will be
-     *                      populated by handler
-     * @param sel           optional ID selector to filter results (nullptr =
-     *                      no filtering)
-     * @param context       processing context containing additional data
-     * @param normalizers   optional array of size 2*n for converting quantized
-     *                      uint16 distances to float.
-     *
-     * @return Allocated result handler (caller owns and must delete).
-     *         Handler processes SIMD batches and populates distances/labels.
-     *
-     * @note The returned handler must be deleted by caller after use.
-     *       Typical usage: handler->begin() → process batches → handler->end()
+     * @param is_max       whether to use CMax comparator (true) or CMin
+     * @param n            number of queries
+     * @param k            number of neighbors to find
+     * @param distances    output distances array
+     * @param labels       output labels array
+     * @param sel          optional ID selector
+     * @return             scanner
      */
-    virtual SIMDResultHandlerToFloat* make_knn_handler(
+    virtual std::unique_ptr<FastScanCodeScanner> make_knn_scanner(
             bool is_max,
-            int impl,
             idx_t n,
             idx_t k,
             float* distances,
             idx_t* labels,
             const IDSelector* sel,
-            const FastScanDistancePostProcessing& context,
-            const float* normalizers = nullptr) const;
+            int impl = 0,
+            const FastScanDistancePostProcessing& context = {}) const;
 
     // dispatch to implementations and parallelize
     void search_dispatch_implem(
@@ -306,16 +292,18 @@ struct IndexIVFFastScan : IndexIVF {
             const IVFSearchParameters* params = nullptr) const;
 
     // implem 10 and 12 are not multithreaded internally, so
-    // export search stats
+    // export search stats. k is required for ensure_topk_full support.
     void search_implem_10(
             idx_t n,
             const float* x,
+            idx_t k,
             SIMDResultHandlerToFloat& handler,
             const CoarseQuantized& cq,
             size_t* ndis_out,
             size_t* nlist_out,
             const FastScanDistancePostProcessing& context,
-            const IVFSearchParameters* params = nullptr) const;
+            const IVFSearchParameters* params,
+            FastScanCodeScanner& scanner) const;
 
     void search_implem_12(
             idx_t n,
@@ -325,7 +313,8 @@ struct IndexIVFFastScan : IndexIVF {
             size_t* ndis_out,
             size_t* nlist_out,
             const FastScanDistancePostProcessing& context,
-            const IVFSearchParameters* params = nullptr) const;
+            const IVFSearchParameters* params,
+            FastScanCodeScanner& scanner) const;
 
     // implem 14 is multithreaded internally across nprobes and queries
     void search_implem_14(
@@ -359,6 +348,18 @@ struct IndexIVFFastScan : IndexIVF {
      */
     void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
 
+    /** Get the size of the code portion packed by pq4_pack_codes.
+     *
+     * Returns the number of bytes per vector that are interleaved into
+     * SIMD blocks by pq4_pack_codes, excluding any embedded metadata
+     * (e.g., RaBitQ factors). The meaning of these bytes depends on the
+     * quantizer: for PQ/AQ they are 4-bit sub-quantizer nibbles, for
+     * RaBitQ they are 1-bit-per-dimension sign bits packed into nibbles.
+     *
+     * Must be implemented by all derived classes.
+     */
+    virtual size_t fast_scan_code_size() const = 0;
+
    protected:
     /** Get stride for interpreting codes during SIMD packing.
      *

data/vendor/faiss/faiss/IndexIVFFlat.cpp

@@ -13,7 +13,6 @@
 
 #include <cinttypes>
 #include <cstdio>
-#include <numeric>
 
 #include <faiss/IndexFlat.h>
 
@@ -22,7 +21,13 @@
 
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/expanded_scanners.h>
+#include <faiss/utils/distances_dispatch.h>
 #include <faiss/utils/extra_distances.h>
+
+#define THE_SIMD_LEVEL SIMDLevel::NONE
+// NOLINTNEXTLINE(facebook-hte-InlineHeader)
+#include <faiss/utils/simd_impl/IVFFlatScanner-inl.h>
+
 #include <faiss/utils/utils.h>
 
 namespace faiss {
@@ -32,18 +37,18 @@ namespace faiss {
  ******************************************/
 
 IndexIVFFlat::IndexIVFFlat(
-        Index* quantizer,
-        size_t d,
-        size_t nlist,
+        Index* quantizer_in,
+        size_t d_in,
+        size_t nlist_in,
         MetricType metric,
-        bool own_invlists)
+        bool own_invlists_in)
         : IndexIVF(
-                  quantizer,
-                  d,
-                  nlist,
-                  sizeof(float) * d,
+                  quantizer_in,
+                  d_in,
+                  nlist_in,
+                  sizeof(float) * d_in,
                   metric,
-                  own_invlists) {
+                  own_invlists_in) {
     code_size = sizeof(float) * d;
     by_residual = false;
 }
@@ -61,7 +66,7 @@ void IndexIVFFlat::add_core(
     FAISS_THROW_IF_NOT(is_trained);
     FAISS_THROW_IF_NOT(coarse_idx);
     FAISS_THROW_IF_NOT(!by_residual);
-    assert(invlists);
+    FAISS_THROW_IF_NOT_MSG(invlists, "invlists not initialized");
     direct_map.check_can_add(xids);
 
     int64_t n_add = 0;
@@ -74,7 +79,7 @@ void IndexIVFFlat::add_core(
         int rank = omp_get_thread_num();
 
         // each thread takes care of a subset of lists
-        for (size_t i = 0; i < n; i++) {
+        for (idx_t i = 0; i < n; i++) {
             idx_t list_no = coarse_idx[i];
 
             if (list_no >= 0 && list_no % nt == rank) {
@@ -110,7 +115,7 @@ void IndexIVFFlat::encode_vectors(
         memcpy(codes, x, code_size * n);
     } else {
         size_t coarse_size = coarse_code_size();
-        for (size_t i = 0; i < n; i++) {
+        for (idx_t i = 0; i < n; i++) {
             int64_t list_no = list_nos[i];
             uint8_t* code = codes + i * (code_size + coarse_size);
             const float* xi = x + i * d;
@@ -129,7 +134,7 @@ void IndexIVFFlat::decode_vectors(
         const uint8_t* codes,
         const idx_t* /*listnos*/,
         float* x) const {
-    for (size_t i = 0; i < n; i++) {
+    for (idx_t i = 0; i < n; i++) {
         const uint8_t* code = codes + i * code_size;
         float* xi = x + i * d;
         memcpy(xi, code, code_size);
@@ -138,55 +143,13 @@ void IndexIVFFlat::decode_vectors(
 
 void IndexIVFFlat::sa_decode(idx_t n, const uint8_t* bytes, float* x) const {
     size_t coarse_size = coarse_code_size();
-    for (size_t i = 0; i < n; i++) {
+    for (idx_t i = 0; i < n; i++) {
         const uint8_t* code = bytes + i * (code_size + coarse_size);
         float* xi = x + i * d;
         memcpy(xi, code + coarse_size, code_size);
     }
 }
 
-namespace {
-
-template <typename VectorDistance>
-struct IVFFlatScanner : InvertedListScanner {
-    VectorDistance vd;
-    using C = typename VectorDistance::C;
-
-    IVFFlatScanner(
-            const VectorDistance& vd,
-            bool store_pairs,
-            const IDSelector* sel)
-            : InvertedListScanner(store_pairs, sel), vd(vd) {
-        keep_max = vd.is_similarity;
-        code_size = vd.d * sizeof(float);
-    }
-
-    const float* xi;
-    void set_query(const float* query) override {
-        this->xi = query;
-    }
-
-    void set_list(idx_t list_no, float /* coarse_dis */) override {
-        this->list_no = list_no;
-    }
-
-    float distance_to_code(const uint8_t* code) const final {
-        const float* yj = (float*)code;
-        return vd(xi, yj);
-    }
-
-    // redefining the scan_codes allows to inline the distance_to_code
-    size_t scan_codes(
-            size_t list_size,
-            const uint8_t* codes,
-            const idx_t* ids,
-            ResultHandler& handler) const {
-        return run_scan_codes_fix_C<C>(*this, list_size, codes, ids, handler);
-    }
-};
-
-} // anonymous namespace
-
 InvertedListScanner* IndexIVFFlat::get_InvertedListScanner(
         bool store_pairs,
         const IDSelector* sel,
@@ -209,12 +172,17 @@ void IndexIVFFlat::reconstruct_from_offset(
  ******************************************/
 
 IndexIVFFlatDedup::IndexIVFFlatDedup(
-        Index* quantizer,
-        size_t d,
-        size_t nlist_,
-        MetricType metric_type,
-        bool own_invlists)
-        : IndexIVFFlat(quantizer, d, nlist_, metric_type, own_invlists) {}
+        Index* quantizer_in,
+        size_t d_in,
+        size_t nlist_in,
+        MetricType metric_type_in,
+        bool own_invlists_in)
+        : IndexIVFFlat(
+                  quantizer_in,
+                  d_in,
+                  nlist_in,
+                  metric_type_in,
+                  own_invlists_in) {}
 
 void IndexIVFFlatDedup::train(idx_t n, const float* x) {
     std::unordered_map<uint64_t, idx_t> map;
@@ -247,7 +215,7 @@ void IndexIVFFlatDedup::add_with_ids(
         const float* x,
         const idx_t* xids) {
     FAISS_THROW_IF_NOT(is_trained);
-    assert(invlists);
+    FAISS_THROW_IF_NOT_MSG(invlists, "invlists not initialized");
     FAISS_THROW_IF_NOT_MSG(
             direct_map.no(), "IVFFlatDedup not implemented with direct_map");
     std::unique_ptr<int64_t[]> idx(new int64_t[na]);
@@ -261,7 +229,7 @@ void IndexIVFFlatDedup::add_with_ids(
         int rank = omp_get_thread_num();
 
         // each thread takes care of a subset of lists
-        for (size_t i = 0; i < na; i++) {
+        for (idx_t i = 0; i < na; i++) {
             int64_t list_no = idx[i];
 
             if (list_no < 0 || list_no % nt != rank) {
@@ -320,7 +288,7 @@ void IndexIVFFlatDedup::search_preassigned(
         idx_t* labels,
         bool store_pairs,
         const IVFSearchParameters* params,
-        IndexIVFStats* stats) const {
+        IndexIVFStats* /*stats*/) const {
     FAISS_THROW_IF_NOT_MSG(
             !store_pairs, "store_pairs not supported in IVFDedup");
 
@@ -401,7 +369,7 @@ size_t IndexIVFFlatDedup::remove_ids(const IDSelector& sel) {
     std::vector<int64_t> toremove(nlist);
 
 #pragma omp parallel for
-    for (int64_t i = 0; i < nlist; i++) {
+    for (idx_t i = 0; i < static_cast<idx_t>(nlist); i++) {
         int64_t l0 = invlists->list_size(i), l = l0, j = 0;
         InvertedLists::ScopedIds idsi(invlists, i);
         while (j < l) {
@@ -429,7 +397,7 @@ size_t IndexIVFFlatDedup::remove_ids(const IDSelector& sel) {
     }
     // this will not run well in parallel on ondisk because of possible shrinks
     int64_t nremove = 0;
-    for (int64_t i = 0; i < nlist; i++) {
+    for (idx_t i = 0; i < static_cast<idx_t>(nlist); i++) {
         if (toremove[i] > 0) {
             nremove += toremove[i];
             invlists->resize(i, invlists->list_size(i) - toremove[i]);

data/vendor/faiss/faiss/IndexIVFFlat.h

@@ -62,6 +62,38 @@ struct IndexIVFFlat : IndexIVF {
     IndexIVFFlat();
 };
 
+template <typename VectorDistance>
+struct IVFFlatScanner : InvertedListScanner {
+    VectorDistance vd;
+    using C = typename VectorDistance::C;
+
+    IVFFlatScanner(
+            const VectorDistance& vd,
+            bool store_pairs,
+            const IDSelector* sel)
+            : InvertedListScanner(store_pairs, sel), vd(vd) {
+        keep_max = vd.is_similarity;
+        code_size = vd.d * sizeof(float);
+    }
+
+    const float* xi = nullptr;
+    void set_query(const float* query) override {
+        this->xi = query;
+    }
+
+    void set_list(idx_t list_no, float /* coarse_dis */) override {
+        this->list_no = list_no;
+    }
+
+    float distance_to_code(const uint8_t* code) const final;
+
+    size_t scan_codes(
+            size_t list_size,
+            const uint8_t* codes,
+            const idx_t* ids,
+            ResultHandler& handler) const override;
+};
+
 struct IndexIVFFlatDedup : IndexIVFFlat {
     /** Maps ids stored in the index to the ids of vectors that are
      *  the same. When a vector is unique, it does not appear in the

data/vendor/faiss/faiss/IndexIVFFlatPanorama.cpp

@@ -20,29 +20,35 @@
 #include <faiss/impl/ResultHandler.h>
 
 #include <faiss/impl/FaissAssert.h>
+#include <faiss/utils/distances_dispatch.h>
 #include <faiss/utils/extra_distances.h>
 #include <faiss/utils/utils.h>
 
 namespace faiss {
 
 IndexIVFFlatPanorama::IndexIVFFlatPanorama(
-        Index* quantizer,
-        size_t d,
-        size_t nlist,
-        int n_levels,
+        Index* quantizer_in,
+        size_t d_in,
+        size_t nlist_in,
+        int n_levels_in,
         MetricType metric,
-        bool own_invlists)
-        : IndexIVFFlat(quantizer, d, nlist, metric, false), n_levels(n_levels) {
+        bool own_invlists_in,
+        size_t batch_size_in)
+        : IndexIVFFlat(quantizer_in, d_in, nlist_in, metric, false),
+          n_levels(n_levels_in),
+          batch_size(batch_size_in) {
     FAISS_THROW_IF_NOT(metric == METRIC_L2 || metric == METRIC_INNER_PRODUCT);
 
     // We construct the inverted lists here so that we can use the
     // level-oriented storage. This does not cause a leak as we constructed
     // IndexIVF first, with own_invlists set to false.
-    this->invlists = new ArrayInvertedListsPanorama(nlist, code_size, n_levels);
-    this->own_invlists = own_invlists;
+    this->invlists = new ArrayInvertedListsPanorama(
+            nlist, code_size, n_levels, batch_size);
+    this->own_invlists = own_invlists_in;
 }
 
-IndexIVFFlatPanorama::IndexIVFFlatPanorama() : n_levels(0) {}
+IndexIVFFlatPanorama::IndexIVFFlatPanorama()
+        : n_levels(0), batch_size(Panorama::kDefaultBatchSize) {}
 
 namespace {
 
@@ -53,15 +59,26 @@ struct IVFFlatScannerPanorama : InvertedListScanner {
     using C = typename VectorDistance::C;
     static constexpr MetricType metric = VectorDistance::metric;
 
+    mutable std::vector<uint32_t> active_indices_;
+    mutable std::vector<uint8_t> active_byteset_;
+    mutable std::vector<float> exact_distances_;
+    mutable std::vector<float> dot_buffer_;
+
     IVFFlatScannerPanorama(
-            const VectorDistance& vd,
-            const ArrayInvertedListsPanorama* storage,
-            bool store_pairs,
-            const IDSelector* sel)
-            : InvertedListScanner(store_pairs, sel), vd(vd), storage(storage) {
+            const VectorDistance& vd_in,
+            const ArrayInvertedListsPanorama* storage_in,
+            bool store_pairs_in,
+            const IDSelector* sel_in)
+            : InvertedListScanner(store_pairs_in, sel_in),
+              vd(vd_in),
+              storage(storage_in) {
         keep_max = vd.is_similarity;
         code_size = vd.d * sizeof(float);
-        cum_sums.resize(storage->n_levels + 1);
+        cum_sums.resize(storage->pano.n_levels + 1);
+        active_indices_.resize(storage->pano.batch_size);
+        active_byteset_.resize(storage->pano.batch_size);
+        exact_distances_.resize(storage->pano.batch_size);
+        dot_buffer_.resize(storage->pano.batch_size);
     }
 
     const float* xi = nullptr;
@@ -73,8 +90,8 @@ struct IVFFlatScannerPanorama : InvertedListScanner {
         q_norm = cum_sums[0] * cum_sums[0];
     }
 
-    void set_list(idx_t list_no, float /* coarse_dis */) override {
-        this->list_no = list_no;
+    void set_list(idx_t list_no_in, float /* coarse_dis */) override {
+        this->list_no = list_no_in;
     }
 
     /// This function is unreachable as `IndexIVF` only calls this within
@@ -85,6 +102,8 @@ struct IVFFlatScannerPanorama : InvertedListScanner {
                 "IndexIVFFlatPanorama does not support distance_to_code");
     }
 
+    using InvertedListScanner::scan_codes;
+
     size_t scan_codes(
             size_t list_size,
             const uint8_t* codes,
@@ -92,20 +111,16 @@ struct IVFFlatScannerPanorama : InvertedListScanner {
             ResultHandler& handler) const override {
         size_t nup = 0;
 
-        const size_t n_batches =
-                (list_size + storage->kBatchSize - 1) / storage->kBatchSize;
+        const size_t bs = storage->pano.batch_size;
+        const size_t n_batches = (list_size + bs - 1) / bs;
 
         const float* cum_sums_data = storage->get_cum_sums(list_no);
 
-        std::vector<float> exact_distances(storage->kBatchSize);
-        std::vector<uint32_t> active_indices(storage->kBatchSize);
-
         PanoramaStats local_stats;
         local_stats.reset();
 
         for (size_t batch_no = 0; batch_no < n_batches; batch_no++) {
-            size_t batch_start = batch_no * storage->kBatchSize;
-
+            size_t batch_start = batch_no * bs;
             size_t num_active = with_metric_type(metric, [&]<MetricType M>() {
                 return storage->pano.progressive_filter_batch<C, M>(
                         codes,
@@ -117,23 +132,31 @@ struct IVFFlatScannerPanorama : InvertedListScanner {
                         sel,
                         ids,
                         use_sel,
-                        active_indices,
-                        exact_distances,
+                        active_indices_,
+                        active_byteset_,
+                        exact_distances_,
+                        dot_buffer_,
                         handler.threshold,
                         local_stats);
             });
 
+            // num_active is the count of codes for which exact distance
+            // was computed in this batch (post-filter, post-pruning).
+            handler.stats.scan_cnt += num_active;
+
             // Add batch survivors to heap.
             for (size_t i = 0; i < num_active; i++) {
-                uint32_t idx = active_indices[i];
+                uint32_t idx = active_indices_[i];
                 size_t global_idx = batch_start + idx;
-                float dis = exact_distances[idx];
+                float dis = exact_distances_[idx];
 
                 if (C::cmp(handler.threshold, dis)) {
                     int64_t id = store_pairs ? lo_build(list_no, global_idx)
                                              : ids[global_idx];
-                    handler.add_result(dis, id);
-                    nup++;
+                    if (handler.add_result(dis, id)) {
+                        handler.stats.nheap_updates++;
+                        nup++;
+                    }
                 }
             }
         }

data/vendor/faiss/faiss/IndexIVFFlatPanorama.h

@@ -37,6 +37,7 @@ namespace faiss {
 /// `ArrayInvertedListsPanorama`, which is a struct member of `IndexIVF`.
 struct IndexIVFFlatPanorama : IndexIVFFlat {
     size_t n_levels;
+    size_t batch_size;
 
     std::vector<MaybeOwnedVector<float>> cum_sums;
 
@@ -46,7 +47,8 @@ struct IndexIVFFlatPanorama : IndexIVFFlat {
             size_t nlist_,
             int n_levels,
             MetricType = METRIC_L2,
-            bool own_invlists = true);
+            bool own_invlists = true,
+            size_t batch_size = Panorama::kDefaultBatchSize);
 
     InvertedListScanner* get_InvertedListScanner(
             bool store_pairs,

data/vendor/faiss/faiss/IndexIVFIndependentQuantizer.cpp

@@ -13,13 +13,13 @@
 namespace faiss {
 
 IndexIVFIndependentQuantizer::IndexIVFIndependentQuantizer(
-        Index* quantizer,
-        IndexIVF* index_ivf,
-        VectorTransform* vt)
-        : Index(quantizer->d, index_ivf->metric_type),
-          quantizer(quantizer),
-          vt(vt),
-          index_ivf(index_ivf) {
+        Index* quantizer_in,
+        IndexIVF* index_ivf_in,
+        VectorTransform* vt_in)
+        : Index(quantizer_in->d, index_ivf_in->metric_type),
+          quantizer(quantizer_in),
+          vt(vt_in),
+          index_ivf(index_ivf_in) {
     if (vt) {
         FAISS_THROW_IF_NOT_MSG(
                 vt->d_in == d && vt->d_out == index_ivf->d,
@@ -29,14 +29,16 @@ IndexIVFIndependentQuantizer::IndexIVFIndependentQuantizer(
     }
 
     if (quantizer->is_trained && quantizer->ntotal != 0) {
-        FAISS_THROW_IF_NOT(quantizer->ntotal == index_ivf->nlist);
+        FAISS_THROW_IF_NOT(
+                quantizer->ntotal == static_cast<idx_t>(index_ivf->nlist));
     }
     if (index_ivf->is_trained && vt) {
         FAISS_THROW_IF_NOT(vt->is_trained);
     }
     ntotal = index_ivf->ntotal;
     is_trained =
-            (quantizer->is_trained && quantizer->ntotal == index_ivf->nlist &&
+            (quantizer->is_trained &&
+             quantizer->ntotal == static_cast<idx_t>(index_ivf->nlist) &&
              (!vt || vt->is_trained) && index_ivf->is_trained);
 
     // disable precomputed tables because they use the distances that are
@@ -57,15 +59,16 @@ IndexIVFIndependentQuantizer::~IndexIVFIndependentQuantizer() {
 namespace {
 
 struct VTransformedVectors : TransformedVectors {
-    VTransformedVectors(const VectorTransform* vt, idx_t n, const float* x)
-            : TransformedVectors(x, vt ? vt->apply(n, x) : x) {}
+    VTransformedVectors(const VectorTransform* vt, idx_t n, const float* x_in)
+            : TransformedVectors(x_in, vt ? vt->apply(n, x_in) : x_in) {}
 };
 
 struct SubsampledVectors : TransformedVectors {
-    SubsampledVectors(int d, idx_t* n, idx_t max_n, const float* x)
+    SubsampledVectors(int d, idx_t* n, idx_t max_n, const float* x_in)
             : TransformedVectors(
-                      x,
-                      fvecs_maybe_subsample(d, (size_t*)n, max_n, x, true)) {}
+                      x_in,
+                      fvecs_maybe_subsample(d, (size_t*)n, max_n, x_in, true)) {
+    }
 };
 
 } // anonymous namespace
@@ -88,7 +91,7 @@ void IndexIVFIndependentQuantizer::search(
         idx_t* labels,
         const SearchParameters* params) const {
     FAISS_THROW_IF_NOT_MSG(!params, "search parameters not supported");
-    int nprobe = index_ivf->nprobe;
+    size_t nprobe = index_ivf->nprobe;
     std::vector<float> D(n * nprobe);
     std::vector<idx_t> I(n * nprobe);
     quantizer->search(n, x, nprobe, D.data(), I.data());