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/__memory_resource/pinned_memory_pool.h

@@ -0,0 +1,188 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// 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_RESOURCE_PINNED_MEMORY_POOL_H
+#define _CUDA___MEMORY_RESOURCE_PINNED_MEMORY_POOL_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
+
+#if _CCCL_CUDA_COMPILER(CLANG)
+#  include <cuda_runtime.h>
+#  include <cuda_runtime_api.h>
+#endif // _CCCL_CUDA_COMPILER(CLANG)
+
+#include <cuda/__device/all_devices.h>
+#include <cuda/__memory_resource/memory_resource_base.h>
+#include <cuda/__memory_resource/properties.h>
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__exception/throw_error.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+//! @file
+//! The \c pinned_memory_resource class provides a memory resource that allocates pinned memory.
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+#if _CCCL_CTK_AT_LEAST(12, 6)
+
+static ::cudaMemPool_t __get_default_host_pinned_pool();
+
+//! @rst
+//! .. _cudax-memory-resource-async:
+//!
+//! Stream ordered host pinned memory pool
+//! ------------------------------
+//!
+//! ``pinned_memory_pool_ref`` allocates pinned memory using `cudaMallocFromPoolAsync / cudaFreeAsync
+//! <https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__MEMORY__POOLS.html>`__ for allocation/deallocation. A
+//! ``pinned_memory_pool_ref`` is a thin wrapper around a \c cudaMemPool_t with the location type set to \c
+//! cudaMemLocationTypeHost or \c cudaMemLocationTypeHostNuma.
+//!
+//! .. warning::
+//!
+//!    ``pinned_memory_pool_ref`` does not own the pool and it is the responsibility of the user to ensure that the
+//!    lifetime of the pool exceeds the lifetime of the ``pinned_memory_pool_ref``.
+//!
+//! @endrst
+class pinned_memory_pool_ref : public __memory_resource_base
+{
+public:
+  //! @brief  Constructs the pinned_memory_pool_ref from a \c cudaMemPool_t.
+  //! @param __pool The \c cudaMemPool_t used to allocate memory.
+  _CCCL_HOST_API explicit pinned_memory_pool_ref(::cudaMemPool_t __pool) noexcept
+      : __memory_resource_base(__pool)
+  {}
+
+  //! @brief Enables the \c device_accessible property
+  _CCCL_HOST_API friend constexpr void
+  get_property(pinned_memory_pool_ref const&, ::cuda::mr::device_accessible) noexcept
+  {}
+  //! @brief Enables the \c host_accessible property
+  _CCCL_HOST_API friend constexpr void get_property(pinned_memory_pool_ref const&, ::cuda::mr::host_accessible) noexcept
+  {}
+
+  using default_queries = ::cuda::mr::properties_list<::cuda::mr::device_accessible, ::cuda::mr::host_accessible>;
+};
+
+//! @brief Returns the default pinned memory pool.
+//! @throws cuda_error if retrieving the default \c cudaMemPool_t fails.
+//! @returns The default pinned memory pool.
+[[nodiscard]] inline pinned_memory_pool_ref pinned_default_memory_pool()
+{
+  return pinned_memory_pool_ref{::cuda::__get_default_host_pinned_pool()};
+}
+
+//! @rst
+//! .. _cudax-memory-resource-async:
+//!
+//! Stream ordered memory resource
+//! ------------------------------
+//!
+//! ``pinned_memory_pool`` allocates pinned memory using `cudaMallocFromPoolAsync / cudaFreeAsync
+//! <https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__MEMORY__POOLS.html>`__ for allocation/deallocation.
+//! When constructed it creates an underlying \c cudaMemPool_t with the location type set to \c cudaMemLocationTypeHost
+//! or \c cudaMemLocationTypeHostNuma and owns it.
+//!
+//! @endrst
+struct pinned_memory_pool : pinned_memory_pool_ref
+{
+  using reference_type = pinned_memory_pool_ref;
+
+#  if _CCCL_CTK_AT_LEAST(13, 0)
+  //! @brief Constructs a \c pinned_memory_pool with optional properties.
+  //! Properties include the initial pool size and the release threshold. If the pool size grows beyond the release
+  //! threshold, unused memory held by the pool will be released at the next synchronization event.
+
+  //! @note Memory from this pool is accessible from all devices right away, which differs from the default behavior of
+  //! pinned memory pools where memory is not accessible from devices until `cudaMemPoolSetAccess` is called.
+  //!
+  //! @param __properties Optional, additional properties of the pool to be created.
+  _CCCL_HOST_API pinned_memory_pool(memory_pool_properties __properties = {})
+      : pinned_memory_pool_ref(__create_cuda_mempool(
+          __properties, ::CUmemLocation{::CU_MEM_LOCATION_TYPE_HOST, 0}, ::CU_MEM_ALLOCATION_TYPE_PINNED))
+  {
+    enable_access_from(cuda::devices);
+  }
+#  endif // _CCCL_CTK_AT_LEAST(13, 0)
+
+  //! @brief Constructs a \c pinned_memory_pool with the specified NUMA node id and optional properties.
+  //! Properties include the initial pool size and the release threshold. If the pool size grows beyond the release
+  //! threshold, unused memory held by the pool will be released at the next synchronization event.
+  //!
+  //! @note Memory from this pool is accessible from all devices right away, which differs from the default behavior of
+  //! pinned memory pools where memory is not accessible from devices until `cudaMemPoolSetAccess` is called.
+  //!
+  //! @param __numa_id The NUMA node id of the NUMA node the pool is constructed on.
+  //! @param __pool_properties Optional, additional properties of the pool to be created.
+  _CCCL_HOST_API pinned_memory_pool(int __numa_id, memory_pool_properties __properties = {})
+      : pinned_memory_pool_ref(__create_cuda_mempool(
+          __properties, ::CUmemLocation{::CU_MEM_LOCATION_TYPE_HOST_NUMA, __numa_id}, ::CU_MEM_ALLOCATION_TYPE_PINNED))
+  {
+    enable_access_from(cuda::devices);
+  }
+
+  ~pinned_memory_pool() noexcept
+  {
+    ::cuda::__driver::__mempoolDestroy(__pool_);
+  }
+
+  _CCCL_HOST_API static pinned_memory_pool from_native_handle(::cudaMemPool_t __pool) noexcept
+  {
+    return pinned_memory_pool(__pool);
+  }
+
+  pinned_memory_pool(const pinned_memory_pool&)            = delete;
+  pinned_memory_pool& operator=(const pinned_memory_pool&) = delete;
+
+private:
+  pinned_memory_pool(::cudaMemPool_t __pool) noexcept
+      : pinned_memory_pool_ref(__pool)
+  {}
+};
+
+static_assert(::cuda::mr::resource_with<pinned_memory_pool_ref, ::cuda::mr::device_accessible>, "");
+static_assert(::cuda::mr::resource_with<pinned_memory_pool_ref, ::cuda::mr::host_accessible>, "");
+
+static_assert(::cuda::mr::resource_with<pinned_memory_pool, ::cuda::mr::device_accessible>, "");
+static_assert(::cuda::mr::resource_with<pinned_memory_pool, ::cuda::mr::host_accessible>, "");
+
+[[nodiscard]] static ::cudaMemPool_t __get_default_host_pinned_pool()
+{
+#  if _CCCL_CTK_AT_LEAST(13, 0)
+  static ::cudaMemPool_t __default_pool = []() {
+    ::cudaMemPool_t __pool = ::cuda::__driver::__getDefaultMemPool(
+      ::CUmemLocation{::CU_MEM_LOCATION_TYPE_HOST, 0}, ::CU_MEM_ALLOCATION_TYPE_PINNED);
+    // TODO should we be more careful with setting access from all devices? Maybe only if it was not set for any device?
+    ::cuda::__mempool_set_access(__pool, ::cuda::devices, ::CU_MEM_ACCESS_FLAGS_PROT_READWRITE);
+    return __pool;
+  }();
+
+  return __default_pool;
+#  else // ^^^ _CCCL_CTK_AT_LEAST(13, 0) ^^^ / vvv _CCCL_CTK_BELOW(13, 0) vvv
+  static pinned_memory_pool __default_pool(0);
+  return __default_pool.get();
+#  endif // ^^^ _CCCL_CTK_BELOW(13, 0) ^^^
+}
+
+#endif // _CCCL_CTK_AT_LEAST(12, 6)
+
+_CCCL_END_NAMESPACE_CUDA
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif //_CUDA___MEMORY_RESOURCE_PINNED_MEMORY_POOL_H

