faiss 0.6.0 → 0.6.2

data/vendor/faiss/faiss/factory_tools.cpp

@@ -38,6 +38,15 @@ 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"},
+        {faiss::ScalarQuantizer::QT_2bit_tq, "SQtq2"},
+        {faiss::ScalarQuantizer::QT_3bit_tq, "SQtq3"},
+        {faiss::ScalarQuantizer::QT_4bit_tq, "SQtq4"},
+        {faiss::ScalarQuantizer::QT_5bit_tq, "SQtq5"},
 };
 
 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,8 @@
 
 #if defined USE_NVIDIA_CUVS
 #include <raft/core/device_resources.hpp>
-#include <rmm/mr/device/device_memory_resource.hpp>
+#include <cuda/memory_resource>
+#include <optional>
 #endif
 
 namespace faiss {
@@ -163,7 +164,7 @@ struct AllocRequest : public AllocInfo {
     size_t size = 0;
 
 #if defined USE_NVIDIA_CUVS
-    rmm::mr::device_memory_resource* mr = nullptr;
+    std::optional<cuda::mr::any_resource<cuda::mr::device_accessible>> mr;
 #endif
 };
 

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
 
@@ -92,8 +92,8 @@ std::string allocsToString(const std::unordered_map<void*, AllocRequest>& map) {
 StandardGpuResourcesImpl::StandardGpuResourcesImpl()
         :
 #if defined USE_NVIDIA_CUVS
-          mmr_(new rmm::mr::managed_memory_resource),
-          pmr_(new rmm::mr::pinned_memory_resource),
+          mmr_{},
+          pmr_{},
 #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");
             }
@@ -546,10 +546,9 @@ void* StandardGpuResourcesImpl::allocMemory(const AllocRequest& req) {
     } else if (adjReq.space == MemorySpace::Device) {
 #if defined USE_NVIDIA_CUVS
         try {
-            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);
+            auto current_mr = rmm::mr::get_per_device_resource_ref(
+                    rmm::cuda_device_id{adjReq.device});
+            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");
@@ -562,7 +561,7 @@ void* StandardGpuResourcesImpl::allocMemory(const AllocRequest& req) {
             // FIXME: as of CUDA 11, a memory allocation error appears to be
             // presented via cudaGetLastError as well, and needs to be
             // cleared. Just call the function to clear it
-            cudaGetLastError();
+            (void)cudaGetLastError();
 
             std::stringstream ss;
             ss << "StandardGpuResources: alloc fail " << adjReq.toString()
@@ -584,8 +583,8 @@ 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);
-            adjReq.mr = mmr_.get();
+            p = mmr_.allocate(adjReq.stream, adjReq.size);
+            adjReq.mr = mmr_;
         } catch (const std::bad_alloc& rmm_ex) {
             FAISS_THROW_MSG("CUDA memory allocation error");
         }
@@ -596,7 +595,7 @@ void* StandardGpuResourcesImpl::allocMemory(const AllocRequest& req) {
             // FIXME: as of CUDA 11, a memory allocation error appears to be
             // presented via cudaGetLastError as well, and needs to be cleared.
             // Just call the function to clear it
-            cudaGetLastError();
+            (void)cudaGetLastError();
 
             std::stringstream ss;
             ss << "StandardGpuResources: alloc fail " << adjReq.toString()
@@ -648,7 +647,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(

data/vendor/faiss/faiss/gpu/StandardGpuResources.h

@@ -25,7 +25,8 @@
 
 #if defined USE_NVIDIA_CUVS
 #include <raft/core/device_resources.hpp>
-#include <rmm/mr/host/pinned_memory_resource.hpp>
+#include <rmm/mr/managed_memory_resource.hpp>
+#include <rmm/mr/pinned_host_memory_resource.hpp>
 #endif
 
 #include <faiss/gpu/GpuResources.h>
@@ -170,10 +171,10 @@ class StandardGpuResourcesImpl : public GpuResources {
      */
 
     // managed_memory_resource
-    std::unique_ptr<rmm::mr::device_memory_resource> mmr_;
+    rmm::mr::managed_memory_resource mmr_;
 
-    // pinned_memory_resource
-    std::unique_ptr<rmm::mr::host_memory_resource> pmr_;
+    // pinned_host_memory_resource
+    rmm::mr::pinned_host_memory_resource pmr_;
 #endif
 
     /// Pinned memory allocation for use with this GPU

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

@@ -11,6 +11,7 @@
 #include <faiss/gpu/impl/IndexUtils.h>
 #include <faiss/gpu/test/TestUtils.h>
 #include <faiss/gpu/utils/DeviceUtils.h>
+#include <faiss/impl/IDSelector.h>
 #include <gtest/gtest.h>
 #include <sstream>
 #include <unordered_map>
@@ -761,6 +762,51 @@ TEST(TestCuvsGpuIndexFlat, SearchAndReconstruct) {
 }
 #endif
 
+void testIDSelectorFlat(faiss::MetricType metricType) {
+    int numAdd = faiss::gpu::randVal(2000, 5000);
+    int dim = faiss::gpu::randVal(64, 200);
+    int numQuery = faiss::gpu::randVal(32, 100);
+    int k = faiss::gpu::randVal(10, 30);
+    int device = faiss::gpu::randVal(0, faiss::gpu::getNumDevices() - 1);
+
+    faiss::gpu::StandardGpuResources res;
+    res.noTempMemory();
+
+    auto queryVecs = faiss::gpu::randVecs(numQuery, dim);
+    faiss::gpu::GpuIndexFlatConfig config;
+    config.device = device;
+    config.use_cuvs = true;
+    for (bool useFloat16 : {false, true}) {
+        config.useFloat16 = useFloat16;
+        faiss::gpu::GpuIndexFlat gpuIndex(&res, dim, metricType, config);
+        std::vector<float> addVecs = faiss::gpu::randVecs(numAdd, dim);
+        gpuIndex.add(numAdd, addVecs.data());
+
+        faiss::gpu::TestIDSelectorStruct selector_struct(numAdd);
+        faiss::SearchParameters search_params;
+        for (auto& [selectorName, selector] : selector_struct.selector_map) {
+            search_params.sel = selector.get();
+            faiss::gpu::testIDSelectorSearch(
+                    &gpuIndex,
+                    &search_params,
+                    queryVecs,
+                    numQuery,
+                    k,
+                    selectorName);
+        }
+    }
+}
+
+#if defined USE_NVIDIA_CUVS
+TEST(TestCuvsGpuIndexFlat, IDSelector_L2) {
+    testIDSelectorFlat(faiss::METRIC_L2);
+}
+
+TEST(TestCuvsGpuIndexFlat, IDSelector_IP) {
+    testIDSelectorFlat(faiss::METRIC_INNER_PRODUCT);
+}
+#endif
+
 int main(int argc, char** argv) {
     testing::InitGoogleTest(&argc, argv);
 

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

@@ -28,6 +28,8 @@
 #include <faiss/gpu/StandardGpuResources.h>
 #include <faiss/gpu/test/TestUtils.h>
 #include <faiss/gpu/utils/DeviceUtils.h>
+#include <faiss/impl/IDSelector.h>
+#include <faiss/utils/distances.h>
 #include <gtest/gtest.h>
 #include <cmath>
 #include <sstream>
@@ -354,6 +356,11 @@ TEST(TestGpuIndexIVFFlat, Float32_Query_IP) {
 }
 
 TEST(TestGpuIndexIVFFlat, LargeBatch) {
+    // With low-dim vectors, CPU will use non-BLAS. Force the CPU to use
+    // the BLAS for consistent comparison.
+    int saved_threshold = faiss::distance_compute_blas_threshold;
+    faiss::distance_compute_blas_threshold = 1;
+
     Options opt;
     opt.dim = 3;
     opt.numQuery = 100000;
@@ -364,6 +371,8 @@ TEST(TestGpuIndexIVFFlat, LargeBatch) {
     opt.indicesOpt = faiss::gpu::INDICES_64_BIT;
     queryTest(opt, faiss::METRIC_L2, false);
 #endif
+
+    faiss::distance_compute_blas_threshold = saved_threshold;
 }
 
 // float16 coarse quantizer
@@ -909,6 +918,53 @@ TEST(TestGpuIndexIVFFlat, Reconstruct_n) {
     EXPECT_EQ(gpuVals, cpuVals);
 }
 
+void testIDSelectorIVFFlat(faiss::MetricType metricType) {
+    Options opt;
+
+    std::vector<float> trainVecs = faiss::gpu::randVecs(opt.numTrain, opt.dim);
+    std::vector<float> addVecs = faiss::gpu::randVecs(opt.numAdd, opt.dim);
+
+    faiss::gpu::StandardGpuResources res;
+    res.noTempMemory();
+
+    faiss::gpu::GpuIndexIVFFlatConfig config;
+    config.device = opt.device;
+    config.indicesOptions = faiss::gpu::INDICES_64_BIT;
+    config.use_cuvs = true;
+
+    faiss::gpu::GpuIndexIVFFlat gpuIndex(
+            &res, opt.dim, opt.numCentroids, metricType, config);
+    gpuIndex.nprobe = opt.nprobe;
+
+    gpuIndex.train(opt.numTrain, trainVecs.data());
+    gpuIndex.add(opt.numAdd, addVecs.data());
+
+    auto queryVecs = faiss::gpu::randVecs(opt.numQuery, opt.dim);
+    faiss::gpu::TestIDSelectorStruct selector_struct(opt.numAdd);
+    faiss::SearchParametersIVF search_params;
+    search_params.nprobe = opt.nprobe;
+    for (auto& [selectorName, selector] : selector_struct.selector_map) {
+        search_params.sel = selector.get();
+        faiss::gpu::testIDSelectorSearch(
+                &gpuIndex,
+                &search_params,
+                queryVecs,
+                opt.numQuery,
+                opt.k,
+                selectorName);
+    }
+}
+
+#if defined USE_NVIDIA_CUVS
+TEST(TestCuvsGpuIndexIVFFlat, IDSelector_L2) {
+    testIDSelectorIVFFlat(faiss::METRIC_L2);
+}
+
+TEST(TestCuvsGpuIndexIVFFlat, IDSelector_IP) {
+    testIDSelectorIVFFlat(faiss::METRIC_INNER_PRODUCT);
+}
+#endif
+
 int main(int argc, char** argv) {
     testing::InitGoogleTest(&argc, argv);
 

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

@@ -6,11 +6,14 @@
  */
 
 #include <faiss/IndexFlat.h>
+#include <faiss/IndexIVF.h>
 #include <faiss/IndexIVFPQ.h>
 #include <faiss/gpu/GpuIndexIVFPQ.h>
 #include <faiss/gpu/StandardGpuResources.h>
 #include <faiss/gpu/test/TestUtils.h>
 #include <faiss/gpu/utils/DeviceUtils.h>
+#include <faiss/impl/IDSelector.h>
+#include <faiss/utils/distances.h>
 #include <gtest/gtest.h>
 #include <cmath>
 #include <sstream>
@@ -101,7 +104,11 @@ struct Options {
     }
 
     float getCompareEpsilon() const {
-        return 0.035f;
+        // With very low dimensionality (e.g., dim=4, codes=2 giving
+        // dimPerSubQuantizer=2), L2 distances can be very small
+        // (near-zero), causing relative error comparisons to be
+        // unstable despite tiny absolute differences.
+        return (dim <= 8) ? 0.15f : 0.035f;
     }
 
     float getPctMaxDiff1() const {
@@ -190,6 +197,11 @@ TEST(TestGpuIndexIVFPQ, Query_IP) {
 
 // Large batch sizes (>= 65536) should also work
 TEST(TestGpuIndexIVFPQ, LargeBatch) {
+    // With low-dim vectors, CPU will use non-BLAS. Force the CPU to use
+    // the BLAS for consistent comparison.
+    int saved_threshold = faiss::distance_compute_blas_threshold;
+    faiss::distance_compute_blas_threshold = 1;
+
     for (bool usePrecomputed : {false, true}) {
         Options opt;
 
@@ -202,6 +214,8 @@ TEST(TestGpuIndexIVFPQ, LargeBatch) {
 
         queryTest(opt, faiss::MetricType::METRIC_L2);
     }
+
+    faiss::distance_compute_blas_threshold = saved_threshold;
 }
 
 void testMMCodeDistance(faiss::MetricType mt) {
@@ -697,6 +711,11 @@ TEST(TestGpuIndexIVFPQ, Query_IP_Cuvs) {
 
 // Large batch sizes (>= 65536) should also work
 TEST(TestGpuIndexIVFPQ, LargeBatch_Cuvs) {
+    // See LargeBatch comment: force CPU BLAS path to match GPU GEMM
+    // decomposition for consistent L2 distance computation.
+    int saved_threshold = faiss::distance_compute_blas_threshold;
+    faiss::distance_compute_blas_threshold = 1;
+
     Options opt;
 
     // override for large sizes
@@ -711,6 +730,8 @@ TEST(TestGpuIndexIVFPQ, LargeBatch_Cuvs) {
     opt.bitsPerCode = 8;
 
     queryTest(opt, faiss::MetricType::METRIC_L2);
+
+    faiss::distance_compute_blas_threshold = saved_threshold;
 }
 
 TEST(TestGpuIndexIVFPQ, CopyFrom_Cuvs) {
@@ -877,6 +898,62 @@ TEST(TestGpuIndexIVFPQ, UnifiedMemory) {
 #endif
 }
 
+void testIDSelectorIVFPQ(faiss::MetricType metricType) {
+    Options opt;
+
+    std::vector<float> trainVecs = faiss::gpu::randVecs(opt.numTrain, opt.dim);
+    std::vector<float> addVecs = faiss::gpu::randVecs(opt.numAdd, opt.dim);
+
+    faiss::IndexFlatL2 quantizerL2(opt.dim);
+    faiss::IndexFlatIP quantizerIP(opt.dim);
+    faiss::Index* quantizer = metricType == faiss::METRIC_L2
+            ? (faiss::Index*)&quantizerL2
+            : (faiss::Index*)&quantizerIP;
+
+    faiss::IndexIVFPQ cpuIndex(
+            quantizer, opt.dim, opt.numCentroids, opt.codes, opt.bitsPerCode);
+    cpuIndex.metric_type = metricType;
+    cpuIndex.train(opt.numTrain, trainVecs.data());
+    cpuIndex.add(opt.numAdd, addVecs.data());
+
+    faiss::gpu::StandardGpuResources res;
+    res.noTempMemory();
+
+    faiss::gpu::GpuIndexIVFPQConfig config;
+    config.device = opt.device;
+    config.indicesOptions = faiss::gpu::INDICES_64_BIT;
+    config.interleavedLayout = true;
+    config.use_cuvs = true;
+
+    faiss::gpu::GpuIndexIVFPQ gpuIndex(&res, &cpuIndex, config);
+    gpuIndex.nprobe = opt.nprobe;
+
+    auto queryVecs = faiss::gpu::randVecs(opt.numQuery, opt.dim);
+    faiss::gpu::TestIDSelectorStruct selector_struct(opt.numAdd);
+    faiss::SearchParametersIVF search_params;
+    search_params.nprobe = opt.nprobe;
+    for (auto& [selectorName, selector] : selector_struct.selector_map) {
+        search_params.sel = selector.get();
+        faiss::gpu::testIDSelectorSearch(
+                &gpuIndex,
+                &search_params,
+                queryVecs,
+                opt.numQuery,
+                opt.k,
+                selectorName);
+    }
+}
+
+#if defined USE_NVIDIA_CUVS
+TEST(TestCuvsGpuIndexIVFPQ, IDSelector_L2) {
+    testIDSelectorIVFPQ(faiss::METRIC_L2);
+}
+
+TEST(TestCuvsGpuIndexIVFPQ, IDSelector_IP) {
+    testIDSelectorIVFPQ(faiss::METRIC_INNER_PRODUCT);
+}
+#endif
+
 int main(int argc, char** argv) {
     testing::InitGoogleTest(&argc, argv);
 

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

@@ -6,6 +6,7 @@
  */
 
 #include <faiss/gpu/test/TestUtils.h>
+#include <faiss/impl/IDSelector.h>
 #include <faiss/utils/random.h>
 #include <gtest/gtest.h>
 #include <time.h>
@@ -429,5 +430,76 @@ void compareLists(
     }
 }
 
+TestIDSelectorStruct::TestIDSelectorStruct(int numAdd) {
+    // Range selector [20%, 80%] of the database
+    size_t min_id = numAdd / 5;
+    size_t max_id = numAdd * 4 / 5;
+    selector_map["Range"] =
+            std::make_unique<faiss::IDSelectorRange>(min_id, max_id);
+
+    // Array selector (every 3rd element)
+    array_ids.clear();
+    for (int i = 0; i < numAdd; i += 3) {
+        array_ids.push_back(i);
+    }
+    selector_map["Array"] = std::make_unique<faiss::IDSelectorArray>(
+            array_ids.size(), array_ids.data());
+
+    // Batch selector (every 5th element)
+    batch_ids.clear();
+    for (int i = 1; i < numAdd; i += 5) {
+        batch_ids.push_back(i);
+    }
+    selector_map["Batch"] = std::make_unique<faiss::IDSelectorBatch>(
+            batch_ids.size(), batch_ids.data());
+
+    // Bitmap selector (every 4th element selected)
+    size_t bitmap_size = (numAdd + 7) / 8;
+    bitmap.resize(bitmap_size, 0);
+    for (int i = 0; i < numAdd; i += 4) {
+        int byte_idx = i / 8;
+        int bit_idx = i % 8;
+        bitmap[byte_idx] |= (1 << bit_idx);
+    }
+    selector_map["Bitmap"] =
+            std::make_unique<faiss::IDSelectorBitmap>(numAdd, bitmap.data());
+
+    selector_map["Not"] =
+            std::make_unique<faiss::IDSelectorNot>(selector_map["Range"].get());
+    selector_map["And"] = std::make_unique<faiss::IDSelectorAnd>(
+            selector_map["Range"].get(), selector_map["Array"].get());
+    selector_map["Or"] = std::make_unique<faiss::IDSelectorOr>(
+            selector_map["Range"].get(), selector_map["Batch"].get());
+    selector_map["XOr"] = std::make_unique<faiss::IDSelectorXOr>(
+            selector_map["Not"].get(), selector_map["Array"].get());
+}
+
+void testIDSelectorSearch(
+        faiss::Index* index,
+        faiss::SearchParameters* search_params,
+        const std::vector<float>& queryVecs,
+        int numQuery,
+        int k,
+        const std::string& selectorName) {
+    FAISS_ASSERT(search_params && search_params->sel);
+    std::vector<float> distances(numQuery * k, 0);
+    std::vector<faiss::idx_t> labels(numQuery * k, -1);
+    index->search(
+            numQuery,
+            queryVecs.data(),
+            k,
+            distances.data(),
+            labels.data(),
+            search_params);
+    faiss::IDSelector* selector = search_params->sel;
+    for (int i = 0; i < numQuery * k; ++i) {
+        if (labels[i] >= 0) {
+            EXPECT_TRUE(selector->is_member(labels[i]))
+                    << "Label " << labels[i] << " @ " << i << " not in "
+                    << selectorName << " selector";
+        }
+    }
+}
+
 } // namespace gpu
 } // namespace faiss

data/vendor/faiss/faiss/gpu/test/TestUtils.h

@@ -13,6 +13,7 @@
 #include <gtest/gtest.h>
 #include <cstring>
 #include <initializer_list>
+#include <map>
 #include <memory>
 #include <string>
 #include <vector>
@@ -141,5 +142,27 @@ void testIVFEquality(A& cpuIndex, B& gpuIndex) {
     }
 }
 
+/// Run search with the given search_params and verify all returned labels are
+/// members of the selector. Works with any Index that supports search with
+/// SearchParameters.
+void testIDSelectorSearch(
+        faiss::Index* index,
+        faiss::SearchParameters* search_params,
+        const std::vector<float>& queryVecs,
+        int numQuery,
+        int k,
+        const std::string& selectorName);
+
+// Structure to hold all IDSelector instances
+struct TestIDSelectorStruct {
+    // Storage for selectors that need it
+    std::vector<faiss::idx_t> array_ids;
+    std::vector<faiss::idx_t> batch_ids;
+    std::vector<uint8_t> bitmap;
+    std::map<std::string, std::unique_ptr<faiss::IDSelector>> selector_map;
+
+    explicit TestIDSelectorStruct(int numAdd);
+};
+
 } // namespace gpu
 } // namespace faiss

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

@@ -36,6 +36,6 @@ namespace faiss::gpu {
 void convert_to_bitset(
         faiss::gpu::GpuResources* res,
         const faiss::IDSelector& selector,
-        cuvs::core::bitset_view<uint32_t, uint32_t> bitset,
+        cuvs::core::bitset_view<uint32_t, int64_t> bitset,
         int num_threads = 0);
 } // namespace faiss::gpu

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

@@ -27,32 +27,32 @@
 #include <faiss/gpu/GpuResources.h>
 #include <faiss/gpu/utils/Tensor.cuh>
 
-#include <cuvs/distance/distance.h>
+#include <cuvs/distance/distance.hpp>
 
 #pragma GCC visibility push(default)
 namespace faiss {
 namespace gpu {
 
-inline cuvsDistanceType metricFaissToCuvs(
+inline cuvs::distance::DistanceType metricFaissToCuvs(
         MetricType metric,
         bool exactDistance) {
     switch (metric) {
         case MetricType::METRIC_INNER_PRODUCT:
-            return cuvsDistanceType::InnerProduct;
+            return cuvs::distance::DistanceType::InnerProduct;
         case MetricType::METRIC_L2:
-            return cuvsDistanceType::L2Expanded;
+            return cuvs::distance::DistanceType::L2Expanded;
         case MetricType::METRIC_L1:
-            return cuvsDistanceType::L1;
+            return cuvs::distance::DistanceType::L1;
         case MetricType::METRIC_Linf:
-            return cuvsDistanceType::Linf;
+            return cuvs::distance::DistanceType::Linf;
         case MetricType::METRIC_Lp:
-            return cuvsDistanceType::LpUnexpanded;
+            return cuvs::distance::DistanceType::LpUnexpanded;
         case MetricType::METRIC_Canberra:
-            return cuvsDistanceType::Canberra;
+            return cuvs::distance::DistanceType::Canberra;
         case MetricType::METRIC_BrayCurtis:
-            return cuvsDistanceType::BrayCurtis;
+            return cuvs::distance::DistanceType::BrayCurtis;
         case MetricType::METRIC_JensenShannon:
-            return cuvsDistanceType::JensenShannon;
+            return cuvs::distance::DistanceType::JensenShannon;
         default:
             RAFT_FAIL("Distance type not supported");
     }
@@ -71,6 +71,17 @@ idx_t inplaceGatherFilteredRows(
         GpuResources* res,
         Tensor<float, 2, true>& vecs,
         Tensor<idx_t, 1, true>& indices);
+
+/// Copy uint32_t indices to idx_t, replacing any index >= n with -1.
+/// cuVS CAGRA returns sentinel values (e.g. INT32_MAX) for result slots
+/// where filtered search couldn't find a valid neighbor.
+void sanitizeCuvsIndices(
+        GpuResources* res,
+        uint32_t* src,
+        idx_t* dst,
+        size_t count,
+        idx_t n);
+
 } // namespace gpu
 } // namespace faiss
 #pragma GCC visibility pop

data/vendor/faiss/faiss/gpu_metal/GpuIndexFlat.h

@@ -0,0 +1,22 @@
+// @lint-ignore-every LICENSELINT
+/**
+ * Copyright (c) Meta Platforms, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Unified name for flat GPU index when Metal backend is built.
+ * Include this when using the Metal backend for API parity with
+ * faiss::gpu::GpuIndexFlat.
+ */
+
+#pragma once
+
+#include <faiss/gpu_metal/MetalIndexFlat.h>
+
+namespace faiss {
+
+/// When FAISS is built with Metal backend, GpuIndexFlat is MetalIndexFlat.
+using GpuIndexFlat = gpu_metal::MetalIndexFlat;
+
+} // namespace faiss