Merge branch 'main' into java/fix-test-deallocation-issue

mythrocks · web-flow · commit 53bc8618bcb0 · 2025-11-09T19:43:19.000-08:00
diff --git a/c/src/core/c_api.cpp b/c/src/core/c_api.cpp
@@ -124,7 +124,7 @@ extern "C" cuvsError_t cuvsRMMAlloc(cuvsResources_t res, void** ptr, size_t byte
   return cuvs::core::translate_exceptions([=] {
     auto res_ptr = reinterpret_cast<raft::resources*>(res);
     auto mr      = rmm::mr::get_current_device_resource();
-    *ptr         = mr->allocate(bytes, raft::resource::get_cuda_stream(*res_ptr));
+    *ptr         = mr->allocate(raft::resource::get_cuda_stream(*res_ptr), bytes);
   });
 }
 
@@ -133,7 +133,7 @@ extern "C" cuvsError_t cuvsRMMFree(cuvsResources_t res, void* ptr, size_t bytes)
   return cuvs::core::translate_exceptions([=] {
     auto res_ptr = reinterpret_cast<raft::resources*>(res);
     auto mr      = rmm::mr::get_current_device_resource();
-    mr->deallocate(ptr, bytes, raft::resource::get_cuda_stream(*res_ptr));
+    mr->deallocate(raft::resource::get_cuda_stream(*res_ptr), ptr, bytes);
   });
 }
 
@@ -187,13 +187,13 @@ extern "C" cuvsError_t cuvsRMMHostAlloc(void** ptr, size_t bytes)
 {
   return cuvs::core::translate_exceptions([=] {
     if (pinned_mr == nullptr) { pinned_mr = std::make_unique<rmm::mr::pinned_host_memory_resource>(); }
-    *ptr = pinned_mr->allocate(bytes);
+    *ptr = pinned_mr->allocate_sync(bytes);
   });
 }
 
 extern "C" cuvsError_t cuvsRMMHostFree(void* ptr, size_t bytes)
 {
-  return cuvs::core::translate_exceptions([=] { pinned_mr->deallocate(ptr, bytes); });
+  return cuvs::core::translate_exceptions([=] { pinned_mr->deallocate_sync(ptr, bytes); });
 }
 
 thread_local std::string last_error_text = "";
diff --git a/conda/environments/bench_ann_cuda-129_arch-aarch64.yaml b/conda/environments/bench_ann_cuda-129_arch-aarch64.yaml
@@ -5,7 +5,6 @@ channels:
 - rapidsai-nightly
 - conda-forge
 dependencies:
-- benchmark>=1.8.2
 - c-compiler
 - clang-tools==20.1.4
 - clang==20.1.4
diff --git a/conda/environments/bench_ann_cuda-129_arch-x86_64.yaml b/conda/environments/bench_ann_cuda-129_arch-x86_64.yaml
@@ -5,7 +5,6 @@ channels:
 - rapidsai-nightly
 - conda-forge
 dependencies:
-- benchmark>=1.8.2
 - c-compiler
 - clang-tools==20.1.4
 - clang==20.1.4
diff --git a/conda/environments/bench_ann_cuda-130_arch-aarch64.yaml b/conda/environments/bench_ann_cuda-130_arch-aarch64.yaml
@@ -5,7 +5,6 @@ channels:
 - rapidsai-nightly
 - conda-forge
 dependencies:
-- benchmark>=1.8.2
 - c-compiler
 - clang-tools==20.1.4
 - clang==20.1.4
diff --git a/conda/environments/bench_ann_cuda-130_arch-x86_64.yaml b/conda/environments/bench_ann_cuda-130_arch-x86_64.yaml
@@ -5,7 +5,6 @@ channels:
 - rapidsai-nightly
 - conda-forge
 dependencies:
-- benchmark>=1.8.2
 - c-compiler
 - clang-tools==20.1.4
 - clang==20.1.4
diff --git a/conda/recipes/cuvs-bench-cpu/recipe.yaml b/conda/recipes/cuvs-bench-cpu/recipe.yaml
@@ -58,7 +58,6 @@ requirements:
     - ninja
     - ${{ stdlib("c") }}
   host:
-    - benchmark
     - glog ${{ glog_version }}
     - nlohmann_json ${{ nlohmann_json_version }}
     - openblas
@@ -72,7 +71,6 @@ requirements:
         - libboost-devel=1.87
         - mkl-devel=2023
   run:
-    - benchmark
     - click
     - glog ${{ glog_version }}
     - h5py ${{ h5py_version }}
@@ -89,7 +87,6 @@ requirements:
   ignore_run_exports:
     by_name:
       - glog
-      - libaio
       - libboost
       - libcublas
       - mkl  # relaxes pin from host `mkl-devel`
