cuda-cccl 0.3.3__cp313-cp313-win_amd64.whl

cuda/cccl/headers/include/cuda/std/__mdspan/submdspan_mapping.h

@@ -0,0 +1,344 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD___MDSPAN_SUBMDSPAN_MAPPING_H
+#define _CUDA_STD___MDSPAN_SUBMDSPAN_MAPPING_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/__fwd/mdspan.h>
+#include <cuda/std/__mdspan/concepts.h>
+#include <cuda/std/__mdspan/extents.h>
+#include <cuda/std/__mdspan/layout_left.h>
+#include <cuda/std/__mdspan/layout_right.h>
+#include <cuda/std/__mdspan/layout_stride.h>
+#include <cuda/std/__mdspan/mdspan.h>
+#include <cuda/std/__mdspan/submdspan_extents.h>
+#include <cuda/std/__mdspan/submdspan_helper.h>
+#include <cuda/std/__type_traits/make_unsigned.h>
+#include <cuda/std/__type_traits/remove_const.h>
+#include <cuda/std/__type_traits/type_list.h>
+#include <cuda/std/__utility/integer_sequence.h>
+#include <cuda/std/array>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+// [mdspan.sub.map]
+
+// [mdspan.submdspan.submdspan.mapping.result]
+template <class _LayoutMapping>
+struct submdspan_mapping_result
+{
+  static_assert(__mdspan_detail::__layout_mapping_req<_LayoutMapping>,
+                "[mdspan.submdspan.submdspan.mapping.result] shall meet the layout mapping requirements");
+
+  _CCCL_NO_UNIQUE_ADDRESS _LayoutMapping mapping{};
+  size_t offset{};
+};
+
+// [mdspan.sub.map.common]
+// mdspan.sub.map.common-2
+template <class _Extents, class... _Slices>
+_CCCL_CONCEPT __matching_number_of_slices = sizeof...(_Slices) == _Extents::rank();
+
+template <size_t _SliceIndex, class _LayoutMapping, class... _Slices>
+[[nodiscard]] _CCCL_API constexpr auto
+__get_submdspan_strides(const _LayoutMapping& __mapping, _Slices... __slices) noexcept
+{
+  using _SliceType = __get_slice_type<_SliceIndex, _Slices...>;
+  using _Extents   = typename _LayoutMapping::extents_type;
+  using _IndexType = typename _Extents::index_type;
+  if constexpr (__is_strided_slice<remove_cv_t<_SliceType>>)
+  {
+    _SliceType& __slice     = ::cuda::std::__get_slice_at<_SliceIndex>(__slices...);
+    using __unsigned_stride = make_unsigned_t<typename _SliceType::stride_type>;
+    using __unsigned_extent = make_unsigned_t<typename _SliceType::extent_type>;
+    return static_cast<_IndexType>(
+      __mapping.stride(_SliceIndex)
+      * (static_cast<__unsigned_stride>(__slice.stride) < static_cast<__unsigned_extent>(__slice.extent)
+           ? ::cuda::std::__de_ice(__slice.stride)
+           : 1));
+  }
+  else
+  {
+    return static_cast<_IndexType>(__mapping.stride(_SliceIndex));
+  }
+}
+
+template <class _LayoutMapping, class... _Slices, size_t... _SliceIndices>
+[[nodiscard]] _CCCL_API constexpr auto
+__submdspan_strides(index_sequence<_SliceIndices...>, const _LayoutMapping& __mapping, _Slices... __slices) noexcept
+{
+  using _Extents    = typename _LayoutMapping::extents_type;
+  using _IndexType  = typename _Extents::index_type;
+  using _SubExtents = __get_subextents_t<_Extents, _Slices...>;
+  return array<_IndexType, _SubExtents::rank()>{
+    ::cuda::std::__get_submdspan_strides<_SliceIndices>(__mapping, __slices...)...};
+}
+
+_CCCL_TEMPLATE(class _LayoutMapping, class... _Slices)
+_CCCL_REQUIRES(__matching_number_of_slices<typename _LayoutMapping::extents_type, _Slices...>)
+[[nodiscard]] _CCCL_API constexpr auto __submdspan_strides(const _LayoutMapping& __mapping, _Slices... __slices)
+{
+  using _Extents                = typename _LayoutMapping::extents_type;
+  using _IndexType              = typename _Extents::index_type;
+  const auto __filtered_indices = __filter_slices_convertible_to_index<_IndexType, _Slices...>(
+    index_sequence<>{}, ::cuda::std::index_sequence_for<_Slices...>());
+  return ::cuda::std::__submdspan_strides(__filtered_indices, __mapping, __slices...);
+}
+
+// [mdspan.sub.map.common-8]
+template <class _LayoutMapping, class... _Slices, size_t... _SliceIndices>
+[[nodiscard]] _CCCL_API constexpr size_t
+__submdspan_offset(index_sequence<_SliceIndices...>, const _LayoutMapping& __mapping, _Slices... __slices)
+{
+  using _Extents   = typename _LayoutMapping::extents_type;
+  using _IndexType = typename _Extents::index_type;
+  // If first_<index_type, k>(slices...)
+  const array<_IndexType, _Extents::rank()> __offsets = {
+    ::cuda::std::__first_extent_from_slice<_IndexType, _SliceIndices>(__slices...)...};
+
+  using _SubExtents = __get_subextents_t<_Extents, _Slices...>;
+  for (size_t __index = 0; __index != _SubExtents::rank(); ++__index)
+  {
+    // If first_<index_type, k>(slices...) equals extents().extent(k) for any rank index k of extents()
+    if (__offsets[__index] == __mapping.extents().extent(__index))
+    {
+      // then let offset be a value of type size_t equal to (*this).required_span_size()
+      return static_cast<size_t>(__mapping.required_span_size());
+    }
+  }
+  // Otherwise, let offset be a value of type size_t equal to (*this)(first_<index_type, P>(slices...)...).
+  return static_cast<size_t>(__mapping(__offsets[_SliceIndices]...));
+}
+
+_CCCL_TEMPLATE(class _LayoutMapping, class... _Slices)
+_CCCL_REQUIRES(__matching_number_of_slices<typename _LayoutMapping::extents_type, _Slices...>)
+[[nodiscard]] _CCCL_API constexpr size_t __submdspan_offset(const _LayoutMapping& __mapping, _Slices... __slices)
+{
+  return ::cuda::std::__submdspan_offset(::cuda::std::index_sequence_for<_Slices...>(), __mapping, __slices...);
+}
+
+// [mdspan.sub.map.common-9]
+// [mdspan.sub.map.common-9.1]
+template <class _SliceType>
+_CCCL_CONCEPT __is_strided_slice_stride_of_one = _CCCL_REQUIRES_EXPR((_SliceType))(
+  requires(__is_strided_slice<remove_cv_t<_SliceType>>),
+  requires(__integral_constant_like<typename _SliceType::stride_type>),
+  requires(_SliceType::stride_type::value == 1));
+
+template <class _LayoutMapping, class _SliceType>
+_CCCL_API constexpr bool __is_unit_stride_slice()
+{
+  // [mdspan.sub.map.common-9.1]
+  if constexpr (__is_strided_slice_stride_of_one<_SliceType>)
+  {
+    return true;
+  }
+  // [mdspan.sub.map.common-9.2]
+  else if constexpr (__index_pair_like<_SliceType, typename _LayoutMapping::index_type>)
+  {
+    return true;
+  }
+  // [mdspan.sub.map.common-9.3]
+  else if constexpr (is_convertible_v<_SliceType, full_extent_t>)
+  {
+    return true;
+  }
+  else
+  {
+    return false;
+  }
+  _CCCL_UNREACHABLE();
+}
+
+// [mdspan.sub.map.left]
+template <class _LayoutMapping, class _SubExtents, class _Slice, class... _OtherSlices>
+_CCCL_API constexpr bool __can_layout_left()
+{
+  // [mdspan.sub.map.left-1.2]
+  if constexpr (_SubExtents::rank() == 0)
+  {
+    return true;
+  }
+  // [mdspan.sub.map.left-1.3.2]
+  else if constexpr (sizeof...(_OtherSlices) == 0)
+  {
+    return ::cuda::std::__is_unit_stride_slice<_LayoutMapping, _Slice>();
+  }
+  // [mdspan.sub.map.left-1.3.1]
+  else if constexpr (is_convertible_v<_Slice, full_extent_t>)
+  {
+    return ::cuda::std::__can_layout_left<_LayoutMapping, _SubExtents, _OtherSlices...>();
+  }
+  else
+  {
+    return false;
+  }
+  _CCCL_UNREACHABLE();
+}
+
+_CCCL_TEMPLATE(class _Extents, class... _Slices)
+_CCCL_REQUIRES(__matching_number_of_slices<_Extents, _Slices...>)
+[[nodiscard]] _CCCL_API constexpr auto
+__submdspan_mapping_impl(const typename layout_left::mapping<_Extents>& __mapping, _Slices... __slices)
+{
+  // [mdspan.sub.map.left-1.1]
+  if constexpr (_Extents::rank() == 0)
+  {
+    return submdspan_mapping_result{__mapping, 0};
+  }
+  else
+  {
+    // [mdspan.sub.map.left-1.2]
+    // [mdspan.sub.map.left-1.3]
+    using _SubExtents    = __get_subextents_t<_Extents, _Slices...>;
+    const auto __sub_ext = ::cuda::std::submdspan_extents(__mapping.extents(), __slices...);
+    const auto __offset  = ::cuda::std::__submdspan_offset(__mapping, __slices...);
+    if constexpr (::cuda::std::__can_layout_left<typename layout_left::mapping<_Extents>, _SubExtents, _Slices...>())
+    {
+      using __sub_mapping_t = layout_left::template mapping<_SubExtents>;
+      return submdspan_mapping_result<__sub_mapping_t>{__sub_mapping_t{__sub_ext}, __offset};
+    }
+    // [mdspan.sub.map.left-1.4]
+    // TODO: Implement padded layouts
+    else
+    {
+      // [mdspan.sub.map.left-1.5]
+      using __sub_mapping_t    = layout_stride::template mapping<_SubExtents>;
+      const auto __sub_strides = ::cuda::std::__submdspan_strides(__mapping, __slices...);
+      return submdspan_mapping_result<__sub_mapping_t>{__sub_mapping_t{__sub_ext, __sub_strides}, __offset};
+    }
+  }
+  _CCCL_UNREACHABLE();
+}
+
+template <class _LayoutMapping, class _SubExtents, class _Slice, class... _OtherSlices>
+_CCCL_API constexpr bool __can_layout_right()
+{
+  // [mdspan.sub.map.right-1.2]
+  if constexpr (_SubExtents::rank() == 0)
+  {
+    return true;
+  }
+  // [mdspan.sub.map.right-1.3.2]
+  else if constexpr (sizeof...(_OtherSlices) == 0)
+  {
+    return ::cuda::std::__is_unit_stride_slice<_LayoutMapping, _Slice>();
+  }
+  // [mdspan.sub.map.right-1.3.1]
+  else if constexpr (is_convertible_v<_Slice, full_extent_t>)
+  {
+    return ::cuda::std::__can_layout_left<_LayoutMapping, _SubExtents, _OtherSlices...>();
+  }
+  else
+  {
+    return false;
+  }
+  _CCCL_UNREACHABLE();
+}
+
+_CCCL_TEMPLATE(class _Extents, class... _Slices)
+_CCCL_REQUIRES(__matching_number_of_slices<_Extents, _Slices...>)
+[[nodiscard]] _CCCL_API constexpr auto
+__submdspan_mapping_impl(const typename layout_right::mapping<_Extents>& __mapping, _Slices... __slices)
+{
+  // [mdspan.sub.map.right-1.1]
+  if constexpr (_Extents::rank() == 0)
+  {
+    return submdspan_mapping_result{__mapping, 0};
+  }
+  else
+  {
+    // [mdspan.sub.map.right-1.2]
+    // [mdspan.sub.map.right-1.3]
+    using _SubExtents    = __get_subextents_t<_Extents, _Slices...>;
+    const auto __sub_ext = ::cuda::std::submdspan_extents(__mapping.extents(), __slices...);
+    const auto __offset  = ::cuda::std::__submdspan_offset(__mapping, __slices...);
+    if constexpr (::cuda::std::__can_layout_right<typename layout_left::mapping<_Extents>, _SubExtents, _Slices...>())
+    {
+      using __sub_mapping_t = layout_right::template mapping<_SubExtents>;
+      return submdspan_mapping_result<__sub_mapping_t>{__sub_mapping_t{__sub_ext}, __offset};
+    }
+    // [mdspan.sub.map.right-1.4]
+    // TODO: Implement padded layouts
+    else
+    {
+      // [mdspan.sub.map.right-1.5]
+      using __sub_mapping_t    = layout_stride::template mapping<_SubExtents>;
+      const auto __sub_strides = ::cuda::std::__submdspan_strides(__mapping, __slices...);
+      return submdspan_mapping_result<__sub_mapping_t>{__sub_mapping_t{__sub_ext, __sub_strides}, __offset};
+    }
+  }
+  _CCCL_UNREACHABLE();
+}
+
+_CCCL_TEMPLATE(class _Extents, class... _Slices)
+_CCCL_REQUIRES(__matching_number_of_slices<_Extents, _Slices...>)
+[[nodiscard]] _CCCL_API constexpr auto
+__submdspan_mapping_impl(const typename layout_stride::mapping<_Extents>& __mapping, _Slices... __slices)
+{
+  // [mdspan.sub.map.stride-1.1]
+  if constexpr (_Extents::rank() == 0)
+  {
+    return submdspan_mapping_result{__mapping, 0};
+  }
+  else
+  {
+    // [mdspan.sub.map.stride-1.2]
+    using _SubExtents        = __get_subextents_t<_Extents, _Slices...>;
+    using __sub_mapping_t    = layout_stride::template mapping<_SubExtents>;
+    const auto __sub_ext     = ::cuda::std::submdspan_extents(__mapping.extents(), __slices...);
+    const auto __offset      = ::cuda::std::__submdspan_offset(__mapping, __slices...);
+    const auto __sub_strides = ::cuda::std::__submdspan_strides(__mapping, __slices...);
+    return submdspan_mapping_result<__sub_mapping_t>{__sub_mapping_t{__sub_ext, __sub_strides}, __offset};
+  }
+}
+
+_CCCL_TEMPLATE(class _LayoutMapping, class... _Slices)
+_CCCL_REQUIRES(__matching_number_of_slices<typename _LayoutMapping::extents_type, _Slices...>)
+[[nodiscard]] _CCCL_API constexpr auto submdspan_mapping(const _LayoutMapping& __mapping, _Slices... __slices)
+{
+  return ::cuda::std::__submdspan_mapping_impl(__mapping, __slices...);
+}
+
+// [mdspan.sub.sub]
+template <class _LayoutMapping, class... _Slices>
+_CCCL_CONCEPT __can_submdspan_mapping =
+  _CCCL_REQUIRES_EXPR((_LayoutMapping, variadic _Slices), const _LayoutMapping& __mapping, _Slices... __slices)(
+    (::cuda::std::submdspan_mapping(__mapping, __slices...)));
+
+_CCCL_TEMPLATE(class _Tp, class _Extents, class _Layout, class _Accessor, class... _Slices)
+_CCCL_REQUIRES(__matching_number_of_slices<_Extents, _Slices...> _CCCL_AND
+                 __can_submdspan_mapping<typename _Layout::template mapping<_Extents>, _Slices...>)
+[[nodiscard]] _CCCL_API constexpr auto
+submdspan(const mdspan<_Tp, _Extents, _Layout, _Accessor>& __src, _Slices... __slices)
+{
+  auto __sub_map_result = ::cuda::std::submdspan_mapping(__src.mapping(), __slices...);
+  return mdspan(__src.accessor().offset(__src.data_handle(), __sub_map_result.offset),
+                __sub_map_result.mapping,
+                typename _Accessor::offset_policy(__src.accessor()));
+}
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___MDSPAN_SUBMDSPAN_MAPPING_H

