faiss 0.6.1 → 0.6.3

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

@@ -405,7 +405,8 @@ void OnDiskInvertedLists::update_entries(
         size_t n_entry,
         const idx_t* ids_in,
         const uint8_t* codes_in) {
-    FAISS_THROW_IF_NOT(!read_only);
+    FAISS_THROW_IF_MSG(
+            read_only, "cannot modify a read-only OnDiskInvertedLists");
     if (n_entry == 0) {
         return;
     }
@@ -422,7 +423,8 @@ size_t OnDiskInvertedLists::add_entries(
         size_t n_entry,
         const idx_t* ids,
         const uint8_t* code) {
-    FAISS_THROW_IF_NOT(!read_only);
+    FAISS_THROW_IF_MSG(
+            read_only, "cannot modify a read-only OnDiskInvertedLists");
     locks->lock_1(list_no);
     size_t o = list_size(list_no);
     resize_locked(list_no, n_entry + o);
@@ -432,7 +434,8 @@ size_t OnDiskInvertedLists::add_entries(
 }
 
 void OnDiskInvertedLists::resize(size_t list_no, size_t new_size) {
-    FAISS_THROW_IF_NOT(!read_only);
+    FAISS_THROW_IF_MSG(
+            read_only, "cannot modify a read-only OnDiskInvertedLists");
     locks->lock_1(list_no);
     resize_locked(list_no, new_size);
     locks->unlock_1(list_no);
@@ -799,7 +802,19 @@ InvertedLists* OnDiskInvertedListsIOHook::read_ArrayInvertedLists(
         OnDiskInvertedLists::List& l = ails->lists[i];
         l.size = l.capacity = sizes[i];
         l.offset = o;
-        o += l.size * (sizeof(idx_t) + ails->code_size);
+        size_t elem_size = add_no_overflow(
+                sizeof(idx_t), ails->code_size, "OnDisk inverted list element");
+        size_t list_bytes =
+                mul_no_overflow(l.size, elem_size, "OnDisk inverted list");
+        o = add_no_overflow(o, list_bytes, "OnDisk inverted list offset");
+        FAISS_THROW_IF_NOT_FMT(
+                o <= ails->totsize,
+                "inverted list %zu at offset %zu with %zu bytes exceeds "
+                "mapped file size %zu",
+                i,
+                l.offset,
+                list_bytes,
+                ails->totsize);
     }
     // resume normal reading of file
     fseek(fdesc, o, SEEK_SET);

data/vendor/faiss/faiss/python/python_callbacks.cpp

@@ -151,7 +151,9 @@ int64_t PyCallbackShardingFunction::operator()(int64_t i, int64_t shard_count) {
     if (shard_id == nullptr) {
         FAISS_THROW_MSG("propagate py error");
     }
-    return PyLong_AsLongLong(shard_id);
+    int64_t rv = PyLong_AsLongLong(shard_id);
+    Py_DECREF(shard_id);
+    return rv;
 }
 
 PyCallbackShardingFunction::~PyCallbackShardingFunction() {

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

@@ -30,6 +30,7 @@
 #include <faiss/impl/AuxIndexStructures.h>
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/IDSelector.h>
+#include <faiss/impl/mapped_io.h>
 
 #include <algorithm>
 #include <concepts>
@@ -248,4 +249,63 @@ struct FaissResultsAllocator : public svs_runtime::ResultsAllocator {
     using LabelsConverter = OutputBufferConverter<size_t, faiss::idx_t>;
     mutable LabelsConverter labels_converter;
 };
+
+// Helper for memory-mapped SVS index loading.
+// Acquires a pointer to the remaining mapped region and returns the data
+// pointer, size in bytes, and starting position. Validates that mmap returns
+// expected byte count. MappedFileIOReader::mmap returns number of items (not
+// bytes); we always request size=1 so items == bytes, but we name variables
+// explicitly to avoid confusion.
+struct MmapSpan {
+    void* data = nullptr;
+    size_t size_bytes = 0;
+    size_t start_pos = 0;
+};
+
+inline MmapSpan acquire_mmap_span(MappedFileIOReader* mf) {
+    FAISS_THROW_IF_NOT(mf);
+    FAISS_THROW_IF_NOT(mf->mmap_owner);
+    size_t pos = mf->pos;
+    size_t size_to_end = mf->mmap_owner->size() - pos;
+    // Reject an empty span: MappedFileIOReader::mmap() returns 0 without
+    // writing *ptr when no bytes remain, which would otherwise pass the
+    // size check below and hand a nullptr / zero size to the SVS runtime
+    // (e.g. for a truncated or corrupt file).
+    FAISS_THROW_IF_NOT_FMT(
+            size_to_end > 0,
+            "acquire_mmap_span: no mapped bytes remain at reader position %zu",
+            pos);
+    void* data = nullptr;
+    // mmap returns actual_nitems; with size=1 this equals bytes
+    size_t actual_nitems = mf->mmap(&data, 1, size_to_end);
+    FAISS_THROW_IF_NOT_FMT(
+            actual_nitems == size_to_end,
+            "mmap() returned unexpected size: %zu items (expected %zu bytes)",
+            actual_nitems,
+            size_to_end);
+    return {data, size_to_end, pos};
+}
+
+// Adjusts MappedFileIOReader position after SVS consumes read_bytes,
+// storing mmap_owner reference to keep mapping alive.
+inline void finalize_mmap_span(
+        MappedFileIOReader* mf,
+        const MmapSpan& span,
+        size_t read_bytes,
+        std::shared_ptr<MmappedFileMappingOwner>& mmap_owner_out) {
+    // Take ownership of the mapping BEFORE validating read_bytes. By this point
+    // the caller's impl already holds pointers into the mapped region, so the
+    // index must keep the mapping alive even on the throw path. Otherwise the
+    // index would be left with a live impl but no mmap_owner, and once the
+    // reader's mapping reference is released the index destructor (which calls
+    // destroy(impl)) would touch unmapped memory.
+    mmap_owner_out = mf->mmap_owner;
+    FAISS_THROW_IF_NOT_FMT(
+            read_bytes > 0 && read_bytes <= span.size_bytes,
+            "map_to_memory returned invalid read_bytes: %zu (span size %zu)",
+            read_bytes,
+            span.size_bytes);
+    mf->pos = span.start_pos + read_bytes;
+}
+
 } // namespace faiss

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

@@ -22,6 +22,7 @@
  */
 
 #include <faiss/Index.h>
+#include <faiss/impl/mapped_io.h>
 #include <faiss/svs/IndexSVSFaissUtils.h>
 #include <faiss/svs/IndexSVSFlat.h>
 
@@ -55,11 +56,16 @@ void IndexSVSFlat::add(idx_t n, const float* x) {
 
 void IndexSVSFlat::reset() {
     if (impl) {
-        auto status = impl->reset();
+        // Destroy impl to ensure no dangling pointers to mmap region remain.
+        // FlatIndex::reset may retain views; destroy guarantees clean state
+        // matching Vamana static behavior.
+        auto status = svs_runtime::FlatIndex::destroy(impl);
         if (!status.ok()) {
             FAISS_THROW_MSG(status.message());
         }
+        impl = nullptr;
     }
+    mmap_owner.reset(); // Release the memory mapping
     ntotal = 0;
 }
 
@@ -114,4 +120,23 @@ void IndexSVSFlat::deserialize_impl(std::istream& in) {
     FAISS_THROW_IF_NOT_MSG(impl, "Failed to load SVS Flat index.");
 }
 
+void IndexSVSFlat::map_to(MappedFileIOReader* mf) {
+    FAISS_THROW_IF_MSG(impl, "Cannot map_to: SVS index already loaded.");
+    FAISS_THROW_IF_NOT(mf);
+
+    MmapSpan span = acquire_mmap_span(mf);
+
+    auto svs_metric = to_svs_metric(metric_type);
+
+    size_t read_bytes = 0;
+    auto status = svs_runtime::FlatIndex::map_to_memory(
+            &impl, span.data, span.size_bytes, svs_metric, &read_bytes);
+
+    if (!status.ok()) {
+        FAISS_THROW_MSG(status.message());
+    }
+
+    finalize_mmap_span(mf, span, read_bytes, mmap_owner);
+}
+
 } // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSFlat.h

@@ -29,9 +29,14 @@
 #include <svs/runtime/flat_index.h>
 
 #include <iostream>
+#include <memory>
 
 namespace faiss {
 
+// Forward declarations
+struct MappedFileIOReader;
+struct MmappedFileMappingOwner;
+
 struct IndexSVSFlat : Index {
     // sequential labels
     size_t nlabels{0};
@@ -56,10 +61,18 @@ struct IndexSVSFlat : Index {
     /* The actual SVS implementation */
     svs_runtime::FlatIndex* impl{nullptr};
 
+    // Holds a reference to the memory-mapped file owner to keep the memory
+    // mapping alive for the lifetime of this index. Only used when index is
+    // loaded via map_to() with memory-mapped I/O.
+    std::shared_ptr<MmappedFileMappingOwner> mmap_owner{nullptr};
+
     /* Serialization */
     void serialize_impl(std::ostream& out) const;
     void deserialize_impl(std::istream& in);
 
+    /* Memory-mapped deserialization */
+    void map_to(MappedFileIOReader* mf);
+
    protected:
     /* Initializes the implementation*/
     virtual void create_impl();

data/vendor/faiss/faiss/svs/IndexSVSIVF.cpp

@@ -222,7 +222,7 @@ size_t IndexSVSIVF::remove_ids(const IDSelector& sel) {
 }
 
 void IndexSVSIVF::create_impl(idx_t n, const float* x) {
-    FAISS_THROW_IF_NOT(!impl);
+    FAISS_THROW_IF_MSG(impl, "impl already created");
     ntotal = 0;
     auto svs_metric = to_svs_metric(metric_type);
     auto svs_storage_kind = to_svs_storage_kind(storage_kind);

data/vendor/faiss/faiss/svs/IndexSVSIVFLeanVec.cpp

@@ -119,7 +119,7 @@ void IndexSVSIVFLeanVec::deserialize_training_data(std::istream& in) {
 }
 
 void IndexSVSIVFLeanVec::create_impl(idx_t n, const float* x) {
-    FAISS_THROW_IF_NOT(!impl);
+    FAISS_THROW_IF_MSG(impl, "impl already created");
     ntotal = 0;
     auto svs_metric = to_svs_metric(metric_type);
     auto svs_storage_kind = to_svs_storage_kind(storage_kind);

data/vendor/faiss/faiss/svs/IndexSVSVamana.cpp

@@ -25,6 +25,7 @@
 #include <faiss/svs/IndexSVSVamana.h>
 
 #include <faiss/Index.h>
+#include <faiss/impl/mapped_io.h>
 
 #include <svs/runtime/api_defs.h>
 #include <svs/runtime/dynamic_vamana_index.h>
@@ -65,8 +66,12 @@ IndexSVSVamana::IndexSVSVamana(
         idx_t d,
         size_t degree,
         MetricType metric,
-        SVSStorageKind storage)
-        : Index(d, metric), graph_max_degree{degree}, storage_kind{storage} {
+        SVSStorageKind storage,
+        bool is_static)
+        : Index(d, metric),
+          graph_max_degree{degree},
+          is_static{is_static},
+          storage_kind{storage} {
     prune_to = graph_max_degree < 4 ? graph_max_degree : graph_max_degree - 4;
     alpha = metric == METRIC_L2 ? 1.2f : 0.95f;
 
@@ -74,8 +79,9 @@ IndexSVSVamana::IndexSVSVamana(
     // NB: LVQ/LeanVec are only available on Intel(R) hardware AND when using
     //     a build based on LVQ/LeanVec-enabled SVS.
     auto svs_storage = to_svs_storage_kind(storage_kind);
-    auto status =
-            svs_runtime::DynamicVamanaIndex::check_storage_kind(svs_storage);
+    auto status = is_static
+            ? svs_runtime::VamanaIndex::check_storage_kind(svs_storage)
+            : svs_runtime::DynamicVamanaIndex::check_storage_kind(svs_storage);
     if (!status.ok()) {
         FAISS_THROW_MSG(status.message());
     }
@@ -83,11 +89,19 @@ IndexSVSVamana::IndexSVSVamana(
 
 bool IndexSVSVamana::is_lvq_leanvec_enabled() {
     auto lvq = to_svs_storage_kind(SVS_LVQ4x0);
-    auto status = svs_runtime::DynamicVamanaIndex::check_storage_kind(lvq);
+    auto status = svs_runtime::VamanaIndex::check_storage_kind(lvq);
+    if (!status.ok()) {
+        return false;
+    }
+    status = svs_runtime::DynamicVamanaIndex::check_storage_kind(lvq);
     if (!status.ok()) {
         return false;
     }
     auto leanvec = to_svs_storage_kind(SVS_LeanVec4x4);
+    status = svs_runtime::VamanaIndex::check_storage_kind(leanvec);
+    if (!status.ok()) {
+        return false;
+    }
     status = svs_runtime::DynamicVamanaIndex::check_storage_kind(leanvec);
     if (!status.ok()) {
         return false;
@@ -97,21 +111,43 @@ bool IndexSVSVamana::is_lvq_leanvec_enabled() {
 
 IndexSVSVamana::~IndexSVSVamana() {
     if (impl) {
-        auto status = svs_runtime::DynamicVamanaIndex::destroy(impl);
+        svs_runtime::Status status;
+        if (is_static) {
+            status = svs_runtime::VamanaIndex::destroy(impl);
+        } else {
+            status = svs_runtime::DynamicVamanaIndex::destroy(
+                    static_cast<svs_runtime::DynamicVamanaIndex*>(impl));
+        }
         FAISS_ASSERT(status.ok());
         impl = nullptr;
     }
 }
 
 void IndexSVSVamana::add(idx_t n, const float* x) {
+    if (is_static) {
+        FAISS_THROW_IF_MSG(
+                impl,
+                "Static Vamana index does not support add() after initial "
+                "build. All data must be provided in a single add() call.");
+        create_impl(n, x);
+        if (stored_vectors_valid) {
+            stored_vectors.resize(static_cast<size_t>(n) * d);
+            std::memcpy(stored_vectors.data(), x, sizeof(float) * n * d);
+        }
+        ntotal = n;
+        is_trained = true;
+        return;
+    }
+
     if (!impl) {
-        create_impl();
+        create_impl(0, nullptr);
     }
 
     std::vector<size_t> labels(n);
     std::iota(labels.begin(), labels.end(), ntotal);
 
-    auto status = impl->add(n, labels.data(), x);
+    auto* dyn = dynamic_impl();
+    auto status = dyn->add(n, labels.data(), x);
     if (!status.ok()) {
         FAISS_THROW_MSG(status.message());
     }
@@ -137,10 +173,22 @@ void IndexSVSVamana::reconstruct(idx_t key, float* recons) const {
 
 void IndexSVSVamana::reset() {
     if (impl) {
-        impl->reset();
+        if (is_static) {
+            // Static index: destroy the impl so the next add() rebuilds from
+            // scratch. The static SVS backend has no in-place reset that
+            // permits a follow-up add().
+            auto status = svs_runtime::VamanaIndex::destroy(impl);
+            FAISS_ASSERT(status.ok());
+            impl = nullptr;
+        } else {
+            // Dynamic index: in-place reset preserves the impl and avoids
+            // tearing down its allocated state.
+            impl->reset();
+        }
     }
     stored_vectors.clear();
     stored_vectors_valid = true;
+    mmap_owner.reset(); // Release the memory mapping
     is_trained = false;
     ntotal = 0;
 }
@@ -204,18 +252,23 @@ void IndexSVSVamana::range_search(
 }
 
 size_t IndexSVSVamana::remove_ids(const IDSelector& sel) {
+    FAISS_THROW_IF_MSG(
+            is_static,
+            "Static Vamana index does not support remove_ids(). "
+            "The index is immutable after creation.");
     FAISS_THROW_IF_NOT(impl);
+    auto* dyn = dynamic_impl();
     auto id_filter = FaissIDFilter{sel};
     size_t removed = 0;
-    auto Status = impl->remove_selected(&removed, id_filter);
+    auto Status = dyn->remove_selected(&removed, id_filter);
     ntotal -= removed;
     stored_vectors.clear();
     stored_vectors_valid = false;
     return removed;
 }
 
-void IndexSVSVamana::create_impl() {
-    FAISS_THROW_IF_NOT(!impl);
+void IndexSVSVamana::create_impl(idx_t n, const float* x) {
+    FAISS_THROW_IF_MSG(impl, "impl already created");
     ntotal = 0;
     auto svs_metric = to_svs_metric(metric_type);
     auto svs_storage_kind = to_svs_storage_kind(storage_kind);
@@ -231,15 +284,45 @@ void IndexSVSVamana::create_impl() {
             .search_window_size = search_window_size,
             .search_buffer_capacity = search_buffer_capacity,
     };
-    auto Status = svs_runtime::DynamicVamanaIndex::build(
-            &impl,
-            d,
-            svs_metric,
-            svs_storage_kind,
-            build_params,
-            search_params);
-    if (!Status.ok()) {
-        FAISS_THROW_MSG(Status.message());
+
+    svs_runtime::Status Status;
+    if (is_static) {
+        FAISS_THROW_IF_NOT_MSG(
+                n > 0 && x != nullptr,
+                "Static Vamana index requires data at build time.");
+        Status = svs_runtime::VamanaIndex::build(
+                &impl,
+                d,
+                svs_metric,
+                svs_storage_kind,
+                build_params,
+                search_params);
+        if (!Status.ok()) {
+            FAISS_THROW_MSG(Status.message());
+        }
+        FAISS_THROW_IF_NOT(impl);
+        // Populate the static index with the full dataset (one-shot add).
+        Status = impl->add(static_cast<size_t>(n), x);
+        if (!Status.ok()) {
+            // Best-effort cleanup before propagating the error.
+            auto destroy_status = svs_runtime::VamanaIndex::destroy(impl);
+            FAISS_ASSERT(destroy_status.ok());
+            impl = nullptr;
+            FAISS_THROW_MSG(Status.message());
+        }
+    } else {
+        svs_runtime::DynamicVamanaIndex* dyn_impl = nullptr;
+        Status = svs_runtime::DynamicVamanaIndex::build(
+                &dyn_impl,
+                d,
+                svs_metric,
+                svs_storage_kind,
+                build_params,
+                search_params);
+        if (!Status.ok()) {
+            FAISS_THROW_MSG(Status.message());
+        }
+        impl = dyn_impl;
     }
     FAISS_THROW_IF_NOT(impl);
 }
@@ -258,12 +341,56 @@ void IndexSVSVamana::deserialize_impl(std::istream& in) {
     FAISS_THROW_IF_MSG(impl, "Cannot deserialize: SVS index already loaded.");
     auto svs_metric = to_svs_metric(metric_type);
     auto svs_storage_kind = to_svs_storage_kind(storage_kind);
-    auto status = svs_runtime::DynamicVamanaIndex::load(
-            &impl, in, svs_metric, svs_storage_kind);
+
+    svs_runtime::Status status;
+    if (is_static) {
+        status = svs_runtime::VamanaIndex::load(
+                &impl, in, svs_metric, svs_storage_kind);
+    } else {
+        svs_runtime::DynamicVamanaIndex* dyn_impl = nullptr;
+        status = svs_runtime::DynamicVamanaIndex::load(
+                &dyn_impl, in, svs_metric, svs_storage_kind);
+        impl = dyn_impl;
+    }
     if (!status.ok()) {
         FAISS_THROW_MSG(status.message());
     }
     FAISS_THROW_IF_NOT_MSG(impl, "Failed to load SVS Vamana index.");
 }
 
+svs_runtime::DynamicVamanaIndex* IndexSVSVamana::dynamic_impl() const {
+    FAISS_THROW_IF_MSG(
+            is_static, "Operation not supported on a static Vamana index.");
+    FAISS_THROW_IF_NOT(impl);
+    return static_cast<svs_runtime::DynamicVamanaIndex*>(impl);
+}
+
+void IndexSVSVamana::map_to(MappedFileIOReader* mf) {
+    FAISS_THROW_IF_MSG(
+            !is_static,
+            "map_to() is only supported for static Vamana indices.");
+    FAISS_THROW_IF_MSG(impl, "Cannot map_to: SVS index already loaded.");
+    FAISS_THROW_IF_NOT(mf);
+
+    MmapSpan span = acquire_mmap_span(mf);
+
+    auto svs_metric = to_svs_metric(metric_type);
+    auto svs_storage_kind = to_svs_storage_kind(storage_kind);
+
+    size_t read_bytes = 0;
+    auto status = svs_runtime::VamanaIndex::map_to_memory(
+            &impl,
+            span.data,
+            span.size_bytes,
+            svs_metric,
+            svs_storage_kind,
+            &read_bytes);
+
+    if (!status.ok()) {
+        FAISS_THROW_MSG(status.message());
+    }
+
+    finalize_mmap_span(mf, span, read_bytes, mmap_owner);
+}
+
 } // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSVamana.h

@@ -30,11 +30,16 @@
 #include <svs/runtime/dynamic_vamana_index.h>
 
 #include <iostream>
+#include <memory>
 #include <type_traits>
 #include <vector>
 
 namespace faiss {
 
+// Forward declarations
+struct MappedFileIOReader;
+struct MmappedFileMappingOwner;
+
 struct SearchParametersSVSVamana : public SearchParameters {
     size_t search_window_size = 0;
     size_t search_buffer_capacity = 0;
@@ -44,7 +49,7 @@ struct SearchParametersSVSVamana : public SearchParameters {
 enum SVSStorageKind {
     SVS_FP32,
     SVS_FP16,
-    SVS_SQI8,
+    SVS_SQ8,
     SVS_LVQ4x0,
     SVS_LVQ4x4,
     SVS_LVQ4x8,
@@ -61,7 +66,7 @@ inline svs_runtime::StorageKind to_svs_storage_kind(SVSStorageKind kind) {
             return svs_runtime::StorageKind::FP32;
         case SVS_FP16:
             return svs_runtime::StorageKind::FP16;
-        case SVS_SQI8:
+        case SVS_SQ8:
             return svs_runtime::StorageKind::SQI8;
         case SVS_LVQ4x0:
             return svs_runtime::StorageKind::LVQ4x0;
@@ -94,6 +99,9 @@ struct IndexSVSVamana : Index {
     size_t max_candidate_pool_size = 200;
     bool use_full_search_history = true;
 
+    /// Whether this is a static (immutable) Vamana index
+    bool is_static = false;
+
     SVSStorageKind storage_kind = SVS_FP32;
 
     IndexSVSVamana();
@@ -102,7 +110,8 @@ struct IndexSVSVamana : Index {
             idx_t d,
             size_t degree,
             MetricType metric = METRIC_L2,
-            SVSStorageKind storage = SVSStorageKind::SVS_FP32);
+            SVSStorageKind storage = SVSStorageKind::SVS_FP32,
+            bool is_static = false);
 
     ~IndexSVSVamana() override;
 
@@ -137,8 +146,17 @@ struct IndexSVSVamana : Index {
     void serialize_impl(std::ostream& out) const;
     virtual void deserialize_impl(std::istream& in);
 
-    /* The actual SVS implementation */
-    svs_runtime::DynamicVamanaIndex* impl{nullptr};
+    /* Memory-mapped deserialization for static indices */
+    virtual void map_to(MappedFileIOReader* mf);
+
+    /* The actual SVS implementation (VamanaIndex is the base for both
+       static and dynamic variants) */
+    svs_runtime::VamanaIndex* impl{nullptr};
+
+    // Holds a reference to the memory-mapped file owner to keep the memory
+    // mapping alive for the lifetime of this index. Only used when index is
+    // loaded via map_to() with memory-mapped I/O.
+    std::shared_ptr<MmappedFileMappingOwner> mmap_owner{nullptr};
 
     // The SVS runtime API does not expose vector retrieval, so we keep a copy
     // of added vectors to support reconstruct(). When used as a coarse
@@ -147,8 +165,13 @@ struct IndexSVSVamana : Index {
     bool stored_vectors_valid{true};
 
    protected:
-    /* Initializes the implementation*/
-    virtual void create_impl();
+    /* Initializes the implementation. For static indexes the data is consumed
+       at build time; for dynamic indexes n/x are ignored and add() populates
+       the index afterwards. */
+    virtual void create_impl(idx_t n, const float* x);
+
+    /* Returns the dynamic impl pointer, throwing if static */
+    svs_runtime::DynamicVamanaIndex* dynamic_impl() const;
 };
 
 } // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSVamanaLVQ.cpp

@@ -33,7 +33,8 @@ IndexSVSVamanaLVQ::IndexSVSVamanaLVQ(
         idx_t d,
         size_t degree,
         MetricType metric,
-        SVSStorageKind storage)
-        : IndexSVSVamana(d, degree, metric, storage) {}
+        SVSStorageKind storage,
+        bool is_static)
+        : IndexSVSVamana(d, degree, metric, storage, is_static) {}
 
 } // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSVamanaLVQ.h

@@ -34,7 +34,8 @@ struct IndexSVSVamanaLVQ : IndexSVSVamana {
             idx_t d,
             size_t degree,
             MetricType metric = METRIC_L2,
-            SVSStorageKind storage = SVSStorageKind::SVS_LVQ4x0);
+            SVSStorageKind storage = SVSStorageKind::SVS_LVQ4x0,
+            bool is_static = false);
 
     ~IndexSVSVamanaLVQ() override = default;
 };