faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/gpu_metal/MetalIndexFlat.h

@@ -0,0 +1,65 @@
+// @lint-ignore-every LICENSELINT
+/**
+ * Copyright (c) Meta Platforms, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Objective-C++ header (uses Metal types).
+ */
+
+#pragma once
+
+#import <Metal/Metal.h>
+
+#include <faiss/Index.h>
+#include <faiss/gpu_metal/MetalIndex.h>
+
+namespace faiss {
+struct IndexFlat;
+}
+#include <memory>
+
+namespace faiss {
+namespace gpu_metal {
+
+/// Flat index that stores vectors in an MTLBuffer. Supports L2 and inner
+/// product. Search runs on GPU via Metal compute (distance + top-k kernels).
+class MetalIndexFlat : public MetalIndex {
+   public:
+    MetalIndexFlat(
+            std::shared_ptr<MetalResources> resources,
+            int dims,
+            faiss::MetricType metric,
+            float metricArg = 0.0f,
+            MetalIndexConfig config = MetalIndexConfig());
+
+    ~MetalIndexFlat() override;
+
+    void add(idx_t n, const float* x) override;
+    void add_with_ids(idx_t n, const float* x, const idx_t* xids) override;
+    void reset() override;
+    void search(
+            idx_t n,
+            const float* x,
+            idx_t k,
+            float* distances,
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const override;
+
+    /// Copy vectors to a CPU IndexFlat (e.g. for index_metal_gpu_to_cpu).
+    void copyTo(::faiss::IndexFlat* index) const;
+
+   private:
+    /// Ensures vector buffer can hold at least \p newNtotal vectors; grows
+    /// buffer if necessary.
+    void ensureCapacity(idx_t newNtotal);
+
+    /// Vector storage (row-major, ntotal * d floats). Nil when empty.
+    id<MTLBuffer> vectorsBuffer_;
+    /// Capacity of vectorsBuffer_ in number of vectors (0 if buffer is nil).
+    size_t capacityVecs_;
+};
+
+} // namespace gpu_metal
+} // namespace faiss

data/vendor/faiss/faiss/gpu_metal/MetalKernels.h

@@ -0,0 +1,66 @@
+// @lint-ignore-every LICENSELINT
+/**
+ * Copyright (c) Meta Platforms, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * MetalKernels: typed wrapper around Metal compute kernels.
+ * Owns library compilation, pipeline caching, and dispatch encoding.
+ */
+
+#pragma once
+
+#import <Metal/Metal.h>
+#include <faiss/MetricType.h>
+#include <string>
+#include <unordered_map>
+
+namespace faiss {
+namespace gpu_metal {
+
+class MetalKernels {
+   public:
+    explicit MetalKernels(id<MTLDevice> device);
+    ~MetalKernels();
+
+    bool isValid() const;
+    static constexpr int kMaxK = 256;
+
+    void encodeDistanceMatrix(
+            id<MTLComputeCommandEncoder> enc,
+            id<MTLBuffer> queries,
+            id<MTLBuffer> vectors,
+            id<MTLBuffer> distances,
+            int nq,
+            int nb,
+            int d,
+            MetricType metric);
+
+    void encodeTopKThreadgroup(
+            id<MTLComputeCommandEncoder> enc,
+            id<MTLBuffer> distances,
+            id<MTLBuffer> outDist,
+            id<MTLBuffer> outIdx,
+            int nq,
+            int nb,
+            int k,
+            bool wantMin);
+
+    static int selectTopKVariantIndex(int k);
+
+   private:
+    id<MTLComputePipelineState> pipeline(const char* name);
+
+    id<MTLDevice> device_;
+    id<MTLLibrary> library_;
+    std::unordered_map<std::string, id<MTLComputePipelineState>> cache_;
+
+    static constexpr int kTopKVariantSizes[] = {32, 64, 128, 256};
+    static constexpr int kNumTopKVariants = 4;
+};
+
+MetalKernels& getMetalKernels(id<MTLDevice> device);
+
+} // namespace gpu_metal
+} // namespace faiss

data/vendor/faiss/faiss/gpu_metal/MetalResources.h

@@ -0,0 +1,79 @@
+// @lint-ignore-every LICENSELINT
+/**
+ * Copyright (c) Meta Platforms, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * This header uses Objective-C types (Metal framework: id, nil, MTLDevice,
+ * etc.). For correct IDE/linter behavior, associate this file with
+ * "Objective-C++":
+ *
+ */
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import <Metal/Metal.h>
+
+#include <cstddef>
+
+namespace faiss {
+namespace gpu_metal {
+
+/// Allocation type for Metal buffers (mirrors faiss::gpu::AllocType roles).
+enum MetalAllocType {
+    Other = 0,
+    FlatData = 1,
+    IVFLists = 2,
+    Quantizer = 3,
+    QuantizerPrecomputedCodes = 4,
+    TemporaryMemoryBuffer = 10,
+    TemporaryMemoryOverflow = 11,
+};
+
+/// Owns Metal device, command queue, and provides buffer allocation.
+/// Mirrors the roles of faiss::gpu::GpuResources for the Metal backend.
+class MetalResources {
+   public:
+    MetalResources();
+    ~MetalResources();
+
+    MetalResources(const MetalResources&) = delete;
+    MetalResources& operator=(const MetalResources&) = delete;
+
+    /// Returns the Metal device (nil if no Metal-capable device is available).
+    id<MTLDevice> getDevice() const {
+        return device_;
+    }
+
+    /// Returns the command queue for the device (nil if device is nil).
+    id<MTLCommandQueue> getCommandQueue() const {
+        return commandQueue_;
+    }
+
+    /// Allocates a buffer of the given size (bytes). Caller owns the returned
+    /// buffer and must call deallocBuffer when done, or the buffer will leak.
+    /// Returns nil on failure (e.g. device nil or allocation failure).
+    id<MTLBuffer> allocBuffer(size_t size, MetalAllocType type);
+
+    /// Releases a buffer previously returned by allocBuffer. The caller must
+    /// not use the buffer after this call.
+    void deallocBuffer(id<MTLBuffer> buffer, MetalAllocType type);
+
+    /// Blocks until all work submitted to the default command queue has
+    /// completed.
+    void synchronize();
+
+    /// Returns true if the Metal device and queue are available.
+    bool isAvailable() const {
+        return device_ != nil && commandQueue_ != nil;
+    }
+
+   private:
+    id<MTLDevice> device_;
+    id<MTLCommandQueue> commandQueue_;
+};
+
+} // namespace gpu_metal
+} // namespace faiss

data/vendor/faiss/faiss/gpu_metal/StandardMetalResources.h

@@ -0,0 +1,35 @@
+// @lint-ignore-every LICENSELINT
+/**
+ * Copyright (c) Meta Platforms, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Mirrors the role of StandardGpuResources for the Metal backend.
+ */
+
+#pragma once
+
+#include <faiss/gpu_metal/MetalResources.h>
+#include <memory>
+
+namespace faiss {
+namespace gpu_metal {
+
+/// Default Metal resources (single device). Use with index_cpu_to_metal_gpu.
+class StandardMetalResources {
+   public:
+    StandardMetalResources();
+    std::shared_ptr<MetalResources> getResources() const {
+        return res_;
+    }
+    bool isAvailable() const {
+        return res_ && res_->isAvailable();
+    }
+
+   private:
+    std::shared_ptr<MetalResources> res_;
+};
+
+} // namespace gpu_metal
+} // namespace faiss

data/vendor/faiss/faiss/impl/AdSampling.cpp

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <faiss/impl/AdSampling.h>
+
+#include <cmath>
+
+#include <faiss/impl/FaissAssert.h>
+
+namespace faiss {
+namespace detail {
+
+double normal_quantile(double p) {
+    // Three-branch rational polynomial; branch breakpoint p_low = 0.02425.
+    static constexpr double a[] = {
+            -3.969683028665376e+01,
+            2.209460984245205e+02,
+            -2.759285104469687e+02,
+            1.383577518672690e+02,
+            -3.066479806614716e+01,
+            2.506628277459239e+00,
+    };
+    static constexpr double b[] = {
+            -5.447609879822406e+01,
+            1.615858368580409e+02,
+            -1.556989798598866e+02,
+            6.680131188771972e+01,
+            -1.328068155288572e+01,
+    };
+    static constexpr double c[] = {
+            -7.784894002430293e-03,
+            -3.223964580411365e-01,
+            -2.400758277161838e+00,
+            -2.549732539343734e+00,
+            4.374664141464968e+00,
+            2.938163982698783e+00,
+    };
+    static constexpr double d[] = {
+            7.784695709041462e-03,
+            3.224671290700398e-01,
+            2.445134137142996e+00,
+            3.754408661907416e+00,
+    };
+    constexpr double p_low = 0.02425;
+    constexpr double p_high = 1.0 - p_low;
+    if (p < p_low) {
+        const double q = std::sqrt(-2.0 * std::log(p));
+        return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q +
+                c[5]) /
+                ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1.0);
+    } else if (p <= p_high) {
+        const double q = p - 0.5;
+        const double r = q * q;
+        return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r +
+                a[5]) *
+                q /
+                (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r +
+                 1.0);
+    } else {
+        const double q = std::sqrt(-2.0 * std::log(1.0 - p));
+        return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q +
+                 c[5]) /
+                ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1.0);
+    }
+}
+
+double chi2_quantile_wh(int p, double alpha) {
+    FAISS_THROW_IF_NOT(p > 0);
+    // Wilson-Hilferty cube-root approximation:
+    //   ((X/p)^(1/3) - (1 - 2/(9p))) / sqrt(2/(9p)) ~ N(0,1)
+    // inverted into a quantile formula.
+    //
+    // Domain constraint: for very small alpha (< ~0.001) and small p
+    // (< 4), t can go negative, producing a negative chi-squared quantile
+    // (physically impossible). In practice this cannot happen here:
+    // precompute_ad_thresholds calls with alpha = 1 - epsilon where
+    // epsilon = ad_epsilon_factor / d, and d_prime_min >= 16, so
+    // p >= 16 and alpha >= 1 - 1/16 = 0.9375 — well inside the accurate
+    // region of the approximation.
+    const double z = normal_quantile(alpha);
+    const double t = 1.0 - 2.0 / (9.0 * p) + z * std::sqrt(2.0 / (9.0 * p));
+    return p * t * t * t;
+}
+
+std::vector<float> precompute_ad_thresholds(int d, double epsilon) {
+    FAISS_THROW_IF_NOT_MSG(
+            epsilon > 0.0 && epsilon < 1.0,
+            "precompute_ad_thresholds: epsilon must be in (0, 1)");
+    FAISS_THROW_IF_NOT_MSG(
+            d > 0, "precompute_ad_thresholds: d must be positive");
+    std::vector<float> coeff(d + 1);
+    for (int p = 1; p <= d; p++) {
+        coeff[p] = static_cast<float>(chi2_quantile_wh(p, 1.0 - epsilon) / d);
+    }
+    return coeff;
+}
+
+} // namespace detail
+} // namespace faiss

