faiss 0.6.0 → 0.6.2

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/gpu_metal/impl/MetalIVFFlat.h

@@ -0,0 +1,193 @@
+// @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.
+ *
+ * Metal IVF Flat implementation: GPU-resident IVF list storage and helpers.
+ * Mirrors the roles of faiss/gpu/impl/IVFFlat.cuh (storage side only).
+ */
+
+#pragma once
+
+#import <Metal/Metal.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include <faiss/Index.h>
+#include <faiss/MetricType.h>
+#include <faiss/gpu/GpuIndicesOptions.h>
+#include <faiss/gpu_metal/MetalResources.h>
+
+namespace faiss {
+namespace gpu_metal {
+
+/// GPU-resident IVF list storage for flat (float32) codes.
+/// Layout: all lists are stored contiguously in a single codes/ids buffer;
+/// lists are described by (listOffset[list], listLength[list]).
+class MetalIVFFlatImpl {
+   public:
+    struct AppendDebugStats {
+        size_t relayoutEvents = 0;
+        size_t movedLists = 0;
+        size_t movedVectors = 0;
+        size_t reusedSegmentAllocs = 0;
+        size_t tailSegmentAllocs = 0;
+        size_t reusedCapacityVecs = 0;
+        size_t tailCapacityVecs = 0;
+        size_t tailShrinkEvents = 0;
+        size_t tailShrunkVecs = 0;
+    };
+
+    MetalIVFFlatImpl(
+            std::shared_ptr<MetalResources> resources,
+            int dim,
+            idx_t nlist,
+            faiss::MetricType metric,
+            float metricArg,
+            faiss::gpu::IndicesOptions indicesOptions,
+            bool interleavedLayout);
+
+    ~MetalIVFFlatImpl();
+
+    /// Reset all IVF lists and free GPU storage.
+    void reset();
+
+    /// Reserve host/GPU storage for at least totalVecs vectors.
+    void reserveMemory(idx_t totalVecs);
+
+    /// Append a batch of vectors to IVF lists.
+    /// - x: host pointer, size n * dim
+    /// - list_nos: host pointer, size n; -1 entries are skipped
+    /// - xids: host pointer, size n (may be null to use internal ids)
+    void appendVectors(
+            idx_t n,
+            const float* x,
+            const idx_t* list_nos,
+            const idx_t* xids);
+
+    /// Accessors for future GPU search path.
+    int dim() const {
+        return dim_;
+    }
+    idx_t nlist() const {
+        return nlist_;
+    }
+    faiss::MetricType metricType() const {
+        return metric_type_;
+    }
+    float metricArg() const {
+        return metric_arg_;
+    }
+
+    const std::vector<size_t>& listLength() const {
+        return listLength_;
+    }
+    const std::vector<size_t>& listOffset() const {
+        return listOffset_;
+    }
+
+    id<MTLBuffer> codesBuffer() const {
+        return codesBuffer_;
+    }
+    id<MTLBuffer> idsBuffer() const {
+        return idsBuffer_;
+    }
+    /// Pre-built GPU buffer of (nlist) uint32_t offsets (updated on every add).
+    id<MTLBuffer> listOffsetGpuBuffer() const {
+        return listOffsetBuf_;
+    }
+    /// Pre-built GPU buffer of (nlist) uint32_t lengths (updated on every add).
+    id<MTLBuffer> listLengthGpuBuffer() const {
+        return listLengthBuf_;
+    }
+
+    size_t totalVecs() const {
+        return totalVecs_;
+    }
+
+    /// Interleaved codes buffer (blocks of 32 vectors, dims interleaved).
+    id<MTLBuffer> interleavedCodesBuffer() const {
+        return interleavedCodesBuf_;
+    }
+    /// Per-list float offsets into the interleaved codes buffer.
+    id<MTLBuffer> interleavedCodesOffsetBuffer() const {
+        return interleavedCodesOffsetBuf_;
+    }
+    bool interleavedLayout() const {
+        return interleavedLayout_;
+    }
+    /// Rebuild interleaved buffers from host storage if they are stale.
+    void ensureInterleavedLayoutUpToDate();
+    const AppendDebugStats& appendDebugStats() const {
+        return appendStats_;
+    }
+    void resetAppendDebugStats() {
+        appendStats_ = AppendDebugStats{};
+    }
+
+   private:
+    struct FreeSegment {
+        size_t offset = 0;
+        size_t length = 0;
+    };
+
+    bool ensureCapacityForAppend_(
+            const std::vector<size_t>& addPerList,
+            std::vector<uint8_t>* movedLists);
+    void uploadToGpu_(
+            const std::vector<size_t>& oldLength,
+            const std::vector<size_t>& addPerList,
+            const std::vector<uint8_t>& movedLists,
+            bool forceFullUpload);
+    void rebuildInterleavedBuffers_();
+    size_t allocSegment_(size_t length);
+    void freeSegment_(
+            size_t offset,
+            size_t length,
+            bool allowTailShrink = true);
+    void coalesceFreeSegments_();
+    void tryShrinkTail_();
+
+    std::shared_ptr<MetalResources> resources_;
+
+    int dim_;
+    idx_t nlist_;
+    faiss::MetricType metric_type_;
+    float metric_arg_;
+    faiss::gpu::IndicesOptions indicesOptions_;
+    bool interleavedLayout_;
+
+    // Per-list metadata
+    std::vector<size_t> listLength_;
+    std::vector<size_t> listOffset_;
+    std::vector<size_t> listCapacity_;
+
+    // Host copies of IVF data (flat layout)
+    std::vector<float> hostCodes_; // size = totalVecs_ * dim_
+    std::vector<idx_t> hostIds_;   // size = totalVecs_
+    std::vector<FreeSegment> freeSegments_;
+    AppendDebugStats appendStats_;
+    size_t totalVecs_;
+    size_t totalCapacityVecs_;
+
+    // GPU storage
+    id<MTLBuffer> codesBuffer_;
+    id<MTLBuffer> idsBuffer_;
+    id<MTLBuffer> listOffsetBuf_; // (nlist) uint32_t, list element offsets
+    id<MTLBuffer> listLengthBuf_; // (nlist) uint32_t, list sizes
+
+    // Interleaved codes layout (blocks of 32 vectors, dims interleaved)
+    id<MTLBuffer> interleavedCodesBuf_;
+    id<MTLBuffer> interleavedCodesOffsetBuf_; // (nlist) uint32_t, float offsets
+    bool interleavedDirty_ = true;
+
+    static constexpr int kInterleavedGroupSize = 32;
+};
+
+} // 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(