faiss 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08fc3bcca329e78e913982923c3fb3743e07591ffd717f5f3027e0609037b5de'
-  data.tar.gz: 2a1a79aeaef1756a974fe7e9c3448794496ef145046da39aae3b6ce04a9bf131
+  metadata.gz: 3f9b24e9b85c954d799a4c19009626bcd90b5071a0b05136a182030920150b5a
+  data.tar.gz: 1fe65e3ee60d8f77471b8dc6dc77354d7d7f9e7a81a4c12be909ca3ac75fcea1
 SHA512:
-  metadata.gz: 86e6528125608c64ab9bec3f289019cc0a4125e6719d8c43ca7e9f8eb09cb57ce42f9e040fd0290969f45f70fb25c789a50de7aceef07c38b0acb5ca5e674c49
-  data.tar.gz: 4efe37e9e855ab4da2e620e391ac817e6bfa808ca227ea047b55eaff4e7cfdae4c5af59d35b57963653d208e50334edc048fc168fd6d49f805cdb07d3dbc115e
+  metadata.gz: 277f548905897091a697479e256a79d2e2f9c56647be54921ea5fd6caec6381966dd859b58cdc0d09fb9da5670ef9a7248dd5ba487e50eef58f315e96d952986
+  data.tar.gz: 3a837ec44d583d6256f3490da8c6e17eec7e2a3854f4721826f6d03c4949e95163f6d67c70d7626d1b520a4b406fee9a3449b3d8fc7fbdd29fe5ff78dffd2e99

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.6.2 (2026-06-13)
+
+- Updated Faiss to 1.14.3
+
 ## 0.6.1 (2026-05-23)
 
 - Updated Faiss to 1.14.2

data/lib/faiss/version.rb

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

data/vendor/faiss/faiss/Index.h

@@ -17,7 +17,7 @@
 
 #define FAISS_VERSION_MAJOR 1
 #define FAISS_VERSION_MINOR 14
-#define FAISS_VERSION_PATCH 2
+#define FAISS_VERSION_PATCH 3
 
 // Macro to combine the version components into a single string
 #ifndef FAISS_STRINGIFY

data/vendor/faiss/faiss/IndexBinaryHNSW.cpp

