faiss 0.3.4 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc3446fb52271b6e55c4e0ba64cf7146d8bcff39316803e9e7fac68caa0b1d7d
-  data.tar.gz: fb3bdc9c66b670413df99c0f1d914fd4861ccce30e11a1f959fb570d62d7dca0
+  metadata.gz: 94cc2ecdeb397dfce274b08f07006ec7d6d13290f4149d8fca0b9d1a3f2312c6
+  data.tar.gz: a32b28f7bc57f9bad918b0411855617951ce8013af7f1ca9dfc72978f5eb1f78
 SHA512:
-  metadata.gz: b56a61bbe96f7aa628b0eb819b9404c6c48fba6f2c6cf3802d32fad52a8cbb1abbf97e09700c5d2b22faafef7ba2c5424839f7e98dacbb32d86a60c565c1b9f1
-  data.tar.gz: dce96c87b15ee7708e1c08f5f7ab4d04c1fb2f4399d5d423cb1ab9de7099ffc0a1bb81a968fb527562bd3d42d1cd131e60fc80cff668de6fa8270c7a81dec8a5
+  metadata.gz: 317786c14bbd6803a8abd506881e7072dbd8bfaacce3968c8c26705de45f1840177f5fb3ce189b464e5f1bbffd07a277d6f454a977e1e2aef72bdfb7d7cd04a7
+  data.tar.gz: 4de11b05b094b18beaa0326e5d4bf2d7a71c1928b7bd7d12f28f430f7b40b023c6c7b7a4da73f74bc39b0be44c85677113597cf6b60ae4029a96bd11a41f706c

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.4.1 (2025-06-18)
+
+- Fixed error with Rice 4.6
+
+## 0.4.0 (2025-04-25)
+
+- Updated Faiss to 1.11.0
+- Dropped support for Ruby < 3.2
+
 ## 0.3.4 (2025-02-10)
 
 - Fixed error with Rice 4.5

data/ext/faiss/ext.cpp

@@ -1,4 +1,4 @@
-#include "utils.h"
+#include <rice/rice.hpp>
 
 void init_index(Rice::Module& m);
 void init_index_binary(Rice::Module& m);
@@ -7,8 +7,7 @@ void init_pca_matrix(Rice::Module& m);
 void init_product_quantizer(Rice::Module& m);
 
 extern "C"