cuda/cccl/headers/include/cuda/std/__memory/addressof.h

@@ -0,0 +1,67 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, 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) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___MEMORY_ADDRESSOF_H
+#define _CUDA_STD___MEMORY_ADDRESSOF_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/__cccl/prologue.h>
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_MSVC(4312) // warning C4312: 'type cast': conversion from '_Tp' to '_Tp *' of greater size
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+#if _CCCL_HAS_BUILTIN_STD_ADDRESSOF()
+
+// The compiler treats ::std::addressof as a builtin function so it does not need to be
+// instantiated and will be compiled away even at -O0.
+using ::std::addressof;
+
+#elif defined(_CCCL_BUILTIN_ADDRESSOF)
+
+template <class _Tp>
+[[nodiscard]] _CCCL_API inline _CCCL_NO_CFI constexpr _Tp* addressof(_Tp& __x) noexcept
+{
+  return _CCCL_BUILTIN_ADDRESSOF(__x);
+}
+
+template <class _Tp>
+_Tp* addressof(const _Tp&&) noexcept = delete;
+
+#else
+
+template <class _Tp>
+[[nodiscard]] _CCCL_API inline _CCCL_NO_CFI _Tp* addressof(_Tp& __x) noexcept
+{
+  return reinterpret_cast<_Tp*>(const_cast<char*>(&reinterpret_cast<const volatile char&>(__x)));
+}
+
+template <class _Tp>
+_Tp* addressof(const _Tp&&) noexcept = delete;
+
+#endif // defined(_CCCL_BUILTIN_ADDRESSOF)
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+_CCCL_DIAG_POP
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___MEMORY_ADDRESSOF_H

