cuda-cccl 0.3.2__cp313-cp313-manylinux_2_24_aarch64.whl → 0.3.4__cp313-cp313-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/__memory_resource/device_memory_pool.h

@@ -0,0 +1,149 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___MEMORY_RESOURCE_DEVICE_MEMORY_POOL_H
+#define _CUDA___MEMORY_RESOURCE_DEVICE_MEMORY_POOL_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if _CCCL_CUDA_COMPILER(CLANG)
+#  include <cuda_runtime.h>
+#  include <cuda_runtime_api.h>
+#endif // _CCCL_CUDA_COMPILER(CLANG)
+
+#include <cuda/__memory_resource/get_property.h>
+#include <cuda/__memory_resource/memory_resource_base.h>
+#include <cuda/__memory_resource/properties.h>
+#include <cuda/__runtime/api_wrapper.h>
+#include <cuda/std/__concepts/concept_macros.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+//! @file
+//! The \c device_memory_pool class provides an asynchronous memory resource that allocates device memory in stream
+//! order.
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+//! @rst
+//! .. _cudax-memory-resource-async:
+//!
+//! Stream ordered memory pool
+//! ------------------------------
+//!
+//! ``device_memory_pool_ref`` allocates device memory using `cudaMallocFromPoolAsync / cudaFreeAsync
+//! <https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__MEMORY__POOLS.html>`__ for allocation/deallocation. A
+//! ``device_memory_pool_ref`` is a thin wrapper around a \c cudaMemPool_t with the location type set to \c
+//! cudaMemLocationTypeDevice.
+//!
+//! .. warning::
+//!
+//!    ``device_memory_pool_ref`` does not own the pool and it is the responsibility of the user to ensure that the
+//!    lifetime of the pool exceeds the lifetime of the ``device_memory_pool_ref``.
+//!
+//! @endrst
+class device_memory_pool_ref : public __memory_resource_base
+{
+public:
+  //! @brief  Constructs the device_memory_pool_ref from a \c cudaMemPool_t.
+  //! @param __pool The \c cudaMemPool_t used to allocate memory.
+  _CCCL_HOST_API explicit device_memory_pool_ref(::cudaMemPool_t __pool) noexcept
+      : __memory_resource_base(__pool)
+  {}
+
+  device_memory_pool_ref(int)                    = delete;
+  device_memory_pool_ref(::cuda::std::nullptr_t) = delete;
+
+  //! @brief Enables the \c device_accessible property for \c device_memory_pool_ref.
+  //! @relates device_memory_pool_ref
+  _CCCL_HOST_API friend constexpr void
+  get_property(device_memory_pool_ref const&, ::cuda::mr::device_accessible) noexcept
+  {}
+
+  using default_queries = ::cuda::mr::properties_list<::cuda::mr::device_accessible>;
+};
+
+//! @brief  Returns the default ``cudaMemPool_t`` from the specified device.
+//! @throws cuda_error if retrieving the default ``cudaMemPool_t`` fails.
+//! @returns The default memory pool of the specified device.
+[[nodiscard]] inline device_memory_pool_ref device_default_memory_pool(::cuda::device_ref __device)
+{
+  ::cuda::__verify_device_supports_stream_ordered_allocations(__device.get());
+
+  ::cudaMemPool_t __pool;
+  _CCCL_TRY_CUDA_API(
+    ::cudaDeviceGetDefaultMemPool, "Failed to call cudaDeviceGetDefaultMemPool", &__pool, __device.get());
+  return device_memory_pool_ref{__pool};
+}
+
+//! @rst
+//! .. _cudax-memory-resource-async:
+//!
+//! Stream ordered memory resource
+//! ------------------------------
+//!
+//! ``device_memory_pool`` allocates device memory using `cudaMallocFromPoolAsync / cudaFreeAsync
+//! <https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__MEMORY__POOLS.html>`__ for allocation/deallocation. A
+//! When constructed it creates an underlying \c cudaMemPool_t with the location type set to \c
+//! cudaMemLocationTypeDevice and owns it.
+//!
+//! @endrst
+struct device_memory_pool : device_memory_pool_ref
+{
+  using reference_type = device_memory_pool_ref;
+
+  //! @brief Constructs a \c device_memory_pool with the optionally specified initial pool size and release
+  //! threshold. If the pool size grows beyond the release threshold, unused memory held by the pool will be released at
+  //! the next synchronization event.
+  //! @throws cuda_error if the CUDA version does not support ``cudaMallocAsync``.
+  //! @param __device_id The device id of the device the stream pool is constructed on.
+  //! @param __pool_properties Optional, additional properties of the pool to be created.
+  _CCCL_HOST_API device_memory_pool(::cuda::device_ref __device_id, memory_pool_properties __properties = {})
+      : device_memory_pool_ref(__create_cuda_mempool(
+          __properties,
+          ::CUmemLocation{::CU_MEM_LOCATION_TYPE_DEVICE, __device_id.get()},
+          ::CU_MEM_ALLOCATION_TYPE_PINNED))
+  {}
+
+  ~device_memory_pool() noexcept
+  {
+    ::cuda::__driver::__mempoolDestroy(__pool_);
+  }
+
+  _CCCL_HOST_API static device_memory_pool from_native_handle(::cudaMemPool_t __pool) noexcept
+  {
+    return device_memory_pool(__pool);
+  }
+
+  device_memory_pool(const device_memory_pool&)            = delete;
+  device_memory_pool& operator=(const device_memory_pool&) = delete;
+
+private:
+  device_memory_pool(::cudaMemPool_t __pool) noexcept
+      : device_memory_pool_ref(__pool)
+  {}
+};
+
+static_assert(::cuda::mr::synchronous_resource_with<device_memory_pool_ref, ::cuda::mr::device_accessible>, "");
+
+static_assert(::cuda::mr::resource_with<device_memory_pool, ::cuda::mr::device_accessible>, "");
+
+_CCCL_END_NAMESPACE_CUDA
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif //_CUDA___MEMORY_RESOURCE_DEVICE_MEMORY_POOL_H

