cuda-cccl 0.3.0__cp310-cp310-manylinux_2_24_aarch64.whl → 0.3.2__cp310-cp310-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/__mdspan/host_device_accessor.h

@@ -28,11 +28,15 @@
 #include <cuda/std/__iterator/concepts.h>
 #include <cuda/std/__memory/pointer_traits.h>
 #include <cuda/std/__type_traits/always_false.h>
+#include <cuda/std/__type_traits/is_constant_evaluated.h>
+#include <cuda/std/__type_traits/is_constructible.h>
 #include <cuda/std/__type_traits/is_convertible.h>
 #include <cuda/std/__type_traits/is_default_constructible.h>
+#include <cuda/std/__type_traits/is_nothrow_constructible.h>
 #include <cuda/std/__type_traits/is_nothrow_copy_constructible.h>
 #include <cuda/std/__type_traits/is_nothrow_default_constructible.h>
 #include <cuda/std/__utility/declval.h>
+#include <cuda/std/__utility/move.h>
 #include <cuda/std/cassert>
 #include <cuda/std/cstddef>
 
@@ -102,29 +106,30 @@ class __host_accessor : public _Accessor
   static constexpr bool __is_offset_noexcept =
     noexcept(::cuda::std::declval<_Accessor>().offset(::cuda::std::declval<__data_handle_type>(), 0));
 
-  [[nodiscard]] _CCCL_API static constexpr bool
+#if !_CCCL_COMPILER(NVRTC)
+  [[nodiscard]] _CCCL_HOST_API static constexpr bool
   __is_host_accessible_pointer([[maybe_unused]] __data_handle_type __p) noexcept
   {
-#if _CCCL_HAS_CTK()
+#  if _CCCL_HAS_CTK()
     if constexpr (::cuda::std::contiguous_iterator<__data_handle_type>)
     {
-      auto __p1 = ::cuda::std::to_address(__p);
-      ::CUmemorytype __type{};
-      const auto __status =
-        ::cuda::__driver::__pointerGetAttributeNoThrow<::CU_POINTER_ATTRIBUTE_MEMORY_TYPE>(__type, __p1);
-      return (__status != ::cudaSuccess) || __type == ::CU_MEMORYTYPE_HOST;
+      if (!cuda::std::__cccl_default_is_constant_evaluated())
+      {
+        auto __p1 = ::cuda::std::to_address(__p);
+        ::CUmemorytype __type{};
+        const auto __status =
+          ::cuda::__driver::__pointerGetAttributeNoThrow<::CU_POINTER_ATTRIBUTE_MEMORY_TYPE>(__type, __p1);
+        return (__status != ::cudaSuccess) || __type == ::CU_MEMORYTYPE_HOST;
+      }
+      return true;
     }
     else
-#endif // _CCCL_HAS_CTK()
+#  endif // _CCCL_HAS_CTK()
     {
       return true; // cannot be verified
     }
   }
-
-  _CCCL_API static constexpr void __check_host_pointer([[maybe_unused]] __data_handle_type __p) noexcept
-  {
-    _CCCL_ASSERT(__is_host_accessible_pointer(__p), "cuda::__host_accessor data handle is not a HOST pointer");
-  }
+#endif // !_CCCL_COMPILER(NVRTC)
 
 public:
   using offset_policy    = __host_accessor<typename _Accessor::offset_policy>;
@@ -134,10 +139,15 @@ public:
 
   _CCCL_TEMPLATE(class _Accessor2 = _Accessor)
   _CCCL_REQUIRES(::cuda::std::is_default_constructible_v<_Accessor2>)
-  _CCCL_API inline __host_accessor() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Accessor2>)
+  _CCCL_API constexpr __host_accessor() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Accessor2>)
       : _Accessor{}
   {}
 
+  _CCCL_API constexpr __host_accessor(_Accessor&& __acc) noexcept(
+    ::cuda::std::is_nothrow_move_constructible_v<_Accessor>)
+      : _Accessor{::cuda::std::move(__acc)}
+  {}
+
   _CCCL_API constexpr __host_accessor(const _Accessor& __acc) noexcept(
     ::cuda::std::is_nothrow_copy_constructible_v<_Accessor>)
       : _Accessor{__acc}