@@ -36,7 +36,6 @@
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/binary_hamming/IndexBinaryHNSW_impl.h>
-#include <faiss/utils/hamming_distance/hamming_computer-generic.h>
 #undef THE_SIMD_LEVEL
 
 namespace faiss {
@@ -129,7 +128,7 @@ void hnsw_add_vertices(
 
 #pragma omp parallel
             {
-                VisitedTable vt(ntotal);
+                std::unique_ptr<VisitedTable> vt = VisitedTable::create(ntotal);
 
                 std::unique_ptr<DistanceComputer> dis(
                         index_hnsw.get_distance_computer());
@@ -147,7 +146,7 @@ void hnsw_add_vertices(
                             pt_level,
                             pt_id,
                             locks,
-                            vt,
+                            *vt,
                             index_hnsw.keep_max_size_level0 && (pt_level == 0));
 
                     if (do_display && i - i0 > prev_display + 10000) {
@@ -237,7 +236,7 @@ void IndexBinaryHNSW::search(
 
 #pragma omp parallel
     {
-        VisitedTable vt(ntotal);
+        std::unique_ptr<VisitedTable> vt = VisitedTable::create(ntotal);
         std::unique_ptr<DistanceComputer> dis(get_distance_computer());
         RH::SingleResultHandler res(bres);
 
@@ -249,7 +248,7 @@ void IndexBinaryHNSW::search(
             // as the index parameter. This state does not get used in the
             // search function, as it is merely there to enable Panorama
             // execution for IndexHNSWFlatPanorama.
-            HNSWStats stats = hnsw.search(*dis, nullptr, res, vt, params_in);
+            HNSWStats stats = hnsw.search(*dis, nullptr, res, *vt, params_in);
             n1 += stats.n1;
             n2 += stats.n2;
             ndis += stats.ndis;
@@ -377,7 +376,7 @@ void IndexBinaryHNSWCagra::search(
 
 #pragma omp parallel
         {
-            VisitedTable vt(ntotal);
+            std::unique_ptr<VisitedTable> vt = VisitedTable::create(ntotal);
             std::unique_ptr<DistanceComputer> dis(get_distance_computer());
             HNSWStats search_stats;
             RH::SingleResultHandler res(bres);
@@ -395,7 +394,7 @@ void IndexBinaryHNSWCagra::search(
                         &nearest_d[i],
                         1, // search_type
                         search_stats,
-                        vt,
+                        *vt,
                         params);
 
                 res.end();

data/vendor/faiss/faiss/IndexBinaryIVF.cpp

@@ -22,7 +22,6 @@
 #include <faiss/impl/AuxIndexStructures.h>
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/hamming.h>
-#include <faiss/utils/sorting.h>
 #include <faiss/utils/utils.h>
 
 #include <faiss/impl/simd_dispatch.h>
@@ -32,7 +31,6 @@
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/binary_hamming/IndexBinaryIVF_impl.h>
-#include <faiss/utils/hamming_distance/hamming_computer-generic.h>
 #undef THE_SIMD_LEVEL
 
 namespace faiss {
@@ -257,7 +255,9 @@ void IndexBinaryIVF::reconstruct_from_offset(
         idx_t list_no,
         idx_t offset,
         uint8_t* recons) const {
-    memcpy(recons, invlists->get_single_code(list_no, offset), code_size);
+    memcpy(recons,
+           InvertedLists::ScopedCodes(invlists, list_no, offset).get(),
+           code_size);
 }
 
 void IndexBinaryIVF::reset() {

data/vendor/faiss/faiss/IndexHNSW.cpp

@@ -47,12 +47,17 @@ HNSWStats hnsw_stats;
 
 namespace {
 
+// Returns the storage's native distance computer. For similarity metrics
+// (e.g. METRIC_INNER_PRODUCT), distance values are real similarity scores
+// (larger = better); HNSW handles the ordering via `hnsw.is_similarity`.
+//
+// NOTE: callers that drive the legacy max-heap-only code paths (notably
+// `search_from_candidates_2` in the IndexHNSW2Level mixed search) cannot
+// consume similarity scores directly; they assume smaller-is-better.
+// Those paths only fire for the (default) L2 IndexHNSW2Level + Index2Layer
+// configuration today, so passing the native DC is safe in practice.
 DistanceComputer* storage_distance_computer(const Index* storage) {
-    if (is_similarity_metric(storage->metric_type)) {
-        return new NegativeDistanceComputer(storage->get_distance_computer());
-    } else {
-        return storage->get_distance_computer();
-    }
+    return storage->get_distance_computer();
 }
 
 void hnsw_add_vertices(
@@ -145,7 +150,8 @@ void hnsw_add_vertices(
 
 #pragma omp parallel if (i1 > i0 + 100)
             {
-                VisitedTable vt(ntotal, hnsw.use_visited_hashset);
+                std::unique_ptr<VisitedTable> vt =
+                        VisitedTable::create(ntotal, hnsw.use_visited_hashset);
 
                 std::unique_ptr<DistanceComputer> dis(
                         storage_distance_computer(index_hnsw.storage));
@@ -171,7 +177,7 @@ void hnsw_add_vertices(
                             pt_level,
                             pt_id,
                             locks,
-                            vt,
+                            *vt,
                             index_hnsw.keep_max_size_level0 && (pt_level == 0));
 
                     if (do_display && i - i0 > prev_display + 10000) {
@@ -213,13 +219,16 @@ void hnsw_add_vertices(
  **************************************************************/
 
 IndexHNSW::IndexHNSW(int d_in, int M, MetricType metric)
-        : Index(d_in, metric), hnsw(M) {}
+        : Index(d_in, metric), hnsw(M) {
+    hnsw.is_similarity = is_similarity_metric(metric);
+}
 
 IndexHNSW::IndexHNSW(Index* storage_in, int M)
         : Index(storage_in->d, storage_in->metric_type),
           hnsw(M),
           storage(storage_in) {
     metric_arg = storage->metric_arg;
+    hnsw.is_similarity = is_similarity_metric(metric_type);
 }
 
 IndexHNSW::~IndexHNSW() {
@@ -276,7 +285,7 @@ void hnsw_search(
                     res;
             std::unique_ptr<DistanceComputer> dis;
             try {
-                vt = std::make_unique<VisitedTable>(
+                vt = VisitedTable::create(
                         index->ntotal, hnsw.use_visited_hashset);
                 res = std::make_unique<
                         typename BlockResultHandler::SingleResultHandler>(bres);
@@ -325,16 +334,14 @@ void IndexHNSW::search(
         const SearchParameters* params) const {
     FAISS_THROW_IF_NOT(k > 0);
 
-    using RH = HeapBlockResultHandler<HNSW::C>;
-    RH bres(n, distances, labels, k);
-
-    hnsw_search(this, n, x, bres, params);
-
     if (is_similarity_metric(this->metric_type)) {
-        // we need to revert the negated distances
-        for (idx_t i = 0; i < k * n; i++) {
-            distances[i] = -distances[i];
-        }
+        using RH = HeapBlockResultHandler<HNSW::C_similarity>;
+        RH bres(n, distances, labels, k);
+        hnsw_search(this, n, x, bres, params);
+    } else {
+        using RH = HeapBlockResultHandler<HNSW::C_distance>;
+        RH bres(n, distances, labels, k);
+        hnsw_search(this, n, x, bres, params);
     }
 }
 
@@ -344,16 +351,14 @@ void IndexHNSW::range_search(
         float radius,
         RangeSearchResult* result,
         const SearchParameters* params) const {
-    using RH = RangeSearchBlockResultHandler<HNSW::C>;
-    RH bres(result, is_similarity_metric(metric_type) ? -radius : radius);
-
-    hnsw_search(this, n, x, bres, params);
-
-    if (is_similarity_metric(this->metric_type)) {
-        // we need to revert the negated distances
-        for (size_t i = 0; i < result->lims[result->nq]; i++) {
-            result->distances[i] = -result->distances[i];
-        }
+    if (is_similarity_metric(metric_type)) {
+        using RH = RangeSearchBlockResultHandler<HNSW::C_similarity>;
+        RH bres(result, radius);
+        hnsw_search(this, n, x, bres, params);
+    } else {
+        using RH = RangeSearchBlockResultHandler<HNSW::C_distance>;
+        RH bres(result, radius);
+        hnsw_search(this, n, x, bres, params);
     }
 }
 
@@ -361,8 +366,13 @@ void IndexHNSW::search1(
         const float* x,
         ResultHandler& handler,
         SearchParameters* params) const {
-    SingleQueryBlockResultHandler<HNSW::C, false> bres(handler);
-    hnsw_search(this, 1, x, bres, params);
+    if (is_similarity_metric(metric_type)) {
+        SingleQueryBlockResultHandler<HNSW::C_similarity, false> bres(handler);
+        hnsw_search(this, 1, x, bres, params);
+    } else {
+        SingleQueryBlockResultHandler<HNSW::C_distance, false> bres(handler);
+        hnsw_search(this, 1, x, bres, params);
+    }
 }
 
 void IndexHNSW::add(idx_t n, const float* x) {
@@ -459,63 +469,64 @@ void IndexHNSW::search_level_0(
 
     size_t hnsw_ntotal = hnsw.levels.size();
 
-    using RH = HeapBlockResultHandler<HNSW::C>;
-    RH bres(n, distances, labels, k);
+    auto run = [&]<class C>() {
+        using RH = HeapBlockResultHandler<C>;
+        RH bres(n, distances, labels, k);
 
-    std::exception_ptr ex;
-    std::atomic<bool> interrupt{false};
+        std::exception_ptr ex;
+        std::atomic<bool> interrupt{false};
 #pragma omp parallel
-    {
-        std::unique_ptr<DistanceComputer> qdis;
-        HNSWStats search_stats;
-        std::unique_ptr<VisitedTable> vt;
-        std::unique_ptr<RH::SingleResultHandler> res;
-        try {
-            qdis.reset(storage_distance_computer(storage));
-            vt = std::make_unique<VisitedTable>(
-                    hnsw_ntotal, hnsw.use_visited_hashset);
-            res = std::make_unique<RH::SingleResultHandler>(bres);
-        } catch (...) {
-            omp_capture_exception(ex, [&] { interrupt = true; });
-        }
-
-#pragma omp for
-        for (idx_t i = 0; i < n; i++) {
-            if (interrupt.load(std::memory_order_relaxed)) {
-                continue;
-            }
+        {
+            std::unique_ptr<DistanceComputer> qdis;
+            HNSWStats search_stats;
+            std::unique_ptr<VisitedTable> vt;
+            std::unique_ptr<typename RH::SingleResultHandler> res;
             try {
-                res->begin(i);
-                qdis->set_query(x + i * d);
-
-                hnsw.search_level_0(
-                        *qdis.get(),
-                        *res,
-                        nprobe,
-                        nearest + i * nprobe,
-                        nearest_d + i * nprobe,
-                        search_type,
-                        search_stats,
-                        *vt,
-                        params);
-                res->end();
-                vt->advance();
+                qdis.reset(storage_distance_computer(storage));
+                vt = VisitedTable::create(
+                        hnsw_ntotal, hnsw.use_visited_hashset);
+                res = std::make_unique<typename RH::SingleResultHandler>(bres);
             } catch (...) {
                 omp_capture_exception(ex, [&] { interrupt = true; });
             }
-        }
+
+#pragma omp for
+            for (idx_t i = 0; i < n; i++) {
+                if (interrupt.load(std::memory_order_relaxed)) {
+                    continue;
+                }
+                try {
+                    res->begin(i);
+                    qdis->set_query(x + i * d);
+
+                    hnsw.search_level_0(
+                            *qdis.get(),
+                            *res,
+                            nprobe,
+                            nearest + i * nprobe,
+                            nearest_d + i * nprobe,
+                            search_type,
+                            search_stats,
+                            *vt,
+                            params);
+                    res->end();
+                    vt->advance();
+                } catch (...) {
+                    omp_capture_exception(ex, [&] { interrupt = true; });
+                }
+            }
 #pragma omp critical
-        {
-            hnsw_stats.combine(search_stats);
+            {
+                hnsw_stats.combine(search_stats);
+            }
         }
-    }
-    omp_rethrow_if_exception(ex);
+        omp_rethrow_if_exception(ex);
+    };
+
     if (is_similarity_metric(this->metric_type)) {
-// we need to revert the negated distances
-#pragma omp parallel for
-        for (int64_t i = 0; i < k * n; i++) {
-            distances[i] = -distances[i];
-        }
+        run.template operator()<HNSW::C_similarity>();
+    } else {
+        run.template operator()<HNSW::C_distance>();
     }
 }
 
@@ -569,7 +580,8 @@ void IndexHNSW::init_level_0_from_entry_points(
 
 #pragma omp parallel
     {
-        VisitedTable vt(ntotal, hnsw.use_visited_hashset);
+        std::unique_ptr<VisitedTable> vt =
+                VisitedTable::create(ntotal, hnsw.use_visited_hashset);
 
         std::unique_ptr<DistanceComputer> dis(
                 storage_distance_computer(storage));
@@ -583,7 +595,7 @@ void IndexHNSW::init_level_0_from_entry_points(
             dis->set_query(vec.data());
 
             hnsw.add_links_starting_from(
-                    *dis, pt_id, nearest, (*dis)(nearest), 0, locks, vt);
+                    *dis, pt_id, nearest, (*dis)(nearest), 0, locks, *vt);
 
             if (verbose && i % 10000 == 0) {
                 printf("  %d / %d\r", i, n);
@@ -824,7 +836,7 @@ int search_from_candidates_2(
         idx_t* I,
         float* D,
         MinimaxHeap& candidates,
-        VisitedTable& vt,
+        VisitedTableVector& vt,
         HNSWStats& stats,
         int level,
         int nres_in = 0) {
@@ -934,8 +946,7 @@ void IndexHNSW2Level::search(
             constexpr int candidates_size = 1;
             std::unique_ptr<MinimaxHeap> candidates;
             try {
-                vt = std::make_unique<VisitedTable>(
-                        ntotal, /*use_hashset=*/false);
+                vt = VisitedTable::create(ntotal, /*use_hashset=*/false);
                 dis.reset(storage_distance_computer(storage));
                 candidates = std::make_unique<MinimaxHeap>(candidates_size);
             } catch (...) {
@@ -987,7 +998,7 @@ void IndexHNSW2Level::search(
                             idxi,
                             simi,
                             *candidates,
-                            *vt,
+                            static_cast<VisitedTableVector&>(*vt),
                             search_stats,
                             0,
                             k);
@@ -1101,28 +1112,40 @@ void IndexHNSWCagra::search(
         std::vector<storage_idx_t> nearest(n);
         std::vector<float> nearest_d(n);
 
+        auto pick_entrypoints = [&]<class C>() {
 #pragma omp parallel for
-        for (idx_t i = 0; i < n; i++) {
-            std::unique_ptr<DistanceComputer> dis(
-                    storage_distance_computer(this->storage));
-            dis->set_query(x + i * d);
-            nearest[i] = -1;
-            nearest_d[i] = std::numeric_limits<float>::max();
-
-            std::random_device rd;
-            std::mt19937 gen(rd());
-            std::uniform_int_distribution<idx_t> distrib(0, this->ntotal - 1);
-
-            for (idx_t j = 0; j < num_base_level_search_entrypoints; j++) {
-                auto idx = distrib(gen);
-                auto distance = (*dis)(idx);
-                if (distance < nearest_d[i]) {
-                    nearest[i] = static_cast<storage_idx_t>(idx);
-                    nearest_d[i] = distance;
+            for (idx_t i = 0; i < n; i++) {
+                std::unique_ptr<DistanceComputer> dis(
+                        storage_distance_computer(this->storage));
+                dis->set_query(x + i * d);
+                nearest[i] = -1;
+                // C::neutral() is the "worst possible" value: +inf for
+                // CMax (distance) and -inf for CMin (similarity). The
+                // first real candidate will always be strictly better.
+                nearest_d[i] = C::neutral();
+
+                std::random_device rd;
+                std::mt19937 gen(rd());
+                std::uniform_int_distribution<idx_t> distrib(
+                        0, this->ntotal - 1);
+
+                for (idx_t j = 0; j < num_base_level_search_entrypoints; j++) {
+                    auto idx = distrib(gen);
+                    auto distance = (*dis)(idx);
+                    if (C::cmp(nearest_d[i], distance)) {
+                        nearest[i] = static_cast<storage_idx_t>(idx);
+                        nearest_d[i] = distance;
+                    }
                 }
+                FAISS_THROW_IF_NOT_MSG(
+                        nearest[i] >= 0, "Could not find a valid entrypoint.");
             }
-            FAISS_THROW_IF_NOT_MSG(
-                    nearest[i] >= 0, "Could not find a valid entrypoint.");
+        };
+
+        if (is_similarity_metric(metric_type)) {
+            pick_entrypoints.template operator()<HNSW::C_similarity>();
+        } else {
+            pick_entrypoints.template operator()<HNSW::C_distance>();
         }
 
         search_level_0(
@@ -1150,56 +1173,63 @@ void IndexHNSWCagra::range_search(
         return;
     }
 
-    const HNSW& hnsw = this->hnsw;
-    size_t n1 = 0, n2 = 0, ndis = 0, nhops = 0;
-    float threshold = is_similarity_metric(metric_type) ? -radius : radius;
-    RangeSearchPartialResult pres(result);
+    auto run = [&]<class C>() {
+        const HNSW& hnsw = this->hnsw;
+        size_t n1 = 0, n2 = 0, ndis = 0, nhops = 0;
+        RangeSearchPartialResult pres(result);
 
-    for (idx_t i = 0; i < n; i++) {
-        std::unique_ptr<DistanceComputer> dis(
-                storage_distance_computer(storage));
-        dis->set_query(x + i * d);
+        for (idx_t i = 0; i < n; i++) {
+            std::unique_ptr<DistanceComputer> dis(
+                    storage_distance_computer(storage));
+            dis->set_query(x + i * d);
 
-        storage_idx_t nearest = -1;
-        float nearest_d = std::numeric_limits<float>::max();
+            storage_idx_t nearest = -1;
+            // C::neutral() is the "worst possible" value under C: +inf for
+            // CMax (distance) and -inf for CMin (similarity). The first
+            // real candidate will always be strictly better.
+            float nearest_d = C::neutral();
 
-        std::random_device rd;
-        std::mt19937 gen(rd());
-        std::uniform_int_distribution<idx_t> distrib(0, ntotal - 1);
+            std::random_device rd;
+            std::mt19937 gen(rd());
+            std::uniform_int_distribution<idx_t> distrib(0, ntotal - 1);
 
-        for (idx_t j = 0; j < num_base_level_search_entrypoints; j++) {
-            auto idx = distrib(gen);
-            auto distance = (*dis)(idx);
-            if (distance < nearest_d) {
-                nearest = idx;
-                nearest_d = distance;
+            for (idx_t j = 0; j < num_base_level_search_entrypoints; j++) {
+                auto idx = distrib(gen);
+                auto distance = (*dis)(idx);
+                // C::cmp(nearest_d, distance) is true iff distance is
+                // strictly better than the current nearest_d.
+                if (C::cmp(nearest_d, distance)) {
+                    nearest = idx;
+                    nearest_d = distance;
+                }
             }
+            FAISS_THROW_IF_NOT_MSG(
+                    nearest >= 0, "Could not find a valid entrypoint.");
+
+            RangeQueryResult& qres = pres.new_result(i);
+            RangeResultHandler<C> res(&qres, radius);
+            std::unique_ptr<VisitedTable> vt =
+                    VisitedTable::create(ntotal, hnsw.use_visited_hashset);
+            HNSWStats stats;
+            hnsw.search_level_0(
+                    *dis, res, 1, &nearest, &nearest_d, 1, stats, *vt, params);
+            n1 += stats.n1;
+            n2 += stats.n2;
+            ndis += stats.ndis;
+            nhops += stats.nhops;
         }
-        FAISS_THROW_IF_NOT_MSG(
-                nearest >= 0, "Could not find a valid entrypoint.");
-
-        RangeQueryResult& qres = pres.new_result(i);
-        RangeResultHandler<HNSW::C> res(&qres, threshold);
-        VisitedTable vt(ntotal, hnsw.use_visited_hashset);
-        HNSWStats stats;
-        hnsw.search_level_0(
-                *dis, res, 1, &nearest, &nearest_d, 1, stats, vt, params);
-        n1 += stats.n1;
-        n2 += stats.n2;
-        ndis += stats.ndis;
-        nhops += stats.nhops;
-    }
 
-    pres.set_lims();
-    result->do_allocation();
-    pres.copy_result();
+        pres.set_lims();
+        result->do_allocation();
+        pres.copy_result();
 
-    hnsw_stats.combine({n1, n2, ndis, nhops});
+        hnsw_stats.combine({n1, n2, ndis, nhops});
+    };
 
     if (is_similarity_metric(metric_type)) {
-        for (size_t i = 0; i < result->lims[result->nq]; i++) {
-            result->distances[i] = -result->distances[i];
-        }
+        run.template operator()<HNSW::C_similarity>();
+    } else {
+        run.template operator()<HNSW::C_distance>();
     }
 }
 

data/vendor/faiss/faiss/IndexIVF.cpp

@@ -1223,7 +1223,7 @@ void IndexIVF::search_and_return_codes(
         } else {
             size_t list_no = lo_listno(key);
             size_t offset = lo_offset(key);
-            const uint8_t* cc = invlists->get_single_code(list_no, offset);
+            InvertedLists::ScopedCodes cc(invlists, list_no, offset);
 
             labels[ij] = invlists->get_single_id(list_no, offset);
 
@@ -1231,7 +1231,7 @@ void IndexIVF::search_and_return_codes(
                 encode_listno(list_no, code1);
                 code1 += code_size_1 - code_size;
             }
-            memcpy(code1, cc, code_size);
+            memcpy(code1, cc.get(), code_size);
         }
     }
 }

data/vendor/faiss/faiss/IndexIVFAdditiveQuantizer.cpp

@@ -145,8 +145,8 @@ void IndexIVFAdditiveQuantizer::reconstruct_from_offset(
         int64_t list_no,
         int64_t offset,
         float* recons) const {
-    const uint8_t* code = invlists->get_single_code(list_no, offset);
-    aq->decode(code, recons, 1);
+    InvertedLists::ScopedCodes sc(invlists, list_no, offset);
+    aq->decode(sc.get(), recons, 1);
     if (by_residual) {
         std::vector<float> centroid(d);
         quantizer->reconstruct(list_no, centroid.data());

data/vendor/faiss/faiss/IndexIVFFlat.cpp

@@ -164,7 +164,9 @@ void IndexIVFFlat::reconstruct_from_offset(
         int64_t list_no,
         int64_t offset,
         float* recons) const {
-    memcpy(recons, invlists->get_single_code(list_no, offset), code_size);
+    memcpy(recons,
+           InvertedLists::ScopedCodes(invlists, list_no, offset).get(),
+           code_size);
 }
 
 /*****************************************

data/vendor/faiss/faiss/IndexIVFFlatPanorama.cpp

@@ -194,9 +194,9 @@ void IndexIVFFlatPanorama::reconstruct_from_offset(
         int64_t list_no,
         int64_t offset,
         float* recons) const {
-    const uint8_t* code = invlists->get_single_code(list_no, offset);
-    memcpy(recons, code, code_size);
-    invlists->release_codes(list_no, code);
+    memcpy(recons,
+           InvertedLists::ScopedCodes(invlists, list_no, offset).get(),
+           code_size);
 }
 
 } // namespace faiss

data/vendor/faiss/faiss/IndexIVFPQ.cpp

@@ -341,9 +341,8 @@ void IndexIVFPQ::reconstruct_from_offset(
         int64_t list_no,
         int64_t offset,
         float* recons) const {
-    const uint8_t* code = invlists->get_single_code(list_no, offset);
-
-    pq.decode(code, recons);
+    InvertedLists::ScopedCodes sc(invlists, list_no, offset);
+    pq.decode(sc.get(), recons);
     if (by_residual) {
         std::vector<float> centroid(d);
         quantizer->reconstruct(list_no, centroid.data());

data/vendor/faiss/faiss/IndexIVFPQR.cpp

@@ -187,9 +187,8 @@ void IndexIVFPQR::search_preassigned(
                 quantizer->compute_residual(xq, residual_1.get(), list_no);
 
                 // 2nd level residual
-                const uint8_t* l2code = invlists->get_single_code(list_no, ofs);
-
-                pq.decode(l2code, residual_2);
+                InvertedLists::ScopedCodes l2sc(invlists, list_no, ofs);
+                pq.decode(l2sc.get(), residual_2);
                 for (int l = 0; l < d; l++) {
                     residual_2[l] = residual_1[l] - residual_2[l];
                 }