-void Init_ext()
-{
+void Init_ext() {
   auto m = Rice::define_module("Faiss");
 
   init_index(m);

data/ext/faiss/index.cpp

@@ -1,3 +1,6 @@
+#include <string>
+
+#include <faiss/AutoTune.h>
 #include <faiss/Index.h>
 #include <faiss/IndexFlat.h>
 #include <faiss/IndexHNSW.h>
@@ -9,20 +12,20 @@
 #include <faiss/IndexIVFPQ.h>
 #include <faiss/IndexIVFPQR.h>
 #include <faiss/index_io.h>
-#include <faiss/AutoTune.h>
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
 
+#include "numo.hpp"
 #include "utils.h"
 
 namespace Rice::detail {
   template<>
-  struct Type<faiss::MetricType>
-  {
+  struct Type<faiss::MetricType> {
     static bool verify() { return true; }
   };
 
   template<>
-  class From_Ruby<faiss::MetricType>
-  {
+  class From_Ruby<faiss::MetricType> {
   public:
     From_Ruby() = default;
 
@@ -30,8 +33,7 @@ namespace Rice::detail {
 
     Convertible is_convertible(VALUE value) { return Convertible::Cast; }
 
-    faiss::MetricType convert(VALUE x)
-    {
+    faiss::MetricType convert(VALUE x) {
       if (x == Qnil && this->arg_ && this->arg_->hasDefaultValue()) {
         return this->arg_->defaultValue<faiss::MetricType>();
       }
@@ -51,19 +53,16 @@ namespace Rice::detail {
   };
 
   template<>
-  struct Type<faiss::ScalarQuantizer::QuantizerType>
-  {
+  struct Type<faiss::ScalarQuantizer::QuantizerType> {
     static bool verify() { return true; }
   };
 
   template<>
-  class From_Ruby<faiss::ScalarQuantizer::QuantizerType>
-  {
+  class From_Ruby<faiss::ScalarQuantizer::QuantizerType> {
   public:
     Convertible is_convertible(VALUE value) { return Convertible::Cast; }
 
-    faiss::ScalarQuantizer::QuantizerType convert(VALUE x)
-    {
+    faiss::ScalarQuantizer::QuantizerType convert(VALUE x) {
       auto s = Object(x).to_s().str();
       if (s == "qt_8bit") {
         return faiss::ScalarQuantizer::QT_8bit;
@@ -84,7 +83,7 @@ namespace Rice::detail {
       }
     }
   };
-}
+} // namespace Rice::detail
 
 void init_index(Rice::Module& m) {
   Rice::define_class_under<faiss::Index>(m, "Index")

data/ext/faiss/index_binary.cpp

@@ -3,7 +3,9 @@
 #include <faiss/IndexBinaryIVF.h>
 #include <faiss/index_factory.h>
 #include <faiss/index_io.h>
+#include <rice/rice.hpp>
 
+#include "numo.hpp"
 #include "utils.h"
 
 void init_index_binary(Rice::Module& m) {

data/ext/faiss/kmeans.cpp

@@ -1,6 +1,8 @@
 #include <faiss/Clustering.h>
 #include <faiss/IndexFlat.h>
+#include <rice/rice.hpp>
 
+#include "numo.hpp"
 #include "utils.h"
 
 void init_kmeans(Rice::Module& m) {

data/ext/faiss/pca_matrix.cpp

@@ -1,5 +1,7 @@
 #include <faiss/VectorTransform.h>
+#include <rice/rice.hpp>
 
+#include "numo.hpp"
 #include "utils.h"
 
 void init_pca_matrix(Rice::Module& m) {

data/ext/faiss/product_quantizer.cpp

@@ -1,6 +1,8 @@
 #include <faiss/impl/ProductQuantizer.h>
 #include <faiss/index_io.h>
+#include <rice/rice.hpp>
 
+#include "numo.hpp"
 #include "utils.h"
 
 void init_product_quantizer(Rice::Module& m) {

data/ext/faiss/utils.cpp

@@ -1,3 +1,6 @@
+#include <rice/rice.hpp>
+
+#include "numo.hpp"
 #include "utils.h"
 
 size_t check_shape(const numo::NArray& objects, size_t k) {

data/lib/faiss/version.rb

@@ -1,3 +1,3 @@
 module Faiss
-  VERSION = "0.3.4"
+  VERSION = "0.4.1"
 end

data/vendor/faiss/faiss/AutoTune.cpp

@@ -15,7 +15,6 @@
 
 #include <cinttypes>
 #include <cmath>
-#include <typeinfo>
 
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/random.h>
@@ -313,9 +312,6 @@ bool ParameterSpace::combination_ge(size_t c1, size_t c2) const {
     return true;
 }
 
-#define DC(classname) \
-    const classname* ix = dynamic_cast<const classname*>(index)
-
 static void init_pq_ParameterRange(
         const ProductQuantizer& pq,
         ParameterRange& pr) {
@@ -339,6 +335,10 @@ ParameterRange& ParameterSpace::add_range(const std::string& name) {
     return parameter_ranges.back();
 }
 
+// Do not use this macro if ix will be unused
+#define DC(classname) \
+    const classname* ix = dynamic_cast<const classname*>(index)
+
 /// initialize with reasonable parameters for this type of index
 void ParameterSpace::initialize(const Index* index) {
     if (DC(IndexPreTransform)) {
@@ -394,7 +394,7 @@ void ParameterSpace::initialize(const Index* index) {
                     std::numeric_limits<double>::infinity());
         }
     }
-    if (DC(IndexIVFPQR)) {
+    if (dynamic_cast<const IndexIVFPQR*>(index)) {
         ParameterRange& pr = add_range("k_factor");
         for (int i = 0; i <= 6; i++) {
             pr.values.push_back(1 << i);
@@ -410,9 +410,6 @@ void ParameterSpace::initialize(const Index* index) {
 
 #undef DC
 
-// non-const version
-#define DC(classname) classname* ix = dynamic_cast<classname*>(index)
-
 /// set a combination of parameters on an index
 void ParameterSpace::set_index_parameters(Index* index, size_t cno) const {
     for (int i = 0; i < parameter_ranges.size(); i++) {
@@ -442,6 +439,10 @@ void ParameterSpace::set_index_parameters(
     }
 }
 
+// non-const version
+// Do not use this macro if ix will be unused
+#define DC(classname) classname* ix = dynamic_cast<classname*>(index)
+
 void ParameterSpace::set_index_parameter(
         Index* index,
         const std::string& name,
@@ -574,6 +575,8 @@ void ParameterSpace::set_index_parameter(
             name.c_str());
 }
 
+#undef DC
+
 void ParameterSpace::display() const {
     printf("ParameterSpace, %zd parameters, %zd combinations:\n",
            parameter_ranges.size(),

data/vendor/faiss/faiss/Clustering.cpp

@@ -33,22 +33,6 @@ Clustering::Clustering(int d, int k) : d(d), k(k) {}
 Clustering::Clustering(int d, int k, const ClusteringParameters& cp)
         : ClusteringParameters(cp), d(d), k(k) {}
 
-static double imbalance_factor(int n, int k, int64_t* assign) {
-    std::vector<int> hist(k, 0);
-    for (int i = 0; i < n; i++)
-        hist[assign[i]]++;
-
-    double tot = 0, uf = 0;
-
-    for (int i = 0; i < k; i++) {
-        tot += hist[i];
-        uf += hist[i] * (double)hist[i];
-    }
-    uf = uf * k / (tot * tot);
-
-    return uf;
-}
-
 void Clustering::post_process_centroids() {
     if (spherical) {
         fvec_renorm_L2(d, k, centroids.data());

data/vendor/faiss/faiss/IVFlib.cpp

@@ -9,6 +9,7 @@
 #include <omp.h>
 
 #include <memory>
+#include <numeric>
 
 #include <faiss/IndexAdditiveQuantizer.h>
 #include <faiss/IndexIVFAdditiveQuantizer.h>
@@ -16,7 +17,9 @@
 #include <faiss/IndexPreTransform.h>
 #include <faiss/IndexRefine.h>
 #include <faiss/MetaIndexes.h>
+#include <faiss/clone_index.h>
 #include <faiss/impl/FaissAssert.h>
+#include <faiss/index_io.h>
 #include <faiss/utils/distances.h>
 #include <faiss/utils/hamming.h>
 #include <faiss/utils/utils.h>
@@ -198,12 +201,32 @@ static void shift_and_add(
     memcpy(dst.data() + insert_point, src.data(), src.size() * sizeof(T));
 }
 
+template <class T>
+static void shift_and_add(
+        MaybeOwnedVector<T>& dst,
+        size_t remove,
+        const MaybeOwnedVector<T>& src) {
+    if (remove > 0)
+        memmove(dst.data(),
+                dst.data() + remove,
+                (dst.size() - remove) * sizeof(T));
+    size_t insert_point = dst.size() - remove;
+    dst.resize(insert_point + src.size());
+    memcpy(dst.data() + insert_point, src.data(), src.size() * sizeof(T));
+}
+
 template <class T>
 static void remove_from_begin(std::vector<T>& v, size_t remove) {
     if (remove > 0)
         v.erase(v.begin(), v.begin() + remove);
 }
 
+template <class T>
+static void remove_from_begin(MaybeOwnedVector<T>& v, size_t remove) {
+    if (remove > 0)
+        v.erase(v.begin(), v.begin() + remove);
+}
+
 void SlidingIndexWindow::step(const Index* sub_index, bool remove_oldest) {
     FAISS_THROW_IF_NOT_MSG(
             !remove_oldest || n_slice > 0,
@@ -519,5 +542,195 @@ void ivf_residual_add_from_flat_codes(
     index->ntotal += nb;
 }
 
+int64_t DefaultShardingFunction::operator()(int64_t i, int64_t shard_count) {
+    return i % shard_count;
+}
+
+void handle_ivf(
+        faiss::IndexIVF* index,
+        int64_t shard_count,
+        const std::string& filename_template,
+        ShardingFunction* sharding_function,
+        bool generate_ids) {
+    std::vector<faiss::IndexIVF*> sharded_indexes(shard_count);
+    auto clone = static_cast<faiss::IndexIVF*>(faiss::clone_index(index));
+    clone->quantizer->reset();
+    for (int64_t i = 0; i < shard_count; i++) {
+        sharded_indexes[i] =
+                static_cast<faiss::IndexIVF*>(faiss::clone_index(clone));
+        if (generate_ids) {
+            // Assume the quantizer does not natively support add_with_ids.
+            sharded_indexes[i]->quantizer =
+                    new IndexIDMap2(sharded_indexes[i]->quantizer);
+        }
+    }
+
+    // assign centroids to each sharded Index based on sharding_function, and
+    // add them to the quantizer of each sharded index
+    std::vector<std::vector<float>> sharded_centroids(shard_count);
+    std::vector<std::vector<idx_t>> xids(shard_count);
+    for (int64_t i = 0; i < index->quantizer->ntotal; i++) {
+        int64_t shard_id = (*sharding_function)(i, shard_count);
+        // Since the quantizer does not natively support add_with_ids, we simply
+        // generate them.
+        xids[shard_id].push_back(i);
+        float* reconstructed = new float[index->quantizer->d];
+        index->quantizer->reconstruct(i, reconstructed);
+        sharded_centroids[shard_id].insert(
+                sharded_centroids[shard_id].end(),
+                &reconstructed[0],
+                &reconstructed[index->quantizer->d]);
+        delete[] reconstructed;
+    }
+    for (int64_t i = 0; i < shard_count; i++) {
+        if (generate_ids) {
+            sharded_indexes[i]->quantizer->add_with_ids(
+                    sharded_centroids[i].size() / index->quantizer->d,
+                    sharded_centroids[i].data(),
+                    xids[i].data());
+        } else {
+            sharded_indexes[i]->quantizer->add(
+                    sharded_centroids[i].size() / index->quantizer->d,
+                    sharded_centroids[i].data());
+        }
+    }
+
+    for (int64_t i = 0; i < shard_count; i++) {
+        char fname[256];
+        snprintf(fname, 256, filename_template.c_str(), i);
+        faiss::write_index(sharded_indexes[i], fname);
+    }
+
+    for (int64_t i = 0; i < shard_count; i++) {
+        delete sharded_indexes[i];
+    }
+}
+
+void handle_binary_ivf(
+        faiss::IndexBinaryIVF* index,
+        int64_t shard_count,
+        const std::string& filename_template,
+        ShardingFunction* sharding_function,
+        bool generate_ids) {
+    std::vector<faiss::IndexBinaryIVF*> sharded_indexes(shard_count);
+
+    auto clone = static_cast<faiss::IndexBinaryIVF*>(
+            faiss::clone_binary_index(index));
+    clone->quantizer->reset();
+
+    for (int64_t i = 0; i < shard_count; i++) {
+        sharded_indexes[i] = static_cast<faiss::IndexBinaryIVF*>(
+                faiss::clone_binary_index(clone));
+        if (generate_ids) {
+            // Assume the quantizer does not natively support add_with_ids.
+            sharded_indexes[i]->quantizer =
+                    new IndexBinaryIDMap2(sharded_indexes[i]->quantizer);
+        }
+    }
+
+    // assign centroids to each sharded Index based on sharding_function, and
+    // add them to the quantizer of each sharded index
+    int64_t reconstruction_size = index->quantizer->d / 8;
+    std::vector<std::vector<uint8_t>> sharded_centroids(shard_count);
+    std::vector<std::vector<idx_t>> xids(shard_count);
+    for (int64_t i = 0; i < index->quantizer->ntotal; i++) {
+        int64_t shard_id = (*sharding_function)(i, shard_count);
+        // Since the quantizer does not natively support add_with_ids, we simply
+        // generate them.
+        xids[shard_id].push_back(i);
+        uint8_t* reconstructed = new uint8_t[reconstruction_size];
+        index->quantizer->reconstruct(i, reconstructed);
+        sharded_centroids[shard_id].insert(
+                sharded_centroids[shard_id].end(),
+                &reconstructed[0],
+                &reconstructed[reconstruction_size]);
+        delete[] reconstructed;
+    }
+    for (int64_t i = 0; i < shard_count; i++) {
+        if (generate_ids) {
+            sharded_indexes[i]->quantizer->add_with_ids(
+                    sharded_centroids[i].size() / reconstruction_size,
+                    sharded_centroids[i].data(),
+                    xids[i].data());
+        } else {
+            sharded_indexes[i]->quantizer->add(
+                    sharded_centroids[i].size() / reconstruction_size,
+                    sharded_centroids[i].data());
+        }
+    }
+
+    for (int64_t i = 0; i < shard_count; i++) {
+        char fname[256];
+        snprintf(fname, 256, filename_template.c_str(), i);
+        faiss::write_index_binary(sharded_indexes[i], fname);
+    }
+
+    for (int64_t i = 0; i < shard_count; i++) {
+        delete sharded_indexes[i];
+    }
+}
+
+template <typename IndexType>
+void sharding_helper(
+        IndexType* index,
+        int64_t shard_count,
+        const std::string& filename_template,
+        ShardingFunction* sharding_function,
+        bool generate_ids) {
+    FAISS_THROW_IF_MSG(index->quantizer->ntotal == 0, "No centroids to shard.");
+    FAISS_THROW_IF_MSG(
+            filename_template.find("%d") == std::string::npos,
+            "Invalid filename_template. Must contain format specifier for shard count.");
+
+    DefaultShardingFunction default_sharding_function;
+    if (sharding_function == nullptr) {
+        sharding_function = &default_sharding_function;
+    }
+
+    if (typeid(IndexType) == typeid(faiss::IndexIVF)) {
+        handle_ivf(
+                dynamic_cast<faiss::IndexIVF*>(index),
+                shard_count,
+                filename_template,
+                sharding_function,
+                generate_ids);
+    } else if (typeid(IndexType) == typeid(faiss::IndexBinaryIVF)) {
+        handle_binary_ivf(
+                dynamic_cast<faiss::IndexBinaryIVF*>(index),
+                shard_count,
+                filename_template,
+                sharding_function,
+                generate_ids);
+    }
+}
+
+void shard_ivf_index_centroids(
+        faiss::IndexIVF* index,
+        int64_t shard_count,
+        const std::string& filename_template,
+        ShardingFunction* sharding_function,
+        bool generate_ids) {
+    sharding_helper(
+            index,
+            shard_count,
+            filename_template,
+            sharding_function,
+            generate_ids);
+}
+
+void shard_binary_ivf_index_centroids(
+        faiss::IndexBinaryIVF* index,
+        int64_t shard_count,
+        const std::string& filename_template,
+        ShardingFunction* sharding_function,
+        bool generate_ids) {
+    sharding_helper(
+            index,
+            shard_count,
+            filename_template,
+            sharding_function,
+            generate_ids);
+}
+
 } // namespace ivflib
 } // namespace faiss

data/vendor/faiss/faiss/IVFlib.h

@@ -14,6 +14,7 @@
  * IndexIVFs embedded within an IndexPreTransform.
  */
 
+#include <faiss/IndexBinaryIVF.h>
 #include <faiss/IndexIVF.h>
 #include <vector>
 
@@ -167,6 +168,47 @@ void ivf_residual_add_from_flat_codes(
         const uint8_t* codes,
         int64_t code_size = -1);
 
+struct ShardingFunction {
+    virtual int64_t operator()(int64_t i, int64_t shard_count) = 0;
+    virtual ~ShardingFunction() = default;
+    ShardingFunction() {}
+    ShardingFunction(const ShardingFunction&) = default;
+    ShardingFunction(ShardingFunction&&) = default;
+    ShardingFunction& operator=(const ShardingFunction&) = default;
+    ShardingFunction& operator=(ShardingFunction&&) = default;
+};
+struct DefaultShardingFunction : ShardingFunction {
+    int64_t operator()(int64_t i, int64_t shard_count) override;
+};
+
+/**
+ * Shards an IVF index centroids by the given sharding function, and writes
+ * the index to the path given by filename_generator. The centroids must already
+ * be added to the index quantizer.
+ *
+ * @param index             The IVF index containing centroids to shard.
+ * @param shard_count       Number of shards.
+ * @param filename_template Template for shard filenames.
+ * @param sharding_function The function to shard by. The default is ith vector
+ *                          mod shard_count.
+ * @param generate_ids      Generates ids using IndexIDMap2. If true, ids will
+ *                          match the default ids in the unsharded index.
+ * @return                  The number of shards written.
+ */
+void shard_ivf_index_centroids(
+        IndexIVF* index,
+        int64_t shard_count = 20,
+        const std::string& filename_template = "shard.%d.index",
+        ShardingFunction* sharding_function = nullptr,
+        bool generate_ids = false);
+
+void shard_binary_ivf_index_centroids(
+        faiss::IndexBinaryIVF* index,
+        int64_t shard_count = 20,
+        const std::string& filename_template = "shard.%d.index",
+        ShardingFunction* sharding_function = nullptr,
+        bool generate_ids = false);
+
 } // namespace ivflib
 } // namespace faiss
 

data/vendor/faiss/faiss/Index.h

@@ -17,7 +17,7 @@
 #include <typeinfo>
 
 #define FAISS_VERSION_MAJOR 1
-#define FAISS_VERSION_MINOR 10
+#define FAISS_VERSION_MINOR 11
 #define FAISS_VERSION_PATCH 0
 
 // Macro to combine the version components into a single string

data/vendor/faiss/faiss/IndexBinaryFlat.cpp

@@ -37,8 +37,8 @@ void IndexBinaryFlat::search(
         int32_t* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    // Extract IDSelector from params if present
+    const IDSelector* sel = params ? params->sel : nullptr;
     FAISS_THROW_IF_NOT(k > 0);
 
     const idx_t block_size = query_batch_size;
@@ -60,7 +60,8 @@ void IndexBinaryFlat::search(
                     ntotal,
                     code_size,
                     /* ordered = */ true,
-                    approx_topk_mode);
+                    approx_topk_mode,
+                    sel);
         } else {
             hammings_knn_mc(
                     x + s * code_size,
@@ -70,7 +71,8 @@ void IndexBinaryFlat::search(
                     k,
                     code_size,
                     distances + s * k,
-                    labels + s * k);
+                    labels + s * k,
+                    sel);
         }
     }
 }
@@ -107,9 +109,9 @@ void IndexBinaryFlat::range_search(
         int radius,
         RangeSearchResult* result,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
-    hamming_range_search(x, xb.data(), n, ntotal, radius, code_size, result);
+    const IDSelector* sel = params ? params->sel : nullptr;
+    hamming_range_search(
+            x, xb.data(), n, ntotal, radius, code_size, result, sel);
 }
 
 } // namespace faiss

data/vendor/faiss/faiss/IndexBinaryFlat.h

@@ -14,6 +14,7 @@
 
 #include <faiss/IndexBinary.h>
 
+#include <faiss/impl/maybe_owned_vector.h>
 #include <faiss/utils/approx_topk/mode.h>
 
 namespace faiss {
@@ -21,7 +22,7 @@ namespace faiss {
 /** Index that stores the full vectors and performs exhaustive search. */
 struct IndexBinaryFlat : IndexBinary {
     /// database vectors, size ntotal * d / 8
-    std::vector<uint8_t> xb;
+    MaybeOwnedVector<uint8_t> xb;
 
     /** Select between using a heap or counting to select the k smallest values
      * when scanning inverted lists.

data/vendor/faiss/faiss/IndexFlatCodes.cpp

@@ -110,7 +110,7 @@ CodePacker* IndexFlatCodes::get_CodePacker() const {
 }
 
 void IndexFlatCodes::permute_entries(const idx_t* perm) {
-    std::vector<uint8_t> new_codes(codes.size());
+    MaybeOwnedVector<uint8_t> new_codes(codes.size());
 
     for (idx_t i = 0; i < ntotal; i++) {
         memcpy(new_codes.data() + i * code_size,

data/vendor/faiss/faiss/IndexFlatCodes.h

@@ -7,9 +7,11 @@
 
 #pragma once
 
+#include <vector>
+
 #include <faiss/Index.h>
 #include <faiss/impl/DistanceComputer.h>
-#include <vector>
+#include <faiss/impl/maybe_owned_vector.h>
 
 namespace faiss {
 
@@ -21,7 +23,7 @@ struct IndexFlatCodes : Index {
     size_t code_size;
 
     /// encoded dataset, size ntotal * code_size
-    std::vector<uint8_t> codes;
+    MaybeOwnedVector<uint8_t> codes;
 
     IndexFlatCodes();