faiss 0.6.4 → 0.6.5

data/vendor/faiss/faiss/IndexSQFastScan.h

@@ -0,0 +1,129 @@
+/*
+ * 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
+
+#include <vector>
+
+#include <faiss/IndexFastScan.h>
+#include <faiss/IndexFlatCodes.h>
+#include <faiss/IndexScalarQuantizer.h>
+#include <faiss/impl/ScalarQuantizer.h>
+
+namespace faiss {
+
+/** Fast scan version of IndexScalarQuantizer.
+ *
+ * Supported quantizer types:
+ *   - QT_4bit, QT_4bit_uniform: native 4-bit codes mapped onto the
+ *     PQ4 FastScan SIMD (vpshufb / equivalent).
+ *
+ *   - QT_6bit, QT_8bit, QT_8bit_uniform, QT_8bit_direct,
+ *     QT_8bit_direct_signed: re-quantised to 4-bit for the scan, reranked
+ *     against the originals in orig_codes.
+ *
+ *   - All other types (QT_fp16, QT_bf16): use IndexScalarQuantizer directly.
+ */
+struct IndexSQFastScan : IndexFastScan {
+    ScalarQuantizer sq;
+
+    /// Overselection ratio for reranking.
+    float rerank_factor = 2;
+
+    /// Low nibbles of the 8-bit codes, two dimensions per byte, indexed by
+    /// id. The high nibbles live in the packed scan codes. Empty for the
+    /// native 4-bit types, which need no rerank.
+    std::vector<uint8_t> lo_codes;
+
+    /** Constructor.
+     *
+     * @param d       dimensionality of input vectors
+     * @param qtype   any native 4-bit or reranked type (see above)
+     * @param metric  distance metric (METRIC_L2 or METRIC_INNER_PRODUCT)
+     * @param bbs     block size for SIMD processing (multiple of 32)
+     */
+    IndexSQFastScan(
+            int d,
+            ScalarQuantizer::QuantizerType qtype,
+            MetricType metric = METRIC_L2,
+            int bbs = 32);
+
+    IndexSQFastScan();
+
+    /// Build from an existing IndexScalarQuantizer
+    explicit IndexSQFastScan(const IndexScalarQuantizer& orig, int bbs = 32);
+
+    void train(idx_t n, const float* x) override;
+
+    void add(idx_t n, const float* x) override;
+
+    void reset() override;
+
+    void search(
+            idx_t n,
+            const float* x,
+            idx_t k,
+            float* distances,
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const override;
+
+    void compute_codes(uint8_t* codes, idx_t n, const float* x) const override;
+
+    void check_compatible_for_merge(const Index& otherIndex) const override;
+
+    void compute_float_LUT(
+            float* lut,
+            idx_t n,
+            const float* x,
+            const FastScanDistancePostProcessing& context) const override;
+
+    void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
+
+    void sa_encode(idx_t n, const float* x, uint8_t* bytes) const override;
+
+    void reconstruct(idx_t key, float* recons) const override;
+
+    void reconstruct_n(idx_t i0, idx_t ni, float* recons) const override;
+
+    void add_sa_codes(idx_t n, const uint8_t* codes, const idx_t* xids)
+            override;
+
+    void permute_entries(const idx_t* perm);
+
+    FlatCodesDistanceComputer* get_FlatCodesDistanceComputer() const;
+
+    DistanceComputer* get_distance_computer() const override;
+
+    void range_search(
+            idx_t n,
+            const float* x,
+            float radius,
+            RangeSearchResult* result,
+            const SearchParameters* params = nullptr) const override;
+
+    size_t remove_ids(const IDSelector& sel) override;
+
+    void merge_from(Index& otherIndex, idx_t add_id = 0) override;
+
+    void search1(
+            const float* x,
+            ResultHandler& handler,
+            SearchParameters* params = nullptr) const override;
+
+    size_t sa_code_size() const override;
+
+    void fill_sa_code(
+            const CodePacker& packer,
+            idx_t id,
+            uint8_t* scratch,
+            int* values,
+            uint8_t* code_out) const;
+
+    size_t fast_scan_code_size() const override;
+};
+
+} // namespace faiss

data/vendor/faiss/faiss/IndexShards.cpp

