faiss 0.6.1 → 0.6.2

data/vendor/faiss/faiss/IndexIVFRaBitQ.cpp

@@ -309,12 +309,12 @@ void IndexIVFRaBitQ::reconstruct_from_offset(
         int64_t list_no,
         int64_t offset,
         float* recons) const {
-    const uint8_t* code = invlists->get_single_code(list_no, offset);
+    InvertedLists::ScopedCodes sc(invlists, list_no, offset);
 
     std::vector<float> centroid(d);
     quantizer->reconstruct(list_no, centroid.data());
 
-    rabitq.decode_core(code, recons, 1, centroid.data());
+    rabitq.decode_core(sc.get(), recons, 1, centroid.data());
 }
 
 void IndexIVFRaBitQ::sa_decode(idx_t n, const uint8_t* codes, float* x) const {
@@ -357,26 +357,17 @@ float IVFRaBitDistanceComputer::operator()(idx_t i) {
     uint64_t list_no = lo_listno(lo);
     uint64_t offset = lo_offset(lo);
 
-    const uint8_t* code = parent->invlists->get_single_code(list_no, offset);
+    InvertedLists::ScopedCodes sc(parent->invlists, list_no, offset);
 
     // ok, we know the appropriate cluster that we need
     std::vector<float> centroid(parent->d);
     parent->quantizer->reconstruct(list_no, centroid.data());
 
-    // compute the distance
-    float distance = 0;
-
     std::unique_ptr<FlatCodesDistanceComputer> dc(
             parent->rabitq.get_distance_computer(
                     parent->qb, centroid.data(), /*centered=*/false));
     dc->set_query(q);
-    distance = dc->distance_to_code(code);
-
-    // deallocate
-    parent->invlists->release_codes(list_no, code);
-
-    // done
-    return distance;
+    return dc->distance_to_code(sc.get());
 }
 
 float IVFRaBitDistanceComputer::symmetric_dis(idx_t /*i*/, idx_t /*j*/) {

data/vendor/faiss/faiss/IndexNNDescent.cpp

@@ -126,7 +126,7 @@ void IndexNNDescent::search(
             std::unique_ptr<DistanceComputer> dis;
             std::unique_ptr<VisitedTable> vt;
             try {
-                vt = std::make_unique<VisitedTable>(ntotal);
+                vt = VisitedTable::create(ntotal);
                 dis.reset(storage_distance_computer(storage));
             } catch (...) {
                 omp_capture_exception(ex, [&] { interrupt = true; });

data/vendor/faiss/faiss/IndexNSG.cpp

@@ -81,8 +81,7 @@ void IndexNSG::search(
             std::unique_ptr<DistanceComputer> dis;
             std::unique_ptr<VisitedTable> vt;
             try {
-                vt = std::make_unique<VisitedTable>(
-                        ntotal, nsg.use_visited_hashset);
+                vt = VisitedTable::create(ntotal, nsg.use_visited_hashset);
                 dis.reset(storage_distance_computer(storage));
             } catch (...) {
                 omp_capture_exception(ex, [&] { interrupt = true; });

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/cppcontrib/SaDecodeKernels.h

@@ -313,7 +313,7 @@
 #ifdef __AVX2__
 #include <faiss/cppcontrib/sa_decode/Level2-avx2-inl.h>
 #include <faiss/cppcontrib/sa_decode/PQ-avx2-inl.h>
-#elif defined(__ARM_NEON)
+#elif defined(__ARM_NEON) || defined(__aarch64__)
 #include <faiss/cppcontrib/sa_decode/Level2-neon-inl.h>
 #include <faiss/cppcontrib/sa_decode/PQ-neon-inl.h>
 #else