cuda/cccl/headers/include/cuda/std/__memory/align.h

@@ -0,0 +1,67 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___MEMORY_ALIGN_H
+#define _CUDA_STD___MEMORY_ALIGN_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/__cmath/pow2.h>
+#include <cuda/std/__memory/assume_aligned.h>
+#include <cuda/std/__memory/runtime_assume_aligned.h>
+#include <cuda/std/cstddef>
+#include <cuda/std/cstdint>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_MSVC(4146) // unary minus operator applied to unsigned type, result still unsigned
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+_CCCL_API inline void* align(size_t __alignment, size_t __size, void*& __ptr, size_t& __space)
+{
+  _CCCL_ASSERT(::cuda::is_power_of_two(__alignment), "cuda::std::align: alignment must be a power of two!");
+  if (__space < __size)
+  {
+    return nullptr;
+  }
+
+  char* __char_ptr = static_cast<char*>(__ptr);
+  char* __aligned_ptr =
+    reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(__char_ptr + (__alignment - 1)) & -__alignment);
+  const size_t __diff = static_cast<size_t>(__aligned_ptr - __char_ptr);
+  if (__diff > (__space - __size))
+  {
+    return nullptr;
+  }
+
+  //! We need to avoid using __aligned_ptr here, as nvcc looses track of the execution space otherwise
+  __ptr = reinterpret_cast<void*>(__char_ptr + __diff);
+  __space -= __diff;
+  return ::cuda::std::__runtime_assume_aligned(__ptr, __alignment);
+}
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+_CCCL_DIAG_POP
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___MEMORY_ALIGN_H