cuda/cccl/headers/include/cuda/__memory_resource/get_property.h

@@ -8,8 +8,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _CUDA__MEMORY_RESOURCE_GET_PROPERTY_H
-#define _CUDA__MEMORY_RESOURCE_GET_PROPERTY_H
+#ifndef _CUDA___MEMORY_RESOURCE_GET_PROPERTY_H
+#define _CUDA___MEMORY_RESOURCE_GET_PROPERTY_H
 
 #include <cuda/std/detail/__config>
 
@@ -150,4 +150,4 @@ _CCCL_END_NAMESPACE_CUDA
 
 #include <cuda/std/__cccl/epilogue.h>
 
-#endif //_CUDA__MEMORY_RESOURCE_GET_PROPERTY_H
+#endif //_CUDA___MEMORY_RESOURCE_GET_PROPERTY_H

cuda/cccl/headers/include/cuda/__memory_resource/legacy_managed_memory_resource.h

@@ -0,0 +1,148 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___MEMORY_RESOURCE_LEGACY_MANAGED_MEMORY_RESOURCE_H
+#define _CUDA___MEMORY_RESOURCE_LEGACY_MANAGED_MEMORY_RESOURCE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if _CCCL_CUDA_COMPILER(CLANG)
+#  include <cuda_runtime_api.h>
+#endif // _CCCL_CUDA_COMPILER(CLANG)
+
+#include <cuda/__memory_resource/any_resource.h>
+#include <cuda/__memory_resource/get_property.h>
+#include <cuda/__memory_resource/properties.h>
+#include <cuda/__memory_resource/resource.h>
+#include <cuda/__runtime/api_wrapper.h>
+#include <cuda/__stream/internal_streams.h>
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__exception/throw_error.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+//! @file
+//! The \c managed_memory_resource class provides a memory resource that allocates managed memory.
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+//! @brief \c managed_memory_resource uses `cudaMallocManaged` / `cudaFree` for allocation / deallocation.
+class legacy_managed_memory_resource
+{
+private:
+  unsigned int __flags_ = cudaMemAttachGlobal;
+
+  static constexpr unsigned int __available_flags = cudaMemAttachGlobal | cudaMemAttachHost;
+
+public:
+  //! @brief Construct a new legacy_managed_memory_resource.
+  //! @note Synchronous allocations in CUDA are tied to a device, even if not located in device memory.
+  //! This constructor takes an optional device argument to specify the device that should be tied to allocations
+  //! for the resource. This association has the effect of initializing that device and the memory being implicitly
+  //! freed if the device is reset.
+  _CCCL_HOST_API constexpr legacy_managed_memory_resource(
+    const unsigned int __flags = cudaMemAttachGlobal, device_ref __device = {0}) noexcept
+      : __flags_(__flags & __available_flags)
+      , __device_(__device)
+  {
+    _CCCL_ASSERT(__flags_ == __flags, "Unexpected flags passed to legacy_managed_memory_resource");
+  }
+
+  //! @brief Allocate CUDA unified memory of size at least \p __bytes.
+  //! @param __bytes The size in bytes of the allocation.
+  //! @param __alignment The requested alignment of the allocation.
+  //! @throw std::invalid_argument in case of invalid alignment or \c cuda::cuda_error of the returned error code.
+  //! @return Pointer to the newly allocated memory
+  [[nodiscard]] _CCCL_HOST_API void*
+  allocate_sync(const size_t __bytes, const size_t __alignment = ::cuda::mr::default_cuda_malloc_alignment)
+  {
+    // We need to ensure that the provided alignment matches the minimal provided alignment
+    if (!__is_valid_alignment(__alignment))
+    {
+      ::cuda::std::__throw_invalid_argument(
+        "Invalid alignment passed to "
+        "legacy_managed_memory_resource::allocate_sync.");
+    }
+
+    ::cuda::__ensure_current_context __guard(__device_);
+    ::CUdeviceptr __ptr = ::cuda::__driver::__mallocManaged(__bytes, __flags_);
+    return reinterpret_cast<void*>(__ptr);
+  }
+
+  //! @brief Deallocate memory pointed to by \p __ptr.
+  //! @param __ptr Pointer to be deallocated. Must have been allocated through a call to `allocate` or `allocate_sync`
+  //! @param __bytes The number of bytes that was passed to the allocation call that returned \p __ptr.
+  //! @param __alignment The alignment that was passed to the allocation call that returned \p __ptr.
+  _CCCL_HOST_API void deallocate_sync(
+    void* __ptr,
+    const size_t,
+    [[maybe_unused]] const size_t __alignment = ::cuda::mr::default_cuda_malloc_alignment) noexcept
+  {
+    // We need to ensure that the provided alignment matches the minimal provided alignment
+    _CCCL_ASSERT(__is_valid_alignment(__alignment),
+                 "Invalid alignment passed to legacy_managed_memory_resource::deallocate_sync.");
+    _CCCL_ASSERT_CUDA_API(::cuda::__driver::__freeNoThrow,
+                          "legacy_managed_memory_resource::deallocate_sync failed",
+                          reinterpret_cast<::CUdeviceptr>(__ptr));
+  }
+
+  //! @brief Equality comparison with another \c managed_memory_resource.
+  //! @param __other The other \c managed_memory_resource.
+  //! @return Whether both \c managed_memory_resource were constructed with the same flags.
+  [[nodiscard]] _CCCL_HOST_API constexpr bool operator==(legacy_managed_memory_resource const& __other) const noexcept
+  {
+    return __flags_ == __other.__flags_;
+  }
+#if _CCCL_STD_VER <= 2017
+  //! @brief Inequality comparison with another \c managed_memory_resource.
+  //! @param __other The other \c managed_memory_resource.
+  //! @return Whether both \c managed_memory_resource were constructed with different flags.
+  [[nodiscard]] _CCCL_HOST_API constexpr bool operator!=(legacy_managed_memory_resource const& __other) const noexcept
+  {
+    return __flags_ != __other.__flags_;
+  }
+#endif // _CCCL_STD_VER <= 2017
+
+  //! @brief Enables the \c device_accessible property
+  _CCCL_HOST_API friend constexpr void
+  get_property(legacy_managed_memory_resource const&, ::cuda::mr::device_accessible) noexcept
+  {}
+  //! @brief Enables the \c host_accessible property
+  _CCCL_HOST_API friend constexpr void
+  get_property(legacy_managed_memory_resource const&, ::cuda::mr::host_accessible) noexcept
+  {}
+
+  //! @brief Checks whether the passed in alignment is valid
+  static constexpr bool __is_valid_alignment(const size_t __alignment) noexcept
+  {
+    return __alignment <= ::cuda::mr::default_cuda_malloc_alignment
+        && (::cuda::mr::default_cuda_malloc_alignment % __alignment == 0);
+  }
+
+  using default_queries = ::cuda::mr::properties_list<::cuda::mr::device_accessible, ::cuda::mr::host_accessible>;
+
+private:
+  device_ref __device_{0};
+};
+static_assert(::cuda::mr::synchronous_resource_with<legacy_managed_memory_resource, ::cuda::mr::device_accessible>, "");
+static_assert(::cuda::mr::synchronous_resource_with<legacy_managed_memory_resource, ::cuda::mr::host_accessible>, "");
+
+_CCCL_END_NAMESPACE_CUDA
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif //_CUDA___MEMORY_RESOURCE_LEGACY_MANAGED_MEMORY_RESOURCE_H

