Remove device_memory_resource inheritance from all resources and adaptors

Remove the device_memory_resource virtual base class inheritance from all
production memory resources, adaptors, and stream_ordered_memory_resource.

Resources now derive publicly from cuda::mr::shared_resource<Impl> (for
stateful/adaptor types) or stand alone with direct CCCL concept methods
(for stateless types). The legacy do_allocate/do_deallocate/do_is_equal
virtual overrides and pointer-based per-device-resource APIs are removed.

stream_ordered_memory_resource provides allocate/deallocate/allocate_sync/
deallocate_sync directly instead of through the DMR virtual dispatch.

All 103 C++ tests and 1165 Python tests pass.

Author: bdice

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;
@@ -146,14 +174,32 @@ 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,
@@ -165,6 +211,7 @@ class cccl_resource_ref {
                                                         ::rmm::detail::cccl_resource_ref> and
                              not is_specialization_of_v<std::remove_cv_t<OtherResourceType>,
                                                         ::rmm::detail::cccl_async_resource_ref> 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>
@@ -400,15 +447,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 <
@@ -422,6 +486,7 @@ class cccl_async_resource_ref {
                                  ::rmm::detail::cccl_resource_ref> and
       not is_specialization_of_v<std::remove_cv_t<OtherResourceType>,
                                  ::rmm::detail::cccl_async_resource_ref> 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>

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>,

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>,

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>,

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>,