cuda/cccl/headers/include/cuda/std/__memory/allocate_at_least.h

@@ -0,0 +1,81 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___MEMORY_ALLOCATE_AT_LEAST_H
+#define _CUDA_STD___MEMORY_ALLOCATE_AT_LEAST_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/__memory/allocator_traits.h>
+#include <cuda/std/cstddef>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+#if _CCCL_STD_VER >= 2023
+template <class _Pointer>
+struct allocation_result
+{
+  _Pointer ptr;
+  size_t count;
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(allocation_result);
+
+template <class _Alloc>
+[[nodiscard]] _CCCL_API constexpr allocation_result<typename allocator_traits<_Alloc>::pointer>
+allocate_at_least(_Alloc& __alloc, size_t __n)
+{
+  if constexpr (requires { __alloc.allocate_at_least(__n); })
+  {
+    return __alloc.allocate_at_least(__n);
+  }
+  else
+  {
+    return {__alloc.allocate(__n), __n};
+  }
+}
+
+template <class _Alloc>
+[[nodiscard]] _CCCL_API constexpr auto __allocate_at_least(_Alloc& __alloc, size_t __n)
+{
+  return ::cuda::std::allocate_at_least(__alloc, __n);
+}
+#else // ^^^ _CCCL_STD_VER >= 2023 ^^^ / vvv _CCCL_STD_VER < 2023 vvv
+template <class _Pointer>
+struct __allocation_result
+{
+  _Pointer ptr;
+  size_t count;
+};
+
+template <class _Alloc>
+[[nodiscard]] _CCCL_API constexpr __allocation_result<typename allocator_traits<_Alloc>::pointer>
+__allocate_at_least(_Alloc& __alloc, size_t __n)
+{
+  return {__alloc.allocate(__n), __n};
+}
+
+#endif // _CCCL_STD_VER >= 2023
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___MEMORY_ALLOCATE_AT_LEAST_H

cuda/cccl/headers/include/cuda/std/__memory/allocation_guard.h

@@ -0,0 +1,100 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___MEMORY_ALLOCATION_GUARD_H
+#define _CUDA_STD___MEMORY_ALLOCATION_GUARD_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/__memory/allocator_traits.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/cstddef>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+// Helper class to allocate memory using an Allocator in an exception safe
+// manner.
+//
+// The intended usage of this class is as follows:
+//
+// 0
+// 1     __allocation_guard<SomeAllocator> guard(alloc, 10);
+// 2     do_some_initialization_that_may_throw(guard.__get());
+// 3     save_allocated_pointer_in_a_noexcept_operation(guard.__release_ptr());
+// 4
+//
+// If line (2) throws an exception during initialization of the memory, the
+// guard's destructor will be called, and the memory will be released using
+// Allocator deallocation. Otherwise, we release the memory from the guard on
+// line (3) in an operation that can't throw -- after that, the guard is not
+// responsible for the memory anymore.
+//
+// This is similar to a unique_ptr, except it's easier to use with a
+// custom allocator.
+
+_CCCL_BEGIN_NV_DIAG_SUPPRESS(2659) // constexpr non-static member function will not be implicitly 'const' in C++14
+
+template <class _Alloc>
+struct __allocation_guard
+{
+  using _Pointer = typename allocator_traits<_Alloc>::pointer;
+  using _Size    = typename allocator_traits<_Alloc>::size_type;
+
+  template <class _AllocT> // we perform the allocator conversion inside the constructor
+  _CCCL_API inline _CCCL_CONSTEXPR_CXX20 explicit __allocation_guard(_AllocT __alloc, _Size __n)
+      : __alloc_(::cuda::std::move(__alloc))
+      , __n_(__n)
+      , __ptr_(allocator_traits<_Alloc>::allocate(__alloc_, __n_)) // initialization order is important
+  {}
+
+  _CCCL_API inline _CCCL_CONSTEXPR_CXX20 ~__allocation_guard() noexcept
+  {
+    if (__ptr_ != nullptr)
+    {
+      allocator_traits<_Alloc>::deallocate(__alloc_, __ptr_, __n_);
+    }
+  }
+
+  _CCCL_API constexpr _Pointer __release_ptr() noexcept
+  { // not called __release() because it's a keyword in objective-c++
+    _Pointer __tmp = __ptr_;
+    __ptr_         = nullptr;
+    return __tmp;
+  }
+
+  _CCCL_API constexpr _Pointer __get() const noexcept
+  {
+    return __ptr_;
+  }
+
+private:
+  _Alloc __alloc_;
+  _Size __n_;
+  _Pointer __ptr_;
+};
+
+_CCCL_END_NV_DIAG_SUPPRESS()
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___MEMORY_ALLOCATION_GUARD_H