faiss 0.6.2 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f9b24e9b85c954d799a4c19009626bcd90b5071a0b05136a182030920150b5a
-  data.tar.gz: 1fe65e3ee60d8f77471b8dc6dc77354d7d7f9e7a81a4c12be909ca3ac75fcea1
+  metadata.gz: 6a22f4ad8f3c626f1d6571c4cefcb8292965e52eb3b0b77c354f39ed117570c5
+  data.tar.gz: b848af534bebc2ecfdfa5fe7eaa270b530d17d5fe5381aea350451aa03c22d9f
 SHA512:
-  metadata.gz: 277f548905897091a697479e256a79d2e2f9c56647be54921ea5fd6caec6381966dd859b58cdc0d09fb9da5670ef9a7248dd5ba487e50eef58f315e96d952986
-  data.tar.gz: 3a837ec44d583d6256f3490da8c6e17eec7e2a3854f4721826f6d03c4949e95163f6d67c70d7626d1b520a4b406fee9a3449b3d8fc7fbdd29fe5ff78dffd2e99
+  metadata.gz: 4c5083b9733f589fc30c93f429ed4da74fbb4bbdbe2bde17787506cafb178e2715d114e04ed17bd21a1161a096df66a0c502ae6dc245455c1e221737e80a1f3e
+  data.tar.gz: 41eb8ce7434c4408fccf238893468e8c808b1961966a9fc495f960d27ff950d5d6a9cafff18a11e14287f5fedc77f83db9118c47c60e06fdc9f86d9987592c7c

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.6.4 (2026-09-17)
+
+- Updated Faiss to 1.15.1
+
+## 0.6.3 (2026-08-03)
+
+- Updated Faiss to 1.15.0
+
 ## 0.6.2 (2026-06-13)
 
 - Updated Faiss to 1.14.3

data/lib/faiss/version.rb

@@ -1,3 +1,3 @@
 module Faiss
-  VERSION = "0.6.2"
+  VERSION = "0.6.4"
 end

data/vendor/faiss/faiss/AutoTune.cpp

@@ -45,6 +45,8 @@ void AutoTuneCriterion::set_groundtruth(
         gt_D.resize(nq * gt_nnn_in);
         memcpy(gt_D.data(), gt_D_in, sizeof(gt_D[0]) * nq * gt_nnn_in);
     }
+    FAISS_THROW_IF_NOT_MSG(
+            gt_I_in != nullptr, "set_groundtruth: gt_I must be non-null");
     gt_I.resize(nq * gt_nnn_in);
     memcpy(gt_I.data(), gt_I_in, sizeof(gt_I[0]) * nq * gt_nnn_in);
 }
