faiss 0.6.0 → 0.6.1

data/vendor/faiss/faiss/VectorTransform.h

@@ -26,8 +26,8 @@ struct VectorTransform {
     int d_in;  ///! input dimension
     int d_out; ///! output dimension
 
-    explicit VectorTransform(int d_in = 0, int d_out = 0)
-            : d_in(d_in), d_out(d_out), is_trained(true) {}
+    explicit VectorTransform(int d_in_val = 0, int d_out_val = 0)
+            : d_in(d_in_val), d_out(d_out_val), is_trained(true) {}
 
     /// set if the VectorTransform does not require training, or if
     /// training is done already
@@ -82,9 +82,9 @@ struct LinearTransform : VectorTransform {
 
     /// both d_in > d_out and d_out < d_in are supported
     explicit LinearTransform(
-            int d_in = 0,
-            int d_out = 0,
-            bool have_bias = false);
+            int din = 0,
+            int dout = 0,
+            bool have_bias_in = false);
 
     /// same as apply, but result is pre-allocated
     void apply_noalloc(idx_t n, const float* x, float* xt) const override;
@@ -114,8 +114,8 @@ struct LinearTransform : VectorTransform {
 /// Randomly rotate a set of vectors
 struct RandomRotationMatrix : LinearTransform {
     /// both d_in > d_out and d_out < d_in are supported
-    RandomRotationMatrix(int d_in, int d_out)
-            : LinearTransform(d_in, d_out, false) {}
+    RandomRotationMatrix(int d_in_val, int d_out_val)
+            : LinearTransform(d_in_val, d_out_val, false) {}
 
     /// must be called before the transform is used
     void init(int seed);
@@ -183,10 +183,10 @@ struct PCAMatrix : LinearTransform {
 
     // the final matrix is computed after random rotation and/or whitening
     explicit PCAMatrix(
-            int d_in = 0,
-            int d_out = 0,
-            float eigen_power = 0,
-            bool random_rotation = false);
+            int din = 0,
+            int dout = 0,
+            float eigen_power_in = 0,
+            bool random_rotation_in = false);
 
     /// train on n vectors. If n < d_in then the eigenvector matrix
     /// will be completed with 0s
@@ -233,7 +233,7 @@ struct ITQTransform : VectorTransform {
     // concatenation of PCA + ITQ transformation
     LinearTransform pca_then_itq;
 
-    explicit ITQTransform(int d_in = 0, int d_out = 0, bool do_pca = false);
+    explicit ITQTransform(int din = 0, int dout = 0, bool do_pca_in = false);
 
     void train(idx_t n, const float* x) override;
 
@@ -267,7 +267,7 @@ struct OPQMatrix : LinearTransform {
     ProductQuantizer* pq = nullptr;
 
     /// if d2 != -1, output vectors of this dimension
-    explicit OPQMatrix(int d = 0, int M = 1, int d2 = -1);
+    explicit OPQMatrix(int d = 0, int M_in = 1, int d2 = -1);
 
     void train(idx_t n, const float* x) override;
 };
@@ -280,12 +280,12 @@ struct RemapDimensionsTransform : VectorTransform {
     /// -1 -> set output to 0
     std::vector<int> map;
 
-    RemapDimensionsTransform(int d_in, int d_out, const int* map);
+    RemapDimensionsTransform(int din, int dout, const int* map);
 
     /// remap input to output, skipping or inserting dimensions as needed
     /// if uniform: distribute dimensions uniformly
     /// otherwise just take the d_out first ones.
-    RemapDimensionsTransform(int d_in, int d_out, bool uniform = true);
+    RemapDimensionsTransform(int din, int dout, bool uniform = true);
 
     void apply_noalloc(idx_t n, const float* x, float* xt) const override;
 
@@ -301,7 +301,7 @@ struct RemapDimensionsTransform : VectorTransform {
 struct NormalizationTransform : VectorTransform {
     float norm;
 
-    explicit NormalizationTransform(int d, float norm = 2.0);
+    explicit NormalizationTransform(int d, float norm_in = 2.0);
     NormalizationTransform();
 
     void apply_noalloc(idx_t n, const float* x, float* xt) const override;

data/vendor/faiss/faiss/build.cpp

@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+
+#include "faiss/build.h"
+
+namespace faiss {
+
+bool has_omp() {
+    int omp_available = 1;
+    // Detect whether OpenMP is enabled by using the 'max' reduction to render
+    // the below assignment a no-op. This works:
+    //  1) without starting any threads
+    //  2) irrespective of the current thread limit
+#pragma omp parallel reduction(max : omp_available) num_threads(1)
+    omp_available = 0;
+    return omp_available != 0;
+}
+
+} // namespace faiss

data/vendor/faiss/faiss/build.h

@@ -0,0 +1,15 @@
+/*
+ * 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
+
+namespace faiss {
+
+// Returns true iff `faiss` was compiled with non-mocked OpenMP support.
+bool has_omp();
+
+} // namespace faiss

data/vendor/faiss/faiss/clone_index.cpp

@@ -102,8 +102,8 @@ IndexIVF* Cloner::clone_IndexIVF(const IndexIVF* ivf) {
     TRYCLONE(IndexIVFRaBitQ, ivf)
 
     TRYCLONE(IndexIVFFlatDedup, ivf)
-    TRYCLONE(IndexIVFFlat, ivf)
     TRYCLONE(IndexIVFFlatPanorama, ivf)
+    TRYCLONE(IndexIVFFlat, ivf)
 
     TRYCLONE(IndexIVFSpectralHash, ivf)
 
@@ -173,7 +173,7 @@ IndexRowwiseMinMaxBase* clone_IndexRowwiseMinMax(
     }
 }
 
-#define TRYCAST(classname) classname* res = dynamic_cast<classname*>(index)
+#define TRYCAST(classname, var) auto* var = dynamic_cast<classname*>(index)
 
 void reset_AdditiveQuantizerIndex(Index* index) {
     auto clone_ProductQuantizers =
@@ -182,50 +182,50 @@ void reset_AdditiveQuantizerIndex(Index* index) {
                     q = dynamic_cast<AdditiveQuantizer*>(clone_Quantizer(q));
                 }
             };
-    if (TRYCAST(IndexIVFLocalSearchQuantizerFastScan)) {
-        res->aq = &res->lsq;
-    } else if (TRYCAST(IndexIVFResidualQuantizerFastScan)) {
-        res->aq = &res->rq;
-    } else if (TRYCAST(IndexIVFProductLocalSearchQuantizerFastScan)) {
-        res->aq = &res->plsq;
-        clone_ProductQuantizers(res->plsq.quantizers);
-    } else if (TRYCAST(IndexIVFProductResidualQuantizerFastScan)) {
-        res->aq = &res->prq;
-        clone_ProductQuantizers(res->prq.quantizers);
-    } else if (TRYCAST(IndexIVFLocalSearchQuantizer)) {
-        res->aq = &res->lsq;
-    } else if (TRYCAST(IndexIVFResidualQuantizer)) {
-        res->aq = &res->rq;
-    } else if (TRYCAST(IndexIVFProductLocalSearchQuantizer)) {
-        res->aq = &res->plsq;
-        clone_ProductQuantizers(res->plsq.quantizers);
-    } else if (TRYCAST(IndexIVFProductResidualQuantizer)) {
-        res->aq = &res->prq;
-        clone_ProductQuantizers(res->prq.quantizers);
-    } else if (TRYCAST(IndexLocalSearchQuantizerFastScan)) {
-        res->aq = &res->lsq;
-    } else if (TRYCAST(IndexResidualQuantizerFastScan)) {
-        res->aq = &res->rq;
-    } else if (TRYCAST(IndexProductLocalSearchQuantizerFastScan)) {
-        res->aq = &res->plsq;
-        clone_ProductQuantizers(res->plsq.quantizers);
-    } else if (TRYCAST(IndexProductResidualQuantizerFastScan)) {
-        res->aq = &res->prq;
-        clone_ProductQuantizers(res->prq.quantizers);
-    } else if (TRYCAST(IndexLocalSearchQuantizer)) {
-        res->aq = &res->lsq;
-    } else if (TRYCAST(IndexResidualQuantizer)) {
-        res->aq = &res->rq;
-    } else if (TRYCAST(IndexProductLocalSearchQuantizer)) {
-        res->aq = &res->plsq;
-        clone_ProductQuantizers(res->plsq.quantizers);
-    } else if (TRYCAST(IndexProductResidualQuantizer)) {
-        res->aq = &res->prq;
-        clone_ProductQuantizers(res->prq.quantizers);
-    } else if (TRYCAST(LocalSearchCoarseQuantizer)) {
-        res->aq = &res->lsq;
-    } else if (TRYCAST(ResidualCoarseQuantizer)) {
-        res->aq = &res->rq;
+    if (TRYCAST(IndexIVFLocalSearchQuantizerFastScan, r1)) {
+        r1->aq = &r1->lsq;
+    } else if (TRYCAST(IndexIVFResidualQuantizerFastScan, r2)) {
+        r2->aq = &r2->rq;
+    } else if (TRYCAST(IndexIVFProductLocalSearchQuantizerFastScan, r3)) {
+        r3->aq = &r3->plsq;
+        clone_ProductQuantizers(r3->plsq.quantizers);
+    } else if (TRYCAST(IndexIVFProductResidualQuantizerFastScan, r4)) {
+        r4->aq = &r4->prq;
+        clone_ProductQuantizers(r4->prq.quantizers);
+    } else if (TRYCAST(IndexIVFLocalSearchQuantizer, r5)) {
+        r5->aq = &r5->lsq;
+    } else if (TRYCAST(IndexIVFResidualQuantizer, r6)) {
+        r6->aq = &r6->rq;
+    } else if (TRYCAST(IndexIVFProductLocalSearchQuantizer, r7)) {
+        r7->aq = &r7->plsq;
+        clone_ProductQuantizers(r7->plsq.quantizers);
+    } else if (TRYCAST(IndexIVFProductResidualQuantizer, r8)) {
+        r8->aq = &r8->prq;
+        clone_ProductQuantizers(r8->prq.quantizers);
+    } else if (TRYCAST(IndexLocalSearchQuantizerFastScan, r9)) {
+        r9->aq = &r9->lsq;
+    } else if (TRYCAST(IndexResidualQuantizerFastScan, r10)) {
+        r10->aq = &r10->rq;
+    } else if (TRYCAST(IndexProductLocalSearchQuantizerFastScan, r11)) {
+        r11->aq = &r11->plsq;
+        clone_ProductQuantizers(r11->plsq.quantizers);
+    } else if (TRYCAST(IndexProductResidualQuantizerFastScan, r12)) {
+        r12->aq = &r12->prq;
+        clone_ProductQuantizers(r12->prq.quantizers);
+    } else if (TRYCAST(IndexLocalSearchQuantizer, r13)) {
+        r13->aq = &r13->lsq;
+    } else if (TRYCAST(IndexResidualQuantizer, r14)) {
+        r14->aq = &r14->rq;
+    } else if (TRYCAST(IndexProductLocalSearchQuantizer, r15)) {
+        r15->aq = &r15->plsq;
+        clone_ProductQuantizers(r15->plsq.quantizers);
+    } else if (TRYCAST(IndexProductResidualQuantizer, r16)) {
+        r16->aq = &r16->prq;
+        clone_ProductQuantizers(r16->prq.quantizers);
+    } else if (TRYCAST(LocalSearchCoarseQuantizer, r17)) {
+        r17->aq = &r17->lsq;
+    } else if (TRYCAST(ResidualCoarseQuantizer, r18)) {
+        r18->aq = &r18->rq;
     } else {
         FAISS_THROW_MSG(
                 "clone not supported for this type of additive quantizer index");
@@ -319,7 +319,7 @@ Index* Cloner::clone_Index(const Index* index) {
         res->metric_arg = ipt->metric_arg;
 
         res->index = clone_Index(ipt->index);
-        for (int i = 0; i < ipt->chain.size(); i++) {
+        for (size_t i = 0; i < ipt->chain.size(); i++) {
             res->chain.push_back(clone_VectorTransform(ipt->chain[i]));
         }
         res->own_fields = true;
@@ -377,6 +377,7 @@ Index* Cloner::clone_Index(const Index* index) {
         IndexRowwiseMinMaxBase* res = clone_IndexRowwiseMinMax(irmmb);
         res->own_fields = true;
         res->index = clone_Index(irmmb->index);
+        return res;
     } else if (
             dynamic_cast<const IndexAdditiveQuantizerFastScan*>(index) ||
             dynamic_cast<const IndexAdditiveQuantizer*>(index) ||

data/vendor/faiss/faiss/cppcontrib/sa_decode/Level2-avx2-inl.h

@@ -1785,72 +1785,72 @@ struct Index2LevelDecoderImpl<
 
     // process 1 sample
     static void store(
-            const float* const __restrict pqCoarseCentroids0,
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            float* const __restrict outputStore) {}
+            const float* const __restrict /*pqCoarseCentroids0*/,
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            float* const __restrict /*outputStore*/) {}
 
     // process 1 sample
     static void accum(
-            const float* const __restrict pqCoarseCentroids0,
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqCoarseCentroids0*/,
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 2 samples.
     // Each code uses its own coarse pq centroids table and fine pq centroids table.
     static void accum(
-            const float* const __restrict pqCoarseCentroids0,
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const float* const __restrict pqCoarseCentroids1,
-            const float* const __restrict pqFineCentroids1,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqCoarseCentroids0*/,
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const float* const __restrict /*pqCoarseCentroids1*/,
+            const float* const __restrict /*pqFineCentroids1*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 2 samples.
     // Coarse pq centroids table and fine pq centroids table are shared among codes.
     static void accum(
-            const float* const __restrict pqCoarseCentroids,
-            const float* const __restrict pqFineCentroids,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqCoarseCentroids*/,
+            const float* const __restrict /*pqFineCentroids*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 3 samples.
     // Each code uses its own coarse pq centroids table and fine pq centroids table.
     static void accum(
-            const float* const __restrict pqCoarseCentroids0,
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const float* const __restrict pqCoarseCentroids1,
-            const float* const __restrict pqFineCentroids1,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            const float* const __restrict pqCoarseCentroids2,
-            const float* const __restrict pqFineCentroids2,
-            const uint8_t* const __restrict code2,
-            const float weight2,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqCoarseCentroids0*/,
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const float* const __restrict /*pqCoarseCentroids1*/,
+            const float* const __restrict /*pqFineCentroids1*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            const float* const __restrict /*pqCoarseCentroids2*/,
+            const float* const __restrict /*pqFineCentroids2*/,
+            const uint8_t* const __restrict /*code2*/,
+            const float /*weight2*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 3 samples.
     // Coarse pq centroids table and fine pq centroids table are shared among codes.
     static void accum(
-            const float* const __restrict pqCoarseCentroids,
-            const float* const __restrict pqFineCentroids,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            const uint8_t* const __restrict code2,
-            const float weight2,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqCoarseCentroids*/,
+            const float* const __restrict /*pqFineCentroids*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            const uint8_t* const __restrict /*code2*/,
+            const float /*weight2*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // clang-format on
 };

data/vendor/faiss/faiss/cppcontrib/sa_decode/Level2-inl.h

@@ -8,6 +8,12 @@
 #ifndef LEVEL2_INL_H
 #define LEVEL2_INL_H
 
+// GCC does not recognize #pragma unroll (Clang extension)
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#endif
+
 #include <cstddef>
 #include <cstdint>
 
@@ -464,4 +470,9 @@ struct Index2LevelDecoder {
 
 } // namespace cppcontrib
 } // namespace faiss
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
 #endif // LEVEL2_INL_H

data/vendor/faiss/faiss/cppcontrib/sa_decode/PQ-avx2-inl.h

@@ -1428,63 +1428,63 @@ struct IndexPQDecoderImpl<
 
     // process 1 sample
     static void store(
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            float* const __restrict outputStore) {}
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            float* const __restrict /*outputStore*/) {}
 
     // process 1 sample
     static void accum(
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 2 samples.
     // Each code uses its own fine pq centroids table.
     static void accum(
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const float* const __restrict pqFineCentroids1,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const float* const __restrict /*pqFineCentroids1*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 2 samples.
     // Fine pq centroids table is shared among codes.
     static void accum(
-            const float* const __restrict pqFineCentroids,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqFineCentroids*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 3 samples.
     // Each code uses its own fine pq centroids table.
     static void accum(
-            const float* const __restrict pqFineCentroids0,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const float* const __restrict pqFineCentroids1,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            const float* const __restrict pqFineCentroids2,
-            const uint8_t* const __restrict code2,
-            const float weight2,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqFineCentroids0*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const float* const __restrict /*pqFineCentroids1*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            const float* const __restrict /*pqFineCentroids2*/,
+            const uint8_t* const __restrict /*code2*/,
+            const float /*weight2*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // Process 3 samples.
     // Fine pq centroids table is shared among codes.
     static void accum(
-            const float* const __restrict pqFineCentroids,
-            const uint8_t* const __restrict code0,
-            const float weight0,
-            const uint8_t* const __restrict code1,
-            const float weight1,
-            const uint8_t* const __restrict code2,
-            const float weight2,
-            float* const __restrict outputAccum) {}
+            const float* const __restrict /*pqFineCentroids*/,
+            const uint8_t* const __restrict /*code0*/,
+            const float /*weight0*/,
+            const uint8_t* const __restrict /*code1*/,
+            const float /*weight1*/,
+            const uint8_t* const __restrict /*code2*/,
+            const float /*weight2*/,
+            float* const __restrict /*outputAccum*/) {}
 
     // clang-format on
 };

data/vendor/faiss/faiss/cppcontrib/sa_decode/PQ-inl.h

@@ -8,6 +8,12 @@
 #ifndef PQ_INL_H
 #define PQ_INL_H
 
+// GCC does not recognize #pragma unroll (Clang extension)
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#endif
+
 #include <cstddef>
 #include <cstdint>
 
@@ -254,4 +260,9 @@ struct IndexPQDecoder {
 
 } // namespace cppcontrib
 } // namespace faiss
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
 #endif // PQ_INL_H

data/vendor/faiss/faiss/factory_tools.cpp

@@ -38,6 +38,11 @@ const std::map<faiss::ScalarQuantizer::QuantizerType, std::string> sq_types = {
         {faiss::ScalarQuantizer::QT_bf16, "SQbf16"},
         {faiss::ScalarQuantizer::QT_8bit_direct_signed, "SQ8_direct_signed"},
         {faiss::ScalarQuantizer::QT_8bit_direct, "SQ8_direct"},
+        {faiss::ScalarQuantizer::QT_1bit_tqmse, "SQtqmse1"},
+        {faiss::ScalarQuantizer::QT_2bit_tqmse, "SQtqmse2"},
+        {faiss::ScalarQuantizer::QT_3bit_tqmse, "SQtqmse3"},
+        {faiss::ScalarQuantizer::QT_4bit_tqmse, "SQtqmse4"},
+        {faiss::ScalarQuantizer::QT_8bit_tqmse, "SQtqmse8"},
 };
 
 int get_hnsw_M(const faiss::IndexHNSW* index) {

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

@@ -28,6 +28,7 @@
 #include <faiss/gpu/GpuIndexIVFPQ.h>
 
 #include <variant>
+#include <vector>
 #include "faiss/Index.h"
 
 namespace faiss {
@@ -193,14 +194,14 @@ struct GpuIndexCagraConfig : public GpuIndexConfig {
 
 enum class search_algo {
     /// For large batch sizes.
-    SINGLE_CTA,
+    SINGLE_CTA = 0,
     /// For small batch sizes.
-    MULTI_CTA,
-    MULTI_KERNEL,
-    AUTO
+    MULTI_CTA = 1,
+    MULTI_KERNEL = 2,
+    AUTO = 100
 };
 
-enum class hash_mode { HASH, SMALL, AUTO };
+enum class hash_mode { HASH = 0, SMALL = 1, AUTO = 100 };
 
 struct SearchParametersCagra : SearchParameters {
     /// Maximum number of queries to search at the same time (batch size). Auto

data/vendor/faiss/faiss/gpu/GpuResources.h

@@ -33,7 +33,7 @@
 
 #if defined USE_NVIDIA_CUVS
 #include <raft/core/device_resources.hpp>
-#include <rmm/mr/device/device_memory_resource.hpp>
+#include <rmm/mr/device_memory_resource.hpp>
 #endif
 
 namespace faiss {

data/vendor/faiss/faiss/gpu/StandardGpuResources.cpp

@@ -23,9 +23,9 @@
 
 #if defined USE_NVIDIA_CUVS
 #include <raft/core/device_resources.hpp>
-#include <rmm/mr/device/managed_memory_resource.hpp>
-#include <rmm/mr/device/per_device_resource.hpp>
-#include <rmm/mr/host/pinned_memory_resource.hpp>
+#include <rmm/mr/managed_memory_resource.hpp>
+#include <rmm/mr/per_device_resource.hpp>
+#include <rmm/mr/pinned_host_memory_resource.hpp>
 #include <memory>
 #endif
 
@@ -93,7 +93,7 @@ StandardGpuResourcesImpl::StandardGpuResourcesImpl()
         :
 #if defined USE_NVIDIA_CUVS
           mmr_(new rmm::mr::managed_memory_resource),
-          pmr_(new rmm::mr::pinned_memory_resource),
+          pmr_(new rmm::mr::pinned_host_memory_resource),
 #endif
           pinnedMemAlloc_(nullptr),
           pinnedMemAllocSize_(0),
@@ -164,7 +164,7 @@ StandardGpuResourcesImpl::~StandardGpuResourcesImpl() {
 
     if (pinnedMemAlloc_) {
 #if defined USE_NVIDIA_CUVS
-        pmr_->deallocate(pinnedMemAlloc_, pinnedMemAllocSize_);
+        pmr_->deallocate_sync(pinnedMemAlloc_, pinnedMemAllocSize_);
 #else
         auto err = cudaFreeHost(pinnedMemAlloc_);
         FAISS_ASSERT_FMT(
@@ -350,7 +350,7 @@ void StandardGpuResourcesImpl::initializeForDevice(int device) {
         // pinned memory allocation
         if (defaultStreams_.empty() && pinnedMemSize_ > 0) {
             try {
-                pinnedMemAlloc_ = pmr_->allocate(pinnedMemSize_);
+                pinnedMemAlloc_ = pmr_->allocate_sync(pinnedMemSize_);
             } catch (const std::bad_alloc& rmm_ex) {
                 FAISS_THROW_MSG("CUDA memory allocation error");
             }
@@ -549,7 +549,7 @@ void* StandardGpuResourcesImpl::allocMemory(const AllocRequest& req) {
             rmm::mr::device_memory_resource* current_mr =
                     rmm::mr::get_per_device_resource(
                             rmm::cuda_device_id{adjReq.device});
-            p = current_mr->allocate_async(adjReq.size, adjReq.stream);
+            p = current_mr->allocate(adjReq.stream, adjReq.size);
             adjReq.mr = current_mr;
         } catch (const std::bad_alloc& rmm_ex) {
             FAISS_THROW_MSG("CUDA memory allocation error");
@@ -584,7 +584,7 @@ void* StandardGpuResourcesImpl::allocMemory(const AllocRequest& req) {
             // TODO: change this to use the current device resource once RMM has
             // a way to retrieve a "guaranteed" managed memory resource for a
             // device.
-            p = mmr_->allocate_async(adjReq.size, adjReq.stream);
+            p = mmr_->allocate(adjReq.stream, adjReq.size);
             adjReq.mr = mmr_.get();
         } catch (const std::bad_alloc& rmm_ex) {
             FAISS_THROW_MSG("CUDA memory allocation error");
@@ -648,7 +648,7 @@ void StandardGpuResourcesImpl::deallocMemory(int device, void* p) {
             req.space == MemorySpace::Device ||
             req.space == MemorySpace::Unified) {
 #if defined USE_NVIDIA_CUVS
-        req.mr->deallocate_async(p, req.size, req.stream);
+        req.mr->deallocate(req.stream, p, req.size);
 #else
         auto err = cudaFree(p);
         FAISS_ASSERT_FMT(