faiss 0.6.2 → 0.6.3

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

@@ -223,18 +223,18 @@ struct QuantizerTemplate<
 };
 
 /**********************************************************
- * TurboQuant MSE quantizer
+ * Lloyd-Max scalar quantizer
  **********************************************************/
 
-// NEON TurboQuantMSE: decode via gather, encode stays scalar.
+// NEON Lloyd-Max: decode via gather, encode stays scalar.
 // NEON doesn't have movemask so 1-bit encode is also scalar.
-#define DEFINE_TQMSE_NEON_SPECIALIZATION(NBITS, UNPACK_FN)                   \
+#define DEFINE_LLOYD_MAX_NEON_SPECIALIZATION(NBITS, UNPACK_FN)               \
     template <>                                                              \
-    struct QuantizerTurboQuantMSE<NBITS, SIMDLevel::ARM_NEON>                \
-            : QuantizerTurboQuantMSE<NBITS, SIMDLevel::NONE> {               \
-        using Base = QuantizerTurboQuantMSE<NBITS, SIMDLevel::NONE>;         \
+    struct QuantizerLloydMax<NBITS, SIMDLevel::ARM_NEON>                     \
+            : QuantizerLloydMax<NBITS, SIMDLevel::NONE> {                    \
+        using Base = QuantizerLloydMax<NBITS, SIMDLevel::NONE>;              \
                                                                              \
-        QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained)  \
+        QuantizerLloydMax(size_t d, const std::vector<float>& trained)       \
                 : Base(d, trained) {                                         \
             assert(d % 8 == 0);                                              \
         }                                                                    \
@@ -256,19 +256,19 @@ struct QuantizerTemplate<
         }                                                                    \
     }
 
-DEFINE_TQMSE_NEON_SPECIALIZATION(1, unpack_8x1bit_to_u8);
-DEFINE_TQMSE_NEON_SPECIALIZATION(2, unpack_8x2bit_to_u8);
-DEFINE_TQMSE_NEON_SPECIALIZATION(3, unpack_8x3bit_to_u8);
-DEFINE_TQMSE_NEON_SPECIALIZATION(4, unpack_8x4bit_to_u8);
+DEFINE_LLOYD_MAX_NEON_SPECIALIZATION(1, unpack_8x1bit_to_u8);
+DEFINE_LLOYD_MAX_NEON_SPECIALIZATION(2, unpack_8x2bit_to_u8);
+DEFINE_LLOYD_MAX_NEON_SPECIALIZATION(3, unpack_8x3bit_to_u8);
+DEFINE_LLOYD_MAX_NEON_SPECIALIZATION(4, unpack_8x4bit_to_u8);
 
-#undef DEFINE_TQMSE_NEON_SPECIALIZATION
+#undef DEFINE_LLOYD_MAX_NEON_SPECIALIZATION
 
 template <>