cuda/cccl/headers/include/cuda/__memory_resource/properties.h

@@ -8,8 +8,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _CUDA__MEMORY_RESOURCE_PROPERTIES_H
-#define _CUDA__MEMORY_RESOURCE_PROPERTIES_H
+#ifndef _CUDA___MEMORY_RESOURCE_PROPERTIES_H
+#define _CUDA___MEMORY_RESOURCE_PROPERTIES_H
 
 #include <cuda/std/detail/__config>
 
@@ -110,4 +110,4 @@ _CCCL_END_NAMESPACE_CUDA_MR
 
 #include <cuda/std/__cccl/epilogue.h>
 
-#endif //_CUDA__MEMORY_RESOURCE_PROPERTIES_H
+#endif //_CUDA___MEMORY_RESOURCE_PROPERTIES_H

cuda/cccl/headers/include/cuda/__memory_resource/resource.h

@@ -8,8 +8,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _CUDA__MEMORY_RESOURCE_RESOURCE_H
-#define _CUDA__MEMORY_RESOURCE_RESOURCE_H
+#ifndef _CUDA___MEMORY_RESOURCE_RESOURCE_H
+#define _CUDA___MEMORY_RESOURCE_RESOURCE_H
 
 #include <cuda/std/detail/__config>
 
@@ -23,6 +23,7 @@
 
 #include <cuda/__memory_resource/get_property.h>
 #include <cuda/__stream/stream_ref.h>