@@ -193,6 +193,16 @@ void IndexShardsTemplate<IndexT>::add_with_ids(
     syncWithSubIndexes();
 }
 
+template <typename IndexT>
+size_t IndexShardsTemplate<IndexT>::remove_ids(const IDSelector& sel) {
+    FAISS_THROW_IF_MSG(
+            successive_ids, "remove_ids needs successive_ids = false");
+    const idx_t before = this->ntotal;
+    this->runOnIndex([&sel](int, IndexT* index) { index->remove_ids(sel); });
+    syncWithSubIndexes();
+    return before - this->ntotal;
+}
+
 template <typename IndexT>
 void IndexShardsTemplate<IndexT>::search(
         idx_t n,

data/vendor/faiss/faiss/IndexShards.h

@@ -91,6 +91,11 @@ struct IndexShardsTemplate : public ThreadedIndex<IndexT> {
 
     void train(idx_t n, const component_t* x) override;
 
+    /// Removes the ids from every shard, and returns the sum of the counts.
+    /// Needs successive_ids = false: with successive ids, the ids of a shard
+    /// depend on the sizes of the shards before it.
+    size_t remove_ids(const IDSelector& sel) override;
+
     bool successive_ids;
 
     /// Synchronize the top-level index (IndexShards) with data in the

data/vendor/faiss/faiss/SuperKMeans.cpp

@@ -22,6 +22,7 @@
 #include <faiss/impl/ClusteringHelpers.h>
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/PdxLayout.h>
+#include <faiss/impl/platform_macros.h>
 #include <faiss/impl/simd_dispatch.h>
 #include <faiss/utils/distances.h>
 #include <faiss/utils/random.h>
@@ -266,9 +267,9 @@ float adapt_d_prime(
 }
 
 /// Pre-loop setup: subsample, rotate, Forgy init, build ADSampling table,
-/// size the label scratch. Returned `sampled_x_owner` keeps the subsampled
-/// buffer alive when subsampling occurred (otherwise empty).
-std::unique_ptr<uint8_t[]> setup_train_state(
+/// and size the label scratch. The subsampled input only needs to remain alive
+/// through the rotation and is released before the iteration loop starts.
+void setup_train_state(
         TrainState& state,
         std::vector<int64_t>& labels64,
         std::vector<float>& hassign,
@@ -276,10 +277,13 @@ std::unique_ptr<uint8_t[]> setup_train_state(
         int d,
         int k,
         idx_t n,
-        const float* x) {
-    const size_t line_size = sizeof(float) * static_cast<size_t>(d);
+        const void* x,
+        NumericType numeric_type) {
+    const bool fp16 = numeric_type == NumericType::Float16;
+    const size_t line_size =
+            (fp16 ? sizeof(uint16_t) : sizeof(float)) * static_cast<size_t>(d);
     idx_t nx = n;
-    const uint8_t* x_bytes = reinterpret_cast<const uint8_t*>(x);
+    const uint8_t* x_bytes = static_cast<const uint8_t*>(x);
     std::unique_ptr<uint8_t[]> sampled_x_owner;
     if (static_cast<size_t>(nx) >
         static_cast<size_t>(k) * cp.max_points_per_centroid) {
@@ -298,7 +302,6 @@ std::unique_ptr<uint8_t[]> setup_train_state(
         sampled_x_owner.reset(x_new);
         x_bytes = x_new;
     }
-    const float* x_sampled = reinterpret_cast<const float*>(x_bytes);
 
     FAISS_THROW_IF_NOT_MSG(
             nx <= static_cast<idx_t>(std::numeric_limits<int>::max()),
@@ -315,7 +318,28 @@ std::unique_ptr<uint8_t[]> setup_train_state(
     }
 
     state.X_tilde.resize(static_cast<size_t>(state.n) * d);
-    state.R->apply_noalloc(state.n, x_sampled, state.X_tilde.data());
+    if (!fp16) {
+        state.R->apply_noalloc(
+                state.n,
+                reinterpret_cast<const float*>(x_bytes),
+                state.X_tilde.data());
+    } else {
+        const size_t block_size =
+                std::min(static_cast<size_t>(state.n), cp.decode_block_size);
+        std::vector<float> decoded(block_size * d);
+        const uint16_t* x16 = reinterpret_cast<const uint16_t*>(x_bytes);
+        for (size_t i0 = 0; i0 < static_cast<size_t>(state.n);
+             i0 += block_size) {
+            const size_t i1 =
+                    std::min(static_cast<size_t>(state.n), i0 + block_size);
+            fp16_to_fp32((i1 - i0) * d, x16 + i0 * d, decoded.data());
+            state.R->apply_noalloc(
+                    static_cast<idx_t>(i1 - i0),
+                    decoded.data(),
+                    state.X_tilde.data() + i0 * d);
+        }
+    }
+    sampled_x_owner.reset();
 
     // Forgy init: pick k random rows from the rotated pool as initial
     // centroids. These remain in rotated space; un-rotation happens
@@ -351,8 +375,6 @@ std::unique_ptr<uint8_t[]> setup_train_state(
     hassign.assign(k, 0.0f);
 
     labels64.resize(state.n);
-
-    return sampled_x_owner;
 }
 
 /// Un-rotate centroids into output buffer. R orthogonal, so
@@ -411,15 +433,36 @@ SuperKMeans::SuperKMeans(int d, int k, const SuperKMeansParameters& cp_in)
 }
 
 void SuperKMeans::train(idx_t n, const float* x) {
+    train_ex(n, x, NumericType::Float32);
+}
+
+void SuperKMeans::train_ex(idx_t n, const void* x, NumericType numeric_type) {
+    FAISS_THROW_IF_NOT_MSG(
+            numeric_type == NumericType::Float32 ||
+                    numeric_type == NumericType::Float16,
+            "SuperKMeans::train_ex: unsupported numeric type");
     FAISS_THROW_IF_NOT_MSG(n > 0, "SuperKMeans: n must be positive");
     FAISS_THROW_IF_MSG(x == nullptr, "SuperKMeans: x must not be null");
     FAISS_THROW_IF_NOT_MSG(
             n >= static_cast<idx_t>(k), "SuperKMeans: n must be >= k");
+    const bool fp16 = numeric_type == NumericType::Float16;
+    FAISS_THROW_IF_NOT_MSG(
+            !fp16 || cp.decode_block_size > 0,
+            "SuperKMeans: decode_block_size must be positive");
     if (cp.check_input_data_for_NaNs) {
-        for (size_t i = 0; i < static_cast<size_t>(n) * d; i++) {
+        const size_t num_values = static_cast<size_t>(n) * d;
+        if (fp16) {
             FAISS_THROW_IF_NOT_MSG(
-                    std::isfinite(x[i]),
+                    detail::fp16_all_finite(
+                            num_values, static_cast<const uint16_t*>(x)),
                     "SuperKMeans: input contains NaN's or Inf's");
+        } else {
+            const float* x32 = static_cast<const float*>(x);
+            for (size_t i = 0; i < num_values; i++) {
+                FAISS_THROW_IF_NOT_MSG(
+                        std::isfinite(x32[i]),
+                        "SuperKMeans: input contains NaN's or Inf's");
+            }
         }
     }
     if (cp.verbose && n < static_cast<idx_t>(k) * cp.min_points_per_centroid) {
@@ -435,8 +478,7 @@ void SuperKMeans::train(idx_t n, const float* x) {
     std::vector<int64_t> labels64;
     SuperKMeansAssignScratch assign_scratch;
     std::vector<float> hassign;
-    [[maybe_unused]] auto sampled_x_owner =
-            setup_train_state(state, labels64, hassign, cp, d, k, n, x);
+    setup_train_state(state, labels64, hassign, cp, d, k, n, x, numeric_type);
 
     iteration_stats.clear();
     iteration_stats.reserve(cp.niter);
@@ -625,7 +667,7 @@ void super_kmeans_assign_iteration(
                 [[maybe_unused]] const int omp_chunk_local = cp.omp_chunk;
                 int64_t tile_total = 0;
                 int64_t tile_pruned = 0;
-#pragma omp parallel for schedule(dynamic, omp_chunk_local) \
+#pragma omp parallel for schedule(FAISS_OMP_DYNAMIC, omp_chunk_local) \
         reduction(+ : tile_total) reduction(+ : tile_pruned)
                 for (int i = 0; i < bx; ++i) {
                     const float xnp_i = x_norms_partial[xi + i];

data/vendor/faiss/faiss/SuperKMeans.h

@@ -89,11 +89,16 @@ struct SuperKMeans {
 
     SuperKMeans(int d, int k, const SuperKMeansParameters& cp = {});
 
-    /// Train on `n` row-major vectors of dimension `d`. Honors the applicable
-    /// ClusteringParameters fields (niter, seed, verbose,
-    /// max_points_per_centroid, use_faster_subsampling,
-    /// check_input_data_for_NaNs).
+    /// Train on `n` row-major fp32 vectors of dimension `d`.
     void train(idx_t n, const float* x);
+
+    /** Train on vectors of the given numeric type.
+     *
+     * Float32 is the same as train(). Float16 takes packed IEEE binary16
+     * vectors and widens bounded blocks while rotating them into the fp32
+     * training workspace. Centroids and all iteration state remain fp32.
+     */
+    void train_ex(idx_t n, const void* x, NumericType numeric_type);
 };
 
 /// Reusable scratch for super_kmeans_assign_iteration; pass one instance across

data/vendor/faiss/faiss/VectorTransform.cpp

@@ -17,6 +17,7 @@
 
 #include <faiss/IndexPQ.h>
 #include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/platform_macros.h>
 #include <faiss/utils/distances.h>
 #include <faiss/utils/random.h>
 #include <faiss/utils/utils.h>
@@ -481,7 +482,7 @@ void HadamardRotation::apply_noalloc(idx_t n, const float* x, float* xt) const {
     // Three rounds scale by p^(3/2). Normalize once at the end.
     float total_scale = 1.0f / (p * std::sqrt(static_cast<float>(p)));
 
-#pragma omp parallel for schedule(dynamic)
+#pragma omp parallel for schedule(FAISS_OMP_DYNAMIC)
     for (idx_t i = 0; i < n; i++) {
         const float* xi = x + i * d;
         float* xo = xt + i * p;
@@ -526,7 +527,7 @@ void HadamardRotation::reverse_transform(idx_t n, const float* xt, float* x)
     // total_scale = 1/(p*sqrt(p)), so the inverse applies the same factor.
     const float inverse_scale = 1.0f / (p * std::sqrt(static_cast<float>(p)));
 
-#pragma omp parallel for schedule(dynamic)
+#pragma omp parallel for schedule(FAISS_OMP_DYNAMIC)
     for (idx_t i = 0; i < n; i++) {
         const float* xi = xt + i * p;
         float* xo = x + i * p;

data/vendor/faiss/faiss/clone_index.cpp

@@ -9,6 +9,8 @@
 
 #include <faiss/clone_index.h>
 
+#include <memory>
+
 #include <faiss/impl/FaissAssert.h>
 
 #include <faiss/Index2Layer.h>
@@ -37,6 +39,7 @@
 #include <faiss/IndexNSG.h>
 #include <faiss/IndexPQ.h>
 #include <faiss/IndexPQFastScan.h>
+#include <faiss/IndexPiPNN.h>
 #include <faiss/IndexPreTransform.h>
 #include <faiss/IndexRaBitQ.h>
 #include <faiss/IndexRefine.h>
@@ -170,6 +173,17 @@ IndexNSG* clone_IndexNSG(const IndexNSG* insg) {
     }
 }
 
+static IndexPiPNN* clone_IndexPiPNN(const IndexPiPNN* ipipnn) {
+    TRYCLONE(IndexPiPNNFlat, ipipnn)
+    TRYCLONE(IndexPiPNNSQ, ipipnn) {
+        FAISS_THROW_IF_NOT_FMT(
+                typeid(*ipipnn) == typeid(IndexPiPNN),
+                "clone not supported for this type of IndexPiPNN: %s",
+                typeid(*ipipnn).name());
+        return new IndexPiPNN(*ipipnn);
+    }
+}
+
 IndexRowwiseMinMaxBase* clone_IndexRowwiseMinMax(
         const IndexRowwiseMinMaxBase* irmmb) {
     TRYCLONE(IndexRowwiseMinMaxFP16, irmmb)
@@ -356,6 +370,16 @@ Index* Cloner::clone_Index(const Index* index) {
         res->own_fields = true;
         res->storage = clone_Index(insg->storage);
         return res;
+    } else if (
+            const IndexPiPNN* ipipnn = dynamic_cast<const IndexPiPNN*>(index)) {
+        // make sure we don't get a GPU index here
+        std::unique_ptr<Index> storage(
+                ipipnn->storage ? Cloner::clone_Index(ipipnn->storage)
+                                : nullptr);
+        IndexPiPNN* res = clone_IndexPiPNN(ipipnn);
+        res->storage = storage.release();
+        res->own_fields = true;
+        return res;
     } else if (
             const IndexNNDescent* innd =
                     dynamic_cast<const IndexNNDescent*>(index)) {

data/vendor/faiss/faiss/gpu/Dataset.h

@@ -0,0 +1,112 @@
+/*
+ * 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
+
+#include <faiss/Index.h>
+
+#include <memory>
+
+namespace faiss {
+namespace gpu {
+class GpuResourcesProvider;
+
+/** Caller-controlled dense vector storage for cuVS CAGRA.
+ *
+ * Dimensions and row strides are in elements, with contiguous columns. Binary
+ * vectors use UInt8, and their dimension is the number of bytes, not bits.
+ * Views never own or copy their allocation. An owning Dataset controls the
+ * allocation's lifetime; CAGRA always borrows it. Keep the backing allocation
+ * alive and unchanged until all indexes using it and queued GPU work finish.
+ * Moving an owning Dataset preserves its allocation and existing borrowed
+ * views.
+ */
+class Dataset {
+   public:
+    enum class Layout { Standard, Padded };
+
+    ~Dataset();
+    Dataset(Dataset&&) noexcept;
+    Dataset& operator=(Dataset&&) noexcept;
+    Dataset(const Dataset&) = delete;
+    Dataset& operator=(const Dataset&) = delete;
+
+    /// Borrow host storage. rowStride must be at least dim.
+    static Dataset viewHost(
+            const void* data,
+            idx_t numRows,
+            int dim,
+            NumericType numericType,
+            idx_t rowStride);
+
+    /// Borrow storage accessible on device. A Standard view can also be
+    /// CAGRA-compatible when its physical stride and alignment satisfy padding.
+    /// When used by CAGRA, elements between dim and rowStride must be zero.
+    static Dataset viewDevice(
+            const void* data,
+            idx_t numRows,
+            int dim,
+            NumericType numericType,
+            idx_t rowStride,
+            int device);
+
+    /// Borrow CAGRA-compatible device storage without copying. The base address
+    /// must be 16-byte aligned and rowStride must equal dim rounded up to a
+    /// 16-byte row width. The caller must zero elements between dim and
+    /// rowStride, including for compatible Standard views used by CAGRA.
+    static Dataset viewDevicePadded(
+            const void* data,
+            idx_t numRows,
+            int dim,
+            NumericType numericType,
+            idx_t rowStride,
+            int device);
+
+    /// Create padded device storage using cuVS make_device_padded_dataset.
+    /// Device/managed input whose stride already matches the required padding
+    /// is rejected; use a view for that storage. Copies logical columns and
+    /// zeroes padding asynchronously on the resource's stream. Source data must
+    /// be ready on that stream and stay alive and unchanged until copying
+    /// finishes. Order subsequent use on that stream. Retains the resources
+    /// needed to release the allocation.
+    static Dataset makeDevicePadded(
+            GpuResourcesProvider* resources,
+            const Dataset& source,
+            int device);
+
+    const void* getData() const;
+    idx_t getNumRows() const;
+    int getDim() const;
+    idx_t getRowStride() const;
+    NumericType getNumericType() const;
+    int getDevice() const; // -1 for host storage
+    Layout getLayout() const;
+    bool isDevice() const;
+    bool ownsData() const;
+
+    /// Reports device residency, base alignment, and exact required row stride.
+    /// Does not inspect padding values; zero padding is a caller contract.
+    bool isCagraCompatible() const;
+
+    /// Create a non-owning view of the same storage by copying its metadata.
+    /// Does not retain ownership of the backing allocation.
+    Dataset view() const;
+
+    /// Copy logical columns into packed host storage. destination must have
+    /// numRows * dim * sizeof(element) bytes. Completes all device work using
+    /// the source device before copying and returns with the host data ready.
+    void copyToHost(void* destination) const;
+
+   private:
+    struct Impl;
+    explicit Dataset(std::unique_ptr<Impl> impl);
+    const Impl& getImpl() const;
+    std::unique_ptr<Impl> impl_;
+};
+
+} // namespace gpu
+} // namespace faiss

data/vendor/faiss/faiss/gpu/GpuCloner.cpp

@@ -14,7 +14,7 @@
 
 #include <faiss/IndexBinaryFlat.h>
 #include <faiss/IndexFlat.h>
-#if defined(USE_NVIDIA_CUVS) && !defined(FAISS_CUVS_NO_CAGRA)
+#if defined USE_NVIDIA_CUVS
 #include <faiss/IndexBinaryHNSW.h>
 #include <faiss/IndexHNSW.h>
 #endif
@@ -28,7 +28,7 @@
 #include <faiss/MetaIndexes.h>
 #include <faiss/gpu/GpuIndex.h>
 #include <faiss/gpu/GpuIndexBinaryFlat.h>
-#if defined(USE_NVIDIA_CUVS) && !defined(FAISS_CUVS_NO_CAGRA)
+#if defined USE_NVIDIA_CUVS
 #include <faiss/gpu/GpuIndexBinaryCagra.h>
 #include <faiss/gpu/GpuIndexCagra.h>
 #endif
@@ -92,7 +92,7 @@ Index* ToCPUCloner::clone_Index(const Index* index) {
         // (inverse op of ToGpuClonerMultiple)
 
     }
-#if defined(USE_NVIDIA_CUVS) && !defined(FAISS_CUVS_NO_CAGRA)
+#if defined USE_NVIDIA_CUVS
     else if (auto icg = dynamic_cast<const GpuIndexCagra*>(index)) {
         IndexHNSWCagra* res = new IndexHNSWCagra();
         if (icg->get_numeric_type() != faiss::NumericType::Float32) {
@@ -171,6 +171,7 @@ Index* ToGpuCloner::clone_Index(const Index* index) {
         config.flatConfig.useFloat16 = useFloat16CoarseQuantizer;
         config.use_cuvs = use_cuvs;
         config.allowCpuCoarseQuantizer = allowCpuCoarseQuantizer;
+        config.deterministic_tie_break = deterministic_tie_break;
 
         GpuIndexIVFFlat* res = new GpuIndexIVFFlat(
                 provider, ifl->d, ifl->nlist, ifl->metric_type, config);
@@ -189,6 +190,7 @@ Index* ToGpuCloner::clone_Index(const Index* index) {
         config.flatConfig.useFloat16 = useFloat16CoarseQuantizer;
         config.use_cuvs = use_cuvs;
         config.allowCpuCoarseQuantizer = allowCpuCoarseQuantizer;
+        config.deterministic_tie_break = deterministic_tie_break;
 
         GpuIndexIVFScalarQuantizer* res = new GpuIndexIVFScalarQuantizer(
                 provider,
@@ -224,6 +226,7 @@ Index* ToGpuCloner::clone_Index(const Index* index) {
         config.use_cuvs = use_cuvs;
         config.interleavedLayout = use_cuvs;
         config.allowCpuCoarseQuantizer = allowCpuCoarseQuantizer;
+        config.deterministic_tie_break = deterministic_tie_break;
 
         GpuIndexIVFPQ* res = new GpuIndexIVFPQ(provider, ipq, config);
 
@@ -233,14 +236,14 @@ Index* ToGpuCloner::clone_Index(const Index* index) {
 
         return res;
     }
-#if defined(USE_NVIDIA_CUVS) && !defined(FAISS_CUVS_NO_CAGRA)
+#if defined USE_NVIDIA_CUVS
     else if (auto icg = dynamic_cast<const faiss::IndexHNSWCagra*>(index)) {
         GpuIndexCagraConfig config;
         config.device = device;
-        GpuIndexCagra* res =
-                new GpuIndexCagra(provider, icg->d, icg->metric_type, config);
-        res->copyFrom_ex(icg, icg->get_numeric_type());
-        return res;
+        auto res = std::make_unique<GpuIndexCagra>(
+                provider, icg->d, icg->metric_type, config);
+        res->copyFrom(icg);
+        return res.release();
     }
 #endif
     else {
@@ -533,7 +536,7 @@ faiss::IndexBinary* index_binary_gpu_to_cpu(
         ii->copyTo(ret);
         return ret;
     }
-#if defined(USE_NVIDIA_CUVS) && !defined(FAISS_CUVS_NO_CAGRA)
+#if defined USE_NVIDIA_CUVS
     else if (auto ii = dynamic_cast<const GpuIndexBinaryCagra*>(gpu_index)) {
         IndexBinaryHNSWCagra* ret = new IndexBinaryHNSWCagra();
         ii->copyTo(ret);
@@ -555,15 +558,15 @@ faiss::IndexBinary* index_binary_cpu_to_gpu(
         config.device = device;
         return new GpuIndexBinaryFlat(provider, ii, config);
     }
-#if defined(USE_NVIDIA_CUVS) && !defined(FAISS_CUVS_NO_CAGRA)
+#if defined USE_NVIDIA_CUVS
     else if (
             auto ii = dynamic_cast<const faiss::IndexBinaryHNSWCagra*>(index)) {
         GpuIndexCagraConfig config;
         config.device = device;
-        GpuIndexBinaryCagra* res =
-                new GpuIndexBinaryCagra(provider, ii->d, config);
+        auto res =
+                std::make_unique<GpuIndexBinaryCagra>(provider, ii->d, config);
         res->copyFrom(ii);
-        return res;
+        return res.release();
     }
 #endif
     else {

data/vendor/faiss/faiss/gpu/GpuCloner.h

@@ -70,6 +70,8 @@ struct ToGpuClonerMultiple : faiss::Cloner, GpuMultipleClonerOptions {
 faiss::Index* index_gpu_to_cpu(const faiss::Index* gpu_index);
 
 /// converts any CPU index that can be converted to GPU
+/// CAGRA clones contain only the graph. Call updateDataset with caller-owned,
+/// compatible device storage before searching.
 faiss::Index* index_cpu_to_gpu(
         GpuResourcesProvider* provider,
         int device,
@@ -105,6 +107,8 @@ faiss::IndexBinary* index_binary_gpu_to_cpu(
         const faiss::IndexBinary* gpu_index);
 
 /// converts any CPU index that can be converted to GPU
+/// CAGRA clones contain only the graph. Call updateDataset with caller-owned,
+/// compatible device storage before searching.
 faiss::IndexBinary* index_binary_cpu_to_gpu(
         GpuResourcesProvider* provider,
         int device,

data/vendor/faiss/faiss/gpu/GpuClonerOptions.h

@@ -42,6 +42,9 @@ struct GpuClonerOptions {
     /// Use the cuVS implementation. Opt-in: see GpuIndexConfig::use_cuvs.
     bool use_cuvs = false;
 
+    /// IVF indexes only: see GpuIndexIVFConfig::deterministic_tie_break.
+    bool deterministic_tie_break = false;
+
     /// This flag controls the CPU fallback logic for coarse quantizer
     /// component of the index. When set to false (default), the cloner will
     /// throw an exception for indices not implemented on GPU. When set to

data/vendor/faiss/faiss/gpu/GpuIndex.h

@@ -213,6 +213,9 @@ class GpuIndex : public faiss::Index {
             idx_t* labels,
             const SearchParameters* params) const = 0;
 
+    /// Search with queries of the given numeric type; all data is guaranteed
+    /// to be resident on our device. The default handles Float32 and widens
+    /// Float16 queries to float32 on the device before calling searchImpl_
     virtual void searchImpl_ex_(
             idx_t n,
             const void* x,
@@ -220,19 +223,7 @@ class GpuIndex : public faiss::Index {
             int k,
             float* distances,
             idx_t* labels,
-            const SearchParameters* params) const {
-        if (numeric_type == NumericType::Float32) {
-            searchImpl_(
-                    n,
-                    static_cast<const float*>(x),
-                    k,
-                    distances,
-                    labels,
-                    params);
-        } else {
-            FAISS_THROW_MSG("GpuIndex::searchImpl_: unsupported numeric type");
-        }
-    }
+            const SearchParameters* params) const;
 
    private:
     /// Calls addImpl_ for a single page of GPU-resident data