faiss 0.6.1 → 0.6.2

data/vendor/faiss/faiss/impl/scalar_quantizer/sq-rvv.cpp

@@ -302,6 +302,32 @@ struct DCTemplate<
     }
 };
 
+/**********************************************************
+ * TurboQuant masked_sum RVV specialization (scalar fallback)
+ **********************************************************/
+
+template <SIMDLevel SL0>
+float turboq_masked_sum(const float* arr, const uint8_t* bits, size_t d);
+
+template <>
+float turboq_masked_sum<SIMDLevel::RISCV_RVV>(
+        const float* arr,
+        const uint8_t* bits,
+        size_t d) {
+    float result = 0;
+    for (size_t byte_idx = 0; byte_idx < (d + 7) / 8; byte_idx++) {
+        uint8_t b = bits[byte_idx];
+        size_t base = byte_idx * 8;
+        size_t end = std::min(base + 8, d);
+        for (size_t j = base; j < end; j++) {
+            if (b & (1 << (j - base))) {
+                result += arr[j];
+            }
+        }
+    }
+    return result;
+}
+
 } // namespace scalar_quantizer
 } // namespace faiss
 

data/vendor/faiss/faiss/impl/simd_dispatch.h

@@ -36,6 +36,12 @@ constexpr int AVAILABLE_SIMD_LEVELS_AVX2_NEON = AVAILABLE_SIMD_LEVELS_NONE |
 constexpr int AVAILABLE_SIMD_LEVELS_A0 = AVAILABLE_SIMD_LEVELS_AVX2_NEON |
         (1 << int(SIMDLevel::AVX512)) | (1 << int(SIMDLevel::RISCV_RVV));
 
+// A0_SPR: same as A0 + AVX512_SPR (for functions with a dedicated SPR
+// specialization on top of an AVX512 fallback). Currently used by the
+// RaBitQ popcount kernels, which use VPOPCNTDQ on SPR+.
+constexpr int AVAILABLE_SIMD_LEVELS_A0_SPR =
+        AVAILABLE_SIMD_LEVELS_A0 | (1 << int(SIMDLevel::AVX512_SPR));
+
 // A1: same + ARM_SVE (for functions with dedicated SVE implementations)
 constexpr int AVAILABLE_SIMD_LEVELS_A1 =
         AVAILABLE_SIMD_LEVELS_A0 | (1 << int(SIMDLevel::ARM_SVE));
@@ -47,6 +53,37 @@ constexpr int AVAILABLE_SIMD_LEVELS_A2 = AVAILABLE_SIMD_LEVELS_NONE |
 
 constexpr int AVAILABLE_SIMD_LEVELS_ALL = -1;
 