data/vendor/faiss/faiss/impl/AdSampling.h

@@ -0,0 +1,35 @@
+/*
+ * 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 <vector>
+
+namespace faiss {
+namespace detail {
+
+/** Inverse standard normal CDF. Three-branch rational polynomial,
+ * absolute error < 1.15e-9 over `p in (0, 1)`. Behavior at the boundaries
+ * (p <= 0 or p >= 1) is unspecified — returns NaN or +/-inf. */
+double normal_quantile(double p);
+
+/** Chi-squared quantile via cube-root approximation. Validated to within
+ * 2% of scipy for `p in [16, d]` and `alpha <= 1 - 1e-6`. Accuracy
+ * degrades for smaller `p` or for `alpha` near 1. */
+double chi2_quantile_wh(int p, double alpha);
+
+/** Build ADSampling threshold table of size `d + 1`:
+ *   coeff[p] = chi2_quantile_wh(p, 1 - epsilon) / d.
+ *
+ * Indexing: coeff[0] is reserved (left at 0.0f). coeff[1..15] are
+ * computed but NOT accuracy-bounded — callers requiring the 2% scipy
+ * tolerance must consume only coeff[16..d]. SuperKMeans enforces
+ * this via its `d_prime_min = 16` parameter. */
+std::vector<float> precompute_ad_thresholds(int d, double epsilon);
+
+} // namespace detail
+} // namespace faiss