diff --git a/conda/recipes/cuvs-bench/recipe.yaml b/conda/recipes/cuvs-bench/recipe.yaml
@@ -38,14 +38,10 @@ requirements:
     - setuptools >=64.0.0
   run:
     - ${{ pin_compatible("cuda-version", upper_bound="x", lower_bound="x") }}
-    - benchmark
     - click
-    - cuda-cudart
     - cupy >=13.6.0
     - cuvs =${{ version }}
-    - glog ${{ glog_version }}
     - h5py ${{ h5py_version }}
-    - libcublas
     - libcuvs-bench-ann =${{ version }}
     - matplotlib-base>=3.9
     - pandas
@@ -56,17 +52,9 @@ requirements:
     # rmm is needed to determine if package is gpu-enabled
     - rmm =${{ minor_version }}
     - scikit-learn>=1.5
-    - if: linux64
-      then: mkl =2023
   ignore_run_exports:
     by_name:
       - cuda-version
-      - cuda-cudart
-      - glog
-      - libaio
-      - libboost
-      - libcublas
-      - mkl
 
 tests:
   - package_contents:
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
@@ -493,7 +493,6 @@ if(NOT BUILD_CPU_ONLY)
     src/neighbors/nn_descent_index.cpp
     src/neighbors/nn_descent_int8.cu
     src/neighbors/nn_descent_uint8.cu
-    src/neighbors/reachability.cu
     src/neighbors/refine/detail/refine_device_float_float.cu
     src/neighbors/refine/detail/refine_device_half_float.cu
     src/neighbors/refine/detail/refine_device_int8_t_float.cu
diff --git a/cpp/cmake/thirdparty/get_nlohmann_json.cmake b/cpp/cmake/thirdparty/get_nlohmann_json.cmake
@@ -18,10 +18,10 @@ function(find_and_configure_nlohmann_json)
             EXCLUDE_FROM_ALL       ${PKG_EXCLUDE_FROM_ALL}
             )
 
-    if(glog_ADDED)
-        message(VERBOSE "cuVS: Using glog located in ${glog_SOURCE_DIR}")
+    if(nlohmann_json_ADDED)
+        message(VERBOSE "cuVS: Using nlohmann_json located in ${nlohmann_json_SOURCE_DIR}")
     else()
-        message(VERBOSE "cuVS: Using glog located in ${glog_DIR}")
+        message(VERBOSE "cuVS: Using nlohmann_json located in ${nlohmann_json_DIR}")
     endif()
 
 endfunction()
diff --git a/cpp/include/cuvs/neighbors/reachability.hpp b/cpp/include/cuvs/neighbors/reachability.hpp
diff --git a/cpp/src/neighbors/detail/cagra/search_plan.cuh b/cpp/src/neighbors/detail/cagra/search_plan.cuh
@@ -64,13 +64,13 @@ struct lightweight_uvector {
     auto& [r, s] = std::get<rmm_res_type>(res_);
     T* new_ptr   = nullptr;
     if (new_size > 0) {
-      new_ptr = reinterpret_cast<T*>(r.allocate_async(new_size * sizeof(T), kAlign, s));
+      new_ptr = reinterpret_cast<T*>(r.allocate(s, new_size * sizeof(T), kAlign));
     }
     auto copy_size = std::min(size_, new_size);
     if (copy_size > 0) {
       cudaMemcpyAsync(new_ptr, ptr_, copy_size * sizeof(T), cudaMemcpyDefault, s);
     }
-    if (size_ > 0) { r.deallocate_async(ptr_, size_ * sizeof(T), kAlign, s); }
+    if (size_ > 0) { r.deallocate(s, ptr_, size_ * sizeof(T), kAlign); }
     ptr_  = new_ptr;
     size_ = new_size;
   }
@@ -91,7 +91,7 @@ struct lightweight_uvector {
   {
     if (size_ > 0) {
       auto& [r, s] = std::get<rmm_res_type>(res_);
-      r.deallocate_async(ptr_, size_ * sizeof(T), kAlign, s);
+      r.deallocate(s, ptr_, size_ * sizeof(T), kAlign);
     }
   }
 };
diff --git a/cpp/src/neighbors/detail/knn_graph.cuh b/cpp/src/neighbors/detail/knn_graph.cuh
@@ -4,11 +4,13 @@
  */
 
 #pragma once
-#include "knn_brute_force.cuh"
 #include <cuvs/distance/distance.hpp>
+#include <cuvs/neighbors/all_neighbors.hpp>
 
+#include <raft/core/operators.hpp>
 #include <raft/core/resource/cuda_stream.hpp>
 #include <raft/linalg/map.cuh>
+#include <raft/linalg/unary_op.cuh>
 #include <raft/sparse/coo.hpp>
 #include <raft/sparse/linalg/symmetrize.cuh>
 #include <raft/util/cuda_dev_essentials.cuh>
