cuda-cccl 0.1.3.2.0.dev438__cp310-cp310-manylinux_2_24_aarch64.whl → 0.3.1__cp310-cp310-manylinux_2_24_aarch64.whl

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

@@ -0,0 +1,593 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM 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___ITERATOR_ZIP_TRANSFORM_ITERATOR_H
+#define _CUDA___ITERATOR_ZIP_TRANSFORM_ITERATOR_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/__fwd/zip_iterator.h>
+#include <cuda/std/__algorithm/ranges_min_element.h>
+#if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+#  include <cuda/std/__compare/three_way_comparable.h>
+#endif // _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+#include <cuda/__iterator/zip_common.h>
+#include <cuda/std/__concepts/convertible_to.h>
+#include <cuda/std/__concepts/equality_comparable.h>
+#include <cuda/std/__functional/invoke.h>
+#include <cuda/std/__functional/operations.h>
+#include <cuda/std/__iterator/concepts.h>
+#include <cuda/std/__iterator/incrementable_traits.h>
+#include <cuda/std/__iterator/iterator_traits.h>
+#include <cuda/std/__ranges/concepts.h>
+#include <cuda/std/__ranges/movable_box.h>
+#include <cuda/std/__type_traits/common_type.h>
+#include <cuda/std/__type_traits/make_unsigned.h>
+#include <cuda/std/__type_traits/remove_cvref.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/__utility/integer_sequence.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/__utility/pair.h>
+#include <cuda/std/tuple>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+//! @addtogroup iterators
+//! @{
+
+template <class _Fn, class... _Iterators>
+[[nodiscard]] _CCCL_API _CCCL_CONSTEVAL auto __get_zip_transform_iterator_category()
+{
+  using _Constraints = __zip_iter_constraints<_Iterators...>;
+  if constexpr (!::cuda::std::is_reference_v<
+                  ::cuda::std::invoke_result_t<_Fn&, ::cuda::std::iter_reference_t<_Iterators>...>>)
+  {
+    return ::cuda::std::input_iterator_tag{};
+  }
+  else if constexpr (_Constraints::__all_random_access)
+  {
+    return ::cuda::std::random_access_iterator_tag{};
+  }
+  else if constexpr (_Constraints::__all_bidirectional)
+  {
+    return ::cuda::std::bidirectional_iterator_tag{};
+  }
+  else if constexpr (_Constraints::__all_forward)
+  {
+    return ::cuda::std::forward_iterator_tag{};
+  }
+  else
+  {
+    return ::cuda::std::input_iterator_tag{};
+  }
+  _CCCL_UNREACHABLE();
+}
+
+//! @brief @c zip_transform_iterator is an iterator which represents the result of a transformation of a set of
+//! sequences with a given function. This iterator is useful for creating a range filled with the result of applying an
+//! operation to another range without either explicitly storing it in memory, or explicitly executing the
+//! transformation. Using @c zip_transform_iterator facilitates kernel fusion by deferring the execution of a
+//! transformation until the value is needed while saving both memory capacity and bandwidth.
+//!
+//! @c zip_transform_iterator is morally equivalent to a combination of transform_iterator and zip_iterator
+//!
+//! @code{.cpp}
+//!   template <class Fn, class... Iterators>
+//!   using zip_transform_iterator = cuda::transform_iterator<cuda::zip_iterator<Iterators...>, cuda::zip_function<Fn>>;
+//! @endcode
+//!
+//! @c zip_transform_iterator has the additional benefit that it does not require an artificial @c zip_function to work
+//! and more importantly does not need to materialize the result of dereferencing the stored iterators when passing them
+//! to the stored function.
+//!
+//! The following code snippet demonstrates how to create a @c zip_transform_iterator which represents the result of
+//! "zipping" multiple ranges together.
+//!
+//! @code
+//! #include <cuda/iterator>
+//! #include <thrust/device_vector.h>
+//!
+//! struct SumArgs {
+//!   __host__ __device__ float operator()(float a, float b, float c) const noexcept {
+//!     return a + b + c;
+//!   }
+//! };
+//!
+//! thrust::device_vector<float> A{0.f, 1.f, 2.f};
+//! thrust::device_vector<float> B{1.f, 2.f, 3.f};
+//! thrust::device_vector<float> C{2.f, 3.f, 4.f};
+//!
+//! cuda::zip_transform_iterator iter{SumArgs{}, A.begin(), B.begin(), C.begin()};
+//!
+//! *iter;   // returns (3.f)
+//! iter[0]; // returns (3.f)
+//! iter[1]; // returns (6.f)
+//! iter[2]; // returns (9.f)
+//! // iter[3] is an out-of-bounds error
+//! @endcode
+//!
+//! This example shows how to use @c zip_transform_iterator to copy multiple ranges with a single call to @c
+//! thrust::copy.
+//!
+//! @code
+//! #include <cuda/iterator>
+//! #include <thrust/device_vector.h>
+//!
+//! int main()
+//! {
+//!   struct SumArgs {
+//!     __host__ __device__ float operator()(float a, float b, float c) const noexcept {
+//!       return a + b + c;
+//!     }
+//!   };
+//!
+//!   thrust::device_vector<float> A{0.f, 1.f, 2.f};
+//!   thrust::device_vector<float> B{1.f, 2.f, 3.f};
+//!   thrust::device_vector<float> C{2.f, 3.f, 4.f};
+//!   thrust::device_vector<float> out(3);
+//!
+//!   cuda::zip_transform_iterator iter{SumArgs{}, A.begin(), B.begin(), C.begin()}
+//!   thrust::copy(iter, iter + 3, out.begin());
+//!
+//!   // out is now [3.0f, 6.0f, 9.0f]
+//!
+//!   return 0;
+//! }
+//! @endcode
+template <class _Fn, class... _Iterators>
+class zip_transform_iterator
+{
+  ::cuda::std::ranges::__movable_box<_Fn> __func_;
+  __tuple_or_pair<_Iterators...> __current_;
+
+  template <class, class...>
+  friend class zip_transform_iterator;
+
+  template <class _Op>
+  _CCCL_API static constexpr auto
+  __zip_apply(const _Op& __op,
+              const __tuple_or_pair<_Iterators...>& __tuple1,
+              const __tuple_or_pair<_Iterators...>& __tuple2) //
+    noexcept(noexcept(__op(__tuple1, __tuple2, ::cuda::std::make_index_sequence<sizeof...(_Iterators)>())))
+  {
+    return __op(__tuple1, __tuple2, ::cuda::std::make_index_sequence<sizeof...(_Iterators)>());
+  }
+
+public:
+  //! @brief Default-constructs a @c zip_transform_iterator by value-initializing the functor and all stored iterators
+#if _CCCL_HAS_CONCEPTS()
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HIDE_FROM_ABI zip_transform_iterator()
+    requires ::cuda::std::default_initializable<_Fn>
+            && __zip_iter_constraints<_Iterators...>::__all_default_initializable
+  = default;
+#else // ^^^ _CCCL_HAS_CONCEPTS() ^^^ / vvv !_CCCL_HAS_CONCEPTS() vvv
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_TEMPLATE(class _Fn2 = _Fn)
+  _CCCL_REQUIRES(
+    ::cuda::std::default_initializable<_Fn2>&& __zip_iter_constraints<_Iterators...>::__all_default_initializable)
+  _CCCL_API constexpr zip_transform_iterator() noexcept(
+    ::cuda::std::is_nothrow_default_constructible_v<_Fn2>
+    && __zip_iter_constraints<_Iterators...>::__all_nothrow_default_constructible)
+      : __func_(::cuda::std::in_place)
+      , __current_()
+  {}
+#endif // ^^^ !_CCCL_HAS_CONCEPTS() ^^^
+
+  //! @brief Constructs a @c zip_transform_iterator from a tuple of iterators
+  //! @param __iters A tuple or pair of iterators
+  _CCCL_API constexpr explicit zip_transform_iterator(_Fn __fun, __tuple_or_pair<_Iterators...> __iters)
+      : __func_(::cuda::std::in_place, ::cuda::std::move(__fun))
+      , __current_(::cuda::std::move(__iters))
+  {}
+
+  //! @brief Constructs a @c zip_transform_iterator from a tuple of iterators
+  //! @param __iters A tuple of iterators
+  _CCCL_TEMPLATE(size_t _NumIterators = sizeof...(_Iterators))
+  _CCCL_REQUIRES((_NumIterators == 2))
+  _CCCL_API constexpr explicit zip_transform_iterator(_Fn __fun, ::cuda::std::tuple<_Iterators...> __iters)
+      : __func_(::cuda::std::in_place, ::cuda::std::move(__fun))
+      , __current_(::cuda::std::get<0>(::cuda::std::move(__iters)), ::cuda::std::get<1>(::cuda::std::move(__iters)))
+  {}
+
+  //! @brief Constructs a @c zip_transform_iterator from variadic set of iterators
+  //! @param __iters The input iterators
+  _CCCL_API constexpr explicit zip_transform_iterator(_Fn __fun, _Iterators... __iters)
+      : __func_(::cuda::std::in_place, ::cuda::std::move(__fun))
+      , __current_(::cuda::std::move(__iters)...)
+  {}
+
+  using iterator_concept  = decltype(::cuda::__get_zip_iterator_concept<_Iterators...>());
+  using iterator_category = decltype(::cuda::__get_zip_transform_iterator_category<_Fn, _Iterators...>());
+  using difference_type   = ::cuda::std::common_type_t<::cuda::std::iter_difference_t<_Iterators>...>;
+  using value_type =
+    ::cuda::std::remove_cvref_t<::cuda::std::invoke_result_t<_Fn&, ::cuda::std::iter_reference_t<_Iterators>...>>;
+
+  // Those are technically not to spec, but pre-ranges iterator_traits do not work properly with iterators that do not
+  // define all 5 aliases, see https://en.cppreference.com/w/cpp/iterator/iterator_traits.html
+  using reference = ::cuda::std::invoke_result_t<_Fn&, ::cuda::std::iter_reference_t<_Iterators>...>;
+  using pointer   = void;
+
+  // Internal helper functions to extract internals for device dispatch, must be a tuple for cub_transform_many
+  [[nodiscard]] _CCCL_API constexpr ::cuda::std::tuple<_Iterators...>
+  __base() && noexcept(::cuda::std::is_nothrow_move_constructible_v<__tuple_or_pair<_Iterators...>>)
+  {
+    return ::cuda::std::move(__current_);
+  }
+
+  [[nodiscard]] _CCCL_API constexpr _Fn __pred() && noexcept(::cuda::std::is_nothrow_move_constructible_v<_Fn>)
+  {
+    return ::cuda::std::move(*__func_);
+  }
+
+  struct __zip_transform_op_star
+  {
+    _Fn& __func_;
+
+    _CCCL_EXEC_CHECK_DISABLE
+    [[nodiscard]] _CCCL_API constexpr reference operator()(const _Iterators&... __iters) const
+      noexcept(::cuda::std::is_nothrow_invocable_v<_Fn&, ::cuda::std::iter_reference_t<const _Iterators>...>)
+    {
+      return ::cuda::std::invoke(const_cast<_Fn&>(__func_), *__iters...);
+    }
+  };
+
+  //! @brief Invokes the stored function with the result of dereferencing the stored iterators
+  [[nodiscard]] _CCCL_API constexpr reference operator*() const
+    noexcept(::cuda::std::is_nothrow_invocable_v<_Fn&, ::cuda::std::iter_reference_t<const _Iterators>...>)
+  {
+    return ::cuda::std::apply(__zip_transform_op_star{const_cast<_Fn&>(*__func_)}, __current_);
+  }
+
+  struct __zip_transform_op_subscript
+  {
+    difference_type __n_;
+    _Fn& __func_;
+
+    _CCCL_EXEC_CHECK_DISABLE
+    [[nodiscard]] _CCCL_API constexpr reference operator()(const _Iterators&... __iters) const noexcept(noexcept(
+      ::cuda::std::invoke(const_cast<_Fn&>(__func_), __iters[::cuda::std::iter_difference_t<_Iterators>(__n_)]...)))
+    {
+      return ::cuda::std::invoke(
+        const_cast<_Fn&>(__func_), __iters[::cuda::std::iter_difference_t<_Iterators>(__n_)]...);
+    }
+  };
+
+  //! @brief Invokes the stored function with the result of dereferencing the stored iterators advanced by an offset
+  //! @param __n The additional offset
+  _CCCL_TEMPLATE(class _Constraints = __zip_iter_constraints<_Iterators...>)
+  _CCCL_REQUIRES(_Constraints::__all_random_access)
+  _CCCL_API constexpr reference operator[](difference_type __n) const
+    noexcept(noexcept(::cuda::std::apply(__zip_transform_op_subscript{__n, const_cast<_Fn&>(*__func_)}, __current_)))
+  {
+    return ::cuda::std::apply(__zip_transform_op_subscript{__n, const_cast<_Fn&>(*__func_)}, __current_);
+  }
+
+  //! @brief Increments all stored iterators
+  _CCCL_API constexpr zip_transform_iterator&
+  operator++() noexcept(noexcept(::cuda::std::apply(__zip_op_increment{}, __current_)))
+  {
+    ::cuda::std::apply(__zip_op_increment{}, __current_);
+    return *this;
+  }
+
+  //! @brief Increments all stored iterators
+  //! @returns A copy of the original @c zip_transform_iterator if possible
+  _CCCL_API constexpr auto operator++(int)
+  {
+    if constexpr (__zip_iter_constraints<_Iterators...>::__all_forward)
+    {
+      auto __tmp = *this;
+      ++*this;
+      return __tmp;
+    }
+    else
+    {
+      ++*this;
+    }
+  }
+
+  //! @brief Decrements all stored iterators
+  _CCCL_TEMPLATE(class _Constraints = __zip_iter_constraints<_Iterators...>)
+  _CCCL_REQUIRES(_Constraints::__all_bidirectional)
+  _CCCL_API constexpr zip_transform_iterator&
+  operator--() noexcept(noexcept(::cuda::std::apply(__zip_op_decrement{}, __current_)))
+  {
+    ::cuda::std::apply(__zip_op_decrement{}, __current_);
+    return *this;
+  }
+
+  //! @brief Decrements all stored iterators
+  _CCCL_TEMPLATE(class _Constraints = __zip_iter_constraints<_Iterators...>)
+  _CCCL_REQUIRES(_Constraints::__all_bidirectional)
+  _CCCL_API constexpr zip_transform_iterator operator--(int)
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  struct __zip_op_pe
+  {
+    difference_type __n;
+
+    _CCCL_EXEC_CHECK_DISABLE
+    _CCCL_API constexpr void operator()(_Iterators&... __iters) const
+      noexcept(noexcept(((void) (__iters += ::cuda::std::iter_difference_t<_Iterators>(__n)), ...)))
+    {
+      ((void) (__iters += ::cuda::std::iter_difference_t<_Iterators>(__n)), ...);
+    }
+  };
+
+  //! @brief Increments all stored iterators by a given number of elements
+  //! @param __n The number of elements to increment
+  _CCCL_TEMPLATE(class _Constraints = __zip_iter_constraints<_Iterators...>)
+  _CCCL_REQUIRES(_Constraints::__all_random_access)
+  _CCCL_API constexpr zip_transform_iterator&
+  operator+=(difference_type __n) noexcept(noexcept(::cuda::std::apply(__zip_op_pe{__n}, __current_)))
+  {
+    ::cuda::std::apply(__zip_op_pe{__n}, __current_);
+    return *this;
+  }
+
+  struct __zip_op_me
+  {
+    difference_type __n;
+
+    _CCCL_EXEC_CHECK_DISABLE
+    _CCCL_API constexpr void operator()(_Iterators&... __iters) const
+      noexcept(noexcept(((void) (__iters -= ::cuda::std::iter_difference_t<_Iterators>(__n)), ...)))
+    {
+      ((void) (__iters -= ::cuda::std::iter_difference_t<_Iterators>(__n)), ...);
+    }
+  };
+
+  //! @brief Decrements all stored iterators by a given number of elements
+  //! @param __n The number of elements to decrement
+  _CCCL_TEMPLATE(class _Constraints = __zip_iter_constraints<_Iterators...>)
+  _CCCL_REQUIRES(_Constraints::__all_random_access)
+  _CCCL_API constexpr zip_transform_iterator& operator-=(difference_type __n)
+  {
+    ::cuda::std::apply(__zip_op_me{__n}, __current_);
+    return *this;
+  }
+
+  //! @brief Returns a copy of a @c zip_transform_iterator incremented by a given number of elements
+  //! @param __iter The @c zip_transform_iterator to increment
+  //! @param __n The number of elements to increment
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator+(const zip_transform_iterator& __iter, difference_type __n)
+    _CCCL_TRAILING_REQUIRES(zip_transform_iterator)(_Constraints::__all_random_access)
+  {
+    auto __rhs = __iter;
+    __rhs += __n;
+    return __rhs;
+  }
+
+  //! @brief Returns a copy of a @c zip_transform_iterator incremented by a given number of elements
+  //! @param __n The number of elements to increment
+  //! @param __iter The @c zip_transform_iterator to increment
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator+(difference_type __n, const zip_transform_iterator& __iter)
+    _CCCL_TRAILING_REQUIRES(zip_transform_iterator)(_Constraints::__all_random_access)
+  {
+    return __iter + __n;
+  }
+
+  //! @brief Returns a copy of a @c zip_transform_iterator decremented by a given number of elements
+  //! @param __n The number of elements to decrement
+  //! @param __iter The @c zip_transform_iterator to decrement
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator-(const zip_transform_iterator& __iter, difference_type __n)
+    _CCCL_TRAILING_REQUIRES(zip_transform_iterator)(_Constraints::__all_random_access)
+  {
+    auto __rhs = __iter;
+    __rhs -= __n;
+    return __rhs;
+  }
+
+  struct __zip_op_minus
+  {
+    struct __less_abs
+    {
+      // abs in cstdlib is not constexpr
+      _CCCL_EXEC_CHECK_DISABLE
+      [[nodiscard]] _CCCL_API static constexpr difference_type
+      __abs(difference_type __t) noexcept(noexcept(__t < 0 ? -__t : __t))
+      {
+        return __t < 0 ? -__t : __t;
+      }
+
+      _CCCL_EXEC_CHECK_DISABLE
+      [[nodiscard]] _CCCL_API constexpr bool operator()(difference_type __n, difference_type __y) const
+        noexcept(noexcept(__abs(__n) < __abs(__y)))
+      {
+        return __abs(__n) < __abs(__y);
+      }
+    };
+
+    _CCCL_EXEC_CHECK_DISABLE
+    template <size_t _Zero, size_t... _Indices>
+    [[nodiscard]] _CCCL_API constexpr difference_type
+    operator()(const __tuple_or_pair<_Iterators...>& __iters1,
+               const __tuple_or_pair<_Iterators...>& __iters2,
+               ::cuda::std::index_sequence<_Zero, _Indices...>) const //
+      noexcept(noexcept(((::cuda::std::get<_Indices>(__iters1) - ::cuda::std::get<_Indices>(__iters2)) && ...)))
+    {
+      const auto __first = static_cast<difference_type>(::cuda::std::get<0>(__iters1) - ::cuda::std::get<0>(__iters2));
+      if (__first == 0)
+      {
+        return __first;
+      }
+
+      const difference_type __temp[] = {
+        __first,
+        static_cast<difference_type>(::cuda::std::get<_Indices>(__iters1) - ::cuda::std::get<_Indices>(__iters2))...};
+      return *::cuda::std::ranges::min_element(__temp, __zip_op_minus::__less_abs{});
+    }
+  };
+
+  //! @brief Returns the distance between two @c zip_transform_iterators
+  //! @returns The minimal distance between any of the stored iterators
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator-(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
+    _CCCL_TRAILING_REQUIRES(difference_type)(_Constraints::__all_sized_sentinel)
+  {
+    return __zip_apply(__zip_op_minus{}, __n.__current_, __y.__current_);
+  }
+
+  struct __zip_op_eq
+  {
+    _CCCL_EXEC_CHECK_DISABLE
+    template <size_t... _Indices>
+    _CCCL_API constexpr bool operator()(const __tuple_or_pair<_Iterators...>& __iters1,
+                                        const __tuple_or_pair<_Iterators...>& __iters2,
+                                        ::cuda::std::index_sequence<_Indices...>) const
+      noexcept(noexcept(((::cuda::std::get<_Indices>(__iters1) == ::cuda::std::get<_Indices>(__iters2)) || ...)))
+    {
+      return ((::cuda::std::get<_Indices>(__iters1) == ::cuda::std::get<_Indices>(__iters2)) || ...);
+    }
+  };
+
+  //! @brief Compares two @c zip_transform_iterator for equality by comparing the tuple of stored iterators
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator==(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
+    _CCCL_TRAILING_REQUIRES(bool)(_Constraints::__all_equality_comparable)
+  {
+    if constexpr (_Constraints::__all_bidirectional)
+    {
+      return __n.__current_ == __y.__current_;
+    }
+    else
+    {
+      return __zip_apply(__zip_op_eq{}, __n.__current_, __y.__current_);
+    }
+    _CCCL_UNREACHABLE();
+  }
+
+#if _CCCL_STD_VER <= 2017
+  //! @brief Compares two @c zip_transform_iterator for inequality by comparing the tuple of stored iterators
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator!=(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
+    _CCCL_TRAILING_REQUIRES(bool)(_Constraints::__all_equality_comparable)
+  {
+    if constexpr (_Constraints::__all_bidirectional)
+    {
+      return __n.__current_ != __y.__current_;
+    }
+    else
+    {
+      return !__zip_apply(__zip_op_eq{}, __n.__current_, __y.__current_);
+    }
+    _CCCL_UNREACHABLE();
+  }
+#endif // _CCCL_STD_VER <= 2017
+
+#if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+  //! @brief Three-way compares two @c zip_transform_iterator by comparing the tuple of stored iterators
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator<=>(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
+    _CCCL_TRAILING_REQUIRES(bool)(_Constraints::__all_random_access&& _Constraints::__all_three_way_comparable)
+  {
+    return __n.__current_ <=> __y.__current_;
+  }
+
+#else // ^^^ _LIBCUDACXX_HAS_SPACESHIP_OPERATOR() ^^^ / vvv !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR() vvv
+
+  //! @brief Compares two @c zip_transform_iterator for less than by comparing the tuple of stored iterators
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator<(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
+    _CCCL_TRAILING_REQUIRES(bool)(_Constraints::__all_random_access)
+  {
+    return __n.__current_ < __y.__current_;
+  }
+
+  //! @brief Compares two @c zip_transform_iterator for greater than by comparing the tuple of stored iterators
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator>(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
+    _CCCL_TRAILING_REQUIRES(bool)(_Constraints::__all_random_access)
+  {
+    return __y < __n;
+  }
+
+  //! @brief Compares two @c zip_transform_iterator for less equal by comparing the tuple of stored iterators
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator<=(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
+    _CCCL_TRAILING_REQUIRES(bool)(_Constraints::__all_random_access)
+  {
+    return !(__y < __n);
+  }
+
+  //! @brief Compares two @c zip_transform_iterator for greater equal by comparing the tuple of stored iterators
+  template <class _Constraints = __zip_iter_constraints<_Iterators...>>
+  _CCCL_API friend constexpr auto operator>=(const zip_transform_iterator& __n, const zip_transform_iterator& __y)
+    _CCCL_TRAILING_REQUIRES(bool)(_Constraints::__all_random_access)
+  {
+    return !(__n < __y);
+  }
+#endif // !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+};
+
+template <class _Fn, class... _Iterators>
+_CCCL_HOST_DEVICE zip_transform_iterator(_Fn, ::cuda::std::tuple<_Iterators...>)
+  -> zip_transform_iterator<_Fn, _Iterators...>;
+
+template <class _Fn, class _Iterator1, class _Iterator2>
+_CCCL_HOST_DEVICE zip_transform_iterator(_Fn, ::cuda::std::pair<_Iterator1, _Iterator2>)
+  -> zip_transform_iterator<_Fn, _Iterator1, _Iterator2>;
+
+template <class _Fn, class... _Iterators>
+_CCCL_HOST_DEVICE zip_transform_iterator(_Fn, _Iterators...) -> zip_transform_iterator<_Fn, _Iterators...>;
+
+//! @brief Creates a @c zip_transform_iterator from a tuple of iterators.
+//! @param __t The tuple of iterators to wrap
+template <class _Fn, class... _Iterators>
+[[nodiscard]] _CCCL_API constexpr auto
+make_zip_transform_iterator(_Fn __fun, ::cuda::std::tuple<_Iterators...> __t) noexcept(
+  ::cuda::std::is_nothrow_move_constructible_v<_Fn>
+  && __zip_iter_constraints<_Iterators...>::__all_nothrow_move_constructible)
+{
+  return zip_transform_iterator<_Fn, _Iterators...>{::cuda::std::move(__fun), ::cuda::std::move(__t)};
+}
+
+//! @brief Creates a @c zip_transform_iterator from a variadic number of iterators.
+//! @param __iters The iterators to wrap
+template <class _Fn, class... _Iterators>
+[[nodiscard]] _CCCL_API constexpr auto make_zip_transform_iterator(_Fn __fun, _Iterators... __iters) noexcept(
+  ::cuda::std::is_nothrow_move_constructible_v<_Fn>
+  && __zip_iter_constraints<_Iterators...>::__all_nothrow_move_constructible)
+{
+  return zip_transform_iterator<_Fn, _Iterators...>{::cuda::std::move(__fun), ::cuda::std::move(__iters)...};
+}
+
+//! @}
+
+_CCCL_END_NAMESPACE_CUDA
+
+// GCC and MSVC2019 have issues determining __is_fancy_pointer in C++17 because they fail to instantiate pointer_traits
+#if (_CCCL_COMPILER(GCC) || _CCCL_COMPILER(MSVC)) && _CCCL_STD_VER <= 2017
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+template <class _Fn, class... _Iterators>
+inline constexpr bool __is_fancy_pointer<::cuda::zip_transform_iterator<_Fn, _Iterators...>> = false;
+_CCCL_END_NAMESPACE_CUDA_STD
+#endif // (_CCCL_COMPILER(GCC) || _CCCL_COMPILER(MSVC)) && _CCCL_STD_VER <= 2017
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA___ITERATOR_ZIP_TRANSFORM_ITERATOR_H

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

@@ -21,6 +21,7 @@
 #  pragma system_header
 #endif // no system header
 
+#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>
@@ -107,10 +108,11 @@ class __host_accessor : public _Accessor
 #if _CCCL_HAS_CTK()
     if constexpr (::cuda::std::contiguous_iterator<__data_handle_type>)
     {
-      ::cudaPointerAttributes __ptr_attrib{};
       auto __p1 = ::cuda::std::to_address(__p);
-      _CCCL_ASSERT_CUDA_API(::cudaPointerGetAttributes, "cudaPointerGetAttributes failed", &__ptr_attrib, __p1);
-      return __ptr_attrib.hostPointer != nullptr || __ptr_attrib.type == ::cudaMemoryTypeUnregistered;
+      ::CUmemorytype __type{};
+      const auto __status =
+        ::cuda::__driver::__pointerGetAttributeNoThrow<::CU_POINTER_ATTRIBUTE_MEMORY_TYPE>(__type, __p1);
+      return (__status != ::cudaSuccess) || __type == ::CU_MEMORYTYPE_HOST;
     }
     else
 #endif // _CCCL_HAS_CTK()
@@ -223,10 +225,11 @@ class __device_accessor : public _Accessor
 #if _CCCL_HAS_CTK()
     if constexpr (::cuda::std::contiguous_iterator<__data_handle_type>)
     {
-      ::cudaPointerAttributes __ptr_attrib{};
       auto __p1 = ::cuda::std::to_address(__p);
-      _CCCL_ASSERT_CUDA_API(::cudaPointerGetAttributes, "cudaPointerGetAttributes failed", &__ptr_attrib, __p1);
-      return __ptr_attrib.devicePointer != nullptr || __ptr_attrib.type == ::cudaMemoryTypeUnregistered;
+      ::CUmemorytype __type{};
+      const auto __status =
+        ::cuda::__driver::__pointerGetAttributeNoThrow<::CU_POINTER_ATTRIBUTE_MEMORY_TYPE>(__type, __p1);
+      return (__status != ::cudaSuccess) || __type == ::CU_MEMORYTYPE_DEVICE;
     }
     else
 #endif // _CCCL_HAS_CTK()
@@ -352,10 +355,11 @@ class __managed_accessor : public _Accessor
 #if _CCCL_HAS_CTK()
     if constexpr (::cuda::std::contiguous_iterator<__data_handle_type>)
     {
-      ::cudaPointerAttributes __ptr_attrib{};
-      auto __p1 = ::cuda::std::to_address(__p);
-      _CCCL_ASSERT_CUDA_API(::cudaPointerGetAttributes, "cudaPointerGetAttributes failed", &__ptr_attrib, __p1);
-      return __ptr_attrib.devicePointer != nullptr && __ptr_attrib.hostPointer == __ptr_attrib.devicePointer;
+      const auto __p1 = ::cuda::std::to_address(__p);
+      bool __is_managed{};
+      const auto __status =
+        ::cuda::__driver::__pointerGetAttributeNoThrow<::CU_POINTER_ATTRIBUTE_IS_MANAGED>(__is_managed, __p1);
+      return (__status != ::cudaSuccess) || __is_managed;
     }
     else
 #endif // _CCCL_HAS_CTK()

cuda/cccl/headers/include/cuda/__runtime/ensure_current_context.h

@@ -11,7 +11,7 @@
 #ifndef _CUDA___RUNTIME_ENSURE_CURRENT_CONTEXT_H
 #define _CUDA___RUNTIME_ENSURE_CURRENT_CONTEXT_H
 
-#include <cuda/__cccl_config>
+#include <cuda/std/detail/__config>
 
 #if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
 #  pragma GCC system_header
@@ -23,7 +23,8 @@
 
 #if _CCCL_HAS_CTK() && !_CCCL_COMPILER(NVRTC)
 
-#  include <cuda/__device/all_devices.h>
+#  include <cuda/__device/device_ref.h>
+#  include <cuda/__device/physical_device.h>
 #  include <cuda/__driver/driver_api.h>
 
 #  include <cuda/std/__cccl/prologue.h>
@@ -46,7 +47,7 @@ struct [[maybe_unused]] __ensure_current_context
   //! @throws cuda_error if the context switch fails
   explicit __ensure_current_context(device_ref __new_device)
   {
-    auto __ctx = devices[__new_device.get()].primary_context();
+    auto __ctx = ::cuda::__physical_devices()[__new_device.get()].__primary_context();
     ::cuda::__driver::__ctxPush(__ctx);
   }
 

cuda/cccl/headers/include/cuda/__runtime/types.h

@@ -29,7 +29,7 @@ _CCCL_BEGIN_NAMESPACE_CUDA
 
 using memory_location = ::cudaMemLocation;
 #  if _CCCL_CTK_AT_LEAST(12, 2)
-inline constexpr memory_location host_memory_location = {cudaMemLocationTypeHost, 0};
+inline constexpr memory_location host_memory_location = {::cudaMemLocationTypeHost, 0};
 #  endif // _CCCL_CTK_AT_LEAST(12, 2)
 
 _CCCL_END_NAMESPACE_CUDA