Migrate RMM usage to CCCL MR design

conda/environments/all_cuda-129_arch-aarch64.yaml

@@ -11,6 +11,7 @@ dependencies:
 - certifi
 - cmake>=3.30.4
 - cuda-nvcc
+- cuda-nvrtc-dev
 - cuda-nvtx-dev
 - cuda-profiler-api
 - cuda-python>=12.9.2,<13.0

conda/environments/all_cuda-129_arch-x86_64.yaml

@@ -11,6 +11,7 @@ dependencies:
 - certifi
 - cmake>=3.30.4
 - cuda-nvcc
+- cuda-nvrtc-dev
 - cuda-nvtx-dev
 - cuda-profiler-api
 - cuda-python>=12.9.2,<13.0

conda/environments/all_cuda-131_arch-aarch64.yaml

@@ -11,6 +11,7 @@ dependencies:
 - certifi
 - cmake>=3.30.4
 - cuda-nvcc
+- cuda-nvrtc-dev
 - cuda-nvtx-dev
 - cuda-profiler-api
 - cuda-python>=13.0.1,<14.0

conda/environments/all_cuda-131_arch-x86_64.yaml

@@ -11,6 +11,7 @@ dependencies:
 - certifi
 - cmake>=3.30.4
 - cuda-nvcc
+- cuda-nvrtc-dev
 - cuda-nvtx-dev
 - cuda-profiler-api
 - cuda-python>=13.0.1,<14.0

conda/recipes/libcugraph/recipe.yaml

@@ -79,6 +79,8 @@ cache:
       - nccl ${{ nccl_version }}
       - openmpi <5.0.3 # Required for building cpp-mgtests (multi-GPU tests)
       - rapids-build-backend >=0.4.0,<0.5.0
+      - cuda-cudart-dev
+      - cuda-nvrtc-dev
       - cuda-nvtx-dev
       - cuda-profiler-api
       - libcublas-dev
@@ -111,6 +113,8 @@ outputs:
         - cuda-version =${{ cuda_version }}
         - librmm =${{ minor_version }}
         - rapids-logger =0.2
+        - cuda-cudart-dev
+        - cuda-nvrtc-dev
         - libcublas-dev
         - libcurand-dev
         - libcusolver-dev
@@ -120,13 +124,17 @@ outputs:
         - libraft =${{ minor_version }}
         - librmm =${{ minor_version }}
         - nccl ${{ nccl_version }}
+        - cuda-cudart
+        - cuda-nvrtc
         - cuda-profiler-api
         - libcublas
         - libcurand
         - libcusolver
         - libcusparse
       ignore_run_exports:
         by_name:
+          - cuda-cudart
+          - cuda-nvrtc
           - cuda-nvtx
           - cuda-version
           - libcublas
@@ -166,13 +174,19 @@ outputs:
         - cuda-version =${{ cuda_version }}
         - libcudf =${{ minor_version }}
         - librmm =${{ minor_version }}
+        - cuda-cudart-dev
+        - cuda-nvrtc-dev
       run:
         - ${{ pin_compatible("cuda-version", upper_bound="x", lower_bound="x") }}
         - ${{ pin_subpackage("libcugraph", exact=True) }}
         - libcudf =${{ minor_version }}
         - librmm =${{ minor_version }}
+        - cuda-cudart
+        - cuda-nvrtc
       ignore_run_exports:
         by_name:
+          - cuda-cudart
+          - cuda-nvrtc
           - cuda-nvtx
           - cuda-version
           - libcublas
@@ -209,15 +223,21 @@ outputs:
       host:
         - ${{ pin_subpackage("libcugraph", exact=True) }}
         - cuda-version =${{ cuda_version }}
+        - cuda-cudart-dev
+        - cuda-nvrtc-dev
         - nccl ${{ nccl_version }}
         - openmpi <5.0.3 # Required for building cpp-mgtests (multi-GPU tests)
         - rapids-logger =0.2
       run:
         - ${{ pin_compatible("cuda-version", upper_bound="x", lower_bound="x") }}
         - ${{ pin_subpackage("libcugraph", exact=True) }}
         - ${{ pin_subpackage("libcugraph_etl", exact=True) }}
