diff --git a/cpp/benchmarks/async_priming/async_priming_bench.cpp b/cpp/benchmarks/async_priming/async_priming_bench.cpp
index fe641b004..1b5204bcd 100644
--- a/cpp/benchmarks/async_priming/async_priming_bench.cpp
+++ b/cpp/benchmarks/async_priming/async_priming_bench.cpp
@@ -1,11 +1,10 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
 #include <rmm/cuda_device.hpp>
 #include <rmm/mr/cuda_async_memory_resource.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
 #include <benchmark/benchmark.h>
 #include <benchmarks/utilities/cxxopts.hpp>
diff --git a/cpp/benchmarks/multi_stream_allocations/multi_stream_allocations_bench.cu b/cpp/benchmarks/multi_stream_allocations/multi_stream_allocations_bench.cu
index d34a55d71..3687a3081 100644
--- a/cpp/benchmarks/multi_stream_allocations/multi_stream_allocations_bench.cu
+++ b/cpp/benchmarks/multi_stream_allocations/multi_stream_allocations_bench.cu
@@ -37,7 +37,8 @@ __global__ void compute_bound_kernel(int64_t* out)
   *out = static_cast<int64_t>(clock_current);
 }
 
-using MRFactoryFunc = std::function<std::shared_ptr<rmm::mr::device_memory_resource>()>;
+using any_device_resource = cuda::mr::any_resource<cuda::mr::device_accessible>;
+using MRFactoryFunc       = std::function<any_device_resource()>;
 
 static void run_prewarm(rmm::cuda_stream_pool& stream_pool, rmm::device_async_resource_ref mr)
 {
@@ -63,7 +64,7 @@ static void BM_MultiStreamAllocations(benchmark::State& state, MRFactoryFunc con
 {
   auto mr = factory();
 
-  rmm::mr::set_current_device_resource_ref(mr.get());
+  rmm::mr::set_current_device_resource_ref(mr);
 
   auto num_streams = state.range(0);
   auto num_kernels = state.range(1);
@@ -71,10 +72,10 @@ static void BM_MultiStreamAllocations(benchmark::State& state, MRFactoryFunc con
 
   auto stream_pool = rmm::cuda_stream_pool(static_cast<std::size_t>(num_streams));
 
-  if (do_prewarm) { run_prewarm(stream_pool, mr.get()); }
+  if (do_prewarm) { run_prewarm(stream_pool, mr); }
 
   for (auto _ : state) {  // NOLINT(clang-analyzer-deadcode.DeadStores)
-    run_test(static_cast<std::size_t>(num_kernels), stream_pool, mr.get());
+    run_test(static_cast<std::size_t>(num_kernels), stream_pool, mr);
     cudaDeviceSynchronize();
   }
 
@@ -83,31 +84,29 @@ static void BM_MultiStreamAllocations(benchmark::State& state, MRFactoryFunc con
   rmm::mr::reset_current_device_resource_ref();
 }
 
-inline auto make_cuda() { return std::make_shared<rmm::mr::cuda_memory_resource>(); }
+inline any_device_resource make_cuda() { return rmm::mr::cuda_memory_resource{}; }
 
-inline auto make_cuda_async() { return std::make_shared<rmm::mr::cuda_async_memory_resource>(); }
+inline any_device_resource make_cuda_async() { return rmm::mr::cuda_async_memory_resource{}; }
 
-inline auto make_pool()
+inline any_device_resource make_pool()
 {
-  return std::make_shared<rmm::mr::pool_memory_resource>(*make_cuda(),
-                                                         rmm::percent_of_free_device_memory(50));
+  rmm::mr::cuda_memory_resource cuda{};
+  return rmm::mr::pool_memory_resource{cuda, rmm::percent_of_free_device_memory(50)};
 }
 
-inline auto make_arena()
+inline any_device_resource make_arena()
 {
-  return std::make_shared<rmm::mr::arena_memory_resource>(
-    rmm::mr::get_current_device_resource_ref());
+  return rmm::mr::arena_memory_resource{rmm::mr::get_current_device_resource_ref()};
 }
 
-inline auto make_binning()
+inline any_device_resource make_binning()
 {
   // Add a binning_memory_resource with fixed-size bins of sizes 256, 512, 1024, 2048 and 4096KiB
   // Larger allocations will use the pool resource
   constexpr auto min_bin_pow2{18};
   constexpr auto max_bin_pow2{22};
-  auto mr =
-    std::make_shared<rmm::mr::binning_memory_resource>(*make_pool(), min_bin_pow2, max_bin_pow2);
-  return mr;
+  auto pool = make_pool();
+  return rmm::mr::binning_memory_resource{pool, min_bin_pow2, max_bin_pow2};
 }
 
 static void benchmark_range(benchmark::internal::Benchmark* bench)
@@ -171,9 +170,9 @@ void run_profile(std::string const& resource_name, int kernel_count, int stream_
   auto mr          = mr_factory();
   auto stream_pool = rmm::cuda_stream_pool(static_cast<std::size_t>(stream_count));
 
-  if (prewarm) { run_prewarm(stream_pool, mr.get()); }
+  if (prewarm) { run_prewarm(stream_pool, mr); }
 
-  run_test(static_cast<std::size_t>(kernel_count), stream_pool, mr.get());
+  run_test(static_cast<std::size_t>(kernel_count), stream_pool, mr);
 }
 
 int main(int argc, char** argv)
@@ -193,7 +192,7 @@ int main(int argc, char** argv)
 
     options.add_options()(  //
       "r,resource",
-      "Type of device_memory_resource",
+      "Type of memory resource",
       cxxopts::value<std::string>()->default_value("pool"));
 
     options.add_options()(  //
diff --git a/cpp/benchmarks/random_allocations/random_allocations.cpp b/cpp/benchmarks/random_allocations/random_allocations.cpp
index db6b394e9..5ab201cab 100644
--- a/cpp/benchmarks/random_allocations/random_allocations.cpp
+++ b/cpp/benchmarks/random_allocations/random_allocations.cpp
@@ -8,9 +8,9 @@
 #include <rmm/mr/binning_memory_resource.hpp>
 #include <rmm/mr/cuda_async_memory_resource.hpp>
 #include <rmm/mr/cuda_memory_resource.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/mr/per_device_resource.hpp>
 #include <rmm/mr/pool_memory_resource.hpp>
+#include <rmm/resource_ref.hpp>
 
 #include <benchmark/benchmark.h>
 #include <benchmarks/utilities/cxxopts.hpp>
@@ -49,7 +49,7 @@ allocation remove_at(allocation_vector& allocs, std::size_t index)
 }
 
 template <typename SizeDistribution>
-void random_allocation_free(rmm::mr::device_memory_resource& mr,
+void random_allocation_free(rmm::device_async_resource_ref mr,
                             SizeDistribution size_distribution,
                             std::size_t num_allocations,
                             std::size_t max_usage,  // in MiB
@@ -127,7 +127,7 @@ void random_allocation_free(rmm::mr::device_memory_resource& mr,
 }  // namespace
 
 void uniform_random_allocations(
-  rmm::mr::device_memory_resource& mr,
+  rmm::device_async_resource_ref mr,
   std::size_t num_allocations,      // NOLINT(bugprone-easily-swappable-parameters)
   std::size_t max_allocation_size,  // size in MiB
   std::size_t max_usage,
@@ -138,7 +138,7 @@ void uniform_random_allocations(
 }
 
 // TODO figure out how to map a normal distribution to integers between 1 and max_allocation_size
-/*void normal_random_allocations(rmm::mr::device_memory_resource& mr,
+/*void normal_random_allocations(rmm::device_async_resource_ref mr,
                                 std::size_t num_allocations = 1000,
                                 std::size_t mean_allocation_size = 500, // in MiB
                                 std::size_t stddev_allocation_size = 500, // in MiB
@@ -148,36 +148,36 @@ void uniform_random_allocations(
 }*/
 
 /// MR factory functions
-inline auto make_cuda() { return std::make_shared<rmm::mr::cuda_memory_resource>(); }
+using any_device_resource = cuda::mr::any_resource<cuda::mr::device_accessible>;
 
-inline auto make_cuda_async() { return std::make_shared<rmm::mr::cuda_async_memory_resource>(); }
+inline any_device_resource make_cuda() { return rmm::mr::cuda_memory_resource{}; }
 
-inline auto make_pool()
+inline any_device_resource make_cuda_async() { return rmm::mr::cuda_async_memory_resource{}; }
+
+inline any_device_resource make_pool()
 {
-  return std::make_shared<rmm::mr::pool_memory_resource>(*make_cuda(),
-                                                         rmm::percent_of_free_device_memory(50));
+  rmm::mr::cuda_memory_resource cuda{};
+  return rmm::mr::pool_memory_resource{cuda, rmm::percent_of_free_device_memory(50)};
 }
 
-inline auto make_arena()
+inline any_device_resource make_arena()
 {
   auto free = rmm::available_device_memory().first;
   constexpr auto reserve{64UL << 20};  // Leave some space for CUDA overhead.
-  return std::make_shared<rmm::mr::arena_memory_resource>(
-    rmm::mr::get_current_device_resource_ref(), free - reserve);
+  return rmm::mr::arena_memory_resource{rmm::mr::get_current_device_resource_ref(), free - reserve};
 }
 
-inline auto make_binning()
+inline any_device_resource make_binning()
 {
   // Add a binning_memory_resource with fixed-size bins of sizes 256, 512, 1024, 2048 and 4096KiB
   // Larger allocations will use the pool resource
   constexpr auto min_bin_pow2{18};
   constexpr auto max_bin_pow2{22};
-  auto mr =
-    std::make_shared<rmm::mr::binning_memory_resource>(*make_pool(), min_bin_pow2, max_bin_pow2);
-  return mr;
+  auto pool = make_pool();
+  return rmm::mr::binning_memory_resource{pool, min_bin_pow2, max_bin_pow2};
 }
 
-using MRFactoryFunc = std::function<std::shared_ptr<rmm::mr::device_memory_resource>()>;
+using MRFactoryFunc = std::function<any_device_resource()>;
 
 constexpr std::size_t max_usage = 16000;
 
@@ -190,7 +190,7 @@ static void BM_RandomAllocations(benchmark::State& state, MRFactoryFunc const& f
 
   try {
     for (auto _ : state) {  // NOLINT(clang-analyzer-deadcode.DeadStores)
-      uniform_random_allocations(*mr, num_allocations, max_size, max_usage);
+      uniform_random_allocations(mr, num_allocations, max_size, max_usage);
     }
   } catch (std::exception const& e) {
     std::cout << "Error: " << e.what() << "\n";
@@ -243,8 +243,7 @@ void declare_benchmark(std::string const& name)
   if (name == "cuda") {
     BENCHMARK_CAPTURE(BM_RandomAllocations, cuda_mr, &make_cuda)  // NOLINT
       ->Apply(benchmark_range);
-  }
-  if (name == "cuda_async") {
+  } else if (name == "cuda_async") {
     BENCHMARK_CAPTURE(BM_RandomAllocations, cuda_async_mr, &make_cuda_async)  // NOLINT
       ->Apply(benchmark_range);
   } else if (name == "binning") {
@@ -268,7 +267,7 @@ static void profile_random_allocations(MRFactoryFunc const& factory,
   auto mr = factory();
 
   try {
-    uniform_random_allocations(*mr, num_allocations, max_size, max_usage);
+    uniform_random_allocations(mr, num_allocations, max_size, max_usage);
   } catch (std::exception const& e) {
     std::cout << "Error: " << e.what() << "\n";
   }
@@ -288,7 +287,7 @@ int main(int argc, char** argv)
     options.add_options()(
       "p,profile", "Profiling mode: run once", cxxopts::value<bool>()->default_value("false"));
     options.add_options()("r,resource",
-                          "Type of device_memory_resource",
+                          "Type of memory resource",
                           cxxopts::value<std::string>()->default_value("pool"));
     options.add_options()("n,numallocs",
                           "Number of allocations (default of 0 tests a range)",
diff --git a/cpp/benchmarks/replay/replay.cpp b/cpp/benchmarks/replay/replay.cpp
index 04e1833ee..b6e95ed6d 100644
--- a/cpp/benchmarks/replay/replay.cpp
+++ b/cpp/benchmarks/replay/replay.cpp
@@ -3,16 +3,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#include <rmm/aligned.hpp>
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/error.hpp>
 #include <rmm/logger.hpp>
 #include <rmm/mr/arena_memory_resource.hpp>
 #include <rmm/mr/binning_memory_resource.hpp>
 #include <rmm/mr/cuda_memory_resource.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/mr/managed_memory_resource.hpp>
 #include <rmm/mr/per_device_resource.hpp>
 #include <rmm/mr/pool_memory_resource.hpp>
+#include <rmm/resource_ref.hpp>
 
 #include <cuda/iterator>
 #include <thrust/execution_policy.h>
@@ -31,56 +32,49 @@
 #include <iterator>
 #include <memory>
 #include <numeric>
+#include <optional>
 #include <string>
 #include <thread>
 
-/// MR factory functions
-std::shared_ptr<rmm::mr::device_memory_resource> make_cuda(std::size_t = 0)
-{
-  return std::make_shared<rmm::mr::cuda_memory_resource>();
-}
+using any_device_resource = cuda::mr::any_resource<cuda::mr::device_accessible>;
 
-std::shared_ptr<rmm::mr::device_memory_resource> make_managed(std::size_t = 0)
-{
-  return std::make_shared<rmm::mr::managed_memory_resource>();
-}
+/// MR factory functions
+any_device_resource make_cuda(std::size_t = 0) { return rmm::mr::cuda_memory_resource{}; }
 
-std::shared_ptr<rmm::mr::device_memory_resource> make_simulated(std::size_t simulated_size)
-{
-  return std::make_shared<rmm::mr::simulated_memory_resource>(simulated_size);
-}
+any_device_resource make_managed(std::size_t = 0) { return rmm::mr::managed_memory_resource{}; }
 
-inline auto make_pool(std::size_t simulated_size)
+inline any_device_resource make_pool(std::size_t simulated_size)
 {
   if (simulated_size > 0) {
-    return std::make_shared<rmm::mr::pool_memory_resource>(
-      *make_simulated(simulated_size), simulated_size, simulated_size);
+    rmm::mr::simulated_memory_resource sim{simulated_size};
+    return rmm::mr::pool_memory_resource{sim, simulated_size, simulated_size};
   }
-  return std::make_shared<rmm::mr::pool_memory_resource>(*make_cuda(), 0);
+  rmm::mr::cuda_memory_resource cuda{};
+  return rmm::mr::pool_memory_resource{cuda, 0};
 }
 
-inline auto make_arena(std::size_t simulated_size)
+inline any_device_resource make_arena(std::size_t simulated_size)
 {
   if (simulated_size > 0) {
-    return std::make_shared<rmm::mr::arena_memory_resource>(
-      rmm::mr::get_current_device_resource_ref(), simulated_size);
+    return rmm::mr::arena_memory_resource{rmm::mr::get_current_device_resource_ref(),
+                                          simulated_size};
   }
-  return std::make_shared<rmm::mr::arena_memory_resource>(
-    rmm::mr::get_current_device_resource_ref());
+  return rmm::mr::arena_memory_resource{rmm::mr::get_current_device_resource_ref()};
 }
 
-inline auto make_binning(std::size_t simulated_size)
+inline any_device_resource make_binning(std::size_t simulated_size)
 {
-  auto mr = std::make_shared<rmm::mr::binning_memory_resource>(*make_pool(simulated_size));
+  auto pool = make_pool(simulated_size);
+  auto mr   = rmm::mr::binning_memory_resource{pool};
   const auto min_size_exp{18};
   const auto max_size_exp{22};
   for (std::size_t i = min_size_exp; i <= max_size_exp; i++) {
-    mr->add_bin(1 << i);
+    mr.add_bin(1 << i);
   }
   return mr;
 }
 
-using MRFactoryFunc = std::function<std::shared_ptr<rmm::mr::device_memory_resource>(std::size_t)>;
+using MRFactoryFunc = std::function<any_device_resource(std::size_t)>;
 
 /**
  * @brief Represents an allocation made during the replay
@@ -95,15 +89,15 @@ struct allocation {
 
 /**
  * @brief Function object for running a replay benchmark with the specified
- * `device_memory_resource`.
+ * memory resource.
  *
- * @tparam MR The type of the `device_memory_resource` to use for allocation
+ * @tparam MR The type of the memory resource to use for allocation
  * replay
  */
 struct replay_benchmark {
   MRFactoryFunc factory_;
   std::size_t simulated_size_;
-  std::shared_ptr<rmm::mr::device_memory_resource> mr_{};
+  std::optional<any_device_resource> mr_{};
   std::vector<std::vector<rmm::detail::event>> const& events_{};
 
   // Maps a pointer from the event log to an active allocation
@@ -173,7 +167,7 @@ struct replay_benchmark {
   {
     if (state.thread_index() == 0) {
       RMM_LOG_INFO("------ Start of Benchmark -----");
-      mr_ = factory_(simulated_size_);
+      mr_.emplace(factory_(simulated_size_));
     }
     // Can't release threads until MR is set up.
     barrier_.arrive_and_wait();
@@ -193,7 +187,7 @@ struct replay_benchmark {
         auto alloc = ptr_alloc.second;
         num_leaked++;
         total_leaked += alloc.size;
-        mr_->deallocate_sync(alloc.ptr, alloc.size);
+        mr_->deallocate_sync(alloc.ptr, alloc.size, rmm::CUDA_ALLOCATION_ALIGNMENT);
       }
       if (num_leaked > 0) {
         std::cout << "LOG shows leak of " << num_leaked << " allocations of " << total_leaked
@@ -225,11 +219,11 @@ struct replay_benchmark {
 
         // rmm::detail::action::ALLOCATE_FAILURE is ignored.
         if (rmm::detail::action::ALLOCATE == event.act) {
-          auto ptr = mr_->allocate_sync(event.size);
+          auto ptr = mr_->allocate_sync(event.size, rmm::CUDA_ALLOCATION_ALIGNMENT);
           set_allocation(event.pointer, allocation{ptr, event.size});
         } else if (rmm::detail::action::FREE == event.act) {
           auto alloc = remove_allocation(event.pointer);
-          mr_->deallocate_sync(alloc.ptr, event.size);
+          mr_->deallocate_sync(alloc.ptr, event.size, rmm::CUDA_ALLOCATION_ALIGNMENT);
         }
 
         event_index++;
@@ -355,7 +349,7 @@ int main(int argc, char** argv)
 
       options.add_options()("f,file", "Name of RMM log file.", cxxopts::value<std::string>());
       options.add_options()("r,resource",
-                            "Type of device_memory_resource",
+                            "Type of memory resource",
                             cxxopts::value<std::string>()->default_value("pool"));
       options.add_options()(
         "s,size",
diff --git a/cpp/benchmarks/utilities/log_parser.hpp b/cpp/benchmarks/utilities/log_parser.hpp
index 5114b7ea0..886c1f585 100644
--- a/cpp/benchmarks/utilities/log_parser.hpp
+++ b/cpp/benchmarks/utilities/log_parser.hpp
@@ -8,7 +8,6 @@
 #include "rapidcsv.h"
 
 #include <rmm/detail/error.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
 #include <chrono>
 #include <cstdint>
diff --git a/cpp/benchmarks/utilities/simulated_memory_resource.hpp b/cpp/benchmarks/utilities/simulated_memory_resource.hpp
index 1676924ba..ff5254b83 100644
--- a/cpp/benchmarks/utilities/simulated_memory_resource.hpp
+++ b/cpp/benchmarks/utilities/simulated_memory_resource.hpp
@@ -4,12 +4,17 @@
  */
 #pragma once
 
+#include <rmm/aligned.hpp>
 #include <rmm/detail/error.hpp>
+#include <rmm/detail/export.hpp>
 #include <rmm/detail/format.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
+#include <cuda/memory_resource>
+#include <cuda/stream_ref>
 #include <cuda_runtime_api.h>
 
+#include <cstddef>
+
 namespace rmm::mr {
 
 /**
@@ -20,7 +25,7 @@ namespace rmm::mr {
  *
  * Deallocation calls are ignored.
  */
-class simulated_memory_resource final : public device_memory_resource {
+class simulated_memory_resource final {
  public:
   /**
    * @brief Construct a `simulated_memory_resource`.
@@ -33,15 +38,13 @@ class simulated_memory_resource final : public device_memory_resource {
   {
   }
 
-  ~simulated_memory_resource() override = default;
+  ~simulated_memory_resource() = default;
 
-  // Disable copy (and move) semantics.
-  simulated_memory_resource(simulated_memory_resource const&)            = delete;
-  simulated_memory_resource& operator=(simulated_memory_resource const&) = delete;
-  simulated_memory_resource(simulated_memory_resource&&)                 = delete;
-  simulated_memory_resource& operator=(simulated_memory_resource&&)      = delete;
+  simulated_memory_resource(simulated_memory_resource const&)            = default;
+  simulated_memory_resource& operator=(simulated_memory_resource const&) = default;
+  simulated_memory_resource(simulated_memory_resource&&)                 = default;
+  simulated_memory_resource& operator=(simulated_memory_resource&&)      = default;
 
- private:
   /**
    * @brief Allocates memory of size at least `bytes`.
    *
@@ -52,7 +55,9 @@ class simulated_memory_resource final : public device_memory_resource {
    * @param bytes The size, in bytes, of the allocation
    * @return void* Pointer to the newly allocated memory
    */
-  void* do_allocate(std::size_t bytes, cuda_stream_view) override
+  void* allocate([[maybe_unused]] cuda::stream_ref stream,
+                 std::size_t bytes,
+                 [[maybe_unused]] std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT)
   {
     // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
     RMM_EXPECTS(begin_ + bytes <= end_,
@@ -68,12 +73,59 @@ class simulated_memory_resource final : public device_memory_resource {
    * @brief Deallocate memory pointed to by `ptr`.
    *
    * @note This call is ignored.
+   */
+  void deallocate([[maybe_unused]] cuda::stream_ref stream,
+                  void* /*ptr*/,
+                  std::size_t /*bytes*/,
+                  [[maybe_unused]] std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT) noexcept
+  {
+  }
+
+  /**
+   * @brief Allocates memory of size at least `bytes` synchronously.
+   *
+   * @param bytes The size, in bytes, of the allocation
+   * @param alignment The alignment of the allocation
+   * @return void* Pointer to the newly allocated memory
+   */
+  void* allocate_sync(std::size_t bytes, std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT)
+  {
+    return allocate(cuda::stream_ref{cudaStream_t{nullptr}}, bytes, alignment);
+  }
+
+  /**
+   * @brief Deallocate memory pointed to by `ptr` synchronously.
+   *
+   * @note This call is ignored.
    *
    * @param ptr Pointer to be deallocated
+   * @param bytes The size, in bytes, of the allocation
+   * @param alignment The alignment of the allocation
    */
-  void do_deallocate(void* /*ptr*/, std::size_t, cuda_stream_view) noexcept override {}
+  void deallocate_sync(void* ptr,
+                       std::size_t bytes,
+                       std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT) noexcept
+  {
+    deallocate(cuda::stream_ref{cudaStream_t{nullptr}}, ptr, bytes, alignment);
+  }
+
+  bool operator==(simulated_memory_resource const&) const noexcept { return true; }
+  bool operator!=(simulated_memory_resource const&) const noexcept { return false; }
 
+  RMM_CONSTEXPR_FRIEND void get_property(simulated_memory_resource const&,
+                                         cuda::mr::device_accessible) noexcept
+  {
+  }
+
+ private:
   char* begin_{};
   char* end_{};
 };
+
+static_assert(cuda::mr::synchronous_resource<simulated_memory_resource>);
+static_assert(cuda::mr::resource<simulated_memory_resource>);
+static_assert(
+  cuda::mr::synchronous_resource_with<simulated_memory_resource, cuda::mr::device_accessible>);
+static_assert(cuda::mr::resource_with<simulated_memory_resource, cuda::mr::device_accessible>);
+
 }  // namespace rmm::mr
diff --git a/cpp/include/rmm/cuda_stream.hpp b/cpp/include/rmm/cuda_stream.hpp
index da620f5c5..cddcc45bd 100644
--- a/cpp/include/rmm/cuda_stream.hpp
+++ b/cpp/include/rmm/cuda_stream.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
  */
 
@@ -98,6 +98,13 @@ class cuda_stream {
    */
   operator cuda_stream_view() const;
 
+  /**
+   * @brief Implicit conversion to cuda::stream_ref
+   *
+   * @return A stream_ref of the owned stream
+   */
+  operator cuda::stream_ref() const;
+
   /**
    * @brief Synchronize the owned CUDA stream.
    *
diff --git a/cpp/include/rmm/detail/cccl_adaptors.hpp b/cpp/include/rmm/detail/cccl_adaptors.hpp
index d8f6999e0..d2b33ec4d 100644
--- a/cpp/include/rmm/detail/cccl_adaptors.hpp
+++ b/cpp/include/rmm/detail/cccl_adaptors.hpp
@@ -32,6 +32,34 @@ inline constexpr bool is_specialization_of_v = false;
 template <template <class...> class Template, class... Args>
 inline constexpr bool is_specialization_of_v<Template<Args...>, Template> = true;
 
+/**
+ * @brief For a type that publicly derives from shared_resource<Impl>, extracts the
+ * shared_resource<Impl> base type and provides a reference cast.
+ *
+ * CCCL's basic_any-based resource_ref can type-erase shared_resource<Impl> directly but not
+ * classes that inherit from it. This helper extracts the base and casts to it.
+ */
+template <typename T, typename = void>
+struct shared_resource_cast {
+  static constexpr bool value = false;
+};
+
+template <typename T>
+struct shared_resource_cast<
+  T,
+  std::void_t<
+    decltype(std::declval<std::remove_cv_t<T>&>().get()),
+    std::enable_if_t<std::is_base_of_v<cuda::mr::shared_resource<std::remove_reference_t<
+                                         decltype(std::declval<T&>().get())>>,
+                                       std::remove_cv_t<T>> and
+                     not is_specialization_of_v<std::remove_cv_t<T>, cuda::mr::shared_resource>>>> {
+  static constexpr bool value = true;
+  using impl_type             = std::remove_reference_t<decltype(std::declval<T&>().get())>;
+  using base_type             = cuda::mr::shared_resource<impl_type>;
+
+  static base_type& cast(T& ref) noexcept { return static_cast<base_type&>(ref); }
+};
+
 // Forward declarations for use in enable_if constraints
 template <typename ResourceType>
 class cccl_resource_ref;
@@ -39,6 +67,20 @@ class cccl_resource_ref;
 template <typename ResourceType>
 class cccl_async_resource_ref;
 
+// Traits to detect cccl_resource_ref and cccl_async_resource_ref specializations.
+// Defined here (outside the class bodies) to avoid the injected-class-name issue
+// where GCC resolves `cccl_async_resource_ref` to the fully-specialized type
+// inside the class template body, breaking is_specialization_of_v.
+template <typename T>
+inline constexpr bool is_cccl_resource_ref_v = false;
+template <typename R>
+inline constexpr bool is_cccl_resource_ref_v<cccl_resource_ref<R>> = true;
+
+template <typename T>
+inline constexpr bool is_cccl_async_resource_ref_v = false;
+template <typename R>
+inline constexpr bool is_cccl_async_resource_ref_v<cccl_async_resource_ref<R>> = true;
+
 /**
  * @brief A wrapper around CCCL synchronous_resource_ref that adds compatibility with
  * device_memory_resource pointers.
@@ -146,28 +188,46 @@ class cccl_resource_ref {
   {
   }
 
+  /**
+   * @brief Construct a ref from a shared_resource-derived type.
+   *
+   * CCCL's basic_any-based resource_ref can type-erase shared_resource<T> directly but not
+   * types that publicly inherit from it. This constructor casts to the shared_resource base.
+   *
+   * @tparam OtherResourceType A type that publicly derives from shared_resource<Impl>
+   * @param other The shared_resource-derived resource to construct a ref from
+   */
+  template <typename OtherResourceType,
+            std::enable_if_t<shared_resource_cast<OtherResourceType>::value>* = nullptr>
+  cccl_resource_ref(OtherResourceType& other)
+    : view_{}, ref_{ResourceType{shared_resource_cast<OtherResourceType>::cast(other)}}
+  {
+  }
+
   /**
    * @brief Construct a ref from a resource.
    *
    * This constructor accepts CCCL resource types but NOT CCCL resource_ref types,
-   * our own wrapper types, or device_memory_resource derived types. The exclusions
-   * are checked FIRST to prevent recursive constraint satisfaction.
+   * our own wrapper types, device_memory_resource derived types, or
+   * shared_resource-derived types (handled by dedicated constructor above).
+   * The exclusions are checked FIRST to prevent recursive constraint satisfaction.
    *
-   * @tparam OtherResourceType A CCCL resource type (not a resource_ref, wrapper, or DMR)
+   * @tparam OtherResourceType A CCCL resource type (not a resource_ref, wrapper, DMR,
+   * or shared_resource)
    * @param other The resource to construct a ref from
    */
-  template <typename OtherResourceType,
-            std::enable_if_t<not is_specialization_of_v<std::remove_cv_t<OtherResourceType>,
-                                                        cuda::mr::synchronous_resource_ref> and
-                             not is_specialization_of_v<std::remove_cv_t<OtherResourceType>,
-                                                        cuda::mr::resource_ref> and
-                             not is_specialization_of_v<std::remove_cv_t<OtherResourceType>,
-                                                        ::rmm::detail::cccl_resource_ref> and
-                             not is_specialization_of_v<std::remove_cv_t<OtherResourceType>,
-                                                        ::rmm::detail::cccl_async_resource_ref> and
-                             not std::is_base_of_v<rmm::mr::device_memory_resource,
-                                                   std::remove_cv_t<OtherResourceType>> and
-                             cuda::mr::synchronous_resource<OtherResourceType>>* = nullptr>
+  template <
+    typename OtherResourceType,
+    std::enable_if_t<
+      not is_specialization_of_v<std::remove_cv_t<OtherResourceType>,
+                                 cuda::mr::synchronous_resource_ref> and
+      not is_specialization_of_v<std::remove_cv_t<OtherResourceType>, cuda::mr::resource_ref> and
+      not is_cccl_resource_ref_v<std::remove_cv_t<OtherResourceType>> and
+      not is_cccl_async_resource_ref_v<std::remove_cv_t<OtherResourceType>> and
+      not shared_resource_cast<OtherResourceType>::value and
+      not std::is_base_of_v<rmm::mr::device_memory_resource,
+                            std::remove_cv_t<OtherResourceType>> and
+      cuda::mr::synchronous_resource<OtherResourceType>>* = nullptr>
   cccl_resource_ref(OtherResourceType& other) : view_{}, ref_{ResourceType{other}}
   {
   }
@@ -400,15 +460,32 @@ class cccl_async_resource_ref {
   {
   }
 
+  /**
+   * @brief Construct a ref from a shared_resource-derived type.
+   *
+   * CCCL's basic_any-based resource_ref can type-erase shared_resource<T> directly but not
+   * types that publicly inherit from it. This constructor casts to the shared_resource base.
+   *
+   * @tparam OtherResourceType A type that publicly derives from shared_resource<Impl>
+   * @param other The shared_resource-derived resource to construct a ref from
+   */
+  template <typename OtherResourceType,
+            std::enable_if_t<shared_resource_cast<OtherResourceType>::value>* = nullptr>
+  cccl_async_resource_ref(OtherResourceType& other)
+    : view_{}, ref_{ResourceType{shared_resource_cast<OtherResourceType>::cast(other)}}
+  {
+  }
+
   /**
    * @brief Construct a ref from a resource.
    *
    * This constructor accepts CCCL resource types but NOT CCCL resource_ref types,
-   * our own wrapper types, any_resource types, or device_memory_resource derived types.
+   * our own wrapper types, any_resource types, device_memory_resource derived types,
+   * or shared_resource-derived types (handled by dedicated constructor above).
    * The exclusions are checked FIRST to prevent recursive constraint satisfaction.
    *
-   * @tparam OtherResourceType A CCCL resource type (not a resource_ref, wrapper, any_resource, or
-   * DMR)
+   * @tparam OtherResourceType A CCCL resource type (not a resource_ref, wrapper, any_resource,
+   * DMR, or shared_resource)
    * @param other The resource to construct a ref from
    */
   template <
@@ -418,10 +495,9 @@ class cccl_async_resource_ref {
                                  cuda::mr::synchronous_resource_ref> and
       not is_specialization_of_v<std::remove_cv_t<OtherResourceType>, cuda::mr::resource_ref> and
       not is_specialization_of_v<std::remove_cv_t<OtherResourceType>, cuda::mr::any_resource> and
-      not is_specialization_of_v<std::remove_cv_t<OtherResourceType>,
-                                 ::rmm::detail::cccl_resource_ref> and
-      not is_specialization_of_v<std::remove_cv_t<OtherResourceType>,
-                                 ::rmm::detail::cccl_async_resource_ref> and
+      not is_cccl_resource_ref_v<std::remove_cv_t<OtherResourceType>> and
+      not is_cccl_async_resource_ref_v<std::remove_cv_t<OtherResourceType>> and
+      not shared_resource_cast<OtherResourceType>::value and
       not std::is_base_of_v<rmm::mr::device_memory_resource,
                             std::remove_cv_t<OtherResourceType>> and
       cuda::mr::resource<OtherResourceType>>* = nullptr>
diff --git a/cpp/include/rmm/mr/aligned_resource_adaptor.hpp b/cpp/include/rmm/mr/aligned_resource_adaptor.hpp
index a8af2f54e..aa05c83de 100644
--- a/cpp/include/rmm/mr/aligned_resource_adaptor.hpp
+++ b/cpp/include/rmm/mr/aligned_resource_adaptor.hpp
@@ -5,10 +5,8 @@
 #pragma once
 
 #include <rmm/aligned.hpp>
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/aligned_resource_adaptor_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -33,40 +31,10 @@ namespace mr {
  * `cuda::mr::shared_resource`.
  */
 class RMM_EXPORT aligned_resource_adaptor
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::aligned_resource_adaptor_impl> {
+  : public cuda::mr::shared_resource<detail::aligned_resource_adaptor_impl> {
   using shared_base = cuda::mr::shared_resource<detail::aligned_resource_adaptor_impl>;
 
  public:
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two adaptors for equality (shared-impl identity).
-   *
-   * @param other The other adaptor to compare against.
-   * @return true if both adaptors share the same underlying impl.
-   */
-  [[nodiscard]] bool operator==(aligned_resource_adaptor const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two adaptors for inequality.
-   *
-   * @param other The other adaptor to compare against.
-   * @return true if the adaptors do not share the same underlying impl.
-   */
-  [[nodiscard]] bool operator!=(aligned_resource_adaptor const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -102,15 +70,6 @@ class RMM_EXPORT aligned_resource_adaptor
    * @briefreturn{rmm::device_async_resource_ref to the upstream resource}
    */
   [[nodiscard]] device_async_resource_ref get_upstream_resource() const noexcept;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<aligned_resource_adaptor, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/arena_memory_resource.hpp b/cpp/include/rmm/mr/arena_memory_resource.hpp
index a11e1249c..d91da19df 100644
--- a/cpp/include/rmm/mr/arena_memory_resource.hpp
+++ b/cpp/include/rmm/mr/arena_memory_resource.hpp
@@ -4,10 +4,8 @@
  */
 #pragma once
 
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/arena_memory_resource_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -63,40 +61,10 @@ namespace mr {
  * \see https://github.com/google/tcmalloc
  */
 class RMM_EXPORT arena_memory_resource
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::arena_memory_resource_impl> {
+  : public cuda::mr::shared_resource<detail::arena_memory_resource_impl> {
   using shared_base = cuda::mr::shared_resource<detail::arena_memory_resource_impl>;
 
  public:
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two resources for equality (shared-impl identity).
-   *
-   * @param other The other arena_memory_resource to compare against.
-   * @return true if both resources share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(arena_memory_resource const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two resources for inequality.
-   *
-   * @param other The other arena_memory_resource to compare against.
-   * @return true if the resources do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(arena_memory_resource const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -118,15 +86,6 @@ class RMM_EXPORT arena_memory_resource
                                  bool dump_log_on_failure              = false);
 
   ~arena_memory_resource() = default;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<arena_memory_resource, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/binning_memory_resource.hpp b/cpp/include/rmm/mr/binning_memory_resource.hpp
index 321586ba6..7a545c6cd 100644
--- a/cpp/include/rmm/mr/binning_memory_resource.hpp
+++ b/cpp/include/rmm/mr/binning_memory_resource.hpp
@@ -4,10 +4,8 @@
  */
 #pragma once
 
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/binning_memory_resource_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -29,41 +27,11 @@ namespace mr {
  * This class is copyable and shares ownership of its internal state, allowing
  * multiple instances to safely reference the same underlying bins.
  */
-class RMM_EXPORT binning_memory_resource final
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::binning_memory_resource_impl> {
+class RMM_EXPORT binning_memory_resource
+  : public cuda::mr::shared_resource<detail::binning_memory_resource_impl> {
   using shared_base = cuda::mr::shared_resource<detail::binning_memory_resource_impl>;
 
  public:
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Equality comparison operator.
-   *
-   * @param other The other binning_memory_resource to compare against.
-   * @return true if both resources share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(binning_memory_resource const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Inequality comparison operator.
-   *
-   * @param other The other binning_memory_resource to compare against.
-   * @return true if the resources do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(binning_memory_resource const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    *
@@ -124,15 +92,6 @@ class RMM_EXPORT binning_memory_resource final
    */
   void add_bin(std::size_t allocation_size,
                std::optional<device_async_resource_ref> bin_resource = std::nullopt);
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<binning_memory_resource, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/callback_memory_resource.hpp b/cpp/include/rmm/mr/callback_memory_resource.hpp
index 6fac33a10..e8b40b1c9 100644
--- a/cpp/include/rmm/mr/callback_memory_resource.hpp
+++ b/cpp/include/rmm/mr/callback_memory_resource.hpp
@@ -4,10 +4,8 @@
  */
 #pragma once
 
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/callback_memory_resource_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -69,38 +67,10 @@ class callback_memory_resource_impl;
  * `cuda::mr::shared_resource`.
  */
 class RMM_EXPORT callback_memory_resource
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::callback_memory_resource_impl> {
+  : public cuda::mr::shared_resource<detail::callback_memory_resource_impl> {
   using shared_base = cuda::mr::shared_resource<detail::callback_memory_resource_impl>;
 
  public:
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two resources for equality (shared-impl identity).
-   *
-   * @param other The other callback_memory_resource to compare against.
-   * @return true if both resources share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(callback_memory_resource const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two resources for inequality.
-   *
-   * @param other The other callback_memory_resource to compare against.
-   * @return true if the resources do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(callback_memory_resource const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -131,11 +101,6 @@ class RMM_EXPORT callback_memory_resource
 
   callback_memory_resource()  = delete;
   ~callback_memory_resource() = default;
-
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
 };
 
 static_assert(cuda::mr::resource_with<callback_memory_resource, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/cuda_async_managed_memory_resource.hpp b/cpp/include/rmm/mr/cuda_async_managed_memory_resource.hpp
index 73030a0a6..efb46fde6 100644
--- a/cpp/include/rmm/mr/cuda_async_managed_memory_resource.hpp
+++ b/cpp/include/rmm/mr/cuda_async_managed_memory_resource.hpp
@@ -5,10 +5,8 @@
 #pragma once
 
 #include <rmm/aligned.hpp>
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/cuda_async_managed_memory_resource_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
 #include <cuda/memory_resource>
 #include <cuda_runtime_api.h>
@@ -24,45 +22,14 @@ namespace mr {
  */
 
 /**
- * @brief `device_memory_resource` derived class that uses
- * `cudaMallocFromPoolAsync`/`cudaFreeFromPoolAsync` with a managed memory pool
- * for allocation/deallocation.
+ * @brief Memory resource that uses `cudaMallocFromPoolAsync`/`cudaFreeFromPoolAsync`
+ * with a managed memory pool for allocation/deallocation.
  */
 class RMM_EXPORT cuda_async_managed_memory_resource final
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::cuda_async_managed_memory_resource_impl> {
+  : public cuda::mr::shared_resource<detail::cuda_async_managed_memory_resource_impl> {
   using shared_base = cuda::mr::shared_resource<detail::cuda_async_managed_memory_resource_impl>;
 
  public:
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two resources for equality (shared-impl identity).
-   *
-   * @param other The other cuda_async_managed_memory_resource to compare against.
-   * @return true if both resources share the same underlying pool.
-   */
-  [[nodiscard]] bool operator==(cuda_async_managed_memory_resource const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two resources for inequality.
-   *
-   * @param other The other cuda_async_managed_memory_resource to compare against.
-   * @return true if the resources do not share the same underlying pool.
-   */
-  [[nodiscard]] bool operator!=(cuda_async_managed_memory_resource const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -98,20 +65,15 @@ class RMM_EXPORT cuda_async_managed_memory_resource final
    */
   [[nodiscard]] cudaMemPool_t pool_handle() const noexcept;
 
-  ~cuda_async_managed_memory_resource()                                         = default;
-  cuda_async_managed_memory_resource(cuda_async_managed_memory_resource const&) = delete;
-  cuda_async_managed_memory_resource(cuda_async_managed_memory_resource&&)      = delete;
-  cuda_async_managed_memory_resource& operator=(cuda_async_managed_memory_resource const&) = delete;
-  cuda_async_managed_memory_resource& operator=(cuda_async_managed_memory_resource&&)      = delete;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
+  ~cuda_async_managed_memory_resource() = default;
+  cuda_async_managed_memory_resource(cuda_async_managed_memory_resource const&) =
+    default;  ///< @default_copy_constructor
+  cuda_async_managed_memory_resource(cuda_async_managed_memory_resource&&) =
+    default;  ///< @default_move_constructor
+  cuda_async_managed_memory_resource& operator=(cuda_async_managed_memory_resource const&) =
+    default;  ///< @default_copy_assignment{cuda_async_managed_memory_resource}
+  cuda_async_managed_memory_resource& operator=(cuda_async_managed_memory_resource&&) =
+    default;  ///< @default_move_assignment{cuda_async_managed_memory_resource}
 };
 
 // static property checks
diff --git a/cpp/include/rmm/mr/cuda_async_memory_resource.hpp b/cpp/include/rmm/mr/cuda_async_memory_resource.hpp
index fd3909689..aa98f8b7d 100644
--- a/cpp/include/rmm/mr/cuda_async_memory_resource.hpp
+++ b/cpp/include/rmm/mr/cuda_async_memory_resource.hpp
@@ -5,10 +5,8 @@
 #pragma once
 
 #include <rmm/aligned.hpp>
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/cuda_async_memory_resource_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
 #include <cuda/memory_resource>
 #include <cuda_runtime_api.h>
@@ -26,12 +24,11 @@ namespace mr {
  */
 
 /**
- * @brief `device_memory_resource` derived class that uses `cudaMallocAsync`/`cudaFreeAsync` for
+ * @brief Memory resource that uses `cudaMallocAsync`/`cudaFreeAsync` for
  * allocation/deallocation.
  */
 class RMM_EXPORT cuda_async_memory_resource final
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::cuda_async_memory_resource_impl> {
+  : public cuda::mr::shared_resource<detail::cuda_async_memory_resource_impl> {
   using shared_base = cuda::mr::shared_resource<detail::cuda_async_memory_resource_impl>;
 
  public:
@@ -75,35 +72,6 @@ class RMM_EXPORT cuda_async_memory_resource final
                           ///< accelerated decompression.
   };
 
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two resources for equality (shared-impl identity).
-   *
-   * @param other The other cuda_async_memory_resource to compare against.
-   * @return true if both resources share the same underlying pool.
-   */
-  [[nodiscard]] bool operator==(cuda_async_memory_resource const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two resources for inequality.
-   *
-   * @param other The other cuda_async_memory_resource to compare against.
-   * @return true if the resources do not share the same underlying pool.
-   */
-  [[nodiscard]] bool operator!=(cuda_async_memory_resource const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -142,20 +110,15 @@ class RMM_EXPORT cuda_async_memory_resource final
    */
   [[nodiscard]] cudaMemPool_t pool_handle() const noexcept;
 
-  ~cuda_async_memory_resource()                                            = default;
-  cuda_async_memory_resource(cuda_async_memory_resource const&)            = delete;
-  cuda_async_memory_resource(cuda_async_memory_resource&&)                 = delete;
-  cuda_async_memory_resource& operator=(cuda_async_memory_resource const&) = delete;
-  cuda_async_memory_resource& operator=(cuda_async_memory_resource&&)      = delete;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
+  ~cuda_async_memory_resource() = default;
+  cuda_async_memory_resource(cuda_async_memory_resource const&) =
+    default;  ///< @default_copy_constructor
+  cuda_async_memory_resource(cuda_async_memory_resource&&) =
+    default;  ///< @default_move_constructor
+  cuda_async_memory_resource& operator=(cuda_async_memory_resource const&) =
+    default;  ///< @default_copy_assignment{cuda_async_memory_resource}
+  cuda_async_memory_resource& operator=(cuda_async_memory_resource&&) =
+    default;  ///< @default_move_assignment{cuda_async_memory_resource}
 };
 
 // static property checks
diff --git a/cpp/include/rmm/mr/cuda_async_view_memory_resource.hpp b/cpp/include/rmm/mr/cuda_async_view_memory_resource.hpp
index 4e7517a75..8c505b442 100644
--- a/cpp/include/rmm/mr/cuda_async_view_memory_resource.hpp
+++ b/cpp/include/rmm/mr/cuda_async_view_memory_resource.hpp
@@ -5,13 +5,11 @@
 #pragma once
 
 #include <rmm/aligned.hpp>
-#include <rmm/cuda_device.hpp>
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/error.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/detail/runtime_capabilities.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
+#include <cuda/memory_resource>
 #include <cuda/stream_ref>
 #include <cuda_runtime_api.h>
 
@@ -26,10 +24,10 @@ namespace mr {
  */
 
 /**
- * @brief `device_memory_resource` derived class that uses `cudaMallocAsync`/`cudaFreeAsync` for
+ * @brief Memory resource that uses `cudaMallocAsync`/`cudaFreeAsync` for
  * allocation/deallocation.
  */
-class cuda_async_view_memory_resource final : public device_memory_resource {
+class cuda_async_view_memory_resource final {
  public:
   /**
    * @brief Constructs a cuda_async_view_memory_resource which uses an existing CUDA memory pool.
@@ -119,8 +117,8 @@ class cuda_async_view_memory_resource final : public device_memory_resource {
    */
   void* allocate_sync(std::size_t bytes, std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT)
   {
-    auto* ptr = allocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, bytes, alignment);
-    RMM_CUDA_TRY(cudaStreamSynchronize(reinterpret_cast<cudaStream_t>(0)));
+    auto* ptr = allocate(cuda::stream_ref{cudaStream_t{nullptr}}, bytes, alignment);
+    RMM_CUDA_TRY(cudaStreamSynchronize(cudaStream_t{nullptr}));
     return ptr;
   }
 
@@ -135,7 +133,7 @@ class cuda_async_view_memory_resource final : public device_memory_resource {
                        std::size_t bytes,
                        std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT) noexcept
   {
-    deallocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, ptr, bytes, alignment);
+    deallocate(cuda::stream_ref{cudaStream_t{nullptr}}, ptr, bytes, alignment);
   }
 
   /**
@@ -150,6 +148,14 @@ class cuda_async_view_memory_resource final : public device_memory_resource {
     return pool_handle() == other.pool_handle();
   }
 
+  /**
+   * @copydoc operator==
+   */
+  [[nodiscard]] bool operator!=(cuda_async_view_memory_resource const& other) const noexcept
+  {
+    return !operator==(other);
+  }
+
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    *
@@ -163,22 +169,6 @@ class cuda_async_view_memory_resource final : public device_memory_resource {
 
  private:
   cudaMemPool_t cuda_pool_handle_{};
-
-  // -- Legacy device_memory_resource overrides (delegates to CCCL interface) --
-  void* do_allocate(std::size_t bytes, rmm::cuda_stream_view stream) override
-  {
-    return allocate(stream, bytes);
-  }
-
-  void do_deallocate(void* ptr, std::size_t bytes, rmm::cuda_stream_view stream) noexcept override
-  {
-    deallocate(stream, ptr, bytes);
-  }
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override
-  {
-    return dynamic_cast<cuda_async_view_memory_resource const*>(&other) != nullptr;
-  }
 };
 
 // static property checks
diff --git a/cpp/include/rmm/mr/cuda_memory_resource.hpp b/cpp/include/rmm/mr/cuda_memory_resource.hpp
index 89245839d..0819c1ecf 100644
--- a/cpp/include/rmm/mr/cuda_memory_resource.hpp
+++ b/cpp/include/rmm/mr/cuda_memory_resource.hpp
@@ -5,11 +5,10 @@
 #pragma once
 
 #include <rmm/aligned.hpp>
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/error.hpp>
 #include <rmm/detail/export.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
+#include <cuda/memory_resource>
 #include <cuda/stream_ref>
 
 #include <cstddef>
@@ -22,13 +21,12 @@ namespace mr {
  * @file
  */
 /**
- * @brief `device_memory_resource` derived class that uses cudaMalloc/Free for
- * allocation/deallocation.
+ * @brief Memory resource that uses cudaMalloc/Free for allocation/deallocation.
  */
-class cuda_memory_resource final : public device_memory_resource {
+class cuda_memory_resource final {
  public:
   cuda_memory_resource()                            = default;
-  ~cuda_memory_resource() override                  = default;
+  ~cuda_memory_resource()                           = default;
   cuda_memory_resource(cuda_memory_resource const&) = default;  ///< @default_copy_constructor
   cuda_memory_resource(cuda_memory_resource&&)      = default;  ///< @default_move_constructor
   cuda_memory_resource& operator=(cuda_memory_resource const&) =
@@ -87,8 +85,8 @@ class cuda_memory_resource final : public device_memory_resource {
    */
   void* allocate_sync(std::size_t bytes, std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT)
   {
-    auto* ptr = allocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, bytes, alignment);
-    RMM_CUDA_TRY(cudaStreamSynchronize(reinterpret_cast<cudaStream_t>(0)));
+    auto* ptr = allocate(cuda::stream_ref{cudaStream_t{nullptr}}, bytes, alignment);
+    RMM_CUDA_TRY(cudaStreamSynchronize(cudaStream_t{nullptr}));
     return ptr;
   }
 
@@ -103,7 +101,7 @@ class cuda_memory_resource final : public device_memory_resource {
                        std::size_t bytes,
                        std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT) noexcept
   {
-    deallocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, ptr, bytes, alignment);
+    deallocate(cuda::stream_ref{cudaStream_t{nullptr}}, ptr, bytes, alignment);
   }
 
   /**
@@ -116,22 +114,19 @@ class cuda_memory_resource final : public device_memory_resource {
   {
   }
 
- private:
-  // -- Legacy device_memory_resource overrides (delegates to CCCL interface) --
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override
-  {
-    return allocate(stream, bytes);
-  }
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override
-  {
-    deallocate(stream, ptr, bytes);
-  }
+  /**
+   * @brief Compare this resource to another.
+   *
+   * All instances of cuda_memory_resource are equivalent.
+   *
+   * @return true Always
+   */
+  [[nodiscard]] bool operator==(cuda_memory_resource const&) const noexcept { return true; }
 
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override
-  {
-    return dynamic_cast<cuda_memory_resource const*>(&other) != nullptr;
-  }
+  /**
+   * @copydoc operator==
+   */
+  [[nodiscard]] bool operator!=(cuda_memory_resource const&) const noexcept { return false; }
 };
 
 // static property checks
diff --git a/cpp/include/rmm/mr/detail/fixed_size_memory_resource_impl.hpp b/cpp/include/rmm/mr/detail/fixed_size_memory_resource_impl.hpp
index a31968b9a..cded81d11 100644
--- a/cpp/include/rmm/mr/detail/fixed_size_memory_resource_impl.hpp
+++ b/cpp/include/rmm/mr/detail/fixed_size_memory_resource_impl.hpp
@@ -40,7 +40,7 @@ class fixed_size_memory_resource_impl final
                                   std::size_t block_size,
                                   std::size_t blocks_to_preallocate);
 
-  ~fixed_size_memory_resource_impl() override;
+  ~fixed_size_memory_resource_impl();
 
   bool operator==(fixed_size_memory_resource_impl const& other) const noexcept
   {
diff --git a/cpp/include/rmm/mr/detail/pool_memory_resource_impl.hpp b/cpp/include/rmm/mr/detail/pool_memory_resource_impl.hpp
index 46f7ca968..5b23197a0 100644
--- a/cpp/include/rmm/mr/detail/pool_memory_resource_impl.hpp
+++ b/cpp/include/rmm/mr/detail/pool_memory_resource_impl.hpp
@@ -38,7 +38,7 @@ class pool_memory_resource_impl final
                             std::size_t initial_pool_size,
                             std::optional<std::size_t> maximum_pool_size);
 
-  ~pool_memory_resource_impl() override;
+  ~pool_memory_resource_impl();
 
   bool operator==(pool_memory_resource_impl const& other) const noexcept
   {
diff --git a/cpp/include/rmm/mr/detail/stream_ordered_memory_resource.hpp b/cpp/include/rmm/mr/detail/stream_ordered_memory_resource.hpp
index 59a84943b..99f3bcd5b 100644
--- a/cpp/include/rmm/mr/detail/stream_ordered_memory_resource.hpp
+++ b/cpp/include/rmm/mr/detail/stream_ordered_memory_resource.hpp
@@ -10,8 +10,8 @@
 #include <rmm/detail/export.hpp>
 #include <rmm/detail/format.hpp>
 #include <rmm/logger.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
+#include <cuda/stream_ref>
 #include <cuda_runtime_api.h>
 
 #include <algorithm>
@@ -65,9 +65,9 @@ struct crtp {
  * 4. `block_type free_block(void* ptr, std::size_t size) noexcept`
  */
 template <typename PoolResource, typename FreeListType>
-class stream_ordered_memory_resource : public crtp<PoolResource>, public device_memory_resource {
+class stream_ordered_memory_resource : public crtp<PoolResource> {
  public:
-  ~stream_ordered_memory_resource() override { release(); }
+  ~stream_ordered_memory_resource() { release(); }
 
   stream_ordered_memory_resource()                                                 = default;
   stream_ordered_memory_resource(stream_ordered_memory_resource const&)            = delete;
@@ -75,6 +75,115 @@ class stream_ordered_memory_resource : public crtp<PoolResource>, public device_
   stream_ordered_memory_resource& operator=(stream_ordered_memory_resource const&) = delete;
   stream_ordered_memory_resource& operator=(stream_ordered_memory_resource&&)      = delete;
 
+  /**
+   * @brief Allocates memory of size at least `size` bytes.
+   *
+   * The returned pointer has at least 256B alignment.
+   *
+   * @throws `std::bad_alloc` if the requested allocation could not be fulfilled
+   *
+   * @param stream The stream in which to order this allocation
+   * @param size The size in bytes of the allocation
+   * @param alignment Unused; alignment is always at least `CUDA_ALLOCATION_ALIGNMENT`
+   * @return void* Pointer to the newly allocated memory
+   */
+  void* allocate(cuda::stream_ref stream, std::size_t size, std::size_t /*alignment*/)
+  {
+    auto const strm = cuda_stream_view{stream};
+
+    RMM_LOG_TRACE("[A][stream %s][%zuB]", rmm::detail::format_stream(strm), size);
+
+    if (size == 0) { return nullptr; }
+
+    lock_guard lock(mtx_);
+
+    auto stream_event = get_event(strm);
+
+    size = rmm::align_up(size, rmm::CUDA_ALLOCATION_ALIGNMENT);
+    RMM_EXPECTS(size <= this->underlying().get_maximum_allocation_size(),
+                std::string("Maximum allocation size exceeded (failed to allocate ") +
+                  rmm::detail::format_bytes(size) + ")",
+                rmm::out_of_memory);
+    auto const block = this->underlying().get_block(size, stream_event);
+
+    RMM_LOG_TRACE("[A][stream %s][%zuB][%p]",
+                  rmm::detail::format_stream(stream_event.stream),
+                  size,
+                  block.pointer());
+
+    log_summary_trace();
+
+    return block.pointer();
+  }
+
+  /**
+   * @brief Deallocate memory pointed to by `ptr`.
+   *
+   * @param stream The stream in which to order this deallocation
+   * @param ptr Pointer to be deallocated
+   * @param size The size in bytes of the allocation to deallocate
+   * @param alignment Unused
+   */
+  void deallocate(cuda::stream_ref stream,
+                  void* ptr,
+                  std::size_t size,
+                  std::size_t /*alignment*/) noexcept
+  {
+    auto const strm = cuda_stream_view{stream};
+
+    RMM_LOG_TRACE("[D][stream %s][%zuB][%p]", rmm::detail::format_stream(strm), size, ptr);
+
+    if (size == 0 || ptr == nullptr) { return; }
+
+    lock_guard lock(mtx_);
+    auto stream_event = get_event(strm);
+
+    size             = rmm::align_up(size, rmm::CUDA_ALLOCATION_ALIGNMENT);
+    auto const block = this->underlying().free_block(ptr, size);
+
+    // TODO: cudaEventRecord has significant overhead on deallocations. For the non-PTDS case
+    // we may be able to delay recording the event in some situations. But using events rather than
+    // streams allows stealing from deleted streams.
+    RMM_ASSERT_CUDA_SUCCESS(cudaEventRecord(stream_event.event, strm.value()));
+
+    stream_free_blocks_[stream_event].insert(block);
+
+    log_summary_trace();
+  }
+
+  /**
+   * @brief Allocates memory of size at least `bytes` synchronously.
+   *
+   * @throws `std::bad_alloc` if the requested allocation could not be fulfilled
+   *
+   * @param bytes The size in bytes of the allocation
+   * @param alignment Alignment of the allocation
+   * @return void* Pointer to the newly allocated memory
+   */
+  [[nodiscard]] void* allocate_sync(std::size_t bytes,
+                                    std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT)
+  {
+    auto const stream = cuda_stream_view{};
+    void* ptr         = allocate(stream, bytes, alignment);
+    stream.synchronize();
+    return ptr;
+  }
+
+  /**
+   * @brief Deallocate memory pointed to by `ptr` synchronously.
+   *
+   * @param ptr Pointer to be deallocated
+   * @param bytes The size in bytes of the allocation to deallocate
+   * @param alignment Alignment of the allocation
+   */
+  void deallocate_sync(
+    void* ptr,
+    std::size_t bytes,
+    [[maybe_unused]] std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT) noexcept
+  {
+    deallocate(cuda_stream_view{}, ptr, bytes, alignment);
+  }
+
  protected:
   using free_list  = FreeListType;
   using block_type = typename free_list::block_type;
@@ -181,73 +290,6 @@ class stream_ordered_memory_resource : public crtp<PoolResource>, public device_
     bool operator<(stream_event_pair const& rhs) const { return event < rhs.event; }
   };
 
-  /**
-   * @brief Allocates memory of size at least `bytes`.
-   *
-   * The returned pointer has at least 256B alignment.
-   *
-   * @throws `std::bad_alloc` if the requested allocation could not be fulfilled
-   *
-   * @param size The size in bytes of the allocation
-   * @param stream The stream in which to order this allocation
-   * @return void* Pointer to the newly allocated memory
-   */
-  void* do_allocate(std::size_t size, cuda_stream_view stream) override
-  {
-    RMM_LOG_TRACE("[A][stream %s][%zuB]", rmm::detail::format_stream(stream), size);
-
-    if (size <= 0) { return nullptr; }
-
-    lock_guard lock(mtx_);
-
-    auto stream_event = get_event(stream);
-
-    size = rmm::align_up(size, rmm::CUDA_ALLOCATION_ALIGNMENT);
-    RMM_EXPECTS(size <= this->underlying().get_maximum_allocation_size(),
-                std::string("Maximum allocation size exceeded (failed to allocate ") +
-                  rmm::detail::format_bytes(size) + ")",
-                rmm::out_of_memory);
-    auto const block = this->underlying().get_block(size, stream_event);
-
-    RMM_LOG_TRACE("[A][stream %s][%zuB][%p]",
-                  rmm::detail::format_stream(stream_event.stream),
-                  size,
-                  block.pointer());
-
-    log_summary_trace();
-
-    return block.pointer();
-  }
-
-  /**
-   * @brief Deallocate memory pointed to by `ptr`.
-   *
-   * @param ptr Pointer to be deallocated
-   * @param size The size in bytes of the allocation to deallocate
-   * @param stream The stream in which to order this deallocation
-   */
-  void do_deallocate(void* ptr, std::size_t size, cuda_stream_view stream) noexcept override
-  {
-    RMM_LOG_TRACE("[D][stream %s][%zuB][%p]", rmm::detail::format_stream(stream), size, ptr);
-
-    if (size <= 0 || ptr == nullptr) { return; }
-
-    lock_guard lock(mtx_);
-    auto stream_event = get_event(stream);
-
-    size             = rmm::align_up(size, rmm::CUDA_ALLOCATION_ALIGNMENT);
-    auto const block = this->underlying().free_block(ptr, size);
-
-    // TODO: cudaEventRecord has significant overhead on deallocations. For the non-PTDS case
-    // we may be able to delay recording the event in some situations. But using events rather than
-    // streams allows stealing from deleted streams.
-    RMM_ASSERT_CUDA_SUCCESS(cudaEventRecord(stream_event.event, stream.value()));
-
-    stream_free_blocks_[stream_event].insert(block);
-
-    log_summary_trace();
-  }
-
  private:
   /**
    * @brief get a unique CUDA event (possibly new) associated with `stream`
diff --git a/cpp/include/rmm/mr/failure_callback_resource_adaptor.hpp b/cpp/include/rmm/mr/failure_callback_resource_adaptor.hpp
index f707cbb68..847d706fc 100644
--- a/cpp/include/rmm/mr/failure_callback_resource_adaptor.hpp
+++ b/cpp/include/rmm/mr/failure_callback_resource_adaptor.hpp
@@ -5,11 +5,9 @@
 #pragma once
 
 #include <rmm/aligned.hpp>
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/error.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/failure_callback_resource_adaptor_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -43,8 +41,7 @@ namespace mr {
  */
 template <typename ExceptionType = rmm::out_of_memory>
 class failure_callback_resource_adaptor
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<
+  : public cuda::mr::shared_resource<
       detail::failure_callback_resource_adaptor_impl<ExceptionType>> {
   using shared_base =
     cuda::mr::shared_resource<detail::failure_callback_resource_adaptor_impl<ExceptionType>>;
@@ -52,35 +49,6 @@ class failure_callback_resource_adaptor
  public:
   using exception_type = ExceptionType;  ///< The type of exception this object catches/throws
 
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two adaptors for equality (shared-impl identity).
-   *
-   * @param other The other failure_callback_resource_adaptor to compare against.
-   * @return true if both adaptors share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(failure_callback_resource_adaptor const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two adaptors for inequality.
-   *
-   * @param other The other failure_callback_resource_adaptor to compare against.
-   * @return true if the adaptors do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(failure_callback_resource_adaptor const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -115,27 +83,6 @@ class failure_callback_resource_adaptor
   {
     return this->get().get_upstream_resource();
   }
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override
-  {
-    return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-  }
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override
-  {
-    shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-  }
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override
-  {
-    if (this == std::addressof(other)) { return true; }
-    auto const* cast = dynamic_cast<failure_callback_resource_adaptor const*>(&other);
-    if (cast == nullptr) { return false; }
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-  }
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(
diff --git a/cpp/include/rmm/mr/fixed_size_memory_resource.hpp b/cpp/include/rmm/mr/fixed_size_memory_resource.hpp
index ed9932c04..07d558d47 100644
--- a/cpp/include/rmm/mr/fixed_size_memory_resource.hpp
+++ b/cpp/include/rmm/mr/fixed_size_memory_resource.hpp
@@ -4,10 +4,8 @@
  */
 #pragma once
 
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/fixed_size_memory_resource_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -31,40 +29,10 @@ namespace mr {
  * multiple instances to safely reference the same underlying pool.
  */
 class RMM_EXPORT fixed_size_memory_resource
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::fixed_size_memory_resource_impl> {
+  : public cuda::mr::shared_resource<detail::fixed_size_memory_resource_impl> {
   using shared_base = cuda::mr::shared_resource<detail::fixed_size_memory_resource_impl>;
 
  public:
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Equality comparison operator.
-   *
-   * @param other The other fixed_size_memory_resource to compare against.
-   * @return true if both resources share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(fixed_size_memory_resource const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Inequality comparison operator.
-   *
-   * @param other The other fixed_size_memory_resource to compare against.
-   * @return true if the resources do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(fixed_size_memory_resource const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    *
@@ -111,15 +79,6 @@ class RMM_EXPORT fixed_size_memory_resource
    * @return std::size_t size in bytes of allocated blocks.
    */
   [[nodiscard]] std::size_t get_block_size() const noexcept;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<fixed_size_memory_resource, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/limiting_resource_adaptor.hpp b/cpp/include/rmm/mr/limiting_resource_adaptor.hpp
index 8cd31fec8..2fa6a2c99 100644
--- a/cpp/include/rmm/mr/limiting_resource_adaptor.hpp
+++ b/cpp/include/rmm/mr/limiting_resource_adaptor.hpp
@@ -5,10 +5,8 @@
 #pragma once
 
 #include <rmm/aligned.hpp>
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/limiting_resource_adaptor_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -35,40 +33,10 @@ namespace mr {
  * `cuda::mr::shared_resource`.
  */
 class RMM_EXPORT limiting_resource_adaptor
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::limiting_resource_adaptor_impl> {
+  : public cuda::mr::shared_resource<detail::limiting_resource_adaptor_impl> {
   using shared_base = cuda::mr::shared_resource<detail::limiting_resource_adaptor_impl>;
 
  public:
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two adaptors for equality (shared-impl identity).
-   *
-   * @param other The other limiting_resource_adaptor to compare against.
-   * @return true if both adaptors share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(limiting_resource_adaptor const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two adaptors for inequality.
-   *
-   * @param other The other limiting_resource_adaptor to compare against.
-   * @return true if the adaptors do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(limiting_resource_adaptor const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -89,20 +57,6 @@ class RMM_EXPORT limiting_resource_adaptor
                             std::size_t allocation_limit,
                             std::size_t alignment = CUDA_ALLOCATION_ALIGNMENT);
 
-  /**
-   * @brief Construct a new limiting resource adaptor using `upstream` to satisfy
-   * allocation requests and limiting the total allocation amount possible.
-   *
-   * @throws rmm::logic_error if `upstream == nullptr`
-   *
-   * @param upstream The resource used for allocating/deallocating device memory
-   * @param allocation_limit Maximum memory allowed for this allocator
-   * @param alignment Alignment in bytes for the start of each allocated buffer
-   */
-  limiting_resource_adaptor(device_memory_resource* upstream,
-                            std::size_t allocation_limit,
-                            std::size_t alignment = CUDA_ALLOCATION_ALIGNMENT);
-
   ~limiting_resource_adaptor() = default;
 
   /**
@@ -129,15 +83,6 @@ class RMM_EXPORT limiting_resource_adaptor
    * @return std::size_t max number of bytes allowed for this allocator
    */
   [[nodiscard]] std::size_t get_allocation_limit() const;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<limiting_resource_adaptor, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/logging_resource_adaptor.hpp b/cpp/include/rmm/mr/logging_resource_adaptor.hpp
index 7bb3e6146..42fd63d57 100644
--- a/cpp/include/rmm/mr/logging_resource_adaptor.hpp
+++ b/cpp/include/rmm/mr/logging_resource_adaptor.hpp
@@ -4,11 +4,8 @@
  */
 #pragma once
 
-#include <rmm/cuda_stream_view.hpp>
-#include <rmm/detail/error.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/logging_resource_adaptor_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -38,40 +35,10 @@ namespace mr {
  * multiple instances to safely reference the same underlying resource and logger.
  */
 class RMM_EXPORT logging_resource_adaptor
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::logging_resource_adaptor_impl> {
+  : public cuda::mr::shared_resource<detail::logging_resource_adaptor_impl> {
   using shared_base = cuda::mr::shared_resource<detail::logging_resource_adaptor_impl>;
 
  public:
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Equality comparison operator.
-   *
-   * @param other The other logging_resource_adaptor to compare against.
-   * @return true if both adaptors share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(logging_resource_adaptor const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Inequality comparison operator.
-   *
-   * @param other The other logging_resource_adaptor to compare against.
-   * @return true if the adaptors do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(logging_resource_adaptor const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    *
@@ -163,15 +130,6 @@ class RMM_EXPORT logging_resource_adaptor
    * @return The value of RMM_LOG_FILE as `std::string`.
    */
   static std::string get_default_filename();
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<logging_resource_adaptor, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/managed_memory_resource.hpp b/cpp/include/rmm/mr/managed_memory_resource.hpp
index 27cb55757..9f972fa1e 100644
--- a/cpp/include/rmm/mr/managed_memory_resource.hpp
+++ b/cpp/include/rmm/mr/managed_memory_resource.hpp
@@ -5,11 +5,10 @@
 #pragma once
 
 #include <rmm/aligned.hpp>
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/error.hpp>
 #include <rmm/detail/export.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
+#include <cuda/memory_resource>
 #include <cuda/stream_ref>
 
 #include <cstddef>
@@ -22,13 +21,12 @@ namespace mr {
  * @file
  */
 /**
- * @brief `device_memory_resource` derived class that uses
- * cudaMallocManaged/Free for allocation/deallocation.
+ * @brief Memory resource that uses cudaMallocManaged/Free for allocation/deallocation.
  */
-class managed_memory_resource final : public device_memory_resource {
+class managed_memory_resource final {
  public:
   managed_memory_resource()                               = default;
-  ~managed_memory_resource() override                     = default;
+  ~managed_memory_resource()                              = default;
   managed_memory_resource(managed_memory_resource const&) = default;  ///< @default_copy_constructor
   managed_memory_resource(managed_memory_resource&&)      = default;  ///< @default_move_constructor
   managed_memory_resource& operator=(managed_memory_resource const&) =
@@ -91,8 +89,8 @@ class managed_memory_resource final : public device_memory_resource {
    */
   void* allocate_sync(std::size_t bytes, std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT)
   {
-    auto* ptr = allocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, bytes, alignment);
-    RMM_CUDA_TRY(cudaStreamSynchronize(reinterpret_cast<cudaStream_t>(0)));
+    auto* ptr = allocate(cuda::stream_ref{cudaStream_t{nullptr}}, bytes, alignment);
+    RMM_CUDA_TRY(cudaStreamSynchronize(cudaStream_t{nullptr}));
     return ptr;
   }
 
@@ -107,7 +105,7 @@ class managed_memory_resource final : public device_memory_resource {
                        std::size_t bytes,
                        std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT) noexcept
   {
-    deallocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, ptr, bytes, alignment);
+    deallocate(cuda::stream_ref{cudaStream_t{nullptr}}, ptr, bytes, alignment);
   }
 
   /**
@@ -130,22 +128,19 @@ class managed_memory_resource final : public device_memory_resource {
   {
   }
 
- private:
-  // -- Legacy device_memory_resource overrides (delegates to CCCL interface) --
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override
-  {
-    return allocate(stream, bytes);
-  }
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override
-  {
-    deallocate(stream, ptr, bytes);
-  }
+  /**
+   * @brief Compare this resource to another.
+   *
+   * All instances of managed_memory_resource are equivalent.
+   *
+   * @return true Always
+   */
+  [[nodiscard]] bool operator==(managed_memory_resource const&) const noexcept { return true; }
 
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override
-  {
-    return dynamic_cast<managed_memory_resource const*>(&other) != nullptr;
-  }
+  /**
+   * @copydoc operator==
+   */
+  [[nodiscard]] bool operator!=(managed_memory_resource const&) const noexcept { return false; }
 };
 
 // static property checks
diff --git a/cpp/include/rmm/mr/per_device_resource.hpp b/cpp/include/rmm/mr/per_device_resource.hpp
index 212e12f45..fd459b2a8 100644
--- a/cpp/include/rmm/mr/per_device_resource.hpp
+++ b/cpp/include/rmm/mr/per_device_resource.hpp
@@ -8,7 +8,6 @@
 #include <rmm/cuda_device.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/cuda_memory_resource.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -19,68 +18,14 @@
 
 /**
  * @file per_device_resource.hpp
- * @brief Management of per-device `device_memory_resource`s
+ * @brief Management of per-device memory resources
  *
- * One might wish to construct a `device_memory_resource` and use it for (de)allocation
- * without explicit dependency injection, i.e., passing a reference to that object to all places it
- * is to be used. Instead, one might want to set their resource as a "default" and have it be used
- * in all places where another resource has not been explicitly specified. In applications with
- * multiple GPUs in the same process, it may also be necessary to maintain independent default
- * resources for each device. To this end, the `set_per_device_resource` and
- * `get_per_device_resource` functions enable mapping a CUDA device id to a `device_memory_resource`
- * pointer.
+ * Provides functions to get/set the default `device_async_resource_ref` for each CUDA device.
+ * The initial resource for each device is a `cuda_memory_resource`.
  *
- * For example, given a pointer, `mr`, to a `device_memory_resource` object, calling
- * `set_per_device_resource(cuda_device_id{0}, mr)` will establish a mapping between CUDA device 0
- * and `mr` such that all future calls to `get_per_device_resource(cuda_device_id{0})` will return
- * the same pointer, `mr`. In this way, all places that use the resource returned from
- * `get_per_device_resource` for (de)allocation will use the user provided resource, `mr`.
- *
- * @note `device_memory_resource`s make CUDA API calls without setting the current CUDA device.
+ * @note Memory resources make CUDA API calls without setting the current CUDA device.
  * Therefore a memory resource should only be used with the current CUDA device set to the device
- * that was active when the memory resource was created. Calling `set_per_device_resource(id, mr)`
- * is only valid if `id` refers to the CUDA device that was active when `mr` was created.
- *
- * If no resource was explicitly set for a given device specified by `id`, then
- * `get_per_device_resource(id)` will return a pointer to a `cuda_memory_resource`.
- *
- * To fetch and modify the resource for the current CUDA device, `get_current_device_resource()` and
- * `set_current_device_resource()` automatically use the current CUDA device id from
- * `cudaGetDevice()`.
- *
- * RMM is in transition to use `cuda::mr::async_resource_ref` in place of raw pointers to
- * `device_memory_resource`. The `set_per_device_resource_ref`, `get_per_device_resource_ref`,
- * `get_current_device_resource_ref`, `set_current_device_resource_ref`, and
- * `reset_current_device_resource_ref` functions provide the same functionality as their
- * `device_memory_resource` counterparts, but with `device_async_resource_ref` objects. The raw
- * pointer versions and the `resource_ref` versions maintain distinc state and are not
- * interchangeable. The raw pointer versions are expected to be deprecated and removed in a future
- * release.
- *
- * Creating a device_memory_resource for each device requires care to set the current device
- * before creating each resource, and to maintain the lifetime of the resources as long as they
- * are set as per-device resources. Here is an example loop that creates `unique_ptr`s to
- * pool_memory_resource objects for each device and sets them as the per-device resource for that
- * device.
- *
- * @code{.cpp}
- * std::vector<unique_ptr<pool_memory_resource>> per_device_pools;
- * for(int i = 0; i < N; ++i) {
- *   cudaSetDevice(i);
- *   per_device_pools.push_back(std::make_unique<pool_memory_resource>());
- *   set_per_device_resource(cuda_device_id{i}, &per_device_pools.back());
- * }
- * @endcode
- * @code{.cpp}
- * using pool_mr = rmm::mr::pool_memory_resource;
- * std::vector<unique_ptr<pool_mr>> per_device_pools;
- * for(int i = 0; i < N; ++i) {
- *   cudaSetDevice(i);
- *   // Note: for brevity, omitting creation of upstream and computing initial_size
- *   per_device_pools.push_back(std::make_unique<pool_mr>(upstream, initial_size));
- *   set_per_device_resource(cuda_device_id{i}, &per_device_pools.back());
- * }
- * @endcode
+ * that was active when the memory resource was created.
  */
 
 namespace RMM_NAMESPACE {
@@ -102,34 +47,16 @@ namespace detail {
 // explicitly mark these functions as exported in case the namespace
 // export changes.
 /**
- * @brief Returns a pointer to the initial resource.
+ * @brief Returns a reference to the initial resource.
  *
  * Returns a global instance of a `cuda_memory_resource` as a function local static.
  *
- * @return Pointer to the static cuda_memory_resource used as the initial, default resource
+ * @return Reference to the static cuda_memory_resource used as the initial, default resource
  */
-RMM_EXPORT inline device_memory_resource* initial_resource()
+RMM_EXPORT inline cuda_memory_resource& initial_resource()
 {
   static cuda_memory_resource mr{};
-  return &mr;
-}
-
-/**
- * @briefreturn{Reference to the lock}
- */
-RMM_EXPORT inline std::mutex& map_lock()
-{
-  static std::mutex map_lock;
-  return map_lock;
-}
-
-/**
- * @briefreturn{Reference to the map from device id -> resource}
- */
-RMM_EXPORT inline auto& get_map()
-{
-  static std::map<cuda_device_id::value_type, device_memory_resource*> device_id_to_resource;
-  return device_id_to_resource;
+  return mr;
 }
 
 /**
@@ -154,163 +81,6 @@ RMM_EXPORT inline auto& get_ref_map()
 
 }  // namespace detail
 
-/**
- * @brief Get the resource for the specified device.
- *
- * Returns a pointer to the `device_memory_resource` for the specified device. The initial
- * resource is a `cuda_memory_resource`.
- *
- * `device_id.value()` must be in the range `[0, cudaGetDeviceCount())`, otherwise behavior is
- * undefined.
- *
- * This function is thread-safe with respect to concurrent calls to `set_per_device_resource`,
- * `get_per_device_resource`, `get_current_device_resource`, and `set_current_device_resource`.
- * Concurrent calls to any of these functions will result in a valid state, but the order of
- * execution is undefined.
- *
- * @note The returned `device_memory_resource` should only be used when CUDA device `device_id` is
- * the current device  (e.g. set using `cudaSetDevice()`). The behavior of a
- * `device_memory_resource` is undefined if used while the active CUDA device is a different device
- * from the one that was active when the `device_memory_resource` was created.
- *
- * @param device_id The id of the target device
- * @return Pointer to the current `device_memory_resource` for device `device_id`
- */
-inline device_memory_resource* get_per_device_resource(cuda_device_id device_id)
-{
-  std::lock_guard<std::mutex> lock{detail::map_lock()};
-  auto& map = detail::get_map();
-  // If a resource was never set for `id`, set to the initial resource
-  auto const found = map.find(device_id.value());
-  return (found == map.end()) ? (map[device_id.value()] = detail::initial_resource())
-                              : found->second;
-}
-
-namespace detail {
-
-// The non-thread-safe implementation of `set_per_device_resource_ref`. This exists because
-// we need to call this function from two places: the thread-safe version of
-// `set_per_device_resource_ref` and the thread-safe version of `set_per_device_resource`,
-// both of which take the lock, so we need an implementation that doesn't take the lock.
-/// @private
-inline cuda::mr::any_resource<cuda::mr::device_accessible> set_per_device_resource_ref_unsafe(
-  cuda_device_id device_id, device_async_resource_ref new_resource_ref)
-{
-  using any_device_resource = cuda::mr::any_resource<cuda::mr::device_accessible>;
-  auto& map                 = detail::get_ref_map();
-  auto const old_itr        = map.find(device_id.value());
-  // If a resource didn't previously exist for `device_id`, return owning copy of initial_resource
-  if (old_itr == map.end()) {
-    map.emplace(device_id.value(), static_cast<any_device_resource>(new_resource_ref));
-    return static_cast<any_device_resource>(device_async_resource_ref{*detail::initial_resource()});
-  }
-
-  return std::exchange(old_itr->second, static_cast<any_device_resource>(new_resource_ref));
-}
-}  // namespace detail
-
-/**
- * @brief Set the `device_memory_resource` for the specified device.
- *
- * If `new_mr` is not `nullptr`, sets the memory resource pointer for the device specified by `id`
- * to `new_mr`. Otherwise, resets `id`s resource to the initial `cuda_memory_resource`.
- *
- * `id.value()` must be in the range `[0, cudaGetDeviceCount())`, otherwise behavior is undefined.
- *
- * The object pointed to by `new_mr` must outlive the last use of the resource, otherwise behavior
- * is undefined. It is the caller's responsibility to maintain the lifetime of the resource
- * object.
- *
- * This function is thread-safe with respect to concurrent calls to `set_per_device_resource`,
- * `get_per_device_resource`, `get_current_device_resource`, and `set_current_device_resource`.
- * Concurrent calls to any of these functions will result in a valid state, but the order of
- * execution is undefined.
- *
- * @note The resource passed in `new_mr` must have been created when device `id` was the current
- * CUDA device (e.g. set using `cudaSetDevice()`). The behavior of a device_memory_resource is
- * undefined if used while the active CUDA device is a different device from the one that was active
- * when the device_memory_resource was created.
- *
- * @param device_id The id of the target device
- * @param new_mr If not `nullptr`, pointer to new `device_memory_resource` to use as new resource
- * for `id`
- * @return Pointer to the previous memory resource for `id`
- */
-inline device_memory_resource* set_per_device_resource(cuda_device_id device_id,
-                                                       device_memory_resource* new_mr)
-{
-  std::lock_guard<std::mutex> lock{detail::map_lock()};
-
-  // Note: even though set_per_device_resource() and set_per_device_resource_ref() are not
-  // interchangeable, we call the latter from the former to maintain resource_ref
-  // state consistent with the resource pointer state. This is necessary because the
-  // Python API still uses the raw pointer API. Once the Python API is updated to use
-  // resource_ref, this call can be removed.
-  if (new_mr != nullptr) { detail::set_per_device_resource_ref_unsafe(device_id, new_mr); }
-
-  auto& map          = detail::get_map();
-  auto const old_itr = map.find(device_id.value());
-  // If a resource didn't previously exist for `id`, return pointer to initial_resource
-  auto* old_mr           = (old_itr == map.end()) ? detail::initial_resource() : old_itr->second;
-  map[device_id.value()] = (new_mr == nullptr) ? detail::initial_resource() : new_mr;
-  return old_mr;
-}
-
-/**
- * @brief Get the memory resource for the current device.
- *
- * Returns a pointer to the resource set for the current device. The initial resource is a
- * `cuda_memory_resource`.
- *
- * The "current device" is the device returned by `cudaGetDevice`.
- *
- * This function is thread-safe with respect to concurrent calls to `set_per_device_resource`,
- * `get_per_device_resource`, `get_current_device_resource`, and `set_current_device_resource`.
- * Concurrent calls to any of these functions will result in a valid state, but the order of
- * execution is undefined.
- *
- * @note The returned `device_memory_resource` should only be used with the current CUDA device.
- * Changing the current device (e.g. using `cudaSetDevice()`) and then using the returned resource
- * can result in undefined behavior. The behavior of a device_memory_resource is undefined if used
- * while the active CUDA device is a different device from the one that was active when the
- * device_memory_resource was created.
- *
- * @return Pointer to the resource for the current device
- */
-inline device_memory_resource* get_current_device_resource()
-{
-  return get_per_device_resource(rmm::get_current_cuda_device());
-}
-
-/**
- * @brief Set the memory resource for the current device.
- *
- * If `new_mr` is not `nullptr`, sets the resource pointer for the current device to
- * `new_mr`. Otherwise, resets the resource to the initial `cuda_memory_resource`.
- *
- * The "current device" is the device returned by `cudaGetDevice`.
- *
- * The object pointed to by `new_mr` must outlive the last use of the resource, otherwise behavior
- * is undefined. It is the caller's responsibility to maintain the lifetime of the resource
- * object.
- *
- * This function is thread-safe with respect to concurrent calls to `set_per_device_resource`,
- * `get_per_device_resource`, `get_current_device_resource`, and `set_current_device_resource`.
- * Concurrent calls to any of these functions will result in a valid state, but the order of
- * execution is undefined.
- *
- * @note The resource passed in `new_mr` must have been created for the current CUDA device. The
- * behavior of a device_memory_resource is undefined if used while the active CUDA device is a
- * different device from the one that was active when the device_memory_resource was created.
- *
- * @param new_mr If not `nullptr`, pointer to new resource to use for the current device
- * @return Pointer to the previous resource for the current device
- */
-inline device_memory_resource* set_current_device_resource(device_memory_resource* new_mr)
-{
-  return set_per_device_resource(rmm::get_current_cuda_device(), new_mr);
-}
-
 /**
  * @brief Get the `device_async_resource_ref` for the specified device.
  *
@@ -342,7 +112,7 @@ inline device_async_resource_ref get_per_device_resource_ref(cuda_device_id devi
   auto const found = map.find(device_id.value());
   if (found == map.end()) {
     // Create a resource_ref from the initial resource, then reify it to any_resource
-    device_async_resource_ref initial_ref{*detail::initial_resource()};
+    device_async_resource_ref initial_ref{detail::initial_resource()};
     auto item = map.emplace(device_id.value(), static_cast<any_device_resource>(initial_ref));
     return device_async_resource_ref{item.first->second};
   }
@@ -376,8 +146,15 @@ inline device_async_resource_ref get_per_device_resource_ref(cuda_device_id devi
 inline cuda::mr::any_resource<cuda::mr::device_accessible> set_per_device_resource_ref(
   cuda_device_id device_id, device_async_resource_ref new_resource_ref)
 {
+  using any_device_resource = cuda::mr::any_resource<cuda::mr::device_accessible>;
   std::lock_guard<std::mutex> lock{detail::ref_map_lock()};
-  return detail::set_per_device_resource_ref_unsafe(device_id, new_resource_ref);
+  auto& map          = detail::get_ref_map();
+  auto const old_itr = map.find(device_id.value());
+  if (old_itr == map.end()) {
+    map.emplace(device_id.value(), static_cast<any_device_resource>(new_resource_ref));
+    return static_cast<any_device_resource>(device_async_resource_ref{detail::initial_resource()});
+  }
+  return std::exchange(old_itr->second, static_cast<any_device_resource>(new_resource_ref));
 }
 
 /**
@@ -453,7 +230,7 @@ inline cuda::mr::any_resource<cuda::mr::device_accessible> set_current_device_re
 inline cuda::mr::any_resource<cuda::mr::device_accessible> reset_per_device_resource_ref(
   cuda_device_id device_id)
 {
-  return set_per_device_resource_ref(device_id, *detail::initial_resource());
+  return set_per_device_resource_ref(device_id, detail::initial_resource());
 }
 
 /**
diff --git a/cpp/include/rmm/mr/pinned_host_memory_resource.hpp b/cpp/include/rmm/mr/pinned_host_memory_resource.hpp
index 1ba9dc55d..d9fa48fc1 100644
--- a/cpp/include/rmm/mr/pinned_host_memory_resource.hpp
+++ b/cpp/include/rmm/mr/pinned_host_memory_resource.hpp
@@ -6,12 +6,10 @@
 
 #include <rmm/aligned.hpp>
 #include <rmm/detail/aligned.hpp>
-#include <rmm/detail/cccl_adaptors.hpp>
 #include <rmm/detail/error.hpp>
 #include <rmm/detail/export.hpp>
-#include <rmm/detail/nvtx/ranges.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
+#include <cuda/memory_resource>
 #include <cuda/stream_ref>
 #include <cuda_runtime_api.h>
 
@@ -33,10 +31,10 @@ namespace mr {
  * `cuda::mr::memory_resource` and `cuda::mr::device_memory_resource` concepts, and
  * the `cuda::mr::host_accessible` and `cuda::mr::device_accessible` properties.
  */
-class pinned_host_memory_resource final : public device_memory_resource {
+class pinned_host_memory_resource final {
  public:
-  pinned_host_memory_resource()           = default;
-  ~pinned_host_memory_resource() override = default;
+  pinned_host_memory_resource()  = default;
+  ~pinned_host_memory_resource() = default;
   pinned_host_memory_resource(pinned_host_memory_resource const&) =
     default;  ///< @default_copy_constructor
   pinned_host_memory_resource(pinned_host_memory_resource&&) =
@@ -112,8 +110,8 @@ class pinned_host_memory_resource final : public device_memory_resource {
    */
   void* allocate_sync(std::size_t bytes, std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT)
   {
-    auto* ptr = allocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, bytes, alignment);
-    RMM_CUDA_TRY(cudaStreamSynchronize(reinterpret_cast<cudaStream_t>(0)));
+    auto* ptr = allocate(cuda::stream_ref{cudaStream_t{nullptr}}, bytes, alignment);
+    RMM_CUDA_TRY(cudaStreamSynchronize(cudaStream_t{nullptr}));
     return ptr;
   }
 
@@ -128,7 +126,7 @@ class pinned_host_memory_resource final : public device_memory_resource {
                        std::size_t bytes,
                        std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT) noexcept
   {
-    deallocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, ptr, bytes, alignment);
+    deallocate(cuda::stream_ref{cudaStream_t{nullptr}}, ptr, bytes, alignment);
   }
 
   /**
@@ -151,22 +149,19 @@ class pinned_host_memory_resource final : public device_memory_resource {
   {
   }
 
- private:
-  // -- Legacy device_memory_resource overrides (delegates to CCCL interface) --
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override
-  {
-    return allocate(stream, bytes);
-  }
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override
-  {
-    deallocate(stream, ptr, bytes);
-  }
+  /**
+   * @brief Compare this resource to another.
+   *
+   * All instances of pinned_host_memory_resource are equivalent.
+   *
+   * @return true Always
+   */
+  [[nodiscard]] bool operator==(pinned_host_memory_resource const&) const noexcept { return true; }
 
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override
-  {
-    return dynamic_cast<pinned_host_memory_resource const*>(&other) != nullptr;
-  }
+  /**
+   * @copydoc operator==
+   */
+  [[nodiscard]] bool operator!=(pinned_host_memory_resource const&) const noexcept { return false; }
 };
 
 // static property checks
diff --git a/cpp/include/rmm/mr/pool_memory_resource.hpp b/cpp/include/rmm/mr/pool_memory_resource.hpp
index aebfbba83..7fdd69170 100644
--- a/cpp/include/rmm/mr/pool_memory_resource.hpp
+++ b/cpp/include/rmm/mr/pool_memory_resource.hpp
@@ -4,10 +4,8 @@
  */
 #pragma once
 
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/pool_memory_resource_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -34,40 +32,10 @@ namespace mr {
  * multiple instances to safely reference the same underlying pool.
  */
 class RMM_EXPORT pool_memory_resource
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::pool_memory_resource_impl> {
+  : public cuda::mr::shared_resource<detail::pool_memory_resource_impl> {
   using shared_base = cuda::mr::shared_resource<detail::pool_memory_resource_impl>;
 
  public:
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Equality comparison operator.
-   *
-   * @param other The other pool_memory_resource to compare against.
-   * @return true if both resources share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(pool_memory_resource const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Inequality comparison operator.
-   *
-   * @param other The other pool_memory_resource to compare against.
-   * @return true if the resources do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(pool_memory_resource const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    *
@@ -108,15 +76,6 @@ class RMM_EXPORT pool_memory_resource
    * @return std::size_t The total size of the currently allocated pool.
    */
   [[nodiscard]] std::size_t pool_size() const noexcept;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<pool_memory_resource, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/prefetch_resource_adaptor.hpp b/cpp/include/rmm/mr/prefetch_resource_adaptor.hpp
index 3e51c1b7b..e7d59a232 100644
--- a/cpp/include/rmm/mr/prefetch_resource_adaptor.hpp
+++ b/cpp/include/rmm/mr/prefetch_resource_adaptor.hpp
@@ -4,10 +4,8 @@
  */
 #pragma once
 
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/prefetch_resource_adaptor_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -28,40 +26,10 @@ namespace mr {
  * `cuda::mr::shared_resource`.
  */
 class RMM_EXPORT prefetch_resource_adaptor
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::prefetch_resource_adaptor_impl> {
+  : public cuda::mr::shared_resource<detail::prefetch_resource_adaptor_impl> {
   using shared_base = cuda::mr::shared_resource<detail::prefetch_resource_adaptor_impl>;
 
  public:
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two adaptors for equality (shared-impl identity).
-   *
-   * @param other The other prefetch_resource_adaptor to compare against.
-   * @return true if both adaptors share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(prefetch_resource_adaptor const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two adaptors for inequality.
-   *
-   * @param other The other prefetch_resource_adaptor to compare against.
-   * @return true if the adaptors do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(prefetch_resource_adaptor const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -84,15 +52,6 @@ class RMM_EXPORT prefetch_resource_adaptor
    * @briefreturn{rmm::device_async_resource_ref to the upstream resource}
    */
   [[nodiscard]] device_async_resource_ref get_upstream_resource() const noexcept;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<prefetch_resource_adaptor, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/sam_headroom_memory_resource.hpp b/cpp/include/rmm/mr/sam_headroom_memory_resource.hpp
index 50291a86d..33c5a15d2 100644
--- a/cpp/include/rmm/mr/sam_headroom_memory_resource.hpp
+++ b/cpp/include/rmm/mr/sam_headroom_memory_resource.hpp
@@ -5,10 +5,8 @@
 #pragma once
 
 #include <rmm/aligned.hpp>
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/sam_headroom_memory_resource_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
 #include <cuda/memory_resource>
 
@@ -35,40 +33,10 @@ namespace mr {
  * large allocations only.
  */
 class RMM_EXPORT sam_headroom_memory_resource final
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::sam_headroom_memory_resource_impl> {
+  : public cuda::mr::shared_resource<detail::sam_headroom_memory_resource_impl> {
   using shared_base = cuda::mr::shared_resource<detail::sam_headroom_memory_resource_impl>;
 
  public:
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two resources for equality (shared-impl identity).
-   *
-   * @param other The other sam_headroom_memory_resource to compare against.
-   * @return true if both resources share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(sam_headroom_memory_resource const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two resources for inequality.
-   *
-   * @param other The other sam_headroom_memory_resource to compare against.
-   * @return true if the resources do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(sam_headroom_memory_resource const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -92,21 +60,16 @@ class RMM_EXPORT sam_headroom_memory_resource final
    */
   explicit sam_headroom_memory_resource(std::size_t headroom);
 
-  sam_headroom_memory_resource()                                               = delete;
-  ~sam_headroom_memory_resource()                                              = default;
-  sam_headroom_memory_resource(sam_headroom_memory_resource const&)            = delete;
-  sam_headroom_memory_resource(sam_headroom_memory_resource&&)                 = delete;
-  sam_headroom_memory_resource& operator=(sam_headroom_memory_resource const&) = delete;
-  sam_headroom_memory_resource& operator=(sam_headroom_memory_resource&&)      = delete;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
+  sam_headroom_memory_resource()  = delete;
+  ~sam_headroom_memory_resource() = default;
+  sam_headroom_memory_resource(sam_headroom_memory_resource const&) =
+    default;  ///< @default_copy_constructor
+  sam_headroom_memory_resource(sam_headroom_memory_resource&&) =
+    default;  ///< @default_move_constructor
+  sam_headroom_memory_resource& operator=(sam_headroom_memory_resource const&) =
+    default;  ///< @default_copy_assignment{sam_headroom_memory_resource}
+  sam_headroom_memory_resource& operator=(sam_headroom_memory_resource&&) =
+    default;  ///< @default_move_assignment{sam_headroom_memory_resource}
 };
 
 // static property checks
diff --git a/cpp/include/rmm/mr/statistics_resource_adaptor.hpp b/cpp/include/rmm/mr/statistics_resource_adaptor.hpp
index d18ac993d..e6bd7c6b5 100644
--- a/cpp/include/rmm/mr/statistics_resource_adaptor.hpp
+++ b/cpp/include/rmm/mr/statistics_resource_adaptor.hpp
@@ -4,10 +4,8 @@
  */
 #pragma once
 
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/statistics_resource_adaptor_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -32,8 +30,7 @@ namespace mr {
  * `cuda::mr::shared_resource`.
  */
 class RMM_EXPORT statistics_resource_adaptor
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::statistics_resource_adaptor_impl> {
+  : public cuda::mr::shared_resource<detail::statistics_resource_adaptor_impl> {
   using shared_base = cuda::mr::shared_resource<detail::statistics_resource_adaptor_impl>;
 
  public:
@@ -44,35 +41,6 @@ class RMM_EXPORT statistics_resource_adaptor
   /// @brief Exclusive-writer lock type used to protect the counter stack.
   using write_lock_t = detail::statistics_resource_adaptor_impl::write_lock_t;
 
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two adaptors for equality (shared-impl identity).
-   *
-   * @param other The other adaptor to compare against.
-   * @return true if both adaptors share the same underlying impl.
-   */
-  [[nodiscard]] bool operator==(statistics_resource_adaptor const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two adaptors for inequality.
-   *
-   * @param other The other adaptor to compare against.
-   * @return true if the adaptors do not share the same underlying impl.
-   */
-  [[nodiscard]] bool operator!=(statistics_resource_adaptor const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -123,15 +91,6 @@ class RMM_EXPORT statistics_resource_adaptor
    * @throws std::out_of_range if the counter stack has fewer than two entries
    */
   std::pair<counter, counter> pop_counters();
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<statistics_resource_adaptor, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/system_memory_resource.hpp b/cpp/include/rmm/mr/system_memory_resource.hpp
index 9a6c11060..6156c71e3 100644
--- a/cpp/include/rmm/mr/system_memory_resource.hpp
+++ b/cpp/include/rmm/mr/system_memory_resource.hpp
@@ -6,13 +6,12 @@
 
 #include <rmm/aligned.hpp>
 #include <rmm/cuda_device.hpp>
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/aligned.hpp>
 #include <rmm/detail/error.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/detail/format.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 
+#include <cuda/memory_resource>
 #include <cuda/stream_ref>
 #include <cuda_runtime_api.h>
 
@@ -45,7 +44,7 @@ static bool is_system_memory_supported(cuda_device_id device_id)
  * @file
  */
 /**
- * @brief `device_memory_resource` derived class that uses malloc/free for allocation/deallocation.
+ * @brief Memory resource that uses malloc/free for allocation/deallocation.
  *
  * There are two flavors of hardware/software environments that support accessing system allocated
  * memory (SAM) from the GPU: HMM and ATS.
@@ -66,14 +65,14 @@ static bool is_system_memory_supported(cuda_device_id device_id)
  *  more information, see
  *  https://developer.nvidia.com/blog/nvidia-grace-hopper-superchip-architecture-in-depth/.
  */
-class system_memory_resource final : public device_memory_resource {
+class system_memory_resource final {
  public:
   system_memory_resource()
   {
     RMM_EXPECTS(rmm::mr::detail::is_system_memory_supported(rmm::get_current_cuda_device()),
                 "System memory allocator is not supported with this hardware/software version.");
   }
-  ~system_memory_resource() override                    = default;
+  ~system_memory_resource()                             = default;
   system_memory_resource(system_memory_resource const&) = default;  ///< @default_copy_constructor
   system_memory_resource(system_memory_resource&&)      = default;  ///< @default_copy_constructor
   system_memory_resource& operator=(system_memory_resource const&) =
@@ -144,8 +143,8 @@ class system_memory_resource final : public device_memory_resource {
    */
   void* allocate_sync(std::size_t bytes, std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT)
   {
-    auto* ptr = allocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, bytes, alignment);
-    RMM_CUDA_TRY(cudaStreamSynchronize(reinterpret_cast<cudaStream_t>(0)));
+    auto* ptr = allocate(cuda::stream_ref{cudaStream_t{nullptr}}, bytes, alignment);
+    RMM_CUDA_TRY(cudaStreamSynchronize(cudaStream_t{nullptr}));
     return ptr;
   }
 
@@ -160,7 +159,7 @@ class system_memory_resource final : public device_memory_resource {
                        std::size_t bytes,
                        std::size_t alignment = rmm::CUDA_ALLOCATION_ALIGNMENT) noexcept
   {
-    deallocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, ptr, bytes, alignment);
+    deallocate(cuda::stream_ref{cudaStream_t{nullptr}}, ptr, bytes, alignment);
   }
 
   /**
@@ -183,22 +182,19 @@ class system_memory_resource final : public device_memory_resource {
   {
   }
 
- private:
-  // -- Legacy device_memory_resource overrides (delegates to CCCL interface) --
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override
-  {
-    return allocate(stream, bytes);
-  }
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override
-  {
-    deallocate(stream, ptr, bytes);
-  }
+  /**
+   * @brief Compare this resource to another.
+   *
+   * All instances of system_memory_resource are equivalent.
+   *
+   * @return true Always
+   */
+  [[nodiscard]] bool operator==(system_memory_resource const&) const noexcept { return true; }
 
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override
-  {
-    return dynamic_cast<system_memory_resource const*>(&other) != nullptr;
-  }
+  /**
+   * @copydoc operator==
+   */
+  [[nodiscard]] bool operator!=(system_memory_resource const&) const noexcept { return false; }
 };
 
 // static property checks
diff --git a/cpp/include/rmm/mr/thread_safe_resource_adaptor.hpp b/cpp/include/rmm/mr/thread_safe_resource_adaptor.hpp
index d6c050c1e..e19f51cec 100644
--- a/cpp/include/rmm/mr/thread_safe_resource_adaptor.hpp
+++ b/cpp/include/rmm/mr/thread_safe_resource_adaptor.hpp
@@ -4,10 +4,8 @@
  */
 #pragma once
 
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/thread_safe_resource_adaptor_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -33,42 +31,12 @@ namespace mr {
  * `cuda::mr::shared_resource`.
  */
 class RMM_EXPORT thread_safe_resource_adaptor
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::thread_safe_resource_adaptor_impl> {
+  : public cuda::mr::shared_resource<detail::thread_safe_resource_adaptor_impl> {
   using shared_base = cuda::mr::shared_resource<detail::thread_safe_resource_adaptor_impl>;
 
  public:
   using lock_t = std::lock_guard<std::mutex>;  ///< Type of lock used to synchronize access
 
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two adaptors for equality (shared-impl identity).
-   *
-   * @param other The other thread_safe_resource_adaptor to compare against.
-   * @return true if both adaptors share the same underlying state.
-   */
-  [[nodiscard]] bool operator==(thread_safe_resource_adaptor const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two adaptors for inequality.
-   *
-   * @param other The other thread_safe_resource_adaptor to compare against.
-   * @return true if the adaptors do not share the same underlying state.
-   */
-  [[nodiscard]] bool operator!=(thread_safe_resource_adaptor const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -91,15 +59,6 @@ class RMM_EXPORT thread_safe_resource_adaptor
    * @briefreturn{rmm::device_async_resource_ref to the upstream resource}
    */
   [[nodiscard]] device_async_resource_ref get_upstream_resource() const noexcept;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<thread_safe_resource_adaptor, cuda::mr::device_accessible>,
diff --git a/cpp/include/rmm/mr/tracking_resource_adaptor.hpp b/cpp/include/rmm/mr/tracking_resource_adaptor.hpp
index 35ab8e0a7..ae5fedadd 100644
--- a/cpp/include/rmm/mr/tracking_resource_adaptor.hpp
+++ b/cpp/include/rmm/mr/tracking_resource_adaptor.hpp
@@ -4,10 +4,8 @@
  */
 #pragma once
 
-#include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/export.hpp>
 #include <rmm/mr/detail/tracking_resource_adaptor_impl.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/resource_ref.hpp>
 
 #include <cuda/memory_resource>
@@ -34,8 +32,7 @@ namespace mr {
  * `cuda::mr::shared_resource`.
  */
 class RMM_EXPORT tracking_resource_adaptor
-  : public device_memory_resource,
-    private cuda::mr::shared_resource<detail::tracking_resource_adaptor_impl> {
+  : public cuda::mr::shared_resource<detail::tracking_resource_adaptor_impl> {
   using shared_base = cuda::mr::shared_resource<detail::tracking_resource_adaptor_impl>;
 
  public:
@@ -46,35 +43,6 @@ class RMM_EXPORT tracking_resource_adaptor
   /// @brief Exclusive-writer lock type used to protect the allocations map.
   using write_lock_t = detail::tracking_resource_adaptor_impl::write_lock_t;
 
-  // Begin legacy device_memory_resource compatibility layer
-  using device_memory_resource::allocate;
-  using device_memory_resource::allocate_sync;
-  using device_memory_resource::deallocate;
-  using device_memory_resource::deallocate_sync;
-
-  /**
-   * @brief Compare two adaptors for equality (shared-impl identity).
-   *
-   * @param other The other adaptor to compare against.
-   * @return true if both adaptors share the same underlying impl.
-   */
-  [[nodiscard]] bool operator==(tracking_resource_adaptor const& other) const noexcept
-  {
-    return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(other);
-  }
-
-  /**
-   * @brief Compare two adaptors for inequality.
-   *
-   * @param other The other adaptor to compare against.
-   * @return true if the adaptors do not share the same underlying impl.
-   */
-  [[nodiscard]] bool operator!=(tracking_resource_adaptor const& other) const noexcept
-  {
-    return !(*this == other);
-  }
-  // End legacy device_memory_resource compatibility layer
-
   /**
    * @brief Enables the `cuda::mr::device_accessible` property
    */
@@ -124,15 +92,6 @@ class RMM_EXPORT tracking_resource_adaptor
    * @brief Log any outstanding allocations via RMM_LOG_DEBUG.
    */
   void log_outstanding_allocations() const;
-
-  // Begin legacy device_memory_resource compatibility layer
- private:
-  void* do_allocate(std::size_t bytes, cuda_stream_view stream) override;
-
-  void do_deallocate(void* ptr, std::size_t bytes, cuda_stream_view stream) noexcept override;
-
-  [[nodiscard]] bool do_is_equal(device_memory_resource const& other) const noexcept override;
-  // End legacy device_memory_resource compatibility layer
 };
 
 static_assert(cuda::mr::resource_with<tracking_resource_adaptor, cuda::mr::device_accessible>,
diff --git a/cpp/src/cuda_stream.cpp b/cpp/src/cuda_stream.cpp
index 7fb959843..98fd09722 100644
--- a/cpp/src/cuda_stream.cpp
+++ b/cpp/src/cuda_stream.cpp
@@ -42,6 +42,8 @@ cuda_stream_view cuda_stream::view() const { return cuda_stream_view{value()}; }
 
 cuda_stream::operator cuda_stream_view() const { return view(); }
 
+cuda_stream::operator cuda::stream_ref() const { return cuda::stream_ref{value()}; }
+
 void cuda_stream::synchronize() const { RMM_CUDA_TRY(cudaStreamSynchronize(value())); }
 
 void cuda_stream::synchronize_no_throw() const noexcept
diff --git a/cpp/src/mr/aligned_resource_adaptor.cpp b/cpp/src/mr/aligned_resource_adaptor.cpp
index b500b30e9..1fd88a1fb 100644
--- a/cpp/src/mr/aligned_resource_adaptor.cpp
+++ b/cpp/src/mr/aligned_resource_adaptor.cpp
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/mr/aligned_resource_adaptor.hpp>
 
 #include <cstddef>
@@ -24,27 +23,5 @@ device_async_resource_ref aligned_resource_adaptor::get_upstream_resource() cons
   return get().get_upstream_resource();
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* aligned_resource_adaptor::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void aligned_resource_adaptor::do_deallocate(void* ptr,
-                                             std::size_t bytes,
-                                             cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool aligned_resource_adaptor::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<aligned_resource_adaptor const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/arena_memory_resource.cpp b/cpp/src/mr/arena_memory_resource.cpp
index c9d418228..f7060c43a 100644
--- a/cpp/src/mr/arena_memory_resource.cpp
+++ b/cpp/src/mr/arena_memory_resource.cpp
@@ -16,27 +16,5 @@ arena_memory_resource::arena_memory_resource(device_async_resource_ref upstream_
 {
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* arena_memory_resource::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void arena_memory_resource::do_deallocate(void* ptr,
-                                          std::size_t bytes,
-                                          cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool arena_memory_resource::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<arena_memory_resource const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/binning_memory_resource.cpp b/cpp/src/mr/binning_memory_resource.cpp
index 147f998e4..a04130a6e 100644
--- a/cpp/src/mr/binning_memory_resource.cpp
+++ b/cpp/src/mr/binning_memory_resource.cpp
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/mr/binning_memory_resource.hpp>
 
 #include <cstddef>
@@ -36,27 +35,5 @@ void binning_memory_resource::add_bin(std::size_t allocation_size,
   get().add_bin(allocation_size, bin_resource);
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* binning_memory_resource::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void binning_memory_resource::do_deallocate(void* ptr,
-                                            std::size_t bytes,
-                                            cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool binning_memory_resource::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<binning_memory_resource const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/callback_memory_resource.cpp b/cpp/src/mr/callback_memory_resource.cpp
index e192d55d0..fe1159425 100644
--- a/cpp/src/mr/callback_memory_resource.cpp
+++ b/cpp/src/mr/callback_memory_resource.cpp
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/mr/callback_memory_resource.hpp>
 #include <rmm/mr/detail/callback_memory_resource_impl.hpp>
 
@@ -24,27 +23,5 @@ callback_memory_resource::callback_memory_resource(allocate_callback_t allocate_
 {
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* callback_memory_resource::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void callback_memory_resource::do_deallocate(void* ptr,
-                                             std::size_t bytes,
-                                             cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool callback_memory_resource::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<callback_memory_resource const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/cuda_async_managed_memory_resource.cpp b/cpp/src/mr/cuda_async_managed_memory_resource.cpp
index 008cdbd77..421c33b40 100644
--- a/cpp/src/mr/cuda_async_managed_memory_resource.cpp
+++ b/cpp/src/mr/cuda_async_managed_memory_resource.cpp
@@ -3,12 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/detail/error.hpp>
 #include <rmm/mr/cuda_async_managed_memory_resource.hpp>
 
-#include <cuda/memory_resource>
-
 namespace RMM_NAMESPACE {
 namespace mr {
 
@@ -22,28 +19,5 @@ cudaMemPool_t cuda_async_managed_memory_resource::pool_handle() const noexcept
   return get().pool_handle();
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* cuda_async_managed_memory_resource::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void cuda_async_managed_memory_resource::do_deallocate(void* ptr,
-                                                       std::size_t bytes,
-                                                       cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool cuda_async_managed_memory_resource::do_is_equal(
-  device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<cuda_async_managed_memory_resource const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/cuda_async_memory_resource.cpp b/cpp/src/mr/cuda_async_memory_resource.cpp
index 2bf38eda0..fe2c28b40 100644
--- a/cpp/src/mr/cuda_async_memory_resource.cpp
+++ b/cpp/src/mr/cuda_async_memory_resource.cpp
@@ -3,13 +3,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/detail/error.hpp>
 #include <rmm/detail/runtime_capabilities.hpp>
 #include <rmm/mr/cuda_async_memory_resource.hpp>
 
-#include <cuda/memory_resource>
-
 namespace RMM_NAMESPACE {
 namespace mr {
 
@@ -32,27 +29,5 @@ cudaMemPool_t cuda_async_memory_resource::pool_handle() const noexcept
   return get().pool_handle();
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* cuda_async_memory_resource::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void cuda_async_memory_resource::do_deallocate(void* ptr,
-                                               std::size_t bytes,
-                                               cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool cuda_async_memory_resource::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<cuda_async_memory_resource const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/detail/arena_memory_resource_impl.cpp b/cpp/src/mr/detail/arena_memory_resource_impl.cpp
index b042fa83f..73d80c86a 100644
--- a/cpp/src/mr/detail/arena_memory_resource_impl.cpp
+++ b/cpp/src/mr/detail/arena_memory_resource_impl.cpp
@@ -31,7 +31,7 @@ void* arena_memory_resource_impl::allocate(cuda::stream_ref stream,
                                            std::size_t bytes,
                                            std::size_t /*alignment*/)
 {
-  if (bytes <= 0) { return nullptr; }
+  if (bytes == 0) { return nullptr; }
   cuda_stream_view sv{stream.get()};
 #ifdef RMM_ARENA_USE_SIZE_CLASSES
   bytes = rmm::mr::detail::arena::align_to_size_class(bytes);
@@ -65,7 +65,7 @@ void arena_memory_resource_impl::deallocate(cuda::stream_ref stream,
                                             std::size_t bytes,
                                             std::size_t /*alignment*/) noexcept
 {
-  if (ptr == nullptr || bytes <= 0) { return; }
+  if (ptr == nullptr || bytes == 0) { return; }
   cuda_stream_view sv{stream.get()};
 #ifdef RMM_ARENA_USE_SIZE_CLASSES
   bytes = rmm::mr::detail::arena::align_to_size_class(bytes);
diff --git a/cpp/src/mr/detail/binning_memory_resource_impl.cpp b/cpp/src/mr/detail/binning_memory_resource_impl.cpp
index 60211380e..d65768daa 100644
--- a/cpp/src/mr/detail/binning_memory_resource_impl.cpp
+++ b/cpp/src/mr/detail/binning_memory_resource_impl.cpp
@@ -63,7 +63,7 @@ void* binning_memory_resource_impl::allocate(cuda::stream_ref stream,
                                              std::size_t bytes,
                                              std::size_t alignment)
 {
-  if (bytes <= 0) { return nullptr; }
+  if (bytes == 0) { return nullptr; }
   return get_resource_ref(bytes).allocate(stream, bytes, alignment);
 }
 
@@ -77,7 +77,7 @@ void binning_memory_resource_impl::deallocate(cuda::stream_ref stream,
 
 void* binning_memory_resource_impl::allocate_sync(std::size_t bytes, std::size_t alignment)
 {
-  if (bytes <= 0) { return nullptr; }
+  if (bytes == 0) { return nullptr; }
   return get_resource_ref(bytes).allocate(cuda_stream_view{}, bytes, alignment);
 }
 
diff --git a/cpp/src/mr/detail/cuda_async_managed_memory_resource_impl.cpp b/cpp/src/mr/detail/cuda_async_managed_memory_resource_impl.cpp
index 8ff039e1f..86d39a335 100644
--- a/cpp/src/mr/detail/cuda_async_managed_memory_resource_impl.cpp
+++ b/cpp/src/mr/detail/cuda_async_managed_memory_resource_impl.cpp
@@ -57,8 +57,8 @@ void cuda_async_managed_memory_resource_impl::deallocate(cuda::stream_ref stream
 void* cuda_async_managed_memory_resource_impl::allocate_sync(std::size_t bytes,
                                                              std::size_t alignment)
 {
-  auto* ptr = allocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, bytes, alignment);
-  RMM_CUDA_TRY(cudaStreamSynchronize(reinterpret_cast<cudaStream_t>(0)));
+  auto* ptr = allocate(cuda::stream_ref{cudaStream_t{nullptr}}, bytes, alignment);
+  RMM_CUDA_TRY(cudaStreamSynchronize(cudaStream_t{nullptr}));
   return ptr;
 }
 
@@ -66,7 +66,7 @@ void cuda_async_managed_memory_resource_impl::deallocate_sync(void* ptr,
                                                               std::size_t bytes,
                                                               std::size_t alignment) noexcept
 {
-  deallocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, ptr, bytes, alignment);
+  deallocate(cuda::stream_ref{cudaStream_t{nullptr}}, ptr, bytes, alignment);
 }
 
 }  // namespace detail
diff --git a/cpp/src/mr/detail/cuda_async_memory_resource_impl.cpp b/cpp/src/mr/detail/cuda_async_memory_resource_impl.cpp
index 8c5be28e1..48f5dad03 100644
--- a/cpp/src/mr/detail/cuda_async_memory_resource_impl.cpp
+++ b/cpp/src/mr/detail/cuda_async_memory_resource_impl.cpp
@@ -59,8 +59,8 @@ cuda_async_memory_resource_impl::cuda_async_memory_resource_impl(
   // specified size (only if initial_pool_size is provided)
   if (initial_pool_size.has_value()) {
     auto const pool_size = initial_pool_size.value();
-    auto* ptr            = allocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, pool_size);
-    deallocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, ptr, pool_size);
+    auto* ptr            = allocate(cuda::stream_ref{cudaStream_t{nullptr}}, pool_size);
+    deallocate(cuda::stream_ref{cudaStream_t{nullptr}}, ptr, pool_size);
   }
 }
 
@@ -91,8 +91,8 @@ void cuda_async_memory_resource_impl::deallocate(cuda::stream_ref stream,
 
 void* cuda_async_memory_resource_impl::allocate_sync(std::size_t bytes, std::size_t alignment)
 {
-  auto* ptr = allocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, bytes, alignment);
-  RMM_CUDA_TRY(cudaStreamSynchronize(reinterpret_cast<cudaStream_t>(0)));
+  auto* ptr = allocate(cuda::stream_ref{cudaStream_t{nullptr}}, bytes, alignment);
+  RMM_CUDA_TRY(cudaStreamSynchronize(cudaStream_t{nullptr}));
   return ptr;
 }
 
@@ -100,7 +100,7 @@ void cuda_async_memory_resource_impl::deallocate_sync(void* ptr,
                                                       std::size_t bytes,
                                                       std::size_t alignment) noexcept
 {
-  deallocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, ptr, bytes, alignment);
+  deallocate(cuda::stream_ref{cudaStream_t{nullptr}}, ptr, bytes, alignment);
 }
 
 }  // namespace detail
diff --git a/cpp/src/mr/detail/sam_headroom_memory_resource_impl.cpp b/cpp/src/mr/detail/sam_headroom_memory_resource_impl.cpp
index e3e0ccf4c..0f1d180e6 100644
--- a/cpp/src/mr/detail/sam_headroom_memory_resource_impl.cpp
+++ b/cpp/src/mr/detail/sam_headroom_memory_resource_impl.cpp
@@ -74,8 +74,8 @@ void sam_headroom_memory_resource_impl::deallocate(cuda::stream_ref stream,
 
 void* sam_headroom_memory_resource_impl::allocate_sync(std::size_t bytes, std::size_t alignment)
 {
-  auto* ptr = allocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, bytes, alignment);
-  RMM_CUDA_TRY(cudaStreamSynchronize(reinterpret_cast<cudaStream_t>(0)));
+  auto* ptr = allocate(cuda::stream_ref{cudaStream_t{nullptr}}, bytes, alignment);
+  RMM_CUDA_TRY(cudaStreamSynchronize(cudaStream_t{nullptr}));
   return ptr;
 }
 
@@ -83,7 +83,7 @@ void sam_headroom_memory_resource_impl::deallocate_sync(void* ptr,
                                                         std::size_t bytes,
                                                         std::size_t alignment) noexcept
 {
-  deallocate(cuda::stream_ref{reinterpret_cast<cudaStream_t>(0)}, ptr, bytes, alignment);
+  deallocate(cuda::stream_ref{cudaStream_t{nullptr}}, ptr, bytes, alignment);
 }
 
 }  // namespace detail
diff --git a/cpp/src/mr/fixed_size_memory_resource.cpp b/cpp/src/mr/fixed_size_memory_resource.cpp
index 48bbed8bf..f379ab893 100644
--- a/cpp/src/mr/fixed_size_memory_resource.cpp
+++ b/cpp/src/mr/fixed_size_memory_resource.cpp
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/mr/fixed_size_memory_resource.hpp>
 
 #include <cstddef>
@@ -29,27 +28,5 @@ std::size_t fixed_size_memory_resource::get_block_size() const noexcept
   return get().get_block_size();
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* fixed_size_memory_resource::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void fixed_size_memory_resource::do_deallocate(void* ptr,
-                                               std::size_t bytes,
-                                               cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool fixed_size_memory_resource::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<fixed_size_memory_resource const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/limiting_resource_adaptor.cpp b/cpp/src/mr/limiting_resource_adaptor.cpp
index ba7bbd11a..a01ee4e4b 100644
--- a/cpp/src/mr/limiting_resource_adaptor.cpp
+++ b/cpp/src/mr/limiting_resource_adaptor.cpp
@@ -3,10 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
-#include <rmm/detail/error.hpp>
 #include <rmm/mr/limiting_resource_adaptor.hpp>
-#include <rmm/resource_ref.hpp>
 
 namespace RMM_NAMESPACE {
 namespace mr {
@@ -19,14 +16,6 @@ limiting_resource_adaptor::limiting_resource_adaptor(device_async_resource_ref u
 {
 }
 
-limiting_resource_adaptor::limiting_resource_adaptor(device_memory_resource* upstream,
-                                                     std::size_t allocation_limit,
-                                                     std::size_t alignment)
-  : limiting_resource_adaptor(
-      to_device_async_resource_ref_checked(upstream), allocation_limit, alignment)
-{
-}
-
 device_async_resource_ref limiting_resource_adaptor::get_upstream_resource() const noexcept
 {
   return get().get_upstream_resource();
@@ -42,27 +31,5 @@ std::size_t limiting_resource_adaptor::get_allocation_limit() const
   return get().get_allocation_limit();
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* limiting_resource_adaptor::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void limiting_resource_adaptor::do_deallocate(void* ptr,
-                                              std::size_t bytes,
-                                              cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool limiting_resource_adaptor::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<limiting_resource_adaptor const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/logging_resource_adaptor.cpp b/cpp/src/mr/logging_resource_adaptor.cpp
index 98f324b94..847aa8d3d 100644
--- a/cpp/src/mr/logging_resource_adaptor.cpp
+++ b/cpp/src/mr/logging_resource_adaptor.cpp
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/mr/logging_resource_adaptor.hpp>
 
 #include <cstddef>
@@ -76,27 +75,5 @@ std::string logging_resource_adaptor::get_default_filename()
   return std::string{filename};
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* logging_resource_adaptor::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void logging_resource_adaptor::do_deallocate(void* ptr,
-                                             std::size_t bytes,
-                                             cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool logging_resource_adaptor::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<logging_resource_adaptor const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/pool_memory_resource.cpp b/cpp/src/mr/pool_memory_resource.cpp
index 1be23e8b4..9282f46ea 100644
--- a/cpp/src/mr/pool_memory_resource.cpp
+++ b/cpp/src/mr/pool_memory_resource.cpp
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/mr/pool_memory_resource.hpp>
 
 #include <cstddef>
@@ -28,27 +27,5 @@ device_async_resource_ref pool_memory_resource::get_upstream_resource() const no
 
 std::size_t pool_memory_resource::pool_size() const noexcept { return get().pool_size(); }
 
-// Begin legacy device_memory_resource compatibility layer
-void* pool_memory_resource::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void pool_memory_resource::do_deallocate(void* ptr,
-                                         std::size_t bytes,
-                                         cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool pool_memory_resource::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<pool_memory_resource const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/prefetch_resource_adaptor.cpp b/cpp/src/mr/prefetch_resource_adaptor.cpp
index ab8fe806b..52aff1a75 100644
--- a/cpp/src/mr/prefetch_resource_adaptor.cpp
+++ b/cpp/src/mr/prefetch_resource_adaptor.cpp
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/mr/prefetch_resource_adaptor.hpp>
 
 namespace RMM_NAMESPACE {
@@ -19,27 +18,5 @@ device_async_resource_ref prefetch_resource_adaptor::get_upstream_resource() con
   return get().get_upstream_resource();
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* prefetch_resource_adaptor::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void prefetch_resource_adaptor::do_deallocate(void* ptr,
-                                              std::size_t bytes,
-                                              cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool prefetch_resource_adaptor::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<prefetch_resource_adaptor const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/sam_headroom_memory_resource.cpp b/cpp/src/mr/sam_headroom_memory_resource.cpp
index 1a93d90d7..ed302d41c 100644
--- a/cpp/src/mr/sam_headroom_memory_resource.cpp
+++ b/cpp/src/mr/sam_headroom_memory_resource.cpp
@@ -3,12 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/detail/error.hpp>
 #include <rmm/mr/sam_headroom_memory_resource.hpp>
 
-#include <cuda/memory_resource>
-
 namespace RMM_NAMESPACE {
 namespace mr {
 
@@ -17,27 +14,5 @@ sam_headroom_memory_resource::sam_headroom_memory_resource(std::size_t headroom)
 {
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* sam_headroom_memory_resource::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void sam_headroom_memory_resource::do_deallocate(void* ptr,
-                                                 std::size_t bytes,
-                                                 cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool sam_headroom_memory_resource::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<sam_headroom_memory_resource const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/statistics_resource_adaptor.cpp b/cpp/src/mr/statistics_resource_adaptor.cpp
index 39e79e654..4531931e0 100644
--- a/cpp/src/mr/statistics_resource_adaptor.cpp
+++ b/cpp/src/mr/statistics_resource_adaptor.cpp
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/mr/statistics_resource_adaptor.hpp>
 
 #include <cstddef>
@@ -45,27 +44,5 @@ statistics_resource_adaptor::pop_counters()
   return get().pop_counters();
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* statistics_resource_adaptor::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void statistics_resource_adaptor::do_deallocate(void* ptr,
-                                                std::size_t bytes,
-                                                cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool statistics_resource_adaptor::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<statistics_resource_adaptor const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/thread_safe_resource_adaptor.cpp b/cpp/src/mr/thread_safe_resource_adaptor.cpp
index 0aab86792..91ff02d10 100644
--- a/cpp/src/mr/thread_safe_resource_adaptor.cpp
+++ b/cpp/src/mr/thread_safe_resource_adaptor.cpp
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/mr/thread_safe_resource_adaptor.hpp>
 
 namespace RMM_NAMESPACE {
@@ -19,27 +18,5 @@ device_async_resource_ref thread_safe_resource_adaptor::get_upstream_resource()
   return get().get_upstream_resource();
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* thread_safe_resource_adaptor::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void thread_safe_resource_adaptor::do_deallocate(void* ptr,
-                                                 std::size_t bytes,
-                                                 cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool thread_safe_resource_adaptor::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<thread_safe_resource_adaptor const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/src/mr/tracking_resource_adaptor.cpp b/cpp/src/mr/tracking_resource_adaptor.cpp
index 24615ffe2..8e6af98b9 100644
--- a/cpp/src/mr/tracking_resource_adaptor.cpp
+++ b/cpp/src/mr/tracking_resource_adaptor.cpp
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <rmm/aligned.hpp>
 #include <rmm/mr/tracking_resource_adaptor.hpp>
 
 #include <cstddef>
@@ -46,27 +45,5 @@ void tracking_resource_adaptor::log_outstanding_allocations() const
   get().log_outstanding_allocations();
 }
 
-// Begin legacy device_memory_resource compatibility layer
-void* tracking_resource_adaptor::do_allocate(std::size_t bytes, cuda_stream_view stream)
-{
-  return shared_base::allocate(stream, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-void tracking_resource_adaptor::do_deallocate(void* ptr,
-                                              std::size_t bytes,
-                                              cuda_stream_view stream) noexcept
-{
-  shared_base::deallocate(stream, ptr, bytes, rmm::CUDA_ALLOCATION_ALIGNMENT);
-}
-
-bool tracking_resource_adaptor::do_is_equal(device_memory_resource const& other) const noexcept
-{
-  if (this == std::addressof(other)) { return true; }
-  auto const* cast = dynamic_cast<tracking_resource_adaptor const*>(&other);
-  if (cast == nullptr) { return false; }
-  return static_cast<shared_base const&>(*this) == static_cast<shared_base const&>(*cast);
-}
-// End legacy device_memory_resource compatibility layer
-
 }  // namespace mr
 }  // namespace RMM_NAMESPACE
diff --git a/cpp/tests/CMakeLists.txt b/cpp/tests/CMakeLists.txt
index f238b0bb1..6a760ebc1 100644
--- a/cpp/tests/CMakeLists.txt
+++ b/cpp/tests/CMakeLists.txt
@@ -153,9 +153,6 @@ ConfigureTest(LOGGING_MR_REF_TEST mr/mr_ref_logging_tests.cpp GPUS 1 PERCENT 5)
 ConfigureTest(FIXED_SIZE_MR_REF_TEST mr/mr_ref_fixed_size_tests.cpp GPUS 1 PERCENT 5)
 ConfigureTest(DEFAULT_MR_REF_TEST mr/mr_ref_default_tests.cpp GPUS 1 PERCENT 5)
 
-# device_memory_resource_view tests
-ConfigureTest(DEVICE_MEMORY_RESOURCE_VIEW_TEST mr/device_memory_resource_view_tests.cpp)
-
 # general adaptor tests
 ConfigureTest(ADAPTOR_TEST mr/adaptor_tests.cpp GPUS 1 PERCENT 5)
 ConfigureTest(CCCL_ADAPTOR_TEST mr/cccl_adaptor_tests.cpp GPUS 1 PERCENT 100)
diff --git a/cpp/tests/device_buffer_tests.cu b/cpp/tests/device_buffer_tests.cu
index 04ea1be98..ce5ba6058 100644
--- a/cpp/tests/device_buffer_tests.cu
+++ b/cpp/tests/device_buffer_tests.cu
@@ -174,7 +174,7 @@ TYPED_TEST(DeviceBufferTest, CopyFromNullptrNonZero)
 
 TYPED_TEST(DeviceBufferTest, CopyConstructor)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
 
   // Initialize buffer
   thrust::sequence(rmm::exec_policy(rmm::cuda_stream_default),
@@ -213,7 +213,7 @@ TYPED_TEST(DeviceBufferTest, CopyConstructor)
 
 TYPED_TEST(DeviceBufferTest, CopyCapacityLargerThanSize)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
 
   // Resizing smaller to make `size()` < `capacity()`
   auto new_size = this->size - 1;
@@ -244,14 +244,14 @@ TYPED_TEST(DeviceBufferTest, CopyCapacityLargerThanSize)
 
 TYPED_TEST(DeviceBufferTest, CopyConstructorExplicitMr)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
 
   thrust::sequence(rmm::exec_policy(rmm::cuda_stream_default),
                    static_cast<signed char*>(buff.data()),
                    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
                    static_cast<signed char*>(buff.data()) + buff.size(),
                    0);
-  rmm::device_buffer buff_copy(buff, this->stream, &this->mr);
+  rmm::device_buffer buff_copy(buff, this->stream, this->mr);
   EXPECT_NE(nullptr, buff_copy.data());
   EXPECT_NE(buff.data(), buff_copy.data());
   EXPECT_EQ(buff.size(), buff_copy.size());
@@ -268,7 +268,7 @@ TYPED_TEST(DeviceBufferTest, CopyConstructorExplicitMr)
 
 TYPED_TEST(DeviceBufferTest, CopyCapacityLargerThanSizeExplicitMr)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
 
   // Resizing smaller to make `size()` < `capacity()`
   auto new_size = this->size - 1;
@@ -279,7 +279,7 @@ TYPED_TEST(DeviceBufferTest, CopyCapacityLargerThanSizeExplicitMr)
                    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
                    static_cast<signed char*>(buff.data()) + buff.size(),
                    0);
-  rmm::device_buffer buff_copy(buff, this->stream, &this->mr);
+  rmm::device_buffer buff_copy(buff, this->stream, this->mr);
   EXPECT_NE(nullptr, buff_copy.data());
   EXPECT_NE(buff.data(), buff_copy.data());
   EXPECT_EQ(buff.size(), buff_copy.size());
@@ -299,7 +299,7 @@ TYPED_TEST(DeviceBufferTest, CopyCapacityLargerThanSizeExplicitMr)
 
 TYPED_TEST(DeviceBufferTest, MoveConstructor)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
   auto* ptr     = buff.data();
   auto size     = buff.size();
   auto capacity = buff.capacity();
@@ -325,7 +325,7 @@ TYPED_TEST(DeviceBufferTest, MoveConstructor)
 
 TYPED_TEST(DeviceBufferTest, MoveConstructorStream)
 {
-  rmm::device_buffer buff(this->size, this->stream, &this->mr);
+  rmm::device_buffer buff(this->size, this->stream, this->mr);
   this->stream.synchronize();
   auto* ptr     = buff.data();
   auto size     = buff.size();
@@ -353,7 +353,7 @@ TYPED_TEST(DeviceBufferTest, MoveConstructorStream)
 
 TYPED_TEST(DeviceBufferTest, MoveAssignmentToDefault)
 {
-  rmm::device_buffer src(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer src(this->size, rmm::cuda_stream_default, this->mr);
   auto* ptr     = src.data();
   auto size     = src.size();
   auto capacity = src.capacity();
@@ -380,14 +380,14 @@ TYPED_TEST(DeviceBufferTest, MoveAssignmentToDefault)
 
 TYPED_TEST(DeviceBufferTest, MoveAssignment)
 {
-  rmm::device_buffer src(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer src(this->size, rmm::cuda_stream_default, this->mr);
   auto* ptr     = src.data();
   auto size     = src.size();
   auto capacity = src.capacity();
   auto mr       = src.memory_resource();
   auto stream   = src.stream();
 
-  rmm::device_buffer dest(this->size - 1, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer dest(this->size - 1, rmm::cuda_stream_default, this->mr);
   dest = std::move(src);
 
   // contents of `from` should be in `to`
@@ -407,7 +407,7 @@ TYPED_TEST(DeviceBufferTest, MoveAssignment)
 
 TYPED_TEST(DeviceBufferTest, SelfMoveAssignment)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
   auto* ptr     = buff.data();
   auto size     = buff.size();
   auto capacity = buff.capacity();
@@ -428,7 +428,7 @@ TYPED_TEST(DeviceBufferTest, SelfMoveAssignment)
 
 TYPED_TEST(DeviceBufferTest, ResizeSmaller)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
 
   thrust::sequence(rmm::exec_policy(rmm::cuda_stream_default),
                    static_cast<signed char*>(buff.data()),
@@ -438,7 +438,7 @@ TYPED_TEST(DeviceBufferTest, ResizeSmaller)
 
   auto* old_data = buff.data();
   rmm::device_buffer old_content(
-    old_data, buff.size(), rmm::cuda_stream_default, &this->mr);  // for comparison
+    old_data, buff.size(), rmm::cuda_stream_default, this->mr);  // for comparison
 
   auto new_size = this->size - 1;
   buff.resize(new_size, rmm::cuda_stream_default);
@@ -463,7 +463,7 @@ TYPED_TEST(DeviceBufferTest, ResizeSmaller)
 
 TYPED_TEST(DeviceBufferTest, ResizeBigger)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
   auto* old_data = buff.data();
   auto new_size  = this->size + 1;
   buff.resize(new_size, rmm::cuda_stream_default);
@@ -475,7 +475,7 @@ TYPED_TEST(DeviceBufferTest, ResizeBigger)
 
 TYPED_TEST(DeviceBufferTest, ReserveSmaller)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
   auto* const old_data    = buff.data();
   auto const old_capacity = buff.capacity();
   auto const new_capacity = buff.capacity() - 1;
@@ -488,7 +488,7 @@ TYPED_TEST(DeviceBufferTest, ReserveSmaller)
 
 TYPED_TEST(DeviceBufferTest, ReserveBigger)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
   auto* const old_data    = buff.data();
   auto const new_capacity = buff.capacity() + 1;
   buff.reserve(new_capacity, rmm::cuda_stream_default);
@@ -500,7 +500,7 @@ TYPED_TEST(DeviceBufferTest, ReserveBigger)
 
 TYPED_TEST(DeviceBufferTest, SetGetStream)
 {
-  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, &this->mr);
+  rmm::device_buffer buff(this->size, rmm::cuda_stream_default, this->mr);
 
   EXPECT_EQ(buff.stream(), rmm::cuda_stream_default);
 
diff --git a/cpp/tests/mr/adaptor_tests.cpp b/cpp/tests/mr/adaptor_tests.cpp
index 4229ae613..830b0fbbc 100644
--- a/cpp/tests/mr/adaptor_tests.cpp
+++ b/cpp/tests/mr/adaptor_tests.cpp
@@ -8,7 +8,6 @@
 #include <rmm/error.hpp>
 #include <rmm/mr/aligned_resource_adaptor.hpp>
 #include <rmm/mr/cuda_memory_resource.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/mr/failure_callback_resource_adaptor.hpp>
 #include <rmm/mr/is_resource_adaptor.hpp>
 #include <rmm/mr/limiting_resource_adaptor.hpp>
@@ -71,28 +70,20 @@ struct AdaptorTest : public ::testing::Test {
         []([[maybe_unused]] std::size_t bytes, [[maybe_unused]] void* arg) { return false; },
         nullptr);
     } else if constexpr (std::is_same_v<adaptor_type, limiting_resource_adaptor>) {
-      return std::make_shared<adaptor_type>(upstream, 64_MiB);
+      return std::make_shared<adaptor_type>(*upstream, 64_MiB);
     } else if constexpr (std::is_same_v<adaptor_type, thread_safe_resource_adaptor>) {
       return std::make_shared<adaptor_type>(*upstream);
     } else {
-      return std::make_shared<adaptor_type>(upstream);
+      return std::make_shared<adaptor_type>(*upstream);
     }
   }
 };
 
 TYPED_TEST_SUITE(AdaptorTest, adaptors);
 
-TYPED_TEST(AdaptorTest, NullUpstream)
-{
-  if constexpr (not std::is_same_v<TypeParam, failure_callback_resource_adaptor<>> and
-                not std::is_same_v<TypeParam, thread_safe_resource_adaptor>) {
-    EXPECT_THROW(this->make_adaptor(nullptr), rmm::logic_error);
-  }
-}
-
 TYPED_TEST(AdaptorTest, Equality)
 {
-  EXPECT_TRUE(this->mr->is_equal(*this->mr));
+  EXPECT_EQ(*this->mr, *this->mr);
 
   {
     auto other_mr = this->make_adaptor(&this->cuda);
@@ -100,16 +91,11 @@ TYPED_TEST(AdaptorTest, Equality)
                   std::is_same_v<TypeParam, limiting_resource_adaptor> or
                   std::is_same_v<TypeParam, thread_safe_resource_adaptor>) {
       // shared_resource equality: two distinct constructions are NOT equal
-      EXPECT_FALSE(this->mr->is_equal(*other_mr));
+      EXPECT_NE(*this->mr, *other_mr);
     } else {
-      EXPECT_TRUE(this->mr->is_equal(*other_mr));
+      EXPECT_EQ(*this->mr, *other_mr);
     }
   }
-
-  {
-    auto other_mr = aligned_resource_adaptor{this->cuda};
-    EXPECT_FALSE(this->mr->is_equal(other_mr));
-  }
 }
 
 TYPED_TEST(AdaptorTest, GetUpstreamResource)
diff --git a/cpp/tests/mr/aligned_mr_tests.cpp b/cpp/tests/mr/aligned_mr_tests.cpp
index 1bc631dbd..e9a2b2cab 100644
--- a/cpp/tests/mr/aligned_mr_tests.cpp
+++ b/cpp/tests/mr/aligned_mr_tests.cpp
@@ -10,7 +10,6 @@
 #include <rmm/cuda_stream.hpp>
 #include <rmm/error.hpp>
 #include <rmm/mr/aligned_resource_adaptor.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/mr/per_device_resource.hpp>
 
 #include <gmock/gmock.h>
@@ -61,14 +60,14 @@ TEST_P(allocation_size, MultiThreaded)
     threads.emplace_back([&, i = i]() {
       void* ptr{nullptr};
       if (i != 0) { std::this_thread::sleep_for(std::chrono::milliseconds{100}); }
-      EXPECT_NO_THROW(ptr = mr.allocate(stream, allocation_size));
+      EXPECT_NO_THROW(ptr = mr.allocate(stream, allocation_size, rmm::CUDA_ALLOCATION_ALIGNMENT));
       if (allocation_size != 0) {
         EXPECT_NE(ptr, nullptr);
       } else {
         EXPECT_EQ(ptr, nullptr);
       }
       if (i == 0) { std::this_thread::sleep_for(std::chrono::milliseconds{100}); }
-      mr.deallocate(stream, ptr, allocation_size);
+      mr.deallocate(stream, ptr, allocation_size, rmm::CUDA_ALLOCATION_ALIGNMENT);
     });
   }
   for (auto& t : threads) {
@@ -109,8 +108,8 @@ TEST(AlignedTest, DefaultAllocationAlignmentPassthrough)
 
   {
     auto const size{5};
-    EXPECT_EQ(mr.allocate(stream, size), pointer);
-    mr.deallocate(stream, pointer, size);
+    EXPECT_EQ(mr.allocate(stream, size, rmm::CUDA_ALLOCATION_ALIGNMENT), pointer);
+    mr.deallocate(stream, pointer, size, rmm::CUDA_ALLOCATION_ALIGNMENT);
   }
 }
 
@@ -131,8 +130,8 @@ TEST(AlignedTest, BelowAlignmentThresholdPassthrough)
 
   {
     auto const size{3};
-    EXPECT_EQ(mr.allocate(stream, size), pointer);
-    mr.deallocate(stream, pointer, size);
+    EXPECT_EQ(mr.allocate(stream, size, rmm::CUDA_ALLOCATION_ALIGNMENT), pointer);
+    mr.deallocate(stream, pointer, size, rmm::CUDA_ALLOCATION_ALIGNMENT);
   }
 
   {
@@ -140,8 +139,8 @@ TEST(AlignedTest, BelowAlignmentThresholdPassthrough)
     void* const pointer1 = int_to_address(456);
     EXPECT_CALL(mock, do_allocate(size, stream)).WillOnce(Return(pointer1));
     EXPECT_CALL(mock, do_deallocate(pointer1, size, stream)).Times(1);
-    EXPECT_EQ(mr.allocate(stream, size), pointer1);
-    mr.deallocate(stream, pointer1, size);
+    EXPECT_EQ(mr.allocate(stream, size, rmm::CUDA_ALLOCATION_ALIGNMENT), pointer1);
+    mr.deallocate(stream, pointer1, size, rmm::CUDA_ALLOCATION_ALIGNMENT);
   }
 }
 
@@ -163,8 +162,8 @@ TEST(AlignedTest, UpstreamAddressAlreadyAligned)
 
   {
     auto const size{65536};
-    EXPECT_EQ(mr.allocate(stream, size), pointer);
-    mr.deallocate(stream, pointer, size);
+    EXPECT_EQ(mr.allocate(stream, size, rmm::CUDA_ALLOCATION_ALIGNMENT), pointer);
+    mr.deallocate(stream, pointer, size, rmm::CUDA_ALLOCATION_ALIGNMENT);
   }
 }
 
@@ -186,8 +185,8 @@ TEST(AlignedTest, AlignUpstreamAddress)
   {
     void* const expected_pointer = int_to_address(4096);
     auto const size{65536};
-    EXPECT_EQ(mr.allocate(stream, size), expected_pointer);
-    mr.deallocate(stream, expected_pointer, size);
+    EXPECT_EQ(mr.allocate(stream, size, rmm::CUDA_ALLOCATION_ALIGNMENT), expected_pointer);
+    mr.deallocate(stream, expected_pointer, size, rmm::CUDA_ALLOCATION_ALIGNMENT);
   }
 }
 
@@ -222,12 +221,12 @@ TEST(AlignedTest, AlignMultiple)
     auto const size1{65536};
     auto const size2{73728};
     auto const size3{77800};
-    EXPECT_EQ(mr.allocate(stream, size1), expected_pointer1);
-    EXPECT_EQ(mr.allocate(stream, size2), expected_pointer2);
-    EXPECT_EQ(mr.allocate(stream, size3), expected_pointer3);
-    mr.deallocate(stream, expected_pointer1, size1);
-    mr.deallocate(stream, expected_pointer2, size2);
-    mr.deallocate(stream, expected_pointer3, size3);
+    EXPECT_EQ(mr.allocate(stream, size1, rmm::CUDA_ALLOCATION_ALIGNMENT), expected_pointer1);
+    EXPECT_EQ(mr.allocate(stream, size2, rmm::CUDA_ALLOCATION_ALIGNMENT), expected_pointer2);
+    EXPECT_EQ(mr.allocate(stream, size3, rmm::CUDA_ALLOCATION_ALIGNMENT), expected_pointer3);
+    mr.deallocate(stream, expected_pointer1, size1, rmm::CUDA_ALLOCATION_ALIGNMENT);
+    mr.deallocate(stream, expected_pointer2, size2, rmm::CUDA_ALLOCATION_ALIGNMENT);
+    mr.deallocate(stream, expected_pointer3, size3, rmm::CUDA_ALLOCATION_ALIGNMENT);
   }
 }
 
diff --git a/cpp/tests/mr/arena_mr_tests.cpp b/cpp/tests/mr/arena_mr_tests.cpp
index 599af4667..61b8d81ae 100644
--- a/cpp/tests/mr/arena_mr_tests.cpp
+++ b/cpp/tests/mr/arena_mr_tests.cpp
@@ -469,13 +469,6 @@ TEST_F(ArenaTest, ArenaDefragment)  // NOLINT
  * Test arena_memory_resource.
  */
 
-TEST_F(ArenaTest, ThrowOnNullUpstream)  // NOLINT
-{
-  auto construct_nullptr = []() { arena_mr mr{nullptr}; };
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto)
-  EXPECT_THROW(construct_nullptr(), rmm::logic_error);
-}
-
 TEST_F(ArenaTest, SizeSmallerThanSuperblockSize)  // NOLINT
 {
   auto construct_small = []() { arena_mr mr{rmm::mr::get_current_device_resource_ref(), 256}; };
@@ -516,8 +509,8 @@ TEST_F(ArenaTest, Defragment)  // NOLINT
     for (std::size_t i = 0; i < num_threads; ++i) {
       threads.emplace_back(std::thread([&] {
         cuda_stream stream{};
-        void* ptr = mr.allocate(stream, 32_KiB);
-        mr.deallocate(stream, ptr, 32_KiB);
+        void* ptr = mr.allocate(cuda_stream_view{stream}, 32_KiB, rmm::CUDA_ALLOCATION_ALIGNMENT);
+        mr.deallocate(cuda_stream_view{stream}, ptr, 32_KiB, rmm::CUDA_ALLOCATION_ALIGNMENT);
       }));
     }
     for (auto& thread : threads) {
@@ -538,26 +531,28 @@ TEST_F(ArenaTest, PerThreadToStreamDealloc)  // NOLINT
   auto const arena_size = superblock::minimum_size * 2;
   arena_mr mr(rmm::mr::get_current_device_resource_ref(), arena_size);
   // Create an allocation from a per thread arena
-  void* thread_ptr = mr.allocate(rmm::cuda_stream_per_thread, 256);
+  void* thread_ptr = mr.allocate(rmm::cuda_stream_per_thread, 256, rmm::CUDA_ALLOCATION_ALIGNMENT);
   // Create an allocation in a stream arena to force global arena
   // to be empty
   cuda_stream stream{};
-  void* ptr = mr.allocate(stream, 32_KiB);
-  mr.deallocate(stream, ptr, 32_KiB);
+  void* ptr = mr.allocate(cuda_stream_view{stream}, 32_KiB, rmm::CUDA_ALLOCATION_ALIGNMENT);
+  mr.deallocate(cuda_stream_view{stream}, ptr, 32_KiB, rmm::CUDA_ALLOCATION_ALIGNMENT);
   // at this point the global arena doesn't have any superblocks so
   // the next allocation causes defrag. Defrag causes all superblocks
   // from the thread and stream arena allocated above to go back to
   // global arena and it allocates one superblock to the stream arena.
-  auto* ptr1 = mr.allocate(rmm::cuda_stream_view{}, superblock::minimum_size);
+  auto* ptr1 =
+    mr.allocate(rmm::cuda_stream_view{}, superblock::minimum_size, rmm::CUDA_ALLOCATION_ALIGNMENT);
   // Allocate again to make sure all superblocks from
   // global arena are owned by a stream arena instead of a thread arena
   // or the global arena.
-  auto* ptr2 = mr.allocate(rmm::cuda_stream_view{}, 32_KiB);
+  auto* ptr2 = mr.allocate(rmm::cuda_stream_view{}, 32_KiB, rmm::CUDA_ALLOCATION_ALIGNMENT);
   // The original thread ptr is now owned by a stream arena so make
   // sure deallocation works.
-  mr.deallocate(rmm::cuda_stream_per_thread, thread_ptr, 256);
-  mr.deallocate(rmm::cuda_stream_view{}, ptr1, superblock::minimum_size);
-  mr.deallocate(rmm::cuda_stream_view{}, ptr2, 32_KiB);
+  mr.deallocate(rmm::cuda_stream_per_thread, thread_ptr, 256, rmm::CUDA_ALLOCATION_ALIGNMENT);
+  mr.deallocate(
+    rmm::cuda_stream_view{}, ptr1, superblock::minimum_size, rmm::CUDA_ALLOCATION_ALIGNMENT);
+  mr.deallocate(rmm::cuda_stream_view{}, ptr2, 32_KiB, rmm::CUDA_ALLOCATION_ALIGNMENT);
 }
 
 TEST_F(ArenaTest, DumpLogOnFailure)  // NOLINT
@@ -581,7 +576,7 @@ TEST_F(ArenaTest, DumpLogOnFailure)  // NOLINT
   }
 
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto)
-  EXPECT_THROW(mr.allocate_sync(8_MiB), rmm::out_of_memory);
+  EXPECT_THROW((void)mr.allocate_sync(8_MiB), rmm::out_of_memory);
 
   struct stat file_status{};
   EXPECT_EQ(stat("rmm_arena_memory_dump.log", &file_status), 0);
diff --git a/cpp/tests/mr/cuda_async_managed_mr_tests.cpp b/cpp/tests/mr/cuda_async_managed_mr_tests.cpp
index edbeffb09..ecdf81d73 100644
--- a/cpp/tests/mr/cuda_async_managed_mr_tests.cpp
+++ b/cpp/tests/mr/cuda_async_managed_mr_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -44,7 +44,7 @@ TEST_F(AsyncManagedMRTest, EqualityWithSamePool)
   // ultimately refer to the same underlying pool handle. Construct two and compare.
   cuda_async_managed_mr mr1{};
   cuda_async_managed_mr mr2{};
-  EXPECT_TRUE(mr1.is_equal(mr2));
+  EXPECT_EQ(mr1, mr2);
 }
 
 TEST_F(AsyncManagedMRTest, AllocatedPointerIsManaged)
diff --git a/cpp/tests/mr/cuda_async_mr_tests.cpp b/cpp/tests/mr/cuda_async_mr_tests.cpp
index fb1034a37..7b4b1e7f1 100644
--- a/cpp/tests/mr/cuda_async_mr_tests.cpp
+++ b/cpp/tests/mr/cuda_async_mr_tests.cpp
@@ -55,7 +55,7 @@ TEST_F(AsyncMRTest, DifferentPoolsUnequal)
   const auto pool_release_threshold{1000};
   cuda_async_mr mr1{pool_init_size, pool_release_threshold};
   cuda_async_mr mr2{pool_init_size, pool_release_threshold};
-  EXPECT_FALSE(mr1.is_equal(mr2));
+  EXPECT_NE(mr1, mr2);
 }
 
 class AsyncMRFabricTest : public AsyncMRTest {
diff --git a/cpp/tests/mr/device_memory_resource_view_tests.cpp b/cpp/tests/mr/device_memory_resource_view_tests.cpp
deleted file mode 100644
index d512924b3..000000000
--- a/cpp/tests/mr/device_memory_resource_view_tests.cpp
+++ /dev/null
@@ -1,258 +0,0 @@
-/*
- * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#include "../mock_resource.hpp"
-
-#include <rmm/cuda_stream_view.hpp>
-#include <rmm/detail/cccl_adaptors.hpp>
-#include <rmm/mr/cuda_async_memory_resource.hpp>
-#include <rmm/mr/cuda_memory_resource.hpp>
-#include <rmm/mr/detail/device_memory_resource_view.hpp>
-#include <rmm/resource_ref.hpp>
-
-#include <gtest/gtest.h>
-
-#include <cstddef>
-#include <memory>
-#include <utility>
-
-namespace rmm::test {
-namespace {
-
-/**
- * @brief Test that device_memory_resource_view can be constructed from a pointer
- */
-TEST(DeviceMemoryResourceViewTest, ConstructFromPointer)
-{
-  rmm::mr::cuda_memory_resource mr;
-  rmm::mr::detail::device_memory_resource_view view{&mr};
-
-  // Should be able to get the pointer back
-  EXPECT_EQ(view.get(), &mr);
-}
-
-/**
- * @brief Test that device_memory_resource_view rejects null pointers
- */
-TEST(DeviceMemoryResourceViewTest, RejectsNullPointer)
-{
-  EXPECT_THROW(rmm::mr::detail::device_memory_resource_view view{nullptr}, rmm::logic_error);
-}
-
-/**
- * @brief Test that device_memory_resource_view is copyable
- */
-TEST(DeviceMemoryResourceViewTest, IsCopyable)
-{
-  rmm::mr::cuda_memory_resource mr;
-  rmm::mr::detail::device_memory_resource_view view1{&mr};
-
-  // Copy construction
-  auto view2 = view1;
-  EXPECT_EQ(view2.get(), &mr);
-
-  // Copy assignment
-  rmm::mr::cuda_memory_resource mr2;
-  rmm::mr::detail::device_memory_resource_view view3{&mr2};
-  view3 = view1;
-  EXPECT_EQ(view3.get(), &mr);
-}
-
-/**
- * @brief Test that device_memory_resource_view is movable
- */
-TEST(DeviceMemoryResourceViewTest, IsMovable)
-{
-  rmm::mr::cuda_memory_resource mr;
-  rmm::mr::detail::device_memory_resource_view view1{&mr};
-
-  // Move construction
-  auto view2 = std::move(view1);
-  EXPECT_EQ(view2.get(), &mr);
-
-  // Move assignment
-  rmm::mr::cuda_memory_resource mr2;
-  rmm::mr::detail::device_memory_resource_view view3{&mr2};
-  rmm::mr::detail::device_memory_resource_view view4{&mr};
-  view3 = std::move(view4);
-  EXPECT_EQ(view3.get(), &mr);
-}
-
-/**
- * @brief Test that device_memory_resource_view properly compares equal views
- */
-TEST(DeviceMemoryResourceViewTest, EqualityComparison)
-{
-  rmm::mr::cuda_memory_resource mr;
-  rmm::mr::detail::device_memory_resource_view view1{&mr};
-  rmm::mr::detail::device_memory_resource_view view2{&mr};
-
-  // Views wrapping the same resource should be equal
-  EXPECT_EQ(view1, view2);
-  EXPECT_FALSE(view1 != view2);
-}
-
-/**
- * @brief Test that device_memory_resource_view properly compares unequal views
- */
-TEST(DeviceMemoryResourceViewTest, InequalityComparison)
-{
-  rmm::mr::cuda_memory_resource mr1;
-  rmm::mr::cuda_memory_resource mr2;
-  rmm::mr::cuda_async_memory_resource mr3;
-  rmm::mr::detail::device_memory_resource_view view1{&mr1};
-  rmm::mr::detail::device_memory_resource_view view2{&mr2};
-  rmm::mr::detail::device_memory_resource_view view3{&mr3};
-
-  // Views wrapping different resources should be equal iff the resources compare equal
-  EXPECT_EQ(mr1, mr2);
-  EXPECT_EQ(view1, view2);
-  EXPECT_NE(mr1, mr3);
-  EXPECT_NE(view1, view3);
-}
-
-/**
- * @brief Test that device_memory_resource_view forwards allocate_sync calls
- */
-TEST(DeviceMemoryResourceViewTest, ForwardsAllocateSync)
-{
-  mock_resource mr;
-  rmm::mr::detail::device_memory_resource_view view{&mr};
-
-  void* expected_ptr = reinterpret_cast<void*>(0x1234);
-  EXPECT_CALL(mr, do_allocate(100, cuda_stream_view{}))
-    .Times(1)
-    .WillOnce(::testing::Return(expected_ptr));
-
-  void* ptr = view.allocate_sync(100);
-  EXPECT_EQ(ptr, expected_ptr);
-}
-
-/**
- * @brief Test that device_memory_resource_view forwards deallocate_sync calls
- */
-TEST(DeviceMemoryResourceViewTest, ForwardsDeallocateSync)
-{
-  mock_resource mr;
-  rmm::mr::detail::device_memory_resource_view view{&mr};
-
-  void* ptr = reinterpret_cast<void*>(0x1234);
-  EXPECT_CALL(mr, do_deallocate(ptr, 100, cuda_stream_view{})).Times(1);
-
-  view.deallocate_sync(ptr, 100);
-}
-
-/**
- * @brief Test that device_memory_resource_view forwards async allocate calls
- */
-TEST(DeviceMemoryResourceViewTest, ForwardsAllocateAsync)
-{
-  mock_resource mr;
-  rmm::mr::detail::device_memory_resource_view view{&mr};
-
-  cuda_stream_view stream{};
-  void* expected_ptr = reinterpret_cast<void*>(0x5678);
-  EXPECT_CALL(mr, do_allocate(200, stream)).Times(1).WillOnce(::testing::Return(expected_ptr));
-
-  void* ptr = view.allocate(stream, 200);
-  EXPECT_EQ(ptr, expected_ptr);
-}
-
-/**
- * @brief Test that device_memory_resource_view forwards async deallocate calls
- */
-TEST(DeviceMemoryResourceViewTest, ForwardsDeallocateAsync)
-{
-  mock_resource mr;
-  rmm::mr::detail::device_memory_resource_view view{&mr};
-
-  cuda_stream_view stream{};
-  void* ptr = reinterpret_cast<void*>(0x5678);
-  EXPECT_CALL(mr, do_deallocate(ptr, 200, stream)).Times(1);
-
-  view.deallocate(stream, ptr, 200);
-}
-
-/**
- * @brief Test that cccl_resource_ref can be constructed from a raw pointer
- */
-TEST(DeviceMemoryResourceViewTest, CcclResourceRefFromPointer)
-{
-  rmm::mr::cuda_memory_resource mr;
-
-  // This should compile and work thanks to the new constructor
-  rmm::device_resource_ref ref{&mr};
-
-  // The ref should be usable for allocations
-  void* ptr = ref.allocate_sync(100);
-  EXPECT_NE(ptr, nullptr);
-  ref.deallocate_sync(ptr, 100);
-}
-
-/**
- * @brief Test that cccl_async_resource_ref can be constructed from a raw pointer
- */
-TEST(DeviceMemoryResourceViewTest, CcclAsyncResourceRefFromPointer)
-{
-  rmm::mr::cuda_memory_resource mr;
-
-  // This should compile and work thanks to the new constructor
-  rmm::device_async_resource_ref ref{&mr};
-
-  // The ref should be usable for allocations
-  void* ptr = ref.allocate_sync(100);
-  EXPECT_NE(ptr, nullptr);
-  ref.deallocate_sync(ptr, 100);
-
-  // And for async allocations
-  cuda_stream_view stream{};
-  ptr = ref.allocate(stream, 200);
-  EXPECT_NE(ptr, nullptr);
-  ref.deallocate(stream, ptr, 200);
-}
-
-/**
- * @brief Test that resource_refs constructed from pointers are copyable
- */
-TEST(DeviceMemoryResourceViewTest, ResourceRefFromPointerIsCopyable)
-{
-  rmm::mr::cuda_memory_resource mr;
-  rmm::device_async_resource_ref ref1{&mr};
-
-  // Copy construction
-  auto ref2 = ref1;
-
-  // Both refs should work
-  void* ptr1 = ref1.allocate_sync(100);
-  void* ptr2 = ref2.allocate_sync(100);
-
-  EXPECT_NE(ptr1, nullptr);
-  EXPECT_NE(ptr2, nullptr);
-  EXPECT_NE(ptr1, ptr2);
-
-  ref1.deallocate_sync(ptr1, 100);
-  ref2.deallocate_sync(ptr2, 100);
-}
-
-/**
- * @brief Test that the view maintains the correct lifecycle semantics (non-owning)
- */
-TEST(DeviceMemoryResourceViewTest, NonOwningSemantics)
-{
-  auto mr_ptr = std::make_unique<rmm::mr::cuda_memory_resource>();
-
-  // Destroying the view should NOT destroy the resource
-  {
-    rmm::mr::detail::device_memory_resource_view view{mr_ptr.get()};
-  }
-
-  // The underlying resource should still be valid
-  void* ptr = mr_ptr->allocate_sync(100);
-  EXPECT_NE(ptr, nullptr);
-  mr_ptr->deallocate_sync(ptr, 100);
-}
-
-}  // namespace
-}  // namespace rmm::test
diff --git a/cpp/tests/mr/failure_callback_mr_tests.cpp b/cpp/tests/mr/failure_callback_mr_tests.cpp
index cb039b4bb..5af05bd89 100644
--- a/cpp/tests/mr/failure_callback_mr_tests.cpp
+++ b/cpp/tests/mr/failure_callback_mr_tests.cpp
@@ -50,7 +50,7 @@ TEST(FailureCallbackTest, RetryAllocationOnce)
   bool retried{false};
   failure_callback_adaptor<> mr{&throwing_mr, failure_handler, &retried};
   EXPECT_EQ(retried, false);
-  EXPECT_THROW(mr.allocate_sync(1_MiB), rmm::bad_alloc);
+  EXPECT_THROW((void)mr.allocate_sync(1_MiB), rmm::bad_alloc);
   EXPECT_EQ(retried, true);
 }
 
@@ -59,8 +59,8 @@ TEST(FailureCallbackTest, DifferentExceptionTypes)
   always_throw_memory_resource<rmm::bad_alloc> bad_alloc_mr;
   always_throw_memory_resource<rmm::out_of_memory> oom_mr;
 
-  EXPECT_THROW(bad_alloc_mr.allocate_sync(1_MiB), rmm::bad_alloc);
-  EXPECT_THROW(oom_mr.allocate_sync(1_MiB), rmm::out_of_memory);
+  EXPECT_THROW((void)bad_alloc_mr.allocate_sync(1_MiB), rmm::bad_alloc);
+  EXPECT_THROW((void)oom_mr.allocate_sync(1_MiB), rmm::out_of_memory);
 
   // Wrap a bad_alloc-catching callback adaptor around an MR that always throws bad_alloc:
   // Should retry once and then re-throw bad_alloc
@@ -70,7 +70,7 @@ TEST(FailureCallbackTest, DifferentExceptionTypes)
       &bad_alloc_mr, failure_handler, &retried};
 
     EXPECT_EQ(retried, false);
-    EXPECT_THROW(bad_alloc_callback_mr.allocate_sync(1_MiB), rmm::bad_alloc);
+    EXPECT_THROW((void)bad_alloc_callback_mr.allocate_sync(1_MiB), rmm::bad_alloc);
     EXPECT_EQ(retried, true);
   }
 
@@ -82,7 +82,7 @@ TEST(FailureCallbackTest, DifferentExceptionTypes)
     failure_callback_adaptor<rmm::out_of_memory> oom_callback_mr{
       &oom_mr, failure_handler, &retried};
     EXPECT_EQ(retried, false);
-    EXPECT_THROW(oom_callback_mr.allocate_sync(1_MiB), rmm::out_of_memory);
+    EXPECT_THROW((void)oom_callback_mr.allocate_sync(1_MiB), rmm::out_of_memory);
     EXPECT_EQ(retried, true);
   }
 
@@ -94,8 +94,9 @@ TEST(FailureCallbackTest, DifferentExceptionTypes)
     failure_callback_adaptor<rmm::out_of_memory> oom_callback_mr{
       &bad_alloc_mr, failure_handler, &retried};
     EXPECT_EQ(retried, false);
-    EXPECT_THROW(oom_callback_mr.allocate_sync(1_MiB), rmm::bad_alloc);  // bad_alloc passes through
-    EXPECT_EQ(retried, false);  // Does not catch / retry on anything except OOM
+    EXPECT_THROW((void)oom_callback_mr.allocate_sync(1_MiB),
+                 rmm::bad_alloc);  // bad_alloc passes through
+    EXPECT_EQ(retried, false);     // Does not catch / retry on anything except OOM
   }
 }
 
diff --git a/cpp/tests/mr/host_mr_ref_tests.cpp b/cpp/tests/mr/host_mr_ref_tests.cpp
index 73e330546..73dca09a9 100644
--- a/cpp/tests/mr/host_mr_ref_tests.cpp
+++ b/cpp/tests/mr/host_mr_ref_tests.cpp
@@ -64,11 +64,9 @@ struct MRRefTest : public ::testing::Test {
 
   MRRefTest() : mr{}, ref{mr} {}
 
-  // Helper to get max alignment for the resource type
   static constexpr std::size_t get_max_alignment()
   {
-    // pinned_host_memory_resource inherits from device_memory_resource which limits alignment to
-    // 256
+    // pinned_host_memory_resource uses cudaHostAlloc which only guarantees 256-byte alignment
     if constexpr (std::is_same_v<MemoryResourceType, rmm::mr::pinned_host_memory_resource>) {
       return 256;
     } else {
@@ -228,27 +226,6 @@ TYPED_TEST(MRRefTest, AlignmentTest)
   }
 }
 
-TYPED_TEST(MRRefTest, UnsupportedAlignmentTest)
-{
-  std::default_random_engine generator(0);
-  constexpr std::size_t MAX_ALLOCATION_SIZE{10 * size_mb};
-  std::uniform_int_distribution<std::size_t> size_distribution(1, MAX_ALLOCATION_SIZE);
-
-  const std::size_t max_alignment = TestFixture::get_max_alignment();
-
-  for (std::size_t num_trials = 0; num_trials < NUM_TRIALS; ++num_trials) {
-    for (std::size_t alignment = MinTestedAlignment; alignment <= max_alignment;
-         alignment *= TestedAlignmentMultiplier) {
-      auto allocation_size = size_distribution(generator);
-      // An unsupported alignment (like an odd number) should result in an
-      // alignment of `alignof(std::max_align_t)`
-      auto const bad_alignment = alignment + 1;
-
-      EXPECT_THROW(this->ref.allocate_sync(allocation_size, bad_alignment), std::bad_alloc);
-    }
-  }
-}
-
 TEST(PinnedHostResource, isPinned)
 {
   rmm::mr::pinned_host_memory_resource mr;
diff --git a/cpp/tests/mr/limiting_mr_tests.cpp b/cpp/tests/mr/limiting_mr_tests.cpp
index ebd390851..a070c068a 100644
--- a/cpp/tests/mr/limiting_mr_tests.cpp
+++ b/cpp/tests/mr/limiting_mr_tests.cpp
@@ -16,18 +16,11 @@ namespace {
 
 using limiting_adaptor = rmm::mr::limiting_resource_adaptor;
 
-TEST(LimitingTest, ThrowOnNullUpstream)
-{
-  auto const max_size{5_MiB};
-  auto construct_nullptr = []() { limiting_adaptor mr{nullptr, max_size}; };
-  EXPECT_THROW(construct_nullptr(), rmm::logic_error);
-}
-
 TEST(LimitingTest, TooBig)
 {
   auto const max_size{5_MiB};
   limiting_adaptor mr{rmm::mr::get_current_device_resource_ref(), max_size};
-  EXPECT_THROW(mr.allocate_sync(max_size + 1), rmm::out_of_memory);
+  EXPECT_THROW((void)mr.allocate_sync(max_size + 1), rmm::out_of_memory);
 }
 
 TEST(LimitingTest, UpstreamFailure)
@@ -35,8 +28,8 @@ TEST(LimitingTest, UpstreamFailure)
   auto const max_size_1{2_MiB};
   auto const max_size_2{5_MiB};
   limiting_adaptor mr1{rmm::mr::get_current_device_resource_ref(), max_size_1};
-  limiting_adaptor mr2{&mr1, max_size_2};
-  EXPECT_THROW(mr2.allocate_sync(4_MiB), rmm::out_of_memory);
+  limiting_adaptor mr2{mr1, max_size_2};
+  EXPECT_THROW((void)mr2.allocate_sync(4_MiB), rmm::out_of_memory);
 }
 
 TEST(LimitingTest, UnderLimitDueToFrees)
@@ -81,7 +74,7 @@ TEST(LimitingTest, OverLimit)
   EXPECT_EQ(mr.get_allocated_bytes(), allocated_bytes);
   EXPECT_EQ(mr.get_allocation_limit() - mr.get_allocated_bytes(), max_size - allocated_bytes);
   auto const size2{3_MiB};
-  EXPECT_THROW(mr.allocate_sync(size2), rmm::out_of_memory);
+  EXPECT_THROW((void)mr.allocate_sync(size2), rmm::out_of_memory);
   EXPECT_EQ(mr.get_allocated_bytes(), allocated_bytes);
   EXPECT_EQ(mr.get_allocation_limit() - mr.get_allocated_bytes(), max_size - allocated_bytes);
   mr.deallocate_sync(ptr1, 4_MiB);
diff --git a/cpp/tests/mr/mr_ref_default_tests.cpp b/cpp/tests/mr/mr_ref_default_tests.cpp
index 52863af75..b976ff5e3 100644
--- a/cpp/tests/mr/mr_ref_default_tests.cpp
+++ b/cpp/tests/mr/mr_ref_default_tests.cpp
@@ -40,71 +40,37 @@ void spawn(Task task, Arguments&&... args)
 
 // Single-threaded default resource tests
 
-TEST(DefaultTest, CurrentDeviceResourceIsCUDA)
-{
-  EXPECT_NE(nullptr, rmm::mr::get_current_device_resource());
-  EXPECT_TRUE(rmm::mr::get_current_device_resource()->is_equal(rmm::mr::cuda_memory_resource{}));
-}
-
-TEST(DefaultTest, UseCurrentDeviceResource) { test_get_current_device_resource(); }
-
 TEST(DefaultTest, UseCurrentDeviceResourceRef) { test_get_current_device_resource_ref(); }
 
-TEST(DefaultTest, GetCurrentDeviceResource)
-{
-  auto* mr = rmm::mr::get_current_device_resource();
-  EXPECT_NE(nullptr, mr);
-  EXPECT_TRUE(mr->is_equal(rmm::mr::cuda_memory_resource{}));
-}
-
 TEST(DefaultTest, GetCurrentDeviceResourceRef)
 {
   auto mr = rmm::mr::get_current_device_resource_ref();
   EXPECT_EQ(mr, rmm::device_async_resource_ref{rmm::mr::detail::initial_resource()});
 }
 
-TEST(DefaultTest, SetCurrentDeviceResourceRefFromPointer)
+TEST(DefaultTest, SetCurrentDeviceResourceRef)
 {
-  // Construct a cuda_memory_resource
   rmm::mr::cuda_memory_resource cuda_mr{};
 
-  // Get a pointer to it (device_memory_resource*)
-  rmm::mr::device_memory_resource* mr_ptr = &cuda_mr;
-
-  // Set with set_current_device_resource_ref using the pointer
-  rmm::mr::set_current_device_resource_ref(mr_ptr);
+  rmm::mr::set_current_device_resource_ref(cuda_mr);
 
-  // Get the ref with get_current_device_resource_ref
   auto ref = rmm::mr::get_current_device_resource_ref();
 
-  // Use that ref to allocate
   constexpr std::size_t size{1024};
   void* ptr = ref.allocate_sync(size);
   EXPECT_NE(ptr, nullptr);
   EXPECT_TRUE(is_properly_aligned(ptr));
   EXPECT_TRUE(is_device_accessible_memory(ptr));
 
-  // Deallocate
   ref.deallocate_sync(ptr, size);
 
-  // Reset to initial resource
   rmm::mr::reset_current_device_resource_ref();
 }
 
 // Multi-threaded default resource tests
 
-TEST(DefaultTest, UseCurrentDeviceResource_mt) { spawn(test_get_current_device_resource); }
-
 TEST(DefaultTest, UseCurrentDeviceResourceRef_mt) { spawn(test_get_current_device_resource_ref); }
 
-TEST(DefaultTest, CurrentDeviceResourceIsCUDA_mt)
-{
-  spawn([]() {
-    EXPECT_NE(nullptr, rmm::mr::get_current_device_resource());
-    EXPECT_TRUE(rmm::mr::get_current_device_resource()->is_equal(rmm::mr::cuda_memory_resource{}));
-  });
-}
-
 TEST(DefaultTest, CurrentDeviceResourceRefIsCUDA_mt)
 {
   spawn([]() {
@@ -113,15 +79,6 @@ TEST(DefaultTest, CurrentDeviceResourceRefIsCUDA_mt)
   });
 }
 
-TEST(DefaultTest, GetCurrentDeviceResource_mt)
-{
-  spawn([]() {
-    rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource();
-    EXPECT_NE(nullptr, mr);
-    EXPECT_TRUE(mr->is_equal(rmm::mr::cuda_memory_resource{}));
-  });
-}
-
 TEST(DefaultTest, GetCurrentDeviceResourceRef_mt)
 {
   spawn([]() {
diff --git a/cpp/tests/mr/mr_ref_test.hpp b/cpp/tests/mr/mr_ref_test.hpp
index eac0dd4a9..aae8ae8fa 100644
--- a/cpp/tests/mr/mr_ref_test.hpp
+++ b/cpp/tests/mr/mr_ref_test.hpp
@@ -90,16 +90,6 @@ struct allocation {
 
 // Various test functions, shared between single-threaded and multithreaded tests.
 
-inline void test_get_current_device_resource()
-{
-  EXPECT_NE(nullptr, rmm::mr::get_current_device_resource());
-  void* ptr = rmm::mr::get_current_device_resource()->allocate_sync(1_MiB);
-  EXPECT_NE(nullptr, ptr);
-  EXPECT_TRUE(is_properly_aligned(ptr));
-  EXPECT_TRUE(is_device_accessible_memory(ptr));
-  rmm::mr::get_current_device_resource()->deallocate_sync(ptr, 1_MiB);
-}
-
 inline void test_get_current_device_resource_ref()
 {
   void* ptr = rmm::mr::get_current_device_resource_ref().allocate_sync(1_MiB);
diff --git a/cpp/tests/mr/pinned_host_pool_mr_tests.cpp b/cpp/tests/mr/pinned_host_pool_mr_tests.cpp
index 83bf2b628..830759f7b 100644
--- a/cpp/tests/mr/pinned_host_pool_mr_tests.cpp
+++ b/cpp/tests/mr/pinned_host_pool_mr_tests.cpp
@@ -45,7 +45,7 @@ TEST(PinnedPoolTest, InitialAndMaxPoolSizeEqual)
   EXPECT_NO_THROW([]() {
     rmm::mr::pinned_host_memory_resource pinned_mr{};
     pool_mr mr(pinned_mr, 1000192, 1000192);
-    mr.allocate_sync(1000);
+    (void)mr.allocate_sync(1000);
   }());
 }
 
@@ -55,7 +55,7 @@ TEST(PinnedPoolTest, NonAlignedPoolSize)
     []() {
       rmm::mr::pinned_host_memory_resource pinned_mr{};
       pool_mr mr(pinned_mr, 1000031, 1000192);
-      mr.allocate_sync(1000);
+      (void)mr.allocate_sync(1000);
     }(),
     rmm::logic_error);
 
@@ -63,7 +63,7 @@ TEST(PinnedPoolTest, NonAlignedPoolSize)
     []() {
       rmm::mr::pinned_host_memory_resource pinned_mr{};
       pool_mr mr(pinned_mr, 1000192, 1000200);
-      mr.allocate_sync(1000);
+      (void)mr.allocate_sync(1000);
     }(),
     rmm::logic_error);
 }
@@ -74,9 +74,9 @@ TEST(PinnedPoolTest, ThrowOutOfMemory)
   const auto initial{0};
   const auto maximum{1024};
   pool_mr mr{pinned_mr, initial, maximum};
-  mr.allocate_sync(1024);
+  (void)mr.allocate_sync(1024);
 
-  EXPECT_THROW(mr.allocate_sync(1024), rmm::out_of_memory);
+  EXPECT_THROW((void)mr.allocate_sync(1024), rmm::out_of_memory);
 }
 
 }  // namespace
diff --git a/cpp/tests/mr/polymorphic_allocator_tests.cpp b/cpp/tests/mr/polymorphic_allocator_tests.cpp
index 856b81fdc..e3ef3274a 100644
--- a/cpp/tests/mr/polymorphic_allocator_tests.cpp
+++ b/cpp/tests/mr/polymorphic_allocator_tests.cpp
@@ -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
  */
 
@@ -23,14 +23,13 @@ struct allocator_test : public ::testing::Test {
 TEST_F(allocator_test, default_resource)
 {
   rmm::mr::polymorphic_allocator<int> allocator{};
-  EXPECT_EQ(allocator.get_upstream_resource(),
-            rmm::device_async_resource_ref{rmm::mr::get_current_device_resource()});
+  EXPECT_EQ(allocator.get_upstream_resource(), rmm::mr::get_current_device_resource_ref());
 }
 
 TEST_F(allocator_test, custom_resource)
 {
   rmm::mr::cuda_memory_resource mr;
-  rmm::mr::polymorphic_allocator<int> allocator{&mr};
+  rmm::mr::polymorphic_allocator<int> allocator{mr};
   EXPECT_EQ(allocator.get_upstream_resource(), rmm::device_async_resource_ref{mr});
 }
 
@@ -52,10 +51,10 @@ TEST_F(allocator_test, self_equality)
 TEST_F(allocator_test, equal_resources)
 {
   rmm::mr::cuda_memory_resource mr0;
-  rmm::mr::polymorphic_allocator<int> alloc0{&mr0};
+  rmm::mr::polymorphic_allocator<int> alloc0{mr0};
 
   rmm::mr::cuda_memory_resource mr1;
-  rmm::mr::polymorphic_allocator<int> alloc1{&mr1};
+  rmm::mr::polymorphic_allocator<int> alloc1{mr1};
   EXPECT_EQ(alloc0, alloc1);
   EXPECT_FALSE(alloc0 != alloc1);
 }
@@ -63,10 +62,10 @@ TEST_F(allocator_test, equal_resources)
 TEST_F(allocator_test, unequal_resources)
 {
   rmm::mr::managed_memory_resource mr0;
-  rmm::mr::polymorphic_allocator<int> alloc0{&mr0};
+  rmm::mr::polymorphic_allocator<int> alloc0{mr0};
 
   rmm::mr::cuda_memory_resource mr1;
-  rmm::mr::polymorphic_allocator<int> alloc1{&mr1};
+  rmm::mr::polymorphic_allocator<int> alloc1{mr1};
   EXPECT_NE(alloc0, alloc1);
 }
 
diff --git a/cpp/tests/mr/pool_mr_tests.cpp b/cpp/tests/mr/pool_mr_tests.cpp
index b7197bd2f..364358724 100644
--- a/cpp/tests/mr/pool_mr_tests.cpp
+++ b/cpp/tests/mr/pool_mr_tests.cpp
@@ -7,7 +7,6 @@
 #include <rmm/detail/error.hpp>
 #include <rmm/device_buffer.hpp>
 #include <rmm/mr/cuda_memory_resource.hpp>
-#include <rmm/mr/device_memory_resource.hpp>
 #include <rmm/mr/limiting_resource_adaptor.hpp>
 #include <rmm/mr/per_device_resource.hpp>
 #include <rmm/mr/pool_memory_resource.hpp>
@@ -65,22 +64,22 @@ TEST(PoolTest, ForceGrowth)
   cuda_mr cuda;
   {
     auto const max_size{6000};
-    limiting_mr limiter{&cuda, max_size};
+    limiting_mr limiter{cuda, max_size};
     pool_mr mr{limiter, 0};
-    EXPECT_NO_THROW(mr.allocate_sync(1000));
-    EXPECT_NO_THROW(mr.allocate_sync(4000));
-    EXPECT_NO_THROW(mr.allocate_sync(500));
-    EXPECT_THROW(mr.allocate_sync(2000), rmm::out_of_memory);  // too much
+    EXPECT_NO_THROW((void)mr.allocate_sync(1000));
+    EXPECT_NO_THROW((void)mr.allocate_sync(4000));
+    EXPECT_NO_THROW((void)mr.allocate_sync(500));
+    EXPECT_THROW((void)mr.allocate_sync(2000), rmm::out_of_memory);  // too much
   }
   {
     // with max pool size
     auto const max_size{6000};
-    limiting_mr limiter{&cuda, max_size};
+    limiting_mr limiter{cuda, max_size};
     pool_mr mr{limiter, 0, 8192};
-    EXPECT_NO_THROW(mr.allocate_sync(1000));
-    EXPECT_THROW(mr.allocate_sync(4000), rmm::out_of_memory);  // too much
-    EXPECT_NO_THROW(mr.allocate_sync(500));
-    EXPECT_NO_THROW(mr.allocate_sync(2000));  // fits
+    EXPECT_NO_THROW((void)mr.allocate_sync(1000));
+    EXPECT_THROW((void)mr.allocate_sync(4000), rmm::out_of_memory);  // too much
+    EXPECT_NO_THROW((void)mr.allocate_sync(500));
+    EXPECT_NO_THROW((void)mr.allocate_sync(2000));  // fits
   }
 }
 
@@ -90,9 +89,9 @@ TEST(PoolTest, DeletedStream)
   cudaStream_t stream{};  // we don't use rmm::cuda_stream here to make destruction more explicit
   const int size = 10000;
   EXPECT_EQ(cudaSuccess, cudaStreamCreate(&stream));
-  EXPECT_NO_THROW(rmm::device_buffer buff(size, cuda_stream_view{stream}, &mr));
+  EXPECT_NO_THROW(rmm::device_buffer buff(size, cuda_stream_view{stream}, mr));
   EXPECT_EQ(cudaSuccess, cudaStreamDestroy(stream));
-  EXPECT_NO_THROW(mr.allocate_sync(size));
+  EXPECT_NO_THROW((void)mr.allocate_sync(size));
 }
 
 // Issue #527
@@ -100,7 +99,7 @@ TEST(PoolTest, InitialAndMaxPoolSizeEqual)
 {
   EXPECT_NO_THROW([]() {
     pool_mr mr(rmm::mr::get_current_device_resource_ref(), 1000192, 1000192);
-    mr.allocate_sync(1000);
+    (void)mr.allocate_sync(1000);
   }());
 }
 
@@ -109,14 +108,14 @@ TEST(PoolTest, NonAlignedPoolSize)
   EXPECT_THROW(
     []() {
       pool_mr mr(rmm::mr::get_current_device_resource_ref(), 1000031, 1000192);
-      mr.allocate_sync(1000);
+      (void)mr.allocate_sync(1000);
     }(),
     rmm::logic_error);
 
   EXPECT_THROW(
     []() {
       pool_mr mr(rmm::mr::get_current_device_resource_ref(), 1000192, 1000200);
-      mr.allocate_sync(1000);
+      (void)mr.allocate_sync(1000);
     }(),
     rmm::logic_error);
 }
diff --git a/cpp/tests/mr/prefetch_resource_adaptor_tests.cpp b/cpp/tests/mr/prefetch_resource_adaptor_tests.cpp
index 2365ccd30..7fcc986b2 100644
--- a/cpp/tests/mr/prefetch_resource_adaptor_tests.cpp
+++ b/cpp/tests/mr/prefetch_resource_adaptor_tests.cpp
@@ -73,7 +73,7 @@ TYPED_TEST_SUITE(PrefetchAdaptorTest, resources);
 TYPED_TEST(PrefetchAdaptorTest, PointerAndSize)
 {
   prefetch_adaptor prefetch_mr{this->mr};
-  rmm::device_buffer buff(this->size, this->stream, &prefetch_mr);
+  rmm::device_buffer buff(this->size, this->stream, prefetch_mr);
   // verify data range has been prefetched
   this->expect_prefetched(buff.data(), buff.size(), rmm::get_current_cuda_device());
   // verify that prefetching does not error
@@ -85,6 +85,6 @@ TYPED_TEST(PrefetchAdaptorTest, PointerAndSize)
 TYPED_TEST(PrefetchAdaptorTest, NotPrefetchedWithoutAdaptor)
 {
   // verify not prefetched without adaptor
-  rmm::device_buffer buff(this->size, this->stream, &this->mr);
+  rmm::device_buffer buff(this->size, this->stream, this->mr);
   this->expect_prefetched(buff.data(), buff.size(), rmm::cuda_device_id(cudaInvalidDeviceId));
 }
diff --git a/cpp/tests/mr/statistics_mr_tests.cpp b/cpp/tests/mr/statistics_mr_tests.cpp
index cfd69aa71..30ae9ac91 100644
--- a/cpp/tests/mr/statistics_mr_tests.cpp
+++ b/cpp/tests/mr/statistics_mr_tests.cpp
@@ -6,6 +6,7 @@
 #include "../byte_literals.hpp"
 #include "delayed_memory_resource.hpp"
 
+#include <rmm/aligned.hpp>
 #include <rmm/cuda_stream.hpp>
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/device_buffer.hpp>
@@ -61,14 +62,14 @@ TEST_P(allocation_size, MultiThreaded)
     threads.emplace_back([&, i = i]() {
       void* ptr{nullptr};
       if (i != 0) { std::this_thread::sleep_for(std::chrono::milliseconds{100}); }
-      EXPECT_NO_THROW(ptr = mr.allocate(stream, allocation_size));
+      EXPECT_NO_THROW(ptr = mr.allocate(stream, allocation_size, rmm::CUDA_ALLOCATION_ALIGNMENT));
       if (allocation_size != 0) {
         EXPECT_NE(ptr, nullptr);
       } else {
         EXPECT_EQ(ptr, nullptr);
       }
       if (i == 0) { std::this_thread::sleep_for(std::chrono::milliseconds{100}); }
-      mr.deallocate(stream, ptr, allocation_size);
+      mr.deallocate(stream, ptr, allocation_size, rmm::CUDA_ALLOCATION_ALIGNMENT);
     });
   }
   for (auto& t : threads) {
@@ -80,12 +81,6 @@ TEST_P(allocation_size, MultiThreaded)
   EXPECT_EQ(mr.get_bytes_counter().total, 2 * allocation_size);
 }
 
-TEST(StatisticsTest, ThrowOnNullUpstream)
-{
-  auto construct_nullptr = []() { statistics_adaptor mr{nullptr}; };
-  EXPECT_THROW(construct_nullptr(), rmm::logic_error);
-}
-
 TEST(StatisticsTest, Empty)
 {
   statistics_adaptor mr{rmm::mr::get_current_device_resource_ref()};
diff --git a/cpp/tests/mr/stream_allocator_adaptor_tests.cpp b/cpp/tests/mr/stream_allocator_adaptor_tests.cpp
index ee8513201..f77d3f25d 100644
--- a/cpp/tests/mr/stream_allocator_adaptor_tests.cpp
+++ b/cpp/tests/mr/stream_allocator_adaptor_tests.cpp
@@ -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
  */
 
@@ -51,11 +51,11 @@ TEST_F(allocator_test, equal_allocators)
 TEST_F(allocator_test, unequal_resources)
 {
   rmm::mr::cuda_memory_resource mr0;
-  rmm::mr::polymorphic_allocator<int> alloc0{&mr0};
+  rmm::mr::polymorphic_allocator<int> alloc0{mr0};
   auto adapted0 = rmm::mr::stream_allocator_adaptor(alloc0, stream);
 
   rmm::mr::managed_memory_resource mr1;
-  rmm::mr::polymorphic_allocator<int> alloc1{&mr1};
+  rmm::mr::polymorphic_allocator<int> alloc1{mr1};
   auto adapted1 = rmm::mr::stream_allocator_adaptor(alloc1, stream);
 
   EXPECT_NE(adapted0, adapted1);
diff --git a/cpp/tests/mr/system_mr_tests.cu b/cpp/tests/mr/system_mr_tests.cu
index 5ff49e274..c18e0fc4d 100644
--- a/cpp/tests/mr/system_mr_tests.cu
+++ b/cpp/tests/mr/system_mr_tests.cu
@@ -122,7 +122,7 @@ TEST_F(SystemMRTest, HeadroomMRDifferentParametersUnequal)
 {
   headroom_mr mr1{size_mb};
   headroom_mr mr2{size_gb};
-  EXPECT_FALSE(mr1.is_equal(mr2));
+  EXPECT_NE(mr1, mr2);
 }
 }  // namespace
 }  // namespace rmm::test
diff --git a/cpp/tests/mr/tracking_mr_tests.cpp b/cpp/tests/mr/tracking_mr_tests.cpp
index e693a2845..ec7b0a6c1 100644
--- a/cpp/tests/mr/tracking_mr_tests.cpp
+++ b/cpp/tests/mr/tracking_mr_tests.cpp
@@ -6,6 +6,7 @@
 #include "../byte_literals.hpp"
 #include "delayed_memory_resource.hpp"
 
+#include <rmm/aligned.hpp>
 #include <rmm/cuda_stream.hpp>
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/detail/error.hpp>
@@ -66,14 +67,14 @@ TEST_P(allocation_size, MultiThreaded)
     threads.emplace_back([&, i = i]() {
       void* ptr{nullptr};
       if (i != 0) { std::this_thread::sleep_for(std::chrono::milliseconds{100}); }
-      EXPECT_NO_THROW(ptr = mr.allocate(stream, allocation_size));
+      EXPECT_NO_THROW(ptr = mr.allocate(stream, allocation_size, rmm::CUDA_ALLOCATION_ALIGNMENT));
       if (allocation_size != 0) {
         EXPECT_NE(ptr, nullptr);
       } else {
         EXPECT_EQ(ptr, nullptr);
       }
       if (i == 0) { std::this_thread::sleep_for(std::chrono::milliseconds{100}); }
-      mr.deallocate(stream, ptr, allocation_size);
+      mr.deallocate(stream, ptr, allocation_size, rmm::CUDA_ALLOCATION_ALIGNMENT);
     });
   }
   for (auto& t : threads) {
@@ -83,12 +84,6 @@ TEST_P(allocation_size, MultiThreaded)
   EXPECT_EQ(mr.get_allocated_bytes(), 0);
 }
 
-TEST(TrackingTest, ThrowOnNullUpstream)
-{
-  auto construct_nullptr = []() { tracking_adaptor mr{nullptr}; };
-  EXPECT_THROW(construct_nullptr(), rmm::logic_error);
-}
-
 TEST(TrackingTest, Empty)
 {
   tracking_adaptor mr{rmm::mr::get_current_device_resource_ref()};
diff --git a/cpp/tests/prefetch_tests.cpp b/cpp/tests/prefetch_tests.cpp
index 30fe0a647..4ae054f1a 100644
--- a/cpp/tests/prefetch_tests.cpp
+++ b/cpp/tests/prefetch_tests.cpp
@@ -70,7 +70,7 @@ TYPED_TEST_SUITE(PrefetchTest, resources);
 
 TYPED_TEST(PrefetchTest, PointerAndSize)
 {
-  rmm::device_buffer buff(this->size, this->stream, &this->mr);
+  rmm::device_buffer buff(this->size, this->stream, this->mr);
   // verify not prefetched before prefetching
   this->expect_prefetched(buff.data(), buff.size(), rmm::cuda_device_id(cudaInvalidDeviceId));
   rmm::prefetch(buff.data(), buff.size(), rmm::get_current_cuda_device(), this->stream);
@@ -81,14 +81,14 @@ TYPED_TEST(PrefetchTest, PointerAndSize)
 TYPED_TEST(PrefetchTest, DeviceUVector)
 {
   {
-    rmm::device_uvector<int> uvec(this->size, this->stream, &this->mr);
+    rmm::device_uvector<int> uvec(this->size, this->stream, this->mr);
     rmm::prefetch<int>(uvec, rmm::get_current_cuda_device(), this->stream);
     this->expect_prefetched(uvec.data(), uvec.size() * sizeof(int), rmm::get_current_cuda_device());
   }
 
   // test iterator range of part of the vector (implicitly constructs a span)
   {
-    rmm::device_uvector<int> uvec(this->size, this->stream, &this->mr);
+    rmm::device_uvector<int> uvec(this->size, this->stream, this->mr);
     rmm::prefetch<int>(
       {uvec.begin(), std::next(uvec.begin(), static_cast<std::ptrdiff_t>(this->size / 2))},  // span
       rmm::get_current_cuda_device(),
@@ -100,7 +100,7 @@ TYPED_TEST(PrefetchTest, DeviceUVector)
 
 TYPED_TEST(PrefetchTest, DeviceScalar)
 {
-  rmm::device_scalar<int> scalar(this->stream, &this->mr);
+  rmm::device_scalar<int> scalar(this->stream, this->mr);
   // Implicitly constructs a span from the data and size
   rmm::prefetch<int>({scalar.data(), scalar.size()}, rmm::get_current_cuda_device(), this->stream);
   this->expect_prefetched(scalar.data(), sizeof(int), rmm::get_current_cuda_device());