cuda-cccl 0.3.1__cp311-cp311-manylinux_2_24_aarch64.whl → 0.3.2__cp311-cp311-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/std/__ranges/movable_box.h

@@ -65,7 +65,7 @@ _CCCL_CONCEPT __movable_box_object = move_constructible<_Tp> && is_object_v<_Tp>
 // whenever we can apply any of these optimizations for both the copy assignment and the move assignment
 // operator.
 template <class _Tp>
-[[nodiscard]] _CCCL_API constexpr bool __doesnt_need_empty_state() noexcept
+[[nodiscard]] _CCCL_API _CCCL_CONSTEVAL bool __doesnt_need_empty_state() noexcept
 {
   if constexpr (copy_constructible<_Tp>)
   {
@@ -92,7 +92,7 @@ template <class _Tp>
 // Hence, when the _Tp doesn't have an assignment operator, we can't risk making it a potentially-overlapping
 // subobject because of the above, and we don't use [[no_unique_address]] in that case.
 template <class _Tp>
-[[nodiscard]] _CCCL_API constexpr bool __can_use_no_unique_address() noexcept
+[[nodiscard]] _CCCL_API _CCCL_CONSTEVAL bool __can_use_no_unique_address() noexcept
 {
   if constexpr (copy_constructible<_Tp>)
   {

cuda/cccl/headers/include/cuda/std/__type_traits/is_primary_template.h

@@ -70,7 +70,7 @@ using __select_traits = conditional_t<__is_primary_cccl_template<_Iter>::value,
 #else // ^^^ _CCCL_COMPILER(NVRTC) ^^^ / vvv !_CCCL_COMPILER(NVRTC) vvv
 
 // We also need to respect what the user is defining to std::iterator_traits
-#  if defined(__GLIBCXX__)
+#  if _CCCL_HOST_STD_LIB(LIBSTDCXX)
 // libstdc++ uses `is_base_of`
 template <class _Iter, bool>
 inline constexpr bool __is_primary_std_template_impl =
@@ -83,13 +83,15 @@ inline constexpr bool __is_primary_std_template_impl<_Iter, true> = true;
 template <class _Iter>
 struct __is_primary_std_template : bool_constant<__is_primary_std_template_impl<_Iter, is_pointer_v<_Iter>>>
 {};
-#  elif defined(_LIBCPP_VERSION)
+#  elif _CCCL_HOST_STD_LIB(LIBCXX)
+
 // libc++ uses the same mechanism than we do with __primary_template
 template <class _Traits>
 using __test_for_primary_std_template = enable_if_t<_IsSame<_Traits, typename _Traits::__primary_template>::value>;
 template <class _Iter>
-using __is_primary_std_template = _IsValidExpansion<__test_for_primary_template, ::std::iterator_traits<_Iter>>;
-#  elif defined(_MSVC_STL_VERSION) || defined(_IS_WRS)
+using __is_primary_std_template = _IsValidExpansion<__test_for_primary_std_template, ::std::iterator_traits<_Iter>>;
+
+#  elif _CCCL_HOST_STD_LIB(STL)
 // On MSVC we must check for the base class because `_From_primary` is only defined in C++20
 template <class _Iter, bool>
 inline constexpr bool __is_primary_std_template_impl =
@@ -102,7 +104,7 @@ inline constexpr bool __is_primary_std_template_impl<_Iter, true> = true;
 template <class _Iter>
 struct __is_primary_std_template : bool_constant<__is_primary_std_template_impl<_Iter, is_pointer_v<_Iter>>>
 {};
-#  endif // _MSVC_STL_VERSION || _IS_WRS
+#  endif // ^^^ _CCCL_HOST_STD_LIB(STL) ^^^
 
 template <class _Iter, class _OtherTraits>
 using __select_traits =

cuda/cccl/headers/include/cuda/std/__type_traits/result_of.h

@@ -33,7 +33,7 @@ template <class _Callable>
 class result_of;
 
 template <class _Fp, class... _Args>
-class CCCL_DEPRECATED _CCCL_TYPE_VISIBILITY_DEFAULT result_of<_Fp(_Args...)> : public __invoke_of<_Fp, _Args...>
+class CCCL_DEPRECATED _CCCL_TYPE_VISIBILITY_DEFAULT result_of<_Fp(_Args...)> : public invoke_result<_Fp, _Args...>
 {};
 
 template <class _Tp>

cuda/cccl/headers/include/cuda/std/__utility/pair.h

@@ -61,11 +61,6 @@
 #include <cuda/std/__utility/piecewise_construct.h>
 #include <cuda/std/cstddef>
 
-// Provide compatibility between `std::pair` and `cuda::std::pair`
-#if !_CCCL_COMPILER(NVRTC)
-#  include <utility>
-#endif // !_CCCL_COMPILER(NVRTC)
-
 #include <cuda/std/__cccl/prologue.h>
 
 _CCCL_BEGIN_NAMESPACE_CUDA_STD

cuda/cccl/headers/include/cuda/std/bitset

@@ -653,7 +653,7 @@ _CCCL_API constexpr void __throw_if_out_of_range(size_t __pos, const char* __msg
 }
 
 template <>
-_CCCL_API inline void __throw_if_out_of_range<0>(size_t __pos, const char* __msg)
+_CCCL_API inline void __throw_if_out_of_range<0>(size_t, const char* __msg)
 {
   ::cuda::std::__throw_out_of_range(__msg);
 }

cuda/cccl/headers/include/cuda/std/detail/libcxx/include/__config

@@ -184,19 +184,22 @@ extern "C++" {
 // NVRTC has a bug that prevented the use of delegated constructors, as it did not accept execution space annotations.
 // This creates a whole lot of boilerplate that we can avoid through a macro (see nvbug3961621)
 #  if _CCCL_COMPILER(NVRTC, <, 12, 6)
-#    define _LIBCUDACXX_DELEGATE_CONSTRUCTORS(__class, __baseclass, ...)                                    \
-      using __base = __baseclass<__VA_ARGS__>;                                                              \
-      _CCCL_TEMPLATE(class... _Args)                                                                        \
-      _CCCL_REQUIRES(is_constructible_v<__base, _Args...>)                                                  \
-      _CCCL_API constexpr __class(_Args&&... __args) noexcept(is_nothrow_constructible_v<__base, _Args...>) \
-          : __base(::cuda::std::forward<_Args>(__args)...)                                                  \
-      {}                                                                                                    \
-      _CCCL_HIDE_FROM_ABI constexpr __class() noexcept = default;
+#    define _LIBCUDACXX_DELEGATE_CONSTRUCTORS(__class, __baseclass, ...)                                          \
+      using __base = __baseclass<__VA_ARGS__>;                                                                    \
+      _CCCL_TEMPLATE(class... _Args)                                                                              \
+      _CCCL_REQUIRES(::cuda::std::is_constructible_v<__base, _Args...>)                                           \
+      _CCCL_API constexpr __class(_Args&&... __args) noexcept(                                                    \
+        ::cuda::std::is_nothrow_constructible_v<__base, _Args...>)                                                \
+          : __base(::cuda::std::forward<_Args>(__args)...)                                                        \
+      {}                                                                                                          \
+      _CCCL_HIDE_FROM_ABI constexpr __class() noexcept(::cuda::std::is_nothrow_default_constructible_v<__base>) = \
+        default;
 #  else // ^^^ workaround ^^^ / vvv no workaround vvv
-#    define _LIBCUDACXX_DELEGATE_CONSTRUCTORS(__class, __baseclass, ...) \
-      using __base = __baseclass<__VA_ARGS__>;                           \
-      using __base::__base;                                              \
-      _CCCL_HIDE_FROM_ABI constexpr __class() noexcept = default;
+#    define _LIBCUDACXX_DELEGATE_CONSTRUCTORS(__class, __baseclass, ...)                                          \
+      using __base = __baseclass<__VA_ARGS__>;                                                                    \
+      using __base::__base;                                                                                       \
+      _CCCL_HIDE_FROM_ABI constexpr __class() noexcept(::cuda::std::is_nothrow_default_constructible_v<__base>) = \
+        default;
 #  endif // ^^^ no workaround ^^^
 
 #endif // __cplusplus

cuda/cccl/headers/include/cuda/std/detail/libcxx/include/variant

@@ -563,7 +563,7 @@ struct __variant
             class... _OtherVariants,
             enable_if_t<(_Remaining != 0) && (_CurrentVariant == 0), int> = 0>
   _CCCL_API inline _CCCL_VISIBILITY_HIDDEN static constexpr size_t
-  __get_runtime_index(const _Variant& __v, const _OtherVariants&... __vs) noexcept
+  __get_runtime_index(const _Variant& __v, const _OtherVariants&...) noexcept
   {
     return __v.__impl_.index();
   }
@@ -574,7 +574,7 @@ struct __variant
             class... _OtherVariants,
             enable_if_t<(_Remaining != 0) && (_CurrentVariant != 0), int> = 0>
   _CCCL_API inline _CCCL_VISIBILITY_HIDDEN static constexpr size_t
-  __get_runtime_index(const _Variant& __v, const _OtherVariants&... __vs) noexcept
+  __get_runtime_index(const _Variant&, const _OtherVariants&... __vs) noexcept
   {
     return __get_runtime_index<_Remaining, _CurrentVariant - 1>(__vs...);
   }
@@ -995,9 +995,10 @@ class _CCCL_TYPE_VISIBILITY_DEFAULT __ctor : public __dtor<_Traits>
   {
     if (__index == _CurrentIndex)
     {
-      __construct_at(::cuda::std::addressof(__access::__base::__get_alt<_CurrentIndex>(__lhs.__as_base())),
-                     in_place,
-                     __access::__base::__get_alt<_CurrentIndex>(::cuda::std::forward<_Rhs>(__rhs).__as_base()).__value);
+      ::cuda::std::__construct_at(
+        ::cuda::std::addressof(__access::__base::__get_alt<_CurrentIndex>(__lhs.__as_base())),
+        in_place,
+        __access::__base::__get_alt<_CurrentIndex>(::cuda::std::forward<_Rhs>(__rhs).__as_base()).__value);
       return;
     }
     __generic_construct_impl(
@@ -1010,9 +1011,10 @@ class _CCCL_TYPE_VISIBILITY_DEFAULT __ctor : public __dtor<_Traits>
   {
     if (__index == 0)
     {
-      __construct_at(::cuda::std::addressof(__access::__base::__get_alt<0>(__lhs.__as_base())),
-                     in_place,
-                     __access::__base::__get_alt<0>(::cuda::std::forward<_Rhs>(__rhs).__as_base()).__value);
+      ::cuda::std::__construct_at(
+        ::cuda::std::addressof(__access::__base::__get_alt<0>(__lhs.__as_base())),
+        in_place,
+        __access::__base::__get_alt<0>(::cuda::std::forward<_Rhs>(__rhs).__as_base()).__value);
       return;
     }
     // We already checked that every variant has a value, so we should never reach this line
@@ -1027,7 +1029,7 @@ protected:
   template <size_t _Ip, class _Tp, class... _Args>
   _CCCL_API inline static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args)
   {
-    __construct_at(::cuda::std::addressof(__a), in_place, ::cuda::std::forward<_Args>(__args)...);
+    ::cuda::std::__construct_at(::cuda::std::addressof(__a), in_place, ::cuda::std::forward<_Args>(__args)...);
     return __a.__value;
   }
 

cuda/cccl/headers/include/cuda/std/inplace_vector

@@ -1525,8 +1525,8 @@ public:
   _CCCL_API constexpr iterator
   erase(const_iterator __cfirst, const_iterator __clast) noexcept(is_nothrow_move_assignable_v<_Tp>)
   {
-    const iterator __first = (iterator) __cfirst;
-    const iterator __last  = (iterator) __clast;
+    const iterator __first = this->begin() + (__cfirst - this->begin());
+    const iterator __last  = this->begin() + (__clast - this->begin());
     const iterator __end   = this->end();
     if (__first == __last)
     {
@@ -1736,7 +1736,7 @@ public:
     }
   }
 
-  _CCCL_API constexpr inplace_vector(const size_type __count, const _Tp& __value)
+  _CCCL_API constexpr inplace_vector(const size_type __count, const _Tp&)
       : __base()
   {
     if (__count > 0)
@@ -1973,7 +1973,7 @@ public:
 
   _CCCL_TEMPLATE(class _Range)
   _CCCL_REQUIRES(::cuda::std::ranges::__container_compatible_range<_Range, _Tp>)
-  _CCCL_API constexpr iterator insert_range(const_iterator __cpos, _Range&& __range)
+  _CCCL_API constexpr iterator insert_range(const_iterator, _Range&& __range)
   {
     if (::cuda::std::ranges::begin(__range) != ::cuda::std::ranges::end(__range))
     {

cuda/cccl/headers/include/cuda/std/numbers

@@ -26,6 +26,9 @@
 
 #include <cuda/std/__cccl/prologue.h>
 
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_NVHPC(inexact_fp_conversion)
+
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 template <class _Tp>
@@ -336,6 +339,8 @@ inline constexpr double phi        = __numbers<double>::__phi();
 
 _CCCL_END_NAMESPACE_CUDA_STD
 
+_CCCL_DIAG_POP
+
 #include <cuda/std/__cccl/epilogue.h>
 
 #endif // _CUDA_STD_NUMBERS

cuda/cccl/headers/include/cuda/std/string_view

@@ -24,6 +24,9 @@
 #include <cuda/std/__cstddef/types.h>
 #include <cuda/std/__functional/hash.h>
 #include <cuda/std/__functional/unary_function.h>
+#include <cuda/std/__fwd/allocator.h>
+#include <cuda/std/__fwd/char_traits.h>
+#include <cuda/std/__fwd/string.h>
 #include <cuda/std/__fwd/string_view.h>
 #include <cuda/std/__iterator/access.h>
 #include <cuda/std/__iterator/bounded_iter.h>
@@ -49,16 +52,19 @@
 #include <cuda/std/__type_traits/is_trivially_constructible.h>
 #include <cuda/std/__type_traits/is_trivially_copyable.h>
 #include <cuda/std/__type_traits/remove_cvref.h>
-#include <cuda/std/__type_traits/remove_reference.h>
 #include <cuda/std/__type_traits/type_identity.h>
 #include <cuda/std/__utility/declval.h>
 #include <cuda/std/detail/libcxx/include/stdexcept>
 #include <cuda/std/limits>
 #include <cuda/std/version>
 
+// todo: find a way to get rid of these includes
 #if !_CCCL_COMPILER(NVRTC)
-#  include <string_view>
-#endif // !_CCCL_COMPILER(NVRTC)
+#  include <string> // for std::basic_string operator<<
+#  if __cpp_lib_string_view >= 201606L
+#    include <string_view> // for std::basic_string_view operator<<
+#  endif // __cpp_lib_string_view >= 201606L
+#endif // __cpp_lib_string_view >= 201606L
 
 #include <cuda/std/__cccl/prologue.h>
 
@@ -75,13 +81,65 @@ inline constexpr bool __cccl_is_string_view_v<const volatile _Tp> = __cccl_is_st
 template <class _CharT, class _Traits>
 inline constexpr bool __cccl_is_string_view_v<basic_string_view<_CharT, _Traits>> = true;
 
+template <class _Tp>
+inline constexpr bool __cccl_is_std_string_v = false;
+#if !_CCCL_COMPILER(NVRTC)
+template <class _CharT, class _Traits, class _Alloc>
+inline constexpr bool __cccl_is_std_string_v<::std::basic_string<_CharT, _Traits, _Alloc>> = true;
+#endif // !_CCCL_COMPILER(NVRTC)
+
+template <class _Tp>
+inline constexpr bool __cccl_is_std_string_view_v = false;
+#if __cpp_lib_string_view >= 201606L
+template <class _CharT, class _Traits>
+inline constexpr bool __cccl_is_std_string_view_v<::std::basic_string_view<_CharT, _Traits>> = true;
+#endif // __cpp_lib_string_view >= 201606L
+
 template <class _Range, class _CharT, class _Traits>
 _CCCL_CONCEPT __cccl_has_basic_sv_conv_operator =
   _CCCL_REQUIRES_EXPR((_Range, _CharT, _Traits), remove_cvref_t<_Range>& __d)(
     (__d.operator ::cuda::std::basic_string_view<_CharT, _Traits>()));
 
+template <class _Range, class _CharT, class _Traits>
+_CCCL_CONCEPT __cccl_basic_sv_compatible_range_check_traits = _CCCL_REQUIRES_EXPR((_Range, _CharT, _Traits)) //
+  ( //
+    typename(typename _Range::traits_type), //
+    requires(is_same_v<typename _Range::traits_type, _Traits>) //
+  );
+
+template <class _Range, class _CharT, class _Traits>
+_CCCL_CONCEPT __cccl_basic_sv_compatible_range_check_traits_std_ext =
+#if !_CCCL_COMPILER(NVRTC)
+  _CCCL_REQUIRES_EXPR((_Range, _CharT, _Traits)) //
+  ( //
+    typename(typename _Range::traits_type), //
+    requires(is_same_v<typename _Range::traits_type, ::std::char_traits<_CharT>>), //
+    requires(is_same_v<_Traits, ::cuda::std::char_traits<_CharT>>) //
+  );
+#else // ^^^ !_CCCL_COMPILER(NVRTC) ^^^ / vvv _CCCL_COMPILER(NVRTC) vvv
+  true;
+#endif // ^^^ _CCCL_COMPILER(NVRTC) ^^^
+
+template <class _Range, class _CharT, class _Traits>
+_CCCL_CONCEPT __cccl_basic_sv_compatible_range = _CCCL_REQUIRES_EXPR((_Range, _CharT, _Traits)) //
+  ( //
+    requires(::cuda::std::ranges::contiguous_range<_Range>), //
+    requires(::cuda::std::ranges::sized_range<_Range>), //
+    requires(is_same_v<::cuda::std::ranges::range_value_t<_Range>, _CharT>), //
+    requires(!(__cccl_is_string_view_v<remove_cvref_t<_Range>>
+               && __cccl_basic_sv_compatible_range_check_traits<_Range, _CharT, _Traits>) ), //
+    requires(!is_convertible_v<_Range, const _CharT*>), //
+    requires(!__cccl_has_basic_sv_conv_operator<_Range, _CharT, _Traits>), //
+    requires(!(__cccl_is_std_string_v<remove_cvref_t<_Range>>
+               && (__cccl_basic_sv_compatible_range_check_traits<_Range, _CharT, _Traits>
+                   || __cccl_basic_sv_compatible_range_check_traits_std_ext<_Range, _CharT, _Traits>) )), //
+    requires(!(__cccl_is_std_string_view_v<remove_cvref_t<_Range>>
+               && (__cccl_basic_sv_compatible_range_check_traits<_Range, _CharT, _Traits>
+                   || __cccl_basic_sv_compatible_range_check_traits_std_ext<_Range, _CharT, _Traits>) )) //
+  );
+
 template <class _CharT, class _Traits>
-class basic_string_view
+class _CCCL_TYPE_VISIBILITY_DEFAULT basic_string_view
 {
 public:
   using traits_type            = _Traits;
@@ -146,17 +204,54 @@ public:
     _CCCL_ASSERT((__end - __begin) >= 0, "string_view::string_view(iterator, sentinel) received invalid range");
   }
 
+#if !_CCCL_COMPILER(NVRTC)
+  _CCCL_TEMPLATE(class _Traits2 = _Traits, class _Alloc)
+  _CCCL_REQUIRES(is_same_v<_Traits2, char_traits<_CharT>>)
+  _CCCL_HOST_API constexpr basic_string_view(
+    const ::std::basic_string<_CharT, ::std::char_traits<_CharT>, _Alloc>& __sv) noexcept
+      : __data_{__sv.data()}
+      , __size_{__sv.size()}
+  {}
+
+  template <class _Alloc>
+  _CCCL_HOST_API constexpr basic_string_view(const ::std::basic_string<_CharT, _Traits, _Alloc>& __sv) noexcept
+      : __data_{__sv.data()}
+      , __size_{__sv.size()}
+  {}
+#endif // !_CCCL_COMPILER(NVRTC)
+
+#if __cpp_lib_string_view >= 201606L
+  _CCCL_TEMPLATE(class _Traits2 = _Traits)
+  _CCCL_REQUIRES(is_same_v<_Traits2, char_traits<_CharT>>)
+  _CCCL_HOST_API constexpr basic_string_view(::std::basic_string_view<_CharT> __s) noexcept
+      : __data_{__s.data()}
+      , __size_{__s.size()}
+  {}
+
+  _CCCL_HOST_API constexpr basic_string_view(::std::basic_string_view<_CharT, _Traits> __s) noexcept
+      : __data_{__s.data()}
+      , __size_{__s.size()}
+  {}
+#endif // __cpp_lib_string_view >= 201606L
+
   _CCCL_TEMPLATE(class _Range)
-  _CCCL_REQUIRES(
-    (!is_same_v<remove_cvref_t<_Range>, basic_string_view>) _CCCL_AND ::cuda::std::ranges::contiguous_range<_Range>
-      _CCCL_AND ::cuda::std::ranges::sized_range<_Range> _CCCL_AND
-        is_same_v<::cuda::std::ranges::range_value_t<_Range>, _CharT> _CCCL_AND(!is_convertible_v<_Range, const _CharT*>)
-          _CCCL_AND(!__cccl_has_basic_sv_conv_operator<_Range, _CharT, _Traits>))
+  _CCCL_REQUIRES(__cccl_basic_sv_compatible_range<_Range, _CharT, _Traits>)
   _CCCL_API explicit constexpr basic_string_view(_Range&& __r)
       : __data_{::cuda::std::ranges::data(__r)}
       , __size_{::cuda::std::ranges::size(__r)}
   {}
 
+  // msvc has problems with constructing a string view from another string view using the from ranges constructor,
+  // so we define the constructor ourselves
+#if _CCCL_COMPILER(MSVC)
+  _CCCL_TEMPLATE(class _OtherTraits)
+  _CCCL_REQUIRES((!is_same_v<_Traits, _OtherTraits>) )
+  _CCCL_API explicit constexpr basic_string_view(const basic_string_view<_CharT, _OtherTraits>& __other)
+      : __data_{__other.data()}
+      , __size_{__other.size()}
+  {}
+#endif // _CCCL_COMPILER(MSVC)
+
   [[nodiscard]] _CCCL_API constexpr const_iterator begin() const noexcept
   {
     return const_iterator{__data_};
@@ -698,6 +793,20 @@ public:
     return __lhs.compare(__rhs) >= 0;
   }
 
+#if __cpp_lib_string_view >= 201606L
+  _CCCL_TEMPLATE(class _Traits2 = _Traits)
+  _CCCL_REQUIRES(is_same_v<_Traits2, char_traits<_CharT>>)
+  _CCCL_HOST_API constexpr operator ::std::basic_string_view<_CharT>() const noexcept
+  {
+    return ::std::basic_string_view<_CharT>{__data_, __size_};
+  }
+
+  _CCCL_HOST_API constexpr operator ::std::basic_string_view<_CharT, _Traits>() const noexcept
+  {
+    return ::std::basic_string_view<_CharT, _Traits>{__data_, __size_};
+  }
+#endif // ^^^ __cpp_lib_string_view >= 201606L ^^^
+
 private:
   enum class __assume_valid
   {
@@ -725,6 +834,23 @@ _CCCL_TEMPLATE(class _Range)
 _CCCL_REQUIRES(::cuda::std::ranges::contiguous_range<_Range>)
 _CCCL_HOST_DEVICE basic_string_view(_Range&&) -> basic_string_view<::cuda::std::ranges::range_value_t<_Range>>;
 
+#if !_CCCL_COMPILER(NVRTC)
+template <class _CharT, class _Alloc>
+_CCCL_HOST basic_string_view(::std::basic_string<_CharT, ::std::char_traits<_CharT>, _Alloc>)
+  -> basic_string_view<_CharT>;
+
+template <class _CharT, class _Traits, class _Alloc>
+_CCCL_HOST basic_string_view(::std::basic_string<_CharT, _Traits, _Alloc>) -> basic_string_view<_CharT, _Traits>;
+#endif // !_CCCL_COMPILER(NVRTC)
+
+#if __cpp_lib_string_view >= 201606L
+template <class _CharT>
+_CCCL_HOST basic_string_view(::std::basic_string_view<_CharT>) -> basic_string_view<_CharT>;
+
+template <class _CharT, class _Traits>
+_CCCL_HOST basic_string_view(::std::basic_string_view<_CharT, _Traits>) -> basic_string_view<_CharT, _Traits>;
+#endif // __cpp_lib_string_view >= 201606L
+
 // operator <<
 
 #if !_CCCL_COMPILER(NVRTC)
@@ -732,14 +858,23 @@ template <class _CharT>
 _CCCL_HOST_API ::std::basic_ostream<_CharT>&
 operator<<(::std::basic_ostream<_CharT>& __os, basic_string_view<_CharT> __str)
 {
-  return __os << ::std::basic_string_view<_CharT>{__str.data(), __str.size()};
+#  if __cpp_lib_string_view >= 201606L
+  return __os << ::std::basic_string_view<_CharT, ::std::char_traits<_CharT>>{__str};
+#  else // ^^^ __cpp_lib_string_view >= 201606L ^^^ / vvv __cpp_lib_string_view < 201606L vvv
+  return __os
+      << ::std::basic_string<_CharT, ::std::char_traits<_CharT>, ::std::allocator<_CharT>>{__str.data(), __str.size()};
+#  endif // ^^^ __cpp_lib_string_view < 201606L ^^^
 }
 
 template <class _CharT, class _Traits>
 _CCCL_HOST_API ::std::basic_ostream<_CharT, _Traits>&
 operator<<(::std::basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __str)
 {
-  return __os << ::std::basic_string_view<_CharT, _Traits>{__str.data(), __str.size()};
+#  if __cpp_lib_string_view >= 201606L
+  return __os << ::std::basic_string_view<_CharT, _Traits>{__str};
+#  else // ^^^ __cpp_lib_string_view >= 201606L ^^^ / vvv __cpp_lib_string_view < 201606L vvv
+  return __os << ::std::basic_string<_CharT, _Traits, ::std::allocator<_CharT>>{__str.data(), __str.size()};
+#  endif // ^^^ __cpp_lib_string_view < 201606L ^^^
 }
 #endif // !_CCCL_COMPILER(NVRTC)
 

cuda/cccl/headers/include/cuda/stream_ref

@@ -48,6 +48,11 @@ private:
 #  pragma system_header
 #endif // no system header
 
+#if !defined(CCCL_IGNORE_DEPRECATED_STREAM_REF_HEADER)
+_CCCL_WARNING("The <cuda/stream_ref> header is deprecated and will be removed in the next major release. The \
+contents were moved to <cuda/stream>. To ignore this message, define CCCL_IGNORE_DEPRECATED_STREAM_REF_HEADER.")
+#endif // !CCCL_IGNORE_DEPRECATED_STREAM_REF_HEADER
+
 #include <cuda/__stream/get_stream.h>
 #include <cuda/__stream/stream_ref.h>
 

cuda/cccl/headers/include/cuda/utility

@@ -21,6 +21,7 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/__utility/in_range.h>
 #include <cuda/__utility/static_for.h>
 #include <cuda/std/utility>
 

cuda/cccl/headers/include/nv/target

@@ -67,10 +67,11 @@ constexpr base_int_t sm_100_bit = 1 << 17;
 constexpr base_int_t sm_103_bit = 1 << 19;
 constexpr base_int_t sm_110_bit = 1 << 20;
 constexpr base_int_t sm_120_bit = 1 << 21;
+constexpr base_int_t sm_121_bit = 1 << 22;
 constexpr base_int_t all_devices =
   sm_35_bit | sm_37_bit | sm_50_bit | sm_52_bit | sm_53_bit | sm_60_bit | sm_61_bit | sm_62_bit | sm_70_bit | sm_72_bit
   | sm_75_bit | sm_80_bit | sm_86_bit | sm_87_bit | sm_89_bit | sm_90_bit | sm_100_bit | sm_103_bit | sm_110_bit
-  | sm_120_bit;
+  | sm_120_bit | sm_121_bit;
 
 // Store a set of targets as a set of bits
 struct _NV_BITSET_ATTRIBUTE target_description
@@ -105,6 +106,7 @@ enum class sm_selector : base_int_t
   sm_103 = 103,
   sm_110 = 110,
   sm_120 = 120,
+  sm_121 = 121,
 };
 
 constexpr base_int_t toint(sm_selector a)
@@ -134,12 +136,14 @@ constexpr base_int_t bitexact(sm_selector a)
        : toint(a) == 103 ? sm_103_bit
        : toint(a) == 110 ? sm_110_bit
        : toint(a) == 120 ? sm_120_bit
+       : toint(a) == 121 ? sm_121_bit
                          : 0;
 }
 
 constexpr base_int_t bitrounddown(sm_selector a)
 {
-  return toint(a) >= 120 ? sm_120_bit
+  return toint(a) >= 121 ? sm_121_bit
+       : toint(a) >= 120 ? sm_120_bit
        : toint(a) >= 110 ? sm_110_bit
        : toint(a) >= 103 ? sm_103_bit
        : toint(a) >= 100 ? sm_100_bit
@@ -222,6 +226,7 @@ constexpr sm_selector sm_100 = sm_selector::sm_100;
 constexpr sm_selector sm_103 = sm_selector::sm_103;
 constexpr sm_selector sm_110 = sm_selector::sm_110;
 constexpr sm_selector sm_120 = sm_selector::sm_120;
+constexpr sm_selector sm_121 = sm_selector::sm_121;
 
 using detail::is_exactly;
 using detail::provides;

cuda/cccl/headers/include/thrust/allocate_unique.h

@@ -16,10 +16,10 @@
 #endif // no system header
 #include <thrust/detail/allocator/allocator_traits.h>
 #include <thrust/detail/memory_algorithms.h>
-#include <thrust/detail/memory_wrapper.h>
 #include <thrust/detail/raw_pointer_cast.h>
 #include <thrust/detail/type_deduction.h>
 
+#include <cuda/std/__cccl/memory_wrapper.h>
 #include <cuda/std/utility>
 
 THRUST_NAMESPACE_BEGIN