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/__execution/determinism.h

@@ -32,7 +32,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_EXECUTION
 
 namespace determinism
 {
-
 struct __get_determinism_t;
 
 enum class __determinism_t
@@ -81,7 +80,6 @@ struct __get_determinism_t
 };
 
 _CCCL_GLOBAL_CONSTANT auto __get_determinism = __get_determinism_t{};
-
 } // namespace determinism
 
 _CCCL_END_NAMESPACE_CUDA_EXECUTION

cuda/cccl/headers/include/cuda/__execution/output_ordering.h

@@ -33,7 +33,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_EXECUTION
 
 namespace output_ordering
 {
-
 struct __get_output_ordering_t;
 
 enum class __output_ordering_t
@@ -79,7 +78,6 @@ struct __get_output_ordering_t
 };
 
 _CCCL_GLOBAL_CONSTANT auto __get_output_ordering = __get_output_ordering_t{};
-
 } // namespace output_ordering
 
 _CCCL_END_NAMESPACE_CUDA_EXECUTION

cuda/cccl/headers/include/cuda/__functional/maximum.h

@@ -4,7 +4,7 @@
 // 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.
 //
 //===----------------------------------------------------------------------===//
 
@@ -21,7 +21,11 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/__functional/minimum_maximum_common.h>
+#include <cuda/std/__cmath/min_max.h>
 #include <cuda/std/__type_traits/common_type.h>
+#include <cuda/std/__type_traits/is_extended_floating_point.h>
+#include <cuda/std/__type_traits/is_floating_point.h>
 
 #include <cuda/std/__cccl/prologue.h>
 
@@ -32,9 +36,16 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT maximum
 {
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API constexpr _Tp operator()(const _Tp& __lhs, const _Tp& __rhs) const
-    noexcept(noexcept((__lhs < __rhs) ? __rhs : __lhs))
+    noexcept(__is_maximum_minimum_noexcept_v<_Tp, _Tp, _Tp>)
   {
-    return (__lhs < __rhs) ? __rhs : __lhs;
+    if constexpr (::cuda::std::is_floating_point_v<_Tp> || ::cuda::std::__is_extended_floating_point_v<_Tp>)
+    {
+      return ::cuda::std::fmax(__lhs, __rhs);
+    }
+    else
+    {
+      return (__lhs < __rhs) ? __rhs : __lhs;
+    }
   }
 };
 _LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(maximum);
@@ -43,11 +54,18 @@ template <>
 struct _CCCL_TYPE_VISIBILITY_DEFAULT maximum<void>
 {
   _CCCL_EXEC_CHECK_DISABLE
-  template <class _T1, class _T2>
-  [[nodiscard]] _CCCL_API constexpr ::cuda::std::common_type_t<_T1, _T2>
-  operator()(const _T1& __lhs, const _T2& __rhs) const noexcept(noexcept((__lhs < __rhs) ? __rhs : __lhs))
+  template <class Tp, class Up, class _Common = ::cuda::std::common_type_t<Tp, Up>>
+  [[nodiscard]] _CCCL_API constexpr _Common operator()(const Tp& __lhs, const Up& __rhs) const
+    noexcept(__is_maximum_minimum_noexcept_v<Tp, Up, _Common>)
   {
-    return (__lhs < __rhs) ? __rhs : __lhs;
+    if constexpr (::cuda::std::is_floating_point_v<_Common> || ::cuda::std::__is_extended_floating_point_v<_Common>)
+    {
+      return ::cuda::std::fmax(static_cast<_Common>(__lhs), static_cast<_Common>(__rhs));
+    }
+    else
+    {
+      return (__lhs < __rhs) ? __rhs : __lhs;
+    }
   }
 };
 

cuda/cccl/headers/include/cuda/__functional/minimum.h

@@ -4,7 +4,7 @@
 // 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.
 //
 //===----------------------------------------------------------------------===//
 
@@ -21,7 +21,11 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/__functional/minimum_maximum_common.h>
+#include <cuda/std/__cmath/min_max.h>
 #include <cuda/std/__type_traits/common_type.h>
+#include <cuda/std/__type_traits/is_extended_floating_point.h>
+#include <cuda/std/__type_traits/is_floating_point.h>
 
 #include <cuda/std/__cccl/prologue.h>
 