+        - cuda-cudart
+        - cuda-nvrtc
       ignore_run_exports:
         by_name:
+          - cuda-cudart
+          - cuda-nvrtc
           - cuda-nvtx
           - cuda-version
           - libcublas

cpp/CMakeLists.txt

@@ -60,7 +60,7 @@ message(VERBOSE "CUGRAPH: CUGRAPH_USE_CUVS_STATIC=${CUGRAPH_USE_CUVS_STATIC}")
 set(CMAKE_CXX_SCAN_FOR_MODULES OFF)
 
 # CUDA runtime
-rapids_cuda_init_runtime(USE_STATIC ON)
+rapids_cuda_init_runtime(USE_STATIC OFF)
 
 rapids_find_package(CUDAToolkit REQUIRED
     BUILD_EXPORT_SET    cugraph-exports
@@ -471,6 +471,9 @@ SECTIONS
 }
 ]=])
 
+set_property(TARGET cugraph PROPERTY NO_CUDART_DEP ON)
+set_property(TARGET cugraph_mg PROPERTY NO_CUDART_DEP ON)
+
 set(cugraph_suffixes "" "_mg")
 foreach(suffix IN LISTS cugraph_suffixes)
     set_target_properties(cugraph${suffix}
@@ -511,13 +514,14 @@ foreach(suffix IN LISTS cugraph_suffixes)
     # - link libraries -------------------------------------------------------------
     target_link_libraries(cugraph${suffix}
         PUBLIC
-            rmm::rmm
             raft::raft
             $<BUILD_LOCAL_INTERFACE:CUDA::toolkit>
         PRIVATE
             ${COMPILED_RAFT_LIB}
             $<IF:$<BOOL:${CUGRAPH_USE_CUVS_STATIC}>,cuvs::cuvs_static,cuvs::cuvs> #
             cuco::cuco
+            rmm::rmm
+        INTERFACE $<COMPILE_ONLY:rmm::rmm>
     )
 
     ################################################################################

cpp/examples/developers/graph_operations/graph_operations.cu

@@ -40,12 +40,11 @@ std::unique_ptr<raft::handle_t> initialize_mg_handle()
   int comm_rank{};
   RAFT_MPI_TRY(MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank));
 
-  std::shared_ptr<rmm::mr::device_memory_resource> resource =
-    std::make_shared<rmm::mr::cuda_memory_resource>();
-  rmm::mr::set_current_device_resource(resource.get());
+  auto resource = rmm::mr::cuda_memory_resource();
+  rmm::mr::set_current_device_resource(resource);
 
   std::unique_ptr<raft::handle_t> handle =
-    std::make_unique<raft::handle_t>(rmm::cuda_stream_per_thread, resource);
+    std::make_unique<raft::handle_t>(rmm::cuda_stream_per_thread, nullptr, resource);
 
   raft::comms::initialize_mpi_comms(handle.get(), MPI_COMM_WORLD);
   auto& comm           = handle->get_comms();

cpp/examples/developers/vertex_and_edge_partition/vertex_and_edge_partition.cu

@@ -37,12 +37,11 @@ std::unique_ptr<raft::handle_t> initialize_mg_handle()
   int comm_rank{};
   RAFT_MPI_TRY(MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank));
 
-  std::shared_ptr<rmm::mr::device_memory_resource> resource =
-    std::make_shared<rmm::mr::cuda_memory_resource>();
-  rmm::mr::set_current_device_resource(resource.get());
+  auto resource = rmm::mr::cuda_memory_resource();
+  rmm::mr::set_current_device_resource(resource);
 
   std::unique_ptr<raft::handle_t> handle =
-    std::make_unique<raft::handle_t>(rmm::cuda_stream_per_thread, resource);
+    std::make_unique<raft::handle_t>(rmm::cuda_stream_per_thread, nullptr, resource);
 
   raft::comms::initialize_mpi_comms(handle.get(), MPI_COMM_WORLD);
   auto& comm           = handle->get_comms();

cpp/examples/users/multi_gpu_application/mg_graph_algorithms.cpp

@@ -32,12 +32,11 @@ std::unique_ptr<raft::handle_t> initialize_mg_handle()
   int comm_rank{};
   RAFT_MPI_TRY(MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank));
 
