faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/invlists/InvertedLists.h

@@ -28,6 +28,24 @@ struct InvertedListsIterator {
     virtual bool is_available() const = 0;
     virtual void next() = 0;
     virtual std::pair<idx_t, const uint8_t*> get_id_and_codes() = 0;
+
+    /// When true, iterate_codes will invoke on_distance_computed() and
+    /// on_heap_changed() via virtual dispatch. When false (the default),
+    /// iterate_codes skips the callbacks entirely — the guard branch is
+    /// perfectly predicted and costs ~0 cycles, so non-callback users
+    /// pay no overhead. Derived classes that override the callbacks
+    /// should set this to true in their constructor.
+    bool has_search_callbacks_ = false;
+
+    /// Called from iterate_codes after distance computation for the vector
+    /// returned by the most recent get_id_and_codes(). Default: no-op.
+    /// Only invoked when has_search_callbacks_ is true.
+    virtual void on_distance_computed(idx_t /* vid */, float /* distance */) {}
+
+    /// Called from iterate_codes when a vector replaces the current worst
+    /// in the top-K heap. evicted_id is the displaced entry. Default: no-op.
+    /// Only invoked when has_search_callbacks_ is true.
+    virtual void on_heap_changed(idx_t /* new_id */, idx_t /* evicted_id */) {}
 };
 
 /** Table of inverted lists
@@ -44,7 +62,7 @@ struct InvertedLists {
     /// request to use iterator rather than get_codes / get_ids
     bool use_iterator = false;
 
-    InvertedLists(size_t nlist, size_t code_size);
+    InvertedLists(size_t nlist_, size_t code_size_);
 
     virtual ~InvertedLists();
 
@@ -87,7 +105,7 @@ struct InvertedLists {
 
     /// prepare the following lists (default does nothing)
     /// a list can be -1 hence the signed long
-    virtual void prefetch_lists(const idx_t* list_nos, int nlist) const;
+    virtual void prefetch_lists(const idx_t* list_nos, int nlist_in) const;
 
     /*****************************************
      * Iterator interface (with context)     */
