faiss 0.6.4 → 0.6.5

data/vendor/faiss/faiss/gpu/GpuIndexBinaryCagra.h

@@ -33,6 +33,7 @@ namespace faiss {
 namespace gpu {
 
 class BinaryCuvsCagra;
+class Dataset;
 
 struct GpuIndexBinaryCagra : public IndexBinary {
    public:
@@ -49,22 +50,34 @@ struct GpuIndexBinaryCagra : public IndexBinary {
     /// stream and handle resources on the GPU
     std::shared_ptr<GpuResources> getResources();
 
-    /// Trains CAGRA based on the given vector data and add them along with ids.
-    /// NB: The use of the add function here is to build the CAGRA graph on
-    /// the base dataset. Use this function when you want to add vectors with
-    /// ids. Ref: https://github.com/facebookresearch/faiss/issues/4107
+    /// Pointer-based construction is unsupported. Use a caller-owned Dataset.
     void add(idx_t n, const uint8_t* x) override;
-
-    /// Trains CAGRA based on the given vector data.
-    /// NB: The use of the train function here is to build the CAGRA graph on
-    /// the base dataset and is currently the only function to add the full set
-    /// of vectors (without IDs) to the index. There is no external quantizer to
-    /// be trained here.
     void train(idx_t n, const uint8_t* x) override;
 
-    /// Initialize ourselves from the given CPU index; will overwrite
-    /// all data in ourselves
-    void copyFrom(const faiss::IndexBinaryHNSWCagra* index);
+    /// Build the full graph, borrowing UInt8 vectors with dim == d / 8.
+    /// The backing storage must remain alive and unchanged until all index
+    /// operations have completed. Does nothing if already trained; call reset()
+    /// before building again.
+    void train(const Dataset& dataset) override;
+    void add(const Dataset& dataset) override;
+
+    /// Rebind search storage without changing the graph. The vectors and their
+    /// ordering must match the training data. Requires compatible device data;
+    /// any padding must be zero and the caller retains ownership. Previous
+    /// work on the index stream completes before rebinding.
+    void updateDataset(const Dataset& dataset);
+    bool isSearchReady() const;
+
+    /// Copy the CPU graph. Without a Dataset, import only the graph and
+    /// metadata; attach vectors with updateDataset before search or copyTo.
+    /// If provided, dataset must describe writable, compatible storage on this
+    /// device with the CPU index's shape and UInt8 type. Copy CPU vectors into
+    /// that allocation, zero padding, and borrow it for search. The caller owns
+    /// the allocation and must keep it alive through index use. Copies complete
+    /// before return, so the CPU index can be released in either case.
+    void copyFrom(
+            const faiss::IndexBinaryHNSWCagra* index,
+            Dataset* dataset = nullptr);
 
     /// Copy ourselves to the given CPU index; will overwrite all data
     /// in the index instance

data/vendor/faiss/faiss/gpu/GpuIndexCagra.h

@@ -27,6 +27,11 @@
 #include <faiss/gpu/GpuIndex.h>
 #include <faiss/gpu/GpuIndexIVFPQ.h>
 
+#ifndef SWIG
+#include <faiss/gpu/Dataset.h>
+#include <optional>
+#endif
+
 #include <variant>
 #include <vector>
 #include "faiss/Index.h"
@@ -216,7 +221,6 @@ struct GpuIndexCagraConfig : public GpuIndexConfig {
     std::shared_ptr<IVFPQBuildCagraConfig> ivf_pq_params{nullptr};
     std::shared_ptr<IVFPQSearchCagraConfig> ivf_pq_search_params{nullptr};
     float refine_rate = 2.0f;
-    bool store_dataset = true;
 
     /// Whether to use MST optimization to guarantee graph connectivity.
     bool guarantee_connectivity = false;
@@ -309,28 +313,43 @@ struct GpuIndexCagra : public GpuIndex {
             faiss::MetricType metric = faiss::METRIC_L2,
             GpuIndexCagraConfig config = GpuIndexCagraConfig());
 
-    /// Trains CAGRA based on the given vector data and add them along with ids.
-    /// NB: The use of the add function here is to build the CAGRA graph on
-    /// the base dataset. Use this function when you want to add vectors with
-    /// ids. Ref: https://github.com/facebookresearch/faiss/issues/4107
+    ~GpuIndexCagra() override;
+
+    /// Build the full graph while borrowing dataset storage. The backing
+    /// allocation must remain alive and unchanged through index use and all
+    /// outstanding GPU work. Does nothing if already trained; call reset()
+    /// before building again.
+    void train(const Dataset& dataset) override;
+
+    /// Equivalent to train(dataset); incremental insertion is unsupported.
+    void add(const Dataset& dataset) override;
+
+    /// Attach search-compatible device storage without changing the graph.
+    /// Shape, dtype and vector ordering must match the trained dataset. The
+    /// values must be the same; this method does not rebuild for changed data.
+    /// Previous work on this index's stream completes before rebinding.
+    void updateDataset(const Dataset& dataset);
+    bool isSearchReady() const;
+
+    /// Copy the CPU graph and metadata. With no dataset, import only the
+    /// graph: no vector storage is retained and GPU search is unavailable.
+    /// When supplied, dataset must describe writable CAGRA-compatible device
+    /// storage with matching shape and dtype on this index's device. Its
+    /// contents are overwritten with CPU vectors and its padding is zeroed.
+    /// The index borrows that allocation and becomes search-ready. The caller
+    /// retains ownership and must keep the allocation alive through index use
+    /// and queued GPU work. Copies finish before return, so the CPU index may
+    /// then be released in either mode.
+    void copyFrom(
+            const faiss::IndexHNSWCagra* index,
+            Dataset* dataset = nullptr);
+
+    /// Legacy pointer entry points throw: use the Dataset overloads.
     void add(idx_t n, const float* x) override;
     void add_ex(idx_t n, const void* x, NumericType numeric_type) override;
-
-    /// Trains CAGRA based on the given vector data.
-    /// NB: The use of the train function here is to build the CAGRA graph on
-    /// the base dataset and is currently the only function to add the full set
-    /// of vectors (without IDs) to the index. There is no external quantizer to
-    /// be trained here.
     void train(idx_t n, const float* x) override;
     void train_ex(idx_t n, const void* x, NumericType numeric_type) override;
 
-    /// Initialize ourselves from the given CPU index; will overwrite
-    /// all data in ourselves
-    void copyFrom(const faiss::IndexHNSWCagra* index);
-    void copyFrom_ex(
-            const faiss::IndexHNSWCagra* index,
-            NumericType numeric_type);
-
     /// Copy ourselves to the given CPU index; will overwrite all data
     /// in the index instance
     void copyTo(faiss::IndexHNSWCagra* index) const;
@@ -372,7 +391,9 @@ struct GpuIndexCagra : public GpuIndex {
     /// more than one device: cuVS `all_neighbors` knn graph construction over
     /// overlapping clusters, followed by graph pruning. Leaves the result in
     /// merged_knngraph_ for copyTo(); index_ stays empty.
-    void trainAllNeighbors_(idx_t n, const float* x);
+#ifndef SWIG
+    void trainAllNeighbors_(const Dataset& dataset);
+#endif
 
     /// Populate HNSW levels >= 1 of `index` by building a CAGRA graph over
     /// each level's node subset on the GPU. Requires the level table to be
@@ -385,9 +406,9 @@ struct GpuIndexCagra : public GpuIndex {
     /// Our configuration options
     const GpuIndexCagraConfig cagraConfig_;
 
-    faiss::NumericType numeric_type_;
+    faiss::NumericType numeric_type_ = NumericType::Float32;
 
-    /// Instance that we own; contains the inverted lists
+    /// Instance that owns the CAGRA graph and borrows dataset storage
     std::variant<
             std::monostate,
             std::shared_ptr<CuvsCagra<float>>,
@@ -398,7 +419,9 @@ struct GpuIndexCagra : public GpuIndex {
     /// Multi-GPU state: populated by trainAllNeighbors_(), used by copyTo()
     std::vector<idx_t> merged_knngraph_;
     idx_t merged_knngraph_degree_ = 0;
-    const float* multi_gpu_dataset_ = nullptr;
+#ifndef SWIG
+    std::optional<Dataset> multiGpuDataset_;
+#endif
 };
 
 } // namespace gpu

data/vendor/faiss/faiss/gpu/GpuIndexFlat.h

@@ -131,6 +131,17 @@ class GpuIndexFlat : public GpuIndex {
             idx_t* labels,
             const SearchParameters* params) const override;
 
+    /// Called from GpuIndex for search; Float16 queries are searched without
+    /// conversion against float16 storage
+    void searchImpl_ex_(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            int k,
+            float* distances,
+            idx_t* labels,
+            const SearchParameters* params) const override;
+
    protected:
     /// Our configuration options
     const GpuIndexFlatConfig flatConfig_;

data/vendor/faiss/faiss/gpu/GpuIndexIVF.h

@@ -32,6 +32,12 @@ struct GpuIndexIVFConfig : public GpuIndexConfig {
     /// throw an exception for indices not implemented on GPU. When set to
     /// true, it will fallback to a CPU implementation.
     bool allowCpuCoarseQuantizer = false;
+
+    /// Break a distance tie on the smaller id, so a search repeats. Honoured
+    /// by GpuIndexIVFFlat and GpuIndexIVFScalarQuantizer with the interleaved
+    /// layout for k up to 1024, and by the cuVS GpuIndexIVFScalarQuantizer
+    /// and GpuIndexIVFPQ for k and nprobe up to 256.
+    bool deterministic_tie_break = false;
 };
 
 /// Base class of all GPU IVF index types. This (for now) deliberately does not

data/vendor/faiss/faiss/gpu/test/TestGpuDatasetHeader.cpp

@@ -0,0 +1,18 @@
+/*
+ * 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.
+ */
+
+// Keep this translation unit ordinary C++ without CUDA, RAFT, or cuVS headers.
+#include <faiss/gpu/Dataset.h>
+
+#include <type_traits>
+
+using faiss::gpu::Dataset;
+
+static_assert(!std::is_copy_constructible_v<Dataset>);
+static_assert(!std::is_copy_assignable_v<Dataset>);
+static_assert(std::is_nothrow_move_constructible_v<Dataset>);
+static_assert(std::is_nothrow_move_assignable_v<Dataset>);

data/vendor/faiss/faiss/gpu/test/TestGpuIndexFlat.cpp

@@ -5,14 +5,19 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <faiss/Clustering.h>
 #include <faiss/IndexFlat.h>
 #include <faiss/gpu/GpuIndexFlat.h>
+#include <faiss/gpu/GpuIndexIVFFlat.h>
 #include <faiss/gpu/StandardGpuResources.h>
 #include <faiss/gpu/impl/IndexUtils.h>
 #include <faiss/gpu/test/TestUtils.h>
 #include <faiss/gpu/utils/DeviceUtils.h>
 #include <faiss/impl/IDSelector.h>
+#include <faiss/utils/fp16.h>
 #include <gtest/gtest.h>
+#include <algorithm>
+#include <cstdint>
 #include <sstream>
 #include <unordered_map>
 #include <vector>
@@ -807,6 +812,216 @@ TEST(TestCuvsGpuIndexFlat, IDSelector_IP) {
 }
 #endif
 
+// Packs float vectors as IEEE binary16, the Float16 input of search_ex
+std::vector<uint16_t> toFp16(const std::vector<float>& v) {
+    std::vector<uint16_t> out(v.size());
+    std::transform(v.begin(), v.end(), out.begin(), [](float f) {
+        return faiss::encode_fp16(f);
+    });
+    return out;
+}
+
+std::vector<float> fromFp16(const std::vector<uint16_t>& v) {
+    std::vector<float> out(v.size());
+    std::transform(v.begin(), v.end(), out.begin(), [](uint16_t h) {
+        return faiss::decode_fp16(h);
+    });
+    return out;
+}
+
+// A copy of host data on a GPU device
+struct DeviceCopy {
+    DeviceCopy(int device, const void* src, size_t bytes) {
+        faiss::gpu::DeviceScope scope(device);
+        CUDA_VERIFY(cudaMalloc(&data, bytes));
+        CUDA_VERIFY(cudaMemcpy(data, src, bytes, cudaMemcpyHostToDevice));
+    }
+
+    DeviceCopy(const DeviceCopy&) = delete;
+    DeviceCopy& operator=(const DeviceCopy&) = delete;
+
+    ~DeviceCopy() {
+        CUDA_VERIFY(cudaFree(data));
+    }
+
+    void* data = nullptr;
+};
+
+// search_ex on Float16 queries must return exactly what search returns on the
+// float32 queries rounded to fp16, as the rounded values are what the index
+// computes with, whether the queries are on the host (paged or not) or on the
+// device
+void testSearchExFloat16(faiss::gpu::GpuIndex& index) {
+    int numQuery = faiss::gpu::randVal(1, 512);
+    int k = std::min(faiss::gpu::randVal(1, 50), int(index.ntotal));
+
+    auto queries = faiss::gpu::randVecs(numQuery, index.d);
+    auto queries16 = toFp16(queries);
+    auto roundedQueries = fromFp16(queries16);
+
+    std::vector<float> refDistances(numQuery * k);
+    std::vector<faiss::idx_t> refLabels(numQuery * k);
+    index.search(
+            numQuery,
+            roundedQueries.data(),
+            k,
+            refDistances.data(),
+            refLabels.data());
+
+    auto expectSearchExMatches = [&](const void* x, const std::string& where) {
+        std::vector<float> distances(numQuery * k, 0);
+        std::vector<faiss::idx_t> labels(numQuery * k, -1);
+        index.search_ex(
+                numQuery,
+                x,
+                faiss::NumericType::Float16,
+                k,
+                distances.data(),
+                labels.data());
+
+        EXPECT_EQ(labels, refLabels) << where;
+        EXPECT_EQ(distances, refDistances) << where;
+    };
+
+    expectSearchExMatches(queries16.data(), "host queries");
+
+    auto minPagingSize = index.getMinPagingSize();
+    index.setMinPagingSize(0);
+    expectSearchExMatches(queries16.data(), "paged host queries");
+    index.setMinPagingSize(minPagingSize);
+
+    DeviceCopy queries16Device(
+            index.getDevice(),
+            queries16.data(),
+            queries16.size() * sizeof(uint16_t));
+    expectSearchExMatches(queries16Device.data, "device queries");
+}
+
+// Covers both float32 storage (queries widened on the device) and float16
+// storage (queries searched natively)
+template <typename GpuIndexFlatT>
+void testFlatSearchExFloat16() {
+    faiss::gpu::StandardGpuResources res;
+    res.noTempMemory();
+
+    int dim = faiss::gpu::randVal(50, 400);
+    int numVecs = faiss::gpu::randVal(1000, 5000);
+    auto vecs = faiss::gpu::randVecs(numVecs, dim);
+
+    for (bool useFloat16 : {false, true}) {
+        faiss::gpu::GpuIndexFlatConfig config;
+        config.device = faiss::gpu::randVal(0, faiss::gpu::getNumDevices() - 1);
+        config.useFloat16 = useFloat16;
+
+        GpuIndexFlatT gpuIndex(&res, dim, config);
+        gpuIndex.add(numVecs, vecs.data());
+
+        SCOPED_TRACE(useFloat16 ? "useFloat16" : "float32 storage");
+        testSearchExFloat16(gpuIndex);
+    }
+}
+
+TEST(TestGpuIndexFlat, SearchExFloat16_L2) {
+    testFlatSearchExFloat16<faiss::gpu::GpuIndexFlatL2>();
+}
+
+TEST(TestGpuIndexFlat, SearchExFloat16_IP) {
+    testFlatSearchExFloat16<faiss::gpu::GpuIndexFlatIP>();
+}
+
+// Indexes without a native fp16 search widen the queries on the device
+TEST(TestGpuIndexFlat, SearchExFloat16_IVFFlatDefault) {
+    faiss::gpu::StandardGpuResources res;
+    res.noTempMemory();
+
+    int dim = 64;
+    int numVecs = 5000;
+    auto vecs = faiss::gpu::randVecs(numVecs, dim);
+
+    faiss::gpu::GpuIndexIVFFlatConfig config;
+    config.device = faiss::gpu::randVal(0, faiss::gpu::getNumDevices() - 1);
+
+    int numLists = 32;
+    faiss::gpu::GpuIndexIVFFlat gpuIndex(
+            &res, dim, numLists, faiss::METRIC_L2, config);
+    gpuIndex.nprobe = 4;
+    gpuIndex.train(numVecs, vecs.data());
+    gpuIndex.add(numVecs, vecs.data());
+
+    testSearchExFloat16(gpuIndex);
+}
+
+// k-means on fp16 data with a GPU assignment index must match k-means on the
+// float32 rounding of that data with the same kind of index
+TEST(TestGpuIndexFlat, ClusteringTrainExFloat16) {
+    faiss::gpu::StandardGpuResources res;
+    res.noTempMemory();
+
+    int dim = 32;
+    int numCentroids = 20;
+    // Fits in a single decode block, so that both runs search the same batches
+    int numVecs = 2000;
+    auto vecs = faiss::gpu::randVecs(numVecs, dim);
+    auto vecs16 = toFp16(vecs);
+    auto roundedVecs = fromFp16(vecs16);
+
+    faiss::ClusteringParameters cp;
+    cp.niter = 10;
+
+    for (bool useFloat16 : {false, true}) {
+        faiss::gpu::GpuIndexFlatConfig config;
+        config.device = faiss::gpu::randVal(0, faiss::gpu::getNumDevices() - 1);
+        config.useFloat16 = useFloat16;
+
+        faiss::gpu::GpuIndexFlatL2 refIndex(&res, dim, config);
+        faiss::Clustering refClustering(dim, numCentroids, cp);
+        refClustering.train(numVecs, roundedVecs.data(), refIndex);
+
+        faiss::gpu::GpuIndexFlatL2 gpuIndex(&res, dim, config);
+        faiss::Clustering clustering(dim, numCentroids, cp);
+        clustering.train_ex(
+                numVecs, vecs16.data(), faiss::NumericType::Float16, gpuIndex);
+
+        ASSERT_EQ(clustering.centroids.size(), refClustering.centroids.size());
+        for (size_t i = 0; i < clustering.centroids.size(); ++i) {
+            EXPECT_NEAR(
+                    clustering.centroids[i], refClustering.centroids[i], 1e-5f)
+                    << "useFloat16 " << useFloat16 << " element " << i;
+        }
+    }
+}
+
+// add and reconstruct_n copy the whole vector set between host and device in
+// one copy. On ROCm, a pageable copy of more than 64 KiB goes through 16 MiB
+// pinned chunks: 17 vectors take one chunk, and 10,500 vectors take two full
+// chunks and a partial one. Each size has its own resources, so the second
+// size reuses the pinned chunks after the streams of the first are destroyed.
+TEST(TestGpuIndexFlat, LargeHostCopyRoundTrip) {
+    int dim = 1000;
+    int device = faiss::gpu::randVal(0, faiss::gpu::getNumDevices() - 1);
+
+    for (int numVecs : {17, 10500}) {
+        faiss::gpu::StandardGpuResources res;
+        res.noTempMemory();
+
+        faiss::gpu::GpuIndexFlatConfig config;
+        config.device = device;
+
+        faiss::gpu::GpuIndexFlatL2 gpuIndex(&res, dim, config);
+        std::vector<float> vecs = faiss::gpu::randVecs(numVecs, dim);
+        gpuIndex.add(numVecs, vecs.data());
+
+        std::vector<float> out(vecs.size());
+        gpuIndex.reconstruct_n(0, numVecs, out.data());
+
+        // Report the first difference; printing millions of values is useless
+        size_t firstDiff =
+                std::mismatch(out.begin(), out.end(), vecs.begin()).first -
+                out.begin();
+        EXPECT_EQ(firstDiff, out.size()) << "numVecs " << numVecs;
+    }
+}
+
 int main(int argc, char** argv) {
     testing::InitGoogleTest(&argc, argv);
 

data/vendor/faiss/faiss/gpu/test/TestGpuIndexIVFFlat.cpp

@@ -31,8 +31,11 @@
 #include <faiss/impl/IDSelector.h>
 #include <faiss/utils/distances.h>
 #include <gtest/gtest.h>
+#include <algorithm>
 #include <cmath>
+#include <random>
 #include <sstream>
+#include <unordered_set>
 #include <vector>
 
 // FIXME: figure out a better way to test fp16
@@ -472,6 +475,101 @@ TEST(TestGpuIndexIVFFlat, Float32_32_CopyFrom) {
 #endif
 }
 
+#if defined USE_NVIDIA_CUVS
+class TestCuvsGpuIndexIVFFlatCopyFrom
+        : public testing::TestWithParam<faiss::MetricType> {};
+
+TEST_P(TestCuvsGpuIndexIVFFlatCopyFrom, SearchLargeK) {
+    constexpr int numVecs = 16384;
+    constexpr int dim = 128;
+    constexpr int numCentroids = 32;
+    const auto metric = GetParam();
+    std::mt19937 rng(42);
+    std::uniform_int_distribution<int> random(-30, 30);
+    std::vector<float> vecs(numVecs * dim);
+    for (auto& value : vecs) {
+        value = random(rng);
+    }
+
+    faiss::IndexFlat quantizer(dim, metric);
+    faiss::IndexIVFFlat cpuIndex(&quantizer, dim, numCentroids, metric);
+    cpuIndex.cp.niter = 5;
+    cpuIndex.train(numVecs, vecs.data());
+    cpuIndex.add(numVecs, vecs.data());
+    cpuIndex.nprobe = numCentroids;
+
+    faiss::gpu::StandardGpuResources res;
+    faiss::gpu::GpuIndexIVFFlatConfig config;
+    config.use_cuvs = true;
+    config.indicesOptions = faiss::gpu::INDICES_64_BIT;
+    faiss::gpu::GpuIndexIVFFlat gpuIndex(
+            &res, dim, numCentroids, metric, config);
+    gpuIndex.copyFrom(&cpuIndex);
+
+    faiss::IndexFlat exact(dim, metric);
+    exact.add(numVecs, vecs.data());
+    // k > 256 takes the cuVS path that sizes its workspace from the
+    // accumulated list sizes. Cloning must populate those sizes first.
+    for (int k : {256, 257, 500, 3500}) {
+        SCOPED_TRACE(testing::Message() << "k=" << k);
+        for (int numQueries : {1, 4}) {
+            SCOPED_TRACE(testing::Message() << "numQueries=" << numQueries);
+            std::vector<float> expected(numQueries * k);
+            std::vector<float> distances(numQueries * k);
+            std::vector<faiss::idx_t> expectedIds(numQueries * k);
+            std::vector<faiss::idx_t> ids(numQueries * k);
+            exact.search(
+                    numQueries,
+                    vecs.data(),
+                    k,
+                    expected.data(),
+                    expectedIds.data());
+            for (int repeat = 0; repeat < 2; ++repeat) {
+                gpuIndex.search(
+                        numQueries,
+                        vecs.data(),
+                        k,
+                        distances.data(),
+                        ids.data());
+                for (int q = 0; q < numQueries; ++q) {
+                    std::unordered_set<faiss::idx_t> uniqueIds;
+                    for (int i = q * k; i < (q + 1) * k; ++i) {
+                        ASSERT_GE(ids[i], 0);
+                        ASSERT_LT(ids[i], numVecs);
+                        EXPECT_TRUE(uniqueIds.insert(ids[i]).second);
+                        float score = 0;
+                        for (int j = 0; j < dim; ++j) {
+                            float a = vecs[q * dim + j];
+                            float b = vecs[ids[i] * dim + j];
+                            score += metric == faiss::METRIC_L2
+                                    ? (a - b) * (a - b)
+                                    : a * b;
+                        }
+                        EXPECT_FLOAT_EQ(score, distances[i]);
+                    }
+                    // cuVS need not return sorted results, and tied scores
+                    // may select different IDs at the top-k boundary.
+                    std::vector<float> actual(
+                            distances.begin() + q * k,
+                            distances.begin() + (q + 1) * k);
+                    auto begin = expected.begin() + q * k;
+                    std::sort(begin, begin + k);
+                    std::sort(actual.begin(), actual.end());
+                    for (int i = 0; i < k; ++i) {
+                        EXPECT_FLOAT_EQ(begin[i], actual[i]);
+                    }
+                }
+            }
+        }
+    }
+}
+
+INSTANTIATE_TEST_SUITE_P(
+        Cuvs,
+        TestCuvsGpuIndexIVFFlatCopyFrom,
+        testing::Values(faiss::METRIC_L2, faiss::METRIC_INNER_PRODUCT));
+#endif
+
 TEST(TestGpuIndexIVFFlat, Float32_negative) {
     Options opt;
 

data/vendor/faiss/faiss/gpu/utils/DeviceUtils.h

@@ -63,6 +63,17 @@ size_t getMaxSharedMemPerBlockCurrentDevice();
 /// a device (deviceId >= 0) or the host (-1).
 int getDeviceForAddress(const void* p);
 
+/// cudaMemcpyAsync, except that on ROCm a copy of more than 64 KiB to or from
+/// pageable host memory goes through pinned staging buffers. As with CUDA's
+/// pageable copies, a host-to-device copy returns once the source can be
+/// reused, and a device-to-host copy returns once the data is on the host.
+void memcpyHostDeviceAsync(
+        void* dst,
+        const void* src,
+        size_t bytes,
+        cudaMemcpyKind kind,
+        cudaStream_t stream);
+
 /// Does the given device support full unified memory sharing host
 /// memory?
 bool getFullUnifiedMemSupport(int device);

data/vendor/faiss/faiss/gpu/utils/StackDeviceMemory.cpp

@@ -145,7 +145,7 @@ void StackDeviceMemory::Stack::returnAlloc(
     }
 
     head_ = p;
-    lastUsers_.push_back(Range(p, p + size, stream));
+    lastUsers_.emplace_back(p, p + size, stream);
 }
 
 std::string StackDeviceMemory::Stack::toString() const {

data/vendor/faiss/faiss/gpu_metal/MetalCloner.h

@@ -11,6 +11,7 @@
 #pragma once
 
 #include <faiss/Index.h>
+#include <faiss/IndexBinary.h>
 
 namespace faiss {
 namespace gpu_metal {
@@ -31,5 +32,15 @@ faiss::Index* index_cpu_to_metal_gpu(
 /// Caller owns the returned index.
 faiss::Index* index_metal_gpu_to_cpu(const faiss::Index* index);
 
+/// Clone IndexBinaryFlat to Metal. device must be 0; caller owns the result.
+faiss::IndexBinary* index_binary_cpu_to_metal_gpu(
+        StandardMetalResources* res,
+        int device,
+        const faiss::IndexBinary* index);
+
+/// Clone MetalIndexBinaryFlat to CPU. Caller owns the returned index.
+faiss::IndexBinary* index_binary_metal_gpu_to_cpu(
+        const faiss::IndexBinary* index);
+
 } // namespace gpu_metal
 } // namespace faiss