data/vendor/faiss/faiss/impl/AdditiveQuantizer.cpp

@@ -48,13 +48,13 @@ int sgemm_(
 namespace faiss {
 
 AdditiveQuantizer::AdditiveQuantizer(
-        size_t d,
-        const std::vector<size_t>& nbits,
-        Search_type_t search_type)
-        : Quantizer(d),
-          M(nbits.size()),
-          nbits(nbits),
-          search_type(search_type) {
+        size_t d_in,
+        const std::vector<size_t>& nbits_in,
+        Search_type_t search_type_in)
+        : Quantizer(d_in),
+          M(nbits_in.size()),
+          nbits(nbits_in),
+          search_type(search_type_in) {
     set_derived_values();
 }
 
@@ -65,7 +65,7 @@ void AdditiveQuantizer::set_derived_values() {
     tot_bits = 0;
     only_8bit = true;
     codebook_offsets.resize(M + 1, 0);
-    for (int i = 0; i < M; i++) {
+    for (size_t i = 0; i < M; i++) {
         int nbit = nbits[i];
         FAISS_CHECK_RANGE(nbit, 0, 31);
         size_t k = (size_t)1 << nbit;
@@ -107,7 +107,7 @@ void AdditiveQuantizer::set_derived_values() {
 void AdditiveQuantizer::train_norm(size_t n, const float* norms) {
     norm_min = HUGE_VALF;
     norm_max = -HUGE_VALF;
-    for (idx_t i = 0; i < n; i++) {
+    for (size_t i = 0; i < n; i++) {
         if (norms[i] < norm_min) {
             norm_min = norms[i];
         }
@@ -167,7 +167,7 @@ void AdditiveQuantizer::compute_codebook_tables() {
     fvec_norms_L2sqr(
             centroid_norms.data(), codebooks.data(), d, total_codebook_size);
     size_t cross_table_size = 0;
-    for (int m = 0; m < M; m++) {
+    for (size_t m = 0; m < M; m++) {
         FAISS_CHECK_RANGE(nbits[m], 0, 31);
         size_t K = (size_t)1 << nbits[m];
         size_t product =
@@ -177,7 +177,7 @@ void AdditiveQuantizer::compute_codebook_tables() {
     }
     codebook_cross_products.resize(cross_table_size);
     size_t ofs = 0;
-    for (int m = 1; m < M; m++) {
+    for (size_t m = 1; m < M; m++) {
         FINTEGER ki = (size_t)1 << nbits[m];
         FINTEGER kk = codebook_offsets[m];
         FINTEGER di = d;
@@ -186,7 +186,7 @@ void AdditiveQuantizer::compute_codebook_tables() {
         FAISS_THROW_IF_NOT_FMT(
                 add_no_overflow(ofs, step_size, "cross product table offset") <=
                         cross_table_size,
-                "cross product table overflow at step %d: "
+                "cross product table overflow at step %zd: "
                 "%zd + %zd > %zd",
                 m,
                 ofs,
@@ -300,11 +300,12 @@ void AdditiveQuantizer::pack_codes(
             norms = norm_buf.data();
         }
     }
+    int64_t n_signed = n;
 #pragma omp parallel for if (n > 1000)
-    for (int64_t i = 0; i < n; i++) {
+    for (int64_t i = 0; i < n_signed; i++) {
         const int32_t* codes1 = codes + i * ld_codes;
         BitstringWriter bsw(packed_codes + i * code_size, code_size);
-        for (int m = 0; m < M; m++) {
+        for (size_t m = 0; m < M; m++) {
             bsw.write(codes1[m], nbits[m]);
         }
         if (norm_bits != 0) {
@@ -317,12 +318,13 @@ void AdditiveQuantizer::decode(const uint8_t* code, float* x, size_t n) const {
     FAISS_THROW_IF_NOT_MSG(
             is_trained, "The additive quantizer is not trained yet.");
 
+    int64_t n_signed = n;
     // standard additive quantizer decoding
 #pragma omp parallel for if (n > 100)
-    for (int64_t i = 0; i < n; i++) {
+    for (int64_t i = 0; i < n_signed; i++) {
         BitstringReader bsr(code + i * code_size, code_size);
         float* xi = x + i * d;
-        for (int m = 0; m < M; m++) {
+        for (size_t m = 0; m < M; m++) {
             int idx = bsr.read(nbits[m]);
             const float* c = codebooks.data() + d * (codebook_offsets[m] + idx);
             if (m == 0) {
@@ -346,12 +348,13 @@ void AdditiveQuantizer::decode_unpacked(
         ld_codes = M;
     }
 
+    int64_t n_signed = n;
     // standard additive quantizer decoding
 #pragma omp parallel for if (n > 1000)
-    for (int64_t i = 0; i < n; i++) {
+    for (int64_t i = 0; i < n_signed; i++) {
         const int32_t* codesi = code + i * ld_codes;
         float* xi = x + i * d;
-        for (int m = 0; m < M; m++) {
+        for (size_t m = 0; m < M; m++) {
             int idx = codesi[m];
             const float* c = codebooks.data() + d * (codebook_offsets[m] + idx);
             if (m == 0) {
@@ -371,13 +374,14 @@ AdditiveQuantizer::~AdditiveQuantizer() {}
 
 void AdditiveQuantizer::compute_centroid_norms(float* norms) const {
     size_t ntotal = (size_t)1 << tot_bits;
+    int64_t ntotal_signed = ntotal;
     // TODO: make tree of partial sums
     with_simd_level([&]<SIMDLevel SL>() {
 #pragma omp parallel
         {
             std::vector<float> tmp(d);
 #pragma omp for
-            for (int64_t i = 0; i < ntotal; i++) {
+            for (int64_t i = 0; i < ntotal_signed; i++) {
                 decode_64bit(i, tmp.data());
                 norms[i] = fvec_norm_L2sqr<SL>(tmp.data(), d);
             }
@@ -386,7 +390,7 @@ void AdditiveQuantizer::compute_centroid_norms(float* norms) const {
 }
 
 void AdditiveQuantizer::decode_64bit(idx_t bits, float* xi) const {
-    for (int m = 0; m < M; m++) {
+    for (size_t m = 0; m < M; m++) {
         idx_t idx = bits & (((size_t)1 << nbits[m]) - 1);
         bits >>= nbits[m];
         const float* c = codebooks.data() + d * (codebook_offsets[m] + idx);
@@ -436,7 +440,7 @@ void compute_inner_prod_with_LUT(
         const float* LUT,
         float* ips) {
     size_t prev_size = 1;
-    for (int m = 0; m < aq.M; m++) {
+    for (size_t m = 0; m < aq.M; m++) {
         const float* LUTm = LUT + aq.codebook_offsets[m];
         int nb = aq.nbits[m];
         size_t nc = (size_t)1 << nb;
@@ -509,7 +513,7 @@ void AdditiveQuantizer::knn_centroids_L2(
             // ||x - y||^2 = ||x||^2 + ||y||^2 - 2 * <x,y>
 
             maxheap_heapify(k, distances_i, labels_i);
-            for (idx_t j = 0; j < ntotal; j++) {
+            for (size_t j = 0; j < ntotal; j++) {
                 float disj = q_norms[i] + norms[j] - 2 * dis[j];
                 if (disj < distances_i[0]) {
                     heap_replace_top<CMax<float, int64_t>>(
@@ -532,7 +536,7 @@ float accumulate_IPs(
         BitstringReader& bs,
         const float* LUT) {
     float accu = 0;
-    for (int m = 0; m < aq.M; m++) {
+    for (size_t m = 0; m < aq.M; m++) {
         size_t nbit = aq.nbits[m];
         int idx = bs.read(nbit);
         accu += LUT[idx];
@@ -545,7 +549,7 @@ float compute_norm_from_LUT(const AdditiveQuantizer& aq, BitstringReader& bs) {
     float accu = 0;
     std::vector<int> idx(aq.M);
     const float* c = aq.codebook_cross_products.data();
-    for (int m = 0; m < aq.M; m++) {
+    for (size_t m = 0; m < aq.M; m++) {
         size_t nbit = aq.nbits[m];
         int i = bs.read(nbit);
         size_t K = 1 << nbit;
@@ -553,7 +557,7 @@ float compute_norm_from_LUT(const AdditiveQuantizer& aq, BitstringReader& bs) {
 
         accu += aq.centroid_norms[aq.codebook_offsets[m] + i];
 
-        for (int l = 0; l < m; l++) {
+        for (size_t l = 0; l < m; l++) {
             int j = idx[l];
             accu += 2 * c[j * K + i];
             c += (1 << aq.nbits[l]) * K;

data/vendor/faiss/faiss/impl/AdditiveQuantizer.h

@@ -83,6 +83,7 @@ struct AdditiveQuantizer : Quantizer {
         ST_norm_lsq2x4, ///< use a 2x4 bits lsq as norm quantizer (for fast
                         ///< scan)
         ST_norm_rq2x4,  ///< use a 2x4 bits rq as norm quantizer (for fast scan)
+        ST_count
     };
 
     AdditiveQuantizer(

data/vendor/faiss/faiss/impl/AuxIndexStructures.cpp

@@ -20,10 +20,11 @@ namespace faiss {
  * RangeSearchResult
  ***********************************************************************/
 
-RangeSearchResult::RangeSearchResult(size_t nq, bool alloc_lims) : nq(nq) {
+RangeSearchResult::RangeSearchResult(size_t nq_in, bool alloc_lims)
+        : nq(nq_in) {
     if (alloc_lims) {
-        lims = new size_t[nq + 1];
-        memset(lims, 0, sizeof(*lims) * (nq + 1));
+        lims = new size_t[nq_in + 1];
+        memset(lims, 0, sizeof(*lims) * (nq_in + 1));
     } else {
         lims = nullptr;
     }
@@ -39,7 +40,7 @@ void RangeSearchResult::do_allocation() {
     // simultaneously
     FAISS_THROW_IF_NOT(labels == nullptr && distances == nullptr);
     size_t ofs = 0;
-    for (int i = 0; i < nq; i++) {
+    for (size_t i = 0; i < nq; i++) {
         size_t n = lims[i];
         lims[i] = ofs;
         ofs += n;
@@ -59,12 +60,12 @@ RangeSearchResult::~RangeSearchResult() {
  * BufferList
  ***********************************************************************/
 
-BufferList::BufferList(size_t buffer_size) : buffer_size(buffer_size) {
-    wp = buffer_size;
+BufferList::BufferList(size_t buffer_size_in) : buffer_size(buffer_size_in) {
+    wp = buffer_size_in;
 }
 
 BufferList::~BufferList() {
-    for (int i = 0; i < buffers.size(); i++) {
+    for (size_t i = 0; i < buffers.size(); i++) {
         delete[] buffers[i].ids;
         delete[] buffers[i].dis;
     }
@@ -140,7 +141,7 @@ void RangeSearchPartialResult::finalize() {
 
 /// called by range_search before do_allocation
 void RangeSearchPartialResult::set_lims() {
-    for (int i = 0; i < queries.size(); i++) {
+    for (size_t i = 0; i < queries.size(); i++) {
         RangeQueryResult& qres = queries[i];
         res->lims[qres.qno] = qres.nres;
     }
@@ -149,7 +150,7 @@ void RangeSearchPartialResult::set_lims() {
 /// called by range_search after do_allocation
 void RangeSearchPartialResult::copy_result(bool incremental) {
     size_t ofs = 0;
-    for (int i = 0; i < queries.size(); i++) {
+    for (size_t i = 0; i < queries.size(); i++) {
         RangeQueryResult& qres = queries[i];
 
         copy_range(

data/vendor/faiss/faiss/impl/AuxIndexStructures.h

@@ -18,6 +18,8 @@
 #include <mutex>
 #include <vector>
 
+#include <faiss/impl/InvertedListScannerStats.h>
+
 #include <faiss/MetricType.h>
 #include <faiss/impl/platform_macros.h>
 
@@ -92,6 +94,7 @@ struct RangeQueryResult {
     idx_t qno;   //< id of the query
     size_t nres; //< nb of results for this query
     RangeSearchPartialResult* pres;
+    InvertedListScannerStats stats;
 
     /// called by search function to report a new result
     void add(float dis, idx_t id);