+#include <cuda/__utility/__basic_any/semiregular.h>
 #include <cuda/std/__concepts/concept_macros.h>
 #include <cuda/std/__concepts/convertible_to.h>
 #include <cuda/std/__concepts/equality_comparable.h>
@@ -30,6 +31,7 @@
 #include <cuda/std/__tuple_dir/sfinae_helpers.h>
 #include <cuda/std/__type_traits/decay.h>
 #include <cuda/std/__type_traits/fold.h>
+#include <cuda/std/__type_traits/is_same.h>
 
 #include <cuda/std/__cccl/prologue.h>
 
@@ -119,7 +121,39 @@ _CCCL_CONCEPT __different_resource =
   __different_resource__<::cuda::std::convertible_to<_OtherResource const&, _Resource const&>>::__value(
     static_cast<_OtherResource*>(nullptr));
 
+template <class _Resource, class _OtherResource>
+_CCCL_CONCEPT __non_polymorphic_resources = _CCCL_REQUIRES_EXPR((_Resource, _OtherResource))(
+  requires(::cuda::mr::synchronous_resource<_Resource>),
+  requires(::cuda::mr::synchronous_resource<_OtherResource>),
+  requires(::cuda::__non_polymorphic<_Resource>),
+  requires(::cuda::__non_polymorphic<_OtherResource>));
+
 _CCCL_END_NAMESPACE_CUDA_MR
+
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+//! @brief Equality comparison between two resources of different types. Always returns false.
+_CCCL_TEMPLATE(class _Resource, class _OtherResource)
+_CCCL_REQUIRES((!::cuda::std::is_same_v<_Resource, _OtherResource>)
+                 _CCCL_AND ::cuda::mr::__non_polymorphic_resources<_Resource, _OtherResource>)
+[[nodiscard]] bool operator==(_Resource const&, _OtherResource const&) noexcept
+{
+  return false;
+}
+
+#if _CCCL_STD_VER <= 2017
+//! @brief Inequality comparison between two resources of different types. Always returns true.
+_CCCL_TEMPLATE(class _Resource, class _OtherResource)
+_CCCL_REQUIRES((!::cuda::std::is_same_v<_Resource, _OtherResource>)
+                 _CCCL_AND ::cuda::mr::__non_polymorphic_resources<_Resource, _OtherResource>)
+[[nodiscard]] bool operator!=(_Resource const&, _OtherResource const&) noexcept
+{
+  return true;
+}
+#endif // _CCCL_STD_VER <= 2017
+
+_CCCL_END_NAMESPACE_CUDA
+
 #include <cuda/std/__cccl/epilogue.h>
 
