faiss 0.5.3 → 0.6.1

data/vendor/faiss/faiss/IndexRaBitQFastScan.h

@@ -7,16 +7,16 @@
 
 #pragma once
 
+#include <memory>
 #include <vector>
 
 #include <faiss/IndexFastScan.h>
 #include <faiss/IndexRaBitQ.h>
-#include <faiss/impl/RaBitQStats.h>
 #include <faiss/impl/RaBitQUtils.h>
 #include <faiss/impl/RaBitQuantizer.h>
-#include <faiss/impl/simd_result_handlers.h>
+#include <faiss/impl/fast_scan/simd_result_handlers.h>
+#include <faiss/impl/simdlib/simdlib_dispatch.h>
 #include <faiss/utils/Heap.h>
-#include <faiss/utils/simdlib.h>
 
 namespace faiss {
 
@@ -43,17 +43,6 @@ struct IndexRaBitQFastScan : IndexFastScan {
     /// Center of all points (same as IndexRaBitQ)
     std::vector<float> center;
 
-    /// Per-vector auxiliary data (1-bit codes stored separately in `codes`)
-    ///
-    /// 1-bit codes (sign bits) are stored in the inherited `codes` array from
-    /// IndexFastScan in packed FastScan format for SIMD processing.
-    ///
-    /// This flat_storage holds per-vector factors and refinement-bit codes:
-    /// Layout for 1-bit: [SignBitFactors (8 bytes)]
-    /// Layout for multi-bit: [SignBitFactorsWithError
-    /// (12B)][ref_codes][ExtraBitsFactors (8B)]
-    std::vector<uint8_t> flat_storage;
-
     /// Default number of bits to quantize a query with
     uint8_t qb = 8;
 
@@ -77,7 +66,7 @@ struct IndexRaBitQFastScan : IndexFastScan {
 
     void compute_codes(uint8_t* codes, idx_t n, const float* x) const override;
 
-    /// Compute storage size per vector in flat_storage
+    /// Compute per-vector auxiliary data size in block aux region
     size_t compute_per_vector_storage_size() const;
 
     void compute_float_LUT(
@@ -88,6 +77,16 @@ struct IndexRaBitQFastScan : IndexFastScan {
 
     void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
 
+    /// Packed code size: (d + 7) / 8 bytes (1-bit-per-dimension sign bits,
+    /// excluding factors)
+    size_t fast_scan_code_size() const override;
+
+    /// Return CodePackerRaBitQ with enlarged block size
+    CodePacker* get_CodePacker() const override;
+
+    /// Remove vectors and compact both PQ4 codes and auxiliary data
+    size_t remove_ids(const IDSelector& sel) override;
+
     void search(
             idx_t n,
             const float* x,
@@ -96,17 +95,17 @@ struct IndexRaBitQFastScan : IndexFastScan {
             idx_t* labels,
             const SearchParameters* params = nullptr) const override;
 
-    /// Override to create RaBitQ-specific handlers
-    SIMDResultHandlerToFloat* make_knn_handler(
+    /// RaBitQ scanner wired through rabitq_make_knn_scanner
+    std::unique_ptr<FastScanCodeScanner> 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,
-            const FastScanDistancePostProcessing& context) const override;
+            int impl = 0,
+            const FastScanDistancePostProcessing& context = {}) const override;
 };
 
 /** SIMD result handler for RaBitQ FastScan that applies distance corrections
@@ -126,21 +125,33 @@ struct IndexRaBitQFastScan : IndexFastScan {
  *
  * @tparam C Comparator type (CMin/CMax) for heap operations
  * @tparam with_id_map Whether to use id mapping (similar to HeapHandler)
+ * @tparam SL SIMD level for per-TU template instantiation
  */
-template <class C, bool with_id_map = false>
+template <
+        class C,
+        bool with_id_map = false,
+        SIMDLevel SL = SINGLE_SIMD_LEVEL_256>
 struct RaBitQHeapHandler
-        : simd_result_handlers::ResultHandlerCompare<C, with_id_map> {
-    using RHC = simd_result_handlers::ResultHandlerCompare<C, with_id_map>;
+        : simd_result_handlers::ResultHandlerCompare<C, with_id_map, SL> {
+    using RHC = simd_result_handlers::ResultHandlerCompare<C, with_id_map, SL>;
     using RHC::normalizers;
+    static constexpr SIMDLevel SL256 = simd256_level_selector<SL>::value;
+    using simd16uint16 = simd16uint16_tpl<SL256>;
 
     const IndexRaBitQFastScan* rabitq_index;
     float* heap_distances; // [nq * k]
     int64_t* heap_labels;  // [nq * k]
     const size_t nq, k;
-    const FastScanDistancePostProcessing&
+    const FastScanDistancePostProcessing*
             context;         // Processing context with query offset
     const bool is_multi_bit; // Runtime flag for multi-bit mode
 
+    // Cached block-layout constants (invariant for handler lifetime)
+    const size_t storage_size;
+    const size_t packed_block_size;
+    const size_t full_block_size;
+    std::vector<uint8_t> unpack_buf; // sign bits scratch buffer
+
     // Use float-based comparator for heap operations
     using Cfloat = typename std::conditional<
             C::is_max,
@@ -154,22 +165,169 @@ struct RaBitQHeapHandler
             float* distances,
             int64_t* labels,
             const IDSelector* sel_in,
-            const FastScanDistancePostProcessing& context,
-            bool multi_bit);
+            const FastScanDistancePostProcessing* ctx,
+            bool multi_bit)
+            : RHC(nq_val, index->ntotal, sel_in),
+              rabitq_index(index),
+              heap_distances(distances),
+              heap_labels(labels),
+              nq(nq_val),
+              k(k_val),
+              context(ctx),
+              is_multi_bit(multi_bit),
+              storage_size(index->compute_per_vector_storage_size()),
+              packed_block_size(((index->M2 + 1) / 2) * index->bbs),
+              full_block_size(index->get_block_stride()),
+              unpack_buf((index->d + 7) / 8) {
+#pragma omp parallel for if (nq > 100)
+        for (int64_t q = 0; q < static_cast<int64_t>(nq); q++) {
+            float* heap_dis = heap_distances + q * k;
+            int64_t* heap_ids = heap_labels + q * k;
+            heap_heapify<Cfloat>(k, heap_dis, heap_ids);
+        }
+    }
+
+    void handle(size_t q, size_t b, simd16uint16 d0, simd16uint16 d1) final {
+        ALIGNED(32) uint16_t d32tab[32];
+        d0.store(d32tab);
+        d1.store(d32tab + 16);
+
+        float* const heap_dis = heap_distances + q * k;
+        int64_t* const heap_ids = heap_labels + q * k;
+
+        rabitq_utils::QueryFactorsData query_factors_data = {};
+        if (context && context->query_factors != nullptr) {
+            query_factors_data = context->query_factors[q];
+        }
+
+        const float one_a = normalizers ? (1.0f / normalizers[2 * q]) : 1.0f;
+        const float bias = normalizers ? normalizers[2 * q + 1] : 0.0f;
+
+        const size_t base_db_idx = this->j0 + b * 32;
+        const size_t max_vectors = (base_db_idx < rabitq_index->ntotal)
+                ? std::min<size_t>(32, rabitq_index->ntotal - base_db_idx)
+                : 0;
+
+        const size_t block_idx = base_db_idx / rabitq_index->bbs;
+        const uint8_t* aux_base = rabitq_index->codes.get() +
+                block_idx * full_block_size + packed_block_size;
 
-    void handle(size_t q, size_t b, simd16uint16 d0, simd16uint16 d1) override;
+        for (size_t i = 0; i < max_vectors; i++) {
+            const size_t db_idx = base_db_idx + i;
+            const float normalized_distance = d32tab[i] * one_a + bias;
+            const uint8_t* base_ptr = aux_base + i * storage_size;
 
-    void begin(const float* norms);
+            if (is_multi_bit) {
+                const SignBitFactorsWithError& full_factors =
+                        *reinterpret_cast<const SignBitFactorsWithError*>(
+                                base_ptr);
 
-    void end();
+                float dist_1bit = rabitq_utils::compute_1bit_adjusted_distance(
+                        normalized_distance,
+                        full_factors,
+                        query_factors_data,
+                        rabitq_index->centered,
+                        rabitq_index->qb,
+                        rabitq_index->d);
+
+                const bool is_similarity = rabitq_index->metric_type ==
+                        MetricType::METRIC_INNER_PRODUCT;
+                bool should_refine = rabitq_utils::should_refine_candidate(
+                        dist_1bit,
+                        full_factors.f_error,
+                        context && context->query_factors
+                                ? context->query_factors[q].g_error
+                                : 0.0f,
+                        heap_dis[0],
+                        is_similarity);
+
+                if (should_refine) {
+                    float dist_full = compute_full_multibit_distance(db_idx, q);
+
+                    if (Cfloat::cmp(heap_dis[0], dist_full)) {
+                        heap_replace_top<Cfloat>(
+                                k, heap_dis, heap_ids, dist_full, db_idx);
+                    }
+                }
+            } else {
+                const rabitq_utils::SignBitFactors& db_factors =
+                        *reinterpret_cast<const rabitq_utils::SignBitFactors*>(
+                                base_ptr);
+
+                float adjusted_distance =
+                        rabitq_utils::compute_1bit_adjusted_distance(
+                                normalized_distance,
+                                db_factors,
+                                query_factors_data,
+                                rabitq_index->centered,
+                                rabitq_index->qb,
+                                rabitq_index->d);
+
+                if (Cfloat::cmp(heap_dis[0], adjusted_distance)) {
+                    heap_replace_top<Cfloat>(
+                            k, heap_dis, heap_ids, adjusted_distance, db_idx);
+                }
+            }
+        }
+    }
+
+    void begin(const float* norms) override {
+        normalizers = norms;
+    }
+
+    void end() override {
+#pragma omp parallel for if (nq > 100)
+        for (int64_t q = 0; q < static_cast<int64_t>(nq); q++) {
+            float* heap_dis = heap_distances + q * k;
+            int64_t* heap_ids = heap_labels + q * k;
+            heap_reorder<Cfloat>(k, heap_dis, heap_ids);
+        }
+    }
 
    private:
-    /// Compute full multi-bit distance for a candidate vector (multi-bit only)
-    float compute_full_multibit_distance(size_t db_idx, size_t q) const;
+    float compute_full_multibit_distance(size_t db_idx, size_t q) {
+        const size_t ex_bits = rabitq_index->rabitq.nb_bits - 1;
+        const size_t dim = rabitq_index->d;
+
+        const uint8_t* base_ptr = rabitq_utils::get_block_aux_ptr(
+                rabitq_index->codes.get(),
+                db_idx,
+                rabitq_index->bbs,
+                packed_block_size,
+                full_block_size,
+                storage_size);
+
+        const size_t ex_code_size = (dim * ex_bits + 7) / 8;
+        const uint8_t* ex_code = base_ptr + sizeof(SignBitFactorsWithError);
+        const ExtraBitsFactors& ex_fac =
+                *reinterpret_cast<const ExtraBitsFactors*>(
+                        base_ptr + sizeof(SignBitFactorsWithError) +
+                        ex_code_size);
+
+        const rabitq_utils::QueryFactorsData& query_factors =
+                context->query_factors[q];
+
+        rabitq_utils::unpack_sign_bits_from_packed(
+                rabitq_index->codes.get(),
+                rabitq_index->bbs,
+                rabitq_index->M2,
+                db_idx,
+                full_block_size,
+                unpack_buf.data());
+        const uint8_t* sign_bits = unpack_buf.data();
 
-    /// Compute lower bound using 1-bit distance and error bound (multi-bit
-    /// only)
-    float compute_lower_bound(float dist_1bit, size_t db_idx, size_t q) const;
+        return rabitq_utils::compute_full_multibit_distance(
+                sign_bits,
+                ex_code,
+                ex_fac,
+                query_factors.rotated_q.data(),
+                (rabitq_index->metric_type == MetricType::METRIC_INNER_PRODUCT)
+                        ? query_factors.q_dot_c
+                        : query_factors.qr_to_c_L2sqr,
+                dim,
+                ex_bits,
+                rabitq_index->metric_type);
+    }
 };
 
 } // namespace faiss

data/vendor/faiss/faiss/IndexRefine.cpp

@@ -18,10 +18,10 @@ namespace faiss {
  * IndexRefine
  ***************************************************/
 
-IndexRefine::IndexRefine(Index* base_index, Index* refine_index)
-        : Index(base_index->d, base_index->metric_type),
-          base_index(base_index),
-          refine_index(refine_index) {
+IndexRefine::IndexRefine(Index* base_index_in, Index* refine_index_in)
+        : Index(base_index_in->d, base_index_in->metric_type),
+          base_index(base_index_in),
+          refine_index(refine_index_in) {
     own_fields = own_refine_index = false;
     if (refine_index != nullptr) {
         FAISS_THROW_IF_NOT(base_index->d == refine_index->d);
@@ -58,36 +58,6 @@ void IndexRefine::reset() {
     ntotal = 0;
 }
 
-namespace {
-
-using idx_t = faiss::idx_t;
-
-template <class C>
-static void reorder_2_heaps(
-        idx_t n,
-        idx_t k,
-        idx_t* __restrict labels,
-        float* __restrict distances,
-        idx_t k_base,
-        const idx_t* __restrict base_labels,
-        const float* __restrict base_distances) {
-#pragma omp parallel for if (n > 1)
-    for (idx_t i = 0; i < n; i++) {
-        idx_t* idxo = labels + i * k;
-        float* diso = distances + i * k;
-        const idx_t* idxi = base_labels + i * k_base;
-        const float* disi = base_distances + i * k_base;
-
-        heap_heapify<C>(k, diso, idxo, disi, idxi, k);
-        if (k_base != k) { // add remaining elements
-            heap_addn<C>(k, diso, idxo, disi + k, idxi + k, k_base - k);
-        }
-        heap_reorder<C>(k, diso, idxo);
-    }
-}
-
-} // anonymous namespace
-
 void IndexRefine::search(
         idx_t n,
         const float* x,
@@ -114,6 +84,8 @@ void IndexRefine::search(
 
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(is_trained);
+    FAISS_THROW_IF_NOT_MSG(
+            n <= INT64_MAX / k_base, "n * k_base would overflow int64");
     idx_t* base_labels = labels;
     float* base_distances = distances;
     std::unique_ptr<idx_t[]> del1;
@@ -129,8 +101,8 @@ void IndexRefine::search(
     base_index->search(
             n, x, k_base, base_distances, base_labels, base_index_params);
 
-    for (int i = 0; i < n * k_base; i++) {
-        assert(base_labels[i] >= -1 && base_labels[i] < ntotal);
+    for (idx_t i = 0; i < n * k_base; i++) {
+        FAISS_THROW_IF_NOT(base_labels[i] >= -1 && base_labels[i] < ntotal);
     }
 
     // parallelize over queries
@@ -155,12 +127,12 @@ void IndexRefine::search(
 
     // sort and store result
     if (metric_type == METRIC_L2) {
-        typedef CMax<float, idx_t> C;
+        using C = CMax<float, idx_t>;
         reorder_2_heaps<C>(
                 n, k, labels, distances, k_base, base_labels, base_distances);
 
     } else if (metric_type == METRIC_INNER_PRODUCT) {
-        typedef CMin<float, idx_t> C;
+        using C = CMin<float, idx_t>;
         reorder_2_heaps<C>(
                 n, k, labels, distances, k_base, base_labels, base_distances);
     } else {
@@ -221,7 +193,7 @@ void IndexRefine::sa_encode(idx_t n, const float* x, uint8_t* bytes) const {
     base_index->sa_encode(n, x, tmp1.get());
     std::unique_ptr<uint8_t[]> tmp2(new uint8_t[n * cs2]);
     refine_index->sa_encode(n, x, tmp2.get());
-    for (size_t i = 0; i < n; i++) {
+    for (idx_t i = 0; i < n; i++) {
         uint8_t* b = bytes + i * (cs1 + cs2);
         memcpy(b, tmp1.get() + cs1 * i, cs1);
         memcpy(b + cs1, tmp2.get() + cs2 * i, cs2);
@@ -230,10 +202,9 @@ void IndexRefine::sa_encode(idx_t n, const float* x, uint8_t* bytes) const {
 
 void IndexRefine::sa_decode(idx_t n, const uint8_t* bytes, float* x) const {
     size_t cs1 = base_index->sa_code_size(), cs2 = refine_index->sa_code_size();
-    std::unique_ptr<uint8_t[]> tmp2(
-            new uint8_t[n * refine_index->sa_code_size()]);
-    for (size_t i = 0; i < n; i++) {
-        memcpy(tmp2.get() + i * cs2, bytes + i * (cs1 + cs2), cs2);
+    std::unique_ptr<uint8_t[]> tmp2(new uint8_t[n * cs2]);
+    for (idx_t i = 0; i < n; i++) {
+        memcpy(tmp2.get() + i * cs2, bytes + i * (cs1 + cs2) + cs1, cs2);
     }
 
     refine_index->sa_decode(n, tmp2.get(), x);
@@ -252,10 +223,10 @@ IndexRefine::~IndexRefine() {
  * IndexRefineFlat
  ***************************************************/
 
-IndexRefineFlat::IndexRefineFlat(Index* base_index)
+IndexRefineFlat::IndexRefineFlat(Index* base_index_in)
         : IndexRefine(
-                  base_index,
-                  new IndexFlat(base_index->d, base_index->metric_type)) {
+                  base_index_in,
+                  new IndexFlat(base_index_in->d, base_index_in->metric_type)) {
     is_trained = base_index->is_trained;
     own_refine_index = true;
     FAISS_THROW_IF_NOT_MSG(
@@ -263,8 +234,8 @@ IndexRefineFlat::IndexRefineFlat(Index* base_index)
             "base_index should be empty in the beginning");
 }
 
-IndexRefineFlat::IndexRefineFlat(Index* base_index, const float* xb)
-        : IndexRefine(base_index, nullptr) {
+IndexRefineFlat::IndexRefineFlat(Index* base_index_in, const float* xb)
+        : IndexRefine(base_index_in, nullptr) {
     is_trained = base_index->is_trained;
     refine_index = new IndexFlat(base_index->d, base_index->metric_type);
     own_refine_index = true;
@@ -301,6 +272,8 @@ void IndexRefineFlat::search(
 
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(is_trained);
+    FAISS_THROW_IF_NOT_MSG(
+            n <= INT64_MAX / k_base, "n * k_base would overflow int64");
     idx_t* base_labels = labels;
     float* base_distances = distances;
     std::unique_ptr<idx_t[]> del1;
@@ -316,8 +289,8 @@ void IndexRefineFlat::search(
     base_index->search(
             n, x, k_base, base_distances, base_labels, base_index_params);
 
-    for (int i = 0; i < n * k_base; i++) {
-        assert(base_labels[i] >= -1 && base_labels[i] < ntotal);
+    for (idx_t i = 0; i < n * k_base; i++) {
+        FAISS_THROW_IF_NOT(base_labels[i] >= -1 && base_labels[i] < ntotal);
     }
 
     // compute refined distances
@@ -328,12 +301,12 @@ void IndexRefineFlat::search(
 
     // sort and store result
     if (metric_type == METRIC_L2) {
-        typedef CMax<float, idx_t> C;
+        using C = CMax<float, idx_t>;
         reorder_2_heaps<C>(
                 n, k, labels, distances, k_base, base_labels, base_distances);
 
     } else if (metric_type == METRIC_INNER_PRODUCT) {
-        typedef CMin<float, idx_t> C;
+        using C = CMin<float, idx_t>;
         reorder_2_heaps<C>(
                 n, k, labels, distances, k_base, base_labels, base_distances);
     } else {
@@ -356,7 +329,7 @@ void IndexRefinePanorama::search(
     if (params_in) {
         params = dynamic_cast<const IndexRefineSearchParameters*>(params_in);
         FAISS_THROW_IF_NOT_MSG(
-                params, "IndexRefineFlat params have incorrect type");
+                params, "IndexRefinePanorama params have incorrect type");
     }
 
     idx_t k_base = (params != nullptr) ? idx_t(k * params->k_factor)
@@ -371,6 +344,8 @@ void IndexRefinePanorama::search(
 
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(is_trained);
+    FAISS_THROW_IF_NOT_MSG(
+            n <= INT64_MAX / k_base, "n * k_base would overflow int64");
 
     std::unique_ptr<idx_t[]> del1;
     std::unique_ptr<float[]> del2;
@@ -382,8 +357,8 @@ void IndexRefinePanorama::search(
     base_index->search(
             n, x, k_base, base_distances, base_labels, base_index_params);
 
-    for (int i = 0; i < n * k_base; i++) {
-        assert(base_labels[i] >= -1 && base_labels[i] < ntotal);
+    for (idx_t i = 0; i < n * k_base; i++) {
+        FAISS_THROW_IF_NOT(base_labels[i] >= -1 && base_labels[i] < ntotal);
     }
 
     refine_index->search_subset(

data/vendor/faiss/faiss/IndexRefine.h

@@ -28,8 +28,8 @@ struct IndexRefine : Index {
     /// refinement index
     Index* refine_index;
 
-    bool own_fields;       ///< should the base index be deallocated?
-    bool own_refine_index; ///< same with the refinement index
+    bool own_fields = false;       ///< should the base index be deallocated?
+    bool own_refine_index = false; ///< same with the refinement index
 
     /// factor between k requested in search and the k requested from
     /// the base_index (should be >= 1)
@@ -98,8 +98,8 @@ struct IndexRefineFlat : IndexRefine {
 /** Version where the search calls search_subset, allowing for Panorama
  * refinement. */
 struct IndexRefinePanorama : IndexRefine {
-    explicit IndexRefinePanorama(Index* base_index, Index* refine_index)
-            : IndexRefine(base_index, refine_index) {}
+    explicit IndexRefinePanorama(Index* base_index_in, Index* refine_index_in)
+            : IndexRefine(base_index_in, refine_index_in) {}
 
     IndexRefinePanorama() : IndexRefine() {}
 

data/vendor/faiss/faiss/IndexReplicas.cpp

@@ -16,7 +16,7 @@ namespace {
 
 // IndexBinary needs to update the code_size when d is set...
 
-void sync_d(Index* index) {}
+void sync_d(Index* /*index*/) {}
 
 void sync_d(IndexBinary* index) {
     FAISS_THROW_IF_NOT(index->d % 8 == 0);
@@ -30,14 +30,14 @@ IndexReplicasTemplate<IndexT>::IndexReplicasTemplate(bool threaded)
         : ThreadedIndex<IndexT>(threaded) {}
 
 template <typename IndexT>
-IndexReplicasTemplate<IndexT>::IndexReplicasTemplate(idx_t d, bool threaded)
-        : ThreadedIndex<IndexT>(d, threaded) {
+IndexReplicasTemplate<IndexT>::IndexReplicasTemplate(idx_t d_in, bool threaded)
+        : ThreadedIndex<IndexT>(static_cast<int>(d_in), threaded) {
     sync_d(this);
 }
 
 template <typename IndexT>
-IndexReplicasTemplate<IndexT>::IndexReplicasTemplate(int d, bool threaded)
-        : ThreadedIndex<IndexT>(d, threaded) {
+IndexReplicasTemplate<IndexT>::IndexReplicasTemplate(int d_in, bool threaded)
+        : ThreadedIndex<IndexT>(d_in, threaded) {
     sync_d(this);
 }
 
@@ -71,7 +71,7 @@ void IndexReplicasTemplate<IndexT>::onAfterAddIndex(IndexT* index) {
 }
 
 template <typename IndexT>
-void IndexReplicasTemplate<IndexT>::onAfterRemoveIndex(IndexT* index) {
+void IndexReplicasTemplate<IndexT>::onAfterRemoveIndex(IndexT* /*index*/) {
     syncWithSubIndexes();
 }
 

data/vendor/faiss/faiss/IndexRowwiseMinMax.cpp

@@ -162,10 +162,10 @@ void sa_decode_impl(
 
     // allocate tmp buffers
     std::vector<uint8_t> tmp(
-            (chunk_size < n_input ? chunk_size : n_input) * old_code_size);
-    std::vector<StorageMinMaxFP16> minmax(
-            (chunk_size < n_input ? chunk_size : n_input));
-
+            (chunk_size < static_cast<size_t>(n_input)
+                     ? chunk_size
+                     : static_cast<size_t>(n_input)) *
+            old_code_size);
     // all the elements to process
     size_t n_left = n_input;
 
@@ -226,7 +226,7 @@ void train_inplace_impl(
     std::vector<StorageMinMaxT> minmax(n);
 
     // normalize
-#pragma omp for
+#pragma omp parallel for
     for (idx_t i = 0; i < n; i++) {
         // compute min & max values
         float minv = std::numeric_limits<float>::max();
@@ -264,6 +264,7 @@ void train_inplace_impl(
     sub_index->train(n, x);
 
     // rescale data back
+#pragma omp parallel for
     for (idx_t i = 0; i < n; i++) {
         float scaler = 0;
         float minv = 0;
@@ -289,7 +290,7 @@ void train_impl(IndexRowwiseMinMaxBase* const index, idx_t n, const float* x) {
     // temp buffer
     std::vector<float> tmp(n * d);
 
-#pragma omp for
+#pragma omp parallel for
     for (idx_t i = 0; i < n; i++) {
         // compute min & max values
         float minv = std::numeric_limits<float>::max();
@@ -304,7 +305,7 @@ void train_impl(IndexRowwiseMinMaxBase* const index, idx_t n, const float* x) {
         const float scaler = maxv - minv;
 
         // save the coefficients
-        StorageMinMaxT storage;
+        StorageMinMaxT storage = {};
         storage.from_floats(scaler, minv);
 
         // and load them back, because the coefficients might
@@ -339,9 +340,9 @@ int rowwise_minmax_sa_decode_bs = 16384;
  * IndexRowwiseMinMaxBase implementation
  ********************************************************/
 
-IndexRowwiseMinMaxBase::IndexRowwiseMinMaxBase(Index* index)
-        : Index(index->d, index->metric_type),
-          index{index},
+IndexRowwiseMinMaxBase::IndexRowwiseMinMaxBase(Index* index_in)
+        : Index(index_in->d, index_in->metric_type),
+          index{index_in},
           own_fields{false} {}
 
 IndexRowwiseMinMaxBase::IndexRowwiseMinMaxBase()
@@ -376,8 +377,8 @@ void IndexRowwiseMinMaxBase::reset() {
  * IndexRowwiseMinMaxFP16 implementation
  ********************************************************/
 
-IndexRowwiseMinMaxFP16::IndexRowwiseMinMaxFP16(Index* index)
-        : IndexRowwiseMinMaxBase(index) {}
+IndexRowwiseMinMaxFP16::IndexRowwiseMinMaxFP16(Index* index_in)
+        : IndexRowwiseMinMaxBase(index_in) {}
 
 IndexRowwiseMinMaxFP16::IndexRowwiseMinMaxFP16() : IndexRowwiseMinMaxBase() {}
 
@@ -411,8 +412,8 @@ void IndexRowwiseMinMaxFP16::train_inplace(idx_t n, float* x) {
  * IndexRowwiseMinMax implementation
  ********************************************************/
 
-IndexRowwiseMinMax::IndexRowwiseMinMax(Index* index)
-        : IndexRowwiseMinMaxBase(index) {}
+IndexRowwiseMinMax::IndexRowwiseMinMax(Index* index_in)
+        : IndexRowwiseMinMaxBase(index_in) {}
 
 IndexRowwiseMinMax::IndexRowwiseMinMax() : IndexRowwiseMinMaxBase() {}
 

data/vendor/faiss/faiss/IndexRowwiseMinMax.h

@@ -43,7 +43,7 @@ struct IndexRowwiseMinMaxBase : Index {
     Index* index;
 
     /// whether the subindex needs to be freed in the destructor.
-    bool own_fields;
+    bool own_fields = false;
 
     explicit IndexRowwiseMinMaxBase(Index* index);