@@ -32,9 +36,16 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT minimum
 {
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API constexpr _Tp operator()(const _Tp& __lhs, const _Tp& __rhs) const
-    noexcept(noexcept((__lhs < __rhs) ? __lhs : __rhs))
+    noexcept(__is_maximum_minimum_noexcept_v<_Tp, _Tp, _Tp>)
   {
-    return (__lhs < __rhs) ? __lhs : __rhs;
+    if constexpr (::cuda::std::is_floating_point_v<_Tp> || ::cuda::std::__is_extended_floating_point_v<_Tp>)
+    {
+      return ::cuda::std::fmin(__lhs, __rhs);
+    }
+    else
+    {
+      return (__lhs < __rhs) ? __lhs : __rhs;
+    }
   }
 };
 _LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(minimum);
@@ -43,11 +54,18 @@ template <>
 struct _CCCL_TYPE_VISIBILITY_DEFAULT minimum<void>
 {
   _CCCL_EXEC_CHECK_DISABLE
-  template <class _T1, class _T2>
-  [[nodiscard]] _CCCL_API constexpr ::cuda::std::common_type_t<_T1, _T2>
-  operator()(const _T1& __lhs, const _T2& __rhs) const noexcept(noexcept((__lhs < __rhs) ? __lhs : __rhs))
+  template <class _Tp, class _Up, class _Common = ::cuda::std::common_type_t<_Tp, _Up>>
+  [[nodiscard]] _CCCL_API constexpr _Common operator()(const _Tp& __lhs, const _Up& __rhs) const
+    noexcept(__is_maximum_minimum_noexcept_v<_Tp, _Up, _Common>)
   {
-    return (__lhs < __rhs) ? __lhs : __rhs;
+    if constexpr (::cuda::std::is_floating_point_v<_Common> || ::cuda::std::__is_extended_floating_point_v<_Common>)
+    {
+      return ::cuda::std::fmin(static_cast<_Common>(__lhs), static_cast<_Common>(__rhs));
+    }
+    else
+    {
+      return (__lhs < __rhs) ? __lhs : __rhs;
+    }
   }
 };
 

cuda/cccl/headers/include/cuda/__functional/minimum_maximum_common.h

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_FUNCTIONAL_MINIMUM_MAXIMUM_COMMON_H
+#define _CUDA_FUNCTIONAL_MINIMUM_MAXIMUM_COMMON_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/__floating_point/traits.h>
+#include <cuda/std/__type_traits/common_type.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/is_nothrow_convertible.h>
+#include <cuda/std/__utility/declval.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+template <typename _Tp, typename _Up, typename _Common = ::cuda::std::common_type_t<_Tp, _Up>, typename _Enable = void>
+constexpr bool __is_maximum_minimum_noexcept_v =
+  noexcept(::cuda::std::declval<_Tp>() < ::cuda::std::declval<_Up>())
+  && ::cuda::std::is_nothrow_convertible_v<_Tp, _Common> && ::cuda::std::is_nothrow_convertible_v<_Up, _Common>;
+
+// Extended floating point types, such as __half and __nv bfloat16 cannot be compared with operator<. We need to
+// handle them separately with SFINAE.
+template <typename _Tp, typename _Up, typename _Common>
+constexpr bool __is_maximum_minimum_noexcept_v<
+  _Tp,
+  _Up,
+  _Common,
+  ::cuda::std::enable_if_t<::cuda::std::__is_ext_nv_fp_v<_Tp> || ::cuda::std::__is_ext_nv_fp_v<_Up>>> = false;
+
+_CCCL_END_NAMESPACE_CUDA
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_FUNCTIONAL_MINIMUM_MAXIMUM_COMMON_H

cuda/cccl/headers/include/cuda/__functional/proclaim_return_type.h

@@ -33,7 +33,6 @@
 _CCCL_BEGIN_NAMESPACE_CUDA
 namespace __detail
 {
-
 template <class _Ret, class _DecayFn>
 class __return_type_wrapper
 {
@@ -92,7 +91,6 @@ public:
     return ::cuda::std::__invoke(::cuda::std::move(__fn_), ::cuda::std::forward<_As>(__as)...);
   }
 };
-
 } // namespace __detail
 
 template <class _Ret, class _Fn>

cuda/cccl/headers/include/cuda/__iterator/counting_iterator.h

@@ -41,6 +41,7 @@
 #include <cuda/std/__ranges/enable_borrowed_range.h>
 #include <cuda/std/__ranges/movable_box.h>
 #include <cuda/std/__ranges/view_interface.h>
