faiss 0.5.3 → 0.6.0

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

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+/**
+ * @file simd_dispatch.h
+ * @brief Internal dispatch macros for SIMD level selection.
+ *
+ * This is a PRIVATE header - do not include in public APIs or user code.
+ * Only faiss internal .cpp files should include this header.
+ *
+ * For the public API (SIMDLevel enum, SIMDConfig class), use:
+ *   #include <faiss/utils/simd_levels.h>
+ */
+
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/utils/simd_levels.h>
+
+namespace faiss {
+
+/*********************** x86 SIMD dispatch cases */
+
+#ifdef COMPILE_SIMD_AVX2
+#define DISPATCH_SIMDLevel_AVX2(f, ...) \
+    case SIMDLevel::AVX2:               \
+        return f<SIMDLevel::AVX2>(__VA_ARGS__)
+#else
+#define DISPATCH_SIMDLevel_AVX2(f, ...)
+#endif
+
+#ifdef COMPILE_SIMD_AVX512
+#define DISPATCH_SIMDLevel_AVX512(f, ...) \
+    case SIMDLevel::AVX512:               \
+        return f<SIMDLevel::AVX512>(__VA_ARGS__)
+#else
+#define DISPATCH_SIMDLevel_AVX512(f, ...)
+#endif
+
+#ifdef COMPILE_SIMD_AVX512_SPR
+#define DISPATCH_SIMDLevel_AVX512_SPR(f, ...) \
+    case SIMDLevel::AVX512_SPR:               \
+        return f<SIMDLevel::AVX512_SPR>(__VA_ARGS__)
+#else
+#define DISPATCH_SIMDLevel_AVX512_SPR(f, ...)
+#endif
+
+/*********************** ARM SIMD dispatch cases */
+
+#ifdef COMPILE_SIMD_ARM_NEON
+#define DISPATCH_SIMDLevel_ARM_NEON(f, ...) \
+    case SIMDLevel::ARM_NEON:               \
+        return f<SIMDLevel::ARM_NEON>(__VA_ARGS__)
+#else
+#define DISPATCH_SIMDLevel_ARM_NEON(f, ...)
+#endif
+
+#ifdef COMPILE_SIMD_ARM_SVE
+#define DISPATCH_SIMDLevel_ARM_SVE(f, ...) \
+    case SIMDLevel::ARM_SVE:               \
+        return f<SIMDLevel::ARM_SVE>(__VA_ARGS__)
+#else
+#define DISPATCH_SIMDLevel_ARM_SVE(f, ...)
+#endif
+
+/*********************** Main dispatch macro */
+
+#ifdef FAISS_ENABLE_DD
+
+// DD mode: runtime dispatch based on SIMDConfig::level
+#define DISPATCH_SIMDLevel(f, ...)                         \
+    switch (SIMDConfig::level) {                           \
+        case SIMDLevel::NONE:                              \
+            return f<SIMDLevel::NONE>(__VA_ARGS__);        \
+            DISPATCH_SIMDLevel_AVX2(f, __VA_ARGS__);       \
+            DISPATCH_SIMDLevel_AVX512(f, __VA_ARGS__);     \
+            DISPATCH_SIMDLevel_AVX512_SPR(f, __VA_ARGS__); \
+            DISPATCH_SIMDLevel_ARM_NEON(f, __VA_ARGS__);   \
+            DISPATCH_SIMDLevel_ARM_SVE(f, __VA_ARGS__);    \
+        default:                                           \
+            FAISS_THROW_MSG("Invalid SIMD level");         \
+    }
+
+#else // Static mode
+
+// Static mode: direct call to compiled-in SIMD level (no runtime switch)
+#if defined(COMPILE_SIMD_AVX512_SPR)
+#define DISPATCH_SIMDLevel(f, ...) return f<SIMDLevel::AVX512_SPR>(__VA_ARGS__)
+#elif defined(COMPILE_SIMD_AVX512)
+#define DISPATCH_SIMDLevel(f, ...) return f<SIMDLevel::AVX512>(__VA_ARGS__)
+#elif defined(COMPILE_SIMD_AVX2)
+#define DISPATCH_SIMDLevel(f, ...) return f<SIMDLevel::AVX2>(__VA_ARGS__)
+#elif defined(COMPILE_SIMD_ARM_SVE)
+#define DISPATCH_SIMDLevel(f, ...) return f<SIMDLevel::ARM_SVE>(__VA_ARGS__)
+#elif defined(COMPILE_SIMD_ARM_NEON)
+#define DISPATCH_SIMDLevel(f, ...) return f<SIMDLevel::ARM_NEON>(__VA_ARGS__)
+#else
+#define DISPATCH_SIMDLevel(f, ...) return f<SIMDLevel::NONE>(__VA_ARGS__)
+#endif
+
+#endif // FAISS_ENABLE_DD
+
+/**
+ * Dispatch to a lambda with SIMDLevel as a compile-time constant.
+ *
+ * This function calls the provided templated lambda with the current
+ * runtime SIMD level (from SIMDConfig::level) as a compile-time template
+ * argument. This enables SIMD-specialized code paths while keeping the
+ * dispatch logic centralized.
+ *
+ * The key benefit is that the SIMD dispatch happens once, outside any loops,
+ * so the loop body runs with the optimal SIMD implementation without
+ * per-iteration dispatch overhead.
+ *
+ * Example with a loop (the dispatch happens once, not per iteration):
+ *
+ *   std::vector<float> distances(n);
+ *   with_simd_level([&]<SIMDLevel level>() {
+ *       for (size_t i = 0; i < n; i++) {
+ *           distances[i] = fvec_L2sqr<level>(query, vectors + i * d, d);
+ *       }
+ *   });
+ *
+ * The lambda must be a generic lambda with a SIMDLevel template parameter.
+ *
+ * @param action A generic lambda with signature `template<SIMDLevel> T
+ * operator()()`
+ * @return The return value of the lambda
+ */
+template <typename LambdaType>
+inline auto with_simd_level(LambdaType&& action) {
+    DISPATCH_SIMDLevel(action.template operator());
+}
+
+} // namespace faiss

