faiss 0.6.0 → 0.6.2

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;
 }
@@ -56,7 +57,7 @@ IndexSVSVamanaLeanVec::~IndexSVSVamanaLeanVec() {
         FAISS_ASSERT(status.ok());
         training_data = nullptr;
     }
-    IndexSVSVamana::~IndexSVSVamana();
+    // Base class destructor handles impl cleanup
 }
 
 void IndexSVSVamanaLeanVec::add(idx_t n, const float* x) {
@@ -66,10 +67,10 @@ void IndexSVSVamanaLeanVec::add(idx_t n, const float* x) {
 }
 
 void IndexSVSVamanaLeanVec::train(idx_t n, const float* x) {
-    train(n, x, 0, nullptr);
+    train_with_queries(n, x, 0, nullptr);
 }
 
-void IndexSVSVamanaLeanVec::train(
+void IndexSVSVamanaLeanVec::train_with_queries(
         idx_t n,
         const float* x,
         idx_t n_train_q,
@@ -91,6 +92,15 @@ void IndexSVSVamanaLeanVec::train(
     is_trained = true;
 }
 
+void IndexSVSVamanaLeanVec::reset() {
+    if (training_data) {
+        auto status = svs_runtime::LeanVecTrainingData::destroy(training_data);
+        FAISS_ASSERT(status.ok());
+        training_data = nullptr;
+    }
+    IndexSVSVamana::reset();
+}
+
 void IndexSVSVamanaLeanVec::serialize_training_data(std::ostream& out) const {
     FAISS_THROW_IF_NOT_MSG(
             training_data, "Cannot serialize: Training data not initialized.");
@@ -111,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);
@@ -127,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);
 }

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

@@ -35,7 +35,8 @@ struct IndexSVSVamanaLeanVec : IndexSVSVamana {
             size_t degree,
             MetricType metric = METRIC_L2,
             size_t leanvec_dims = 0,
-            SVSStorageKind storage = SVSStorageKind::SVS_LeanVec4x4);
+            SVSStorageKind storage = SVSStorageKind::SVS_LeanVec4x4,
+            bool is_static = false);
 
     ~IndexSVSVamanaLeanVec() override;
 
@@ -49,8 +50,13 @@ struct IndexSVSVamanaLeanVec : IndexSVSVamana {
      * 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 train_with_queries(
+            idx_t n,
+            const float* x,
+            idx_t n_train_q,
+            const float* xq_train) override;
+
+    void reset() override;
 
     void serialize_training_data(std::ostream& out) const;
     void deserialize_training_data(std::istream& in);
@@ -61,7 +67,7 @@ struct IndexSVSVamanaLeanVec : IndexSVSVamana {
     svs_runtime::LeanVecTrainingData* training_data{nullptr};
 
    protected:
-    void create_impl() override;
+    void create_impl(idx_t n, const float* x) override;
 };
 
 } // namespace faiss

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

