faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/Index.h

@@ -17,7 +17,7 @@
 
 #define FAISS_VERSION_MAJOR 1
 #define FAISS_VERSION_MINOR 14
-#define FAISS_VERSION_PATCH 1
+#define FAISS_VERSION_PATCH 2
 
 // Macro to combine the version components into a single string
 #ifndef FAISS_STRINGIFY
@@ -114,8 +114,8 @@ struct Index {
     MetricType metric_type;
     float metric_arg; ///< argument of the metric type
 
-    explicit Index(idx_t d = 0, MetricType metric = METRIC_L2)
-            : d(d),
+    explicit Index(idx_t d_in = 0, MetricType metric = METRIC_L2)
+            : d(static_cast<int>(d_in)),
               ntotal(0),
               verbose(false),
               is_trained(true),
@@ -131,7 +131,7 @@ struct Index {
      */
     virtual void train(idx_t n, const float* x);
 
-    /** Perfrom training on a representative set of vectors and a representative
+    /** Perform training on a representative set of vectors and a representative
      * set of queries
      *
      * @param n         nb of training vectors
@@ -139,7 +139,7 @@ struct Index {
      * @param n_train_q nb of training queries
      * @param xq_train  training queries, size n_train_q * d
      */
-    virtual void train(
+    virtual void train_with_queries(
             idx_t n,
             const float* x,
             idx_t n_train_q,

data/vendor/faiss/faiss/Index2Layer.cpp

@@ -13,10 +13,6 @@
 #include <cstdint>
 #include <cstdio>
 
-#ifdef __SSE3__
-#include <immintrin.h>
-#endif
-
 #include <algorithm>
 
 #include <faiss/IndexIVFPQ.h>
@@ -138,12 +134,13 @@ struct Distance2Level : DistanceComputer {
     size_t d;
     const Index2Layer& storage;
     std::vector<float> buf;
-    const float* q;
+    const float* q = nullptr;
 
-    const float *pq_l1_tab, *pq_l2_tab;
+    const float* pq_l1_tab = nullptr;
+    const float* pq_l2_tab = nullptr;
 
-    explicit Distance2Level(const Index2Layer& storage) : storage(storage) {
-        d = storage.d;
+    explicit Distance2Level(const Index2Layer& storage_) : storage(storage_) {
+        d = storage_.d;
         FAISS_ASSERT(storage.pq.dsub == 4);
         pq_l2_tab = storage.pq.centroids.data();
         buf.resize(2 * d);
@@ -162,46 +159,40 @@ struct Distance2Level : DistanceComputer {
 
 // well optimized for xNN+PQNN
 struct DistanceXPQ4 : Distance2Level {
-    int M, k;
+    int M = 0;
+    int k = 0;
 
-    explicit DistanceXPQ4(const Index2Layer& storage)
-            : Distance2Level(storage) {
+    explicit DistanceXPQ4(const Index2Layer& storage_)
+            : Distance2Level(storage_) {
         const IndexFlat* quantizer =
                 dynamic_cast<IndexFlat*>(storage.q1.quantizer);
 
         FAISS_ASSERT(quantizer);
-        M = storage.pq.M;
+        M = static_cast<int>(storage.pq.M);
         pq_l1_tab = quantizer->get_xb();
     }
 
     float operator()(idx_t i) override {
-#ifdef __SSE3__
         const uint8_t* code = storage.codes.data() + i * storage.code_size;
         idx_t key = 0;
         memcpy(&key, code, storage.code_size_1);
         code += storage.code_size_1;
 
-        // walking pointers
         const float* qa = q;
-        const __m128* l1_t = (const __m128*)(pq_l1_tab + d * key);
-        const __m128* pq_l2_t = (const __m128*)pq_l2_tab;
-        __m128 accu = _mm_setzero_ps();
+        const float* l1 = pq_l1_tab + d * key;
+        const float* l2 = pq_l2_tab;
+        float accu = 0;
 
         for (int m = 0; m < M; m++) {
-            __m128 qi = _mm_loadu_ps(qa);
-            __m128 recons = _mm_add_ps(l1_t[m], pq_l2_t[*code++]);
-            __m128 diff = _mm_sub_ps(qi, recons);
-            accu = _mm_add_ps(accu, _mm_mul_ps(diff, diff));
-            pq_l2_t += 256;
+            for (int j = 0; j < 4; j++) {
+                float diff = qa[j] - (l1[m * 4 + j] + l2[*code * 4 + j]);
+                accu += diff * diff;
+            }
+            code++;
+            l2 += 256 * 4;
             qa += 4;
         }
-
-        accu = _mm_hadd_ps(accu, accu);
-        accu = _mm_hadd_ps(accu, accu);
-        return _mm_cvtss_f32(accu);
-#else
-        FAISS_THROW_MSG("not implemented for non-x64 platforms");
-#endif
+        return accu;
     }
 };
 
@@ -209,15 +200,15 @@ struct DistanceXPQ4 : Distance2Level {
 struct Distance2xXPQ4 : Distance2Level {
     int M_2, mi_nbits;
 
-    explicit Distance2xXPQ4(const Index2Layer& storage)
-            : Distance2Level(storage) {
+    explicit Distance2xXPQ4(const Index2Layer& storage_)
+            : Distance2Level(storage_) {
         const MultiIndexQuantizer* mi =
                 dynamic_cast<MultiIndexQuantizer*>(storage.q1.quantizer);
 
         FAISS_ASSERT(mi);
         FAISS_ASSERT(storage.pq.M % 2 == 0);
-        M_2 = storage.pq.M / 2;
-        mi_nbits = mi->pq.nbits;
+        M_2 = static_cast<int>(storage.pq.M / 2);
+        mi_nbits = static_cast<int>(mi->pq.nbits);
         pq_l1_tab = mi->pq.centroids.data();
     }
 
@@ -226,42 +217,36 @@ struct Distance2xXPQ4 : Distance2Level {
         int64_t key01 = 0;
         memcpy(&key01, code, storage.code_size_1);
         code += storage.code_size_1;
-#ifdef __SSE3__
 
-        // walking pointers
         const float* qa = q;
-        const __m128* pq_l1_t = (const __m128*)pq_l1_tab;
-        const __m128* pq_l2_t = (const __m128*)pq_l2_tab;
-        __m128 accu = _mm_setzero_ps();
+        const float* l1 = pq_l1_tab;
+        const float* l2 = pq_l2_tab;
+        float accu = 0;
 
         for (int mi_m = 0; mi_m < 2; mi_m++) {
             int64_t l1_idx = key01 & (((int64_t)1 << mi_nbits) - 1);
-            const __m128* pq_l1 = pq_l1_t + M_2 * l1_idx;
+            const float* l1_sub = l1 + M_2 * l1_idx * 4;
 
             for (int m = 0; m < M_2; m++) {
-                __m128 qi = _mm_loadu_ps(qa);
-                __m128 recons = _mm_add_ps(pq_l1[m], pq_l2_t[*code++]);
-                __m128 diff = _mm_sub_ps(qi, recons);
-                accu = _mm_add_ps(accu, _mm_mul_ps(diff, diff));
-                pq_l2_t += 256;
+                for (int j = 0; j < 4; j++) {
+                    float diff =
+                            qa[j] - (l1_sub[m * 4 + j] + l2[*code * 4 + j]);
+                    accu += diff * diff;
+                }
+                code++;
+                l2 += 256 * 4;
                 qa += 4;
             }
-            pq_l1_t += M_2 << mi_nbits;
+            l1 += (M_2 << mi_nbits) * 4;
             key01 >>= mi_nbits;
         }
-        accu = _mm_hadd_ps(accu, accu);
-        accu = _mm_hadd_ps(accu, accu);
-        return _mm_cvtss_f32(accu);
-#else
-        FAISS_THROW_MSG("not implemented for non-x64 platforms");
-#endif
+        return accu;
     }
 };
 
 } // namespace
 
 DistanceComputer* Index2Layer::get_distance_computer() const {
-#ifdef __SSE3__
     const MultiIndexQuantizer* mi =
             dynamic_cast<MultiIndexQuantizer*>(q1.quantizer);
 
@@ -274,7 +259,6 @@ DistanceComputer* Index2Layer::get_distance_computer() const {
     if (fl && pq.dsub == 4) {
         return new DistanceXPQ4(*this);
     }
-#endif
 
     return Index::get_distance_computer();
 }

data/vendor/faiss/faiss/IndexAdditiveQuantizer.cpp

@@ -13,6 +13,7 @@
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/ResidualQuantizer.h>
 #include <faiss/impl/ResultHandler.h>
+#include <faiss/utils/distances_dispatch.h>
 #include <faiss/utils/extra_distances.h>
 
 namespace faiss {
@@ -22,10 +23,10 @@ namespace faiss {
  **************************************************************************************/
 
 IndexAdditiveQuantizer::IndexAdditiveQuantizer(
-        idx_t d,
-        AdditiveQuantizer* aq,
+        idx_t d_,
+        AdditiveQuantizer* aq_,
         MetricType metric)
-        : IndexFlatCodes(aq->code_size, d, metric), aq(aq) {
+        : IndexFlatCodes(aq_->code_size, d_, metric), aq(aq_) {
     FAISS_THROW_IF_NOT(metric == METRIC_INNER_PRODUCT || metric == METRIC_L2);
 }
 
@@ -44,14 +45,14 @@ struct AQDistanceComputerDecompress : FlatCodesDistanceComputer {
 
     AQDistanceComputerDecompress(
             const IndexAdditiveQuantizer& iaq,
-            VectorDistance vd)
+            VectorDistance vd_)
             : FlatCodesDistanceComputer(iaq.codes.data(), iaq.code_size),
               tmp(iaq.d * 2),
               aq(*iaq.aq),
-              vd(vd),
+              vd(vd_),
               d(iaq.d) {}
 
-    const float* q;
+    const float* q = nullptr;
     void set_query(const float* x) final {
         q = x;
     }
@@ -82,7 +83,7 @@ struct AQDistanceComputerLUT : FlatCodesDistanceComputer {
               aq(*iaq.aq),
               d(iaq.d) {}
 
-    float bias;
+    float bias = 0.0f;
     void set_query(const float* x) final {
         q = x;
         // this is quite sub-optimal for multiple queries
@@ -127,7 +128,7 @@ void search_with_decompress(
             typename BlockResultHandler::SingleResultHandler;
 
 #pragma omp parallel for if (res.nq > 100)
-    for (int64_t q = 0; q < res.nq; q++) {
+    for (int64_t q = 0; q < static_cast<int64_t>(res.nq); q++) {
         SingleResultHandler resi(res);
         resi.begin(q);
         std::vector<float> tmp(ir.d);
@@ -163,7 +164,7 @@ void search_with_LUT(
     aq.compute_LUT(nq, xq, LUT.get());
 
 #pragma omp parallel for if (nq > 100)
-    for (int64_t q = 0; q < nq; q++) {
+    for (int64_t q = 0; q < static_cast<int64_t>(nq); q++) {
         SingleResultHandler resi(res);
         resi.begin(q);
         std::vector<float> tmp(aq.d);
@@ -298,23 +299,23 @@ void IndexAdditiveQuantizer::sa_decode(idx_t n, const uint8_t* bytes, float* x)
  **************************************************************************************/
 
 IndexResidualQuantizer::IndexResidualQuantizer(
-        int d,        ///< dimensionality of the input vectors
+        int d_,       ///< dimensionality of the input vectors
         size_t M,     ///< number of subquantizers
         size_t nbits, ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type)
         : IndexResidualQuantizer(
-                  d,
+                  d_,
                   std::vector<size_t>(M, nbits),
                   metric,
                   search_type) {}
 
 IndexResidualQuantizer::IndexResidualQuantizer(
-        int d,
+        int d_,
         const std::vector<size_t>& nbits,
         MetricType metric,
         Search_type_t search_type)
-        : IndexAdditiveQuantizer(d, &rq, metric), rq(d, nbits, search_type) {
+        : IndexAdditiveQuantizer(d_, &rq, metric), rq(d_, nbits, search_type) {
     code_size = rq.code_size;
     is_trained = false;
 }
@@ -332,13 +333,13 @@ void IndexResidualQuantizer::train(idx_t n, const float* x) {
  **************************************************************************************/
 
 IndexLocalSearchQuantizer::IndexLocalSearchQuantizer(
-        int d,
+        int d_,
         size_t M,     ///< number of subquantizers
         size_t nbits, ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type)
-        : IndexAdditiveQuantizer(d, &lsq, metric),
-          lsq(d, M, nbits, search_type) {
+        : IndexAdditiveQuantizer(d_, &lsq, metric),
+          lsq(d_, M, nbits, search_type) {
     code_size = lsq.code_size;
     is_trained = false;
 }
@@ -356,14 +357,14 @@ void IndexLocalSearchQuantizer::train(idx_t n, const float* x) {
  **************************************************************************************/
 
 IndexProductResidualQuantizer::IndexProductResidualQuantizer(
-        int d,          ///< dimensionality of the input vectors
+        int d_,         ///< dimensionality of the input vectors
         size_t nsplits, ///< number of residual quantizers
         size_t Msub,    ///< number of subquantizers per RQ
         size_t nbits,   ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type)
-        : IndexAdditiveQuantizer(d, &prq, metric),
-          prq(d, nsplits, Msub, nbits, search_type) {
+        : IndexAdditiveQuantizer(d_, &prq, metric),
+          prq(d_, nsplits, Msub, nbits, search_type) {
     code_size = prq.code_size;
     is_trained = false;
 }
@@ -381,14 +382,14 @@ void IndexProductResidualQuantizer::train(idx_t n, const float* x) {
  **************************************************************************************/
 
 IndexProductLocalSearchQuantizer::IndexProductLocalSearchQuantizer(
-        int d,          ///< dimensionality of the input vectors
+        int d_,         ///< dimensionality of the input vectors
         size_t nsplits, ///< number of local search quantizers
         size_t Msub,    ///< number of subquantizers per LSQ
         size_t nbits,   ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type)
-        : IndexAdditiveQuantizer(d, &plsq, metric),
-          plsq(d, nsplits, Msub, nbits, search_type) {
+        : IndexAdditiveQuantizer(d_, &plsq, metric),
+          plsq(d_, nsplits, Msub, nbits, search_type) {
     code_size = plsq.code_size;
     is_trained = false;
 }
@@ -406,10 +407,10 @@ void IndexProductLocalSearchQuantizer::train(idx_t n, const float* x) {
  **************************************************************************************/
 
 AdditiveCoarseQuantizer::AdditiveCoarseQuantizer(
-        idx_t d,
-        AdditiveQuantizer* aq,
+        idx_t d_,
+        AdditiveQuantizer* aq_,
         MetricType metric)
-        : Index(d, metric), aq(aq) {}
+        : Index(d_, metric), aq(aq_) {}
 
 void AdditiveCoarseQuantizer::add(idx_t, const float*) {
     FAISS_THROW_MSG("not applicable");
@@ -463,7 +464,8 @@ void AdditiveCoarseQuantizer::search(
     if (metric_type == METRIC_INNER_PRODUCT) {
         aq->knn_centroids_inner_product(n, x, k, distances, labels);
     } else if (metric_type == METRIC_L2) {
-        FAISS_THROW_IF_NOT(centroid_norms.size() == ntotal);
+        FAISS_THROW_IF_NOT(
+                centroid_norms.size() == static_cast<size_t>(ntotal));
         aq->knn_centroids_L2(n, x, k, distances, labels, centroid_norms.data());
     }
 }
@@ -473,20 +475,20 @@ void AdditiveCoarseQuantizer::search(
  **************************************************************************************/
 
 ResidualCoarseQuantizer::ResidualCoarseQuantizer(
-        int d, ///< dimensionality of the input vectors
+        int d_, ///< dimensionality of the input vectors
         const std::vector<size_t>& nbits,
         MetricType metric)
-        : AdditiveCoarseQuantizer(d, &rq, metric), rq(d, nbits) {
+        : AdditiveCoarseQuantizer(d_, &rq, metric), rq(d_, nbits) {
     FAISS_THROW_IF_NOT(rq.tot_bits <= 63);
     is_trained = false;
 }
 
 ResidualCoarseQuantizer::ResidualCoarseQuantizer(
-        int d,
+        int d_,
         size_t M,     ///< number of subquantizers
         size_t nbits, ///< number of bit per subvector index
         MetricType metric)
-        : ResidualCoarseQuantizer(d, std::vector<size_t>(M, nbits), metric) {}
+        : ResidualCoarseQuantizer(d_, std::vector<size_t>(M, nbits), metric) {}
 
 ResidualCoarseQuantizer::ResidualCoarseQuantizer()
         : ResidualCoarseQuantizer(0, 0, 0) {}
@@ -504,7 +506,8 @@ void ResidualCoarseQuantizer::set_beam_factor(float new_beam_factor) {
         // Does not use the cross_products
         rq.codebook_cross_products.resize(0);
         // but the centroid norms are necessary!
-        if (metric_type == METRIC_L2 && ntotal != centroid_norms.size()) {
+        if (metric_type == METRIC_L2 &&
+            static_cast<size_t>(ntotal) != centroid_norms.size()) {
             if (verbose) {
                 printf("AdditiveCoarseQuantizer::train: computing centroid norms for %zd centroids\n",
                        size_t(ntotal));
@@ -540,7 +543,7 @@ void ResidualCoarseQuantizer::search(
 
     int beam_size = int(k * actual_beam_factor);
     if (beam_size > ntotal) {
-        beam_size = ntotal;
+        beam_size = static_cast<int>(ntotal);
     }
     size_t memory_per_point = rq.memory_per_point(beam_size);
 
@@ -573,8 +576,17 @@ void ResidualCoarseQuantizer::search(
         return;
     }
 
-    std::vector<int32_t> codes(beam_size * rq.M * n);
-    std::vector<float> beam_distances(n * beam_size);
+    size_t codes_size = mul_no_overflow(
+            mul_no_overflow(
+                    static_cast<size_t>(beam_size), rq.M, "beam_size * M"),
+            static_cast<size_t>(n),
+            "beam_size * M * n");
+    size_t beam_dist_size = mul_no_overflow(
+            static_cast<size_t>(n),
+            static_cast<size_t>(beam_size),
+            "n * beam_size");
+    std::vector<int32_t> codes(codes_size);
+    std::vector<float> beam_distances(beam_dist_size);
 
     rq.refine_beam(
             n, 1, x, beam_size, codes.data(), nullptr, beam_distances.data());
@@ -590,7 +602,7 @@ void ResidualCoarseQuantizer::search(
         for (idx_t j = 0; j < k; j++) {
             idx_t l = 0;
             int shift = 0;
-            for (int m = 0; m < rq.M; m++) {
+            for (size_t m = 0; m < rq.M; m++) {
                 l |= (*codes_i++) << shift;
                 shift += rq.nbits[m];
             }
@@ -613,11 +625,11 @@ void ResidualCoarseQuantizer::initialize_from(
  **************************************************************************************/
 
 LocalSearchCoarseQuantizer::LocalSearchCoarseQuantizer(
-        int d,        ///< dimensionality of the input vectors
+        int d_,       ///< dimensionality of the input vectors
         size_t M,     ///< number of subquantizers
         size_t nbits, ///< number of bit per subvector index
         MetricType metric)
-        : AdditiveCoarseQuantizer(d, &lsq, metric), lsq(d, M, nbits) {
+        : AdditiveCoarseQuantizer(d_, &lsq, metric), lsq(d_, M, nbits) {
     FAISS_THROW_IF_NOT(lsq.tot_bits <= 63);
     is_trained = false;
 }

data/vendor/faiss/faiss/IndexAdditiveQuantizerFastScan.cpp

@@ -11,11 +11,10 @@
 #include <memory>
 
 #include <faiss/impl/FaissAssert.h>
-#include <faiss/impl/FastScanDistancePostProcessing.h>
 #include <faiss/impl/LocalSearchQuantizer.h>
-#include <faiss/impl/LookupTableScaler.h>
 #include <faiss/impl/ResidualQuantizer.h>
-#include <faiss/impl/pq4_fast_scan.h>
+#include <faiss/impl/fast_scan/FastScanDistancePostProcessing.h>
+#include <faiss/impl/fast_scan/fast_scan.h>
 #include <faiss/utils/quantize_lut.h>
 #include <faiss/utils/utils.h>
 
@@ -26,16 +25,16 @@ inline size_t roundup(size_t a, size_t b) {
 }
 
 IndexAdditiveQuantizerFastScan::IndexAdditiveQuantizerFastScan(
-        AdditiveQuantizer* aq,
+        AdditiveQuantizer* aq_,
         MetricType metric,
-        int bbs) {
-    init(aq, metric, bbs);
+        int bbs_) {
+    init(aq_, metric, bbs_);
 }
 
 void IndexAdditiveQuantizerFastScan::init(
         AdditiveQuantizer* aq_init,
         MetricType metric,
-        int bbs) {
+        int bbs_) {
     FAISS_THROW_IF_NOT(aq_init != nullptr);
     FAISS_THROW_IF_NOT(!aq_init->nbits.empty());
     FAISS_THROW_IF_NOT(aq_init->nbits[0] == 4);
@@ -57,7 +56,7 @@ void IndexAdditiveQuantizerFastScan::init(
     } else {
         M = aq_init->M;
     }
-    init_fastscan(aq_init->d, M, 4, metric, bbs);
+    init_fastscan(static_cast<int>(aq_init->d), M, 4, metric, bbs_);
 
     max_train_points = 1024 * ksub * M;
 }
@@ -70,8 +69,8 @@ IndexAdditiveQuantizerFastScan::IndexAdditiveQuantizerFastScan()
 
 IndexAdditiveQuantizerFastScan::IndexAdditiveQuantizerFastScan(
         const IndexAdditiveQuantizer& orig,
-        int bbs) {
-    init(orig.aq, orig.metric_type, bbs);
+        int bbs_) {
+    init(orig.aq, orig.metric_type, bbs_);
 
     ntotal = orig.ntotal;
     is_trained = orig.is_trained;
@@ -202,9 +201,8 @@ void IndexAdditiveQuantizerFastScan::search(
         return;
     }
 
-    NormTableScaler scaler(norm_scale);
     FastScanDistancePostProcessing context;
-    context.norm_scaler = &scaler;
+    context.pq2x4_scale = norm_scale;
     if (metric_type == METRIC_L2) {
         search_dispatch_implem<true>(n, x, k, distances, labels, context);
     } else {
@@ -219,19 +217,23 @@ void IndexAdditiveQuantizerFastScan::sa_decode(
     aq->decode(bytes, x, n);
 }
 
+size_t IndexAdditiveQuantizerFastScan::fast_scan_code_size() const {
+    return M2 / 2;
+}
+
 /**************************************************************************************
  * IndexResidualQuantizerFastScan
  **************************************************************************************/
 
 IndexResidualQuantizerFastScan::IndexResidualQuantizerFastScan(
-        int d,        ///< dimensionality of the input vectors
-        size_t M,     ///< number of subquantizers
-        size_t nbits, ///< number of bit per subvector index
+        int d_,        ///< dimensionality of the input vectors
+        size_t M_,     ///< number of subquantizers
+        size_t nbits_, ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type,
-        int bbs)
-        : rq(d, M, nbits, search_type) {
-    init(&rq, metric, bbs);
+        int bbs_)
+        : rq(d_, M_, nbits_, search_type) {
+    init(&rq, metric, bbs_);
 }
 
 IndexResidualQuantizerFastScan::IndexResidualQuantizerFastScan() {
@@ -243,14 +245,14 @@ IndexResidualQuantizerFastScan::IndexResidualQuantizerFastScan() {
  **************************************************************************************/
 
 IndexLocalSearchQuantizerFastScan::IndexLocalSearchQuantizerFastScan(
-        int d,
-        size_t M,     ///< number of subquantizers
-        size_t nbits, ///< number of bit per subvector index
+        int d_,
+        size_t M_,     ///< number of subquantizers
+        size_t nbits_, ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type,
-        int bbs)
-        : lsq(d, M, nbits, search_type) {
-    init(&lsq, metric, bbs);
+        int bbs_)
+        : lsq(d_, M_, nbits_, search_type) {
+    init(&lsq, metric, bbs_);
 }
 
 IndexLocalSearchQuantizerFastScan::IndexLocalSearchQuantizerFastScan() {
@@ -262,15 +264,15 @@ IndexLocalSearchQuantizerFastScan::IndexLocalSearchQuantizerFastScan() {
  **************************************************************************************/
 
 IndexProductResidualQuantizerFastScan::IndexProductResidualQuantizerFastScan(
-        int d,          ///< dimensionality of the input vectors
+        int d_,         ///< dimensionality of the input vectors
         size_t nsplits, ///< number of residual quantizers
         size_t Msub,    ///< number of subquantizers per RQ
-        size_t nbits,   ///< number of bit per subvector index
+        size_t nbits_,  ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type,
-        int bbs)
-        : prq(d, nsplits, Msub, nbits, search_type) {
-    init(&prq, metric, bbs);
+        int bbs_)
+        : prq(d_, nsplits, Msub, nbits_, search_type) {
+    init(&prq, metric, bbs_);
 }
 
 IndexProductResidualQuantizerFastScan::IndexProductResidualQuantizerFastScan() {
@@ -283,15 +285,15 @@ IndexProductResidualQuantizerFastScan::IndexProductResidualQuantizerFastScan() {
 
 IndexProductLocalSearchQuantizerFastScan::
         IndexProductLocalSearchQuantizerFastScan(
-                int d,          ///< dimensionality of the input vectors
+                int d_,         ///< dimensionality of the input vectors
                 size_t nsplits, ///< number of local search quantizers
                 size_t Msub,    ///< number of subquantizers per LSQ
-                size_t nbits,   ///< number of bit per subvector index
+                size_t nbits_,  ///< number of bit per subvector index
                 MetricType metric,
                 Search_type_t search_type,
-                int bbs)
-        : plsq(d, nsplits, Msub, nbits, search_type) {
-    init(&plsq, metric, bbs);
+                int bbs_)
+        : plsq(d_, nsplits, Msub, nbits_, search_type) {
+    init(&plsq, metric, bbs_);
 }
 
 IndexProductLocalSearchQuantizerFastScan::

data/vendor/faiss/faiss/IndexAdditiveQuantizerFastScan.h

@@ -28,7 +28,7 @@ namespace faiss {
  */
 
 struct IndexAdditiveQuantizerFastScan : IndexFastScan {
-    AdditiveQuantizer* aq;
+    AdditiveQuantizer* aq = nullptr;
     using Search_type_t = AdditiveQuantizer::Search_type_t;
 
     bool rescale_norm = true;
@@ -86,6 +86,9 @@ struct IndexAdditiveQuantizerFastScan : IndexFastScan {
      * @param x       output vectors, size n * d
      */
     void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
+
+    /// Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
+    size_t fast_scan_code_size() const override;
 };
 
 /** Index based on a residual quantizer. Stored vectors are

data/vendor/faiss/faiss/IndexBinary.cpp

@@ -16,9 +16,11 @@
 
 namespace faiss {
 
-IndexBinary::IndexBinary(idx_t d, MetricType metric)
-        : d(d), code_size(d / 8), metric_type(metric) {
-    FAISS_THROW_IF_NOT(d % 8 == 0);
+IndexBinary::IndexBinary(idx_t d_, MetricType metric)
+        : d(static_cast<int>(d_)),
+          code_size(static_cast<int>(d_ / 8)),
+          metric_type(metric) {
+    FAISS_THROW_IF_NOT(d_ % 8 == 0);
 }
 
 IndexBinary::~IndexBinary() = default;