@@ -65,25 +67,31 @@ void knn_graph(raft::resources const& res,
 
   raft::linalg::map_offset(res, rows_view, [k] __device__(nnz_t i) { return value_idx(i / k); });
 
-  std::vector<value_t*> inputs;
-  inputs.push_back(const_cast<value_t*>(X.data_handle()));
-
-  std::vector<size_t> sizes;
-  sizes.push_back(m);
-
-  brute_force_knn_impl<size_t, value_idx, value_t, value_t>(res,
-                                                            inputs,
-                                                            sizes,
-                                                            n,
-                                                            const_cast<value_t*>(X.data_handle()),
-                                                            m,
-                                                            indices.data(),
-                                                            data.data(),
-                                                            k,
-                                                            true,
-                                                            true,
-                                                            nullptr,
-                                                            metric);
+  cuvs::neighbors::all_neighbors::all_neighbors_params params;
+  params.metric = metric;
+
+  cuvs::neighbors::graph_build_params::brute_force_params bf_params;
+  bf_params.build_params.metric = metric;
+  params.graph_build_params     = bf_params;
+
+  params.n_clusters     = 1;
+  params.overlap_factor = 1;
+
+  rmm::device_uvector<int64_t> indices_64(nnz, stream);
+  auto indices_64_view = raft::make_device_matrix_view<int64_t, int64_t>(indices_64.data(), m, k);
+  auto distances_view  = raft::make_device_matrix_view<value_t, int64_t>(data.data(), m, k);
+
+  cuvs::neighbors::all_neighbors::build(
+    res,
+    params,
+    raft::make_device_matrix_view<const value_t, int64_t>(X.data_handle(), m, n),
+    indices_64_view,
+    distances_view);
+
+  raft::linalg::unary_op(res,
+                         raft::make_const_mdspan(indices_64_view),
+                         raft::make_device_vector_view<value_idx, nnz_t>(indices.data(), nnz),
+                         raft::cast_op<value_idx>{});
 
   raft::sparse::linalg::symmetrize(res,
                                    rows.data(),
diff --git a/cpp/src/neighbors/reachability.cu b/cpp/src/neighbors/reachability.cu
diff --git a/dependencies.yaml b/dependencies.yaml
@@ -452,7 +452,6 @@ dependencies:
           - nlohmann_json>=3.12.0
           - glog>=0.6.0
           - h5py>=3.8.0
-          - benchmark>=1.8.2
           - openblas
     specific:
       - output_types: conda

Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ extern "C" cuvsError_t cuvsRMMAlloc(cuvsResources_t res, void** ptr, size_t byte`
`124`	`124`	`return cuvs::core::translate_exceptions([=] {`
`125`	`125`	`auto res_ptr = reinterpret_cast<raft::resources*>(res);`
`126`	`126`	`auto mr = rmm::mr::get_current_device_resource();`
`127`		`- ptr = mr->allocate(bytes, raft::resource::get_cuda_stream(res_ptr));`
	`127`	`+ ptr = mr->allocate(raft::resource::get_cuda_stream(res_ptr), bytes);`
`128`	`128`	`});`
`129`	`129`	`}`
`130`	`130`
`@@ -133,7 +133,7 @@ extern "C" cuvsError_t cuvsRMMFree(cuvsResources_t res, void* ptr, size_t bytes)`
`133`	`133`	`return cuvs::core::translate_exceptions([=] {`
`134`	`134`	`auto res_ptr = reinterpret_cast<raft::resources*>(res);`
`135`	`135`	`auto mr = rmm::mr::get_current_device_resource();`
`136`		`- mr->deallocate(ptr, bytes, raft::resource::get_cuda_stream(*res_ptr));`
	`136`	`+ mr->deallocate(raft::resource::get_cuda_stream(*res_ptr), ptr, bytes);`
`137`	`137`	`});`
`138`	`138`	`}`
`139`	`139`
`@@ -187,13 +187,13 @@ extern "C" cuvsError_t cuvsRMMHostAlloc(void** ptr, size_t bytes)`
`187`	`187`	`{`
`188`	`188`	`return cuvs::core::translate_exceptions([=] {`
`189`	`189`	`if (pinned_mr == nullptr) { pinned_mr = std::make_unique<rmm::mr::pinned_host_memory_resource>(); }`
`190`		`- *ptr = pinned_mr->allocate(bytes);`
	`190`	`+ *ptr = pinned_mr->allocate_sync(bytes);`
`191`	`191`	`});`
`192`	`192`	`}`
`193`	`193`
`194`	`194`	`extern "C" cuvsError_t cuvsRMMHostFree(void* ptr, size_t bytes)`
`195`	`195`	`{`
`196`		`- return cuvs::core::translate_exceptions([=] { pinned_mr->deallocate(ptr, bytes); });`
	`196`	`+ return cuvs::core::translate_exceptions([=] { pinned_mr->deallocate_sync(ptr, bytes); });`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`thread_local std::string last_error_text = "";`