@@ -17,7 +17,7 @@ namespace faiss {
 template <typename C>
 void HeapArray<C>::heapify() {
 #pragma omp parallel for
-    for (int64_t j = 0; j < nh; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(nh); j++) {
         heap_heapify<C>(k, val + j * k, ids + j * k);
     }
 }
@@ -25,7 +25,7 @@ void HeapArray<C>::heapify() {
 template <typename C>
 void HeapArray<C>::reorder() {
 #pragma omp parallel for
-    for (int64_t j = 0; j < nh; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(nh); j++) {
         heap_reorder<C>(k, val + j * k, ids + j * k);
     }
 }
@@ -37,7 +37,7 @@ void HeapArray<C>::addn(size_t nj, const T* vin, TI j0, size_t i0, int64_t ni) {
     }
     assert(i0 >= 0 && i0 + ni <= nh);
 #pragma omp parallel for if (ni * nj > 100000)
-    for (int64_t i = i0; i < i0 + ni; i++) {
+    for (int64_t i = i0; i < static_cast<int64_t>(i0) + ni; i++) {
         T* __restrict simi = get_val(i);
         TI* __restrict idxi = get_ids(i);
         const T* ip_line = vin + (i - i0) * nj;
@@ -68,7 +68,7 @@ void HeapArray<C>::addn_with_ids(
     }
     assert(i0 >= 0 && i0 + ni <= nh);
 #pragma omp parallel for if (ni * nj > 100000)
-    for (int64_t i = i0; i < i0 + ni; i++) {
+    for (int64_t i = i0; i < static_cast<int64_t>(i0) + ni; i++) {
         T* __restrict simi = get_val(i);
         TI* __restrict idxi = get_ids(i);
         const T* ip_line = vin + (i - i0) * nj;
@@ -96,7 +96,7 @@ void HeapArray<C>::addn_query_subset_with_ids(
         id_stride = nj;
     }
 #pragma omp parallel for if (nsubset * nj > 100000)
-    for (int64_t si = 0; si < nsubset; si++) {
+    for (int64_t si = 0; si < static_cast<int64_t>(nsubset); si++) {
         TI i = subset[si];
         T* __restrict simi = get_val(i);
         TI* __restrict idxi = get_ids(i);
@@ -115,7 +115,7 @@ void HeapArray<C>::addn_query_subset_with_ids(
 template <typename C>
 void HeapArray<C>::per_line_extrema(T* out_val, TI* out_ids) const {
 #pragma omp parallel for if (nh * k > 100000)
-    for (int64_t j = 0; j < nh; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(nh); j++) {
         int64_t imin = -1;
         typename C::T xval = C::Crev::neutral();
         const typename C::T* x_ = val + j * k;
@@ -187,7 +187,7 @@ void merge_knn_results(
         std::vector<distance_t> buf2(nshard);
         distance_t* heap_vals = buf2.data();
 #pragma omp for
-        for (long i = 0; i < n; i++) {
+        for (long i = 0; i < static_cast<long>(n); i++) {
             // the heap maps values to the shard where they are
             // produced.
             const distance_t* D_in = all_distances + i * k;
@@ -195,7 +195,7 @@ void merge_knn_results(
             int heap_size = 0;
 
             // push the first element of each shard (if not -1)
-            for (long s = 0; s < nshard; s++) {
+            for (long s = 0; s < static_cast<long>(nshard); s++) {
                 pointer[s] = 0;
                 if (I_in[stride * s] >= 0) {
                     heap_push<C>(
@@ -210,7 +210,7 @@ void merge_knn_results(
             distance_t* D = distances + i * k;
             idx_t* I = labels + i * k;
 
-            int j;
+            size_t j;
             for (j = 0; j < k && heap_size > 0; j++) {
                 // pop element from best shard
                 int s = shard_ids[0]; // top of heap
@@ -221,7 +221,7 @@ void merge_knn_results(
                 // pop from shard, advance pointer for this shard
                 heap_pop<C>(heap_size--, heap_vals, shard_ids);
                 p++;
-                if (p < k && I_in[stride * s + p] >= 0) {
+                if (static_cast<size_t>(p) < k && I_in[stride * s + p] >= 0) {
                     heap_push<C>(
                             ++heap_size,
                             heap_vals,

data/vendor/faiss/faiss/utils/NeuralNet.cpp

@@ -80,12 +80,12 @@ template struct Tensor2DTemplate<int32_t>;
  * Layers implementation
  *************************************************************/
 
-Linear::Linear(size_t in_features, size_t out_features, bool bias)
-        : in_features(in_features),
-          out_features(out_features),
-          weight(in_features * out_features) {
-    if (bias) {
-        this->bias.resize(out_features);
+Linear::Linear(size_t in_features_in, size_t out_features_in, bool bias_in)
+        : in_features(in_features_in),
+          out_features(out_features_in),
+          weight(in_features_in * out_features_in) {
+    if (bias_in) {
+        this->bias.resize(out_features_in);
     }
 }
 
@@ -123,9 +123,9 @@ Tensor2D Linear::operator()(const Tensor2D& x) const {
     return output;
 }
 
-Embedding::Embedding(size_t num_embeddings, size_t embedding_dim)
-        : num_embeddings(num_embeddings), embedding_dim(embedding_dim) {
-    weight.resize(num_embeddings * embedding_dim);
+Embedding::Embedding(size_t num_embeddings_in, size_t embedding_dim_in)
+        : num_embeddings(num_embeddings_in), embedding_dim(embedding_dim_in) {
+    weight.resize(num_embeddings_in * embedding_dim_in);
 }
 
 Tensor2D Embedding::operator()(const Int32Tensor2D& code) const {
@@ -181,8 +181,13 @@ Tensor2D FFN::operator()(const Tensor2D& x_in) const {
 
 using namespace nn;
 
-QINCoStep::QINCoStep(int d, int K, int L, int h)
-        : d(d), K(K), L(L), h(h), codebook(K, d), MLPconcat(2 * d, d) {
+QINCoStep::QINCoStep(int d_in, int K_in, int L_in, int h_in)
+        : d(d_in),
+          K(K_in),
+          L(L_in),
+          h(h_in),
+          codebook(K_in, d_in),
+          MLPconcat(2 * d_in, d_in) {
     for (int i = 0; i < L; i++) {
         residual_blocks.emplace_back(d, h);
     }
@@ -208,7 +213,8 @@ nn::Int32Tensor2D QINCoStep::encode(
         nn::Tensor2D* residuals) const {
     size_t n = xhat.shape[0];
     FAISS_THROW_IF_NOT(
-            n == x.shape[0] && xhat.shape[1] == d && x.shape[1] == d);
+            n == x.shape[0] && xhat.shape[1] == static_cast<size_t>(d) &&
+            x.shape[1] == static_cast<size_t>(d));
 
     // repeated codebook
     Tensor2D zqs_r(n * K, d);  // size n, K, d
@@ -226,7 +232,7 @@ nn::Int32Tensor2D QINCoStep::encode(
 
     // manual broadcasting
     for (size_t i = 0; i < n; i++) {
-        for (size_t j = 0; j < K; j++) {
+        for (size_t j = 0; j < static_cast<size_t>(K); j++) {
             copy_row(zqs_r, i * K + j, 0, codebook.data() + j * d);
             copy_row(cc, i * K + j, 0, codebook.data() + j * d);
             copy_row(cc, i * K + j, d, xhat.data() + i * d);
@@ -244,8 +250,8 @@ nn::Int32Tensor2D QINCoStep::encode(
     for (size_t i = 0; i < n; i++) {
         float* zqs_r_row = zqs_r.data() + i * K * d;
         const float* xhat_row = xhat.data() + i * d;
-        for (size_t l = 0; l < K; l++) {
-            for (size_t j = 0; j < d; j++) {
+        for (size_t l = 0; l < static_cast<size_t>(K); l++) {
+            for (size_t j = 0; j < static_cast<size_t>(d); j++) {
                 zqs_r_row[j] += xhat_row[j];
             }
             zqs_r_row += d;
@@ -257,17 +263,18 @@ nn::Int32Tensor2D QINCoStep::encode(
     float* res = nullptr;
     if (residuals) {
         FAISS_THROW_IF_NOT(
-                residuals->shape[0] == n && residuals->shape[1] == d);
+                residuals->shape[0] == n &&
+                residuals->shape[1] == static_cast<size_t>(d));
         res = residuals->data();
     }
 
-    for (size_t i = 0; i < n; i++) {
-        const float* q = x.data() + i * d;
-        const float* db = zqs_r.data() + i * K * d;
-        float dis_min = HUGE_VALF;
-        int64_t idx = -1;
-        with_simd_level([&]<SIMDLevel SL>() {
-            for (size_t j = 0; j < K; j++) {
+    with_simd_level([&]<SIMDLevel SL>() {
+        for (size_t i = 0; i < n; i++) {
+            const float* q = x.data() + i * d;
+            const float* db = zqs_r.data() + i * K * d;
+            float dis_min = HUGE_VALF;
+            int64_t idx = -1;
+            for (size_t j = 0; j < static_cast<size_t>(K); j++) {
                 float dis = fvec_L2sqr<SL>(q, db, d);
                 if (dis < dis_min) {
                     dis_min = dis;
@@ -275,17 +282,17 @@ nn::Int32Tensor2D QINCoStep::encode(
                 }
                 db += d;
             }
-        });
-        codes.v[i] = idx;
-        if (res) {
-            const float* xhat_row = xhat.data() + i * d;
-            const float* xhat_next_row = zqs_r.data() + (i * K + idx) * d;
-            for (size_t j = 0; j < d; j++) {
-                res[j] = xhat_next_row[j] - xhat_row[j];
+            codes.v[i] = idx;
+            if (res) {
+                const float* xhat_row = xhat.data() + i * d;
+                const float* xhat_next_row = zqs_r.data() + (i * K + idx) * d;
+                for (size_t j = 0; j < static_cast<size_t>(d); j++) {
+                    res[j] = xhat_next_row[j] - xhat_row[j];
+                }
+                res += d;
             }
-            res += d;
         }
-    }
+    });
     return codes;
 }
 
@@ -293,15 +300,19 @@ nn::Int32Tensor2D QINCoStep::encode(
  * QINCo implementation
  *************************************************************/
 
-QINCo::QINCo(int d, int K, int L, int M, int h)
-        : NeuralNetCodec(d, M), K(K), L(L), h(h), codebook0(K, d) {
+QINCo::QINCo(int d_in, int K_in, int L_in, int M_in, int h_in)
+        : NeuralNetCodec(d_in, M_in),
+          K(K_in),
+          L(L_in),
+          h(h_in),
+          codebook0(K_in, d_in) {
     for (int i = 1; i < M; i++) {
         steps.emplace_back(d, K, L, h);
     }
 }
 
 nn::Tensor2D QINCo::decode(const nn::Int32Tensor2D& codes) const {
-    FAISS_THROW_IF_NOT(codes.shape[1] == M);
+    FAISS_THROW_IF_NOT(codes.shape[1] == static_cast<size_t>(M));
     Tensor2D xhat = codebook0(codes.column(0));
     for (int i = 1; i < M; i++) {
         xhat += steps[i - 1].decode(xhat, codes.column(i));
@@ -310,7 +321,7 @@ nn::Tensor2D QINCo::decode(const nn::Int32Tensor2D& codes) const {
 }
 
 nn::Int32Tensor2D QINCo::encode(const nn::Tensor2D& x) const {
-    FAISS_THROW_IF_NOT(x.shape[1] == d);
+    FAISS_THROW_IF_NOT(x.shape[1] == static_cast<size_t>(d));
     size_t n = x.shape[0];
     Int32Tensor2D codes(n, M);
     Tensor2D xhat(n, d);

data/vendor/faiss/faiss/utils/NeuralNet.h

@@ -118,7 +118,7 @@ struct QINCoStep {
 struct NeuralNetCodec {
     int d, M;
 
-    NeuralNetCodec(int d, int M) : d(d), M(M) {}
+    NeuralNetCodec(int d_in, int M_in) : d(d_in), M(M_in) {}
 
     virtual nn::Tensor2D decode(const nn::Int32Tensor2D& codes) const = 0;
     virtual nn::Int32Tensor2D encode(const nn::Tensor2D& x) const = 0;

data/vendor/faiss/faiss/utils/approx_topk_hamming/approx_topk_hamming.h

@@ -11,12 +11,17 @@
 #include <limits>
 #include <utility>
 
+#include <faiss/impl/simdlib/simdlib_dispatch.h>
 #include <faiss/utils/Heap.h>
-#include <faiss/utils/simdlib.h>
 
 namespace faiss {
 
-// HeapWithBucketsForHamming32 uses simd8uint32 under the hood.
+// Explicit SIMD-level aliases for this file (no global bare aliases).
+using simd8uint32 = simd8uint32_tpl<SINGLE_SIMD_LEVEL_256>;
+using simd16uint16 = simd16uint16_tpl<SINGLE_SIMD_LEVEL_256>;
+
+// HeapWithBucketsForHamming32 uses simd8uint32 under the
+// hood.
 
 template <typename C, uint32_t NBUCKETS, uint32_t N, typename HammingComputerT>
 struct HeapWithBucketsForHamming32 {
@@ -197,8 +202,9 @@ struct HeapWithBucketsForHamming32<
     }
 };
 
-// HeapWithBucketsForHamming16 uses simd16uint16 under the hood.
-// Less registers needed in total, so higher values of NBUCKETS/N can be used,
+// HeapWithBucketsForHamming16 uses simd16uint16 under
+// the hood. Less registers needed in total, so higher values of NBUCKETS/N can
+// be used,
 //   but somewhat slower.
 // No more than 32K elements currently, but it can be reorganized a bit
 //   to be limited to 32K elements per beam.

data/vendor/faiss/faiss/utils/bf16.h

@@ -7,8 +7,13 @@
 
 #pragma once
 
+#include <cstddef>
 #include <cstdint>
 
+#if defined(__AVX512F__) || defined(__AVX512BF16__)
+#include <immintrin.h>
+#endif
+
 namespace faiss {
 
 namespace {
@@ -33,4 +38,33 @@ inline float decode_bf16(const uint16_t v) {
     return fp.as_f32;
 }
 
+inline void encode_bf16_simd(const float* src, uint16_t* dst, size_t n) {
+    size_t i = 0;
+#ifdef __AVX512BF16__
+    for (; i + 16 <= n; i += 16) {
+        __m512 v = _mm512_loadu_ps(src + i);
+        __m256bh encoded = _mm512_cvtneps_pbh(v);
+        _mm256_storeu_epi16(dst + i, (__m256i)encoded);
+    }
+#endif
+    for (; i < n; i++) {
+        dst[i] = encode_bf16(src[i]);
+    }
+}
+
+inline void decode_bf16_simd(const uint16_t* src, float* dst, size_t n) {
+    size_t i = 0;
+#if defined(__AVX512F__)
+    for (; i + 16 <= n; i += 16) {
+        __m256i v = _mm256_loadu_si256((const __m256i*)(src + i));
+        __m512i w = _mm512_cvtepu16_epi32(v);
+        w = _mm512_slli_epi32(w, 16);
+        _mm512_storeu_ps(dst + i, _mm512_castsi512_ps(w));
+    }
+#endif
+    for (; i < n; i++) {
+        dst[i] = decode_bf16(src[i]);
+    }
+}
+
 } // namespace faiss