@@ -147,44 +157,59 @@ public:
   __host_accessor(const __device_accessor<_OtherAccessor>&) = delete;
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(
-    ::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
-  _CCCL_API constexpr __host_accessor(const __host_accessor<_OtherAccessor>& __acc) noexcept(noexcept(_Accessor{
-    ::cuda::std::declval<_OtherAccessor>()}))
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    ::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
+  _CCCL_API constexpr __host_accessor(const __host_accessor<_OtherAccessor>& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
       : _Accessor{__acc}
   {}
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(
-    !::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    !::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
   _CCCL_API constexpr explicit __host_accessor(const __host_accessor<_OtherAccessor>& __acc) noexcept(
-    noexcept(_Accessor{::cuda::std::declval<_OtherAccessor>()}))
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
       : _Accessor{__acc}
   {}
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(
-    ::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
-  _CCCL_API constexpr __host_accessor(const __managed_accessor<_OtherAccessor>& __acc) noexcept(noexcept(_Accessor{
-    ::cuda::std::declval<_OtherAccessor>()}))
-      : _Accessor{__acc}
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, _OtherAccessor> _CCCL_AND(
+    ::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_API constexpr __host_accessor(__host_accessor<_OtherAccessor>&& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, _OtherAccessor>)
+      : _Accessor{::cuda::std::move(__acc)}
   {}
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
     !::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_API constexpr explicit __host_accessor(__host_accessor<_OtherAccessor>&& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, _OtherAccessor>)
+      : _Accessor{::cuda::std::move(__acc)}
+  {}
+
+  _CCCL_TEMPLATE(typename _OtherAccessor)
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    ::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
+  _CCCL_API constexpr __host_accessor(const __managed_accessor<_OtherAccessor>& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
+      : _Accessor{__acc}
+  {}
+
+  _CCCL_TEMPLATE(typename _OtherAccessor)
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    !::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
   _CCCL_API constexpr explicit __host_accessor(const __managed_accessor<_OtherAccessor>& __acc) noexcept(
-    noexcept(_Accessor{::cuda::std::declval<_OtherAccessor>()}))
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
       : _Accessor{__acc}
   {}
 
   _CCCL_API constexpr reference access(data_handle_type __p, size_t __i) const noexcept(__is_access_noexcept)
   {
-#if _CCCL_HOST_COMPILATION()
-    __check_host_pointer(__p);
-#else // ^^^ _CCCL_HOST_COMPILATION() ^^^ // vvv !_CCCL_HOST_COMPILATION() vvv
-    static_assert(false, "cuda::__host_accessor cannot be used in DEVICE code");
-#endif // !_CCCL_HOST_COMPILATION()
+    NV_IF_ELSE_TARGET(
+      NV_IS_DEVICE,
+      (_CCCL_VERIFY(false, "cuda::__host_accessor cannot be used in DEVICE code");),
+      (_CCCL_ASSERT(__is_host_accessible_pointer(__p), "cuda::__host_accessor data handle is not a HOST pointer");))
     return _Accessor::access(__p, __i);
   }
 
@@ -265,12 +290,17 @@ public:
   using reference        = typename _Accessor::reference;
   using element_type     = typename _Accessor::element_type;
 
-  _CCCL_TEMPLATE(typename _NotUsed = void)
-  _CCCL_REQUIRES(::cuda::std::is_default_constructible_v<_Accessor>)
-  _CCCL_API inline __device_accessor() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Accessor>)
+  _CCCL_TEMPLATE(class _Accessor2 = _Accessor)
+  _CCCL_REQUIRES(::cuda::std::is_default_constructible_v<_Accessor2>)
+  _CCCL_API constexpr __device_accessor() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Accessor2>)
       : _Accessor{}
   {}
 
+  _CCCL_API constexpr __device_accessor(_Accessor&& __acc) noexcept(
+    ::cuda::std::is_nothrow_move_constructible_v<_Accessor>)
+      : _Accessor{::cuda::std::move(__acc)}
+  {}
+
   _CCCL_API constexpr __device_accessor(const _Accessor& __acc) noexcept(
     ::cuda::std::is_nothrow_copy_constructible_v<_Accessor>)
       : _Accessor{__acc}
@@ -280,34 +310,50 @@ public:
   __device_accessor(const __host_accessor<_OtherAccessor>&) = delete;
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(
-    ::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    ::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
   _CCCL_API constexpr __device_accessor(const __device_accessor<_OtherAccessor>& __acc) noexcept(
-    ::cuda::std::is_nothrow_copy_constructible_v<_Accessor>)
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
       : _Accessor{__acc}
   {}
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(
-    !::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    !::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
   _CCCL_API constexpr explicit __device_accessor(const __device_accessor<_OtherAccessor>& __acc) noexcept(
-    ::cuda::std::is_nothrow_copy_constructible_v<_Accessor>)
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
       : _Accessor{__acc}
   {}
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(
-    ::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
-  _CCCL_API constexpr __device_accessor(const __managed_accessor<_OtherAccessor>& __acc) noexcept(noexcept(_Accessor{
-    ::cuda::std::declval<_OtherAccessor>()}))
-      : _Accessor{__acc}
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, _OtherAccessor> _CCCL_AND(
+    ::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_API constexpr __device_accessor(__device_accessor<_OtherAccessor>&& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, _OtherAccessor>)
+      : _Accessor{::cuda::std::move(__acc)}
   {}
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, _OtherAccessor> _CCCL_AND(
     !::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_API constexpr explicit __device_accessor(__device_accessor<_OtherAccessor>&& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, _OtherAccessor>)
+      : _Accessor{::cuda::std::move(__acc)}
+  {}
+
+  _CCCL_TEMPLATE(typename _OtherAccessor)
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    ::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
+  _CCCL_API constexpr __device_accessor(const __managed_accessor<_OtherAccessor>& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
+      : _Accessor{__acc}
+  {}
+
+  _CCCL_TEMPLATE(typename _OtherAccessor)
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    !::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
   _CCCL_API constexpr explicit __device_accessor(const __managed_accessor<_OtherAccessor>& __acc) noexcept(
-    noexcept(_Accessor{::cuda::std::declval<_OtherAccessor>()}))
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
       : _Accessor{__acc}
   {}
 
@@ -316,7 +362,7 @@ public:
     NV_IF_ELSE_TARGET(
       NV_IS_DEVICE,
       (_CCCL_ASSERT(__is_device_accessible_pointer_from_device(__p), "The pointer is not device accessible");),
-      (_CCCL_ASSERT(false, "cuda::device_accessor cannot be used in HOST code");))
+      (_CCCL_VERIFY(false, "cuda::device_accessor cannot be used in HOST code");))
     return _Accessor::access(__p, __i);
   }
 
@@ -379,12 +425,17 @@ public:
   using reference        = typename _Accessor::reference;
   using element_type     = typename _Accessor::element_type;
 
-  _CCCL_TEMPLATE(typename _NotUsed = void)
-  _CCCL_REQUIRES(::cuda::std::is_default_constructible_v<_Accessor>)
-  _CCCL_API inline __managed_accessor() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Accessor>)
+  _CCCL_TEMPLATE(class _Accessor2 = _Accessor)
+  _CCCL_REQUIRES(::cuda::std::is_default_constructible_v<_Accessor2>)
+  _CCCL_API constexpr __managed_accessor() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Accessor2>)
       : _Accessor{}
   {}
 
+  _CCCL_API constexpr __managed_accessor(_Accessor&& __acc) noexcept(
+    ::cuda::std::is_nothrow_move_constructible_v<_Accessor>)
+      : _Accessor{::cuda::std::move(__acc)}
+  {}
+
   _CCCL_API constexpr __managed_accessor(const _Accessor& __acc) noexcept(
     ::cuda::std::is_nothrow_copy_constructible_v<_Accessor>)
       : _Accessor{__acc}
@@ -397,21 +448,37 @@ public:
   __managed_accessor(const __device_accessor<_OtherAccessor>&) = delete;
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(
-    ::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
-  _CCCL_API constexpr __managed_accessor(const __managed_accessor<_OtherAccessor>& __acc) noexcept(noexcept(_Accessor{
-    ::cuda::std::declval<_OtherAccessor>()}))
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    ::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
+  _CCCL_API constexpr __managed_accessor(const __managed_accessor<_OtherAccessor>& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
       : _Accessor{__acc}
   {}
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(
-    !::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    !::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
   _CCCL_API constexpr explicit __managed_accessor(const __managed_accessor<_OtherAccessor>& __acc) noexcept(
-    noexcept(_Accessor{::cuda::std::declval<_OtherAccessor>()}))
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
       : _Accessor{__acc}
   {}
 
+  _CCCL_TEMPLATE(typename _OtherAccessor)
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, _OtherAccessor> _CCCL_AND(
+    ::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_API constexpr __managed_accessor(__managed_accessor<_OtherAccessor>&& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, _OtherAccessor>)
+      : _Accessor{::cuda::std::move(__acc)}
+  {}
+
+  _CCCL_TEMPLATE(typename _OtherAccessor)
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, _OtherAccessor> _CCCL_AND(
+    !::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_API constexpr explicit __managed_accessor(__managed_accessor<_OtherAccessor>&& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, _OtherAccessor>)
+      : _Accessor{::cuda::std::move(__acc)}
+  {}
+
   _CCCL_API constexpr reference access(data_handle_type __p, size_t __i) const noexcept(__is_access_noexcept)
   {
     NV_IF_TARGET(NV_IS_HOST, (__check_managed_pointer(__p);))

cuda/cccl/headers/include/cuda/__mdspan/host_device_mdspan.h

@@ -22,6 +22,16 @@
 #endif // no system header
 
 #include <cuda/__mdspan/host_device_accessor.h>
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__fwd/array.h>
+#include <cuda/std/__fwd/span.h>
+#include <cuda/std/__type_traits/extent.h>
+#include <cuda/std/__type_traits/is_convertible.h>
+#include <cuda/std/__type_traits/is_pointer.h>
+#include <cuda/std/__type_traits/rank.h>
+#include <cuda/std/__type_traits/remove_all_extents.h>
+#include <cuda/std/__type_traits/remove_pointer.h>
+#include <cuda/std/__type_traits/remove_reference.h>
 #include <cuda/std/mdspan>
 
 #include <cuda/std/__cccl/prologue.h>
@@ -32,19 +42,184 @@ template <typename _ElementType,
           typename _Extents,
           typename _LayoutPolicy   = ::cuda::std::layout_right,
           typename _AccessorPolicy = ::cuda::std::default_accessor<_ElementType>>
-using host_mdspan = ::cuda::std::mdspan<_ElementType, _Extents, _LayoutPolicy, host_accessor<_AccessorPolicy>>;
+class host_mdspan : public ::cuda::std::mdspan<_ElementType, _Extents, _LayoutPolicy, host_accessor<_AccessorPolicy>>
+{
+public:
+  _LIBCUDACXX_DELEGATE_CONSTRUCTORS(
+    host_mdspan, ::cuda::std::mdspan, _ElementType, _Extents, _LayoutPolicy, host_accessor<_AccessorPolicy>);
+
+  _CCCL_API friend constexpr void swap(host_mdspan& __x, host_mdspan& __y) noexcept
+  {
+    swap(static_cast<__base&>(__x), static_cast<__base&>(__y));
+  }
+};
+
+_CCCL_TEMPLATE(class _ElementType, class... _OtherIndexTypes)
+_CCCL_REQUIRES((sizeof...(_OtherIndexTypes) > 0)
+                 _CCCL_AND(::cuda::std::is_convertible_v<_OtherIndexTypes, size_t>&&...))
+_CCCL_HOST_DEVICE explicit host_mdspan(_ElementType*, _OtherIndexTypes...)
+  -> host_mdspan<_ElementType, ::cuda::std::extents<size_t, ::cuda::std::__maybe_static_ext<_OtherIndexTypes>...>>;
+
+_CCCL_TEMPLATE(class _Pointer)
+_CCCL_REQUIRES(::cuda::std::is_pointer_v<::cuda::std::remove_reference_t<_Pointer>>)
+_CCCL_HOST_DEVICE host_mdspan(_Pointer&&)
+  -> host_mdspan<::cuda::std::remove_pointer_t<::cuda::std::remove_reference_t<_Pointer>>, ::cuda::std::extents<size_t>>;
+
+_CCCL_TEMPLATE(class _CArray)
+_CCCL_REQUIRES(::cuda::std::is_array_v<_CArray> _CCCL_AND(::cuda::std::rank_v<_CArray> == 1))
+_CCCL_HOST_DEVICE host_mdspan(_CArray&)
+  -> host_mdspan<::cuda::std::remove_all_extents_t<_CArray>,
+                 ::cuda::std::extents<size_t, ::cuda::std::extent_v<_CArray, 0>>>;
+
+template <class _ElementType, class _OtherIndexType, size_t _Size>
+_CCCL_HOST_DEVICE host_mdspan(_ElementType*, const ::cuda::std::array<_OtherIndexType, _Size>&)
+  -> host_mdspan<_ElementType, ::cuda::std::dextents<size_t, _Size>>;
+
+template <class _ElementType, class _OtherIndexType, size_t _Size>
+_CCCL_HOST_DEVICE host_mdspan(_ElementType*, ::cuda::std::span<_OtherIndexType, _Size>)
+  -> host_mdspan<_ElementType, ::cuda::std::dextents<size_t, _Size>>;
+
+// This one is necessary because all the constructors take `data_handle_type`s, not
+// `_ElementType*`s, and `data_handle_type` is taken from `accessor_type::data_handle_type`, which
+// seems to throw off automatic deduction guides.
+template <class _ElementType, class _OtherIndexType, size_t... _ExtentsPack>
+_CCCL_HOST_DEVICE host_mdspan(_ElementType*, const ::cuda::std::extents<_OtherIndexType, _ExtentsPack...>&)
+  -> host_mdspan<_ElementType, ::cuda::std::extents<_OtherIndexType, _ExtentsPack...>>;
+
+template <class _ElementType, class _MappingType>
+_CCCL_HOST_DEVICE host_mdspan(_ElementType*, const _MappingType&)
+  -> host_mdspan<_ElementType, typename _MappingType::extents_type, typename _MappingType::layout_type>;
+
+template <class _MappingType, class _AccessorType>
+_CCCL_HOST_DEVICE host_mdspan(const typename _AccessorType::data_handle_type, const _MappingType&, const _AccessorType&)
+  -> host_mdspan<typename _AccessorType::element_type,
+                 typename _MappingType::extents_type,
+                 typename _MappingType::layout_type,
+                 _AccessorType>;
 
 template <typename _ElementType,
           typename _Extents,
           typename _LayoutPolicy   = ::cuda::std::layout_right,
           typename _AccessorPolicy = ::cuda::std::default_accessor<_ElementType>>
-using device_mdspan = ::cuda::std::mdspan<_ElementType, _Extents, _LayoutPolicy, device_accessor<_AccessorPolicy>>;
+class device_mdspan
+    : public ::cuda::std::mdspan<_ElementType, _Extents, _LayoutPolicy, device_accessor<_AccessorPolicy>>
+{
+public:
+  _LIBCUDACXX_DELEGATE_CONSTRUCTORS(
+    device_mdspan, ::cuda::std::mdspan, _ElementType, _Extents, _LayoutPolicy, device_accessor<_AccessorPolicy>);
+
+  _CCCL_API friend constexpr void swap(device_mdspan& __x, device_mdspan& __y) noexcept
+  {
+    swap(static_cast<__base&>(__x), static_cast<__base&>(__y));
+  }
+};
+
+_CCCL_TEMPLATE(class _ElementType, class... _OtherIndexTypes)
+_CCCL_REQUIRES((sizeof...(_OtherIndexTypes) > 0)
+                 _CCCL_AND(::cuda::std::is_convertible_v<_OtherIndexTypes, size_t>&&... && true))
+_CCCL_HOST_DEVICE explicit device_mdspan(_ElementType*, _OtherIndexTypes...)
+  -> device_mdspan<_ElementType, ::cuda::std::extents<size_t, ::cuda::std::__maybe_static_ext<_OtherIndexTypes>...>>;
+
+_CCCL_TEMPLATE(class _Pointer)
+_CCCL_REQUIRES(::cuda::std::is_pointer_v<::cuda::std::remove_reference_t<_Pointer>>)
+_CCCL_HOST_DEVICE device_mdspan(_Pointer&&)
+  -> device_mdspan<::cuda::std::remove_pointer_t<::cuda::std::remove_reference_t<_Pointer>>,
+                   ::cuda::std::extents<size_t>>;
+
+_CCCL_TEMPLATE(class _CArray)
+_CCCL_REQUIRES(::cuda::std::is_array_v<_CArray> _CCCL_AND(::cuda::std::rank_v<_CArray> == 1))
+_CCCL_HOST_DEVICE device_mdspan(_CArray&)
+  -> device_mdspan<::cuda::std::remove_all_extents_t<_CArray>,
+                   ::cuda::std::extents<size_t, ::cuda::std::extent_v<_CArray, 0>>>;
+
+template <class _ElementType, class _OtherIndexType, size_t _Size>
+_CCCL_HOST_DEVICE device_mdspan(_ElementType*, const ::cuda::std::array<_OtherIndexType, _Size>&)
+  -> device_mdspan<_ElementType, ::cuda::std::dextents<size_t, _Size>>;
+
+template <class _ElementType, class _OtherIndexType, size_t _Size>
+_CCCL_HOST_DEVICE device_mdspan(_ElementType*, ::cuda::std::span<_OtherIndexType, _Size>)
+  -> device_mdspan<_ElementType, ::cuda::std::dextents<size_t, _Size>>;
+
+// This one is necessary because all the constructors take `data_handle_type`s, not
+// `_ElementType*`s, and `data_handle_type` is taken from `accessor_type::data_handle_type`, which
+// seems to throw off automatic deduction guides.
+template <class _ElementType, class _OtherIndexType, size_t... _ExtentsPack>
+_CCCL_HOST_DEVICE device_mdspan(_ElementType*, const ::cuda::std::extents<_OtherIndexType, _ExtentsPack...>&)
+  -> device_mdspan<_ElementType, ::cuda::std::extents<_OtherIndexType, _ExtentsPack...>>;
+
+template <class _ElementType, class _MappingType>
+_CCCL_HOST_DEVICE device_mdspan(_ElementType*, const _MappingType&)
+  -> device_mdspan<_ElementType, typename _MappingType::extents_type, typename _MappingType::layout_type>;
+
+template <class _MappingType, class _AccessorType>
+_CCCL_HOST_DEVICE
+device_mdspan(const typename _AccessorType::data_handle_type, const _MappingType&, const _AccessorType&)
+  -> device_mdspan<typename _AccessorType::element_type,
+                   typename _MappingType::extents_type,
+                   typename _MappingType::layout_type,
+                   _AccessorType>;
 
 template <typename _ElementType,
           typename _Extents,
           typename _LayoutPolicy   = ::cuda::std::layout_right,
           typename _AccessorPolicy = ::cuda::std::default_accessor<_ElementType>>
-using managed_mdspan = ::cuda::std::mdspan<_ElementType, _Extents, _LayoutPolicy, managed_accessor<_AccessorPolicy>>;
+class managed_mdspan
+    : public ::cuda::std::mdspan<_ElementType, _Extents, _LayoutPolicy, managed_accessor<_AccessorPolicy>>
+{
+public:
+  _LIBCUDACXX_DELEGATE_CONSTRUCTORS(
+    managed_mdspan, ::cuda::std::mdspan, _ElementType, _Extents, _LayoutPolicy, managed_accessor<_AccessorPolicy>);
+
+  _CCCL_API friend constexpr void swap(managed_mdspan& __x, managed_mdspan& __y) noexcept
+  {
+    swap(static_cast<__base&>(__x), static_cast<__base&>(__y));
+  }
+};
+
+_CCCL_TEMPLATE(class _ElementType, class... _OtherIndexTypes)
+_CCCL_REQUIRES((sizeof...(_OtherIndexTypes) > 0)
+                 _CCCL_AND(::cuda::std::is_convertible_v<_OtherIndexTypes, size_t>&&... && true))
+_CCCL_HOST_DEVICE explicit managed_mdspan(_ElementType*, _OtherIndexTypes...)
+  -> managed_mdspan<_ElementType, ::cuda::std::extents<size_t, ::cuda::std::__maybe_static_ext<_OtherIndexTypes>...>>;
+
+_CCCL_TEMPLATE(class _Pointer)
+_CCCL_REQUIRES(::cuda::std::is_pointer_v<::cuda::std::remove_reference_t<_Pointer>>)
+_CCCL_HOST_DEVICE managed_mdspan(_Pointer&&)
+  -> managed_mdspan<::cuda::std::remove_pointer_t<::cuda::std::remove_reference_t<_Pointer>>,
+                    ::cuda::std::extents<size_t>>;
+
+_CCCL_TEMPLATE(class _CArray)
+_CCCL_REQUIRES(::cuda::std::is_array_v<_CArray> _CCCL_AND(::cuda::std::rank_v<_CArray> == 1))
+_CCCL_HOST_DEVICE managed_mdspan(_CArray&)
+  -> managed_mdspan<::cuda::std::remove_all_extents_t<_CArray>,
+                    ::cuda::std::extents<size_t, ::cuda::std::extent_v<_CArray, 0>>>;
+
+template <class _ElementType, class _OtherIndexType, size_t _Size>
+_CCCL_HOST_DEVICE managed_mdspan(_ElementType*, const ::cuda::std::array<_OtherIndexType, _Size>&)
+  -> managed_mdspan<_ElementType, ::cuda::std::dextents<size_t, _Size>>;
+
+template <class _ElementType, class _OtherIndexType, size_t _Size>
+_CCCL_HOST_DEVICE managed_mdspan(_ElementType*, ::cuda::std::span<_OtherIndexType, _Size>)
+  -> managed_mdspan<_ElementType, ::cuda::std::dextents<size_t, _Size>>;
+
+// This one is necessary because all the constructors take `data_handle_type`s, not
+// `_ElementType*`s, and `data_handle_type` is taken from `accessor_type::data_handle_type`, which
+// seems to throw off automatic deduction guides.
+template <class _ElementType, class _OtherIndexType, size_t... _ExtentsPack>
+_CCCL_HOST_DEVICE managed_mdspan(_ElementType*, const ::cuda::std::extents<_OtherIndexType, _ExtentsPack...>&)
+  -> managed_mdspan<_ElementType, ::cuda::std::extents<_OtherIndexType, _ExtentsPack...>>;
+
+template <class _ElementType, class _MappingType>
+_CCCL_HOST_DEVICE managed_mdspan(_ElementType*, const _MappingType&)
+  -> managed_mdspan<_ElementType, typename _MappingType::extents_type, typename _MappingType::layout_type>;
+
+template <class _MappingType, class _AccessorType>
+_CCCL_HOST_DEVICE
+managed_mdspan(const typename _AccessorType::data_handle_type, const _MappingType&, const _AccessorType&)
+  -> managed_mdspan<typename _AccessorType::element_type,
+                    typename _MappingType::extents_type,
+                    typename _MappingType::layout_type,
+                    _AccessorType>;
 
 /***********************************************************************************************************************
  * Accessibility Traits

cuda/cccl/headers/include/cuda/__mdspan/restrict_accessor.h

@@ -22,13 +22,17 @@
 #endif // no system header
 
 #include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__type_traits/is_constructible.h>
 #include <cuda/std/__type_traits/is_convertible.h>
 #include <cuda/std/__type_traits/is_default_constructible.h>
+#include <cuda/std/__type_traits/is_nothrow_constructible.h>
 #include <cuda/std/__type_traits/is_nothrow_copy_constructible.h>
 #include <cuda/std/__type_traits/is_nothrow_default_constructible.h>
+#include <cuda/std/__type_traits/is_nothrow_move_constructible.h>
 #include <cuda/std/__type_traits/is_pointer.h>
 #include <cuda/std/__type_traits/remove_pointer.h>
 #include <cuda/std/__utility/declval.h>
+#include <cuda/std/__utility/move.h>
 #include <cuda/std/cstddef>
 
 #include <cuda/std/__cccl/prologue.h>
@@ -55,6 +59,9 @@ inline constexpr bool is_restrict_accessor_v<__restrict_accessor<_Accessor>> = t
  * Restrict Accessor
  **********************************************************************************************************************/
 
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_GCC("-Wignored-qualifiers")
+
 template <typename _Accessor>
 class __restrict_accessor : public _Accessor
 {
@@ -77,7 +84,7 @@ public:
 
   _CCCL_TEMPLATE(class _Accessor2 = _Accessor)
   _CCCL_REQUIRES(::cuda::std::is_default_constructible_v<_Accessor2>)
-  _CCCL_API inline __restrict_accessor() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Accessor2>)
+  _CCCL_API constexpr __restrict_accessor() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Accessor2>)
       : _Accessor{}
   {}
 
@@ -86,22 +93,43 @@ public:
       : _Accessor{__acc}
   {}
 
+  _CCCL_API constexpr __restrict_accessor(_Accessor&& __acc) noexcept(
+    ::cuda::std::is_nothrow_move_constructible_v<_Accessor>)
+      : _Accessor{::cuda::std::move(__acc)}
+  {}
+
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(
-    ::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
-  _CCCL_API constexpr __restrict_accessor(const __restrict_accessor<_OtherAccessor>& __acc) noexcept(noexcept(_Accessor{
-    ::cuda::std::declval<_OtherAccessor>()}))
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    ::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
+  _CCCL_API constexpr __restrict_accessor(const __restrict_accessor<_OtherAccessor>& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
       : _Accessor{__acc}
   {}
 
   _CCCL_TEMPLATE(typename _OtherAccessor)
-  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_OtherAccessor> _CCCL_AND(
-    !::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, const _OtherAccessor&> _CCCL_AND(
+    !::cuda::std::is_convertible_v<const _OtherAccessor&, _Accessor>))
   _CCCL_API constexpr explicit __restrict_accessor(const __restrict_accessor<_OtherAccessor>& __acc) noexcept(
-    noexcept(_Accessor{::cuda::std::declval<_OtherAccessor>()}))
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, const _OtherAccessor&>)
       : _Accessor{__acc}
   {}
 
+  _CCCL_TEMPLATE(typename _OtherAccessor)
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, _OtherAccessor> _CCCL_AND(
+    ::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_API constexpr __restrict_accessor(__restrict_accessor<_OtherAccessor>&& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, _OtherAccessor>)
+      : _Accessor{::cuda::std::move(__acc)}
+  {}
+
+  _CCCL_TEMPLATE(typename _OtherAccessor)
+  _CCCL_REQUIRES(::cuda::std::is_constructible_v<_Accessor, _OtherAccessor> _CCCL_AND(
+    !::cuda::std::is_convertible_v<_OtherAccessor, _Accessor>))
+  _CCCL_API constexpr explicit __restrict_accessor(__restrict_accessor<_OtherAccessor>&& __acc) noexcept(
+    ::cuda::std::is_nothrow_constructible_v<_Accessor, _OtherAccessor>)
+      : _Accessor{::cuda::std::move(__acc)}
+  {}
+
   _CCCL_API constexpr reference access(__element_type* _CCCL_RESTRICT __p, size_t __i) const
     noexcept(__is_access_noexcept)
   {
@@ -115,6 +143,8 @@ public:
   }
 };
 
+_CCCL_DIAG_POP
+
 _CCCL_END_NAMESPACE_CUDA
 
 #include <cuda/std/__cccl/epilogue.h>