@@ -148,7 +150,7 @@ bool OperatingPoints::add(
     }
     // remove non-optimal points from array
     for (size_t i = a.size() - 1; i > 0; --i) {
-        if (a[i].t < a[i - 1].t) {
+        if (a[i].t <= a[i - 1].t) {
             a.erase(a.begin() + (i - 1));
         }
     }

data/vendor/faiss/faiss/Clustering.cpp

@@ -367,7 +367,7 @@ void Clustering::train_encoded(
                         ? std::numeric_limits<double>::max()
                         : std::abs(prev_obj - obj) / std::abs(prev_obj);
 
-                if (change >= 0 && change <= early_stop_threshold) {
+                if (change <= early_stop_threshold) {
                     if (verbose) {
                         printf("\n  Converged at iteration %d: "
                                "objective did not change\n",
@@ -439,6 +439,14 @@ float kmeans_clustering(
         size_t k,
         const float* x,
         float* centroids) {
+    FAISS_THROW_IF_NOT_FMT(
+            d <= static_cast<size_t>(std::numeric_limits<int>::max()),
+            "kmeans_clustering: d=%zu exceeds INT_MAX",
+            d);
+    FAISS_THROW_IF_NOT_FMT(
+            k <= static_cast<size_t>(std::numeric_limits<int>::max()),
+            "kmeans_clustering: k=%zu exceeds INT_MAX",
+            k);
     Clustering clus(static_cast<int>(d), static_cast<int>(k));
     clus.verbose = d * n * k > (size_t(1) << 30);
     // display logs if > 1Gflop per iteration

data/vendor/faiss/faiss/Clustering.h

@@ -75,6 +75,14 @@ struct ClusteringParameters {
     /// so the training process stops only if an error
     /// is unchanged from the previous iteration.
     double early_stop_threshold = 0.0;
+
+    /// Whether to use the SuperKMeans (super fast k-means) variant instead of
+    /// the vanilla Clustering implementation. Only honored by callers that
+    /// explicitly support it (e.g. IVF level-1 quantizer training). Cannot be
+    /// combined with a user-provided clustering index: SuperKMeans assigns
+    /// with its own index, so callers that supply both get an exception rather
+    /// than a silent downgrade to vanilla Clustering.
+    bool use_super_kmeans = false;
 };
 
 struct ClusteringIterationStats {

data/vendor/faiss/faiss/IVFlib.cpp

@@ -592,8 +592,12 @@ void handle_ivf(
                 static_cast<faiss::IndexIVF*>(faiss::clone_index(clone));
         if (generate_ids) {
             // Assume the quantizer does not natively support add_with_ids.
-            sharded_index->quantizer =
-                    new IndexIDMap2(sharded_index->quantizer);
+            // The IDMap wraps the cloned quantizer; own_fields makes it delete
+            // that quantizer when sharded_index (which owns the IDMap) is
+            // freed.
+            auto* id_quantizer = new IndexIDMap2(sharded_index->quantizer);
+            id_quantizer->own_fields = true;
+            sharded_index->quantizer = id_quantizer;
             sharded_index->quantizer->add_with_ids(
                     sharded_centroids[i].size() / index->quantizer->d,
                     sharded_centroids[i].data(),
@@ -615,6 +619,7 @@ void handle_ivf(
         faiss::write_index(sharded_index, fname);
         delete sharded_index;
     }
+    delete clone;
 }
 
 void handle_binary_ivf(
@@ -650,8 +655,13 @@ void handle_binary_ivf(
                 faiss::clone_binary_index(clone));
         if (generate_ids) {
             // Assume the quantizer does not natively support add_with_ids.
-            sharded_index->quantizer =
+            // The IDMap wraps the cloned quantizer; own_fields makes it delete
+            // that quantizer when sharded_index (which owns the IDMap) is
+            // freed.
+            auto* id_quantizer =
                     new IndexBinaryIDMap2(sharded_index->quantizer);
+            id_quantizer->own_fields = true;
+            sharded_index->quantizer = id_quantizer;
             sharded_index->quantizer->add_with_ids(
                     sharded_centroids[i].size() / reconstruction_size,
                     sharded_centroids[i].data(),
@@ -673,6 +683,7 @@ void handle_binary_ivf(
         faiss::write_index_binary(sharded_index, fname);
         delete sharded_index;
     }
+    delete clone;
 }
 
 template <typename IndexType>

data/vendor/faiss/faiss/Index.h

@@ -16,8 +16,8 @@
 #include <cstdio>
 
 #define FAISS_VERSION_MAJOR 1
-#define FAISS_VERSION_MINOR 14
-#define FAISS_VERSION_PATCH 3
+#define FAISS_VERSION_MINOR 15
+#define FAISS_VERSION_PATCH 1
 
 // Macro to combine the version components into a single string
 #ifndef FAISS_STRINGIFY

data/vendor/faiss/faiss/IndexAdditiveQuantizer.cpp

@@ -58,8 +58,8 @@ struct AQDistanceComputerDecompress : FlatCodesDistanceComputer {
     }
 
     float symmetric_dis(idx_t i, idx_t j) final {
-        aq.decode(codes + i * d, tmp.data(), 1);
-        aq.decode(codes + j * d, tmp.data() + d, 1);
+        aq.decode(codes + i * code_size, tmp.data(), 1);
+        aq.decode(codes + j * code_size, tmp.data() + d, 1);
         return vd(tmp.data(), tmp.data() + d);
     }
 
@@ -79,7 +79,8 @@ struct AQDistanceComputerLUT : FlatCodesDistanceComputer {
 
     explicit AQDistanceComputerLUT(const IndexAdditiveQuantizer& iaq)
             : FlatCodesDistanceComputer(iaq.codes.data(), iaq.code_size),
-              LUT(iaq.aq->total_codebook_size + iaq.d * 2),
+              LUT(iaq.aq->total_codebook_size // Storage for LUT.
+                  + size_t(iaq.d) * 2), // tmp storage for symmetric distance.
               aq(*iaq.aq),
               d(iaq.d) {}
 
@@ -96,9 +97,9 @@ struct AQDistanceComputerLUT : FlatCodesDistanceComputer {
     }
 
     float symmetric_dis(idx_t i, idx_t j) final {
-        float* tmp = LUT.data();
-        aq.decode(codes + i * d, tmp, 1);
-        aq.decode(codes + j * d, tmp + d, 1);
+        float* tmp = LUT.data() + aq.total_codebook_size;
+        aq.decode(codes + i * code_size, tmp, 1);
+        aq.decode(codes + j * code_size, tmp + d, 1);
         return fvec_L2sqr(tmp, tmp + d, d);
     }
 
@@ -234,8 +235,7 @@ void IndexAdditiveQuantizer::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 (aq->search_type == AdditiveQuantizer::ST_decompress) {
         with_VectorDistance(d, metric_type, metric_arg, [&](auto vd) {
@@ -458,8 +458,7 @@ void AdditiveCoarseQuantizer::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 (metric_type == METRIC_INNER_PRODUCT) {
         aq->knn_centroids_inner_product(n, x, k, distances, labels);

data/vendor/faiss/faiss/IndexAdditiveQuantizerFastScan.cpp

@@ -36,7 +36,7 @@ void IndexAdditiveQuantizerFastScan::init(
         MetricType metric,
         int bbs_) {
     FAISS_THROW_IF_NOT(aq_init != nullptr);
-    FAISS_THROW_IF_NOT(!aq_init->nbits.empty());
+    FAISS_THROW_IF_MSG(aq_init->nbits.empty(), "nbits must not be empty");
     FAISS_THROW_IF_NOT(aq_init->nbits[0] == 4);
     if (metric == METRIC_INNER_PRODUCT) {
         FAISS_THROW_IF_NOT_MSG(
@@ -192,8 +192,7 @@ void IndexAdditiveQuantizerFastScan::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 > 0);
     bool rescale = (rescale_norm && norm_scale > 1 && metric_type == METRIC_L2);
     if (!rescale) {

data/vendor/faiss/faiss/IndexBinaryFromFloat.cpp

@@ -9,9 +9,11 @@
 
 #include <faiss/IndexBinaryFromFloat.h>
 
+#include <faiss/MetricType.h>
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/utils.h>
 #include <algorithm>
+#include <cmath>
 #include <memory>
 
 namespace faiss {
@@ -55,8 +57,7 @@ void IndexBinaryFromFloat::search(
         int32_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);
 
     constexpr idx_t bs = 32768;
@@ -68,8 +69,27 @@ void IndexBinaryFromFloat::search(
         binary_to_real(bn * d, x + b * code_size, xf.get());
 
         index->search(bn, xf.get(), k, df.get(), labels + b * k);
-        for (int i = 0; i < bn * k; ++i) {
-            distances[b * k + i] = int32_t(std::round(df[i] / 4.0));
+        // binary_to_real maps bits to {-1, +1}, so the float distance relates
+        // to the Hamming distance differently for each metric. In all cases the
+        // mapping is monotonic, so the result order needs no adjustment.
+        switch (index->metric_type) {
+            case METRIC_INNER_PRODUCT:
+                for (int i = 0; i < bn * k; ++i) {
+                    distances[b * k + i] =
+                            int32_t(std::round((d - df[i]) / 2.0));
+                }
+                break;
+            case METRIC_L1:
+                for (int i = 0; i < bn * k; ++i) {
+                    distances[b * k + i] = int32_t(std::round(df[i] / 2.0));
+                }
+                break;
+            case METRIC_L2:
+            default:
+                for (int i = 0; i < bn * k; ++i) {
+                    distances[b * k + i] = int32_t(std::round(df[i] / 4.0));
+                }
+                break;
         }
     }
 }

data/vendor/faiss/faiss/IndexBinaryHNSW.cpp

@@ -7,7 +7,6 @@
 
 #include <faiss/IndexBinaryHNSW.h>
 
-#include <omp.h>
 #include <cassert>
 #include <cmath>
 #include <cstdio>
@@ -24,7 +23,6 @@
 #include <faiss/impl/ResultHandler.h>
 #include <faiss/impl/VisitedTable.h>
 #include <faiss/utils/Heap.h>
-#include <faiss/utils/hamming.h>
 #include <faiss/utils/random.h>
 
 #include <faiss/impl/simd_dispatch.h>
@@ -40,140 +38,6 @@
 
 namespace faiss {
 
-/**************************************************************
- * add / search blocks of descriptors
- **************************************************************/
-
-namespace {
-
-void hnsw_add_vertices(
-        IndexBinaryHNSW& index_hnsw,
-        size_t n0,
-        size_t n,
-        const uint8_t* x,
-        bool verbose,
-        bool preset_levels = false) {
-    HNSW& hnsw = index_hnsw.hnsw;
-    size_t ntotal = n0 + n;
-    double t0 = getmillisecs();
-    if (verbose) {
-        printf("hnsw_add_vertices: adding %zd elements on top of %zd "
-               "(preset_levels=%d)\n",
-               n,
-               n0,
-               int(preset_levels));
-    }
-
-    int max_level = hnsw.prepare_level_tab(n, preset_levels);
-
-    if (verbose) {
-        printf("  max_level = %d\n", max_level);
-    }
-
-    auto& locks = index_hnsw.locks;
-    locks.prepare(ntotal);
-
-    // add vectors from highest to lowest level
-    std::vector<int> hist;
-    std::vector<int> order(n);
-
-    { // make buckets with vectors of the same level
-
-        // build histogram
-        for (size_t i = 0; i < n; i++) {
-            HNSW::storage_idx_t pt_id =
-                    static_cast<HNSW::storage_idx_t>(i + n0);
-            int pt_level = hnsw.levels[pt_id] - 1;
-            while (pt_level >= static_cast<int>(hist.size())) {
-                hist.push_back(0);
-            }
-            hist[pt_level]++;
-        }
-
-        // accumulate
-        std::vector<int> offsets(hist.size() + 1, 0);
-        for (size_t i = 0; i < hist.size() - 1; i++) {
-            offsets[i + 1] = offsets[i] + hist[i];
-        }
-
-        // bucket sort
-        for (size_t i = 0; i < n; i++) {
-            HNSW::storage_idx_t pt_id =
-                    static_cast<HNSW::storage_idx_t>(i + n0);
-            int pt_level = hnsw.levels[pt_id] - 1;
-            order[offsets[pt_level]++] = pt_id;
-        }
-    }
-
-    { // perform add
-        RandomGenerator rng2(789);
-
-        size_t i1 = static_cast<int>(n);
-
-        for (int pt_level = static_cast<int>(hist.size()) - 1;
-             pt_level >= int(!index_hnsw.init_level0);
-             pt_level--) {
-            size_t i0 = i1 - hist[pt_level];
-
-            if (verbose) {
-                printf("Adding %zu elements at level %d\n", i1 - i0, pt_level);
-            }
-
-            // random permutation to get rid of dataset order bias
-            for (size_t j = i0; j < i1; j++) {
-                std::swap(
-                        order[j],
-                        order[j + rng2.rand_int(static_cast<int>(i1 - j))]);
-            }
-
-#pragma omp parallel
-            {
-                std::unique_ptr<VisitedTable> vt = VisitedTable::create(ntotal);
-
-                std::unique_ptr<DistanceComputer> dis(
-                        index_hnsw.get_distance_computer());
-                bool do_display = verbose && omp_get_thread_num() == 0;
-                size_t prev_display = 0;
-
-#pragma omp for schedule(dynamic)
-                for (int64_t i = i0; i < i1; i++) {
-                    HNSW::storage_idx_t pt_id = order[i];
-                    dis->set_query(
-                            (float*)(x + (pt_id - n0) * index_hnsw.code_size));
-
-                    hnsw.add_with_locks(
-                            *dis,
-                            pt_level,
-                            pt_id,
-                            locks,
-                            *vt,
-                            index_hnsw.keep_max_size_level0 && (pt_level == 0));
-
-                    if (do_display && i - i0 > prev_display + 10000) {
-                        prev_display = i - i0;
-                        printf("  %zu / %zu\r", i - i0, i1 - i0);
-                        fflush(stdout);
-                    }
-                }
-            }
-            i1 = i0;
-        }
-        if (index_hnsw.init_level0) {
-            FAISS_ASSERT(i1 == 0);
-        } else {
-            FAISS_ASSERT((i1 - hist[0]) == 0);
-        }
-    }
-    if (verbose) {
-        printf("Done in %.3f ms\n", getmillisecs() - t0);
-    }
-    if (!index_hnsw.retain_locks) {
-        locks.clear();
-    }
-}
-
-} // anonymous namespace
-
 /**************************************************************
  * IndexBinaryHNSW implementation
  **************************************************************/
@@ -271,18 +135,25 @@ void IndexBinaryHNSW::add(idx_t n, const uint8_t* x) {
     storage->add(n, x);
     ntotal = storage->ntotal;
 
-    hnsw_add_vertices(
-            *this,
+    bool preset_levels = hnsw.levels.size() == static_cast<size_t>(ntotal);
+
+    hnsw_add_vertices_deterministic(
+            hnsw,
             n0,
             n,
-            x,
+            d,
+            init_level0,
+            keep_max_size_level0,
+            preset_levels,
             verbose,
-            hnsw.levels.size() == static_cast<size_t>(ntotal));
+            [this] { return get_distance_computer(); },
+            [this, x, n0](DistanceComputer& dc, HNSW::storage_idx_t pt_id) {
+                dc.set_query((const float*)(x + (pt_id - n0) * code_size));
+            });
 }
 
 void IndexBinaryHNSW::reset() {
     hnsw.reset();
-    locks.clear();
     storage->reset();
     ntotal = 0;
 }
@@ -293,8 +164,8 @@ void IndexBinaryHNSW::reconstruct(idx_t key, uint8_t* recons) const {
 
 DistanceComputer* IndexBinaryHNSW::get_distance_computer() const {
     IndexBinaryFlat* flat_storage = dynamic_cast<IndexBinaryFlat*>(storage);
-    FAISS_THROW_IF_NOT_MSG(
-            flat_storage != nullptr,
+    FAISS_THROW_IF_MSG(
+            flat_storage == nullptr,
             "IndexBinaryHNSW requires IndexBinaryFlat storage");
     return with_simd_level([&]<SIMDLevel SL>() {
         return make_binary_hnsw_distance_computer_fixSL<SL>(
@@ -317,8 +188,8 @@ IndexBinaryHNSWCagra::IndexBinaryHNSWCagra(int d_, int M)
 }
 
 void IndexBinaryHNSWCagra::add(idx_t n, const uint8_t* x) {
-    FAISS_THROW_IF_NOT_MSG(
-            !base_level_only,
+    FAISS_THROW_IF_MSG(
+            base_level_only,
             "Cannot add vectors when base_level_only is set to True");
 
     IndexBinaryHNSW::add(n, x);

data/vendor/faiss/faiss/IndexBinaryHNSW.h

@@ -11,7 +11,6 @@
 
 #include <faiss/IndexBinaryFlat.h>
 #include <faiss/impl/HNSW.h>
-#include <faiss/impl/hnsw/LockVector.h>
 #include <faiss/utils/utils.h>
 
 namespace faiss {
@@ -41,11 +40,6 @@ struct IndexBinaryHNSW : IndexBinary {
     // used when GpuIndexBinaryCagra::copyFrom(IndexBinaryHNSW*) is called.
     bool keep_max_size_level0 = false;
 
-    // Per-node locks for HNSW graph construction.
-    LockVector locks;
-    // locks are freed after each call to add() unless this flag is set.
-    bool retain_locks = false;
-
     explicit IndexBinaryHNSW();
     explicit IndexBinaryHNSW(int d, int M = 32);
     explicit IndexBinaryHNSW(IndexBinary* storage, int M = 32);

data/vendor/faiss/faiss/IndexBinaryHash.cpp

@@ -27,7 +27,7 @@
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/binary_hamming/IndexBinaryHash_impl.h>
-#include <faiss/utils/hamming_distance/hamming_computer-generic.h>
+#include <faiss/utils/hamming_distance/hamming_computer-generic.h> // IWYU pragma: keep
 #undef THE_SIMD_LEVEL
 
 namespace faiss {
@@ -83,8 +83,7 @@ void IndexBinaryHash::range_search(
         int radius,
         RangeSearchResult* result,
         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");
     size_t nlist = 0, ndis = 0, n0 = 0;
 
 #pragma omp parallel if (n > 100) reduction(+ : ndis, n0, nlist)
@@ -116,8 +115,7 @@ void IndexBinaryHash::search(
         int32_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);
 
     using HeapForL2 = CMax<int32_t, idx_t>;
@@ -216,8 +214,7 @@ void IndexBinaryMultiHash::range_search(
         int radius,
         RangeSearchResult* result,
         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");
     size_t nlist = 0, ndis = 0, n0 = 0;
 
 #pragma omp parallel if (n > 100) reduction(+ : ndis, n0, nlist)
@@ -249,8 +246,7 @@ void IndexBinaryMultiHash::search(
         int32_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);
 
     using HeapForL2 = CMax<int32_t, idx_t>;

data/vendor/faiss/faiss/IndexBinaryIVF.cpp

@@ -192,7 +192,7 @@ void IndexBinaryIVF::reconstruct_n(idx_t i0, idx_t ni, uint8_t* recons) const {
                 continue;
             }
 
-            uint8_t* reconstructed = recons + (id - i0) * d;
+            uint8_t* reconstructed = recons + (id - i0) * code_size;
             reconstruct_from_offset(list_no, offset, reconstructed);
         }
     }
@@ -206,8 +206,7 @@ void IndexBinaryIVF::search_and_reconstruct(
         idx_t* __restrict labels,
         uint8_t* __restrict recons,
         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");
     const size_t nprobe_2 = std::min(nlist, this->nprobe);
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(nprobe_2 > 0);
@@ -234,10 +233,10 @@ void IndexBinaryIVF::search_and_reconstruct(
         for (idx_t j = 0; j < k; ++j) {
             idx_t ij = i * k + j;
             idx_t key = labels[ij];
-            uint8_t* reconstructed = recons + ij * d;
+            uint8_t* reconstructed = recons + ij * code_size;
             if (key < 0) {
                 // Fill with NaNs
-                memset(reconstructed, -1, sizeof(*reconstructed) * d);
+                memset(reconstructed, -1, code_size);
             } else {
                 int list_no = key >> 32;
                 int offset = key & 0xffffffff;
@@ -349,10 +348,6 @@ void IndexBinaryIVF::replace_invlists(InvertedLists* il, bool own) {
     own_invlists = own;
 }
 
-// IVFBinaryScannerL2, search_knn_hamming_count, BlockSearch,
-// BlockSearchVariableK, search_knn_hamming_per_invlist are now in
-// impl/binary_hamming/IndexBinaryIVF_impl.h (compiled per-ISA)
-
 namespace {
 
 void search_knn_hamming_heap(
@@ -462,13 +457,9 @@ void search_knn_hamming_heap(
 
 } // anonymous namespace
 
-// The remaining template code (search_knn_hamming_count,
-// search_knn_hamming_per_invlist, etc.) has been moved to
-// impl/binary_hamming/IndexBinaryIVF_impl.h
-
 BinaryInvertedListScanner* IndexBinaryIVF::get_InvertedListScanner(
         bool store_pairs) const {
-    return with_simd_level([&]<SIMDLevel SL>() {
+    return with_simd_level_with_vpopcnt([&]<SIMDLevel SL>() {
         return make_binary_ivf_scanner_fixSL<SL>(code_size, store_pairs);
     });
 }
@@ -484,7 +475,7 @@ void IndexBinaryIVF::search_preassigned(
         bool store_pairs,
         const IVFSearchParameters* params) const {
     if (per_invlist_search) {
-        with_simd_level([&]<SIMDLevel SL>() {
+        with_simd_level_with_vpopcnt([&]<SIMDLevel SL>() {
             search_knn_hamming_per_invlist_fixSL<SL>(
                     code_size,
                     this,
@@ -502,7 +493,7 @@ void IndexBinaryIVF::search_preassigned(
         search_knn_hamming_heap(
                 this, n, x, k, cidx, cdis, dis, idx, store_pairs, params);
     } else {
-        with_simd_level([&]<SIMDLevel SL>() {
+        with_simd_level_with_vpopcnt([&]<SIMDLevel SL>() {
             search_knn_hamming_count_fixSL<SL>(
                     code_size,
                     store_pairs,
@@ -524,8 +515,7 @@ void IndexBinaryIVF::range_search(
         int radius,
         RangeSearchResult* __restrict res,
         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");
     const size_t nprobe_2 = std::min(nlist, this->nprobe);
     std::unique_ptr<idx_t[]> idx(new idx_t[n * nprobe_2]);
     std::unique_ptr<int32_t[]> coarse_dis(new int32_t[n * nprobe_2]);

data/vendor/faiss/faiss/IndexBinaryIVF.h

@@ -232,7 +232,14 @@ struct BinaryInvertedListScanner {
     virtual uint32_t distance_to_code(const uint8_t* code) const = 0;
 
     /** compute the distances to codes. (distances, labels) should be
-     * organized as a min- or max-heap
+     * organized as a max-heap: the scan accepts a code whose distance is
+     * below distances[0] and replaces the top. A min-heap caller reads its
+     * neutral value as a huge unsigned bound and gets wrong results.
+
+     *
+     * The heap top is the only bound. To keep the k nearest codes inside a
+     * radius, seed every heap slot with that radius instead of the neutral
+     * value; an unfilled slot keeps its label of -1.
      *
      * @param n      number of codes to scan
      * @param codes  codes to scan (n * code_size)