-  std::shared_ptr<rmm::mr::device_memory_resource> resource =
-    std::make_shared<rmm::mr::cuda_memory_resource>();
-  rmm::mr::set_current_device_resource(resource.get());
+  auto resource = rmm::mr::cuda_memory_resource();
+  rmm::mr::set_current_device_resource(resource);
 
   std::unique_ptr<raft::handle_t> handle =
-    std::make_unique<raft::handle_t>(rmm::cuda_stream_per_thread, resource);
+    std::make_unique<raft::handle_t>(rmm::cuda_stream_per_thread, nullptr, resource);
 
   raft::comms::initialize_mpi_comms(handle.get(), MPI_COMM_WORLD);
   auto& comm           = handle->get_comms();

cpp/examples/users/single_gpu_application/sg_graph_algorithms.cpp

@@ -15,12 +15,11 @@
 std::unique_ptr<raft::handle_t> initialize_sg_handle()
 {
   RAFT_CUDA_TRY(cudaSetDevice(0));
-  std::shared_ptr<rmm::mr::device_memory_resource> resource =
-    std::make_shared<rmm::mr::cuda_memory_resource>();
-  rmm::mr::set_current_device_resource(resource.get());
+  auto resource = rmm::mr::cuda_memory_resource();
+  rmm::mr::set_current_device_resource(resource);
 
   std::unique_ptr<raft::handle_t> handle =
-    std::make_unique<raft::handle_t>(rmm::cuda_stream_per_thread, resource);
+    std::make_unique<raft::handle_t>(rmm::cuda_stream_per_thread, nullptr, resource);
   return std::move(handle);
 }
 

cpp/include/cugraph/algorithms.hpp

