faiss 0.6.1 → 0.6.3

data/vendor/faiss/faiss/IndexPQ.cpp

@@ -107,7 +107,7 @@ void IndexPQ::search(
     if (iparams) {
         params = dynamic_cast<const SearchParametersPQ*>(iparams);
         FAISS_THROW_IF_NOT_MSG(params, "invalid search params");
-        FAISS_THROW_IF_NOT_MSG(!params->sel, "selector not supported");
+        FAISS_THROW_IF_MSG(params->sel, "selector not supported");
         param_search_type = params->search_type;
     }
 
@@ -459,7 +459,7 @@ struct SortedArray {
 
     void init(const T* x_2) {
         this->x = x_2;
-        FAISS_THROW_IF_NOT(!perm.empty());
+        FAISS_THROW_IF_MSG(perm.empty(), "permutation array must not be empty");
         for (int n = 0; n < N; n++) {
             perm[n] = n;
         }
@@ -543,7 +543,7 @@ struct SemiSortedArray {
 
     void init(const T* x_2) {
         this->x = x_2;
-        FAISS_THROW_IF_NOT(!perm.empty());
+        FAISS_THROW_IF_MSG(perm.empty(), "permutation array must not be empty");
         for (int n = 0; n < N; n++) {
             perm[n] = n;
         }
@@ -665,7 +665,7 @@ struct MinSumK {
 
     void mark_seen(int64_t i) {
         if (use_seen) {
-            FAISS_THROW_IF_NOT(!seen.empty());
+            FAISS_THROW_IF_MSG(seen.empty(), "seen bitmap must not be empty");
             seen[i >> 3] |= 1 << (i & 7);
         }
     }
@@ -795,8 +795,7 @@ void MultiIndexQuantizer::search(
         float* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     if (n == 0) {
         return;
     }
@@ -943,8 +942,7 @@ void MultiIndexQuantizer2::search(
         float* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
 
     if (n == 0) {
         return;

data/vendor/faiss/faiss/IndexPreTransform.cpp

@@ -229,6 +229,7 @@ size_t IndexPreTransform::remove_ids(const IDSelector& sel) {
 }
 
 void IndexPreTransform::reconstruct(idx_t key, float* recons) const {
+    FAISS_THROW_IF_NOT_MSG(index, "IndexPreTransform: null sub-index");
     float* x = chain.empty() ? recons : new float[index->d];
     std::unique_ptr<float[]> del(recons == x ? nullptr : x);
     // Initial reconstruction
@@ -239,6 +240,7 @@ void IndexPreTransform::reconstruct(idx_t key, float* recons) const {
 }
 
 void IndexPreTransform::reconstruct_n(idx_t i0, idx_t ni, float* recons) const {
+    FAISS_THROW_IF_NOT_MSG(index, "IndexPreTransform: null sub-index");
     float* x = chain.empty() ? recons : new float[ni * index->d];
     std::unique_ptr<float[]> del(recons == x ? nullptr : x);
     // Initial reconstruction
@@ -345,6 +347,19 @@ struct PreTransformDistanceComputer : DistanceComputer {
     float operator()(idx_t i) override {
         return (*sub_dc)(i);
     }
+
+    void distances_batch_4(
+            const idx_t idx0,
+            const idx_t idx1,
+            const idx_t idx2,
+            const idx_t idx3,
+            float& dis0,
+            float& dis1,
+            float& dis2,
+            float& dis3) override {
+        sub_dc->distances_batch_4(
+                idx0, idx1, idx2, idx3, dis0, dis1, dis2, dis3);
+    }
 };
 
 } // anonymous namespace

data/vendor/faiss/faiss/IndexRaBitQ.cpp

@@ -122,8 +122,8 @@ struct Run_search_with_dc_res {
                     // RaBitQuantizer.cpp for details.
                     auto* dc = dynamic_cast<RaBitQDistanceComputer*>(
                             dc_base.get());
-                    FAISS_THROW_IF_NOT_MSG(
-                            dc != nullptr,
+                    FAISS_THROW_IF_MSG(
+                            dc == nullptr,
                             "Failed to cast to RaBitQDistanceComputer for two-stage search");
 
                     bool is_similarity =

data/vendor/faiss/faiss/IndexRaBitQFastScan.cpp

@@ -512,8 +512,7 @@ void IndexRaBitQFastScan::search(
         float* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
 
     // Create query factors array on stack - memory managed by caller
     std::vector<rabitq_utils::QueryFactorsData> query_factors_storage(n);

data/vendor/faiss/faiss/IndexRaBitQFastScan.h

@@ -209,8 +209,12 @@ struct RaBitQHeapHandler
                 : 0;
 
         const size_t block_idx = base_db_idx / rabitq_index->bbs;
+        // aux_base points at this 32-lane sub-block's factors: the bbs block
+        // base plus the loop-invariant intra-block offset
+        // ((base_db_idx % bbs)). Only the per-element i term varies below.
         const uint8_t* aux_base = rabitq_index->codes.get() +
-                block_idx * full_block_size + packed_block_size;
+                block_idx * full_block_size + packed_block_size +
+                (base_db_idx % rabitq_index->bbs) * storage_size;
 
         for (size_t i = 0; i < max_vectors; i++) {
             const size_t db_idx = base_db_idx + i;

data/vendor/faiss/faiss/IndexRefine.cpp

@@ -156,7 +156,17 @@ void IndexRefine::range_search(
     SearchParameters* base_index_params =
             (params != nullptr) ? params->base_index_params : nullptr;
 
-    base_index->range_search(n, x, radius, result, base_index_params);
+    const float kf = (params != nullptr) ? params->k_factor : this->k_factor;
+
+    const bool is_similarity = is_similarity_metric(metric_type);
+
+    // Scale the base_index search radius by k_factor. Results are filtered to
+    // the exact radius below, so this only affects recall, not correctness; it
+    // is up to the user to pick a k_factor that widens the base search for
+    // their metric.
+    const float base_radius = radius * kf;
+
+    base_index->range_search(n, x, base_radius, result, base_index_params);
 
 #pragma omp parallel if (n > 1)
     {
@@ -177,6 +187,25 @@ void IndexRefine::range_search(
             }
         }
     }
+
+    // Exact filtering done here, as base index's approximations
+    // can fall outside the specified exact radius.
+    const std::vector<size_t> prev_lims(result->lims, result->lims + n + 1);
+    size_t wp = 0;
+    for (idx_t i = 0; i < n; i++) {
+        for (size_t j = prev_lims[i]; j < prev_lims[i + 1]; j++) {
+            const float dis = result->distances[j];
+            const bool within = is_similarity
+                    ? CMin<float, idx_t>::cmp(radius, dis)
+                    : CMax<float, idx_t>::cmp(radius, dis);
+            if (within) {
+                result->labels[wp] = result->labels[j];
+                result->distances[wp] = result->distances[j];
+                wp++;
+            }
+        }
+        result->lims[i + 1] = wp;
+    }
 }
 
 void IndexRefine::reconstruct(idx_t key, float* recons) const {

data/vendor/faiss/faiss/IndexReplicas.cpp

@@ -127,8 +127,7 @@ void IndexReplicasTemplate<IndexT>::search(
         distance_t* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT_MSG(this->count() > 0, "no replicas in index");
 

data/vendor/faiss/faiss/IndexScalarQuantizer.cpp

@@ -14,6 +14,9 @@
 
 #include <omp.h>
 
+#include <faiss/impl/ResultHandler.h>
+#include <faiss/impl/expanded_scanners.h>
+
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/IDSelector.h>
 #include <faiss/impl/ScalarQuantizer.h>
@@ -137,6 +140,9 @@ IndexIVFScalarQuantizer::IndexIVFScalarQuantizer(
         by_residual = false;
         is_trained = true; // no training needed
     }
+    if (ScalarQuantizer::TurboQuantRefine::is_turboq_full(qtype)) {
+        by_residual = false;
+    }
 }
 
 IndexIVFScalarQuantizer::IndexIVFScalarQuantizer() : IndexIVF() {
@@ -330,9 +336,65 @@ void IndexIVFScalarQuantizer::add_core(
 InvertedListScanner* IndexIVFScalarQuantizer::get_InvertedListScanner(
         bool store_pairs,
         const IDSelector* sel,
-        const IVFSearchParameters*) const {
-    return sq.select_InvertedListScanner(
-            metric_type, quantizer, store_pairs, sel, by_residual);
+        const IVFSearchParameters* search_params) const {
+    if (!ScalarQuantizer::TurboQuantRefine::is_turboq_full(sq.qtype)) {
+        return sq.select_InvertedListScanner(
+                metric_type, quantizer, store_pairs, sel, by_residual);
+    }
+
+    // TurboQ full types: create a TQ-specific scanner that supports
+    // search params (qb, int_qjl) and pre-screening.
+    uint8_t tq_qb = 0;
+    bool tq_int_qjl = false;
+    if (auto* tp = dynamic_cast<const IVFSQTurboQSearchParameters*>(
+                search_params)) {
+        tq_qb = tp->qb;
+        tq_int_qjl = tp->int_qjl;
+    }
+    using TurboQDC = ScalarQuantizer::TurboQuantRefine::DistanceComputer;
+    auto* dc = static_cast<TurboQDC*>(sq.get_distance_computer(metric_type));
+    dc->configure(tq_qb, tq_int_qjl);
+
+    struct TQScanner : InvertedListScanner {
+        std::unique_ptr<TurboQDC> dc;
+
+        explicit TQScanner(
+                TurboQDC* dc_in,
+                bool store_pairs_in,
+                const IDSelector* sel_in,
+                bool keep_max_in)
+                : InvertedListScanner(store_pairs_in, sel_in), dc(dc_in) {
+            this->keep_max = keep_max_in;
+        }
+
+        void set_query(const float* query) override {
+            dc->set_query(query);
+        }
+
+        void set_list(idx_t list_no_in, float) override {
+            this->list_no = list_no_in;
+        }
+
+        float distance_to_code(const uint8_t* code) const final {
+            return dc->distance_to_code(code);
+        }
+
+        size_t scan_codes(
+                size_t list_size,
+                const uint8_t* codes,
+                const idx_t* ids,
+                ResultHandler& handler) const override {
+            dc->set_prescreen_threshold(&handler.threshold, !keep_max);
+            size_t nup = run_scan_codes(*this, list_size, codes, ids, handler);
+            dc->clear_prescreen_threshold();
+            return nup;
+        }
+    };
+
+    auto* scanner = new TQScanner(
+            dc, store_pairs, sel, is_similarity_metric(metric_type));
+    scanner->code_size = code_size;
+    return scanner;
 }
 
 void IndexIVFScalarQuantizer::reconstruct_from_offset(
@@ -344,18 +406,18 @@ void IndexIVFScalarQuantizer::reconstruct_from_offset(
         quantizer->reconstruct(list_no, recons);
         return;
     }
-    const uint8_t* code = invlists->get_single_code(list_no, offset);
+    InvertedLists::ScopedCodes sc(invlists, list_no, offset);
 
     if (by_residual) {
         std::vector<float> centroid(d);
         quantizer->reconstruct(list_no, centroid.data());
 
-        sq.decode(code, recons, 1);
+        sq.decode(sc.get(), recons, 1);
         for (int i = 0; i < d; ++i) {
             recons[i] += centroid[i];
         }
     } else {
-        sq.decode(code, recons, 1);
+        sq.decode(sc.get(), recons, 1);
     }
 }
 

data/vendor/faiss/faiss/IndexScalarQuantizer.h

@@ -63,6 +63,16 @@ struct IndexScalarQuantizer : IndexFlatCodes {
  * distances are computed.
  */
 
+/// Search parameters for TurboQuant full types (QT_*_tq).
+struct IVFSQTurboQSearchParameters : IVFSearchParameters {
+    /// Query quantization bits for integer MSE pre-screening.
+    /// 0 = float path (default), 1-8 = integer popcount path.
+    uint8_t qb = 0;
+
+    /// Also use integer popcount for QJL stage (requires qb > 0).
+    bool int_qjl = false;
+};
+
 struct IndexIVFScalarQuantizer : IndexIVF {
     ScalarQuantizer sq;
 

data/vendor/faiss/faiss/IndexShards.cpp

@@ -143,8 +143,8 @@ void IndexShardsTemplate<IndexT>::add_with_ids(
             "request them to be shifted");
 
     if (successive_ids) {
-        FAISS_THROW_IF_NOT_MSG(
-                !xids,
+        FAISS_THROW_IF_MSG(
+                xids,
                 "It makes no sense to pass in ids and "
                 "request them to be shifted");
         FAISS_THROW_IF_NOT_MSG(

data/vendor/faiss/faiss/IndexShardsIVF.cpp

@@ -106,8 +106,8 @@ void IndexShardsIVF::add_with_ids(
             "request them to be shifted");
 
     if (successive_ids) {
-        FAISS_THROW_IF_NOT_MSG(
-                !xids,
+        FAISS_THROW_IF_MSG(
+                xids,
                 "It makes no sense to pass in ids and "
                 "request them to be shifted");
         FAISS_THROW_IF_NOT_MSG(

data/vendor/faiss/faiss/MetaIndexes.cpp

@@ -63,8 +63,7 @@ void IndexSplitVectors::search(
         float* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     FAISS_THROW_IF_NOT_MSG(k == 1, "search implemented only for k=1");
     FAISS_THROW_IF_NOT_MSG(
             sum_d == d, "not enough indexes compared to # dimensions");
@@ -187,8 +186,7 @@ void IndexRandom::search(
         float* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     FAISS_THROW_IF_NOT(k <= ntotal);
 #pragma omp parallel for if (n > 1000)
     for (idx_t i = 0; i < n; i++) {