cuda/cccl/headers/include/cuda/__memory_resource/legacy_pinned_memory_resource.h

@@ -0,0 +1,139 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___MEMORY_RESOURCE_LEGACY_PINNED_MEMORY_RESOURCE_H
+#define _CUDA___MEMORY_RESOURCE_LEGACY_PINNED_MEMORY_RESOURCE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if _CCCL_CUDA_COMPILER(CLANG)
+#  include <cuda_runtime.h>
+#  include <cuda_runtime_api.h>
+#endif // _CCCL_CUDA_COMPILER(CLANG)
+
+#include <cuda/__memory_resource/memory_resource_base.h>
+#include <cuda/__memory_resource/properties.h>
+#include <cuda/__runtime/api_wrapper.h>
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__exception/throw_error.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+//! @file
+//! The \c legacy_pinned_memory_resource class provides a memory resource that allocates pinned memory.
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+//! @brief legacy_pinned_memory_resource uses `cudaMallocHost` / `cudaFreeAsync` for allocation / deallocation.
+//! @note This memory resource will be deprecated in the future. For CUDA 12.6 and above, use
+//! `cuda::experimental::pinned_memory_resource` instead, which is the long-term replacement.
+class legacy_pinned_memory_resource
+{
+public:
+  //! @brief Construct a new legacy_pinned_memory_resource.
+  //! @note Synchronous allocations in CUDA are tied to a device, even if not located in device memory.
+  //! This constructor takes an optional device argument to specify the device that should be tied to allocations
+  //! for the resource. This association has the effect of initializing that device and the memory being implicitly
+  //! freed if the device is reset.
+  _CCCL_HOST_API constexpr legacy_pinned_memory_resource(::cuda::device_ref __device = {0}) noexcept
+      : __device_(__device)
+  {}
+
+  //! @brief Allocate host memory of size at least \p __bytes.
+  //! @param __bytes The size in bytes of the allocation.
+  //! @param __alignment The requested alignment of the allocation.
+  //! @throw std::invalid_argument in case of invalid alignment or \c cuda::cuda_error of the returned error code.
+  //! @return Pointer to the newly allocated memory
+  [[nodiscard]] _CCCL_HOST_API void*
+  allocate_sync(const size_t __bytes, const size_t __alignment = ::cuda::mr::default_cuda_malloc_host_alignment)
+  {
+    // We need to ensure that the provided alignment matches the minimal provided alignment
+    if (!__is_valid_alignment(__alignment))
+    {
+      ::cuda::std::__throw_invalid_argument(
+        "Invalid alignment passed to "
+        "legacy_pinned_memory_resource::allocate_sync.");
+    }
+
+    ::cuda::__ensure_current_context __guard(__device_);
+    void* __ptr = ::cuda::__driver::__mallocHost(__bytes);
+    return __ptr;
+  }
+
+  //! @brief Deallocate memory pointed to by \p __ptr.
+  //! @param __ptr Pointer to be deallocated. Must have been allocated through a call to `allocate_sync`.
+  //! @param __bytes The number of bytes that was passed to the allocation call that returned \p __ptr.
+  //! @param __alignment The alignment that was passed to the allocation call that returned \p __ptr.
+  _CCCL_HOST_API void deallocate_sync(
+    void* __ptr,
+    const size_t,
+    [[maybe_unused]] const size_t __alignment = ::cuda::mr::default_cuda_malloc_host_alignment) noexcept
+  {
+    // We need to ensure that the provided alignment matches the minimal provided alignment
+    _CCCL_ASSERT(__is_valid_alignment(__alignment),
+                 "Invalid alignment passed to legacy_pinned_memory_resource::deallocate_sync.");
+    _CCCL_ASSERT_CUDA_API(
+      ::cuda::__driver::__freeHostNoThrow, "legacy_pinned_memory_resource::deallocate_sync failed", __ptr);
+  }
+
+  //! @brief Equality comparison with another \c legacy_pinned_memory_resource.
+  //! @param __other The other \c legacy_pinned_memory_resource.
+  //! @return Whether both \c legacy_pinned_memory_resource were constructed with the same flags.
+  [[nodiscard]] _CCCL_HOST_API constexpr bool operator==(legacy_pinned_memory_resource const&) const noexcept
+  {
+    return true;
+  }
+#if _CCCL_STD_VER <= 2017
+  //! @brief Equality comparison with another \c legacy_pinned_memory_resource.
+  //! @param __other The other \c legacy_pinned_memory_resource.
+  //! @return Whether both \c legacy_pinned_memory_resource were constructed with different flags.
+  [[nodiscard]] _CCCL_HOST_API constexpr bool operator!=(legacy_pinned_memory_resource const&) const noexcept
+  {
+    return false;
+  }
+#endif // _CCCL_STD_VER <= 2017
+
+  //! @brief Enables the \c device_accessible property
+  _CCCL_HOST_API friend constexpr void
+  get_property(legacy_pinned_memory_resource const&, ::cuda::mr::device_accessible) noexcept
+  {}
+  //! @brief Enables the \c host_accessible property
+  _CCCL_HOST_API friend constexpr void
+  get_property(legacy_pinned_memory_resource const&, ::cuda::mr::host_accessible) noexcept
+  {}
+
+  //! @brief Checks whether the passed in alignment is valid
+  static constexpr bool __is_valid_alignment(const size_t __alignment) noexcept
+  {
+    return __alignment <= ::cuda::mr::default_cuda_malloc_host_alignment
+        && (::cuda::mr::default_cuda_malloc_host_alignment % __alignment == 0);
+  }
+
+  using default_queries = ::cuda::mr::properties_list<::cuda::mr::device_accessible, ::cuda::mr::host_accessible>;
+
+private:
+  device_ref __device_{0};
+};
+
+static_assert(::cuda::mr::synchronous_resource_with<legacy_pinned_memory_resource, ::cuda::mr::device_accessible>, "");
+static_assert(::cuda::mr::synchronous_resource_with<legacy_pinned_memory_resource, ::cuda::mr::host_accessible>, "");
+
+_CCCL_END_NAMESPACE_CUDA
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif //_CUDA___MEMORY_RESOURCE_LEGACY_PINNED_MEMORY_RESOURCE_H