+#include <cuda/std/__type_traits/always_false.h>
 #include <cuda/std/__type_traits/conditional.h>
 #include <cuda/std/__type_traits/enable_if.h>
 #include <cuda/std/__type_traits/is_constructible.h>
@@ -79,13 +80,21 @@ struct __get_wider_signed
     {
       return ::cuda::std::type_identity<long>{};
     }
-    else
+#if _CCCL_HAS_INT128()
+    else if constexpr (sizeof(_Int) < sizeof(long long))
     {
       return ::cuda::std::type_identity<long long>{};
     }
-
-    static_assert(sizeof(_Int) <= sizeof(long long),
-                  "Found integer-like type that is bigger than largest integer like type.");
+    else // if constexpr (sizeof(_Int) < sizeof(__int128_t))
+    {
+      return ::cuda::std::type_identity<__int128_t>{};
+    }
+#else // ^^^ _CCCL_HAS_INT128() ^^^ / vvv !_CCCL_HAS_INT128() vvv
+    else // if constexpr (sizeof(_Int) < sizeof(long long))
+    {
+      return ::cuda::std::type_identity<long long>{};
+    }
+#endif // _CCCL_HAS_INT128()
     _CCCL_UNREACHABLE();
   }
 

cuda/cccl/headers/include/cuda/__iterator/zip_function.h

@@ -76,7 +76,8 @@ public:
   //! @brief Applies a tuple to the stored functor
   //! @param __tuple The tuple of arguments to be passed
   _CCCL_EXEC_CHECK_DISABLE