+constexpr SIMDLevel get_simd_fallback(SIMDLevel level) {
+    switch (level) {
+        case SIMDLevel::AVX512_SPR:
+            return SIMDLevel::AVX512;
+        case SIMDLevel::AVX512:
+            return SIMDLevel::AVX2;
+        case SIMDLevel::ARM_SVE:
+            return SIMDLevel::ARM_NEON;
+        case SIMDLevel::AVX2:
+        case SIMDLevel::ARM_NEON:
+        case SIMDLevel::RISCV_RVV:
+            return SIMDLevel::NONE;
+        default:
+            return SIMDLevel::NONE;
+    }
+}
+
+template <int available_levels, SIMDLevel current_level, typename LambdaType>
+inline auto dispatch_with_fallback(LambdaType&& action) {
+    if constexpr (available_levels & (1 << int(current_level))) {
+        return action.template operator()<current_level>();
+    } else if constexpr (current_level != SIMDLevel::NONE) {
+        return dispatch_with_fallback<
+                available_levels,
+                get_simd_fallback(current_level)>(
+                std::forward<LambdaType>(action));
+    } else {
+        return action.template operator()<SIMDLevel::NONE>();
+    }
+}
+
 /** The complete dispatching function. It takes into account:
  * - the currently selected SIMD level
  * - the compiled in SIMD levels (given by COMPILE_SIMD_XXX)
@@ -114,14 +151,15 @@ inline auto with_selected_simd_levels(LambdaType&& action) {
     }
 #else // static dispatch
     // In static mode, SINGLE_SIMD_LEVEL is a constexpr resolved at compile
-    // time. If the compiled level is not in the available set, fall through
-    // to NONE (mirroring the DD fallthrough behavior). Only SINGLE_SIMD_LEVEL
-    // and NONE have compiled specializations.
-    if constexpr (available_levels & (1 << int(SINGLE_SIMD_LEVEL))) {
-        return action.template operator()<SINGLE_SIMD_LEVEL>();
-    } else {
-        return action.template operator()<SIMDLevel::NONE>();
-    }
+    // time. We mirror the DD fallthrough behavior at compile time via
+    // dispatch_with_fallback, which recursively walks get_simd_fallback:
+    //   x86:   AVX512_SPR -> AVX512 -> AVX2 -> NONE
+    //   ARM:   ARM_SVE -> ARM_NEON -> NONE
+    //   RISCV: RISCV_RVV -> NONE
+    // The first level in the chain that appears in available_levels is
+    // selected; if none match, NONE is used unconditionally.
+    return dispatch_with_fallback<available_levels, SINGLE_SIMD_LEVEL>(
+            std::forward<LambdaType>(action));
 #endif
 }
 
@@ -160,6 +198,15 @@ inline auto with_simd_level(LambdaType&& action) {
             std::forward<LambdaType>(action));
 }
 
+/**
+ * Use for functions with AVX512_SPR-specific implementations.
+ */
+template <typename LambdaType>
+inline auto with_simd_level_spr(LambdaType&& action) {
+    return with_selected_simd_levels<AVAILABLE_SIMD_LEVELS_A0_SPR>(
+            std::forward<LambdaType>(action));
+}
+
 /**
  * Use for functions implemented with simdXintY (256-bit) operations
  * that don't have dedicated AVX512 or SVE implementations.
@@ -170,4 +217,14 @@ inline auto with_simd_level_256bit(LambdaType&& action) {
             std::forward<LambdaType>(action));
 }
 
+/**
+ * Use for functions that have A0-level implementations plus an AVX512_SPR
+ * specialization (e.g. using VPOPCNTDQ).
+ */
+template <typename LambdaType>
+inline auto with_simd_level_a0_spr(LambdaType&& action) {
+    return with_selected_simd_levels<AVAILABLE_SIMD_LEVELS_A0_SPR>(
+            std::forward<LambdaType>(action));
+}
+
 } // namespace faiss

data/vendor/faiss/faiss/index_factory.cpp

@@ -168,9 +168,13 @@ std::map<std::string, ScalarQuantizer::QuantizerType> sq_types = {
         {"SQtqmse3", ScalarQuantizer::QT_3bit_tqmse},
         {"SQtqmse4", ScalarQuantizer::QT_4bit_tqmse},
         {"SQtqmse8", ScalarQuantizer::QT_8bit_tqmse},
+        {"SQtq2", ScalarQuantizer::QT_2bit_tq},
+        {"SQtq3", ScalarQuantizer::QT_3bit_tq},
+        {"SQtq4", ScalarQuantizer::QT_4bit_tq},
+        {"SQtq5", ScalarQuantizer::QT_5bit_tq},
 };
 const std::string sq_pattern =
-        "(SQ0|SQ4|SQ8|SQ6|SQfp16|SQbf16|SQ8_direct_signed|SQ8_direct|SQtqmse1|SQtqmse2|SQtqmse3|SQtqmse4|SQtqmse8)";
+        "(SQ0|SQ4|SQ8|SQ6|SQfp16|SQbf16|SQ8_direct_signed|SQ8_direct|SQtqmse1|SQtqmse2|SQtqmse3|SQtqmse4|SQtqmse8|SQtq2|SQtq3|SQtq4|SQtq5)";
 
 std::map<std::string, AdditiveQuantizer::Search_type_t> aq_search_type = {
         {"_Nfloat", AdditiveQuantizer::ST_norm_float},

data/vendor/faiss/faiss/index_io.h

@@ -137,6 +137,22 @@ size_t get_deserialization_vector_byte_limit();
 // and do not modify while deserialization is in progress on other threads.
 void set_deserialization_vector_byte_limit(size_t value);
 
+// Returns the current IndexLattice r2 limit for deserialization.
+// When nonzero, deserialization rejects IndexLattice payloads whose
+// r2 (squared lattice radius) exceeds this value.  The
+// ZnSphereCodecRec constructor that runs at IndexLattice deserialize
+// time builds a decode cache whose population cost scales
+// polynomially in r2 and dim, and can exceed real-world workload time
+// budgets even for r2 values that do not trip the existing
+// decode-cache memory cap.
+// Default: 0 (no limit).
+size_t get_deserialization_lattice_r2_limit();
+
+// Sets the IndexLattice r2 deserialization limit.
+// NOT thread-safe: set before any concurrent deserialization calls
+// and do not modify while deserialization is in progress on other threads.
+void set_deserialization_lattice_r2_limit(size_t value);
+
 } // namespace faiss
 
 #endif