cuda/cccl/headers/include/cuda/__memory_resource/managed_memory_pool.h

@@ -0,0 +1,146 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___MEMORY_RESOURCE_MANAGED_MEMORY_POOL_H
+#define _CUDA___MEMORY_RESOURCE_MANAGED_MEMORY_POOL_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if _CCCL_CTK_AT_LEAST(13, 0)
+
+#  include <cuda/__memory_resource/memory_resource_base.h>
+#  include <cuda/__memory_resource/properties.h>
+#  include <cuda/std/__concepts/concept_macros.h>
+#  include <cuda/std/__exception/throw_error.h>
+
+#  include <cuda/std/__cccl/prologue.h>
+
+//! @file
+//! The \c managed_memory_resource class provides a memory resource that allocates managed memory.
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+[[nodiscard]] static ::cudaMemPool_t __get_default_managed_pool()
+{
+  return ::cuda::__driver::__getDefaultMemPool(
+    ::CUmemLocation{::CU_MEM_LOCATION_TYPE_NONE, 0}, ::CU_MEM_ALLOCATION_TYPE_MANAGED);
+}
+
+//! @rst
+//! .. _cudax-memory-resource-async:
+//!
+//! Stream ordered memory resource
+//! ------------------------------
+//!
+//! ``managed_memory_pool_ref`` allocates managed memory using `cudaMallocFromPoolAsync / cudaFreeAsync
+//! <https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__MEMORY__POOLS.html>`__ for allocation/deallocation. A
+//! ``managed_memory_pool_ref`` is a thin wrapper around a \c cudaMemPool_t with the allocation type set to \c
+//! cudaMemAllocationTypeManaged.
+//!
+//! .. warning::
+//!
+//!    ``managed_memory_pool_ref`` does not own the pool and it is the responsibility of the user to ensure that the
+//!    lifetime of the pool exceeds the lifetime of the ``managed_memory_pool_ref``.
+//!
+//! @endrst
+class managed_memory_pool_ref : public __memory_resource_base
+{
+public:
+  //! @brief  Constructs the managed_memory_pool_ref from a \c cudaMemPool_t.
+  //! @param __pool The \c cudaMemPool_t used to allocate memory.
+  _CCCL_HOST_API explicit managed_memory_pool_ref(::cudaMemPool_t __pool) noexcept
+      : __memory_resource_base(__pool)
+  {}
+
+  //! @brief Enables the \c device_accessible property
+  _CCCL_HOST_API friend constexpr void
+  get_property(managed_memory_pool_ref const&, ::cuda::mr::device_accessible) noexcept
+  {}
+  //! @brief Enables the \c host_accessible property
+  _CCCL_HOST_API friend constexpr void get_property(managed_memory_pool_ref const&, ::cuda::mr::host_accessible) noexcept
+  {}
+
+  using default_queries = ::cuda::mr::properties_list<::cuda::mr::device_accessible, ::cuda::mr::host_accessible>;
+};
+
+//! @brief Returns the default managed memory pool.
+//! @throws cuda_error if retrieving the default \c cudaMemPool_t fails.
+//! @returns The default managed memory pool.
+[[nodiscard]] inline managed_memory_pool_ref managed_default_memory_pool()
+{
+  return managed_memory_pool_ref{::cuda::__get_default_managed_pool()};
+}
+
+//! @rst
+//! .. _cudax-memory-resource-async:
+//!
+//! Stream ordered memory resource
+//! ------------------------------
+//!
+//! ``managed_memory_pool`` allocates managed memory using `cudaMallocFromPoolAsync / cudaFreeAsync
+//! <https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__MEMORY__POOLS.html>`__ for allocation/deallocation. A
+//! When constructed it creates an underlying \c cudaMemPool_t with the allocation type set to \c
+//! cudaMemAllocationTypeManaged and owns it.
+//!
+//! @endrst
+struct managed_memory_pool : managed_memory_pool_ref
+{
+  using reference_type = managed_memory_pool_ref;
+
+  //! @brief Constructs a \c managed_memory_pool with optional properties.
+  //! Properties include the initial pool size and the release threshold. If the pool size grows beyond the release
+  //! threshold, unused memory held by the pool will be released at the next synchronization event.
+  //! @param __properties Optional, additional properties of the pool to be created.
+  _CCCL_HOST_API managed_memory_pool(memory_pool_properties __properties = {})
+      : managed_memory_pool_ref(__create_cuda_mempool(
+          __properties, ::CUmemLocation{::CU_MEM_LOCATION_TYPE_NONE, 0}, ::CU_MEM_ALLOCATION_TYPE_MANAGED))
+  {}
+
+  // TODO add a constructor that accepts memory location one a type for it is added
+
+  ~managed_memory_pool() noexcept
+  {
+    ::cuda::__driver::__mempoolDestroy(__pool_);
+  }
+
+  _CCCL_HOST_API static managed_memory_pool from_native_handle(::cudaMemPool_t __pool) noexcept
+  {
+    return managed_memory_pool(__pool);
+  }
+
+  managed_memory_pool(const managed_memory_pool&)            = delete;
+  managed_memory_pool& operator=(const managed_memory_pool&) = delete;
+
+private:
+  managed_memory_pool(::cudaMemPool_t __pool) noexcept
+      : managed_memory_pool_ref(__pool)
+  {}
+};
+
+static_assert(::cuda::mr::resource_with<managed_memory_pool_ref, ::cuda::mr::device_accessible>, "");
+static_assert(::cuda::mr::resource_with<managed_memory_pool_ref, ::cuda::mr::host_accessible>, "");
+
+static_assert(::cuda::mr::resource_with<managed_memory_pool, ::cuda::mr::device_accessible>, "");
+static_assert(::cuda::mr::resource_with<managed_memory_pool, ::cuda::mr::host_accessible>, "");
+
+_CCCL_END_NAMESPACE_CUDA
+
+#  include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CCCL_CTK_AT_LEAST(13, 0)
+
+#endif //_CUDA___MEMORY_RESOURCE_MANAGED_MEMORY_POOL_H