-  template <class _Tuple>
+  _CCCL_TEMPLATE(class _Tuple)
+  _CCCL_REQUIRES(::cuda::std::__can_apply<const _Fn&, _Tuple>)
   [[nodiscard]] _CCCL_API constexpr decltype(auto) operator()(_Tuple&& __tuple) const
     noexcept(__is_nothrow_invocable<const _Fn&, _Tuple>)
   {
@@ -85,7 +86,8 @@ public:
 
   //! @brief Applies a tuple to the stored functor
   _CCCL_EXEC_CHECK_DISABLE
-  template <class _Tuple>
+  _CCCL_TEMPLATE(class _Tuple)
+  _CCCL_REQUIRES(::cuda::std::__can_apply<_Fn&, _Tuple>)
   [[nodiscard]] _CCCL_API constexpr decltype(auto)
   operator()(_Tuple&& __tuple) noexcept(__is_nothrow_invocable<_Fn&, _Tuple>)
   {

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

@@ -24,7 +24,6 @@
 #include <cuda/__driver/driver_api.h>
 #include <cuda/__memory/address_space.h>
 #include <cuda/std/__concepts/concept_macros.h>
-#include <cuda/std/__cuda/api_wrapper.h>
 #include <cuda/std/__iterator/concepts.h>
 #include <cuda/std/__memory/pointer_traits.h>
 #include <cuda/std/__type_traits/always_false.h>

cuda/cccl/headers/include/cuda/__memcpy_async/cp_async_bulk_shared_global.h

@@ -26,8 +26,11 @@
 #  if __cccl_ptx_isa >= 800
 
 #    include <cuda/__ptx/instructions/cp_async_bulk.h>
+#    include <cuda/__ptx/instructions/elect_sync.h>
+#    include <cuda/__ptx/instructions/mbarrier_expect_tx.h>
 #    include <cuda/__ptx/ptx_dot_variants.h>
 #    include <cuda/__ptx/ptx_helper_functions.h>
+#    include <cuda/std/__type_traits/conditional.h>
 #    include <cuda/std/cstdint>
 
 #    include <nv/target>
@@ -36,18 +39,36 @@
 
 _CCCL_BEGIN_NAMESPACE_CUDA
 
+template <typename _Group>
+[[nodiscard]] _CCCL_DEVICE _CCCL_FORCEINLINE bool __elect_from_group(const _Group& __g) noexcept
+{
+  // cooperative groups maps a multidimensional thread id into the thread rank the same way as warps do
+  const unsigned int tid             = __g.thread_rank();
+  const unsigned int warp_id         = tid / 32;
+  const unsigned int uniform_warp_id = __shfl_sync(0xFFFFFFFF, warp_id, 0); // broadcast from lane 0
+  return uniform_warp_id == 0 && ::cuda::ptx::elect_sync(0xFFFFFFFF); // elect a leader thread among warp 0
+}
+
 extern "C" _CCCL_DEVICE void __cuda_ptx_cp_async_bulk_shared_global_is_not_supported_before_SM_90__();
 template <typename _Group>
-inline _CCCL_DEVICE void __cp_async_bulk_shared_global(
+inline _CCCL_DEVICE void __cp_async_bulk_shared_global_and_expect_tx(
   const _Group& __g, char* __dest, const char* __src, ::cuda::std::size_t __size, ::cuda::std::uint64_t* __bar_handle)
 {
   // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-bulk
-  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,
-                    (if (__g.thread_rank() == 0) {
-                      ::cuda::ptx::cp_async_bulk(
-                        ::cuda::ptx::space_cluster, ::cuda::ptx::space_global, __dest, __src, __size, __bar_handle);
-                    }),
-                    (::cuda::__cuda_ptx_cp_async_bulk_shared_global_is_not_supported_before_SM_90__();));
+  NV_IF_ELSE_TARGET(
+    NV_PROVIDES_SM_90,
+    (if (__elect_from_group(__g)) {
+      ::cuda::ptx::cp_async_bulk(
+        ::cuda::std::conditional_t<__cccl_ptx_isa >= 860, ::cuda::ptx::space_shared_t, ::cuda::ptx::space_cluster_t>{},
+        ::cuda::ptx::space_global,
+        __dest,
+        __src,
+        __size,
+        __bar_handle);
+      ::cuda::ptx::mbarrier_expect_tx(
+        ::cuda::ptx::sem_relaxed, ::cuda::ptx::scope_cta, ::cuda::ptx::space_shared, __bar_handle, __size);
+    }),
+    (::cuda::__cuda_ptx_cp_async_bulk_shared_global_is_not_supported_before_SM_90__();));
 }
 
 _CCCL_END_NAMESPACE_CUDA

cuda/cccl/headers/include/cuda/__memcpy_async/dispatch_memcpy_async.h

@@ -82,7 +82,7 @@ template <::cuda::std::size_t _Align, typename _Group>
        if (__can_use_complete_tx
            && ::cuda::device::is_address_from(__bar_handle, ::cuda::device::address_space::shared))
        {
-         ::cuda::__cp_async_bulk_shared_global(__group, __dest_char, __src_char, __size, __bar_handle);
+         ::cuda::__cp_async_bulk_shared_global_and_expect_tx(__group, __dest_char, __src_char, __size, __bar_handle);
          return __completion_mechanism::__mbarrier_complete_tx;
        }
      }

cuda/cccl/headers/include/cuda/__memcpy_async/elect_one.h

@@ -0,0 +1,52 @@
+// -*- 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) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___MEMCPY_ASYNC_ELECT_ONE_H_
+#define _CUDA___MEMCPY_ASYNC_ELECT_ONE_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/__ptx/instructions/elect_sync.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_DEVICE
+
+//! Elects a single leader thread from a one dimensional thread block. For SM90+ will use ptx::elect_sync() etc.,
+//! otherwise just selects the thread with ID 0. If the returned value is used as condition for an if statement, the
+//! compiler will emit a uniform data path for the branch.
+[[nodiscard]] _CCCL_DEVICE_API _CCCL_FORCEINLINE bool __block_elect_one() noexcept
+{
+  _CCCL_ASSERT(blockDim.y == 1 && blockDim.z == 1, "The block must by one dimensional");
+
+  NV_IF_ELSE_TARGET(
+    NV_PROVIDES_SM_90,
+    (const auto tid             = threadIdx.x; //
+     const auto warp_id         = tid / 32;
+     const auto uniform_warp_id = __shfl_sync(~0, warp_id, 0); // broadcast from lane 0
+     return uniform_warp_id == 0 && cuda::ptx::elect_sync(~0); // elect a leader thread among warp 0
+     ),
+    (return threadIdx.x == 0;));
+}
+
+_CCCL_END_NAMESPACE_CUDA_DEVICE
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA___MEMCPY_ASYNC_ELECT_ONE_H_

cuda/cccl/headers/include/cuda/__memcpy_async/memcpy_async_tx.h

@@ -27,7 +27,6 @@
 
 #    include <cuda/__barrier/async_contract_fulfillment.h>
 #    include <cuda/__barrier/barrier_block_scope.h>
-#    include <cuda/__barrier/barrier_native_handle.h>
 #    include <cuda/__memcpy_async/check_preconditions.h>
 #    include <cuda/__memory/address_space.h>
 #    include <cuda/__memory/aligned_size.h>
@@ -35,6 +34,7 @@
 #    include <cuda/__ptx/ptx_dot_variants.h>
 #    include <cuda/__ptx/ptx_helper_functions.h>
 #    include <cuda/std/__atomic/scopes.h>
+#    include <cuda/std/__type_traits/conditional.h>
 #    include <cuda/std/__type_traits/is_trivially_copyable.h>
 #    include <cuda/std/cstdint>
 
@@ -76,7 +76,7 @@ _CCCL_DEVICE inline async_contract_fulfillment memcpy_async_tx(
       if (::cuda::device::is_address_from(__dest, ::cuda::device::address_space::shared)
           && ::cuda::device::is_address_from(__src, ::cuda::device::address_space::global)) {
         ::cuda::ptx::cp_async_bulk(
-          ::cuda::ptx::space_cluster,
+          ::cuda::std::conditional_t<__cccl_ptx_isa >= 860, ::cuda::ptx::space_shared_t, ::cuda::ptx::space_cluster_t>{},
           ::cuda::ptx::space_global,
           __dest,
           __src,
@@ -85,7 +85,6 @@ _CCCL_DEVICE inline async_contract_fulfillment memcpy_async_tx(
       } else {
         // memcpy_async_tx only supports copying from global to shared
         // or from shared to remote cluster dsmem. To copy to remote
-        // dsmem, we need to arrive on a cluster-scoped barrier, which
         // is not yet implemented. So we trap in this case as well.
         _CCCL_UNREACHABLE();
       }),

cuda/cccl/headers/include/cuda/__memcpy_async/memcpy_completion.h

@@ -87,13 +87,7 @@ struct __memcpy_completion_impl
         // bulk group to be used with shared memory barriers.
         _CCCL_UNREACHABLE();
       case __completion_mechanism::__mbarrier_complete_tx:
-#if __cccl_ptx_isa >= 800
-        // Pre-sm90, the mbarrier_complete_tx completion mechanism is not available.
-        NV_IF_TARGET(NV_PROVIDES_SM_90,
-                     (
-                       // Only perform the expect_tx operation with the leader thread
-                       if (__group.thread_rank() == 0) { ::cuda::device::barrier_expect_tx(__barrier, __size); }));
-#endif // __cccl_ptx_isa >= 800
+        // we already updated the mbarrier's tx count when we issued the bulk copy
         return async_contract_fulfillment::async;
       case __completion_mechanism::__sync:
         // sync: In this case, we do not need to do anything. The user will have

cuda/cccl/headers/include/cuda/__memcpy_async/try_get_barrier_handle.h

@@ -22,7 +22,6 @@
 #endif // no system header
 
 #include <cuda/__barrier/barrier_block_scope.h>
-#include <cuda/__barrier/barrier_native_handle.h>
 #include <cuda/std/__atomic/scopes.h>
 #include <cuda/std/__barrier/barrier.h>
 #include <cuda/std/__barrier/empty_completion.h>

cuda/cccl/headers/include/cuda/__memory/get_device_address.h

@@ -23,7 +23,7 @@
 
 #if _CCCL_HAS_CTK()
 
-#  include <cuda/std/__cuda/api_wrapper.h>
+#  include <cuda/__runtime/api_wrapper.h>
 #  include <cuda/std/__memory/addressof.h>
 
 #  include <nv/target>

cuda/cccl/headers/include/cuda/__memory/ranges_overlap.h

@@ -0,0 +1,126 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___MEMORY_RANGES_OVERLAP_H
+#define _CUDA___MEMORY_RANGES_OVERLAP_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__iterator/concepts.h>
+#include <cuda/std/__memory/pointer_traits.h>
+#include <cuda/std/__type_traits/is_constant_evaluated.h>
+#include <cuda/std/cstdint>
+
+#include <cuda/std/__cccl/prologue.h>
+
+#if _CCCL_HOST_COMPILATION()
+#  include <functional>
+#endif // _CCCL_HOST_COMPILATION()
+
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+#if _CCCL_DEVICE_COMPILATION()
+
+[[nodiscard]]
+_CCCL_DEVICE_API inline bool __ptr_ranges_overlap_device(
+  const void* __lhs_begin, const void* __lhs_end, const void* __rhs_begin, const void* __rhs_end) noexcept
+{
+  using uintptr_t            = ::cuda::std::uintptr_t;
+  const auto __lhs_start_ptr = reinterpret_cast<uintptr_t>(__lhs_begin);
+  const auto __lhs_end_ptr   = reinterpret_cast<uintptr_t>(__lhs_end);
+  const auto __rhs_start_ptr = reinterpret_cast<uintptr_t>(__rhs_begin);
+  const auto __rhs_end_ptr   = reinterpret_cast<uintptr_t>(__rhs_end);
+  _CCCL_ASSERT(__lhs_start_ptr <= __lhs_end_ptr, "lhs range is invalid");
+  _CCCL_ASSERT(__rhs_start_ptr <= __rhs_end_ptr, "rhs range is invalid");
+  return __lhs_start_ptr < __rhs_end_ptr && __rhs_start_ptr < __lhs_end_ptr;
+}
+
+#else // ^^^^ _CCCL_DEVICE_COMPILATION() ^^^^ / vvvv _CCCL_HOST_COMPILATION() vvvv
+
+template <typename _Tp>
+[[nodiscard]]
+_CCCL_HOST_API bool
+__ptr_ranges_overlap_host(_Tp* __lhs_begin, _Tp* __lhs_end, _Tp* __rhs_begin, _Tp* __rhs_end) noexcept
+{
+  _CCCL_ASSERT(::std::less_equal<>{}(__lhs_begin, __lhs_end), "lhs range is invalid");
+  _CCCL_ASSERT(::std::less_equal<>{}(__rhs_begin, __rhs_end), "rhs range is invalid");
+  return ::std::less<>{}(__lhs_begin, __rhs_end) && ::std::less<>{}(__rhs_begin, __lhs_end);
+}
+
+#endif // ^^^^ _CCCL_HOST_COMPILATION() ^^^^
+
+_CCCL_TEMPLATE(typename _Tp)
+_CCCL_REQUIRES(::cuda::std::forward_iterator<_Tp>)
+[[nodiscard]] _CCCL_API constexpr bool
+ranges_overlap(_Tp __lhs_begin, _Tp __lhs_end, _Tp __rhs_begin, _Tp __rhs_end) noexcept
+{
+  if constexpr (::cuda::std::contiguous_iterator<_Tp>)
+  {
+    if (::cuda::std::__cccl_default_is_constant_evaluated())
+    {
+      // UB is not possible in a constant expression
+      _CCCL_ASSERT(__lhs_begin <= __lhs_end, "lhs range is invalid");
+      _CCCL_ASSERT(__rhs_begin <= __rhs_end, "rhs range is invalid");
+      return __lhs_begin < __rhs_end && __rhs_begin < __lhs_end;
+    }
+    else
+    {
+      const auto __ptr_lhs_begin = ::cuda::std::to_address(__lhs_begin);
+      const auto __ptr_lhs_end   = ::cuda::std::to_address(__lhs_end);
+      const auto __ptr_rhs_begin = ::cuda::std::to_address(__rhs_begin);
+      const auto __ptr_rhs_end   = ::cuda::std::to_address(__rhs_end);
+      NV_IF_ELSE_TARGET(
+        NV_IS_HOST,
+        (return ::cuda::__ptr_ranges_overlap_host(__ptr_lhs_begin, __ptr_lhs_end, __ptr_rhs_begin, __ptr_rhs_end);),
+        (return ::cuda::__ptr_ranges_overlap_device(__ptr_lhs_begin, __ptr_lhs_end, __ptr_rhs_begin, __ptr_rhs_end);));
+    }
+  }
+  else if constexpr (::cuda::std::random_access_iterator<_Tp>)
+  {
+    _CCCL_ASSERT(__lhs_begin <= __lhs_end, "lhs range is invalid");
+    _CCCL_ASSERT(__rhs_begin <= __rhs_end, "rhs range is invalid");
+    return __lhs_begin < __rhs_end && __rhs_begin < __lhs_end;
+  }
+  else
+  {
+    // For forward iterators: if two ranges [A,B) and [C,D) overlap from the same sequence,
+    // then either C is in [A,B) or A is in [C,D). We check both conditions.
+    for (auto __lhs_it = __lhs_begin; __lhs_it != __lhs_end; ++__lhs_it)
+    {
+      if (__lhs_it == __rhs_begin)
+      {
+        return true;
+      }
+    }
+    for (auto __rhs_it = __rhs_begin; __rhs_it != __rhs_end; ++__rhs_it)
+    {
+      if (__rhs_it == __lhs_begin)
+      {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+_CCCL_END_NAMESPACE_CUDA
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA___MEMORY_RANGES_OVERLAP_H