-struct QuantizerTurboQuantMSE<8, SIMDLevel::ARM_NEON>
-        : QuantizerTurboQuantMSE<8, SIMDLevel::NONE> {
-    using Base = QuantizerTurboQuantMSE<8, SIMDLevel::NONE>;
+struct QuantizerLloydMax<8, SIMDLevel::ARM_NEON>
+        : QuantizerLloydMax<8, SIMDLevel::NONE> {
+    using Base = QuantizerLloydMax<8, SIMDLevel::NONE>;
 
-    QuantizerTurboQuantMSE(size_t d, const std::vector<float>& trained)
+    QuantizerLloydMax(size_t d, const std::vector<float>& trained)
             : Base(d, trained) {
         assert(d % 8 == 0);
     }

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

@@ -84,6 +84,24 @@ inline auto dispatch_with_fallback(LambdaType&& action) {
     }
 }
 
+/** Run action at current_level; on a null result, retry the next-lower level,
+ * down to NONE (terminal). action is called per level tried, so never moved. */
+template <int available_levels, SIMDLevel current_level, typename LambdaType>
+inline auto dispatch_simd_level_or_lower(LambdaType& action) {
+    if constexpr (current_level == SIMDLevel::NONE) {
+        return action.template operator()<SIMDLevel::NONE>();
+    } else {
+        if constexpr (available_levels & (1 << int(current_level))) {
+            if (auto result = action.template operator()<current_level>()) {
+                return result;
+            }
+        }
+        return dispatch_simd_level_or_lower<
+                available_levels,
+                get_simd_fallback(current_level)>(action);
+    }
+}
+
 /** The complete dispatching function. It takes into account:
  * - the currently selected SIMD level
  * - the compiled in SIMD levels (given by COMPILE_SIMD_XXX)
@@ -163,6 +181,18 @@ inline auto with_selected_simd_levels(LambdaType&& action) {
 #endif
 }
 
+/** Like with_selected_simd_levels, but for factory actions that return null to
+ * decline a level (e.g. AVX-512 needing d % 16 == 0). Falls back to the next
+ * lower level, down to NONE. */
+template <int available_levels, typename LambdaType>
+inline auto with_simd_level_fallback(const LambdaType& action) {
+    return with_selected_simd_levels<available_levels>(
+            [&action]<SIMDLevel SL>() {
+                return dispatch_simd_level_or_lower<available_levels, SL>(
+                        action);
+            });
+}
+
 /**
  * Dispatch to a lambda with SIMDLevel as a compile-time constant.
  *
@@ -198,15 +228,6 @@ 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.

data/vendor/faiss/faiss/index_factory.cpp

@@ -21,11 +21,13 @@
 #include <faiss/Index2Layer.h>
 #include <faiss/IndexAdditiveQuantizer.h>
 #include <faiss/IndexAdditiveQuantizerFastScan.h>
+#include <faiss/IndexEDEN.h>
 #include <faiss/IndexFlat.h>
 #include <faiss/IndexHNSW.h>
 #include <faiss/IndexIVF.h>
 #include <faiss/IndexIVFAdditiveQuantizer.h>
 #include <faiss/IndexIVFAdditiveQuantizerFastScan.h>
+#include <faiss/IndexIVFEDEN.h>
 #include <faiss/IndexIVFFlat.h>
 #include <faiss/IndexIVFFlatPanorama.h>
 #include <faiss/IndexIVFPQ.h>
@@ -315,8 +317,8 @@ Index* parse_coarse_quantizer(
         SVSStorageKind storage = SVSStorageKind::SVS_FP32;
         if (sm[3].matched) {
             std::string s = sm[3].str().substr(1);
-            if (s == "SQI8") {
-                storage = SVSStorageKind::SVS_SQI8;
+            if (s == "SQ8") {
+                storage = SVSStorageKind::SVS_SQ8;
             } else if (s == "FP16") {
                 storage = SVSStorageKind::SVS_FP16;
             } else if (s == "FP32") {
@@ -514,6 +516,18 @@ IndexIVF* parse_IndexIVF(
         uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
         return new IndexIVFRaBitQ(get_q(), d, nlist, mt, own_il, nb_bits);
     }
+    // IndexIVFEDEN with optional nb_bits (1-8) and scale type.
+    // Accepts: "EDEN" (default 1-bit), "EDEN{nb_bits}" (e.g., "EDEN4"),
+    //          or "EDEN{nb_bits}BIASED" for the MSE-minimizing scale.
+    if (match("EDEN([1-8])?(BIASED|BIAS)?")) {
+        uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
+        EDENScaleType scale_type =
+                sm[2].str() == "BIASED" || sm[2].str() == "BIAS"
+                ? EDENScaleType_BIASED
+                : EDENScaleType_UNBIASED;
+        return new IndexIVFEDEN(
+                get_q(), d, nlist, mt, own_il, nb_bits, scale_type);
+    }
     // Accepts: "RaBitQfs" (default 1-bit, batch size 32)
     //          "RaBitQfs{nb_bits}" (e.g., "RaBitQfs4")
     //          "RaBitQfs_64" (1-bit, batch size 64)
@@ -681,16 +695,16 @@ Index* parse_svs_datatype(
         }
         FAISS_ASSERT(false && "Unsupported SVS index type for Float16");
     }
-    if (re_match(datatype_string, "SQI8", sm)) {
+    if (re_match(datatype_string, "SQ8", sm)) {
         if (index_type == "Vamana") {
             return new IndexSVSVamana(
-                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQI8);
+                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQ8);
         }
         if (index_type == "IVF") {
             return new IndexSVSIVF(
-                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQI8);
+                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQ8);
         }
-        FAISS_ASSERT(false && "Unsupported SVS index type for SQI8");
+        FAISS_ASSERT(false && "Unsupported SVS index type for SQ8");
     }
     if (re_match(datatype_string, "(LVQ[0-9]+x[0-9]+)", sm)) {
         if (index_type == "Vamana") {
@@ -917,6 +931,18 @@ Index* parse_other_indexes(
         return new IndexRaBitQ(d, metric, nb_bits);
     }
 
+    // IndexEDEN with optional nb_bits (1-8) and scale type.
+    // Accepts: "EDEN" (default 1-bit), "EDEN{nb_bits}" (e.g., "EDEN4"),
+    //          or "EDEN{nb_bits}BIASED" for the MSE-minimizing scale.
+    if (match("EDEN([1-8])?(BIASED|BIAS)?")) {
+        uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
+        EDENScaleType scale_type =
+                sm[2].str() == "BIASED" || sm[2].str() == "BIAS"
+                ? EDENScaleType_BIASED
+                : EDENScaleType_UNBIASED;
+        return new IndexEDEN(d, metric, nb_bits, scale_type);
+    }
+
     if (match("RaBitQfs([1-9])?(_[0-9]+)?")) {
         uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
         int bbs = mres_to_int(sm[2], 32, 1);

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

@@ -80,7 +80,7 @@ idx_t DirectMap::get(idx_t key) const {
         return lo;
     } else if (type == Hashtable) {
         auto res = hashtable.find(key);
-        FAISS_THROW_IF_NOT_MSG(res != hashtable.end(), "key not found");
+        FAISS_THROW_IF_MSG(res == hashtable.end(), "key not found");
         return res->second;
     } else {
         FAISS_THROW_MSG("direct map not initialized");

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

@@ -371,8 +371,8 @@ ArrayInvertedListsPanorama::ArrayInvertedListsPanorama(
           pano(code_size_in, n_levels_in, batch_size) {
     FAISS_THROW_IF_NOT(n_levels_in > 0);
     FAISS_THROW_IF_NOT(code_size_in % sizeof(float) == 0);
-    FAISS_THROW_IF_NOT_MSG(
-            !use_iterator,
+    FAISS_THROW_IF_MSG(
+            use_iterator,
             "IndexIVFFlatPanorama does not support iterators, use vanilla IndexIVFFlat instead");
     FAISS_ASSERT(level_width % sizeof(float) == 0);
 

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>
@@ -187,6 +188,7 @@ void IndexSVSVamana::reset() {
     }
     stored_vectors.clear();
     stored_vectors_valid = true;
+    mmap_owner.reset(); // Release the memory mapping
     is_trained = false;
     ntotal = 0;
 }
@@ -266,7 +268,7 @@ size_t IndexSVSVamana::remove_ids(const IDSelector& sel) {
 }
 
 void IndexSVSVamana::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);
@@ -363,4 +365,32 @@ svs_runtime::DynamicVamanaIndex* IndexSVSVamana::dynamic_impl() const {
     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;
@@ -141,10 +146,18 @@ struct IndexSVSVamana : Index {
     void serialize_impl(std::ostream& out) const;
     virtual void deserialize_impl(std::istream& in);
 
+    /* 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
     // quantizer this holds only nlist centroids.

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

@@ -29,7 +29,6 @@
 #include <svs/runtime/vamana_index.h>
 
 #include <memory>
-#include <span>
 #include "faiss/svs/IndexSVSVamana.h"
 
 namespace faiss {
@@ -122,7 +121,7 @@ void IndexSVSVamanaLeanVec::deserialize_training_data(std::istream& in) {
 }
 
 void IndexSVSVamanaLeanVec::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/utils/approx_topk_hamming/approx_topk_hamming.h

@@ -118,7 +118,7 @@ struct HeapWithBucketsForHamming32<
                         }
                     }
 
-                    if (valid_counter == 8) {
+                    if (valid_counter == 0) {
                         continue; // Skip if all vectors are filtered out
                     }
 

data/vendor/faiss/faiss/utils/distances.cpp

@@ -291,6 +291,11 @@ void exhaustive_inner_product_seq(
         BlockResultHandler& res) {
     using SingleResultHandler =
             typename BlockResultHandler::SingleResultHandler;
+
+    if (nx == 0) {
+        return;
+    }
+
     [[maybe_unused]] int nt = std::min(int(nx), omp_get_max_threads());
 
 #pragma omp parallel num_threads(nt)
@@ -327,6 +332,11 @@ void exhaustive_L2sqr_seq(
         BlockResultHandler& res) {
     using SingleResultHandler =
             typename BlockResultHandler::SingleResultHandler;
+
+    if (nx == 0) {
+        return;
+    }
+
     [[maybe_unused]] int nt = std::min(int(nx), omp_get_max_threads());
 
 #pragma omp parallel num_threads(nt)
@@ -531,8 +541,10 @@ void exhaustive_L2sqr_blas<Top1BlockResultHandler<CMax<float, int64_t>>>(
         return;
     }
 
-    with_selected_simd_levels<AVAILABLE_SIMD_LEVELS_A2>([&]<SIMDLevel SL>() {
-        if constexpr (SL == SIMDLevel::AVX2 || SL == SIMDLevel::ARM_SVE) {
+    with_selected_simd_levels<AVAILABLE_SIMD_LEVELS_A1>([&]<SIMDLevel SL>() {
+        if constexpr (
+                SL == SIMDLevel::AVX2 || SL == SIMDLevel::AVX512 ||
+                SL == SIMDLevel::ARM_SVE) {
             exhaustive_L2sqr_blas_cmax<SL>(x, y, d, nx, ny, res, y_norms);
         } else {
             exhaustive_L2sqr_blas_default_impl<

data/vendor/faiss/faiss/utils/distances_simd.cpp

@@ -10,18 +10,19 @@
 #include <faiss/utils/distances.h>
 
 #include <cmath>
-#include <cstdio>
 #include <cstring>
 
-#include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/simdlib/simdlib_dispatch.h>
 
 #define THE_SIMD_LEVEL SIMDLevel::NONE
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/utils/simd_impl/distances_autovec-inl.h>
 
+// This TU is the SIMDLevel::NONE build of the specializations that
+// distances_simdlib256.h emits, so the include is required despite no symbol
+// being named directly here.
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
-#include <faiss/utils/simd_impl/distances_simdlib256.h>
+#include <faiss/utils/simd_impl/distances_simdlib256.h> // IWYU pragma: keep
 
 namespace faiss {