cuda-cccl 0.4.3__cp312-cp312-manylinux_2_26_x86_64.whl

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

@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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_GET_MEMORY_RESOURCE_H
+#define _CUDA___MEMORY_RESOURCE_GET_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
+
+#include <cuda/__memory_resource/properties.h>
+#include <cuda/__memory_resource/resource.h>
+#include <cuda/__stream/stream_ref.h>
+#include <cuda/std/__concepts/equality_comparable.h>
+#include <cuda/std/__execution/env.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/remove_cvref.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_MR
+
+struct __get_memory_resource_t;
+
+template <class _Tp>
+_CCCL_CONCEPT __has_member_get_resource = _CCCL_REQUIRES_EXPR((_Tp), const _Tp& __t)(
+  requires(resource<::cuda::std::remove_cvref_t<decltype(__t.get_memory_resource())>>));
+
+template <class _Env>
+_CCCL_CONCEPT __has_query_get_memory_resource = _CCCL_REQUIRES_EXPR((_Env))(
+  requires(!__has_member_get_resource<_Env>),
+  requires(
+    resource<
+      ::cuda::std::remove_cvref_t<::cuda::std::execution::__query_result_t<const _Env&, __get_memory_resource_t>>>));
+
+//! @brief `__get_memory_resource_t` is a customization point object that queries a type `T` for an associated memory
+//! resource
+struct __get_memory_resource_t
+{
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_TEMPLATE(class _Tp)
+  _CCCL_REQUIRES(__has_member_get_resource<_Tp>)
+  [[nodiscard]] _CCCL_API constexpr decltype(auto) operator()(const _Tp& __t) const noexcept
+  {
+    static_assert(noexcept(__t.get_memory_resource()), "get_memory_resource must be noexcept");
+    return __t.get_memory_resource();
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_TEMPLATE(class _Env)
+  _CCCL_REQUIRES(__has_query_get_memory_resource<_Env>)
+  [[nodiscard]] _CCCL_API constexpr decltype(auto) operator()(const _Env& __env) const noexcept
+  {
+    static_assert(noexcept(__env.query(*this)), "get_memory_resource_t query must be noexcept");
+    return __env.query(*this);
+  }
+};
+
+_CCCL_GLOBAL_CONSTANT auto __get_memory_resource = __get_memory_resource_t{};
+
+using get_memory_resource_t = __get_memory_resource_t;
+
+_CCCL_GLOBAL_CONSTANT auto get_memory_resource = get_memory_resource_t{};
+
+_CCCL_END_NAMESPACE_CUDA_MR
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif //_CUDA__MEMORY_RESOURCE_GET_MEMORY_RESOURCE_H

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

@@ -0,0 +1,153 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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_GET_PROPERTY_H
+#define _CUDA___MEMORY_RESOURCE_GET_PROPERTY_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
+
+#include <cuda/std/__concepts/same_as.h>
+#include <cuda/std/__type_traits/remove_const_ref.h>
+#include <cuda/std/__type_traits/void_t.h>
+#include <cuda/std/__utility/declval.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+//! @brief The \c has_property concept verifies that a Resource satisfies a given Property
+//! @rst
+//! For \c has_property we require the following free function to be callable
+//!
+//! .. code cpp::
+//!
+//!    get_property(const Resource& res, Property prop);
+//!
+//! @endrst
+template <class _Resource, class _Property>
+_CCCL_CONCEPT has_property = _CCCL_REQUIRES_EXPR((_Resource, _Property), const _Resource& __res, _Property __prop)(
+  ((void) get_property(__res, __prop)));
+
+template <class _Property>
+using __property_value_t = typename _Property::value_type;
+
+//! @brief The \c property_with_value concept verifies that a Property is stateful and signals this through the
+//! `value_type` alias
+//! @rst
+//! .. code cpp::
+//!
+//!    struct stateless_property {};
+//!    static_assert(!cuda::property_with_value<stateless_property>);
+//!
+//!    struct stateful_property { using value_type = int; };
+//!    static_assert(!cuda::property_with_value<stateful_property>);
+//!
+//! @endrst
+template <class _Property>
+_CCCL_CONCEPT property_with_value = _CCCL_REQUIRES_EXPR((_Property))(typename(__property_value_t<_Property>));
+
+//! @brief The \c has_property_with concept verifies that a Resource satisfies a given stateful Property
+//! @rst
+//! For \c has_property_with we require the following free function to be callable and its return type to exactly match
+//! the ``value_type`` of the Property
+//!
+//! .. code cpp::
+//!
+//!    struct stateless_property {};
+//!    constexpr void get_property(const Resource& res, stateless_property) {}
+//!
+//!    // The resource must be stateful
+//!    static_assert(!cuda::has_property_with<Resource, stateless_property, int>);
+//!
+//!    struct stateful_property { using value_type = int; };
+//!    constexpr int get_property(const Resource& res, stateful_property) {}
+//!
+//!    // The resource is stateful and has the correct return type
+//!    static_assert(cuda::has_property_with<Resource, stateful_property, int>);
+//!
+//!    // The resource is stateful but the return type is incorrect
+//!    static_assert(!cuda::has_property_with<Resource, stateful_property, double>);
+//!
+//!    constexpr double get_property(const OtherResource& res, stateful_property) {}
+//!
+//!    // The resource is stateful but the value_type does not match the `get_property` return type
+//!    static_assert(!cuda::has_property_with<OtherResource, stateful_property, double>);
+//!
+//! @endrst
+template <class _Resource, class _Property, class _Return>
+_CCCL_CONCEPT_FRAGMENT(__has_property_with_,
+                       requires(const _Resource& __res)(
+                         requires(property_with_value<_Property>),
+                         requires(::cuda::std::same_as<_Return, decltype(get_property(__res, _Property{}))>)));
+template <class _Resource, class _Property, class _Return>
+_CCCL_CONCEPT has_property_with = _CCCL_FRAGMENT(__has_property_with_, _Resource, _Property, _Return);
+
+template <class _Resource, class _Upstream>
+_CCCL_CONCEPT_FRAGMENT(
+  __has_upstream_resource_,
+  requires(const _Resource& __res)(
+    requires(::cuda::std::same_as<::cuda::std::__remove_const_ref_t<decltype(__res.upstream_resource())>, _Upstream>)));
+template <class _Resource, class _Upstream>
+_CCCL_CONCEPT __has_upstream_resource = _CCCL_FRAGMENT(__has_upstream_resource_, _Resource, _Upstream);
+
+_CCCL_BEGIN_NAMESPACE_CPO(__forward_property)
+template <class _Derived, class _Upstream>
+struct __fn
+{
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_TEMPLATE(class _Property)
+  _CCCL_REQUIRES((!property_with_value<_Property>) _CCCL_AND has_property<_Upstream, _Property>)
+  _CCCL_API friend constexpr void get_property(const _Derived&, _Property) noexcept {}
+
+  // The indirection is needed, otherwise the compiler might believe that _Derived is an incomplete type
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_TEMPLATE(class _Property, class _Derived2 = _Derived)
+  _CCCL_REQUIRES(property_with_value<_Property> _CCCL_AND has_property<_Upstream, _Property> _CCCL_AND
+                   __has_upstream_resource<_Derived2, _Upstream>)
+  _CCCL_API friend constexpr __property_value_t<_Property> get_property(const _Derived& __res, _Property __prop)
+  {
+    return get_property(__res.upstream_resource(), __prop);
+  }
+};
+_CCCL_END_NAMESPACE_CPO
+
+//! @brief The \c forward_property CRTP template allows Derived to forward all properties of Upstream
+//! @rst
+//! .. code cpp::
+//!
+//!    class UpstreamWithProperties;
+//!
+//!    class DerivedClass : cuda::forward_properties<DerivedClass, UpstreamWithProperties> {
+//!      // This method is needed to forward stateful properties
+//!      UpstreamWithProperties& upstream_resource() const { ... }
+//!    };
+//!
+//! .. note::
+//!
+//!    In order to forward stateful properties, a type needs do implement an `upstream_resource()` method that returns
+//!    an instance of the upstream.
+//!
+//! @endrst
+template <class _Derived, class _Upstream>
+using forward_property = __forward_property::__fn<_Derived, _Upstream>;
+
+_CCCL_END_NAMESPACE_CUDA
+
+#include <cuda/std/__cccl/epilogue.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_MR
+
+//! @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
+  _CCCL_HOST_API 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_MR
+
+#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,141 @@
+//===----------------------------------------------------------------------===//
+//
+// 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/__device/device_ref.h>
+#include <cuda/__memory_resource/properties.h>
+#include <cuda/__memory_resource/resource.h>
+#include <cuda/__runtime/api_wrapper.h>
+#include <cuda/__runtime/ensure_current_context.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_MR
+
+//! @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::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
+  _CCCL_HOST_API 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_MR
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif //_CUDA___MEMORY_RESOURCE_LEGACY_PINNED_MEMORY_RESOURCE_H

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

@@ -0,0 +1,130 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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_PROPERTIES_H
+#define _CUDA___MEMORY_RESOURCE_PROPERTIES_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
+
+#include <cuda/std/__type_traits/decay.h>
+#include <cuda/std/__type_traits/type_set.h>
+#include <cuda/std/cstddef>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_MR
+
+//! @brief The default alignment by a cudaMalloc{...} call
+inline constexpr size_t default_cuda_malloc_alignment = 256;
+
+//! @brief The default alignment by a cudaMallocHost{...} call
+inline constexpr size_t default_cuda_malloc_host_alignment = alignof(::cuda::std::max_align_t);
+
+//! @brief The device_accessible property signals that the allocated memory is device accessible
+struct device_accessible
+{};
+
+//! @brief The device_accessible property signals that the allocated memory is host accessible
+struct host_accessible
+{};
+
+//! @brief determines whether a set of properties signals host accessible memory.
+template <class... _Properties>
+inline constexpr bool __is_host_accessible =
+  ::cuda::std::__type_set_contains_v<::cuda::std::__make_type_set<_Properties...>, host_accessible>;
+
+//! @brief determines whether a set of properties signals device accessible memory.
+template <class... _Properties>
+inline constexpr bool __is_device_accessible =
+  ::cuda::std::__type_set_contains_v<::cuda::std::__make_type_set<_Properties...>, device_accessible>;
+
+//! @brief determines whether a set of properties signals host device accessible memory.
+template <class... _Properties>
+inline constexpr bool __is_host_device_accessible =
+  ::cuda::std::__type_set_contains_v<::cuda::std::__make_type_set<_Properties...>, host_accessible, device_accessible>;
+
+//! @brief verifies that a set of properties contains at least one execution space property
+template <class... _Properties>
+inline constexpr bool __contains_execution_space_property =
+  __is_host_accessible<_Properties...> || __is_device_accessible<_Properties...>;
+
+//! @brief A type representing a list of memory resource properties
+//! @tparam _Properties The properties to be included in the list
+//! It has a member template `rebind` that allows constructing a type by combining
+//! a template and type arguments with the properties from this list. The properties
+//! are appended after the type arguments in the resulting type.
+template <class... _Properties>
+struct properties_list
+{
+  //! @brief A type alias for a type template instantiated with the properties
+  //! from this list appended to the type arguments.
+  template <template <class...> class _Fn, class... _ExtraArgs>
+  using rebind = _Fn<_ExtraArgs..., _Properties...>;
+
+  template <class _QueryProperty>
+  _CCCL_HOST_API static constexpr bool has_property([[maybe_unused]] _QueryProperty)
+  {
+    return ::cuda::std::__type_set_contains_v<::cuda::std::__make_type_set<_Properties...>, _QueryProperty>;
+  }
+};
+
+template <class _Tp>
+inline constexpr bool __is_queries_list = false;
+
+template <class... _Tp>
+inline constexpr bool __is_queries_list<properties_list<_Tp...>> = true;
+
+template <typename _Tp>
+_CCCL_CONCEPT __has_default_queries =
+  _CCCL_REQUIRES_EXPR((_Tp))(requires(__is_queries_list<typename ::cuda::std::decay_t<_Tp>::default_queries>));
+
+template <typename _Resource, bool _HasDefaultQueries = __has_default_queries<_Resource>>
+struct __copy_default_queries;
+
+template <typename _Resource>
+struct __copy_default_queries<_Resource, true>
+{
+  using default_queries = typename _Resource::default_queries;
+};
+
+template <typename _Resource>
+struct __copy_default_queries<_Resource, false>
+{};
+
+enum class __memory_accessability
+{
+  __host,
+  __device,
+  __host_device,
+};
+
+template <class... _Properties>
+struct __memory_accessability_from_properties
+{
+  static constexpr __memory_accessability value =
+    ::cuda::mr::__is_host_device_accessible<_Properties...> ? __memory_accessability::__host_device
+    : ::cuda::mr::__is_device_accessible<_Properties...>
+      ? __memory_accessability::__device
+      : __memory_accessability::__host;
+};
+
+_CCCL_END_NAMESPACE_CUDA_MR
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif //_CUDA___MEMORY_RESOURCE_PROPERTIES_H