-#endif //_CUDA__MEMORY_RESOURCE_RESOURCE_H
+#endif //_CUDA___MEMORY_RESOURCE_RESOURCE_H

cuda/cccl/headers/include/cuda/__numeric/add_overflow.h

@@ -45,6 +45,10 @@
 
 #include <cuda/std/__cccl/prologue.h>
 
+#if _CCCL_CHECK_BUILTIN(__builtin_add_overflow) || _CCCL_COMPILER(GCC)
+#  define _CCCL_BUILTIN_ADD_OVERFLOW(...) __builtin_add_overflow(__VA_ARGS__)
+#endif // _CCCL_CHECK_BUILTIN(__builtin_add_overflow)
+
 _CCCL_BEGIN_NAMESPACE_CUDA
 
 template <class _Tp>
@@ -174,6 +178,12 @@ template <typename _Tp>
   return ::cuda::__add_overflow_generic_impl(__lhs, __rhs);
 }
 
+template <typename _Result, typename _Lhs, typename _Rhs>
+inline constexpr bool __is_add_representable_v =
+  sizeof(_Result) > sizeof(_Lhs) && sizeof(_Result) > sizeof(_Rhs)
+  && (::cuda::std::is_signed_v<_Result>
+      || (::cuda::std::is_unsigned_v<_Lhs> && ::cuda::std::is_unsigned_v<_Rhs> && ::cuda::std::is_unsigned_v<_Result>) );
+
 /***********************************************************************************************************************
  * Public interface
  **********************************************************************************************************************/
@@ -185,8 +195,8 @@ _CCCL_TEMPLATE(typename _Result = void,
                typename _ActualResult = ::cuda::std::conditional_t<::cuda::std::is_void_v<_Result>, _Common, _Result>)
 _CCCL_REQUIRES((::cuda::std::is_void_v<_Result> || ::cuda::std::__cccl_is_integer_v<_Result>)
                  _CCCL_AND ::cuda::std::__cccl_is_integer_v<_Lhs> _CCCL_AND ::cuda::std::__cccl_is_integer_v<_Rhs>)
