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/std/__linalg/transposed.h

@@ -41,7 +41,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace linalg
 {
-
 namespace __detail
 {
 // This struct helps us impose the rank constraint on the __type alias itself.
@@ -88,7 +87,6 @@ _CCCL_API constexpr __transpose_extents_t<_Extents> __transpose_extents(const _E
   }
   _CCCL_UNREACHABLE(); // GCC9 workaround
 }
-
 } // namespace __detail
 
 template <class _Layout>
@@ -202,7 +200,6 @@ public:
 
 namespace __detail
 {
-
 template <class _ElementType, class _Accessor>
 struct __transposed_element_accessor
 {
@@ -297,7 +294,6 @@ struct __transposed_layout<layout_transpose<_NestedLayout>>
 {
   using __layout_type = _NestedLayout;
 };
-
 } // namespace __detail
 
 template <class _ElementType, class _Extents, class _Layout, class _Accessor>
@@ -311,7 +307,6 @@ template <class _ElementType, class _Extents, class _Layout, class _Accessor>
   return mdspan<__element_type, typename decltype(__mapping)::extents_type, __layout_type, __accessor_type>{
     __a.data_handle(), __mapping, __accessor};
 }
-
 } // end namespace linalg
 
 _CCCL_END_NAMESPACE_CUDA_STD

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

@@ -33,6 +33,7 @@
 #include <cuda/std/__concepts/copyable.h>
 #include <cuda/std/__concepts/equality_comparable.h>
 #include <cuda/std/__concepts/same_as.h>
+#include <cuda/std/__fwd/mdspan.h>
 #include <cuda/std/__tuple_dir/tuple_element.h>
 #include <cuda/std/__tuple_dir/tuple_like.h>
 #include <cuda/std/__type_traits/integral_constant.h>
