faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/IndexPQFastScan.cpp

@@ -9,8 +9,8 @@
 
 #include <memory>
 
-#include <faiss/impl/FastScanDistancePostProcessing.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/utils.h>
 
 namespace faiss {
@@ -20,25 +20,27 @@ inline size_t roundup(size_t a, size_t b) {
 }
 
 IndexPQFastScan::IndexPQFastScan(
-        int d,
-        size_t M,
-        size_t nbits,
+        int d_in,
+        size_t M_in,
+        size_t nbits_in,
         MetricType metric,
-        int bbs)
-        : pq(d, M, nbits) {
-    init_fastscan(d, M, nbits, metric, bbs);
+        int bbs_in)
+        : pq(d_in, M_in, nbits_in) {
+    init_fastscan(d_in, M_in, nbits_in, metric, bbs_in);
 }
 
-IndexPQFastScan::IndexPQFastScan(const IndexPQ& orig, int bbs) : pq(orig.pq) {
-    init_fastscan(orig.d, pq.M, pq.nbits, orig.metric_type, bbs);
+IndexPQFastScan::IndexPQFastScan(const IndexPQ& orig, int bbs_in)
+        : pq(orig.pq) {
+    init_fastscan(orig.d, pq.M, pq.nbits, orig.metric_type, bbs_in);
     ntotal = orig.ntotal;
-    ntotal2 = roundup(ntotal, bbs);
+    ntotal2 = roundup(ntotal, bbs_in);
     is_trained = orig.is_trained;
     orig_codes = orig.codes.data();
 
     // pack the codes
     codes.resize(ntotal2 * M2 / 2);
-    pq4_pack_codes(orig.codes.data(), ntotal, M, ntotal2, bbs, M2, codes.get());
+    pq4_pack_codes(
+            orig.codes.data(), ntotal, M, ntotal2, bbs_in, M2, codes.get());
 }
 
 void IndexPQFastScan::train(idx_t n, const float* x) {
@@ -49,9 +51,9 @@ void IndexPQFastScan::train(idx_t n, const float* x) {
     is_trained = true;
 }
 
-void IndexPQFastScan::compute_codes(uint8_t* codes, idx_t n, const float* x)
+void IndexPQFastScan::compute_codes(uint8_t* out_codes, idx_t n, const float* x)
         const {
-    pq.compute_codes(x, codes, n);
+    pq.compute_codes(x, out_codes, n);
 }
 
 void IndexPQFastScan::compute_float_LUT(
@@ -70,4 +72,8 @@ void IndexPQFastScan::sa_decode(idx_t n, const uint8_t* bytes, float* x) const {
     pq.decode(bytes, x, n);
 }
 
+size_t IndexPQFastScan::fast_scan_code_size() const {
+    return M2 / 2;
+}
+
 } // namespace faiss

data/vendor/faiss/faiss/IndexPQFastScan.h

@@ -52,6 +52,9 @@ struct IndexPQFastScan : IndexFastScan {
             const FastScanDistancePostProcessing& context) const override;
 
     void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
+
+    /// Packed code size: M2 / 2 bytes (4-bit PQ sub-quantizer nibbles)
+    size_t fast_scan_code_size() const override;
 };
 
 } // namespace faiss

data/vendor/faiss/faiss/IndexPreTransform.cpp

@@ -26,16 +26,20 @@ namespace faiss {
 
 IndexPreTransform::IndexPreTransform() : index(nullptr), own_fields(false) {}
 
-IndexPreTransform::IndexPreTransform(Index* index)
-        : Index(index->d, index->metric_type), index(index), own_fields(false) {
-    is_trained = index->is_trained;
-    ntotal = index->ntotal;
+IndexPreTransform::IndexPreTransform(Index* index_in)
+        : Index(index_in->d, index_in->metric_type),
+          index(index_in),
+          own_fields(false) {
+    is_trained = index_in->is_trained;
+    ntotal = index_in->ntotal;
 }
 
-IndexPreTransform::IndexPreTransform(VectorTransform* ltrans, Index* index)
-        : Index(index->d, index->metric_type), index(index), own_fields(false) {
-    is_trained = index->is_trained;
-    ntotal = index->ntotal;
+IndexPreTransform::IndexPreTransform(VectorTransform* ltrans, Index* index_in)
+        : Index(index_in->d, index_in->metric_type),
+          index(index_in),
+          own_fields(false) {
+    is_trained = index_in->is_trained;
+    ntotal = index_in->ntotal;
     prepend_transform(ltrans);
 }
 
@@ -48,7 +52,7 @@ void IndexPreTransform::prepend_transform(VectorTransform* ltrans) {
 
 IndexPreTransform::~IndexPreTransform() {
     if (own_fields) {
-        for (int i = 0; i < chain.size(); i++) {
+        for (size_t i = 0; i < chain.size(); i++) {
             delete chain[i];
         }
         delete index;
@@ -58,9 +62,9 @@ IndexPreTransform::~IndexPreTransform() {
 void IndexPreTransform::train(idx_t n, const float* x) {
     int last_untrained = 0;
     if (!index->is_trained) {
-        last_untrained = chain.size();
+        last_untrained = static_cast<int>(chain.size());
     } else {
-        for (int i = chain.size() - 1; i >= 0; i--) {
+        for (int i = static_cast<int>(chain.size()) - 1; i >= 0; i--) {
             if (!chain[i]->is_trained) {
                 last_untrained = i;
                 break;
@@ -76,7 +80,7 @@ void IndexPreTransform::train(idx_t n, const float* x) {
     }
 
     for (int i = 0; i <= last_untrained; i++) {
-        if (i < chain.size()) {
+        if (i < static_cast<int>(chain.size())) {
             VectorTransform* ltrans = chain[i];
             if (!ltrans->is_trained) {
                 if (verbose) {
@@ -119,13 +123,15 @@ const float* IndexPreTransform::apply_chain(idx_t n, const float* x) const {
     const float* prev_x = x;
     std::unique_ptr<const float[]> del;
 
-    for (int i = 0; i < chain.size(); i++) {
+    for (size_t i = 0; i < chain.size(); i++) {
         float* xt = chain[i]->apply(n, prev_x);
         std::unique_ptr<const float[]> del2(xt);
         del2.swap(del);
         prev_x = xt;
     }
-    del.release();
+    // Intentionally release ownership: caller takes ownership of the returned
+    // buffer
+    (void)del.release();
     return prev_x;
 }
 
@@ -134,7 +140,7 @@ void IndexPreTransform::reverse_chain(idx_t n, const float* xt, float* x)
     const float* next_x = xt;
     std::unique_ptr<const float[]> del;
 
-    for (int i = chain.size() - 1; i >= 0; i--) {
+    for (int i = static_cast<int>(chain.size()) - 1; i >= 0; i--) {
         float* prev_x = (i == 0) ? x : new float[n * chain[i]->d_in];
         std::unique_ptr<const float[]> del2((prev_x == x) ? nullptr : prev_x);
         chain[i]->reverse_transform(n, next_x, prev_x);
@@ -305,7 +311,7 @@ void IndexPreTransform::check_compatible_for_merge(
     auto other = dynamic_cast<const IndexPreTransform*>(&otherIndex);
     FAISS_THROW_IF_NOT(other);
     FAISS_THROW_IF_NOT(chain.size() == other->chain.size());
-    for (int i = 0; i < chain.size(); i++) {
+    for (size_t i = 0; i < chain.size(); i++) {
         chain[i]->check_identical(*other->chain[i]);
     }
     index->check_compatible_for_merge(*other->index);
@@ -318,8 +324,9 @@ struct PreTransformDistanceComputer : DistanceComputer {
     std::unique_ptr<DistanceComputer> sub_dc;
     std::unique_ptr<const float[]> query;
 
-    explicit PreTransformDistanceComputer(const IndexPreTransform* index)
-            : index(index), sub_dc(index->index->get_distance_computer()) {}
+    explicit PreTransformDistanceComputer(const IndexPreTransform* index_in)
+            : index(index_in),
+              sub_dc(index_in->index->get_distance_computer()) {}
 
     void set_query(const float* x) override {
         const float* xt = index->apply_chain(1, x);

data/vendor/faiss/faiss/IndexPreTransform.h

@@ -26,7 +26,7 @@ struct IndexPreTransform : Index {
     std::vector<VectorTransform*> chain; ///! chain of transforms
     Index* index;                        ///! the sub-index
 
-    bool own_fields; ///! whether pointers are deleted in destructor
+    bool own_fields = false; ///! whether pointers are deleted in destructor
 
     explicit IndexPreTransform(Index* index);
 

data/vendor/faiss/faiss/IndexRaBitQ.cpp

@@ -21,8 +21,8 @@ using rabitq_utils::SignBitFactorsWithError;
 
 IndexRaBitQ::IndexRaBitQ() = default;
 
-IndexRaBitQ::IndexRaBitQ(idx_t d, MetricType metric, uint8_t nb_bits_in)
-        : IndexFlatCodes(0, d, metric), rabitq(d, metric, nb_bits_in) {
+IndexRaBitQ::IndexRaBitQ(idx_t d_in, MetricType metric, uint8_t nb_bits_in)
+        : IndexFlatCodes(0, d_in, metric), rabitq(d_in, metric, nb_bits_in) {
     // Update code size based on nb_bits
     code_size = rabitq.code_size;
 
@@ -32,14 +32,14 @@ IndexRaBitQ::IndexRaBitQ(idx_t d, MetricType metric, uint8_t nb_bits_in)
 void IndexRaBitQ::train(idx_t n, const float* x) {
     // compute a centroid
     std::vector<float> centroid(d, 0);
-    for (size_t i = 0; i < n; i++) {
-        for (size_t j = 0; j < d; j++) {
+    for (idx_t i = 0; i < n; i++) {
+        for (size_t j = 0; j < static_cast<size_t>(d); j++) {
             centroid[j] += x[i * d + j];
         }
     }
 
     if (n != 0) {
-        for (size_t j = 0; j < d; j++) {
+        for (size_t j = 0; j < static_cast<size_t>(d); j++) {
             centroid[j] /= (float)n;
         }
     }
@@ -70,10 +70,10 @@ FlatCodesDistanceComputer* IndexRaBitQ::get_FlatCodesDistanceComputer() const {
 }
 
 FlatCodesDistanceComputer* IndexRaBitQ::get_quantized_distance_computer(
-        const uint8_t qb,
-        bool centered) const {
+        const uint8_t qb_in,
+        bool centered_in) const {
     FlatCodesDistanceComputer* dc =
-            rabitq.get_distance_computer(qb, center.data(), centered);
+            rabitq.get_distance_computer(qb_in, center.data(), centered_in);
     dc->code_size = rabitq.code_size;
     dc->codes = codes.data();
     return dc;
@@ -102,19 +102,12 @@ struct Run_search_with_dc_res {
                     index->get_quantized_distance_computer(qb, centered));
             SingleResultHandler resi(res);
 #pragma omp for
-            for (int64_t q = 0; q < res.nq; q++) {
+            for (int64_t q = 0; q < static_cast<int64_t>(res.nq); q++) {
                 resi.begin(q);
                 dc_base->set_query(xq + d * q);
 
-                // Stats tracking for multi-bit two-stage search only
-                // n_1bit_evaluations: candidates evaluated using 1-bit lower
-                // bound n_multibit_evaluations: candidates requiring full
-                // multi-bit distance
-                size_t local_1bit_evaluations = 0;
-                size_t local_multibit_evaluations = 0;
-
                 if (ex_bits == 0) {
-                    // 1-bit: Standard single-stage search (no stats tracking)
+                    // 1-bit: Standard single-stage search
                     for (size_t i = 0; i < ntotal; i++) {
                         if (res.is_in_selection(i)) {
                             float dis = (*dc_base)(i);
@@ -133,7 +126,6 @@ struct Run_search_with_dc_res {
                             dc != nullptr,
                             "Failed to cast to RaBitQDistanceComputer for two-stage search");
 
-                    // Use appropriate comparison based on metric type
                     bool is_similarity =
                             is_similarity_metric(index->metric_type);
 
@@ -142,16 +134,9 @@ struct Run_search_with_dc_res {
                             const uint8_t* code =
                                     index->codes.data() + i * index->code_size;
 
-                            local_1bit_evaluations++;
-
-                            // Stage 1: Compute distance bound using 1-bit codes
-                            // For L2 (min-heap): use lower_bound (est -
-                            // error) For IP (max-heap): use upper_bound (est
-                            // + error)
                             float est_distance =
                                     dc->distance_to_code_1bit(code);
 
-                            // Extract f_error for filtering
                             size_t code_size_base = (index->d + 7) / 8;
                             const rabitq_utils::SignBitFactorsWithError*
                                     base_fac = reinterpret_cast<
@@ -159,7 +144,6 @@ struct Run_search_with_dc_res {
                                                     SignBitFactorsWithError*>(
                                             code + code_size_base);
 
-                            // Stage 2: Adaptive filtering
                             bool should_refine =
                                     rabitq_utils::should_refine_candidate(
                                             est_distance,
@@ -168,8 +152,6 @@ struct Run_search_with_dc_res {
                                             resi.threshold,
                                             is_similarity);
                             if (should_refine) {
-                                local_multibit_evaluations++;
-                                // Compute full multi-bit distance
                                 float dist_full =
                                         dc->distance_to_code_full(code);
                                 resi.add_result(dist_full, i);
@@ -178,13 +160,6 @@ struct Run_search_with_dc_res {
                     }
                 }
 
-                // Update global stats atomically
-#pragma omp atomic
-                rabitq_stats.n_1bit_evaluations += local_1bit_evaluations;
-#pragma omp atomic
-                rabitq_stats.n_multibit_evaluations +=
-                        local_multibit_evaluations;
-
                 resi.end();
             }
         }
@@ -224,7 +199,7 @@ void IndexRaBitQ::search(
 }
 
 void IndexRaBitQ::range_search(
-        idx_t n,
+        idx_t /*n*/,
         const float* x,
         float radius,
         RangeSearchResult* result,

data/vendor/faiss/faiss/IndexRaBitQ.h

@@ -8,7 +8,6 @@
 #pragma once
 
 #include <faiss/IndexFlatCodes.h>
-#include <faiss/impl/RaBitQStats.h>
 #include <faiss/impl/RaBitQuantizer.h>
 
 namespace faiss {
@@ -26,6 +25,8 @@ struct IndexRaBitQ : IndexFlatCodes {
 
     // the default number of bits to quantize a query with.
     // use '0' to disable quantization and use raw fp32 values.
+    // Note: qb=0 is NOT supported by FastScan variants, which require
+    // quantized queries for SIMD lookup table construction.
     uint8_t qb = 4;
 
     // quantize the query with a zero-centered scalar quantizer.