-[[nodiscard]] _CCCL_API constexpr overflow_result<_ActualResult>
-add_overflow(const _Lhs __lhs, const _Rhs __rhs) noexcept
+[[nodiscard]]
+_CCCL_API constexpr overflow_result<_ActualResult> add_overflow(const _Lhs __lhs, const _Rhs __rhs) noexcept
 {
 // (1) __builtin_add_overflow is not available in a constant expression with gcc + nvcc
 // (2) __builtin_add_overflow generates suboptimal code with nvc++ and clang-cuda for device code
@@ -206,7 +216,7 @@ add_overflow(const _Lhs __lhs, const _Rhs __rhs) noexcept
   [[maybe_unused]] const bool __is_lhs_ge_zero = is_unsigned_v<_Lhs> || __lhs >= 0;
   [[maybe_unused]] const bool __is_rhs_ge_zero = is_unsigned_v<_Rhs> || __rhs >= 0;
   // shortcut for the case where inputs are representable with the max type
-  if constexpr (__is_integer_representable_v<_Lhs, _CommonAll> && __is_integer_representable_v<_Rhs, _CommonAll>)
+  if constexpr (__is_add_representable_v<_ActualResult, _Lhs, _Rhs>)
   {
     const auto __lhs1 = static_cast<_CommonAll>(__lhs);
     const auto __rhs1 = static_cast<_CommonAll>(__rhs);

cuda/cccl/headers/include/cuda/__numeric/div_overflow.h

@@ -0,0 +1,150 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the libcu++ Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___NUMERIC_DIV_OVERFLOW_H
+#define _CUDA___NUMERIC_DIV_OVERFLOW_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/__cmath/neg.h>
+#include <cuda/__cmath/uabs.h>
+#include <cuda/__numeric/overflow_cast.h>
+#include <cuda/__numeric/overflow_result.h>
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__limits/numeric_limits.h>
+#include <cuda/std/__type_traits/common_type.h>
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/is_integer.h>
+#include <cuda/std/__type_traits/is_signed.h>
+#include <cuda/std/__type_traits/is_unsigned.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__type_traits/make_unsigned.h>
+#include <cuda/std/__utility/cmp.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+template <typename _Result, typename _Lhs, typename _Rhs>
+inline constexpr bool __is_div_representable_v =
+  (sizeof(_Result) > sizeof(_Lhs) && sizeof(_Result) > sizeof(_Rhs) && ::cuda::std::is_signed_v<_Result>)
+  || (sizeof(_Result) >= sizeof(_Lhs) && sizeof(_Result) >= sizeof(_Rhs)
+      && ::cuda::std::is_unsigned_v<_Lhs> && ::cuda::std::is_unsigned_v<_Rhs> && ::cuda::std::is_unsigned_v<_Result>);
+
+/***********************************************************************************************************************
+ * Public interface
+ **********************************************************************************************************************/
+
+// div_overflow strategy:
+//
+// * If the result is representable with the actual result type, directly return the result
+// * Both inputs are signed:   check for min / -1, otherwise directly return the result
+// * Both inputs are positive: directly return the result
+// * Mixed signed/unsigned:
+//   - If the result is unsigned, return overflow (check for lhs != 0)
+//   - If the result is signed, compute |lhs| / |rhs| and return the result as negative (always representable)
+
+_CCCL_TEMPLATE(typename _Result = void,
+               typename _Lhs,
+               typename _Rhs,
+               typename _Common       = ::cuda::std::common_type_t<_Lhs, _Rhs>,
+               typename _ActualResult = ::cuda::std::conditional_t<::cuda::std::is_void_v<_Result>, _Common, _Result>)
+_CCCL_REQUIRES((::cuda::std::is_void_v<_Result> || ::cuda::std::__cccl_is_integer_v<_Result>)
+                 _CCCL_AND ::cuda::std::__cccl_is_integer_v<_Lhs> _CCCL_AND ::cuda::std::__cccl_is_integer_v<_Rhs>)
+[[nodiscard]]
+_CCCL_API constexpr overflow_result<_ActualResult> div_overflow(const _Lhs __lhs, const _Rhs __rhs) noexcept
+{
+  _CCCL_ASSERT(__rhs != _Rhs{0}, "division by zero");
+  // the result is representable with the actual result type
+  if constexpr (__is_div_representable_v<_ActualResult, _Lhs, _Rhs>)
+  {
+    const auto __lhs1   = static_cast<_ActualResult>(__lhs);
+    const auto __rhs1   = static_cast<_ActualResult>(__rhs);
+    const auto __result = static_cast<_ActualResult>(__lhs1 / __rhs1);
+    return overflow_result<_ActualResult>{__result, false};
+  }
+  else
+  {
+    using ::cuda::std::is_signed_v;
+    using ::cuda::std::is_unsigned_v;
+    using ::cuda::std::make_unsigned_t;
+    using ::cuda::std::numeric_limits;
+    constexpr bool __both_signed              = is_signed_v<_Lhs> && is_signed_v<_Rhs>;
+    [[maybe_unused]] const bool __lhs_ge_zero = is_unsigned_v<_Lhs> || __lhs >= _Lhs{0};
+    [[maybe_unused]] const bool __rhs_ge_zero = is_unsigned_v<_Rhs> || __rhs >= _Rhs{0};
+    if constexpr (__both_signed)
+    {
+      constexpr auto __lhs_min = numeric_limits<_Lhs>::min();
+      // special case for min / -1 -> potential overflow
+      if (__lhs == __lhs_min && __rhs == _Rhs{-1})
+      {
+        constexpr auto __neg_lhs_min = ::cuda::uabs(__lhs_min);
+        constexpr auto __result_max  = numeric_limits<_ActualResult>::max();
+        const bool __overflow        = ::cuda::std::cmp_greater(__neg_lhs_min, __result_max);
+        return overflow_result<_ActualResult>{static_cast<_ActualResult>(__neg_lhs_min), __overflow};
+      }
+      const auto __lhs1 = static_cast<_Common>(__lhs);
+      const auto __rhs1 = static_cast<_Common>(__rhs);
+      return ::cuda::overflow_cast<_ActualResult>(__lhs1 / __rhs1);
+    }
+    else if (__lhs_ge_zero && __rhs_ge_zero) // lhs and rhs are both >= 0
+    {
+      constexpr auto __result_max = numeric_limits<_ActualResult>::max();
+      using _UnsignedCommon       = make_unsigned_t<_Common>;
+      const auto __lhs1           = static_cast<_UnsignedCommon>(__lhs);
+      const auto __rhs1           = static_cast<_UnsignedCommon>(__rhs);
+      const auto __result         = __lhs1 / __rhs1;
+      const auto __is_overflow    = ::cuda::std::cmp_greater(__result, __result_max);
+      return overflow_result<_ActualResult>{static_cast<_ActualResult>(__result), __is_overflow};
+    }
+    else // lhs and rhs are mixed positive/negative -> negative result
+    {
+      const auto __lhs1   = ::cuda::uabs(__lhs);
+      const auto __rhs1   = ::cuda::uabs(__rhs);
+      const auto __div    = __lhs1 / __rhs1;
+      const auto __result = static_cast<_ActualResult>(::cuda::neg(__div));
+      if constexpr (is_unsigned_v<_ActualResult>)
+      {
+        return overflow_result<_ActualResult>{__result, __lhs != 0};
+      }
+      else
+      {
+        constexpr auto __result_min     = numeric_limits<_ActualResult>::min();
+        constexpr auto __neg_result_min = ::cuda::uabs(__result_min);
+        const auto __is_overflow        = ::cuda::std::cmp_greater(__div, __neg_result_min);
+        return overflow_result<_ActualResult>{__result, __is_overflow};
+      }
+    }
+  }
+}
+
+//! @brief Divides two numbers \p __lhs and \p __rhs with overflow detection
+_CCCL_TEMPLATE(typename _Result, typename _Lhs, typename _Rhs)
+_CCCL_REQUIRES(::cuda::std::__cccl_is_integer_v<_Result> _CCCL_AND ::cuda::std::__cccl_is_integer_v<_Lhs>
+                 _CCCL_AND ::cuda::std::__cccl_is_integer_v<_Rhs>)
+[[nodiscard]] _CCCL_API constexpr bool div_overflow(_Result& __result, const _Lhs __lhs, const _Rhs __rhs) noexcept
+{
+  const auto __res = ::cuda::div_overflow<_Result>(__lhs, __rhs);
+  __result         = __res.value;
+  return __res.overflow;
+}
+
+_CCCL_END_NAMESPACE_CUDA
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA___NUMERIC_DIV_OVERFLOW_H

cuda/cccl/headers/include/cuda/__numeric/overflow_cast.h

@@ -33,8 +33,8 @@ _CCCL_BEGIN_NAMESPACE_CUDA
 
 template <typename _From, typename _To>
 inline constexpr bool __is_integer_representable_v =
-  ::cuda::std::cmp_less(::cuda::std::numeric_limits<_From>::max(), ::cuda::std::numeric_limits<_To>::max())
-  && ::cuda::std::cmp_greater(::cuda::std::numeric_limits<_From>::min(), ::cuda::std::numeric_limits<_To>::min());
+  ::cuda::std::cmp_less_equal(::cuda::std::numeric_limits<_From>::max(), ::cuda::std::numeric_limits<_To>::max())
+  && ::cuda::std::cmp_greater_equal(::cuda::std::numeric_limits<_From>::min(), ::cuda::std::numeric_limits<_To>::min());
 
 //! @brief Casts a number \p __from to a number of type \p _To with overflow detection
 //! @param __from The number to cast