@@ -801,7 +801,7 @@ template <typename vertex_t, typename edge_t, typename weight_t>
 std::unique_ptr<legacy::GraphCOO<vertex_t, edge_t, weight_t>> minimum_spanning_tree(
   raft::handle_t const& handle,
   legacy::GraphCSRView<vertex_t, edge_t, weight_t> const& graph,
-  rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource());
+  rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource_ref());
 
 namespace subgraph {
 /**

cpp/include/cugraph/dendrogram.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2024, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 #pragma once
@@ -18,7 +18,7 @@ class Dendrogram {
   void add_level(vertex_t first_index,
                  vertex_t num_verts,
                  rmm::cuda_stream_view stream_view,
-                 rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource())
+                 rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource_ref())
   {
     level_ptr_.push_back(
       std::make_unique<rmm::device_uvector<vertex_t>>(num_verts, stream_view, mr));

cpp/include/cugraph/host_staging_buffer_manager.hpp

@@ -10,12 +10,10 @@
 
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/device_uvector.hpp>
-#include <rmm/mr/owning_wrapper.hpp>
 #include <rmm/mr/pinned_host_memory_resource.hpp>
 #include <rmm/mr/pool_memory_resource.hpp>
 
 #include <cstddef>
-#include <memory>
 #include <optional>
 
 namespace cugraph {
@@ -32,14 +30,12 @@ class host_staging_buffer_manager {
     return s.initialized;
   }
 
-  static void init(raft::handle_t const& handle,
-                   std::shared_ptr<rmm::mr::pinned_host_memory_resource> pinned_mr)
+  static void init(raft::handle_t const& handle, rmm::mr::pinned_host_memory_resource pinned_mr)
   {
     auto& s = state();
     CUGRAPH_EXPECTS(s.initialized == false, "host_staging_buffer_manager is already initialized.");
-    s.initialized    = true;
-    s.pinned_pool_mr = rmm::mr::make_owning_wrapper<rmm::mr::pool_memory_resource>(
-      std::move(pinned_mr), init_staging_buffer_size, max_staging_buffer_size);
+    s.initialized = true;
+    s.pinned_pool_mr.emplace(pinned_mr, init_staging_buffer_size, max_staging_buffer_size);
   }
 
   static void clear()
@@ -53,16 +49,13 @@ class host_staging_buffer_manager {
   static rmm::device_uvector<T> allocate_staging_buffer(size_t size, rmm::cuda_stream_view stream)
   {
     auto& s = state();
-    return rmm::device_uvector<T>(size, stream, s.pinned_pool_mr.get());
+    return rmm::device_uvector<T>(size, stream, *s.pinned_pool_mr);
   }
 
  private:
   struct state_t {
     bool initialized = false;
-    std::shared_ptr<
-      rmm::mr::owning_wrapper<rmm::mr::pool_memory_resource<rmm::mr::pinned_host_memory_resource>,
-                              rmm::mr::pinned_host_memory_resource>>
-      pinned_pool_mr{};
+    std::optional<rmm::mr::pool_memory_resource> pinned_pool_mr{};
   };
 
   static state_t& state()

cpp/include/cugraph/large_buffer_manager.hpp

@@ -12,8 +12,8 @@
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/device_uvector.hpp>
 #include <rmm/mr/pinned_host_memory_resource.hpp>
+#include <rmm/resource_ref.hpp>
 
-#include <memory>
 #include <optional>
 
 namespace cugraph {
@@ -23,17 +23,15 @@ namespace detail {
 class large_memory_buffer_resource_t {
  public:
   large_memory_buffer_resource_t() = delete;
-  large_memory_buffer_resource_t(std::shared_ptr<rmm::mr::pinned_host_memory_resource> mr) : mr_(mr)
-  {
-  }
+  large_memory_buffer_resource_t(rmm::mr::pinned_host_memory_resource mr) : mr_(std::move(mr)) {}
 
-  rmm::mr::pinned_host_memory_resource* get() const { return mr_.get(); }
+  rmm::device_async_resource_ref get() { return mr_; }
 
  private:
-  std::shared_ptr<rmm::mr::pinned_host_memory_resource>
+  rmm::mr::pinned_host_memory_resource
     mr_{};  // currently, large memory buffer is backed by CUDA (rmm) pinned host memory, in the
             // future, we may support different memory resources, in that case, we may update mr_ to
-            // a std::shared_ptr of a std::variant type, and add additional constructors taking
+            // a std::variant type, and add additional constructors taking
             // different memory resources.
 };
 
@@ -91,7 +89,7 @@ class large_buffer_manager {
   }
 
   static detail::large_memory_buffer_resource_t create_memory_buffer_resource(
-    std::shared_ptr<rmm::mr::pinned_host_memory_resource> mr)
+    rmm::mr::pinned_host_memory_resource mr)
   {
     return detail::large_memory_buffer_resource_t(std::move(mr));
   }

cpp/include/cugraph/legacy/functions.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2020-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 #pragma once
@@ -40,7 +40,7 @@ namespace cugraph {
 template <typename VT, typename ET, typename WT>
 std::unique_ptr<legacy::GraphCSR<VT, ET, WT>> coo_to_csr(
   legacy::GraphCOOView<VT, ET, WT> const& graph,
-  rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource());
+  rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource_ref());
 
 /**
  * @brief    Broadcast using handle communicator

cpp/include/cugraph/legacy/graph.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2020-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 #pragma once
@@ -358,7 +358,7 @@ class GraphCOO {
            edge_t number_of_edges,
            bool has_data                     = false,
            cudaStream_t stream               = nullptr,
-           rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource())
+           rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource_ref())
     : number_of_vertices_p(number_of_vertices),
       number_of_edges_p(number_of_edges),
       src_indices_p(sizeof(vertex_t) * number_of_edges, stream, mr),
@@ -369,7 +369,7 @@ class GraphCOO {
 
   GraphCOO(GraphCOOView<vertex_t, edge_t, weight_t> const& graph,
            cudaStream_t stream               = nullptr,
-           rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource())
+           rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource_ref())
     : number_of_vertices_p(graph.number_of_vertices),
       number_of_edges_p(graph.number_of_edges),
       src_indices_p(graph.src_indices, graph.number_of_edges * sizeof(vertex_t), stream, mr),
@@ -540,7 +540,7 @@ class GraphCSR : public GraphCompressedSparseBase<vertex_t, edge_t, weight_t> {
            edge_t number_of_edges_,
            bool has_data_                    = false,
            cudaStream_t stream               = nullptr,
-           rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource())
+           rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource_ref())
     : GraphCompressedSparseBase<vertex_t, edge_t, weight_t>(
         number_of_vertices_, number_of_edges_, has_data_, stream, mr)
   {