faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/IndexFastScan.cpp

@@ -13,37 +13,34 @@
 
 #include <faiss/impl/CodePacker.h>
 #include <faiss/impl/FaissAssert.h>
-#include <faiss/impl/FastScanDistancePostProcessing.h>
 #include <faiss/impl/IDSelector.h>
-#include <faiss/impl/LookupTableScaler.h>
 #include <faiss/impl/RaBitQUtils.h>
-#include <faiss/impl/pq4_fast_scan.h>
-#include <faiss/impl/simd_result_handlers.h>
+#include <faiss/impl/fast_scan/FastScanDistancePostProcessing.h>
+#include <faiss/impl/fast_scan/fast_scan.h>
+#include <faiss/impl/fast_scan/simd_result_handlers.h>
 #include <faiss/utils/hamming.h>
 #include <faiss/utils/quantize_lut.h>
 #include <faiss/utils/utils.h>
 
 namespace faiss {
 
-using namespace simd_result_handlers;
-
 inline size_t roundup(size_t a, size_t b) {
     return (a + b - 1) / b * b;
 }
 
 void IndexFastScan::init_fastscan(
-        int d,
+        int d_,
         size_t M_init,
         size_t nbits_init,
         MetricType metric,
-        int bbs) {
+        int bbs_) {
     FAISS_THROW_IF_NOT(nbits_init == 4);
-    FAISS_THROW_IF_NOT(bbs % 32 == 0);
-    this->d = d;
+    FAISS_THROW_IF_NOT(bbs_ % 32 == 0);
+    this->d = d_;
     this->M = M_init;
     this->nbits = nbits_init;
     this->metric_type = metric;
-    this->bbs = bbs;
+    this->bbs = bbs_;
     ksub = (1 << nbits_init);
 
     code_size = (M_init * nbits_init + 7) / 8;
@@ -152,7 +149,7 @@ void IndexFastScan::check_compatible_for_merge(const Index& otherIndex) const {
             "can only merge indexes of the same type");
 }
 
-void IndexFastScan::merge_from(Index& otherIndex, idx_t add_id) {
+void IndexFastScan::merge_from(Index& otherIndex, idx_t /*add_id*/) {
     check_compatible_for_merge(otherIndex);
     IndexFastScan* other = static_cast<IndexFastScan*>(&otherIndex);
     ntotal2 = roundup(ntotal + other->ntotal, bbs);
@@ -161,7 +158,7 @@ void IndexFastScan::merge_from(Index& otherIndex, idx_t add_id) {
     std::unique_ptr<CodePacker> packer(get_CodePacker());
     std::unique_ptr<CodePacker> other_packer(other->get_CodePacker());
 
-    for (int i = 0; i < other->ntotal; i++) {
+    for (idx_t i = 0; i < other->ntotal; i++) {
         other_packer->unpack_1(other->codes.data(), i, buffer.data());
         packer->pack_1(buffer.data(), ntotal + i, codes.data());
     }
@@ -187,18 +184,18 @@ void estimators_from_tables_generic(
         BitstringReader bsr(codes + j * index.code_size, index.code_size);
         accu_t dis = 0;
         const dis_t* dt = dis_table;
-        int nscale = context.norm_scaler ? context.norm_scaler->nscale : 0;
+        int nscale = context.pq2x4_scale ? 2 : 0;
 
         for (size_t m = 0; m < index.M - nscale; m++) {
-            uint64_t c = bsr.read(index.nbits);
+            uint64_t c = bsr.read(static_cast<int>(index.nbits));
             dis += dt[c];
             dt += index.ksub;
         }
 
-        if (nscale && context.norm_scaler) {
+        if (nscale) {
             for (size_t m = 0; m < nscale; m++) {
-                uint64_t c = bsr.read(index.nbits);
-                dis += context.norm_scaler->scale_one(dt[c]);
+                uint64_t c = bsr.read(static_cast<int>(index.nbits));
+                dis += dt[c] * context.pq2x4_scale;
                 dt += index.ksub;
             }
         }
@@ -212,43 +209,18 @@ void estimators_from_tables_generic(
 
 } // anonymous namespace
 
-// Default implementation of make_knn_handler with centralized fallback logic
-SIMDResultHandlerToFloat* IndexFastScan::make_knn_handler(
+std::unique_ptr<FastScanCodeScanner> IndexFastScan::make_knn_scanner(
         bool is_max,
-        int impl,
         idx_t n,
         idx_t k,
-        size_t ntotal,
+        size_t ntotal_,
         float* distances,
         idx_t* labels,
         const IDSelector* sel,
+        int impl,
         const FastScanDistancePostProcessing&) const {
-    // Create default handlers based on k and impl
-    if (is_max) {
-        using HeapHC = HeapHandler<CMax<uint16_t, int>, false>;
-        using ReservoirHC = ReservoirHandler<CMax<uint16_t, int>, false>;
-        using SingleResultHC = SingleResultHandler<CMax<uint16_t, int>, false>;
-
-        if (k == 1) {
-            return new SingleResultHC(n, ntotal, distances, labels, sel);
-        } else if (impl % 2 == 0) {
-            return new HeapHC(n, ntotal, k, distances, labels, sel);
-        } else {
-            return new ReservoirHC(n, ntotal, k, 2 * k, distances, labels, sel);
-        }
-    } else {
-        using HeapHC = HeapHandler<CMin<uint16_t, int>, false>;
-        using ReservoirHC = ReservoirHandler<CMin<uint16_t, int>, false>;
-        using SingleResultHC = SingleResultHandler<CMin<uint16_t, int>, false>;
-
-        if (k == 1) {
-            return new SingleResultHC(n, ntotal, distances, labels, sel);
-        } else if (impl % 2 == 0) {
-            return new HeapHC(n, ntotal, k, distances, labels, sel);
-        } else {
-            return new ReservoirHC(n, ntotal, k, 2 * k, distances, labels, sel);
-        }
-    }
+    return make_fast_scan_knn_scanner(
+            is_max, impl, n, ntotal_, k, distances, labels, sel);
 }
 
 using namespace quantize_lut;
@@ -263,7 +235,7 @@ void IndexFastScan::compute_quantized_LUT(
     std::unique_ptr<float[]> dis_tables(new float[n * dim12]);
     compute_float_LUT(dis_tables.get(), n, x, context);
 
-    for (uint64_t i = 0; i < n; i++) {
+    for (idx_t i = 0; i < n; i++) {
         round_uint8_per_column(
                 dis_tables.get() + i * dim12,
                 M,
@@ -272,11 +244,11 @@ void IndexFastScan::compute_quantized_LUT(
                 &normalizers[2 * i + 1]);
     }
 
-    for (uint64_t i = 0; i < n; i++) {
+    for (idx_t i = 0; i < n; i++) {
         const float* t_in = dis_tables.get() + i * dim12;
         uint8_t* t_out = lut + i * M2 * ksub;
 
-        for (int j = 0; j < dim12; j++) {
+        for (size_t j = 0; j < dim12; j++) {
             t_out[j] = int(t_in[j]);
         }
         memset(t_out + dim12, 0, (M2 - M) * ksub);
@@ -420,7 +392,7 @@ void IndexFastScan::search_implem_234(
     if (implem == 2) {
         // default float
     } else if (implem == 3 || implem == 4) {
-        for (uint64_t i = 0; i < n; i++) {
+        for (idx_t i = 0; i < n; i++) {
             round_uint8_per_column(
                     dis_tables.get() + i * dim12,
                     M,
@@ -453,7 +425,7 @@ void IndexFastScan::search_implem_234(
             float a = normalizers[2 * i];
             float b = normalizers[2 * i + 1];
 
-            for (int j = 0; j < k; j++) {
+            for (idx_t j = 0; j < k; j++) {
                 heap_dis[j] = heap_dis[j] / a + b;
             }
         }
@@ -469,7 +441,6 @@ void IndexFastScan::search_implem_12(
         idx_t* labels,
         int impl,
         const FastScanDistancePostProcessing& context) const {
-    using RH = ResultHandlerCompare<C, false>;
     FAISS_THROW_IF_NOT(bbs == 32);
 
     // handle qbs2 blocking by recursive call
@@ -510,46 +481,37 @@ void IndexFastScan::search_implem_12(
     // block sizes are encoded in qbs, 4 bits at a time
 
     // caution: we override an object field
-    int qbs = this->qbs;
+    int qbs_ = this->qbs;
 
-    if (n != pq4_qbs_to_nq(qbs)) {
-        qbs = pq4_preferred_qbs(n);
+    if (n != pq4_qbs_to_nq(qbs_)) {
+        qbs_ = pq4_preferred_qbs(static_cast<int>(n));
     }
 
-    int LUT_nq =
-            pq4_pack_LUT_qbs(qbs, M2, quantized_dis_tables.get(), LUT.get());
+    int LUT_nq = pq4_pack_LUT_qbs(
+            qbs_, static_cast<int>(M2), quantized_dis_tables.get(), LUT.get());
     FAISS_THROW_IF_NOT(LUT_nq == n);
 
-    std::unique_ptr<RH> handler(
-            static_cast<RH*>(make_knn_handler(
-                    C::is_max,
-                    impl,
-                    n,
-                    k,
-                    ntotal,
-                    distances,
-                    labels,
-                    nullptr,
-                    context)));
+    auto scanner = make_knn_scanner(
+            C::is_max, n, k, ntotal, distances, labels, nullptr, impl, context);
+    auto* rh = scanner->handler();
+    rh->normalizers = normalizers.get();
+    // Note: skip & 2 previously set handler->disable (run kernel,
+    // discard results). Through the scanner path, skip & 2 now skips
+    // the kernel entirely (same as skip & 4), since disable is not
+    // accessible through the SIMDResultHandlerToFloat* interface.
+    if (!(skip & (2 | 4))) {
+        scanner->accumulate_loop_qbs(
+                qbs_,
 
-    handler->disable = bool(skip & 2);
-    handler->normalizers = normalizers.get();
-
-    if (skip & 4) {
-        // pass
-    } else {
-        pq4_accumulate_loop_qbs(
-                qbs,
                 ntotal2,
-                M2,
+                static_cast<int>(M2),
                 codes.get(),
                 LUT.get(),
-                *handler.get(),
-                context.norm_scaler,
+                context.pq2x4_scale,
                 get_block_stride());
     }
     if (!(skip & 8)) {
-        handler->end();
+        rh->end();
     }
 }
 
@@ -564,10 +526,16 @@ void IndexFastScan::search_implem_14(
         idx_t* labels,
         int impl,
         const FastScanDistancePostProcessing& context) const {
-    using RH = ResultHandlerCompare<C, false>;
     FAISS_THROW_IF_NOT(bbs % 32 == 0);
 
-    int qbs2 = qbs == 0 ? 4 : qbs;
+    // The accumulate loop dispatch table only instantiates certain
+    // (nq, BB) pairs where BB = bbs/32.  Cap the query batch size to
+    // the maximum nq instantiated for the current BB so the caller
+    // doesn't have to know about internal template constraints.
+    //   BB=1 → nq up to 4,  BB=2 → nq up to 2,  BB>=3 → nq=1
+    int BB = bbs / 32;
+    int max_qbs = BB <= 1 ? 4 : BB == 2 ? 2 : 1;
+    int qbs2 = std::min(qbs == 0 ? 4 : qbs, max_qbs);
 
     // handle qbs2 blocking by recursive call
     if (n > qbs2) {
@@ -602,38 +570,33 @@ void IndexFastScan::search_implem_14(
     }
 
     AlignedTable<uint8_t> LUT(n * dim12);
-    pq4_pack_LUT(n, M2, quantized_dis_tables.get(), LUT.get());
-
-    std::unique_ptr<RH> handler(
-            static_cast<RH*>(make_knn_handler(
-                    C::is_max,
-                    impl,
-                    n,
-                    k,
-                    ntotal,
-                    distances,
-                    labels,
-                    nullptr,
-                    context)));
-    handler->disable = bool(skip & 2);
-    handler->normalizers = normalizers.get();
-
-    if (skip & 4) {
-        // pass
-    } else {
-        pq4_accumulate_loop(
-                n,
+    pq4_pack_LUT(
+            static_cast<int>(n),
+            static_cast<int>(M2),
+            quantized_dis_tables.get(),
+            LUT.get());
+
+    auto scanner = make_knn_scanner(
+            C::is_max, n, k, ntotal, distances, labels, nullptr, impl, context);
+    auto* rh = scanner->handler();
+    rh->normalizers = normalizers.get();
+    // Note: skip & 2 previously set handler->disable (run kernel,
+    // discard results). Through the scanner path, skip & 2 now skips
+    // the kernel entirely (same as skip & 4), since disable is not
+    // accessible through the SIMDResultHandlerToFloat* interface.
+    if (!(skip & (2 | 4))) {
+        scanner->accumulate_loop(
+                static_cast<int>(n),
                 ntotal2,
                 bbs,
-                M2,
+                static_cast<int>(M2),
                 codes.get(),
                 LUT.get(),
-                *handler.get(),
-                context.norm_scaler,
+                context.pq2x4_scale,
                 get_block_stride());
     }
     if (!(skip & 8)) {
-        handler->end();
+        rh->end();
     }
 }
 

data/vendor/faiss/faiss/IndexFastScan.h

@@ -7,16 +7,17 @@
 
 #pragma once
 
+#include <memory>
+
 #include <faiss/Index.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 CodePacker;
-struct NormTableScaler;
 struct IDSelector;
-struct SIMDResultHandlerToFloat;
 
 /** Fast scan version of IndexPQ and IndexAQ. Works for 4-bit PQ and AQ for now.
  *
@@ -43,8 +44,8 @@ struct IndexFastScan : Index {
 
     // vector quantizer
     size_t M;
-    size_t nbits;
-    size_t ksub;
+    size_t nbits = 0;
+    size_t ksub = 0;
     size_t code_size;
 
     // packed version of the codes
@@ -122,33 +123,22 @@ struct IndexFastScan : Index {
             const float* x,
             const FastScanDistancePostProcessing& context) const = 0;
 
-    /** Create a KNN handler for this index type
-     *
-     * This method can be overridden by derived classes to provide
-     * specialized handlers (e.g., RaBitQHeapHandler for RaBitQ indexes).
-     * Base implementation creates standard handlers based on k and impl.
+    /** Create a SIMD-dispatched scanner for knn search.
      *
-     * @param is_max       whether to use CMax comparator (true) or CMin (false)
-     * @param impl         implementation number
-     * @param n            number of queries
-     * @param k            number of neighbors to find
-     * @param ntotal       total number of vectors in database
-     * @param distances    output distances array
-     * @param labels       output labels array
-     * @param sel          optional ID selector
-     * @param context      processing context for distance post-processing
-     * @return             pointer to created handler (never returns nullptr)
+     * Returns a FastScanCodeScanner that bundles handler + accumulation
+     * kernel behind the SIMD dispatch boundary.
+     * The scanner's accumulate methods dispatch to the optimal SIMD level.
      */
-    virtual SIMDResultHandlerToFloat* make_knn_handler(
+    virtual std::unique_ptr<FastScanCodeScanner> make_knn_scanner(
             bool is_max,
-            int impl,
             idx_t n,
             idx_t k,
             size_t ntotal,
             float* distances,
             idx_t* labels,
             const IDSelector* sel,
-            const FastScanDistancePostProcessing& context) const;
+            int impl = 0,
+            const FastScanDistancePostProcessing& context = {}) const;
 
     // called by search function
     void compute_quantized_LUT(
@@ -246,6 +236,18 @@ struct IndexFastScan : Index {
     void sa_encode(idx_t n, const float* x, uint8_t* bytes) const override {
         compute_codes(bytes, n, x);
     }
+
+    /** 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;
 };
 
 struct FastScanStats {

data/vendor/faiss/faiss/IndexFlat.cpp

@@ -23,8 +23,8 @@
 
 namespace faiss {
 
-IndexFlat::IndexFlat(idx_t d, MetricType metric)
-        : IndexFlatCodes(sizeof(float) * d, d, metric) {}
+IndexFlat::IndexFlat(idx_t d_, MetricType metric)
+        : IndexFlatCodes(sizeof(float) * d_, d_, metric) {}
 
 void IndexFlat::search(
         idx_t n,
@@ -65,6 +65,7 @@ void IndexFlat::range_search(
         float radius,
         RangeSearchResult* result,
         const SearchParameters* params) const {
+    FAISS_THROW_IF_NOT_MSG(result, "RangeSearchResult object must not be null");
     IDSelector* sel = params ? params->sel : nullptr;
 
     switch (metric_type) {
@@ -86,6 +87,7 @@ void IndexFlat::compute_distance_subset(
         idx_t k,
         float* distances,
         const idx_t* labels) const {
+    FAISS_THROW_IF_NOT(k > 0);
     switch (metric_type) {
         case METRIC_INNER_PRODUCT:
             fvec_inner_products_by_idx(distances, x, get_xb(), labels, d, n, k);
@@ -126,11 +128,11 @@ struct FlatL2Dis : FlatCodesDistanceComputer {
         return fvec_L2sqr<SL>(b + j * d, b + i * d, d);
     }
 
-    explicit FlatL2Dis(const IndexFlat& storage, const float* q = nullptr)
+    explicit FlatL2Dis(const IndexFlat& storage, const float* q_ = nullptr)
             : FlatCodesDistanceComputer(
                       storage.codes.data(),
                       storage.code_size,
-                      q),
+                      q_),
               d(storage.d),
               nb(storage.ntotal),
               b(storage.get_xb()),
@@ -236,13 +238,13 @@ struct FlatIPDis : FlatCodesDistanceComputer {
         return fvec_inner_product<SL>(q, (const float*)code, d);
     }
 
-    explicit FlatIPDis(const IndexFlat& storage, const float* q = nullptr)
+    explicit FlatIPDis(const IndexFlat& storage, const float* q_in = nullptr)
             : FlatCodesDistanceComputer(
                       storage.codes.data(),
                       storage.code_size),
               d(storage.d),
               nb(storage.ntotal),
-              q(q),
+              q(q_in),
               b(storage.get_xb()),
               ndis(0) {}
 
@@ -361,13 +363,13 @@ struct FlatL2WithNormsDis : FlatCodesDistanceComputer {
 
     explicit FlatL2WithNormsDis(
             const IndexFlatL2& storage,
-            const float* q = nullptr)
+            const float* q_in = nullptr)
             : FlatCodesDistanceComputer(
                       storage.codes.data(),
                       storage.code_size),
               d(storage.d),
               nb(storage.ntotal),
-              q(q),
+              q(q_in),
               b(storage.get_xb()),
               ndis(0),
               l2norms(storage.cached_l2norms.data()),
@@ -452,8 +454,8 @@ FlatCodesDistanceComputer* IndexFlatL2::get_FlatCodesDistanceComputer() const {
  * IndexFlat1D
  ***************************************************/
 
-IndexFlat1D::IndexFlat1D(bool continuous_update)
-        : IndexFlatL2(1), continuous_update(continuous_update) {}
+IndexFlat1D::IndexFlat1D(bool continuous_update_in)
+        : IndexFlatL2(1), continuous_update(continuous_update_in) {}
 
 /// if not continuous_update, call this between the last add and
 /// the first search
@@ -489,7 +491,8 @@ void IndexFlat1D::search(
             !params, "search params not supported for this index");
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT_MSG(
-            perm.size() == ntotal, "Call update_permutation before search");
+            perm.size() == static_cast<size_t>(ntotal),
+            "Call update_permutation before search");
     const float* xb = get_xb();
 
 #pragma omp parallel for if (n > 10000)
@@ -624,9 +627,11 @@ inline void flat_pano_search_core(
     {
         SingleResultHandler res(handler);
 
-        std::vector<float> query_cum_norms(index.n_levels + 1);
-        std::vector<float> exact_distances(index.batch_size);
+        std::vector<float> query_cum_norms(index.pano.n_levels + 1);
         std::vector<uint32_t> active_indices(index.batch_size);
+        std::vector<uint8_t> active_byteset(index.batch_size);
+        std::vector<float> exact_distances(index.batch_size);
+        std::vector<float> dot_buffer(index.batch_size);
 
 #pragma omp for
         for (int64_t i = 0; i < n; i++) {
@@ -661,7 +666,9 @@ inline void flat_pano_search_core(
                                     nullptr,
                                     use_sel,
                                     active_indices,
+                                    active_byteset,
                                     exact_distances,
+                                    dot_buffer,
                                     threshold,
                                     local_stats);
                         });
@@ -691,7 +698,7 @@ void IndexFlatPanorama::add(idx_t n, const float* x) {
     size_t num_batches = (ntotal + batch_size - 1) / batch_size;
 
     codes.resize(num_batches * batch_size * code_size);
-    cum_sums.resize(num_batches * batch_size * (n_levels + 1));
+    cum_sums.resize(num_batches * batch_size * (pano.n_levels + 1));
 
     const uint8_t* code = reinterpret_cast<const uint8_t*>(x);
     pano.copy_codes_to_level_layout(codes.data(), offset, n, code);
@@ -706,7 +713,7 @@ void IndexFlatPanorama::search(
         idx_t* labels,
         const SearchParameters* params) const {
     FAISS_THROW_IF_NOT(k > 0);
-    FAISS_THROW_IF_NOT(batch_size >= k);
+    FAISS_THROW_IF_NOT(batch_size >= static_cast<size_t>(k));
 
     dispatch_metric_compare(metric_type, [&]<typename C>() {
         HeapBlockResultHandler<C, false> handler(
@@ -764,7 +771,7 @@ size_t IndexFlatPanorama::remove_ids(const IDSelector& sel) {
         ntotal = j;
         size_t num_batches = (ntotal + batch_size - 1) / batch_size;
         codes.resize(num_batches * batch_size * code_size);
-        cum_sums.resize(num_batches * batch_size * (n_levels + 1));
+        cum_sums.resize(num_batches * batch_size * (pano.n_levels + 1));
     }
     return nremove;
 }
@@ -836,7 +843,7 @@ void IndexFlatPanorama::search_subset(
             {
                 SingleResultHandler res(handler);
 
-                std::vector<float> query_cum_norms(n_levels + 1);
+                std::vector<float> query_cum_norms(pano.n_levels + 1);
 
                 // Panorama's optimized point-wise refinement (Algorithm 2):
                 // Batch-wise Panorama, as implemented in Panorama.h, incurs
@@ -867,14 +874,14 @@ void IndexFlatPanorama::search_subset(
 
                     res.begin(i);
 
-                    for (size_t j = 0; j < k_base; j++) {
+                    for (idx_t j = 0; j < k_base; j++) {
                         idx_t idx = idsi[j];
 
                         if (idx < 0) {
                             continue;
                         }
 
-                        size_t cum_sum_offset = (n_levels + 1) * idx;
+                        size_t cum_sum_offset = (pano.n_levels + 1) * idx;
                         float cum_sum = cum_sums[cum_sum_offset];
                         float exact_distance = 0.0f;
                         if constexpr (!is_sim) {
@@ -890,7 +897,7 @@ void IndexFlatPanorama::search_subset(
                         local_stats.total_dims += d;
 
                         bool pruned = false;
-                        for (size_t level = 0; level < n_levels; level++) {
+                        for (size_t level = 0; level < pano.n_levels; level++) {
                             local_stats.total_dims_scanned +=
                                     pano.level_width_floats;
 

data/vendor/faiss/faiss/IndexFlat.h

@@ -74,7 +74,7 @@ struct IndexFlat : IndexFlatCodes {
 };
 
 struct IndexFlatIP : IndexFlat {
-    explicit IndexFlatIP(idx_t d) : IndexFlat(d, METRIC_INNER_PRODUCT) {}
+    explicit IndexFlatIP(idx_t d_in) : IndexFlat(d_in, METRIC_INNER_PRODUCT) {}
     IndexFlatIP() {}
 };
 
@@ -88,7 +88,7 @@ struct IndexFlatL2 : IndexFlat {
     /**
      * @param d dimensionality of the input vectors
      */
-    explicit IndexFlatL2(idx_t d) : IndexFlat(d, METRIC_L2) {}
+    explicit IndexFlatL2(idx_t d_in) : IndexFlat(d_in, METRIC_L2) {}
     IndexFlatL2() {}
 
     // override for l2 norms cache.
@@ -113,14 +113,14 @@ struct IndexFlatPanorama : IndexFlat {
      * @param batch_size batch size for Panorama storage
      */
     explicit IndexFlatPanorama(
-            idx_t d,
+            idx_t d_in,
             MetricType metric,
-            size_t n_levels,
-            size_t batch_size)
-            : IndexFlat(d, metric),
-              batch_size(batch_size),
-              n_levels(n_levels),
-              pano(code_size, n_levels, batch_size) {
+            size_t n_levels_in,
+            size_t batch_size_in)
+            : IndexFlat(d_in, metric),
+              batch_size(batch_size_in),
+              n_levels(n_levels_in),
+              pano(code_size, n_levels_in, batch_size_in) {
         FAISS_THROW_IF_NOT(
                 metric == METRIC_L2 || metric == METRIC_INNER_PRODUCT);
     }
@@ -174,10 +174,10 @@ struct IndexFlatL2Panorama : IndexFlatPanorama {
      * @param batch_size batch size for Panorama storage
      */
     explicit IndexFlatL2Panorama(
-            idx_t d,
-            size_t n_levels,
-            size_t batch_size = 512)
-            : IndexFlatPanorama(d, METRIC_L2, n_levels, batch_size) {}
+            idx_t d_in,
+            size_t n_levels_in,
+            size_t batch_size_in = 512)
+            : IndexFlatPanorama(d_in, METRIC_L2, n_levels_in, batch_size_in) {}
 };
 
 struct IndexFlatIPPanorama : IndexFlatPanorama {
@@ -187,11 +187,14 @@ struct IndexFlatIPPanorama : IndexFlatPanorama {
      * @param batch_size batch size for Panorama storage
      */
     explicit IndexFlatIPPanorama(
-            idx_t d,
-            size_t n_levels,
-            size_t batch_size = 512)
-            : IndexFlatPanorama(d, METRIC_INNER_PRODUCT, n_levels, batch_size) {
-    }
+            idx_t d_in,
+            size_t n_levels_in,
+            size_t batch_size_in = 512)
+            : IndexFlatPanorama(
+                      d_in,
+                      METRIC_INNER_PRODUCT,
+                      n_levels_in,
+                      batch_size_in) {}
 };
 
 /// optimized version for 1D "vectors".