@@ -55,14 +56,7 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace __mdspan_detail
 {
-
 // [mdspan.layout.stride.expo]/3
-template <class>
-struct __is_extents : false_type
-{};
-
-template <class _Tp>
-inline constexpr bool __is_extents_v = __is_extents<_Tp>::value;
 
 // [mdspan.layout.general]/2
 template <class _Layout, class _Mapping>
@@ -81,7 +75,7 @@ _CCCL_CONCEPT __layout_mapping_req_type = _CCCL_REQUIRES_EXPR((_Mapping))(
 // [mdspan.layout.reqmts]/2-4
 template <class _Mapping>
 _CCCL_CONCEPT __layout_mapping_req_types = _CCCL_REQUIRES_EXPR((_Mapping))(
-  requires(__is_extents_v<typename _Mapping::extents_type>),
+  requires(__is_cuda_std_extents_v<typename _Mapping::extents_type>),
   requires(same_as<typename _Mapping::index_type, typename _Mapping::extents_type::index_type>),
   requires(same_as<typename _Mapping::rank_type, typename _Mapping::extents_type::rank_type>),
   requires(__is_mapping_of<typename _Mapping::layout_type, _Mapping>));
@@ -105,7 +99,7 @@ _CCCL_CONCEPT __layout_mapping_req = _CCCL_REQUIRES_EXPR((_Mapping))(
 template <class _Mapping>
 _CCCL_CONCEPT __layout_mapping_alike = _CCCL_REQUIRES_EXPR((_Mapping))(
   requires(__is_mapping_of<typename _Mapping::layout_type, _Mapping>),
-  requires(__is_extents_v<typename _Mapping::extents_type>),
+  requires(__is_cuda_std_extents_v<typename _Mapping::extents_type>),
   requires(same_as<bool, decltype(_Mapping::is_always_strided())>),
   requires(same_as<bool, decltype(_Mapping::is_always_exhaustive())>),
   requires(same_as<bool, decltype(_Mapping::is_always_unique())>),
@@ -123,7 +117,6 @@ static constexpr bool __matches_dynamic_rank = (_Size == _Extent::rank_dynamic()
 
 template <class _Extent, size_t _Size>
 static constexpr bool __matches_static_rank = (_Size == _Extent::rank()) && (_Size != _Extent::rank_dynamic());
-
 } // namespace __mdspan_detail
 
 template <class _Tp, class _IndexType>

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

@@ -51,7 +51,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace __mdspan_detail
 {
-
 // ------------------------------------------------------------------
 // ------------ __static_array --------------------------------------
 // ------------------------------------------------------------------
@@ -175,8 +174,8 @@ constexpr size_t __count_dynamic_v = (size_t{0} + ... + static_cast<size_t>(_Val
 // The position of a dynamic value is indicated through a tag value.
 // We manually implement EBCO because MSVC and some odler compiler fail hard with [[no_unique_address]]
 template <class _TDynamic, class _TStatic, _TStatic _DynTag, _TStatic... _Values>
-struct __maybe_static_array
-    : private __possibly_empty_array<_TDynamic, __count_dynamic_v<_TStatic, _DynTag, _Values...>>
+struct _CCCL_DECLSPEC_EMPTY_BASES
+__maybe_static_array : private __possibly_empty_array<_TDynamic, __count_dynamic_v<_TStatic, _DynTag, _Values...>>
 {
   static_assert(is_convertible_v<_TStatic, _TDynamic>,
                 "__maybe_static_array: _TStatic must be convertible to _TDynamic");
@@ -239,14 +238,14 @@ public:
 
   // constructors from dynamic values only -- this covers the case for rank() == 0
   _CCCL_TEMPLATE(class... _DynVals)
-  _CCCL_REQUIRES((sizeof...(_DynVals) == __size_dynamic_) && (!__all<__is_std_span_v<_DynVals>...>::value))
+  _CCCL_REQUIRES((sizeof...(_DynVals) == __size_dynamic_) && (!__all<__is_cuda_std_span_v<_DynVals>...>::value))
   _CCCL_API constexpr __maybe_static_array(_DynVals... __vals) noexcept
       : _DynamicValues{static_cast<_TDynamic>(__vals)...}
   {}
 
   // constructors from all values -- here rank will be greater than 0
   _CCCL_TEMPLATE(class... _DynVals)
-  _CCCL_REQUIRES((sizeof...(_DynVals) != __size_dynamic_) && (!__all<__is_std_span_v<_DynVals>...>::value))
+  _CCCL_REQUIRES((sizeof...(_DynVals) != __size_dynamic_) && (!__all<__is_cuda_std_span_v<_DynVals>...>::value))
   _CCCL_API constexpr __maybe_static_array(_DynVals... __vals)
       : _DynamicValues{}
   {
@@ -398,7 +397,6 @@ _CCCL_REQUIRES(integral<_To>)
   }
   return true;
 }
-
 } // namespace __mdspan_detail
 
 // ------------------------------------------------------------------
@@ -650,7 +648,6 @@ public:
 // Recursive helper classes to implement dextents alias for extents
 namespace __mdspan_detail
 {
-
 template <class _IndexType, size_t _Rank, class _Extents = extents<_IndexType>>
 struct __make_dextents;
 
@@ -668,7 +665,6 @@ struct __make_dextents<_IndexType, 0, extents<_IndexType, _ExtentsPack...>>
 {
   using type = extents<_IndexType, _ExtentsPack...>;
 };
-
 } // end namespace __mdspan_detail
 
 // [mdspan.extents.dextents], alias template
@@ -691,12 +687,6 @@ _CCCL_HOST_DEVICE extents(_IndexTypes...) -> extents<size_t, __to_dynamic_extent
 
 namespace __mdspan_detail
 {
-
-//! NOTE we define __is_extents_v through __is_extents because nvrtc fails otherwise.
-//! Specializing __is_extents_v is valid, because all other cases remain as false
-template <class _IndexType, size_t... _ExtentsPack>
-inline constexpr bool __is_extents_v<extents<_IndexType, _ExtentsPack...>> = true;
-
 // Function to check whether a set of indices are a multidimensional
 // index into extents. This is a word of power in the C++ standard
 // requiring that the indices are larger than 0 and smaller than
@@ -754,7 +744,6 @@ template <class _Extents, class... _From>
   return __mdspan_detail::__is_multidimensional_index_in_impl(
     make_index_sequence<_Extents::rank()>(), __ext, __values...);
 }
-
 } // namespace __mdspan_detail
 
 _CCCL_END_NAMESPACE_CUDA_STD

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

@@ -47,10 +47,10 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 // Helper for lightweight test checking that one did pass a layout policy as LayoutPolicy template argument
 template <class _Extents>
-class layout_left::mapping : private __mdspan_ebco<_Extents>
+class _CCCL_DECLSPEC_EMPTY_BASES layout_left::mapping : private __mdspan_ebco<_Extents>
 {
 public:
-  static_assert(__mdspan_detail::__is_extents_v<_Extents>,
+  static_assert(__is_cuda_std_extents_v<_Extents>,
                 "layout_left::mapping template argument must be a specialization of extents.");
 
   using extents_type = _Extents;
@@ -298,8 +298,8 @@ public:
 
 #if _CCCL_STD_VER <= 2017
   template <class _OtherExtents, class _Extents2 = _Extents>
-  [[nodiscard]] _CCCL_API friend constexpr auto
-  operator!=(const mapping& __lhs, const mapping<_OtherExtents>& __rhs) noexcept
+  [[nodiscard]]
+  _CCCL_API friend constexpr auto operator!=(const mapping& __lhs, const mapping<_OtherExtents>& __rhs) noexcept
     _CCCL_TRAILING_REQUIRES(bool)((_OtherExtents::rank() == _Extents2::rank()))
   {
     return __lhs.extents() != __rhs.extents();

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

@@ -47,10 +47,10 @@
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 template <class _Extents>
-class layout_right::mapping : private __mdspan_ebco<_Extents>
+class _CCCL_DECLSPEC_EMPTY_BASES layout_right::mapping : private __mdspan_ebco<_Extents>
 {
 public:
-  static_assert(__mdspan_detail::__is_extents_v<_Extents>,
+  static_assert(__is_cuda_std_extents_v<_Extents>,
                 "layout_right::mapping template argument must be a specialization of extents.");
 
   using extents_type = _Extents;
@@ -291,8 +291,8 @@ public:
 
 #if _CCCL_STD_VER <= 2017
   template <class _OtherExtents, class _Extents2 = _Extents>
-  [[nodiscard]] _CCCL_API friend constexpr auto
-  operator!=(const mapping& __lhs, const mapping<_OtherExtents>& __rhs) noexcept
+  [[nodiscard]]
+  _CCCL_API friend constexpr auto operator!=(const mapping& __lhs, const mapping<_OtherExtents>& __rhs) noexcept
     _CCCL_TRAILING_REQUIRES(bool)((_OtherExtents::rank() == _Extents2::rank()))
   {
     return __lhs.extents() != __rhs.extents();

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

@@ -50,7 +50,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace __layout_stride_detail
 {
-
 template <class _StridedLayoutMapping, class _Extents>
 _CCCL_CONCEPT __can_convert = _CCCL_REQUIRES_EXPR((_StridedLayoutMapping, _Extents))(
   requires(__mdspan_detail::__layout_mapping_alike<_StridedLayoutMapping>),
@@ -67,16 +66,15 @@ struct __constraints
         || __mdspan_detail::__is_mapping_of<layout_right, _StridedLayoutMapping>
         || __mdspan_detail::__is_mapping_of<layout_stride, _StridedLayoutMapping>);
 };
-
 } // namespace __layout_stride_detail
 
 template <class _Extents>
-class layout_stride::mapping
+class _CCCL_DECLSPEC_EMPTY_BASES layout_stride::mapping
     : private __mdspan_ebco<_Extents,
                             __mdspan_detail::__possibly_empty_array<typename _Extents::index_type, _Extents::rank()>>
 {
 public:
-  static_assert(__mdspan_detail::__is_extents_v<_Extents>,
+  static_assert(__is_cuda_std_extents_v<_Extents>,
                 "layout_stride::mapping template argument must be a specialization of extents.");
 
   using extents_type = _Extents;

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

@@ -108,7 +108,7 @@ class mdspan
                             _AccessorPolicy>
 {
 private:
-  static_assert(__mdspan_detail::__is_extents_v<_Extents>,
+  static_assert(__is_cuda_std_extents_v<_Extents>,
                 "mdspan: Extents template parameter must be a specialization of extents.");
   static_assert(!is_array_v<_ElementType>, "mdspan: ElementType template parameter may not be an array type");
   static_assert(!is_abstract_v<_ElementType>, "mdspan: ElementType template parameter may not be an abstract class");
@@ -291,7 +291,7 @@ public:
   //--------------------------------------------------------------------------------
   // [mdspan.mdspan.members], members
 
-#if defined(_LIBCUDACXX_HAS_MULTIARG_OPERATOR_BRACKETS)
+#if _CCCL_HAS_MULTIARG_OPERATOR_BRACKETS()
   _CCCL_TEMPLATE(class... _OtherIndexTypes)
   _CCCL_REQUIRES((sizeof...(_OtherIndexTypes) == extents_type::rank())
                    _CCCL_AND __mdspan_detail::__all_convertible_to_index_type<index_type, _OtherIndexTypes...>)
@@ -311,7 +311,7 @@ public:
   {
     return accessor().access(data_handle(), mapping()(static_cast<index_type>(::cuda::std::move(__index))));
   }
-#endif // _LIBCUDACXX_HAS_MULTIARG_OPERATOR_BRACKETS
+#endif // _CCCL_HAS_MULTIARG_OPERATOR_BRACKETS
 
   template <class _OtherIndexType, size_t... _Idxs>
   [[nodiscard]] _CCCL_API constexpr decltype(auto)

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

@@ -154,7 +154,7 @@ template <size_t _Index, class _Extents, class... _Slices>
 [[nodiscard]] _CCCL_API constexpr typename _Extents::index_type
 __last_extent_from_slice(const _Extents& __src, _Slices... __slices) noexcept
 {
-  static_assert(__mdspan_detail::__is_extents_v<_Extents>,
+  static_assert(__is_cuda_std_extents_v<_Extents>,
                 "[mdspan.sub.helpers] mandates Extents to be a specialization of extents");
   using _IndexType                     = typename _Extents::index_type;
   using _SliceType                     = __get_slice_type<_Index, _Slices...>;

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

@@ -23,6 +23,7 @@
 #endif // no system header
 
 #include <cuda/std/__memory/uses_allocator.h>
+#include <cuda/std/__new/device_new.h>
 #include <cuda/std/__type_traits/integral_constant.h>
 #include <cuda/std/__type_traits/is_constructible.h>
 #include <cuda/std/__type_traits/remove_cvref.h>

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

@@ -26,6 +26,7 @@
 #include <cuda/std/__fwd/allocator.h>
 #include <cuda/std/__memory/construct_at.h>
 #include <cuda/std/__memory/pointer_traits.h>
+#include <cuda/std/__new/device_new.h>
 #include <cuda/std/__type_traits/enable_if.h>
 #include <cuda/std/__type_traits/is_copy_constructible.h>
 #include <cuda/std/__type_traits/is_empty.h>
@@ -280,13 +281,6 @@ _CCCL_API inline auto __to_raw_pointer(const _Pointer& __p, _None...) noexcept
 }
 #endif // _CCCL_STD_VER >= 2020
 
-// __is_default_allocator
-template <class _Tp>
-inline constexpr bool __is_default_allocator = false;
-
-template <class _Tp>
-inline constexpr bool __is_default_allocator<allocator<_Tp>> = true;
-
 // __is_cpp17_move_insertable
 template <class _Alloc, class = void>
 inline constexpr bool __is_cpp17_move_insertable = is_move_constructible_v<typename _Alloc::value_type>;
@@ -294,7 +288,7 @@ inline constexpr bool __is_cpp17_move_insertable = is_move_constructible_v<typen
 template <class _Alloc>
 inline constexpr bool __is_cpp17_move_insertable<
   _Alloc,
-  enable_if_t<__is_default_allocator<_Alloc>
+  enable_if_t<__is_cuda_std_allocator_v<_Alloc>
               && __has_construct<_Alloc, typename _Alloc::value_type*, typename _Alloc::value_type&&>>> = true;
 
 // __is_cpp17_copy_insertable
@@ -305,7 +299,7 @@ inline constexpr bool __is_cpp17_copy_insertable =
 template <class _Alloc>
 inline constexpr bool __is_cpp17_copy_insertable<
   _Alloc,
-  enable_if_t<!__is_default_allocator<_Alloc>
+  enable_if_t<!__is_cuda_std_allocator_v<_Alloc>
               && __has_construct<_Alloc, typename _Alloc::value_type*, const typename _Alloc::value_type&>>> =
   __is_cpp17_move_insertable<_Alloc>;
 
@@ -434,7 +428,7 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT allocator_traits
 
   template <class _Tp>
   _CCCL_API inline static enable_if_t<
-    (__is_default_allocator<allocator_type> || !__has_construct<allocator_type, _Tp*, _Tp>)
+    (__is_cuda_std_allocator_v<allocator_type> || !__has_construct<allocator_type, _Tp*, _Tp>)
       && is_trivially_move_constructible_v<_Tp>,
     void>
   __construct_forward_with_exception_guarantees(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2)
@@ -463,7 +457,7 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT allocator_traits
             class _RawDestTp   = remove_const_t<_DestTp>>
   _CCCL_API inline static enable_if_t<
     is_trivially_move_constructible_v<_DestTp> && is_same_v<_RawSourceTp, _RawDestTp>
-      && (__is_default_allocator<allocator_type> || !__has_construct<allocator_type, _DestTp*, _SourceTp&>),
+      && (__is_cuda_std_allocator_v<allocator_type> || !__has_construct<allocator_type, _DestTp*, _SourceTp&>),
     void>
   __construct_range_forward(allocator_type&, _SourceTp* __begin1, _SourceTp* __end1, _DestTp*& __begin2)
   {
@@ -497,7 +491,7 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT allocator_traits
 
   template <class _Tp>
   _CCCL_API inline static enable_if_t<
-    (__is_default_allocator<allocator_type> || !__has_construct<allocator_type, _Tp*, _Tp>)
+    (__is_cuda_std_allocator_v<allocator_type> || !__has_construct<allocator_type, _Tp*, _Tp>)
       && is_trivially_move_constructible_v<_Tp>,
     void>
   __construct_backward_with_exception_guarantees(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2)

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

@@ -25,6 +25,7 @@
 #include <cuda/std/__iterator/access.h>
 #include <cuda/std/__memory/addressof.h>
 #include <cuda/std/__memory/voidify.h>
+#include <cuda/std/__new/device_new.h>
 #include <cuda/std/__type_traits/enable_if.h>
 #include <cuda/std/__type_traits/integral_constant.h>
 #include <cuda/std/__type_traits/is_arithmetic.h>
@@ -38,10 +39,6 @@
 #include <cuda/std/__utility/forward.h>
 #include <cuda/std/__utility/move.h>
 
-#if _CCCL_CUDA_COMPILER(CLANG)
-#  include <new>
-#endif // _CCCL_CUDA_COMPILER(CLANG)
-
 #if _CCCL_STD_VER >= 2020 // need to backfill ::std::construct_at
 #  include <cuda/std/__cccl/memory_wrapper.h>
 
@@ -74,7 +71,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 // This is possible because we are calling ::new ignoring any user defined overloads of operator placement new
 namespace __detail
 {
-
 #if _CCCL_COMPILER(NVHPC, <, 25, 5) // NVHPC has issues determining the narrowing conversions
 template <class _To, class...>
 struct __check_narrowing : true_type

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

@@ -23,6 +23,7 @@
 #endif // no system header
 
 #include <cuda/__cmath/pow2.h>
+#include <cuda/std/__type_traits/is_void.h>
 #include <cuda/std/cstddef> // size_t
 #include <cuda/std/cstdint> // uintptr_t
 
@@ -33,9 +34,13 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 template <size_t _ByteAlignment, class _ElementType>
 [[nodiscard]] _CCCL_API inline bool is_sufficiently_aligned(_ElementType* __ptr) noexcept
 {
+  using ::cuda::std::uintptr_t;
   static_assert(::cuda::is_power_of_two(_ByteAlignment), "alignment must be a power of two");
-  static_assert(_ByteAlignment % alignof(_ElementType) == 0,
-                "the alignment must be a multiple of the element alignment");
+  if constexpr (!::cuda::std::is_void_v<_ElementType>)
+  {
+    static_assert(_ByteAlignment % alignof(_ElementType) == 0,
+                  "the alignment must be a multiple of the element alignment");
+  }
   return (reinterpret_cast<uintptr_t>(__ptr) % _ByteAlignment) == 0;
 }
 

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

@@ -32,6 +32,7 @@
 #include <cuda/std/__memory/construct_at.h>
 #include <cuda/std/__memory/pointer_traits.h>
 #include <cuda/std/__memory/voidify.h>
+#include <cuda/std/__new/device_new.h>
 #include <cuda/std/__new_>
 #include <cuda/std/__type_traits/extent.h>
 #include <cuda/std/__type_traits/is_array.h>

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

@@ -22,6 +22,7 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__fwd/tuple.h>
 #include <cuda/std/__type_traits/is_convertible.h>
 #include <cuda/std/__type_traits/void_t.h>
 #include <cuda/std/cstddef>
@@ -47,6 +48,10 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT uses_allocator : public integral_constant<b
 template <class _Tp, class _Alloc>
 inline constexpr bool uses_allocator_v = __uses_allocator_v<_Tp, _Alloc>;
 
+template <class... _Tp, class _Alloc>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT uses_allocator<tuple<_Tp...>, _Alloc> : true_type
+{};
+
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>

cuda/cccl/headers/include/cuda/std/__new/allocate.h

@@ -28,6 +28,11 @@
 #  include <new> // for align_val_t
 #endif // _LIBCUDACXX_HAS_ALIGNED_ALLOCATION() !_CCCL_COMPILER(NVRTC)
 
+// clang-cuda only provides device flavors of operator new, so we need to pull in <new> here
+#if _CCCL_CUDA_COMPILER(CLANG)
+#  include <new>
+#endif // _CCCL_CUDA_COMPILER(CLANG)
+
 #if !defined(__cpp_sized_deallocation) || __cpp_sized_deallocation < 201309L
 #  define _LIBCUDACXX_HAS_SIZED_DEALLOCATION() 0
 #else

cuda/cccl/headers/include/cuda/{__barrier/barrier_native_handle.h → std/__new/device_new.h}

@@ -1,15 +1,16 @@
+// -*- 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.
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _CUDA___BARRIER_BARRIER_NATIVE_HANDLE_H
-#define _CUDA___BARRIER_BARRIER_NATIVE_HANDLE_H
+#ifndef _CUDA_STD___NEW_DEVICE_NEW_H
+#define _CUDA_STD___NEW_DEVICE_NEW_H
 
 #include <cuda/std/detail/__config>
 
@@ -21,25 +22,9 @@
 #  pragma system_header
 #endif // no system header
 
-#include <cuda/__barrier/barrier_block_scope.h>
-#include <cuda/__fwd/barrier.h>
-#include <cuda/std/cstdint>
+// clang-cuda only provides device flavors of operator new if we included <new>
+#if _CCCL_CUDA_COMPILER(CLANG)
+#  include <new>
+#endif // _CCCL_CUDA_COMPILER(CLANG)
 
-#if _CCCL_CUDA_COMPILATION()
-
-#  include <cuda/std/__cccl/prologue.h>
-
-_CCCL_BEGIN_NAMESPACE_CUDA_DEVICE
-
-_CCCL_DEVICE inline ::cuda::std::uint64_t* barrier_native_handle(barrier<thread_scope_block>& __b)
-{
-  return reinterpret_cast<::cuda::std::uint64_t*>(&__b.__barrier);
-}
-
-_CCCL_END_NAMESPACE_CUDA_DEVICE
-
-#  include <cuda/std/__cccl/epilogue.h>
-
-#endif // _CCCL_CUDA_COMPILATION()
-
-#endif // _CUDA___BARRIER_BARRIER_NATIVE_HANDLE_H
+#endif // _CUDA_STD___NEW_DEVICE_NEW_H

cuda/cccl/headers/include/cuda/std/__new_

@@ -23,6 +23,7 @@
 
 #include <cuda/std/__new/allocate.h>
 #include <cuda/std/__new/bad_alloc.h>
+#include <cuda/std/__new/device_new.h>
 #include <cuda/std/__new/launder.h>
 #include <cuda/std/version>
 

cuda/cccl/headers/include/cuda/std/__optional/optional.h

@@ -30,6 +30,7 @@
 #include <cuda/std/__optional/nullopt.h>
 #include <cuda/std/__optional/optional_base.h>
 #include <cuda/std/__type_traits/disjunction.h>
+#include <cuda/std/__type_traits/is_convertible.h>
 #include <cuda/std/__type_traits/is_copy_constructible.h>
 #include <cuda/std/__type_traits/is_move_constructible.h>
 #include <cuda/std/__type_traits/is_object.h>
@@ -429,7 +430,7 @@ public:
   _CCCL_API constexpr auto and_then(_Func&& __f) &
   {
     using _Up = invoke_result_t<_Func, value_type&>;
-    static_assert(__is_std_optional_v<remove_cvref_t<_Up>>,
+    static_assert(__is_cuda_std_optional_v<remove_cvref_t<_Up>>,
                   "Result of f(value()) must be a specialization of std::optional");
     if (this->__engaged_)
     {
@@ -442,7 +443,7 @@ public:
   _CCCL_API constexpr auto and_then(_Func&& __f) const&
   {
     using _Up = invoke_result_t<_Func, const value_type&>;
-    static_assert(__is_std_optional_v<remove_cvref_t<_Up>>,
+    static_assert(__is_cuda_std_optional_v<remove_cvref_t<_Up>>,
                   "Result of f(value()) must be a specialization of std::optional");
     if (this->__engaged_)
     {
@@ -455,7 +456,7 @@ public:
   _CCCL_API constexpr auto and_then(_Func&& __f) &&
   {
     using _Up = invoke_result_t<_Func, value_type&&>;
-    static_assert(__is_std_optional_v<remove_cvref_t<_Up>>,
+    static_assert(__is_cuda_std_optional_v<remove_cvref_t<_Up>>,
                   "Result of f(std::move(value())) must be a specialization of std::optional");
     if (this->__engaged_)
     {
@@ -468,7 +469,7 @@ public:
   _CCCL_API constexpr auto and_then(_Func&& __f) const&&
   {
     using _Up = invoke_result_t<_Func, const value_type&&>;
-    static_assert(__is_std_optional_v<remove_cvref_t<_Up>>,
+    static_assert(__is_cuda_std_optional_v<remove_cvref_t<_Up>>,
                   "Result of f(std::move(value())) must be a specialization of std::optional");
     if (this->__engaged_)
     {

cuda/cccl/headers/include/cuda/std/__optional/optional_ref.h

@@ -103,20 +103,20 @@ public:
 
   _CCCL_TEMPLATE(class _Up)
   _CCCL_REQUIRES(
-    (!__is_std_optional_v<decay_t<_Up>>) _CCCL_AND is_convertible_v<_Up, _Tp&> _CCCL_AND(!__from_temporary<_Up>))
+    (!__is_cuda_std_optional_v<decay_t<_Up>>) _CCCL_AND is_convertible_v<_Up, _Tp&> _CCCL_AND(!__from_temporary<_Up>))
   _CCCL_API constexpr optional(_Up&& __u) noexcept(noexcept(static_cast<_Tp&>(::cuda::std::declval<_Up>())))
       : __value_(::cuda::std::addressof(static_cast<_Tp&>(::cuda::std::forward<_Up>(__u))))
   {}
 
   _CCCL_TEMPLATE(class _Up)
-  _CCCL_REQUIRES((!__is_std_optional_v<decay_t<_Up>>) _CCCL_AND(!is_convertible_v<_Up, _Tp&>)
+  _CCCL_REQUIRES((!__is_cuda_std_optional_v<decay_t<_Up>>) _CCCL_AND(!is_convertible_v<_Up, _Tp&>)
                    _CCCL_AND is_constructible_v<_Tp&, _Up> _CCCL_AND(!__from_temporary<_Up>))
   _CCCL_API explicit constexpr optional(_Up&& __u) noexcept(noexcept(static_cast<_Tp&>(::cuda::std::declval<_Up>())))
       : __value_(::cuda::std::addressof(static_cast<_Tp&>(::cuda::std::forward<_Up>(__u))))
   {}
 
   _CCCL_TEMPLATE(class _Up)
-  _CCCL_REQUIRES((!__is_std_optional_v<decay_t<_Up>>) _CCCL_AND __from_temporary<_Up>)
+  _CCCL_REQUIRES((!__is_cuda_std_optional_v<decay_t<_Up>>) _CCCL_AND __from_temporary<_Up>)
   _CCCL_API constexpr optional(_Up&&) = delete;
 
   _CCCL_TEMPLATE(class _Up)
@@ -263,7 +263,7 @@ public:
   _CCCL_API constexpr auto and_then(_Func&& __f) const
   {
     using _Up = invoke_result_t<_Func, _Tp&>;
-    static_assert(__is_std_optional_v<remove_cvref_t<_Up>>,
+    static_assert(__is_cuda_std_optional_v<remove_cvref_t<_Up>>,
                   "optional<T&>::and_then: Result of f(value()) must be a specialization of std::optional");
     if (__value_ != nullptr)
     {

cuda/cccl/headers/include/cuda/std/__random/linear_congruential_engine.h

@@ -20,13 +20,13 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__fwd/ios.h>
 #include <cuda/std/__random/is_seed_sequence.h>
 #include <cuda/std/__type_traits/enable_if.h>
 #include <cuda/std/__type_traits/integral_constant.h>
 #include <cuda/std/__type_traits/is_unsigned.h>
 #include <cuda/std/climits>
 #include <cuda/std/cstdint>
-#include <cuda/std/detail/libcxx/include/iosfwd>
 
 #include <cuda/std/__cccl/prologue.h>