data/vendor/faiss/faiss/invlists/DirectMap.cpp

@@ -254,7 +254,10 @@ void DirectMap::update_codes(
                 int64_t id2 = invlists->get_single_id(il, l - 1);
                 array[id2] = lo_build(il, ofs);
                 invlists->update_entry(
-                        il, ofs, id2, invlists->get_single_code(il, l - 1));
+                        il,
+                        ofs,
+                        id2,
+                        InvertedLists::ScopedCodes(invlists, il, l - 1).get());
             }
             invlists->resize(il, l - 1);
         }

data/vendor/faiss/faiss/invlists/InvertedLists.cpp

@@ -498,12 +498,12 @@ void ReadOnlyInvertedLists::resize(size_t, size_t) {
  * HStackInvertedLists implementation
  ******************************************/
 
-HStackInvertedLists::HStackInvertedLists(int nil, const InvertedLists** ils_in)
+HStackInvertedLists::HStackInvertedLists(int n_il, const InvertedLists** ils_in)
         : ReadOnlyInvertedLists(
-                  nil > 0 ? ils_in[0]->nlist : 0,
-                  nil > 0 ? ils_in[0]->code_size : 0) {
-    FAISS_THROW_IF_NOT(nil > 0);
-    for (int i = 0; i < nil; i++) {
+                  n_il > 0 ? ils_in[0]->nlist : 0,
+                  n_il > 0 ? ils_in[0]->code_size : 0) {
+    FAISS_THROW_IF_NOT(n_il > 0);
+    for (int i = 0; i < n_il; i++) {
         ils.push_back(ils_in[i]);
         FAISS_THROW_IF_NOT(
                 ils_in[i]->code_size == code_size && ils_in[i]->nlist == nlist);
@@ -683,9 +683,9 @@ int translate_list_no(const VStackInvertedLists* vil, idx_t list_no) {
     return i0;
 }
 
-idx_t sum_il_sizes(int nil, const InvertedLists** ils_in) {
+idx_t sum_il_sizes(int n_il, const InvertedLists** ils_in) {
     idx_t tot = 0;
-    for (int i = 0; i < nil; i++) {
+    for (int i = 0; i < n_il; i++) {
         tot += ils_in[i]->nlist;
     }
     return tot;
@@ -693,13 +693,13 @@ idx_t sum_il_sizes(int nil, const InvertedLists** ils_in) {
 
 } // namespace
 
-VStackInvertedLists::VStackInvertedLists(int nil, const InvertedLists** ils_in)
+VStackInvertedLists::VStackInvertedLists(int n_il, const InvertedLists** ils_in)
         : ReadOnlyInvertedLists(
-                  sum_il_sizes(nil, ils_in),
-                  nil > 0 ? ils_in[0]->code_size : 0) {
-    FAISS_THROW_IF_NOT(nil > 0);
-    cumsz.resize(nil + 1);
-    for (int i = 0; i < nil; i++) {
+                  sum_il_sizes(n_il, ils_in),
+                  n_il > 0 ? ils_in[0]->code_size : 0) {
+    FAISS_THROW_IF_NOT(n_il > 0);
+    cumsz.resize(n_il + 1);
+    for (int i = 0; i < n_il; i++) {
         ils.push_back(ils_in[i]);
         FAISS_THROW_IF_NOT(ils_in[i]->code_size == code_size);
         cumsz[i + 1] = cumsz[i] + ils_in[i]->nlist;

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

@@ -376,7 +376,7 @@ struct HStackInvertedLists : ReadOnlyInvertedLists {
     std::vector<const InvertedLists*> ils;
 
     /// build InvertedLists by concatenating nil of them
-    HStackInvertedLists(int nil, const InvertedLists** ils);
+    HStackInvertedLists(int n_il, const InvertedLists** ils);
 
     size_t list_size(size_t list_no) const override;
     const uint8_t* get_codes(size_t list_no) const override;
@@ -422,7 +422,7 @@ struct VStackInvertedLists : ReadOnlyInvertedLists {
     std::vector<idx_t> cumsz;
 
     /// build InvertedLists by concatenating nil of them
-    VStackInvertedLists(int nil, const InvertedLists** ils);
+    VStackInvertedLists(int n_il, const InvertedLists** ils);
 
     size_t list_size(size_t list_no) const override;
     const uint8_t* get_codes(size_t list_no) const override;

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

@@ -65,8 +65,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 +78,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 +88,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 +110,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,7 +172,18 @@ 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;
@@ -204,17 +250,22 @@ 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() {
+void IndexSVSVamana::create_impl(idx_t n, const float* x) {
     FAISS_THROW_IF_NOT(!impl);
     ntotal = 0;
     auto svs_metric = to_svs_metric(metric_type);
@@ -231,15 +282,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 +339,28 @@ 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);
+}
+
 } // namespace faiss

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

@@ -94,6 +94,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 +105,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 +141,9 @@ 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};
+    /* The actual SVS implementation (VamanaIndex is the base for both
+       static and dynamic variants) */
+    svs_runtime::VamanaIndex* impl{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 +152,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;
 };

data/vendor/faiss/faiss/svs/IndexSVSVamanaLeanVec.cpp

@@ -44,8 +44,9 @@ IndexSVSVamanaLeanVec::IndexSVSVamanaLeanVec(
         size_t degree,
         MetricType metric,
         size_t leanvec_dims,
-        SVSStorageKind storage_kind)
-        : IndexSVSVamana(d, degree, metric, storage_kind) {
+        SVSStorageKind storage_kind,
+        bool is_static)
+        : IndexSVSVamana(d, degree, metric, storage_kind, is_static) {
     is_trained = false;
     leanvec_d = leanvec_dims == 0 ? d / 2 : leanvec_dims;
 }
@@ -120,7 +121,8 @@ void IndexSVSVamanaLeanVec::deserialize_training_data(std::istream& in) {
     training_data = tdata;
 }
 
-void IndexSVSVamanaLeanVec::create_impl() {
+void IndexSVSVamanaLeanVec::create_impl(idx_t n, const float* x) {
+    FAISS_THROW_IF_NOT(!impl);
     ntotal = 0;
     auto svs_metric = to_svs_metric(metric_type);
     auto svs_storage_kind = to_svs_storage_kind(storage_kind);
@@ -136,29 +138,68 @@ void IndexSVSVamanaLeanVec::create_impl() {
             .search_window_size = search_window_size,
             .search_buffer_capacity = search_buffer_capacity,
     };
+
     auto status = svs_runtime::Status_Ok;
-    if (training_data) {
-        status = svs_runtime::DynamicVamanaIndexLeanVec::build(
-                &impl,
-                d,
-                svs_metric,
-                svs_storage_kind,
-                training_data,
-                build_params,
-                search_params);
+    if (is_static) {
+        FAISS_THROW_IF_NOT_MSG(
+                n > 0 && x != nullptr,
+                "Static Vamana LeanVec index requires data at build time.");
+        if (training_data) {
+            status = svs_runtime::VamanaIndexLeanVec::build(
+                    &impl,
+                    d,
+                    svs_metric,
+                    svs_storage_kind,
+                    training_data,
+                    build_params,
+                    search_params);
+        } else {
+            status = svs_runtime::VamanaIndexLeanVec::build(
+                    &impl,
+                    d,
+                    svs_metric,
+                    svs_storage_kind,
+                    leanvec_d,
+                    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()) {
+            auto destroy_status = svs_runtime::VamanaIndex::destroy(impl);
+            FAISS_ASSERT(destroy_status.ok());
+            impl = nullptr;
+            FAISS_THROW_MSG(status.message());
+        }
     } else {
-        status = svs_runtime::DynamicVamanaIndexLeanVec::build(
-                &impl,
-                d,
-                svs_metric,
-                svs_storage_kind,
-                leanvec_d,
-                build_params,
-                search_params);
-    }
-
-    if (!status.ok()) {
-        FAISS_THROW_MSG(status.message());
+        svs_runtime::DynamicVamanaIndex* dyn_impl = nullptr;
+        if (training_data) {
+            status = svs_runtime::DynamicVamanaIndexLeanVec::build(
+                    &dyn_impl,
+                    d,
+                    svs_metric,
+                    svs_storage_kind,
+                    training_data,
+                    build_params,
+                    search_params);
+        } else {
+            status = svs_runtime::DynamicVamanaIndexLeanVec::build(
+                    &dyn_impl,
+                    d,
+                    svs_metric,
+                    svs_storage_kind,
+                    leanvec_d,
+                    build_params,
+                    search_params);
+        }
+        if (!status.ok()) {
+            FAISS_THROW_MSG(status.message());
+        }
+        impl = dyn_impl;
     }
     FAISS_THROW_IF_NOT(impl);
 }