@@ -203,8 +221,8 @@ struct InvertedLists {
         const idx_t* ids;
         size_t list_no;
 
-        ScopedIds(const InvertedLists* il, size_t list_no)
-                : il(il), ids(il->get_ids(list_no)), list_no(list_no) {}
+        ScopedIds(const InvertedLists* il_, size_t list_no_)
+                : il(il_), ids(il_->get_ids(list_no_)), list_no(list_no_) {}
 
         const idx_t* get() {
             return ids;
@@ -224,13 +242,13 @@ struct InvertedLists {
         const uint8_t* codes;
         size_t list_no;
 
-        ScopedCodes(const InvertedLists* il, size_t list_no)
-                : il(il), codes(il->get_codes(list_no)), list_no(list_no) {}
+        ScopedCodes(const InvertedLists* il_, size_t list_no_)
+                : il(il_), codes(il_->get_codes(list_no_)), list_no(list_no_) {}
 
-        ScopedCodes(const InvertedLists* il, size_t list_no, size_t offset)
-                : il(il),
-                  codes(il->get_single_code(list_no, offset)),
-                  list_no(list_no) {}
+        ScopedCodes(const InvertedLists* il_, size_t list_no_, size_t offset)
+                : il(il_),
+                  codes(il_->get_single_code(list_no_, offset)),
+                  list_no(list_no_) {}
 
         const uint8_t* get() {
             return codes;
@@ -247,7 +265,7 @@ struct ArrayInvertedLists : InvertedLists {
     std::vector<MaybeOwnedVector<uint8_t>> codes; // binary codes, size nlist
     std::vector<MaybeOwnedVector<idx_t>> ids; ///< Inverted lists for indexes
 
-    ArrayInvertedLists(size_t nlist, size_t code_size);
+    ArrayInvertedLists(size_t nlist_in, size_t code_size_in);
 
     size_t list_size(size_t list_no) const override;
     const uint8_t* get_codes(size_t list_no) const override;
@@ -280,13 +298,16 @@ struct ArrayInvertedLists : InvertedLists {
 /// Level-oriented storage as defined in the IVFFlat section of Panorama
 /// (https://www.arxiv.org/pdf/2510.00566).
 struct ArrayInvertedListsPanorama : ArrayInvertedLists {
-    static constexpr size_t kBatchSize = 128;
     std::vector<MaybeOwnedVector<float>> cum_sums;
     const size_t n_levels;
     const size_t level_width; // in code units
     Panorama pano;
 
-    ArrayInvertedListsPanorama(size_t nlist, size_t code_size, size_t n_levels);
+    ArrayInvertedListsPanorama(
+            size_t nlist_in,
+            size_t code_size_in,
+            size_t n_levels_in,
+            size_t batch_size = Panorama::kDefaultBatchSize);
 
     const float* get_cum_sums(size_t list_no) const;
 
@@ -319,7 +340,7 @@ struct ArrayInvertedListsPanorama : ArrayInvertedLists {
             const override;
 
     /// Frees codes returned by `get_single_code`.
-    void release_codes(size_t list_no, const uint8_t* codes) const override;
+    void release_codes(size_t list_no, const uint8_t* codes_in) const override;
 };
 
 /*****************************************************************
@@ -331,8 +352,8 @@ struct ArrayInvertedListsPanorama : ArrayInvertedLists {
 
 /// invlists that fail for all write functions
 struct ReadOnlyInvertedLists : InvertedLists {
-    ReadOnlyInvertedLists(size_t nlist, size_t code_size)
-            : InvertedLists(nlist, code_size) {}
+    ReadOnlyInvertedLists(size_t nlist_, size_t code_size_)
+            : InvertedLists(nlist_, code_size_) {}
 
     size_t add_entries(
             size_t list_no,
@@ -361,7 +382,7 @@ struct HStackInvertedLists : ReadOnlyInvertedLists {
     const uint8_t* get_codes(size_t list_no) const override;
     const idx_t* get_ids(size_t list_no) const override;
 
-    void prefetch_lists(const idx_t* list_nos, int nlist) const override;
+    void prefetch_lists(const idx_t* list_nos, int nlist_in) const override;
 
     void release_codes(size_t list_no, const uint8_t* codes) const override;
     void release_ids(size_t list_no, const idx_t* ids) const override;
@@ -379,7 +400,7 @@ struct SliceInvertedLists : ReadOnlyInvertedLists {
     const InvertedLists* il;
     idx_t i0, i1;
 
-    SliceInvertedLists(const InvertedLists* il, idx_t i0, idx_t i1);
+    SliceInvertedLists(const InvertedLists* il_, idx_t i0_, idx_t i1_);
 
     size_t list_size(size_t list_no) const override;
     const uint8_t* get_codes(size_t list_no) const override;
@@ -393,7 +414,7 @@ struct SliceInvertedLists : ReadOnlyInvertedLists {
     const uint8_t* get_single_code(size_t list_no, size_t offset)
             const override;
 
-    void prefetch_lists(const idx_t* list_nos, int nlist) const override;
+    void prefetch_lists(const idx_t* list_nos, int nlist_in) const override;
 };
 
 struct VStackInvertedLists : ReadOnlyInvertedLists {
@@ -415,7 +436,7 @@ struct VStackInvertedLists : ReadOnlyInvertedLists {
     const uint8_t* get_single_code(size_t list_no, size_t offset)
             const override;
 
-    void prefetch_lists(const idx_t* list_nos, int nlist) const override;
+    void prefetch_lists(const idx_t* list_nos, int nlist_in) const override;
 };
 
 /** use the first inverted lists if they are non-empty otherwise use the second
@@ -427,7 +448,9 @@ struct MaskedInvertedLists : ReadOnlyInvertedLists {
     const InvertedLists* il0;
     const InvertedLists* il1;
 
-    MaskedInvertedLists(const InvertedLists* il0, const InvertedLists* il1);
+    MaskedInvertedLists(
+            const InvertedLists* il0_in,
+            const InvertedLists* il1_in);
 
     size_t list_size(size_t list_no) const override;
     const uint8_t* get_codes(size_t list_no) const override;
@@ -441,7 +464,7 @@ struct MaskedInvertedLists : ReadOnlyInvertedLists {
     const uint8_t* get_single_code(size_t list_no, size_t offset)
             const override;
 
-    void prefetch_lists(const idx_t* list_nos, int nlist) const override;
+    void prefetch_lists(const idx_t* list_nos, int nlist_in) const override;
 };
 
 /** if the inverted list in il is smaller than maxsize then return it,
@@ -450,7 +473,7 @@ struct StopWordsInvertedLists : ReadOnlyInvertedLists {
     const InvertedLists* il0;
     size_t maxsize;
 
-    StopWordsInvertedLists(const InvertedLists* il, size_t maxsize);
+    StopWordsInvertedLists(const InvertedLists* il0_in, size_t maxsize_in);
 
     size_t list_size(size_t list_no) const override;
     const uint8_t* get_codes(size_t list_no) const override;
@@ -461,10 +484,50 @@ struct StopWordsInvertedLists : ReadOnlyInvertedLists {
 
     idx_t get_single_id(size_t list_no, size_t offset) const override;
 
+    const uint8_t* get_single_code(size_t list_no, size_t offset)
+            const override;
+
+    void prefetch_lists(const idx_t* list_nos, int nlist_in) const override;
+};
+
+/** Cap list sizes to maxsize for searching, while allowing writes.
+ *  Unlike StopWordsInvertedLists which skips large lists entirely,
+ *  this caps each list to maxsize entries (partial scan). */
+struct CappedInvertedLists : InvertedLists {
+    InvertedLists* il0;
+    size_t maxsize;
+
+    CappedInvertedLists(InvertedLists* il, size_t maxsize);
+
+    size_t list_size(size_t list_no) const override;
+    size_t real_list_size(size_t list_no) const;
+
+    const uint8_t* get_codes(size_t list_no) const override;
+    const idx_t* get_ids(size_t list_no) const override;
+
+    void release_codes(size_t list_no, const uint8_t* codes) const override;
+    void release_ids(size_t list_no, const idx_t* ids) const override;
+
+    idx_t get_single_id(size_t list_no, size_t offset) const override;
     const uint8_t* get_single_code(size_t list_no, size_t offset)
             const override;
 
     void prefetch_lists(const idx_t* list_nos, int nlist) const override;
+
+    size_t add_entries(
+            size_t list_no,
+            size_t n_entry,
+            const idx_t* ids,
+            const uint8_t* code) override;
+
+    void update_entries(
+            size_t list_no,
+            size_t offset,
+            size_t n_entry,
+            const idx_t* ids,
+            const uint8_t* code) override;
+
+    void resize(size_t list_no, size_t new_size) override;
 };
 
 } // namespace faiss

data/vendor/faiss/faiss/invlists/InvertedListsIOHook.cpp

@@ -24,9 +24,9 @@ namespace faiss {
  **********************************************************/
 
 InvertedListsIOHook::InvertedListsIOHook(
-        const std::string& key,
-        const std::string& classname)
-        : key(key), classname(classname) {}
+        const std::string& key_in,
+        const std::string& classname_in)
+        : key(key_in), classname(classname_in) {}
 
 namespace {
 
@@ -52,7 +52,7 @@ static IOHookTable InvertedListsIOHook_table;
 
 InvertedListsIOHook* InvertedListsIOHook::lookup(int h) {
     for (const auto& callback : InvertedListsIOHook_table) {
-        if (h == fourcc(callback->key)) {
+        if (static_cast<uint32_t>(h) == fourcc(callback->key)) {
             return callback;
         }
     }

data/vendor/faiss/faiss/invlists/OnDiskInvertedLists.cpp

@@ -111,7 +111,7 @@ struct LockLevels {
         level3_in_use = true;
         // wait until there are no level1 holders anymore except the
         // ones that are waiting on level2 (we are holding lock2)
-        while (level1_holders.size() > n_level2) {
+        while (level1_holders.size() > static_cast<size_t>(n_level2)) {
             pthread_cond_wait(&level3_cv, &mutex1);
         }
         // don't release the lock!
@@ -161,7 +161,7 @@ struct OnDiskInvertedLists::OngoingPrefetch {
                 cs += idx[i];
             }
             const idx_t* codes8 = (const idx_t*)codes;
-            idx_t n8 = n * od->code_size / 8;
+            size_t n8 = n * od->code_size / 8;
 
             for (size_t i = 0; i < n8; i++) {
                 cs += codes8[i];
@@ -187,7 +187,7 @@ struct OnDiskInvertedLists::OngoingPrefetch {
 
     const OnDiskInvertedLists* od;
 
-    explicit OngoingPrefetch(const OnDiskInvertedLists* od) : od(od) {
+    explicit OngoingPrefetch(const OnDiskInvertedLists* od_in) : od(od_in) {
         pthread_mutex_init(&mutex, nullptr);
         pthread_mutex_init(&list_ids_mutex, nullptr);
         cur_list = 0;
@@ -206,7 +206,7 @@ struct OnDiskInvertedLists::OngoingPrefetch {
     idx_t get_next_list() {
         idx_t list_no = -1;
         pthread_mutex_lock(&list_ids_mutex);
-        if (cur_list >= 0 && cur_list < list_ids.size()) {
+        if (cur_list >= 0 && static_cast<size_t>(cur_list) < list_ids.size()) {
             list_no = list_ids[cur_list++];
         }
         pthread_mutex_unlock(&list_ids_mutex);
@@ -341,17 +341,17 @@ void OnDiskInvertedLists::update_totsize(size_t new_size) {
 
 OnDiskOneList::OnDiskOneList() : size(0), capacity(0), offset(INVALID_OFFSET) {}
 
-OnDiskInvertedLists::Slot::Slot(size_t offset, size_t capacity)
-        : offset(offset), capacity(capacity) {}
+OnDiskInvertedLists::Slot::Slot(size_t offset_in, size_t capacity_in)
+        : offset(offset_in), capacity(capacity_in) {}
 
 OnDiskInvertedLists::Slot::Slot() : offset(0), capacity(0) {}
 
 OnDiskInvertedLists::OnDiskInvertedLists(
-        size_t nlist,
-        size_t code_size,
-        const char* filename)
-        : InvertedLists(nlist, code_size),
-          filename(filename),
+        size_t nlist_in,
+        size_t code_size_in,
+        const char* filename_in)
+        : InvertedLists(nlist_in, code_size_in),
+          filename(filename_in),
           totsize(0),
           ptr(nullptr),
           read_only(false),
@@ -607,7 +607,7 @@ size_t OnDiskInvertedLists::merge_from_multiple(
     double t0 = getmillisecs(), last_t = t0;
 
 #pragma omp parallel for
-    for (size_t j = 0; j < nlist; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(nlist); j++) {
         List& l = lists[j];
         for (int i = 0; i < n_il; i++) {
             const InvertedLists* il = ils[i];
@@ -660,7 +660,7 @@ size_t OnDiskInvertedLists::merge_from_1(
 }
 
 void OnDiskInvertedLists::crop_invlists(size_t l0, size_t l1) {
-    FAISS_THROW_IF_NOT(0 <= l0 && l0 <= l1 && l1 <= nlist);
+    FAISS_THROW_IF_NOT(l0 <= l1 && l1 <= nlist);
 
     std::vector<List> new_lists(l1 - l0);
     memcpy(new_lists.data(), &lists[l0], (l1 - l0) * sizeof(List));

data/vendor/faiss/faiss/invlists/OnDiskInvertedLists.h

@@ -113,7 +113,7 @@ struct OnDiskInvertedLists : InvertedLists {
     /// restrict the inverted lists to l0:l1 without touching the mmapped region
     void crop_invlists(size_t l0, size_t l1);
 
-    void prefetch_lists(const idx_t* list_nos, int nlist) const override;
+    void prefetch_lists(const idx_t* list_nos, int nlist_in) const override;
 
     ~OnDiskInvertedLists() override;
 

data/vendor/faiss/faiss/svs/IndexSVSFaissUtils.h

@@ -54,7 +54,7 @@ inline svs_runtime::MetricType to_svs_metric(faiss::MetricType metric) {
         case METRIC_L2:
             return svs_runtime::MetricType::L2;
         default:
-            FAISS_ASSERT(false && "not supported SVS distance");
+            FAISS_THROW_MSG("not supported SVS distance");
     }
 }
 

data/vendor/faiss/faiss/svs/IndexSVSFlat.cpp

@@ -107,11 +107,11 @@ void IndexSVSFlat::serialize_impl(std::ostream& out) const {
 void IndexSVSFlat::deserialize_impl(std::istream& in) {
     FAISS_THROW_IF_MSG(impl, "Cannot deserialize: SVS index already loaded.");
     auto metric = to_svs_metric(metric_type);
-    auto status = impl->load(&impl, in, metric);
+    auto status = svs_runtime::FlatIndex::load(&impl, in, metric);
     if (!status.ok()) {
         FAISS_THROW_MSG(status.message());
     }
-    FAISS_THROW_IF_NOT(impl);
+    FAISS_THROW_IF_NOT_MSG(impl, "Failed to load SVS Flat index.");
 }
 
 } // namespace faiss