data/vendor/faiss/faiss/impl/simd_result_handlers.h

@@ -126,8 +126,8 @@ struct StoreResultHandler : SIMDResultHandler {
 
     void handle(size_t q, size_t b, simd16uint16 d0, simd16uint16 d1) final {
         size_t ofs = (q + i0) * ld + j0 + b * 32;
-        d0.store(data + ofs);
-        d1.store(data + ofs + 16);
+        d0.storeu(data + ofs);
+        d1.storeu(data + ofs + 16);
     }
 
     void set_block_origin(size_t i0_in, size_t j0_in) final {
@@ -406,10 +406,10 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
                 auto real_idx = this->adjust_id(b, j);
                 lt_mask -= 1 << j;
                 if (this->sel->is_member(real_idx)) {
-                    T dis_2 = d32tab[j];
-                    if (C::cmp(heap_dis[0], dis_2)) {
+                    T dis_for_j = d32tab[j];
+                    if (C::cmp(heap_dis[0], dis_for_j)) {
                         heap_replace_top<C>(
-                                k, heap_dis, heap_ids, dis_2, real_idx);
+                                k, heap_dis, heap_ids, dis_for_j, real_idx);
                         nup++;
                     }
                 }
@@ -419,10 +419,10 @@ struct HeapHandler : ResultHandlerCompare<C, with_id_map> {
                 // find first non-zero
                 int j = __builtin_ctz(lt_mask);
                 lt_mask -= 1 << j;
-                T dis_2 = d32tab[j];
-                if (C::cmp(heap_dis[0], dis_2)) {
+                T dis_for_j = d32tab[j];
+                if (C::cmp(heap_dis[0], dis_for_j)) {
                     int64_t idx = this->adjust_id(b, j);
-                    heap_replace_top<C>(k, heap_dis, heap_ids, dis_2, idx);
+                    heap_replace_top<C>(k, heap_dis, heap_ids, dis_for_j, idx);
                     nup++;
                 }
             }
@@ -524,8 +524,8 @@ struct ReservoirHandler : ResultHandlerCompare<C, with_id_map> {
                 auto real_idx = this->adjust_id(b, j);
                 lt_mask -= 1 << j;
                 if (this->sel->is_member(real_idx)) {
-                    T dis_2 = d32tab[j];
-                    res.add(dis_2, real_idx);
+                    T dis_for_j = d32tab[j];
+                    res.add(dis_for_j, real_idx);
                 }
             }
         } else {
@@ -533,8 +533,8 @@ struct ReservoirHandler : ResultHandlerCompare<C, with_id_map> {
                 // find first non-zero
                 int j = __builtin_ctz(lt_mask);
                 lt_mask -= 1 << j;
-                T dis_2 = d32tab[j];
-                res.add(dis_2, this->adjust_id(b, j));
+                T dis_for_j = d32tab[j];
+                res.add(dis_for_j, this->adjust_id(b, j));
             }
         }
     }
@@ -761,12 +761,12 @@ void dispatch_SIMDResultHandler_fixedCW(
         SIMDResultHandler& res,
         Consumer& consumer,
         Types... args) {
-    if (auto resh = dynamic_cast<SingleResultHandler<C, W>*>(&res)) {
-        consumer.template f<SingleResultHandler<C, W>>(*resh, args...);
-    } else if (auto resh_2 = dynamic_cast<HeapHandler<C, W>*>(&res)) {
-        consumer.template f<HeapHandler<C, W>>(*resh_2, args...);
-    } else if (auto resh_2 = dynamic_cast<ReservoirHandler<C, W>*>(&res)) {
-        consumer.template f<ReservoirHandler<C, W>>(*resh_2, args...);
+    if (auto resh_sh = dynamic_cast<SingleResultHandler<C, W>*>(&res)) {
+        consumer.template f<SingleResultHandler<C, W>>(*resh_sh, args...);
+    } else if (auto resh_hh = dynamic_cast<HeapHandler<C, W>*>(&res)) {
+        consumer.template f<HeapHandler<C, W>>(*resh_hh, args...);
+    } else if (auto resh_rh = dynamic_cast<ReservoirHandler<C, W>*>(&res)) {
+        consumer.template f<ReservoirHandler<C, W>>(*resh_rh, args...);
     } else { // generic handler -- will not be inlined
         FAISS_THROW_IF_NOT_FMT(
                 simd_result_handlers_accept_virtual,

data/vendor/faiss/faiss/index_factory.cpp

@@ -220,6 +220,9 @@ VectorTransform* parse_VectorTransform(const std::string& description, int d) {
     if (match("RR([0-9]+)?")) {
         return new RandomRotationMatrix(d, mres_to_int(sm[1], d));
     }
+    if (match("HR([0-9]+)?")) {
+        return new HadamardRotation(d, mres_to_int(sm[1], 12345));
+    }
     if (match("ITQ([0-9]+)?")) {
         return new ITQTransform(d, mres_to_int(sm[1], d), sm[1].length() > 0);
     }
@@ -585,7 +588,7 @@ SVSStorageKind parse_lvq(const std::string& lvq_string) {
     if (lvq_string == "LVQ4x8") {
         return SVSStorageKind::SVS_LVQ4x8;
     }
-    FAISS_ASSERT(!"not supported SVS LVQ level");
+    FAISS_ASSERT(false && "not supported SVS LVQ level");
 }
 
 SVSStorageKind parse_leanvec(const std::string& leanvec_string) {
@@ -598,7 +601,7 @@ SVSStorageKind parse_leanvec(const std::string& leanvec_string) {
     if (leanvec_string == "LeanVec8x8") {
         return SVSStorageKind::SVS_LeanVec8x8;
     }
-    FAISS_ASSERT(!"not supported SVS Leanvec level");
+    FAISS_ASSERT(false && "not supported SVS Leanvec level");
 }
 
 Index* parse_svs_datatype(
@@ -610,43 +613,49 @@ Index* parse_svs_datatype(
     std::smatch sm;
 
     if (datatype_string.empty()) {
-        if (index_type == "Vamana")
+        if (index_type == "Vamana") {
             return new IndexSVSVamana(d, std::stoul(arg_string), mt);
-        if (index_type == "Flat")
+        }
+        if (index_type == "Flat") {
             return new IndexSVSFlat(d, mt);
-        FAISS_ASSERT(!"Unspported SVS index type");
+        }
+        FAISS_ASSERT(false && "Unspported SVS index type");
     }
     if (re_match(datatype_string, "FP16", sm)) {
-        if (index_type == "Vamana")
+        if (index_type == "Vamana") {
             return new IndexSVSVamana(
                     d, std::stoul(arg_string), mt, SVSStorageKind::SVS_FP16);
-        FAISS_ASSERT(!"Unspported SVS index type for Float16");
+        }
+        FAISS_ASSERT(false && "Unspported SVS index type for Float16");
     }
     if (re_match(datatype_string, "SQI8", sm)) {
-        if (index_type == "Vamana")
+        if (index_type == "Vamana") {
             return new IndexSVSVamana(
                     d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQI8);
-        FAISS_ASSERT(!"Unspported SVS index type for SQI8");
+        }
+        FAISS_ASSERT(false && "Unspported SVS index type for SQI8");
     }
     if (re_match(datatype_string, "(LVQ[0-9]+x[0-9]+)", sm)) {
-        if (index_type == "Vamana")
+        if (index_type == "Vamana") {
             return new IndexSVSVamanaLVQ(
                     d, std::stoul(arg_string), mt, parse_lvq(sm[0].str()));
-        FAISS_ASSERT(!"Unspported SVS index type for LVQ");
+        }
+        FAISS_ASSERT(false && "Unspported SVS index type for LVQ");
     }
     if (re_match(datatype_string, "(LeanVec[0-9]+x[0-9]+)(_[0-9]+)?", sm)) {
         std::string leanvec_d_string =
                 sm[2].length() > 0 ? sm[2].str().substr(1) : "0";
-        int leanvec_d = std::stoul(leanvec_d_string);
+        int leanvec_d = static_cast<int>(std::stoul(leanvec_d_string));
 
-        if (index_type == "Vamana")
+        if (index_type == "Vamana") {
             return new IndexSVSVamanaLeanVec(
                     d,
                     std::stoul(arg_string),
                     mt,
                     leanvec_d,
                     parse_leanvec(sm[1].str()));
-        FAISS_ASSERT(!"Unspported SVS index type for LeanVec");
+        }
+        FAISS_ASSERT(false && "Unspported SVS index type for LeanVec");
     }
     return nullptr;
 }
@@ -659,7 +668,6 @@ Index* parse_IndexSVS(const std::string& code_string, int d, MetricType mt) {
         return parse_svs_datatype("Flat", "", datatype_string, d, mt);
     }
     if (re_match(code_string, "Vamana([0-9]+)(,.+)?", sm)) {
-        Index* index{nullptr};
         std::string degree_string = sm[1].str();
         std::string datatype_string =
                 sm[2].length() > 0 ? sm[2].str().substr(1) : "";
@@ -667,7 +675,7 @@ Index* parse_IndexSVS(const std::string& code_string, int d, MetricType mt) {
                 "Vamana", degree_string, datatype_string, d, mt);
     }
     if (re_match(code_string, "IVF([0-9]+)(,.+)?", sm)) {
-        FAISS_ASSERT(!"Unspported SVS index type");
+        FAISS_ASSERT(false && "Unspported SVS index type");
     }
     return nullptr;
 }
@@ -703,6 +711,17 @@ Index* parse_other_indexes(
         }
     }
 
+    // IndexFlatIPPanorama
+    if (match("FlatIPPanorama([0-9]+)(_[0-9]+)?")) {
+        FAISS_THROW_IF_NOT(metric == METRIC_INNER_PRODUCT);
+        int nlevels = std::stoi(sm[1].str());
+        if (sm[2].length() == 0) {
+            return new IndexFlatIPPanorama(d, nlevels);
+        }
+        int batch_size = std::stoi(sm[2].str().substr(1));
+        return new IndexFlatIPPanorama(d, nlevels, (size_t)batch_size);
+    }
+
     // IndexLSH
     if (match("LSH([0-9]*)(r?)(t?)")) {
         int nbits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : d;

data/vendor/faiss/faiss/index_io.h

@@ -11,13 +11,17 @@
 #define FAISS_INDEX_IO_H
 
 #include <cstdio>
+#include <memory>
 
 /** I/O functions can read/write to a filename, a file handle or to an
  * object that abstracts the medium.
  *
- * The read functions return objects that should be deallocated with
- * delete. All references within these objects are owned by the
- * object.
+ * The read functions come in two forms:
+ * - read_*_up() returns a std::unique_ptr that owns the result.
+ * - read_*() returns a raw pointer for backward compatibility.
+ *   The caller is responsible for deleting the returned object.
+ *
+ * All references within these objects are owned by the object.
  */
 
 namespace faiss {
@@ -68,25 +72,47 @@ Index* read_index(const char* fname, int io_flags = 0);
 Index* read_index(FILE* f, int io_flags = 0);
 Index* read_index(IOReader* reader, int io_flags = 0);
 
+std::unique_ptr<Index> read_index_up(const char* fname, int io_flags = 0);
+std::unique_ptr<Index> read_index_up(FILE* f, int io_flags = 0);
+std::unique_ptr<Index> read_index_up(IOReader* reader, int io_flags = 0);
+
 IndexBinary* read_index_binary(const char* fname, int io_flags = 0);
 IndexBinary* read_index_binary(FILE* f, int io_flags = 0);
 IndexBinary* read_index_binary(IOReader* reader, int io_flags = 0);
 
+std::unique_ptr<IndexBinary> read_index_binary_up(
+        const char* fname,
+        int io_flags = 0);
+std::unique_ptr<IndexBinary> read_index_binary_up(FILE* f, int io_flags = 0);
+std::unique_ptr<IndexBinary> read_index_binary_up(
+        IOReader* reader,
+        int io_flags = 0);
+
 void write_VectorTransform(const VectorTransform* vt, const char* fname);
 void write_VectorTransform(const VectorTransform* vt, IOWriter* f);
 
 VectorTransform* read_VectorTransform(const char* fname);
 VectorTransform* read_VectorTransform(IOReader* f);
 
+std::unique_ptr<VectorTransform> read_VectorTransform_up(const char* fname);
+std::unique_ptr<VectorTransform> read_VectorTransform_up(IOReader* f);
+
 ProductQuantizer* read_ProductQuantizer(const char* fname);
 ProductQuantizer* read_ProductQuantizer(IOReader* reader);
 
+std::unique_ptr<ProductQuantizer> read_ProductQuantizer_up(const char* fname);
+std::unique_ptr<ProductQuantizer> read_ProductQuantizer_up(IOReader* reader);
+
 void write_ProductQuantizer(const ProductQuantizer* pq, const char* fname);
 void write_ProductQuantizer(const ProductQuantizer* pq, IOWriter* f);
 
 void write_InvertedLists(const InvertedLists* ils, IOWriter* f);
 InvertedLists* read_InvertedLists(IOReader* reader, int io_flags = 0);
 
+std::unique_ptr<InvertedLists> read_InvertedLists_up(
+        IOReader* reader,
+        int io_flags = 0);
+
 } // namespace faiss
 
 #endif

data/vendor/faiss/faiss/invlists/BlockInvertedLists.cpp

@@ -7,6 +7,8 @@
 
 #include <faiss/invlists/BlockInvertedLists.h>
 
+#include <memory>
+
 #include <faiss/impl/CodePacker.h>
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/IDSelector.h>
@@ -81,7 +83,7 @@ const uint8_t* BlockInvertedLists::get_codes(size_t list_no) const {
 
 size_t BlockInvertedLists::remove_ids(const IDSelector& sel) {
     idx_t nremove = 0;
-#pragma omp parallel for
+#pragma omp parallel for reduction(+ : nremove)
     for (idx_t i = 0; i < nlist; i++) {
         std::vector<uint8_t> buffer(packer->code_size);
         idx_t l = ids[i].size(), j = 0;
@@ -95,8 +97,9 @@ size_t BlockInvertedLists::remove_ids(const IDSelector& sel) {
                 j++;
             }
         }
+        idx_t orig_size = ids[i].size();
         resize(i, l);
-        nremove += ids[i].size() - l;
+        nremove += orig_size - l;
     }
 
     return nremove;
@@ -160,7 +163,7 @@ void BlockInvertedListsIOHook::write(const InvertedLists* ils_in, IOWriter* f)
 
 InvertedLists* BlockInvertedListsIOHook::read(IOReader* f, int /* io_flags */)
         const {
-    BlockInvertedLists* il = new BlockInvertedLists();
+    auto il = std::make_unique<BlockInvertedLists>();
     READ1(il->nlist);
     READ1(il->code_size);
     READ1(il->n_per_block);
@@ -174,7 +177,7 @@ InvertedLists* BlockInvertedListsIOHook::read(IOReader* f, int /* io_flags */)
         READVECTOR(il->codes[i]);
     }
 
-    return il;
+    return il.release();
 }
 
 } // namespace faiss

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

@@ -314,7 +314,7 @@ void OnDiskInvertedLists::update_totsize(size_t new_size) {
             slots.push_back(Slot(totsize, new_size - totsize));
         }
     } else {
-        assert(!"not implemented");
+        assert(false && "not implemented");
     }
 
     totsize = new_size;

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

@@ -45,18 +45,6 @@
 // create svs_runtime as alias for svs::runtime::FAISS_SVS_RUNTIME_VERSION
 SVS_RUNTIME_CREATE_API_ALIAS(svs_runtime, FAISS_SVS_RUNTIME_VERSION);
 
-// SVS forward declarations
-namespace svs {
-namespace runtime {
-inline namespace v0 {
-struct FlatIndex;
-struct VamanaIndex;
-struct DynamicVamanaIndex;
-struct LeanVecTrainingData;
-} // namespace v0
-} // namespace runtime
-} // namespace svs
-
 namespace faiss {
 
 inline svs_runtime::MetricType to_svs_metric(faiss::MetricType metric) {
@@ -66,7 +54,7 @@ inline svs_runtime::MetricType to_svs_metric(faiss::MetricType metric) {
         case METRIC_L2:
             return svs_runtime::MetricType::L2;
         default:
-            FAISS_ASSERT(!"not supported SVS distance");
+            FAISS_ASSERT(false && "not supported SVS distance");
     }
 }
 
@@ -93,7 +81,8 @@ template <typename T, typename U, typename = void>
 struct InputBufferConverter {
     InputBufferConverter(std::span<const U> data = {}) : buffer(data.size()) {
         FAISS_ASSERT(
-                !"InputBufferConverter: there is no suitable user code for this type conversion");
+                false &&
+                "InputBufferConverter: there is no suitable user code for this type conversion");
         std::transform(
                 data.begin(), data.end(), buffer.begin(), [](const U& val) {
                     return static_cast<T>(val);
@@ -118,8 +107,8 @@ struct InputBufferConverter {
     std::vector<T> buffer;
 };
 
-// Specialization for reinterpret cast when types are integral and have the same
-// size
+// Specialization for reinterpret cast when types are integral and have
+// the same size
 template <typename T, typename U>
 struct InputBufferConverter<
         T,
@@ -153,7 +142,8 @@ struct OutputBufferConverter {
     OutputBufferConverter(std::span<U> data = {})
             : data_span(data), buffer(data.size()) {
         FAISS_ASSERT(
-                !"OutputBufferConverter: there is no suitable user code for this type conversion");
+                false &&
+                "OutputBufferConverter: there is no suitable user code for this type conversion");
     }
 
     ~OutputBufferConverter() {
@@ -176,8 +166,8 @@ struct OutputBufferConverter {
     std::vector<T> buffer;
 };
 
-// Specialization for reinterpret cast when types are integral and have the same
-// size
+// Specialization for reinterpret cast when types are integral and have
+// the same size
 template <typename T, typename U>
 struct OutputBufferConverter<
         T,

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

@@ -26,6 +26,8 @@
 #include <faiss/Index.h>
 #include <faiss/svs/IndexSVSFaissUtils.h>
 
+#include <svs/runtime/flat_index.h>
+
 #include <iostream>
 
 namespace faiss {

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

@@ -27,6 +27,7 @@
 #include <faiss/svs/IndexSVSFaissUtils.h>
 
 #include <svs/runtime/api_defs.h>
+#include <svs/runtime/dynamic_vamana_index.h>
 
 #include <iostream>
 
@@ -71,7 +72,7 @@ inline svs_runtime::StorageKind to_svs_storage_kind(SVSStorageKind kind) {
         case SVS_LeanVec8x8:
             return svs_runtime::StorageKind::LeanVec8x8;
         default:
-            FAISS_ASSERT(!"not supported SVS storage kind");
+            FAISS_ASSERT(false && "not supported SVS storage kind");
     }
 }
 

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

@@ -66,6 +66,14 @@ void IndexSVSVamanaLeanVec::add(idx_t n, const float* x) {
 }
 
 void IndexSVSVamanaLeanVec::train(idx_t n, const float* x) {
+    train(n, x, 0, nullptr);
+}
+
+void IndexSVSVamanaLeanVec::train(
+        idx_t n,
+        const float* x,
+        idx_t n_train_q,
+        const float* queries) {
     FAISS_THROW_IF_MSG(
             training_data || impl, "Index already trained or contains data.");
 
@@ -74,7 +82,7 @@ void IndexSVSVamanaLeanVec::train(idx_t n, const float* x) {
             "LVQ/LeanVec support not available on this platform or build");
 
     auto status = svs_runtime::LeanVecTrainingData::build(
-            &training_data, d, n, x, leanvec_d);
+            &training_data, d, n, x, n_train_q, queries, leanvec_d);
     if (!status.ok()) {
         FAISS_THROW_MSG(status.message());
     }

data/vendor/faiss/faiss/svs/IndexSVSVamanaLeanVec.h

@@ -41,8 +41,17 @@ struct IndexSVSVamanaLeanVec : IndexSVSVamana {
 
     void add(idx_t n, const float* x) override;
 
+    /* Default train assumes in-distribution data */
     void train(idx_t n, const float* x) override;
 
+    /* Generic train with out-of-distribution parameters.
+     * Out-of-distribution (OOD) means database vectors and queries _can_ be
+     * sampled from different distributions (e.g., cross-modal). More details in
+     * the original publication, arXiv:2312.16335.
+     */
+    void train(idx_t n, const float* x, idx_t n_train_q, const float* xq_train)
+            override;
+
     void serialize_training_data(std::ostream& out) const;
     void deserialize_training_data(std::istream& in);
 

data/vendor/faiss/faiss/utils/Heap.cpp

@@ -254,4 +254,50 @@ INSTANTIATE(CMax, float);
 INSTANTIATE(CMin, int32_t);
 INSTANTIATE(CMax, int32_t);
 
+/**********************************************************
+ * reorder_2_heaps
+ **********************************************************/
+
+template <class C>
+void reorder_2_heaps(
+        int64_t n,
+        int64_t k,
+        typename C::TI* __restrict labels,
+        float* __restrict distances,
+        int64_t k_base,
+        const typename C::TI* __restrict base_labels,
+        const float* __restrict base_distances) {
+#pragma omp parallel for if (n > 1)
+    for (int64_t i = 0; i < n; i++) {
+        typename C::TI* idxo = labels + i * k;
+        float* diso = distances + i * k;
+        const typename C::TI* idxi = base_labels + i * k_base;
+        const float* disi = base_distances + i * k_base;
+
+        heap_heapify<C>(k, diso, idxo, disi, idxi, k);
+        if (k_base != k) { // add remaining elements
+            heap_addn<C>(k, diso, idxo, disi + k, idxi + k, k_base - k);
+        }
+        heap_reorder<C>(k, diso, idxo);
+    }
+}
+
+template void reorder_2_heaps<CMax<float, int64_t>>(
+        int64_t n,
+        int64_t k,
+        int64_t* __restrict labels,
+        float* __restrict distances,
+        int64_t k_base,
+        const int64_t* __restrict base_labels,
+        const float* __restrict base_distances);
+
+template void reorder_2_heaps<CMin<float, int64_t>>(
+        int64_t n,
+        int64_t k,
+        int64_t* __restrict labels,
+        float* __restrict distances,
+        int64_t k_base,
+        const int64_t* __restrict base_labels,
+        const float* __restrict base_distances);
+
 } // namespace faiss