cuda-cccl 0.3.2__cp313-cp313-manylinux_2_24_aarch64.whl → 0.3.4__cp313-cp313-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/std/__atomic/functions/cuda_ptx_generated_helper.h

@@ -105,7 +105,7 @@ struct __atomic_cuda_operand_deduction
   using __tag  = _OpTag;
 };
 
-struct __atomic_longlong2
+struct _CCCL_ALIGNAS(16) __atomic_longlong2
 {
   uint64_t __x;
   uint64_t __y;
@@ -159,16 +159,23 @@ using __atomic_cuda_deduce_minmax = _If<
                     __type_default<__atomic_cuda_operand_deduction<uint64_t, __atomic_cuda_operand_u64>>>>>;
 
 template <class _Type>
-using __atomic_enable_if_native_bitwise = bool;
+using __atomic_enable_if_native_bitwise = enable_if_t<(sizeof(_Type) < 16), bool>;
 
 template <class _Type>
-using __atomic_enable_if_native_arithmetic = enable_if_t<is_scalar_v<_Type>, bool>;
+using __atomic_enable_if_native_arithmetic = enable_if_t<is_scalar_v<_Type> && (sizeof(_Type) < 16), bool>;
 
 template <class _Type>
-using __atomic_enable_if_native_minmax = enable_if_t<is_integral_v<_Type>, bool>;
+using __atomic_enable_if_native_minmax = enable_if_t<is_integral_v<_Type> && (sizeof(_Type) < 16), bool>;
 
 template <class _Type>
-using __atomic_enable_if_not_native_minmax = enable_if_t<!is_integral_v<_Type>, bool>;
+using __atomic_enable_if_not_native_bitwise = enable_if_t<(sizeof(_Type) == 16), bool>;
+
+template <class _Type>
+using __atomic_enable_if_not_native_arithmetic = enable_if_t<is_scalar_v<_Type> && (sizeof(_Type) == 16), bool>;
+
+template <class _Type>
+using __atomic_enable_if_not_native_minmax =
+  enable_if_t<!is_integral_v<_Type> || (is_scalar_v<_Type> && sizeof(_Type) == 16), bool>;
 
 _CCCL_END_NAMESPACE_CUDA_STD
 

cuda/cccl/headers/include/cuda/std/__atomic/functions/host.h

@@ -37,6 +37,23 @@ _CCCL_DIAG_SUPPRESS_CLANG("-Watomic-alignment")
 
 #if !_CCCL_COMPILER(NVRTC)
 
+// The compiler can provide 128b atomic support. Some onus on user to guarantee support.
+#  if _CCCL_HOST_128_ATOMICS_ENABLED()
+#    define _LIBCUDACXX_INT128_WARN(TYPE)
+// The compiler supports 128b via libatomic or another API.
+#  elif _CCCL_HOST_128_ATOMICS_MAYBE()
+#    define _LIBCUDACXX_INT128_WARN(TYPE)                                                                        \
+      static_assert(                                                                                             \
+        sizeof(TYPE) < 16,                                                                                       \
+        "CCCL has detected possible support for 128 bit atomics. However this feature is experimental. You can " \
+        "define CCCL_ENABLE_EXPERIMENTAL_HOST_ATOMICS_128B to ignore and acknowledge that runtime corruption "   \
+        "may occur if you link with libatomic and use locked atomics.");
+// The compiler does not provide support or proof of support. eg. msvc
+#  else
+#    define _LIBCUDACXX_INT128_WARN(TYPE) \
+      static_assert(sizeof(TYPE) < 16, "atomic_ref<T> where sizeof(T) > 8 is not supported on this system.");
+#  endif
+
 template <typename _Tp>
 struct _CCCL_ALIGNAS(sizeof(_Tp)) __atomic_alignment_wrapper
 {
@@ -65,12 +82,14 @@ inline void __atomic_signal_fence_host(memory_order __order)
 template <typename _Tp, typename _Up>
 inline void __atomic_store_host(_Tp* __a, _Up __val, memory_order __order)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   __atomic_store(&__atomic_force_align_host(__a)->__atom, &__val, __atomic_order_to_int(__order));
 }
 
 template <typename _Tp>
 inline auto __atomic_load_host(_Tp* __a, memory_order __order) -> remove_cv_t<_Tp>
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   remove_cv_t<_Tp> __ret;
   __atomic_load(&__atomic_force_align_host(__a)->__atom, &__ret, __atomic_order_to_int(__order));
   return __ret;
@@ -79,6 +98,7 @@ inline auto __atomic_load_host(_Tp* __a, memory_order __order) -> remove_cv_t<_T
 template <typename _Tp, typename _Up>
 inline auto __atomic_exchange_host(_Tp* __a, _Up __val, memory_order __order) -> remove_cv_t<_Tp>
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   remove_cv_t<_Tp> __ret;
   __atomic_exchange(&__atomic_force_align_host(__a)->__atom, &__val, &__ret, __atomic_order_to_int(__order));
   return __ret;
@@ -88,6 +108,7 @@ template <typename _Tp, typename _Up>
 inline bool __atomic_compare_exchange_strong_host(
   _Tp* __a, _Up* __expected, _Up __desired, memory_order __success, memory_order __failure)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   return __atomic_compare_exchange(
     &__atomic_force_align_host(__a)->__atom,
     // This is only alignment wrapped in order to prevent GCC-6 from triggering unused warning
@@ -102,6 +123,7 @@ template <typename _Tp, typename _Up>
 inline bool __atomic_compare_exchange_weak_host(
   _Tp* __a, _Up* __expected, _Up __desired, memory_order __success, memory_order __failure)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   return __atomic_compare_exchange(
     &__atomic_force_align_host(__a)->__atom,
     // This is only alignment wrapped in order to prevent GCC-6 from triggering unused warning
@@ -115,6 +137,7 @@ inline bool __atomic_compare_exchange_weak_host(
 template <typename _Tp, typename _Td, enable_if_t<!is_floating_point_v<_Tp>, int> = 0>
 inline remove_cv_t<_Tp> __atomic_fetch_add_host(_Tp* __a, _Td __delta, memory_order __order)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   constexpr auto __skip_v = __atomic_ptr_skip_t<_Tp>::__skip;
   return __atomic_fetch_add(__a, __delta * __skip_v, __atomic_order_to_int(__order));
 }
@@ -122,6 +145,7 @@ inline remove_cv_t<_Tp> __atomic_fetch_add_host(_Tp* __a, _Td __delta, memory_or
 template <typename _Tp, typename _Td, enable_if_t<is_floating_point_v<_Tp>, int> = 0>
 inline remove_cv_t<_Tp> __atomic_fetch_add_host(_Tp* __a, _Td __delta, memory_order __order)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   auto __expected = __atomic_load_host(__a, memory_order_relaxed);
   auto __desired  = __expected + __delta;
 
@@ -136,6 +160,7 @@ inline remove_cv_t<_Tp> __atomic_fetch_add_host(_Tp* __a, _Td __delta, memory_or
 template <typename _Tp, typename _Td, enable_if_t<!is_floating_point_v<_Tp>, int> = 0>
 inline remove_cv_t<_Tp> __atomic_fetch_sub_host(_Tp* __a, _Td __delta, memory_order __order)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   constexpr auto __skip_v = __atomic_ptr_skip_t<_Tp>::__skip;
   return __atomic_fetch_sub(__a, __delta * __skip_v, __atomic_order_to_int(__order));
 }
@@ -143,6 +168,7 @@ inline remove_cv_t<_Tp> __atomic_fetch_sub_host(_Tp* __a, _Td __delta, memory_or
 template <typename _Tp, typename _Td, enable_if_t<is_floating_point_v<_Tp>, int> = 0>
 inline remove_cv_t<_Tp> __atomic_fetch_sub_host(_Tp* __a, _Td __delta, memory_order __order)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   auto __expected = __atomic_load_host(__a, memory_order_relaxed);
   auto __desired  = __expected - __delta;
 
@@ -157,24 +183,28 @@ inline remove_cv_t<_Tp> __atomic_fetch_sub_host(_Tp* __a, _Td __delta, memory_or
 template <typename _Tp, typename _Td>
 inline remove_cv_t<_Tp> __atomic_fetch_and_host(_Tp* __a, _Td __pattern, memory_order __order)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   return __atomic_fetch_and(__a, __pattern, __atomic_order_to_int(__order));
 }
 
 template <typename _Tp, typename _Td>
 inline remove_cv_t<_Tp> __atomic_fetch_or_host(_Tp* __a, _Td __pattern, memory_order __order)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   return __atomic_fetch_or(__a, __pattern, __atomic_order_to_int(__order));
 }
 
 template <typename _Tp, typename _Td>
 inline remove_cv_t<_Tp> __atomic_fetch_xor_host(_Tp* __a, _Td __pattern, memory_order __order)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   return __atomic_fetch_xor(__a, __pattern, __atomic_order_to_int(__order));
 }
 
 template <typename _Tp, typename _Td>
 inline remove_cv_t<_Tp> __atomic_fetch_max_host(_Tp* __a, _Td __val, memory_order __order)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   auto __expected = __atomic_load_host(__a, memory_order_relaxed);
   auto __desired  = __expected > __val ? __expected : __val;
 
@@ -189,6 +219,7 @@ inline remove_cv_t<_Tp> __atomic_fetch_max_host(_Tp* __a, _Td __val, memory_orde
 template <typename _Tp, typename _Td>
 inline remove_cv_t<_Tp> __atomic_fetch_min_host(_Tp* __a, _Td __val, memory_order __order)
 {
+  _LIBCUDACXX_INT128_WARN(_Tp)
   auto __expected = __atomic_load_host(__a, memory_order_relaxed);
   auto __desired  = __expected < __val ? __expected : __val;
 

cuda/cccl/headers/include/cuda/std/__atomic/types/small.h

@@ -60,14 +60,22 @@ _CCCL_HOST_DEVICE inline __atomic_small_proxy_t<_Tp> __atomic_small_to_32(_Tp __
   return __temp;
 }
 
+_CCCL_DIAG_PUSH
+#if _CCCL_COMPILER(GCC, >=, 8)
+_CCCL_DIAG_SUPPRESS_GCC("-Wclass-memaccess")
+#endif
+
 template <class _Tp, enable_if_t<!is_arithmetic_v<_Tp>, int> = 0>
 _CCCL_HOST_DEVICE inline _Tp __atomic_small_from_32(__atomic_small_proxy_t<_Tp> __val)
 {
+  // GCC starting with GCC8 warns about our extended floating point types having protected data members
   _Tp __temp{};
   ::cuda::std::memcpy(&__temp, &__val, sizeof(_Tp));
   return __temp;
 }
 
+_CCCL_DIAG_POP
+
 template <typename _Tp>
 struct __atomic_small_storage
 {
@@ -207,6 +215,7 @@ template <typename _Sto, typename _Up, typename _Sco, __atomic_storage_is_small<
 _CCCL_HOST_DEVICE inline auto __atomic_fetch_max_dispatch(_Sto* __a, _Up __val, memory_order __order, _Sco = {})
   -> __atomic_underlying_t<_Sto>
 {
+  static_assert(is_floating_point_v<__atomic_underlying_t<_Sto>> || is_integral_v<__atomic_underlying_t<_Sto>>, "");
   using _Tp = __atomic_underlying_t<_Sto>;
   return __atomic_small_from_32<_Tp>(
     __atomic_fetch_max_dispatch(&__a->__a_value, __atomic_small_to_32(__val), __order, _Sco{}));
@@ -216,6 +225,7 @@ template <typename _Sto, typename _Up, typename _Sco, __atomic_storage_is_small<
 _CCCL_HOST_DEVICE inline auto __atomic_fetch_min_dispatch(_Sto* __a, _Up __val, memory_order __order, _Sco = {})
   -> __atomic_underlying_t<_Sto>
 {
+  static_assert(is_floating_point_v<__atomic_underlying_t<_Sto>> || is_integral_v<__atomic_underlying_t<_Sto>>, "");
   using _Tp = __atomic_underlying_t<_Sto>;
   return __atomic_small_from_32<_Tp>(
     __atomic_fetch_min_dispatch(&__a->__a_value, __atomic_small_to_32(__val), __order, _Sco{}));

cuda/cccl/headers/include/cuda/std/__atomic/types.h

@@ -34,9 +34,8 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 template <typename _Tp>
 struct __atomic_traits
 {
-  static constexpr bool __atomic_requires_lock      = !__atomic_is_always_lock_free<_Tp>::__value;
-  static constexpr bool __atomic_requires_small     = sizeof(_Tp) < 4;
-  static constexpr bool __atomic_supports_reference = __atomic_is_always_lock_free<_Tp>::__value && sizeof(_Tp) <= 8;
+  static constexpr bool __atomic_requires_lock  = !__atomic_is_always_lock_free<_Tp>::__value;
+  static constexpr bool __atomic_requires_small = sizeof(_Tp) < 4;
 };
 
 template <typename _Tp>

cuda/cccl/headers/include/cuda/std/__bit/byteswap.h

@@ -21,9 +21,6 @@
 #  pragma system_header
 #endif // no system header
 
-#if _CCCL_CUDA_COMPILATION()
-#  include <cuda/__ptx/instructions/prmt.h>
-#endif // _CCCL_CUDA_COMPILATION()
 #include <cuda/std/__concepts/concept_macros.h>
 #include <cuda/std/__type_traits/is_constant_evaluated.h>
 #include <cuda/std/__type_traits/is_integral.h>
@@ -38,6 +35,34 @@
 
 #include <cuda/std/__cccl/prologue.h>
 
+#if _CCCL_CHECK_BUILTIN(builtin_bswap16) || _CCCL_COMPILER(GCC)
+#  define _CCCL_BUILTIN_BSWAP16(...) __builtin_bswap16(__VA_ARGS__)
+#endif // _CCCL_CHECK_BUILTIN(builtin_bswap16)
+
+#if _CCCL_CHECK_BUILTIN(builtin_bswap32) || _CCCL_COMPILER(GCC)
+#  define _CCCL_BUILTIN_BSWAP32(...) __builtin_bswap32(__VA_ARGS__)
+#endif // _CCCL_CHECK_BUILTIN(builtin_bswap32)
+
+#if _CCCL_CHECK_BUILTIN(builtin_bswap64) || _CCCL_COMPILER(GCC)
+#  define _CCCL_BUILTIN_BSWAP64(...) __builtin_bswap64(__VA_ARGS__)
+#endif // _CCCL_CHECK_BUILTIN(builtin_bswap64)
+
+#if _CCCL_CHECK_BUILTIN(builtin_bswap128) // Only available in GCC >= 11 which supports __has_builtin
+#  define _CCCL_BUILTIN_BSWAP128(...) __builtin_bswap128(__VA_ARGS__)
+#endif // _CCCL_CHECK_BUILTIN(builtin_bswap128)
+
+// nvcc doesn't support these builtins in device code
+#if _CCCL_CUDA_COMPILER(NVCC) && _CCCL_DEVICE_COMPILATION()
+#  undef _CCCL_BUILTIN_BSWAP16
+#  undef _CCCL_BUILTIN_BSWAP32
+#  undef _CCCL_BUILTIN_BSWAP64
+#endif // _CCCL_CUDA_COMPILER(NVCC) && _CCCL_DEVICE_COMPILATION()
+
+// gcc fails to use the builtin when compiling with nvcc
+#if _CCCL_CUDA_COMPILER(NVCC) && _CCCL_COMPILER(GCC, <, 15)
+#  undef _CCCL_BUILTIN_BSWAP128
+#endif // _CCCL_CUDA_COMPILER(NVCC) && _CCCL_COMPILER(GCC, <, 15)
+
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 template <class _Tp>
@@ -60,34 +85,33 @@ template <class _Full>
   }
 }
 
+#if _CCCL_CUDA_COMPILATION()
+
 template <class _Tp>
 [[nodiscard]] _CCCL_HIDE_FROM_ABI _CCCL_DEVICE _Tp __byteswap_impl_device(_Tp __val) noexcept
 {
-#if __cccl_ptx_isa >= 200
   if constexpr (sizeof(_Tp) == sizeof(uint16_t))
   {
-    return static_cast<uint16_t>(::cuda::ptx::prmt(static_cast<uint32_t>(__val), uint32_t{0}, uint32_t{0x3201}));
+    return static_cast<uint16_t>(::__byte_perm(static_cast<uint32_t>(__val), 0u, 0x3201u));
   }
   else if constexpr (sizeof(_Tp) == sizeof(uint32_t))
   {
-    return ::cuda::ptx::prmt(__val, uint32_t{0}, uint32_t{0x0123});
+    return ::__byte_perm(__val, 0u, 0x0123u);
   }
   else if constexpr (sizeof(_Tp) == sizeof(uint64_t))
   {
-    const auto __hi     = static_cast<uint32_t>(__val >> 32);
-    const auto __lo     = static_cast<uint32_t>(__val);
-    const auto __new_lo = ::cuda::ptx::prmt(__hi, uint32_t{0}, uint32_t{0x0123});
-    const auto __new_hi = ::cuda::ptx::prmt(__lo, uint32_t{0}, uint32_t{0x0123});
-
-    return static_cast<uint64_t>(__new_hi) << 32 | static_cast<uint64_t>(__new_lo);
+    const auto __lo = ::__byte_perm(static_cast<uint32_t>(__val >> 32), 0u, 0x0123u);
+    const auto __hi = ::__byte_perm(static_cast<uint32_t>(__val), 0u, 0x0123u);
+    return (static_cast<uint64_t>(__hi) << 32) | static_cast<uint64_t>(__lo);
   }
   else
-#endif // __cccl_ptx_isa >= 200
   {
     return ::cuda::std::__byteswap_impl_recursive(__val);
   }
 }
 
+#endif // _CCCL_CUDA_COMPILATION()
+
 template <class _Tp>
 [[nodiscard]] _CCCL_API constexpr _Tp __byteswap_impl(_Tp __val) noexcept
 {

cuda/cccl/headers/include/cuda/std/__cccl/builtin.h

@@ -159,30 +159,6 @@
 #  undef _CCCL_BUITLIN_CTZG
 #endif // _CCCL_CUDA_COMPILER(NVCC)
 
-#if _CCCL_CHECK_BUILTIN(builtin_bswap16) || _CCCL_COMPILER(GCC)
-#  define _CCCL_BUILTIN_BSWAP16(...) __builtin_bswap16(__VA_ARGS__)
-#endif // _CCCL_CHECK_BUILTIN(builtin_bswap16)
-
-#if _CCCL_CHECK_BUILTIN(builtin_bswap32) || _CCCL_COMPILER(GCC)
-#  define _CCCL_BUILTIN_BSWAP32(...) __builtin_bswap32(__VA_ARGS__)
-#endif // _CCCL_CHECK_BUILTIN(builtin_bswap32)
-
-#if _CCCL_CHECK_BUILTIN(builtin_bswap64) || _CCCL_COMPILER(GCC)
-#  define _CCCL_BUILTIN_BSWAP64(...) __builtin_bswap64(__VA_ARGS__)
-#endif // _CCCL_CHECK_BUILTIN(builtin_bswap64)
-
-#if _CCCL_CHECK_BUILTIN(builtin_bswap128) // Only available in GCC >= 11 which supports __has_builtin
-#  define _CCCL_BUILTIN_BSWAP128(...) __builtin_bswap128(__VA_ARGS__)
-#endif // _CCCL_CHECK_BUILTIN(builtin_bswap128)
-
-// NVCC cannot handle builtins for bswap
-#if _CCCL_CUDA_COMPILER(NVCC)
-#  undef _CCCL_BUILTIN_BSWAP16
-#  undef _CCCL_BUILTIN_BSWAP32
-#  undef _CCCL_BUILTIN_BSWAP64
-#  undef _CCCL_BUILTIN_BSWAP128
-#endif // _CCCL_CUDA_COMPILER(NVCC)
-
 #if _CCCL_CHECK_BUILTIN(builtin_bitreverse8) && !_CCCL_HAS_CUDA_COMPILER()
 #  define _CCCL_BUILTIN_BITREVERSE8(...) __builtin_bitreverse8(__VA_ARGS__)
 #endif
@@ -358,10 +334,6 @@
 #  define _CCCL_BUILTIN_PREFETCH(...)
 #endif // _CCCL_CHECK_BUILTIN(builtin_prefetch)
 
-#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)
-
 #if _CCCL_HAS_BUILTIN(__decay) && _CCCL_CUDA_COMPILER(CLANG)
 #  define _CCCL_BUILTIN_DECAY(...) __decay(__VA_ARGS__)
 #endif // _CCCL_HAS_BUILTIN(__decay) && clang-cuda

cuda/cccl/headers/include/cuda/std/__cccl/dialect.h

@@ -120,4 +120,11 @@
 #  define _CCCL_CONSTINIT _CCCL_REQUIRE_CONSTANT_INITIALIZATION
 #endif // ^^^ no constinit ^^^
 
+// nvcc and nvrtc don't implement multiarg operator[] even in C++23 mode
+#if __cpp_multidimensional_subscript >= 202211L && !_CCCL_CUDA_COMPILER(NVCC) && !_CCCL_CUDA_COMPILER(NVRTC)
+#  define _CCCL_HAS_MULTIARG_OPERATOR_BRACKETS() 1
+#else // ^^^ has multiarg operator[] ^^^ / vvv no multiarg operator[] vvv
+#  define _CCCL_HAS_MULTIARG_OPERATOR_BRACKETS() 0
+#endif // ^^^ no mutiarg operator[] ^^^
+
 #endif // __CCCL_DIALECT_H

cuda/cccl/headers/include/cuda/std/__cccl/epilogue.h

@@ -323,6 +323,8 @@ _CCCL_DIAG_POP
 #  undef _CCCL_POP_MACRO_interface
 #endif
 
+// sal.h on Windows
+
 #if defined(__valid)
 #  error \
     "cccl internal error: macro `__valid` was redefined between <cuda/std/__cccl/prologue.h> and <cuda/std/__cccl/epilogue.h>"
@@ -331,6 +333,14 @@ _CCCL_DIAG_POP
 #  undef _CCCL_POP_MACRO___valid
 #endif
 
+#if defined(__callback)
+#  error \
+    "cccl internal error: macro `__callback` was redefined between <cuda/std/__cccl/prologue.h> and <cuda/std/__cccl/epilogue.h>"
+#elif defined(_CCCL_POP_MACRO___callback)
+#  pragma pop_macro("__callback")
+#  undef _CCCL_POP_MACRO___callback
+#endif
+
 // other macros
 
 #if defined(clang)

cuda/cccl/headers/include/cuda/std/__cccl/exceptions.h

@@ -28,52 +28,9 @@
 #elif _CCCL_COMPILER(NVRTC) // NVRTC has no exceptions
 #  define _CCCL_HAS_EXCEPTIONS() 0
 #elif _CCCL_COMPILER(MSVC) // MSVC needs special checks for `_HAS_EXCEPTIONS` and `_CPPUNWIND`
-#  define _CCCL_HAS_EXCEPTIONS() (_HAS_EXCEPTIONS != 0) && (_CPPUNWIND != 0)
+#  define _CCCL_HAS_EXCEPTIONS() ((_HAS_EXCEPTIONS != 0) && (_CPPUNWIND != 0))
 #else // other compilers use `__EXCEPTIONS`
-#  define _CCCL_HAS_EXCEPTIONS() __EXCEPTIONS
+#  define _CCCL_HAS_EXCEPTIONS() (__EXCEPTIONS)
 #endif // has exceptions
 
-// The following macros are used to conditionally compile exception handling code. They
-// are used in the same way as `try` and `catch`, but they allow for different behavior
-// based on whether exceptions are enabled or not, and whether the code is being compiled
-// for device or not.
-//
-// Usage:
-//   _CCCL_TRY
-//   {
-//     can_throw();               // Code that may throw an exception
-//   }
-//   _CCCL_CATCH (cuda_error& e)  // Handle CUDA exceptions
-//   {
-//     printf("CUDA error: %s\n", e.what());
-//   }
-//   _CCCL_CATCH_ALL              // Handle any other exceptions
-//   {
-//     printf("unknown error\n");
-//   }
-#if !_CCCL_HAS_EXCEPTIONS() || (_CCCL_DEVICE_COMPILATION() && !_CCCL_CUDA_COMPILER(NVHPC))
-#  define _CCCL_TRY if constexpr (true)
-#  define _CCCL_CATCH(...)                                              \
-    else if constexpr (__VA_ARGS__ = ::__cccl_catch_any_lvalue{}; true) \
-    {                                                                   \
-    }                                                                   \
-    else
-#  define _CCCL_CATCH_ALL    \
-    else if constexpr (true) \
-    {                        \
-    }                        \
-    else
-#else // ^^^ !_CCCL_HAS_EXCEPTIONS() || (_CCCL_DEVICE_COMPILATION() && !_CCCL_CUDA_COMPILER(NVHPC)) ^^^
-      // vvv _CCCL_HAS_EXCEPTIONS() && (!_CCCL_DEVICE_COMPILATION() || _CCCL_CUDA_COMPILER(NVHPC)) vvv
-#  define _CCCL_TRY       try
-#  define _CCCL_CATCH     catch
-#  define _CCCL_CATCH_ALL catch (...)
-#endif // ^^^ _CCCL_HAS_EXCEPTIONS() && (!_CCCL_DEVICE_COMPILATION() || _CCCL_CUDA_COMPILER(NVHPC)) ^^^
-
-struct __cccl_catch_any_lvalue
-{
-  template <class _Tp>
-  _CCCL_HOST_DEVICE operator _Tp&() const noexcept;
-};
-
 #endif // __CCCL_EXCEPTIONS_H

cuda/cccl/headers/include/cuda/std/__cccl/is_non_narrowing_convertible.h

@@ -23,7 +23,6 @@
 
 namespace __cccl_internal
 {
-
 #if _CCCL_CUDA_COMPILATION()
 template <class _Tp>
 __host__ __device__ _Tp&& __cccl_declval(int);
@@ -67,7 +66,6 @@ struct __is_non_narrowing_convertible<_Dest,
 {
   static constexpr bool value = true;
 };
-
 } // namespace __cccl_internal
 
 #endif // __CCCL_IS_NON_NARROWING_CONVERTIBLE_H

cuda/cccl/headers/include/cuda/std/__cccl/prologue.h

@@ -247,12 +247,20 @@
 #  define _CCCL_POP_MACRO_interface
 #endif // defined(interface)
 
+// sal.h on Windows
+
 #if defined(__valid)
 #  pragma push_macro("__valid")
 #  undef __valid
 #  define _CCCL_POP_MACRO___valid
 #endif // defined(__valid)
 
+#if defined(__callback)
+#  pragma push_macro("__callback")
+#  undef __callback
+#  define _CCCL_POP_MACRO___callback
+#endif // defined(__callback)
+
 // other macros
 
 #if defined(clang)

cuda/cccl/headers/include/cuda/std/__chrono/calendar.h

@@ -30,7 +30,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace chrono
 {
-
 struct local_t
 {};
 
@@ -44,7 +43,6 @@ struct _CCCL_TYPE_VISIBILITY_DEFAULT last_spec
   _CCCL_HIDE_FROM_ABI explicit last_spec() = default;
 };
 inline constexpr last_spec last{};
-
 } // namespace chrono
 
 _CCCL_END_NAMESPACE_CUDA_STD

cuda/cccl/headers/include/cuda/std/__chrono/day.h

@@ -32,7 +32,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace chrono
 {
-
 class day
 {
 private:
@@ -152,7 +151,6 @@ public:
   }
 #endif // !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
 };
-
 } // namespace chrono
 
 _CCCL_END_NAMESPACE_CUDA_STD

cuda/cccl/headers/include/cuda/std/__chrono/duration.h

@@ -38,25 +38,23 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace chrono
 {
-
 template <class _Rep, class _Period = ratio<1>>
 class _CCCL_TYPE_VISIBILITY_DEFAULT duration;
 
 template <class _Tp>
-inline constexpr bool __is_duration_v = false;
+inline constexpr bool __is_cuda_std_duration_v = false;
 
 template <class _Rep, class _Period>
-inline constexpr bool __is_duration_v<duration<_Rep, _Period>> = true;
+inline constexpr bool __is_cuda_std_duration_v<duration<_Rep, _Period>> = true;
 
 template <class _Rep, class _Period>
-inline constexpr bool __is_duration_v<const duration<_Rep, _Period>> = true;
+inline constexpr bool __is_cuda_std_duration_v<const duration<_Rep, _Period>> = true;
 
 template <class _Rep, class _Period>
-inline constexpr bool __is_duration_v<volatile duration<_Rep, _Period>> = true;
+inline constexpr bool __is_cuda_std_duration_v<volatile duration<_Rep, _Period>> = true;
 
 template <class _Rep, class _Period>
-inline constexpr bool __is_duration_v<const volatile duration<_Rep, _Period>> = true;
-
+inline constexpr bool __is_cuda_std_duration_v<const volatile duration<_Rep, _Period>> = true;
 } // namespace chrono
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
@@ -69,11 +67,10 @@ common_type<::cuda::std::chrono::duration<_Rep1, _Period1>, ::cuda::std::chrono:
 
 namespace chrono
 {
-
 // duration_cast
 
 _CCCL_TEMPLATE(class _ToDuration, class _Rep, class _Period)
-_CCCL_REQUIRES(__is_duration_v<_ToDuration>)
+_CCCL_REQUIRES(__is_cuda_std_duration_v<_ToDuration>)
 [[nodiscard]] _CCCL_API constexpr _ToDuration duration_cast(const duration<_Rep, _Period>& __fd)
 {
   using _FromDuration = duration<_Rep, _Period>;
@@ -128,7 +125,7 @@ public:
 };
 
 _CCCL_TEMPLATE(class _ToDuration, class _Rep, class _Period)
-_CCCL_REQUIRES(__is_duration_v<_ToDuration>)
+_CCCL_REQUIRES(__is_cuda_std_duration_v<_ToDuration>)
 [[nodiscard]] _CCCL_API constexpr _ToDuration floor(const duration<_Rep, _Period>& __d)
 {
   _ToDuration __t = ::cuda::std::chrono::duration_cast<_ToDuration>(__d);
@@ -140,7 +137,7 @@ _CCCL_REQUIRES(__is_duration_v<_ToDuration>)
 }
 
 _CCCL_TEMPLATE(class _ToDuration, class _Rep, class _Period)
-_CCCL_REQUIRES(__is_duration_v<_ToDuration>)
+_CCCL_REQUIRES(__is_cuda_std_duration_v<_ToDuration>)
 [[nodiscard]] _CCCL_API constexpr _ToDuration ceil(const duration<_Rep, _Period>& __d)
 {
   _ToDuration __t = ::cuda::std::chrono::duration_cast<_ToDuration>(__d);
@@ -152,7 +149,7 @@ _CCCL_REQUIRES(__is_duration_v<_ToDuration>)
 }
 
 _CCCL_TEMPLATE(class _ToDuration, class _Rep, class _Period)
-_CCCL_REQUIRES(__is_duration_v<_ToDuration>)
+_CCCL_REQUIRES(__is_cuda_std_duration_v<_ToDuration>)
 [[nodiscard]] _CCCL_API constexpr _ToDuration round(const duration<_Rep, _Period>& __d)
 {
   _ToDuration __lower = ::cuda::std::chrono::floor<_ToDuration>(__d);
@@ -182,8 +179,8 @@ _CCCL_REQUIRES(numeric_limits<_Rep>::is_signed)
 template <class _Rep, class _Period>
 class _CCCL_TYPE_VISIBILITY_DEFAULT duration
 {
-  static_assert(!__is_duration_v<_Rep>, "A duration representation can not be a duration");
-  static_assert(__is_ratio_v<_Period>, "Second template parameter of duration must be a std::ratio");
+  static_assert(!__is_cuda_std_duration_v<_Rep>, "A duration representation can not be a duration");
+  static_assert(__is_cuda_std_ratio_v<_Period>, "Second template parameter of duration must be a std::ratio");
   static_assert(_Period::num > 0, "duration period must be positive");
 
   template <class _R1, class _R2>
@@ -445,7 +442,7 @@ public:
   }
 
   _CCCL_TEMPLATE(class _Rep2)
-  _CCCL_REQUIRES((!__is_duration_v<_Rep2>) _CCCL_AND is_convertible_v<const _Rep2&, common_type_t<_Rep, _Rep2>>)
+  _CCCL_REQUIRES((!__is_cuda_std_duration_v<_Rep2>) _CCCL_AND is_convertible_v<const _Rep2&, common_type_t<_Rep, _Rep2>>)
   [[nodiscard]] _CCCL_API friend constexpr duration<common_type_t<_Rep, _Rep2>, _Period>
   operator/(const duration& __d, const _Rep2& __s)
   {
@@ -463,7 +460,7 @@ public:
   }
 
   _CCCL_TEMPLATE(class _Rep2)
-  _CCCL_REQUIRES((!__is_duration_v<_Rep2>) _CCCL_AND is_convertible_v<const _Rep2&, common_type_t<_Rep, _Rep2>>)
+  _CCCL_REQUIRES((!__is_cuda_std_duration_v<_Rep2>) _CCCL_AND is_convertible_v<const _Rep2&, common_type_t<_Rep, _Rep2>>)
   [[nodiscard]] _CCCL_API friend constexpr duration<common_type_t<_Rep, _Rep2>, _Period>
   operator%(const duration& __d, const _Rep2& __s)
   {
@@ -493,7 +490,6 @@ using days   = duration<int, ratio_multiply<ratio<24>, hours::period>>;
 using weeks  = duration<int, ratio_multiply<ratio<7>, days::period>>;
 using years  = duration<int, ratio_multiply<ratio<146097, 400>, days::period>>;
 using months = duration<int, ratio_divide<years::period, ratio<12>>>;
-
 } // namespace chrono
 
 _CCCL_END_NAMESPACE_CUDA_STD

cuda/cccl/headers/include/cuda/std/__chrono/file_clock.h

@@ -39,13 +39,11 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace chrono
 {
-
 // [time.clock.file], type file_clock
 using file_clock = ::cuda::std::__fs::filesystem::_FilesystemClock;
 
 template <class _Duration>
 using file_time = time_point<file_clock, _Duration>;
-
 } // namespace chrono
 
 _CCCL_END_NAMESPACE_CUDA_STD

cuda/cccl/headers/include/cuda/std/__chrono/high_resolution_clock.h

@@ -30,13 +30,11 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace chrono
 {
-
 #if _LIBCUDACXX_HAS_MONOTONIC_CLOCK()
 using high_resolution_clock = steady_clock;
 #else // ^^^ _LIBCUDACXX_HAS_MONOTONIC_CLOCK() ^^^ / vvv !_LIBCUDACXX_HAS_MONOTONIC_CLOCK() vvv
 using high_resolution_clock = system_clock;
 #endif // !_LIBCUDACXX_HAS_MONOTONIC_CLOCK()
-
 } // namespace chrono
 
 _CCCL_END_NAMESPACE_CUDA_STD

cuda/cccl/headers/include/cuda/std/__chrono/month.h

@@ -32,7 +32,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace chrono
 {
-
 class month
 {
 private:
@@ -177,7 +176,6 @@ inline constexpr month September{9};
 inline constexpr month October{10};
 inline constexpr month November{11};
 inline constexpr month December{12};
-
 } // namespace chrono
 
 _CCCL_END_NAMESPACE_CUDA_STD