Add files using upload-large-folder tool

.gitattributes

@@ -1768,3 +1768,4 @@ videollama2/lib/python3.10/site-packages/scipy.libs/libscipy_openblas-c128ec02.s
 vllm/lib/python3.10/site-packages/cupy/_core/flags.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/cupy/_core/_accelerator.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/cupy/_core/_fusion_kernel.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+vllm/lib/libcrypto.so filter=lfs diff=lfs merge=lfs -text

vllm/lib/libcrypto.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3a22a04cfb89e45ac9fabc0c71c3935ea24c47178c4390c492cb458dca935df
+size 5172040

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__atomic/atomic.h

@@ -0,0 +1,141 @@
+// -*- 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) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___ATOMIC_ATOMIC_H
+#define _CUDA___ATOMIC_ATOMIC_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/atomic>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+// atomic<T>
+
+template <class _Tp, thread_scope _Sco = thread_scope::thread_scope_system>
+struct atomic : public _CUDA_VSTD::__atomic_impl<_Tp, _Sco>
+{
+  using value_type = _Tp;
+
+  _CCCL_HIDE_FROM_ABI constexpr atomic() noexcept = default;
+
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr atomic(_Tp __d) noexcept
+      : _CUDA_VSTD::__atomic_impl<_Tp, _Sco>(__d)
+  {}
+
+  atomic(const atomic&)                     = delete;
+  atomic& operator=(const atomic&)          = delete;
+  atomic& operator=(const atomic&) volatile = delete;
+
+  _LIBCUDACXX_HIDE_FROM_ABI _Tp operator=(_Tp __d) volatile noexcept
+  {
+    this->store(__d);
+    return __d;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI _Tp operator=(_Tp __d) noexcept
+  {
+    this->store(__d);
+    return __d;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _Tp fetch_max(const _Tp& __op, memory_order __m = memory_order_seq_cst) noexcept
+  {
+    return _CUDA_VSTD::__atomic_fetch_max_dispatch(&this->__a, __op, __m, _CUDA_VSTD::__scope_to_tag<_Sco>{});
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI _Tp fetch_max(const _Tp& __op, memory_order __m = memory_order_seq_cst) volatile noexcept
+  {
+    return _CUDA_VSTD::__atomic_fetch_max_dispatch(&this->__a, __op, __m, _CUDA_VSTD::__scope_to_tag<_Sco>{});
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _Tp fetch_min(const _Tp& __op, memory_order __m = memory_order_seq_cst) noexcept
+  {
+    return _CUDA_VSTD::__atomic_fetch_min_dispatch(&this->__a, __op, __m, _CUDA_VSTD::__scope_to_tag<_Sco>{});
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI _Tp fetch_min(const _Tp& __op, memory_order __m = memory_order_seq_cst) volatile noexcept
+  {
+    return _CUDA_VSTD::__atomic_fetch_min_dispatch(&this->__a, __op, __m, _CUDA_VSTD::__scope_to_tag<_Sco>{});
+  }
+};
+
+// atomic_ref<T>
+
+template <class _Tp, thread_scope _Sco = thread_scope::thread_scope_system>
+struct atomic_ref : public _CUDA_VSTD::__atomic_ref_impl<_Tp, _Sco>
+{
+  using value_type = _Tp;
+
+  static constexpr size_t required_alignment = sizeof(_Tp);
+
+  static constexpr bool is_always_lock_free = sizeof(_Tp) <= 8;
+
+  _LIBCUDACXX_HIDE_FROM_ABI explicit constexpr atomic_ref(_Tp& __ref)
+      : _CUDA_VSTD::__atomic_ref_impl<_Tp, _Sco>(__ref)
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI _Tp operator=(_Tp __v) const noexcept
+  {
+    this->store(__v);
+    return __v;
+  }
+
+  _CCCL_HIDE_FROM_ABI atomic_ref(const atomic_ref&) noexcept = default;
+  atomic_ref& operator=(const atomic_ref&)                   = delete;
+  atomic_ref& operator=(const atomic_ref&) const             = delete;
+
+  _LIBCUDACXX_HIDE_FROM_ABI _Tp fetch_max(const _Tp& __op, memory_order __m = memory_order_seq_cst) const noexcept
+  {
+    return _CUDA_VSTD::__atomic_fetch_max_dispatch(&this->__a, __op, __m, _CUDA_VSTD::__scope_to_tag<_Sco>{});
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _Tp fetch_min(const _Tp& __op, memory_order __m = memory_order_seq_cst) const noexcept
+  {
+    return _CUDA_VSTD::__atomic_fetch_min_dispatch(&this->__a, __op, __m, _CUDA_VSTD::__scope_to_tag<_Sco>{});
+  }
+};
+
+inline _CCCL_HOST_DEVICE void
+atomic_thread_fence(memory_order __m, thread_scope _Scope = thread_scope::thread_scope_system)
+{
+  NV_DISPATCH_TARGET(
+    NV_IS_DEVICE,
+    (switch (_Scope) {
+      case thread_scope::thread_scope_system:
+        _CUDA_VSTD::__atomic_thread_fence_cuda((int) __m, __thread_scope_system_tag{});
+        break;
+      case thread_scope::thread_scope_device:
+        _CUDA_VSTD::__atomic_thread_fence_cuda((int) __m, __thread_scope_device_tag{});
+        break;
+      case thread_scope::thread_scope_block:
+        _CUDA_VSTD::__atomic_thread_fence_cuda((int) __m, __thread_scope_block_tag{});
+        break;
+      // Atomics scoped to themselves do not require fencing
+      case thread_scope::thread_scope_thread:
+        break;
+    }),
+    NV_IS_HOST,
+    ((void) _Scope; _CUDA_VSTD::atomic_thread_fence(__m);))
+}
+
+inline _CCCL_HOST_DEVICE void atomic_signal_fence(memory_order __m)
+{
+  _CUDA_VSTD::atomic_signal_fence(__m);
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CUDA___ATOMIC_ATOMIC_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__cmath/ceil_div.h

@@ -0,0 +1,86 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___CMATH_CEIL_DIV_H
+#define _CUDA___CMATH_CEIL_DIV_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/__type_traits/common_type.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/is_enum.h>
+#include <cuda/std/__type_traits/is_integral.h>
+#include <cuda/std/__type_traits/is_signed.h>
+#include <cuda/std/__type_traits/is_unsigned.h>
+#include <cuda/std/__type_traits/make_unsigned.h>
+#include <cuda/std/__type_traits/underlying_type.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+//! @brief Divides two numbers \p __a and \p __b, rounding up if there is a remainder
+//! @param __a The dividend
+//! @param __b The divisor
+//! @pre \p __a must be non-negative
+//! @pre \p __b must be positive
+template <class _Tp,
+          class _Up,
+          _CUDA_VSTD::enable_if_t<_CCCL_TRAIT(_CUDA_VSTD::is_unsigned, _Tp), int> = 0,
+          _CUDA_VSTD::enable_if_t<_CCCL_TRAIT(_CUDA_VSTD::is_integral, _Up), int> = 0>
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 _Tp ceil_div(const _Tp __a, const _Up __b) noexcept
+{
+  _CCCL_ASSERT(__b > _Up(0), "cuda::ceil_div: b must be positive");
+  using _UCommon   = _CUDA_VSTD::make_unsigned_t<_CUDA_VSTD::common_type_t<_Tp, _Up>>;
+  const auto __res = static_cast<_UCommon>(__a) / static_cast<_UCommon>(__b);
+  return static_cast<_Tp>(__res + (__res * static_cast<_UCommon>(__b) != static_cast<_UCommon>(__a)));
+}
+
+//! @brief Divides two numbers \p __a and \p __b, rounding up if there is a remainder
+//! @param __a The dividend
+//! @param __b The divisor
+//! @pre \p __a must be non-negative
+//! @pre \p __b must be positive
+template <class _Tp,
+          class _Up,
+          _CUDA_VSTD::enable_if_t<_CCCL_TRAIT(_CUDA_VSTD::is_signed, _Tp), int>   = 0,
+          _CUDA_VSTD::enable_if_t<_CCCL_TRAIT(_CUDA_VSTD::is_integral, _Up), int> = 0>
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 _Tp ceil_div(const _Tp __a, const _Up __b) noexcept
+{
+  _CCCL_ASSERT(__a >= _Tp(0), "cuda::ceil_div: a must be non negative");
+  _CCCL_ASSERT(__b > _Up(0), "cuda::ceil_div: b must be positive");
+  using _UCommon = _CUDA_VSTD::make_unsigned_t<_CUDA_VSTD::common_type_t<_Tp, _Up>>;
+  // Due to the precondition `__a >= 0` we can safely cast to unsigned without danger of overflowing
+  return static_cast<_Tp>((static_cast<_UCommon>(__a) + static_cast<_UCommon>(__b) - 1) / static_cast<_UCommon>(__b));
+}
+
+//! @brief Divides two numbers \p __a and \p __b, rounding up if there is a remainder, \p __b is an enum
+//! @param __a The dividend
+//! @param __b The divisor
+//! @pre \p __a must be non-negative
+//! @pre \p __b must be positive
+template <class _Tp,
+          class _Up,
+          _CUDA_VSTD::enable_if_t<_CCCL_TRAIT(_CUDA_VSTD::is_integral, _Tp), int> = 0,
+          _CUDA_VSTD::enable_if_t<_CCCL_TRAIT(_CUDA_VSTD::is_enum, _Up), int>     = 0>
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 _Tp ceil_div(const _Tp __a, const _Up __b) noexcept
+{
+  return ::cuda::ceil_div(__a, static_cast<_CUDA_VSTD::underlying_type_t<_Up>>(__b));
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CUDA___CMATH_CEIL_DIV_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__latch/latch.h

@@ -0,0 +1,40 @@
+// -*- 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) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __CUDA__LATCH_LATCH_H
+#define __CUDA__LATCH_LATCH_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/__latch/latch.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+template <thread_scope _Sco>
+class latch : public _CUDA_VSTD::__latch_base<_Sco>
+{
+public:
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr latch(_CUDA_VSTD::ptrdiff_t __count)
+      : _CUDA_VSTD::__latch_base<_Sco>(__count)
+  {}
+};
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // __CUDA__LATCH_LATCH_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/completion_mechanism.h

@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___BARRIER_COMPLETION_MECHANISM_H
+#define _CUDA___BARRIER_COMPLETION_MECHANISM_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
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+//! @brief __completion_mechanism allows memcpy_async to report back what completion
+//! mechanism it used. This is necessary to determine in which way to synchronize
+//! the memcpy_async with a sync object (barrier or pipeline).
+//
+//! In addition, we use this enum to create bit flags so that calling functions
+//! can specify which completion mechanisms can be used (__sync is always
+//! allowed).
+enum class __completion_mechanism
+{
+  __sync                 = 0,
+  __mbarrier_complete_tx = 1 << 0, // Use powers of two here to support the
+  __async_group          = 1 << 1, // bit flag use case
+  __async_bulk_group     = 1 << 2,
+};
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CUDA___BARRIER_COMPLETION_MECHANISM_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/cp_async_bulk_shared_global.h

@@ -0,0 +1,56 @@
+// -*- 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_PTX__MEMCPY_ASYNC_CP_ASYNC_BULK_SHARED_GLOBAL_H_
+#define _CUDA_PTX__MEMCPY_ASYNC_CP_ASYNC_BULK_SHARED_GLOBAL_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_HAS_CUDA_COMPILER
+#  if __cccl_ptx_isa >= 800
+
+#    include <cuda/__ptx/instructions/cp_async_bulk.h>
+#    include <cuda/__ptx/ptx_dot_variants.h>
+#    include <cuda/__ptx/ptx_helper_functions.h>
+#    include <cuda/std/cstdint>
+
+#    include <nv/target>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+extern "C" _CCCL_DEVICE void __cuda_ptx_cp_async_bulk_shared_global_is_not_supported_before_SM_90__();
+template <typename _Group>
+inline __device__ void __cp_async_bulk_shared_global(
+  const _Group& __g, char* __dest, const char* __src, _CUDA_VSTD::size_t __size, _CUDA_VSTD::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_VPTX::cp_async_bulk(
+                        _CUDA_VPTX::space_cluster, _CUDA_VPTX::space_global, __dest, __src, __size, __bar_handle);
+                    }),
+                    (__cuda_ptx_cp_async_bulk_shared_global_is_not_supported_before_SM_90__();));
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#  endif // __cccl_ptx_isa >= 800
+#endif // _CCCL_CUDA_COMPILER
+
+#endif // _CUDA_PTX__MEMCPY_ASYNC_CP_ASYNC_BULK_SHARED_GLOBAL_H_

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/cp_async_fallback.h

@@ -0,0 +1,68 @@
+// -*- 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_PTX__MEMCPY_ASYNC_CP_ASYNC_FALLBACK_H_
+#define _CUDA_PTX__MEMCPY_ASYNC_CP_ASYNC_FALLBACK_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/cstddef>
+
+#include <nv/target>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+template <_CUDA_VSTD::size_t _Copy_size>
+struct __copy_chunk
+{
+  _CCCL_ALIGNAS(_Copy_size) char data[_Copy_size];
+};
+
+template <_CUDA_VSTD::size_t _Alignment, typename _Group>
+inline _CCCL_HOST_DEVICE void
+__cp_async_fallback_mechanism(_Group __g, char* __dest, const char* __src, _CUDA_VSTD::size_t __size)
+{
+  // Maximal copy size is 16 bytes
+  constexpr _CUDA_VSTD::size_t __copy_size = (_Alignment > 16) ? 16 : _Alignment;
+
+  using __chunk_t = __copy_chunk<__copy_size>;
+
+  // "Group"-strided loop over memory
+  const _CUDA_VSTD::size_t __stride = __g.size() * __copy_size;
+
+  // An unroll factor of 64 ought to be enough for anybody. This unroll pragma
+  // is mainly intended to place an upper bound on loop unrolling. The number
+  // is more than high enough for the intended use case: an unroll factor of
+  // 64 allows moving 4 * 64 * 256 = 64kb in one unrolled loop with 256
+  // threads (copying ints). On the other hand, in the unfortunate case that
+  // we have to move 1024 bytes / thread with char width, then we prevent
+  // fully unrolling the loop to 1024 copy instructions. This prevents the
+  // compile times from increasing unreasonably, and also has negligible
+  // impact on runtime performance.
+  _LIBCUDACXX_PRAGMA_UNROLL(64)
+  for (_CUDA_VSTD::size_t __offset = __g.thread_rank() * __copy_size; __offset < __size; __offset += __stride)
+  {
+    __chunk_t tmp                                    = *reinterpret_cast<const __chunk_t*>(__src + __offset);
+    *reinterpret_cast<__chunk_t*>(__dest + __offset) = tmp;
+  }
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CUDA_PTX__MEMCPY_ASYNC_CP_ASYNC_FALLBACK_H_

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/cp_async_shared_global.h

@@ -0,0 +1,102 @@
+// -*- 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_PTX__MEMCPY_ASYNC_CP_ASYNC_SHARED_GLOBAL_H_
+#define _CUDA_PTX__MEMCPY_ASYNC_CP_ASYNC_SHARED_GLOBAL_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_HAS_CUDA_COMPILER
+
+#  include <cuda/__ptx/ptx_dot_variants.h>
+#  include <cuda/__ptx/ptx_helper_functions.h>
+#  include <cuda/std/cstdint>
+
+#  include <nv/target>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+extern "C" _CCCL_DEVICE void __cuda_ptx_cp_async_shared_global_is_not_supported_before_SM_80__();
+template <size_t _Copy_size>
+inline __device__ void __cp_async_shared_global(char* __dest, const char* __src)
+{
+  // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async
+
+  // If `if constexpr` is not available, this function gets instantiated even
+  // if is not called. Do not static_assert in that case.
+#  if _CCCL_STD_VER >= 2017
+  static_assert(_Copy_size == 4 || _Copy_size == 8 || _Copy_size == 16,
+                "cp.async.shared.global requires a copy size of 4, 8, or 16.");
+#  endif // _CCCL_STD_VER >= 2017
+
+  NV_IF_ELSE_TARGET(
+    NV_PROVIDES_SM_80,
+    (asm volatile("cp.async.ca.shared.global [%0], [%1], %2, %2;"
+                  :
+                  : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(__dest))),
+                    "l"(static_cast<_CUDA_VSTD::uint64_t>(__cvta_generic_to_global(__src))),
+                    "n"(_Copy_size)
+                  : "memory");),
+    (__cuda_ptx_cp_async_shared_global_is_not_supported_before_SM_80__();));
+}
+
+template <>
+inline __device__ void __cp_async_shared_global<16>(char* __dest, const char* __src)
+{
+  // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async
+  // When copying 16 bytes, it is possible to skip L1 cache (.cg).
+  NV_IF_ELSE_TARGET(
+    NV_PROVIDES_SM_80,
+    (asm volatile("cp.async.cg.shared.global [%0], [%1], %2, %2;"
+                  :
+                  : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(__dest))),
+                    "l"(static_cast<_CUDA_VSTD::uint64_t>(__cvta_generic_to_global(__src))),
+                    "n"(16)
+                  : "memory");),
+    (__cuda_ptx_cp_async_shared_global_is_not_supported_before_SM_80__();));
+}
+
+template <size_t _Alignment, typename _Group>
+inline __device__ void
+__cp_async_shared_global_mechanism(_Group __g, char* __dest, const char* __src, _CUDA_VSTD::size_t __size)
+{
+  // If `if constexpr` is not available, this function gets instantiated even
+  // if is not called. Do not static_assert in that case.
+#  if _CCCL_STD_VER >= 2017
+  static_assert(4 <= _Alignment, "cp.async requires at least 4-byte alignment");
+#  endif // _CCCL_STD_VER >= 2017
+
+  // Maximal copy size is 16.
+  constexpr int __copy_size = (_Alignment > 16) ? 16 : _Alignment;
+  // We use an int offset here, because we are copying to shared memory,
+  // which is easily addressable using int.
+  const int __group_size = __g.size();
+  const int __group_rank = __g.thread_rank();
+  const int __stride     = __group_size * __copy_size;
+  for (int __offset = __group_rank * __copy_size; __offset < static_cast<int>(__size); __offset += __stride)
+  {
+    __cp_async_shared_global<__copy_size>(__dest + __offset, __src + __offset);
+  }
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CCCL_CUDA_COMPILER
+
+#endif // _CUDA_PTX__MEMCPY_ASYNC_CP_ASYNC_SHARED_GLOBAL_H_

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/dispatch_memcpy_async.h

@@ -0,0 +1,157 @@
+// -*- 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_PTX__MEMCPY_ASYNC_DISPATCH_MEMCPY_ASYNC_H_
+#define _CUDA_PTX__MEMCPY_ASYNC_DISPATCH_MEMCPY_ASYNC_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/__memcpy_async/completion_mechanism.h>
+#include <cuda/__memcpy_async/cp_async_bulk_shared_global.h>
+#include <cuda/__memcpy_async/cp_async_fallback.h>
+#include <cuda/__memcpy_async/cp_async_shared_global.h>
+#include <cuda/std/cstddef>
+#include <cuda/std/cstdint>
+#include <cuda/std/detail/libcxx/include/cstring>
+
+#include <nv/target>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+/***********************************************************************
+ * cuda::memcpy_async dispatch
+ *
+ * The dispatch mechanism takes all the arguments and dispatches to the
+ * fastest asynchronous copy mechanism available.
+ *
+ * It returns a __completion_mechanism that indicates which completion mechanism
+ * was used by the copy mechanism. This value can be used by the sync object to
+ * further synchronize if necessary.
+ *
+ ***********************************************************************/
+
+template <_CUDA_VSTD::size_t _Align, typename _Group>
+_CCCL_NODISCARD _CCCL_DEVICE inline __completion_mechanism __dispatch_memcpy_async_any_to_any(
+  _Group const& __group,
+  char* __dest_char,
+  char const* __src_char,
+  _CUDA_VSTD::size_t __size,
+  _CUDA_VSTD::uint32_t __allowed_completions,
+  _CUDA_VSTD::uint64_t* __bar_handle)
+{
+  __cp_async_fallback_mechanism<_Align>(__group, __dest_char, __src_char, __size);
+  return __completion_mechanism::__sync;
+}
+
+template <_CUDA_VSTD::size_t _Align, typename _Group>
+_CCCL_NODISCARD _CCCL_DEVICE inline __completion_mechanism __dispatch_memcpy_async_global_to_shared(
+  _Group const& __group,
+  char* __dest_char,
+  char const* __src_char,
+  _CUDA_VSTD::size_t __size,
+  _CUDA_VSTD::uint32_t __allowed_completions,
+  _CUDA_VSTD::uint64_t* __bar_handle)
+{
+#if __cccl_ptx_isa >= 800
+  NV_IF_TARGET(
+    NV_PROVIDES_SM_90,
+    (const bool __can_use_complete_tx = __allowed_completions & uint32_t(__completion_mechanism::__mbarrier_complete_tx);
+     (void) __can_use_complete_tx;
+     _CCCL_ASSERT(__can_use_complete_tx == (nullptr != __bar_handle),
+                  "Pass non-null bar_handle if and only if can_use_complete_tx.");
+     _CCCL_IF_CONSTEXPR (_Align >= 16) {
+       if (__can_use_complete_tx && __isShared(__bar_handle))
+       {
+         __cp_async_bulk_shared_global(__group, __dest_char, __src_char, __size, __bar_handle);
+         return __completion_mechanism::__mbarrier_complete_tx;
+       }
+     }
+     // Fallthrough to SM 80..
+     ));
+#endif // __cccl_ptx_isa >= 800
+
+  NV_IF_TARGET(
+    NV_PROVIDES_SM_80,
+    (_CCCL_IF_CONSTEXPR (_Align >= 4) {
+      const bool __can_use_async_group = __allowed_completions & uint32_t(__completion_mechanism::__async_group);
+      if (__can_use_async_group)
+      {
+        __cp_async_shared_global_mechanism<_Align>(__group, __dest_char, __src_char, __size);
+        return __completion_mechanism::__async_group;
+      }
+    }
+     // Fallthrough..
+     ));
+
+  __cp_async_fallback_mechanism<_Align>(__group, __dest_char, __src_char, __size);
+  return __completion_mechanism::__sync;
+}
+
+// __dispatch_memcpy_async is the internal entry point for dispatching to the correct memcpy_async implementation.
+template <_CUDA_VSTD::size_t _Align, typename _Group>
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI __completion_mechanism __dispatch_memcpy_async(
+  _Group const& __group,
+  char* __dest_char,
+  char const* __src_char,
+  _CUDA_VSTD::size_t __size,
+  _CUDA_VSTD::uint32_t __allowed_completions,
+  _CUDA_VSTD::uint64_t* __bar_handle)
+{
+  NV_IF_ELSE_TARGET(
+    NV_IS_DEVICE,
+    (
+      // Dispatch based on direction of the copy: global to shared, shared to
+      // global, etc.
+
+      // CUDA compilers <= 12.2 may not propagate assumptions about the state space
+      // of pointers correctly. Therefore, we
+      // 1) put the code for each copy direction in a separate function, and
+      // 2) make sure none of the code paths can reach each other by "falling through".
+      //
+      // See nvbug 4074679 and also PR #478.
+      if (__isGlobal(__src_char) && __isShared(__dest_char)) {
+        return __dispatch_memcpy_async_global_to_shared<_Align>(
+          __group, __dest_char, __src_char, __size, __allowed_completions, __bar_handle);
+      } else {
+        return __dispatch_memcpy_async_any_to_any<_Align>(
+          __group, __dest_char, __src_char, __size, __allowed_completions, __bar_handle);
+      }),
+    (
+      // Host code path:
+      if (__group.thread_rank() == 0) {
+        memcpy(__dest_char, __src_char, __size);
+      } return __completion_mechanism::__sync;));
+}
+
+template <_CUDA_VSTD::size_t _Align, typename _Group>
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI __completion_mechanism __dispatch_memcpy_async(
+  _Group const& __group,
+  char* __dest_char,
+  char const* __src_char,
+  _CUDA_VSTD::size_t __size,
+  _CUDA_VSTD::uint32_t __allowed_completions)
+{
+  _CCCL_ASSERT(!(__allowed_completions & uint32_t(__completion_mechanism::__mbarrier_complete_tx)),
+               "Cannot allow mbarrier_complete_tx completion mechanism when not passing a barrier. ");
+  return __dispatch_memcpy_async<_Align>(__group, __dest_char, __src_char, __size, __allowed_completions, nullptr);
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CUDA_PTX__MEMCPY_ASYNC_DISPATCH_MEMCPY_ASYNC_H_

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/is_local_smem_barrier.h

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___BARRIER_IS_LOCAL_SMEM_BARRIER_H
+#define _CUDA___BARRIER_IS_LOCAL_SMEM_BARRIER_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/__barrier/barrier.h>
+#include <cuda/std/__atomic/scopes.h>
+#include <cuda/std/__barrier/empty_completion.h>
+#include <cuda/std/__type_traits/is_same.h>
+
+#include <nv/target>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+//! @brief __is_local_smem_barrier returns true if barrier is (1) block-scoped and (2) located in shared memory.
+template <thread_scope _Sco,
+          typename _CompF,
+          bool _Is_mbarrier = (_Sco == thread_scope_block)
+                           && _CCCL_TRAIT(_CUDA_VSTD::is_same, _CompF, _CUDA_VSTD::__empty_completion)>
+_LIBCUDACXX_HIDE_FROM_ABI bool __is_local_smem_barrier(barrier<_Sco, _CompF>& __barrier)
+{
+  NV_IF_ELSE_TARGET(NV_IS_DEVICE, (return _Is_mbarrier && __isShared(&__barrier);), (return false;));
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CUDA___BARRIER_IS_LOCAL_SMEM_BARRIER_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/memcpy_async.h

@@ -0,0 +1,166 @@
+// -*- 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_PTX__MEMCPY_ASYNC_MEMCPY_ASYNC_H_
+#define _CUDA_PTX__MEMCPY_ASYNC_MEMCPY_ASYNC_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_HAS_CUDA_COMPILER
+
+#  include <cuda/__barrier/aligned_size.h>
+#  include <cuda/__barrier/async_contract_fulfillment.h>
+#  include <cuda/__barrier/barrier.h>
+#  include <cuda/__barrier/barrier_block_scope.h>
+#  include <cuda/__barrier/barrier_thread_scope.h>
+#  include <cuda/__memcpy_async/memcpy_async_barrier.h>
+#  include <cuda/std/__atomic/scopes.h>
+#  include <cuda/std/__type_traits/void_t.h>
+#  include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+/***********************************************************************
+ * memcpy_async code:
+ *
+ * A call to cuda::memcpy_async(dest, src, size, barrier) can dispatch to any of
+ * these PTX instructions:
+ *
+ * 1. normal synchronous copy (fallback)
+ * 2. cp.async:      shared  <- global
+ * 3. cp.async.bulk: shared  <- global
+ * 4. TODO: cp.async.bulk: global  <- shared
+ * 5. TODO: cp.async.bulk: cluster <- shared
+ *
+ * Which of these options is chosen, depends on:
+ *
+ * 1. The alignment of dest, src, and size;
+ * 2. The direction of the copy
+ * 3. The current compute capability
+ * 4. The requested completion mechanism
+ *
+ * PTX has 3 asynchronous completion mechanisms:
+ *
+ * 1. Async group           - local to a thread. Used by cp.async
+ * 2. Bulk async group      - local to a thread. Used by cp.async.bulk (shared -> global)
+ * 3. mbarrier::complete_tx - shared memory barier. Used by cp.async.bulk (other directions)
+ *
+ * The code is organized as follows:
+ *
+ * 1. Asynchronous copy mechanisms that wrap the PTX instructions
+ *
+ * 2. Device memcpy_async implementation per copy direction (global to shared,
+ *    shared to global, etc). Dispatches to fastest mechanism based on requested
+ *    completion mechanism(s), pointer alignment, and architecture.
+ *
+ * 3. Host and device memcpy_async implementations. Host implementation is
+ *    basically a memcpy wrapper; device implementation dispatches based on the
+ *    direction of the copy.
+ *
+ * 4. __memcpy_async_barrier:
+ *    a) Sets the allowed completion mechanisms based on the barrier location
+ *    b) Calls the host or device memcpy_async implementation
+ *    c) If necessary, synchronizes with the barrier based on the returned
+ *    completion mechanism.
+ *
+ * 5. The public memcpy_async function overloads. Call into
+ *    __memcpy_async_barrier.
+ *
+ ***********************************************************************/
+
+/***********************************************************************
+ * Asynchronous copy mechanisms:
+ *
+ * 1. cp.async.bulk: shared  <- global
+ * 2. TODO: cp.async.bulk: cluster <- shared
+ * 3. TODO: cp.async.bulk: global  <- shared
+ * 4. cp.async:      shared  <- global
+ * 5. normal synchronous copy (fallback)
+ ***********************************************************************/
+
+template <typename _Group, class _Tp, _CUDA_VSTD::size_t _Alignment, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_HIDE_FROM_ABI async_contract_fulfillment memcpy_async(
+  _Group const& __group,
+  _Tp* __destination,
+  _Tp const* __source,
+  aligned_size_t<_Alignment> __size,
+  barrier<_Sco, _CompF>& __barrier)
+{
+  return __memcpy_async_barrier(__group, __destination, __source, __size, __barrier);
+}
+
+template <class _Tp, typename _Size, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_HIDE_FROM_ABI async_contract_fulfillment
+memcpy_async(_Tp* __destination, _Tp const* __source, _Size __size, barrier<_Sco, _CompF>& __barrier)
+{
+  return __memcpy_async_barrier(__single_thread_group{}, __destination, __source, __size, __barrier);
+}
+
+template <typename _Group, class _Tp, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_HIDE_FROM_ABI async_contract_fulfillment memcpy_async(
+  _Group const& __group,
+  _Tp* __destination,
+  _Tp const* __source,
+  _CUDA_VSTD::size_t __size,
+  barrier<_Sco, _CompF>& __barrier)
+{
+  return __memcpy_async_barrier(__group, __destination, __source, __size, __barrier);
+}
+
+template <typename _Group, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_HIDE_FROM_ABI async_contract_fulfillment memcpy_async(
+  _Group const& __group,
+  void* __destination,
+  void const* __source,
+  _CUDA_VSTD::size_t __size,
+  barrier<_Sco, _CompF>& __barrier)
+{
+  return __memcpy_async_barrier(
+    __group, reinterpret_cast<char*>(__destination), reinterpret_cast<char const*>(__source), __size, __barrier);
+}
+
+template <typename _Group, _CUDA_VSTD::size_t _Alignment, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_HIDE_FROM_ABI async_contract_fulfillment memcpy_async(
+  _Group const& __group,
+  void* __destination,
+  void const* __source,
+  aligned_size_t<_Alignment> __size,
+  barrier<_Sco, _CompF>& __barrier)
+{
+  return __memcpy_async_barrier(
+    __group, reinterpret_cast<char*>(__destination), reinterpret_cast<char const*>(__source), __size, __barrier);
+}
+
+template <typename _Size, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_HIDE_FROM_ABI async_contract_fulfillment
+memcpy_async(void* __destination, void const* __source, _Size __size, barrier<_Sco, _CompF>& __barrier)
+{
+  return __memcpy_async_barrier(
+    __single_thread_group{},
+    reinterpret_cast<char*>(__destination),
+    reinterpret_cast<char const*>(__source),
+    __size,
+    __barrier);
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CCCL_CUDA_COMPILER
+
+#endif // _CUDA_PTX__MEMCPY_ASYNC_MEMCPY_ASYNC_H_

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/memcpy_async_barrier.h

@@ -0,0 +1,118 @@
+// -*- 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_PTX__MEMCPY_ASYNC_MEMCPY_ASYNC_BARRIER_H_
+#define _CUDA_PTX__MEMCPY_ASYNC_MEMCPY_ASYNC_BARRIER_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/__barrier/barrier.h>
+#include <cuda/__barrier/barrier_block_scope.h>
+#include <cuda/__barrier/barrier_thread_scope.h>
+#include <cuda/__memcpy_async/completion_mechanism.h>
+#include <cuda/__memcpy_async/dispatch_memcpy_async.h>
+#include <cuda/__memcpy_async/is_local_smem_barrier.h>
+#include <cuda/__memcpy_async/memcpy_completion.h>
+#include <cuda/__memcpy_async/try_get_barrier_handle.h>
+#include <cuda/std/__atomic/scopes.h>
+#include <cuda/std/__type_traits/is_trivially_copyable.h>
+#include <cuda/std/cstddef>
+#include <cuda/std/cstdint>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+/***********************************************************************
+ * cuda::memcpy_async dispatch helper functions
+ *
+ * - __get_size_align struct to determine the alignment from a size type.
+ ***********************************************************************/
+
+// The __get_size_align struct provides a way to query the guaranteed
+// "alignment" of a provided size. In this case, an n-byte aligned size means
+// that the size is a multiple of n.
+//
+// Use as follows:
+// static_assert(__get_size_align<size_t>::align == 1)
+// static_assert(__get_size_align<aligned_size_t<n>>::align == n)
+
+// Default impl: always returns 1.
+template <typename, typename = void>
+struct __get_size_align
+{
+  static constexpr int align = 1;
+};
+
+// aligned_size_t<n> overload: return n.
+template <typename T>
+struct __get_size_align<T, _CUDA_VSTD::void_t<decltype(T::align)>>
+{
+  static constexpr int align = T::align;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct __single_thread_group
+{
+  _LIBCUDACXX_HIDE_FROM_ABI void sync() const {}
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr _CUDA_VSTD::size_t size() const
+  {
+    return 1;
+  };
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr _CUDA_VSTD::size_t thread_rank() const
+  {
+    return 0;
+  };
+};
+
+template <typename _Group, class _Tp, typename _Size, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_HIDE_FROM_ABI async_contract_fulfillment __memcpy_async_barrier(
+  _Group const& __group, _Tp* __destination, _Tp const* __source, _Size __size, barrier<_Sco, _CompF>& __barrier)
+{
+  static_assert(_CCCL_TRAIT(_CUDA_VSTD::is_trivially_copyable, _Tp), "memcpy_async requires a trivially copyable type");
+
+  // 1. Determine which completion mechanisms can be used with the current
+  // barrier. A local shared memory barrier, i.e., block-scope barrier in local
+  // shared memory, supports the mbarrier_complete_tx mechanism in addition to
+  // the async group mechanism.
+  _CUDA_VSTD::uint32_t __allowed_completions =
+    __is_local_smem_barrier(__barrier)
+      ? (_CUDA_VSTD::uint32_t(__completion_mechanism::__async_group)
+         | _CUDA_VSTD::uint32_t(__completion_mechanism::__mbarrier_complete_tx))
+      : _CUDA_VSTD::uint32_t(__completion_mechanism::__async_group);
+
+  // Alignment: Use the maximum of the alignment of _Tp and that of a possible cuda::aligned_size_t.
+  constexpr _CUDA_VSTD::size_t __size_align = __get_size_align<_Size>::align;
+  constexpr _CUDA_VSTD::size_t __align      = (alignof(_Tp) < __size_align) ? __size_align : alignof(_Tp);
+  // Cast to char pointers. We don't need the type for alignment anymore and
+  // erasing the types reduces the number of instantiations of down-stream
+  // functions.
+  char* __dest_char      = reinterpret_cast<char*>(__destination);
+  char const* __src_char = reinterpret_cast<char const*>(__source);
+
+  // 2. Issue actual copy instructions.
+  auto __bh = __try_get_barrier_handle(__barrier);
+  auto __cm = __dispatch_memcpy_async<__align>(__group, __dest_char, __src_char, __size, __allowed_completions, __bh);
+
+  // 3. Synchronize barrier with copy instructions.
+  return __memcpy_completion_impl::__defer(__cm, __group, __size, __barrier);
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CUDA_PTX__MEMCPY_ASYNC_MEMCPY_ASYNC_BARRIER_H_

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/memcpy_async_tx.h

@@ -0,0 +1,90 @@
+// -*- 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_PTX__MEMCPY_ASYNC_MEMCPY_ASYNC_TX_H_
+#define _CUDA_PTX__MEMCPY_ASYNC_MEMCPY_ASYNC_TX_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_HAS_CUDA_COMPILER
+#  if __cccl_ptx_isa >= 800
+
+#    include <cuda/__barrier/aligned_size.h>
+#    include <cuda/__barrier/async_contract_fulfillment.h>
+#    include <cuda/__barrier/barrier_block_scope.h>
+#    include <cuda/__barrier/barrier_native_handle.h>
+#    include <cuda/__ptx/instructions/cp_async_bulk.h>
+#    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/is_trivially_copyable.h>
+#    include <cuda/std/cstdint>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA_DEVICE
+
+extern "C" _CCCL_DEVICE void __cuda_ptx_memcpy_async_tx_is_not_supported_before_SM_90__();
+template <typename _Tp, _CUDA_VSTD::size_t _Alignment>
+_CCCL_DEVICE inline async_contract_fulfillment memcpy_async_tx(
+  _Tp* __dest,
+  const _Tp* __src,
+  ::cuda::aligned_size_t<_Alignment> __size,
+  ::cuda::barrier<::cuda::thread_scope_block>& __b)
+{
+  // When compiling with NVCC and GCC 4.8, certain user defined types that _are_ trivially copyable are
+  // incorrectly classified as not trivially copyable. Remove this assertion to allow for their usage with
+  // memcpy_async when compiling with GCC 4.8.
+  // FIXME: remove the #if once GCC 4.8 is no longer supported.
+#    if !_CCCL_COMPILER(GCC) || _CCCL_COMPILER(GCC, >, 4, 8)
+  static_assert(_CUDA_VSTD::is_trivially_copyable<_Tp>::value, "memcpy_async_tx requires a trivially copyable type");
+#    endif
+  static_assert(16 <= _Alignment, "mempcy_async_tx expects arguments to be at least 16 byte aligned.");
+
+  _CCCL_ASSERT(__isShared(barrier_native_handle(__b)), "Barrier must be located in local shared memory.");
+  _CCCL_ASSERT(__isShared(__dest), "dest must point to shared memory.");
+  _CCCL_ASSERT(__isGlobal(__src), "src must point to global memory.");
+
+  NV_IF_ELSE_TARGET(
+    NV_PROVIDES_SM_90,
+    (
+      if (__isShared(__dest) && __isGlobal(__src)) {
+        _CUDA_VPTX::cp_async_bulk(
+          _CUDA_VPTX::space_cluster,
+          _CUDA_VPTX::space_global,
+          __dest,
+          __src,
+          static_cast<uint32_t>(__size),
+          barrier_native_handle(__b));
+      } 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_ptx_memcpy_async_tx_is_not_supported_before_SM_90__();));
+
+  return async_contract_fulfillment::async;
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA_DEVICE
+
+#  endif // __cccl_ptx_isa >= 800
+#endif // _CCCL_CUDA_COMPILER
+
+#endif // _CUDA_PTX__MEMCPY_ASYNC_MEMCPY_ASYNC_TX_H_

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/memcpy_completion.h

@@ -0,0 +1,168 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___MEMCPY_ASYNC_MEMCPY_COMPLETION_H
+#define _CUDA___MEMCPY_ASYNC_MEMCPY_COMPLETION_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/__barrier/async_contract_fulfillment.h>
+#include <cuda/__barrier/barrier_block_scope.h>
+#include <cuda/__barrier/barrier_expect_tx.h>
+#include <cuda/__fwd/pipeline.h>
+#include <cuda/__memcpy_async/completion_mechanism.h>
+#include <cuda/__memcpy_async/is_local_smem_barrier.h>
+#include <cuda/__memcpy_async/try_get_barrier_handle.h>
+#include <cuda/std/__atomic/scopes.h>
+#include <cuda/std/cstdint>
+
+#if _CCCL_HAS_CUDA_COMPILER
+#  include <cuda/__ptx/ptx_dot_variants.h>
+#  include <cuda/__ptx/ptx_helper_functions.h>
+#endif // _CCCL_CUDA_COMPILER
+
+#include <nv/target>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+// This struct contains functions to defer the completion of a barrier phase
+// or pipeline stage until a specific memcpy_async operation *initiated by
+// this thread* has completed.
+
+// The user is still responsible for arriving and waiting on (or otherwise
+// synchronizing with) the barrier or pipeline barrier to see the results of
+// copies from other threads participating in the synchronization object.
+struct __memcpy_completion_impl
+{
+  template <typename _Group>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static async_contract_fulfillment
+  __defer(__completion_mechanism __cm,
+          _Group const& __group,
+          _CUDA_VSTD::size_t __size,
+          barrier<::cuda::thread_scope_block>& __barrier)
+  {
+    // In principle, this is the overload for shared memory barriers. However, a
+    // block-scope barrier may also be located in global memory. Therefore, we
+    // check if the barrier is a non-smem barrier and handle that separately.
+    if (!__is_local_smem_barrier(__barrier))
+    {
+      return __defer_non_smem_barrier(__cm, __group, __size, __barrier);
+    }
+
+    switch (__cm)
+    {
+      case __completion_mechanism::__async_group:
+        // Pre-SM80, the async_group mechanism is not available.
+        NV_IF_TARGET(
+          NV_PROVIDES_SM_80,
+          (
+            // Non-Blocking: unbalance barrier by 1, barrier will be
+            // rebalanced when all thread-local cp.async instructions
+            // have completed writing to shared memory.
+            _CUDA_VSTD::uint64_t* __bh = __try_get_barrier_handle(__barrier);
+
+            asm volatile("cp.async.mbarrier.arrive.shared.b64 [%0];" ::"r"(static_cast<_CUDA_VSTD::uint32_t>(
+              __cvta_generic_to_shared(__bh)))
+                         : "memory");));
+        return async_contract_fulfillment::async;
+      case __completion_mechanism::__async_bulk_group:
+        // This completion mechanism should not be used with a shared
+        // memory barrier. Or at least, we do not currently envision
+        // 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
+        return async_contract_fulfillment::async;
+      case __completion_mechanism::__sync:
+        // sync: In this case, we do not need to do anything. The user will have
+        // to issue `bar.arrive_wait();` to see the effect of the transaction.
+        return async_contract_fulfillment::none;
+      default:
+        // Get rid of "control reaches end of non-void function":
+        _CCCL_UNREACHABLE();
+    }
+  }
+
+  template <typename _Group, thread_scope _Sco, typename _CompF>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static async_contract_fulfillment __defer(
+    __completion_mechanism __cm, _Group const& __group, _CUDA_VSTD::size_t __size, barrier<_Sco, _CompF>& __barrier)
+  {
+    return __defer_non_smem_barrier(__cm, __group, __size, __barrier);
+  }
+
+  template <typename _Group, thread_scope _Sco, typename _CompF>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static async_contract_fulfillment __defer_non_smem_barrier(
+    __completion_mechanism __cm, _Group const& __group, _CUDA_VSTD::size_t __size, barrier<_Sco, _CompF>& __barrier)
+  {
+    // Overload for non-smem barriers.
+    switch (__cm)
+    {
+      case __completion_mechanism::__async_group:
+        // Pre-SM80, the async_group mechanism is not available.
+        NV_IF_TARGET(NV_PROVIDES_SM_80,
+                     (
+                       // Blocking: wait for all thread-local cp.async instructions to have
+                       // completed writing to shared memory.
+                       asm volatile("cp.async.wait_all;" ::
+                                      : "memory");));
+        return async_contract_fulfillment::async;
+      case __completion_mechanism::__mbarrier_complete_tx:
+        // Non-smem barriers do not have an mbarrier_complete_tx mechanism..
+        _CCCL_UNREACHABLE();
+      case __completion_mechanism::__async_bulk_group:
+        // This completion mechanism is currently not expected to be used with barriers.
+        _CCCL_UNREACHABLE();
+      case __completion_mechanism::__sync:
+        // sync: In this case, we do not need to do anything.
+        return async_contract_fulfillment::none;
+      default:
+        // Get rid of "control reaches end of non-void function":
+        _CCCL_UNREACHABLE();
+    }
+  }
+
+  template <typename _Group, thread_scope _Sco>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static async_contract_fulfillment
+  __defer(__completion_mechanism __cm, _Group const&, _CUDA_VSTD::size_t, pipeline<_Sco>&)
+  {
+    switch (__cm)
+    {
+      case __completion_mechanism::__async_group:
+        return async_contract_fulfillment::async;
+      case __completion_mechanism::__async_bulk_group:
+        return async_contract_fulfillment::async;
+      case __completion_mechanism::__mbarrier_complete_tx:
+        return async_contract_fulfillment::async;
+      case __completion_mechanism::__sync:
+        return async_contract_fulfillment::none;
+      default:
+        // Get rid of "control reaches end of non-void function":
+        _CCCL_UNREACHABLE();
+    }
+  }
+};
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CUDA___MEMCPY_ASYNC_MEMCPY_COMPLETION_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memcpy_async/try_get_barrier_handle.h

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___BARRIER_TRY_GET_BARRIER_HANDLE_H
+#define _CUDA___BARRIER_TRY_GET_BARRIER_HANDLE_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/__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>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/cstdint>
+
+#include <nv/target>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+//! @brief __try_get_barrier_handle returns barrier handle of block-scoped barriers and a nullptr otherwise.
+template <thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_HIDE_FROM_ABI _CUDA_VSTD::uint64_t* __try_get_barrier_handle(barrier<_Sco, _CompF>& __barrier)
+{
+  return nullptr;
+}
+
+template <>
+_LIBCUDACXX_HIDE_FROM_ABI _CUDA_VSTD::uint64_t*
+__try_get_barrier_handle<::cuda::thread_scope_block, _CUDA_VSTD::__empty_completion>(
+  barrier<thread_scope_block>& __barrier)
+{
+  (void) __barrier;
+  NV_DISPATCH_TARGET(
+    NV_IS_DEVICE, (return ::cuda::device::barrier_native_handle(__barrier);), NV_ANY_TARGET, (return nullptr;));
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CUDA___BARRIER_TRY_GET_BARRIER_HANDLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memory_resource/resource.h

@@ -0,0 +1,129 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA__MEMORY_RESOURCE_RESOURCE_H
+#define _CUDA__MEMORY_RESOURCE_RESOURCE_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_COMPILER(MSVC2017) && defined(LIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE)
+
+#  include <cuda/__memory_resource/get_property.h>
+#  include <cuda/std/__concepts/concept_macros.h>
+#  include <cuda/std/__concepts/convertible_to.h>
+#  include <cuda/std/__concepts/equality_comparable.h>
+#  include <cuda/std/__concepts/same_as.h>
+#  include <cuda/std/__tuple_dir/sfinae_helpers.h>
+#  include <cuda/std/__type_traits/decay.h>
+#  include <cuda/std/__type_traits/fold.h>
+#  include <cuda/stream_ref>
+
+#  if _CCCL_STD_VER >= 2014
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA_MR
+
+//! @brief The \c resource concept verifies that a type Resource satisfies the basic requirements of a memory
+//! resource
+//! @rst
+//! We require that a resource supports the following interface
+//!
+//!   - ``allocate(size_t bytes, size_t alignment)``
+//!   - ``deallocate(void* ptr, size_t bytes, size_t alignment)``
+//!   - ``T() == T()``
+//!   - ``T() != T()``
+//!
+//! @endrst
+//! @tparam _Resource The type that should implement the resource concept
+template <class _Resource>
+_CCCL_CONCEPT resource =
+  _CCCL_REQUIRES_EXPR((_Resource), _Resource& __res, void* __ptr, size_t __bytes, size_t __alignment)(
+    _Same_as(void*) __res.allocate(__bytes, __alignment), //
+    _Same_as(void) __res.deallocate(__ptr, __bytes, __alignment),
+    requires(_CUDA_VSTD::equality_comparable<_Resource>));
+
+//! @brief The \c async_resource concept verifies that a type Resource satisfies the basic requirements of a
+//! memory resource and additionally supports stream ordered allocations
+//! @rst
+//! We require that an async resource supports the following interface
+//!
+//!   - ``allocate(size_t bytes, size_t alignment)``
+//!   - ``deallocate(void* ptr, size_t bytes, size_t alignment)``
+//!   - ``T() == T()``
+//!   - ``T() != T()``
+//!
+//!   - ``allocate_async(size_t bytes, size_t alignment, cuda::stream_ref stream)``
+//!   - ``deallocate_async(void* ptr, size_t bytes, size_t alignment, cuda::stream_ref stream)``
+//!
+//! @endrst
+//! @tparam _Resource The type that should implement the async resource concept
+template <class _Resource>
+_CCCL_CONCEPT async_resource = _CCCL_REQUIRES_EXPR(
+  (_Resource), _Resource& __res, void* __ptr, size_t __bytes, size_t __alignment, ::cuda::stream_ref __stream)(
+  _Same_as(void*) __res.allocate_async(__bytes, __alignment, __stream),
+  _Same_as(void) __res.deallocate_async(__ptr, __bytes, __alignment, __stream),
+  requires(resource<_Resource>));
+
+//! @brief The \c resource_with concept verifies that a type Resource satisfies the `resource` concept and
+//! also satisfies all the provided Properties
+//! @tparam _Resource
+//! @tparam _Properties
+// We cannot use fold expressions here due to a nvcc bug
+template <class _Resource, class... _Properties>
+_CCCL_CONCEPT resource_with = _CCCL_REQUIRES_EXPR((_Resource, variadic _Properties))(
+  requires(resource<_Resource>), requires(_CUDA_VSTD::__all<has_property<_Resource, _Properties>...>::value));
+
+//! @brief The \c async_resource_with concept verifies that a type Resource satisfies the `async_resource`
+//! concept and also satisfies all the provided Properties
+//! @tparam _Resource
+//! @tparam _Properties
+// We cannot use fold expressions here due to a nvcc bug
+template <class _Resource, class... _Properties>
+_CCCL_CONCEPT async_resource_with = _CCCL_REQUIRES_EXPR((_Resource, variadic _Properties))(
+  requires(async_resource<_Resource>), requires(_CUDA_VSTD::__all<has_property<_Resource, _Properties>...>::value));
+
+template <bool _Convertible>
+struct __different_resource__
+{
+  template <class _OtherResource>
+  static constexpr bool __value(_OtherResource*) noexcept
+  {
+    return resource<_OtherResource>;
+  }
+};
+
+template <>
+struct __different_resource__<true>
+{
+  static constexpr bool __value(void*) noexcept
+  {
+    return false;
+  }
+};
+
+template <class _Resource, class _OtherResource>
+_CCCL_CONCEPT __different_resource =
+  __different_resource__<_CUDA_VSTD::convertible_to<_OtherResource const&, _Resource const&>>::__value(
+    static_cast<_OtherResource*>(nullptr));
+
+_LIBCUDACXX_END_NAMESPACE_CUDA_MR
+
+#  endif // _CCCL_STD_VER >= 2014
+
+#endif // !_CCCL_COMPILER(MSVC2017) && LIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE
+
+#endif //_CUDA__MEMORY_RESOURCE_RESOURCE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__memory_resource/resource_ref.h

@@ -0,0 +1,653 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA__MEMORY_RESOURCE_RESOURCE_REF_H
+#define _CUDA__MEMORY_RESOURCE_RESOURCE_REF_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_COMPILER(MSVC2017) && defined(LIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE)
+
+#  include <cuda/__memory_resource/get_property.h>
+#  include <cuda/__memory_resource/properties.h>
+#  include <cuda/__memory_resource/resource.h>
+#  include <cuda/std/__concepts/concept_macros.h>
+#  include <cuda/std/__memory/addressof.h>
+#  include <cuda/std/__type_traits/is_base_of.h>
+#  include <cuda/std/__type_traits/is_nothrow_move_constructible.h>
+#  include <cuda/std/__type_traits/type_set.h>
+#  include <cuda/std/__utility/exchange.h>
+#  include <cuda/std/__utility/move.h>
+#  include <cuda/std/cstddef>
+#  include <cuda/stream_ref>
+
+#  if _CCCL_STD_VER >= 2014
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA_MR
+
+union _AnyResourceStorage
+{
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr _AnyResourceStorage(void* __ptr = nullptr) noexcept
+      : __ptr_(__ptr)
+  {}
+
+  void* __ptr_;
+  char __buf_[3 * sizeof(void*)];
+};
+
+template <class _Resource>
+constexpr bool _IsSmall() noexcept
+{
+  return (sizeof(_Resource) <= sizeof(_AnyResourceStorage)) //
+      && (alignof(_AnyResourceStorage) % alignof(_Resource) == 0)
+      && _CCCL_TRAIT(_CUDA_VSTD::is_nothrow_move_constructible, _Resource);
+}
+
+template <class _Resource>
+constexpr _Resource* _Any_resource_cast(_AnyResourceStorage* __object) noexcept
+{
+  return static_cast<_Resource*>(_IsSmall<_Resource>() ? __object->__buf_ : __object->__ptr_);
+}
+
+template <class _Resource>
+constexpr const _Resource* _Any_resource_cast(const _AnyResourceStorage* __object) noexcept
+{
+  return static_cast<const _Resource*>(_IsSmall<_Resource>() ? __object->__buf_ : __object->__ptr_);
+}
+
+enum class _WrapperType
+{
+  _Reference,
+  _Owning
+};
+
+enum class _AllocType
+{
+  _Default,
+  _Async,
+};
+
+struct _Alloc_vtable
+{
+  using _AllocFn   = void* (*) (void*, size_t, size_t);
+  using _DeallocFn = void (*)(void*, void*, size_t, size_t) _CCCL_FUNCTION_TYPE_NOEXCEPT;
+  using _EqualFn   = bool (*)(void*, void*);
+  using _DestroyFn = void (*)(_AnyResourceStorage*) _CCCL_FUNCTION_TYPE_NOEXCEPT;
+  using _MoveFn    = void (*)(_AnyResourceStorage*, _AnyResourceStorage*) _CCCL_FUNCTION_TYPE_NOEXCEPT;
+  using _CopyFn    = void (*)(_AnyResourceStorage*, const _AnyResourceStorage*);
+
+  bool __is_small;
+  _AllocFn __alloc_fn;
+  _DeallocFn __dealloc_fn;
+  _EqualFn __equal_fn;
+  _DestroyFn __destroy_fn;
+  _MoveFn __move_fn;
+  _CopyFn __copy_fn;
+
+  constexpr _Alloc_vtable(
+    bool __is_small_,
+    _AllocFn __alloc_fn_,
+    _DeallocFn __dealloc_fn_,
+    _EqualFn __equal_fn_,
+    _DestroyFn __destroy_fn_,
+    _MoveFn __move_fn_,
+    _CopyFn __copy_fn_) noexcept
+      : __is_small(__is_small_)
+      , __alloc_fn(__alloc_fn_)
+      , __dealloc_fn(__dealloc_fn_)
+      , __equal_fn(__equal_fn_)
+      , __destroy_fn(__destroy_fn_)
+      , __move_fn(__move_fn_)
+      , __copy_fn(__copy_fn_)
+  {}
+};
+
+struct _Async_alloc_vtable : public _Alloc_vtable
+{
+  using _AsyncAllocFn   = void* (*) (void*, size_t, size_t, ::cuda::stream_ref);
+  using _AsyncDeallocFn = void (*)(void*, void*, size_t, size_t, ::cuda::stream_ref);
+
+  _AsyncAllocFn __async_alloc_fn;
+  _AsyncDeallocFn __async_dealloc_fn;
+
+  constexpr _Async_alloc_vtable(
+    bool __is_small_,
+    _Alloc_vtable::_AllocFn __alloc_fn_,
+    _Alloc_vtable::_DeallocFn __dealloc_fn_,
+    _Alloc_vtable::_EqualFn __equal_fn_,
+    _Alloc_vtable::_DestroyFn __destroy_fn_,
+    _Alloc_vtable::_MoveFn __move_fn_,
+    _Alloc_vtable::_CopyFn __copy_fn_,
+    _AsyncAllocFn __async_alloc_fn_,
+    _AsyncDeallocFn __async_dealloc_fn_) noexcept
+      : _Alloc_vtable(__is_small_, __alloc_fn_, __dealloc_fn_, __equal_fn_, __destroy_fn_, __move_fn_, __copy_fn_)
+      , __async_alloc_fn(__async_alloc_fn_)
+      , __async_dealloc_fn(__async_dealloc_fn_)
+  {}
+};
+
+struct _Resource_vtable_builder
+{
+  template <_WrapperType _Wrapper_type>
+  using __wrapper_type = _CUDA_VSTD::integral_constant<_WrapperType, _Wrapper_type>;
+
+  template <class _Resource, class _Property>
+  static __property_value_t<_Property> _Get_property(const void* __res) noexcept
+  {
+    return get_property(*static_cast<const _Resource*>(__res), _Property{});
+  }
+
+  template <class _Resource>
+  static void* _Alloc(void* __object, size_t __bytes, size_t __alignment)
+  {
+    return static_cast<_Resource*>(__object)->allocate(__bytes, __alignment);
+  }
+
+  template <class _Resource>
+  static void _Dealloc(void* __object, void* __ptr, size_t __bytes, size_t __alignment) noexcept
+  {
+    // TODO: this breaks RMM because their memory resources do not declare their
+    // deallocate functions to be noexcept. Comment out the check for now until
+    // we can fix RMM.
+    // static_assert(noexcept(static_cast<_Resource*>(__object)->deallocate(__ptr, __bytes, __alignment)));
+    return static_cast<_Resource*>(__object)->deallocate(__ptr, __bytes, __alignment);
+  }
+
+  template <class _Resource>
+  static void* _Alloc_async(void* __object, size_t __bytes, size_t __alignment, ::cuda::stream_ref __stream)
+  {
+    return static_cast<_Resource*>(__object)->allocate_async(__bytes, __alignment, __stream);
+  }
+
+  template <class _Resource>
+  static void
+  _Dealloc_async(void* __object, void* __ptr, size_t __bytes, size_t __alignment, ::cuda::stream_ref __stream)
+  {
+    return static_cast<_Resource*>(__object)->deallocate_async(__ptr, __bytes, __alignment, __stream);
+  }
+
+  template <class _Resource>
+  static bool _Equal(void* __left, void* __rhs)
+  {
+    return *static_cast<_Resource*>(__left) == *static_cast<_Resource*>(__rhs);
+  }
+
+  template <class _Resource>
+  static void _Destroy_impl(_AnyResourceStorage* __object_, __wrapper_type<_WrapperType::_Owning>) noexcept
+  {
+    _Resource* __object = _Any_resource_cast<_Resource>(__object_);
+    _CCCL_IF_CONSTEXPR (_IsSmall<_Resource>())
+    {
+      __object->~_Resource();
+    }
+    else
+    {
+      delete __object;
+    }
+  }
+
+  template <class _Resource>
+  static void _Destroy_impl(_AnyResourceStorage*, __wrapper_type<_WrapperType::_Reference>) noexcept
+  {}
+
+  template <class _Resource, _WrapperType _Wrapper_type>
+  static void _Destroy(_AnyResourceStorage* __object) noexcept
+  {
+    _Destroy_impl<_Resource>(__object, __wrapper_type<_Wrapper_type>{});
+  }
+
+  template <class _Resource>
+  static void _Move_impl(
+    _AnyResourceStorage* __object, _AnyResourceStorage* __other_, __wrapper_type<_WrapperType::_Owning>) noexcept
+  {
+    _CCCL_IF_CONSTEXPR (_IsSmall<_Resource>())
+    {
+      _Resource* __other = _Any_resource_cast<_Resource>(__other_);
+      ::new (static_cast<void*>(__object->__buf_)) _Resource(_CUDA_VSTD::move(*__other));
+      __other->~_Resource();
+    }
+    else
+    {
+      __object->__ptr_ = _CUDA_VSTD::exchange(__other_->__ptr_, nullptr);
+    }
+  }
+
+  template <class _Resource>
+  static void _Move_impl(_AnyResourceStorage*, _AnyResourceStorage*, __wrapper_type<_WrapperType::_Reference>) noexcept
+  {}
+
+  template <class _Resource, _WrapperType _Wrapper_type>
+  static void _Move(_AnyResourceStorage* __object, _AnyResourceStorage* __other) noexcept
+  {
+    _Move_impl<_Resource>(__object, __other, __wrapper_type<_Wrapper_type>{});
+  }
+
+  template <class _Resource>
+  static void _Copy_impl(
+    _AnyResourceStorage* __object, const _AnyResourceStorage* __other, __wrapper_type<_WrapperType::_Owning>) noexcept
+  {
+    _CCCL_IF_CONSTEXPR (_IsSmall<_Resource>())
+    {
+      ::new (static_cast<void*>(__object->__buf_)) _Resource(*_Any_resource_cast<_Resource>(__other));
+    }
+    else
+    {
+      __object->__ptr_ = new _Resource(*_Any_resource_cast<_Resource>(__other));
+    }
+  }
+
+  template <class _Resource>
+  static void
+  _Copy_impl(_AnyResourceStorage*, const _AnyResourceStorage*, __wrapper_type<_WrapperType::_Reference>) noexcept
+  {}
+
+  template <class _Resource, _WrapperType _Wrapper_type>
+  static void _Copy(_AnyResourceStorage* __object, const _AnyResourceStorage* __other)
+  {
+    _Copy_impl<_Resource>(__object, __other, __wrapper_type<_Wrapper_type>{});
+  }
+
+  _CCCL_TEMPLATE(class _Resource, _AllocType _Alloc_type, _WrapperType _Wrapper_type)
+  _CCCL_REQUIRES((_Alloc_type == _AllocType::_Default))
+  static constexpr _Alloc_vtable _Create() noexcept
+  {
+    return {_IsSmall<_Resource>(),
+            &_Resource_vtable_builder::_Alloc<_Resource>,
+            &_Resource_vtable_builder::_Dealloc<_Resource>,
+            &_Resource_vtable_builder::_Equal<_Resource>,
+            &_Resource_vtable_builder::_Destroy<_Resource, _Wrapper_type>,
+            &_Resource_vtable_builder::_Move<_Resource, _Wrapper_type>,
+            &_Resource_vtable_builder::_Copy<_Resource, _Wrapper_type>};
+  }
+
+  _CCCL_TEMPLATE(class _Resource, _AllocType _Alloc_type, _WrapperType _Wrapper_type)
+  _CCCL_REQUIRES((_Alloc_type == _AllocType::_Async))
+  static constexpr _Async_alloc_vtable _Create() noexcept
+  {
+    return {_IsSmall<_Resource>(),
+            &_Resource_vtable_builder::_Alloc<_Resource>,
+            &_Resource_vtable_builder::_Dealloc<_Resource>,
+            &_Resource_vtable_builder::_Equal<_Resource>,
+            &_Resource_vtable_builder::_Destroy<_Resource, _Wrapper_type>,
+            &_Resource_vtable_builder::_Move<_Resource, _Wrapper_type>,
+            &_Resource_vtable_builder::_Copy<_Resource, _Wrapper_type>,
+            &_Resource_vtable_builder::_Alloc_async<_Resource>,
+            &_Resource_vtable_builder::_Dealloc_async<_Resource>};
+  }
+};
+
+template <class _Property>
+using __property_fn_t = __property_value_t<_Property> (*)(const void*);
+
+template <class _Property>
+struct _Property_vtable
+{
+  __property_fn_t<_Property> __property_fn = nullptr;
+
+  constexpr _Property_vtable(__property_fn_t<_Property> __property_fn_) noexcept
+      : __property_fn(__property_fn_)
+  {}
+};
+
+template <_AllocType _Alloc_type, class... _Properties>
+class basic_resource_ref;
+
+template <class... _Properties>
+struct _Resource_vtable : public _Property_vtable<_Properties>...
+{
+  constexpr _Resource_vtable(__property_fn_t<_Properties>... __property_fn_) noexcept
+      : _Property_vtable<_Properties>(__property_fn_)...
+  {}
+
+  template <class... _OtherProperties>
+  constexpr _Resource_vtable(const _Resource_vtable<_OtherProperties...>& __other) noexcept
+      : _Property_vtable<_Properties>(__other._Property_vtable<_Properties>::__property_fn)...
+  {}
+
+  template <class _Resource>
+  static constexpr _Resource_vtable _Create() noexcept
+  {
+    return {&_Resource_vtable_builder::_Get_property<_Resource, _Properties>...};
+  }
+};
+
+template <class... _Properties>
+struct _Filtered;
+
+template <bool _IsUniqueProperty>
+struct _Property_filter
+{
+  template <class _Property, class... _Properties>
+  using _Filtered_properties =
+    typename _Filtered<_Properties...>::_Filtered_vtable::template _Append_property<_Property>;
+};
+
+template <>
+struct _Property_filter<false>
+{
+  template <class _Property, class... _Properties>
+  using _Filtered_properties = typename _Filtered<_Properties...>::_Filtered_vtable;
+};
+
+template <class _Property, class... _Properties>
+struct _Filtered<_Property, _Properties...>
+{
+  using _Filtered_vtable = typename _Property_filter<
+    property_with_value<_Property> && !_CUDA_VSTD::__is_included_in_v<_Property, _Properties...>>::
+    template _Filtered_properties<_Property, _Properties...>;
+
+  template <class _OtherPropery>
+  using _Append_property = _Filtered<_OtherPropery, _Property, _Properties...>;
+
+  using _Vtable = _Resource_vtable<_Property, _Properties...>;
+};
+
+template <>
+struct _Filtered<>
+{
+  using _Filtered_vtable = _Filtered<>;
+
+  template <class _OtherPropery>
+  using _Append_property = _Filtered<_OtherPropery>;
+
+  using _Vtable = _Resource_vtable<>;
+};
+
+template <class... _Properties>
+using _Filtered_vtable = typename _Filtered<_Properties...>::_Filtered_vtable::_Vtable;
+
+template <_WrapperType _Wrapper_type>
+using __alloc_object_storage_t = _CUDA_VSTD::_If<_Wrapper_type == _WrapperType::_Reference, void*, _AnyResourceStorage>;
+
+struct _Resource_ref_base
+{};
+
+template <class _Vtable, _WrapperType _Wrapper_type>
+struct _CCCL_DECLSPEC_EMPTY_BASES _Alloc_base : _Resource_ref_base
+{
+  static_assert(_CUDA_VSTD::is_base_of_v<_Alloc_vtable, _Vtable>, "");
+
+  _Alloc_base(void* __object_, const _Vtable* __static_vtabl_) noexcept
+      : __object(__object_)
+      , __static_vtable(__static_vtabl_)
+  {}
+
+  _CCCL_NODISCARD void* allocate(size_t __bytes, size_t __alignment = alignof(_CUDA_VSTD::max_align_t))
+  {
+    return __static_vtable->__alloc_fn(_Get_object(), __bytes, __alignment);
+  }
+
+  void deallocate(void* _Ptr, size_t __bytes, size_t __alignment = alignof(_CUDA_VSTD::max_align_t)) noexcept
+  {
+    __static_vtable->__dealloc_fn(_Get_object(), _Ptr, __bytes, __alignment);
+  }
+
+protected:
+  static _CCCL_FORCEINLINE void* _Get_object_(bool, void* __object) noexcept
+  {
+    return __object;
+  }
+
+  static _CCCL_FORCEINLINE void* _Get_object_(const bool __is_small, const _AnyResourceStorage& __object) noexcept
+  {
+    const void* __pv = __is_small ? __object.__buf_ : __object.__ptr_;
+    return const_cast<void*>(__pv);
+  }
+
+  void* _Get_object() const noexcept
+  {
+    return _Get_object_(__static_vtable->__is_small, this->__object);
+  }
+
+  __alloc_object_storage_t<_Wrapper_type> __object{};
+  const _Vtable* __static_vtable = nullptr;
+};
+
+template <class _Vtable, _WrapperType _Wrapper_type>
+struct _Async_alloc_base : public _Alloc_base<_Vtable, _Wrapper_type>
+{
+  static_assert(_CUDA_VSTD::is_base_of_v<_Async_alloc_vtable, _Vtable>, "");
+
+  _Async_alloc_base(void* __object_, const _Vtable* __static_vtabl_) noexcept
+      : _Alloc_base<_Vtable, _Wrapper_type>(__object_, __static_vtabl_)
+  {}
+
+  _CCCL_NODISCARD void* allocate_async(size_t __bytes, size_t __alignment, ::cuda::stream_ref __stream)
+  {
+    return this->__static_vtable->__async_alloc_fn(this->_Get_object(), __bytes, __alignment, __stream);
+  }
+
+  _CCCL_NODISCARD void* allocate_async(size_t __bytes, ::cuda::stream_ref __stream)
+  {
+    return this->__static_vtable->__async_alloc_fn(this->_Get_object(), __bytes, alignof(max_align_t), __stream);
+  }
+
+  void deallocate_async(void* _Ptr, size_t __bytes, ::cuda::stream_ref __stream)
+  {
+    this->__static_vtable->__async_dealloc_fn(this->_Get_object(), _Ptr, __bytes, alignof(max_align_t), __stream);
+  }
+
+  void deallocate_async(void* _Ptr, size_t __bytes, size_t __alignment, ::cuda::stream_ref __stream)
+  {
+    this->__static_vtable->__async_dealloc_fn(this->_Get_object(), _Ptr, __bytes, __alignment, __stream);
+  }
+};
+
+template <class _Resource>
+_CCCL_CONCEPT _Is_resource_ref = _CUDA_VSTD::convertible_to<_Resource&, _Resource_ref_base>;
+
+template <_AllocType _Alloc_type, _WrapperType _Wrapper_type>
+using _Resource_base =
+  _CUDA_VSTD::_If<_Alloc_type == _AllocType::_Default,
+                  _Alloc_base<_Alloc_vtable, _Wrapper_type>,
+                  _Async_alloc_base<_Async_alloc_vtable, _Wrapper_type>>;
+
+template <_AllocType _Alloc_type>
+using _Vtable_store = _CUDA_VSTD::_If<_Alloc_type == _AllocType::_Default, _Alloc_vtable, _Async_alloc_vtable>;
+
+template <_AllocType _Alloc_type, _WrapperType _Wrapper_type, class _Resource>
+_CCCL_INLINE_VAR constexpr _Vtable_store<_Alloc_type> __alloc_vtable =
+  _Resource_vtable_builder::template _Create<_Resource, _Alloc_type, _Wrapper_type>();
+
+struct _Resource_ref_helper
+{
+  //! This is used from \c basic_any_resource to make it convertible to a \c basic_resource_ref
+  template <_AllocType _Alloc_type, class... _Properties>
+  static basic_resource_ref<_Alloc_type, _Properties...>
+  _Construct(void* __object,
+             const _Vtable_store<_Alloc_type>* __static_vtable,
+             _Filtered_vtable<_Properties...> __properties) noexcept
+  {
+    return basic_resource_ref<_Alloc_type, _Properties...>(__object, __static_vtable, __properties);
+  }
+};
+
+template <_AllocType _Alloc_type, class... _Properties>
+class basic_resource_ref
+    : public _Resource_base<_Alloc_type, _WrapperType::_Reference>
+    , private _Filtered_vtable<_Properties...>
+{
+private:
+  static_assert(__contains_execution_space_property<_Properties...>,
+                "The properties of cuda::mr::basic_resource_ref must contain at least one execution space property!");
+
+  template <_AllocType, class...>
+  friend class basic_resource_ref;
+
+  template <class...>
+  friend struct _Resource_vtable;
+
+  friend struct _Resource_ref_helper;
+
+  using __vtable = _Filtered_vtable<_Properties...>;
+
+  //! @brief Checks whether \c _OtherProperties is a true superset of \c _Properties, accounting for host_accessible
+  template <class... _OtherProperties>
+  static constexpr bool __properties_match =
+    _CUDA_VSTD::__type_set_contains_v<_CUDA_VSTD::__make_type_set<_OtherProperties...>, _Properties...>;
+
+  //! @brief Constructs a \c basic_resource_ref from a void*, a resource vtable ptr, and a vtable
+  //! for the properties. This is used to create a \c basic_resource_ref from a \c basic_any_resource.
+  explicit basic_resource_ref(
+    void* __object_, const _Vtable_store<_Alloc_type>* __static_vtable, __vtable __properties) noexcept
+      : _Resource_base<_Alloc_type, _WrapperType::_Reference>(__object_, __static_vtable)
+      , __vtable(__properties)
+  {}
+
+public:
+  //! @brief Constructs a \c basic_resource_ref from a type that satisfies the \c resource or \c async_resource concept
+  //! as well as all properties
+  //! @param __res The resource to be wrapped within the \c basic_resource_ref
+  _CCCL_TEMPLATE(class _Resource, _AllocType _Alloc_type2 = _Alloc_type)
+  _CCCL_REQUIRES((!_Is_resource_ref<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Default)
+                   _CCCL_AND resource_with<_Resource, _Properties...>)
+  basic_resource_ref(_Resource& __res) noexcept
+      : _Resource_base<_Alloc_type, _WrapperType::_Reference>(
+          _CUDA_VSTD::addressof(__res), &__alloc_vtable<_Alloc_type, _WrapperType::_Reference, _Resource>)
+      , __vtable(__vtable::template _Create<_Resource>())
+  {}
+
+  //! @brief Constructs a \c resource_ref from a type that satisfies the \c async_resource concept  as well as all
+  //! properties. This ignores the async interface of the passed in resource
+  //! @param __res The resource to be wrapped within the \c resource_ref
+  _CCCL_TEMPLATE(class _Resource, _AllocType _Alloc_type2 = _Alloc_type)
+  _CCCL_REQUIRES((!_Is_resource_ref<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Async)
+                   _CCCL_AND async_resource_with<_Resource, _Properties...>)
+  basic_resource_ref(_Resource& __res) noexcept
+      : _Resource_base<_Alloc_type, _WrapperType::_Reference>(
+          _CUDA_VSTD::addressof(__res), &__alloc_vtable<_Alloc_type, _WrapperType::_Reference, _Resource>)
+      , __vtable(__vtable::template _Create<_Resource>())
+  {}
+
+  //! @brief Constructs a \c basic_resource_ref from a type that satisfies the \c resource or \c async_resource concept
+  //! as well as all properties
+  //! @param __res Pointer to a resource to be wrapped within the \c basic_resource_ref
+  _CCCL_TEMPLATE(class _Resource, _AllocType _Alloc_type2 = _Alloc_type)
+  _CCCL_REQUIRES((!_Is_resource_ref<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Default)
+                   _CCCL_AND resource_with<_Resource, _Properties...>)
+  basic_resource_ref(_Resource* __res) noexcept
+      : _Resource_base<_Alloc_type, _WrapperType::_Reference>(
+          __res, &__alloc_vtable<_Alloc_type, _WrapperType::_Reference, _Resource>)
+      , __vtable(__vtable::template _Create<_Resource>())
+  {}
+
+  //! @brief Constructs a \c resource_ref from a type that satisfies the \c async_resource concept  as well as all
+  //! properties. This ignores the async interface of the passed in resource
+  //! @param __res Pointer to a resource to be wrapped within the \c resource_ref
+  _CCCL_TEMPLATE(class _Resource, _AllocType _Alloc_type2 = _Alloc_type)
+  _CCCL_REQUIRES((!_Is_resource_ref<_Resource>) _CCCL_AND(_Alloc_type2 == _AllocType::_Async)
+                   _CCCL_AND async_resource_with<_Resource, _Properties...>)
+  basic_resource_ref(_Resource* __res) noexcept
+      : _Resource_base<_Alloc_type, _WrapperType::_Reference>(
+          __res, &__alloc_vtable<_Alloc_type, _WrapperType::_Reference, _Resource>)
+      , __vtable(__vtable::template _Create<_Resource>())
+  {}
+
+  //! @brief Conversion from a \c basic_resource_ref with the same set of properties but in a different order
+  //! @param __ref The other \c basic_resource_ref
+  _CCCL_TEMPLATE(class... _OtherProperties)
+  _CCCL_REQUIRES(__properties_match<_OtherProperties...>)
+  basic_resource_ref(basic_resource_ref<_Alloc_type, _OtherProperties...> __ref) noexcept
+      : _Resource_base<_Alloc_type, _WrapperType::_Reference>(__ref.__object, __ref.__static_vtable)
+      , __vtable(static_cast<const _Filtered_vtable<_OtherProperties...>&>(__ref))
+  {}
+
+  //! @brief Conversion from a \c async_resource_ref with the same set of properties but in a different order to a
+  //! \c resource_ref
+  //! @param __ref The other \c async_resource_ref
+  _CCCL_TEMPLATE(_AllocType _OtherAllocType, class... _OtherProperties)
+  _CCCL_REQUIRES((_OtherAllocType == _AllocType::_Async) _CCCL_AND(_OtherAllocType != _Alloc_type)
+                   _CCCL_AND __properties_match<_OtherProperties...>)
+  basic_resource_ref(basic_resource_ref<_OtherAllocType, _OtherProperties...> __ref) noexcept
+      : _Resource_base<_Alloc_type, _WrapperType::_Reference>(__ref.__object, __ref.__static_vtable)
+      , __vtable(static_cast<const _Filtered_vtable<_OtherProperties...>&>(__ref))
+  {}
+
+  //! @brief Equality comparison between two \c basic_resource_ref
+  //! @param __lhs The first \c basic_resource_ref
+  //! @param __rhs The second \c basic_resource_ref
+  //! @return Checks whether both resources have the same equality function stored in their vtable and if so returns
+  //! the result of that equality comparison. Otherwise returns false.
+  _CCCL_NODISCARD_FRIEND bool operator==(const basic_resource_ref& __lhs, const basic_resource_ref& __rhs)
+  {
+    // BUGBUG: comparing function pointers like this can lead to false negatives:
+    return (__lhs.__static_vtable->__equal_fn == __rhs.__static_vtable->__equal_fn)
+        && __lhs.__static_vtable->__equal_fn(__lhs.__object, __rhs.__object);
+  }
+
+  //! @overload
+  _CCCL_TEMPLATE(class... _OtherProperties)
+  _CCCL_REQUIRES((sizeof...(_Properties) == sizeof...(_OtherProperties))
+                   _CCCL_AND __properties_match<_OtherProperties...>)
+  _CCCL_NODISCARD bool operator==(const basic_resource_ref<_Alloc_type, _OtherProperties...>& __rhs) const
+  {
+    // BUGBUG: comparing function pointers like this can lead to false negatives:
+    return (this->__static_vtable->__equal_fn == __rhs.__static_vtable->__equal_fn)
+        && this->__static_vtable->__equal_fn(this->__object, __rhs.__object);
+  }
+
+  //! @brief Inequality comparison between two \c basic_resource_ref
+  //! @param __lhs The first \c basic_resource_ref
+  //! @param __rhs The second \c basic_resource_ref
+  //! @return Checks whether both resources have the same equality function stored in their vtable and if so returns
+  //! the inverse result of that equality comparison. Otherwise returns true.
+  _CCCL_NODISCARD_FRIEND bool operator!=(const basic_resource_ref& __lhs, const basic_resource_ref& __rhs)
+  {
+    return !(__lhs == __rhs);
+  }
+
+  //! @overload
+  _CCCL_TEMPLATE(class... _OtherProperties)
+  _CCCL_REQUIRES((sizeof...(_Properties) == sizeof...(_OtherProperties))
+                   _CCCL_AND __properties_match<_OtherProperties...>)
+  _CCCL_NODISCARD bool operator!=(const basic_resource_ref<_Alloc_type, _OtherProperties...>& __rhs) const
+  {
+    return !(*this == __rhs);
+  }
+
+  //! @brief Forwards the stateless properties
+  _CCCL_TEMPLATE(class _Property)
+  _CCCL_REQUIRES((!property_with_value<_Property>) _CCCL_AND _CUDA_VSTD::__is_included_in_v<_Property, _Properties...>)
+  friend void get_property(const basic_resource_ref&, _Property) noexcept {}
+
+  //! @brief Forwards the stateful properties
+  _CCCL_TEMPLATE(class _Property)
+  _CCCL_REQUIRES(property_with_value<_Property> _CCCL_AND _CUDA_VSTD::__is_included_in_v<_Property, _Properties...>)
+  _CCCL_NODISCARD_FRIEND __property_value_t<_Property> get_property(const basic_resource_ref& __res, _Property) noexcept
+  {
+    return __res._Property_vtable<_Property>::__property_fn(__res.__object);
+  }
+};
+
+//! @brief Type erased wrapper around a `resource` that satisfies \tparam _Properties
+//! @tparam _Properties The properties that any resource wrapped within the `resource_ref` needs to satisfy
+template <class... _Properties>
+using resource_ref = basic_resource_ref<_AllocType::_Default, _Properties...>;
+
+//! @brief Type erased wrapper around a `async_resource` that satisfies \tparam _Properties
+//! @tparam _Properties The properties that any async resource wrapped within the `async_resource_ref` needs to satisfy
+template <class... _Properties>
+using async_resource_ref = basic_resource_ref<_AllocType::_Async, _Properties...>;
+
+_LIBCUDACXX_END_NAMESPACE_CUDA_MR
+
+#  endif // _CCCL_STD_VER >= 2014
+
+#endif // !_CCCL_COMPILER(MSVC2017) && LIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE
+
+#endif //_CUDA__MEMORY_RESOURCE_RESOURCE_REF_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/__type_traits/is_floating_point.h

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// 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__TYPE_TRAITS_IS_FLOATING_POINT_H
+#define __CUDA__TYPE_TRAITS_IS_FLOATING_POINT_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/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_extended_floating_point.h>
+#include <cuda/std/__type_traits/is_floating_point.h>
+#include <cuda/std/__type_traits/remove_cv.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_floating_point
+    : _CUDA_VSTD::bool_constant<_CUDA_VSTD::is_floating_point<_CUDA_VSTD::remove_cv_t<_Tp>>::value
+                                || _CUDA_VSTD::__is_extended_floating_point<_CUDA_VSTD::remove_cv_t<_Tp>>::value>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_floating_point_v =
+  _CUDA_VSTD::is_floating_point_v<_CUDA_VSTD::remove_cv_t<_Tp>>
+  || _CUDA_VSTD::__is_extended_floating_point_v<_CUDA_VSTD::remove_cv_t<_Tp>>;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // __CUDA__TYPE_TRAITS_IS_FLOATING_POINT_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__memory/temporary_buffer.h

@@ -0,0 +1,89 @@
+// -*- 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_TEMPORARY_BUFFER_H
+#define _LIBCUDACXX___MEMORY_TEMPORARY_BUFFER_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/__iterator/iterator.h>
+#include <cuda/std/__iterator/iterator_traits.h>
+#include <cuda/std/__memory/addressof.h>
+#include <cuda/std/__new_>
+#include <cuda/std/__type_traits/alignment_of.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/__utility/pair.h>
+#include <cuda/std/cstddef>
+#include <cuda/std/limits>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+_CCCL_NODISCARD _LIBCUDACXX_NO_CFI _LIBCUDACXX_HIDE_FROM_ABI pair<_Tp*, ptrdiff_t>
+get_temporary_buffer(ptrdiff_t __n) noexcept
+{
+  pair<_Tp*, ptrdiff_t> __r(0, 0);
+  const ptrdiff_t __m =
+    (~ptrdiff_t(0) ^ ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1))) / sizeof(_Tp);
+  if (__n > __m)
+  {
+    __n = __m;
+  }
+  while (__n > 0)
+  {
+#if !defined(_LIBCUDACXX_HAS_NO_ALIGNED_ALLOCATION)
+    if (__is_overaligned_for_new(_LIBCUDACXX_ALIGNOF(_Tp)))
+    {
+      _CUDA_VSTD::align_val_t __al = _CUDA_VSTD::align_val_t(_CUDA_VSTD::alignment_of<_Tp>::value);
+      __r.first                    = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
+    }
+    else
+    {
+      __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
+    }
+#else // ^^^ !_LIBCUDACXX_HAS_NO_ALIGNED_ALLOCATION ^^^ / vvv _LIBCUDACXX_HAS_NO_ALIGNED_ALLOCATION vvv
+    if (__is_overaligned_for_new(_LIBCUDACXX_ALIGNOF(_Tp)))
+    {
+      // Since aligned operator new is unavailable, return an empty
+      // buffer rather than one with invalid alignment.
+      return __r;
+    }
+
+    __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
+#endif // _LIBCUDACXX_HAS_NO_ALIGNED_ALLOCATION
+
+    if (__r.first)
+    {
+      __r.second = __n;
+      break;
+    }
+    __n /= 2;
+  }
+  return __r;
+}
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI void return_temporary_buffer(_Tp* __p) noexcept
+{
+  _CUDA_VSTD::__cccl_deallocate_unsized((void*) __p, _LIBCUDACXX_ALIGNOF(_Tp));
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_TEMPORARY_BUFFER_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/nv/detail/__preprocessor

@@ -0,0 +1,176 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__GNUC__)
+#  pragma GCC system_header
+#endif
+
+// For all compilers and dialects this header defines:
+//  _NV_EVAL
+//  _NV_IF
+//  _NV_CONCAT_EVAL
+// For C++11 and up it defines:
+//  _NV_STRIP_PAREN
+//  _NV_DISPATCH_N_ARY
+//  _NV_FIRST_ARG
+//  _NV_REMOVE_PAREN
+
+#if defined(_NV_TARGET_CPP11)
+#  define _NV_EVAL1(...) __VA_ARGS__
+#  define _NV_EVAL(...)  _NV_EVAL1(__VA_ARGS__)
+#else
+#  define _NV_EVAL1(x) x
+#  define _NV_EVAL(x)  _NV_EVAL1(x)
+#endif // C++11
+
+#define _NV_CONCAT_EVAL1(l, r) _NV_EVAL(l##r)
+#define _NV_CONCAT_EVAL(l, r)  _NV_CONCAT_EVAL1(l, r)
+
+#define _NV_IF_0(t, f) f
+#define _NV_IF_1(t, f) t
+
+#define _NV_IF_BIT(b)           _NV_EVAL(_NV_IF_##b)
+#define _NV_IF__EVAL(fn, t, f)  _NV_EVAL(fn(t, f))
+#define _NV_IF_EVAL(cond, t, f) _NV_IF__EVAL(_NV_IF_BIT(cond), t, f)
+
+#define _NV_IF1(cond, t, f) _NV_IF_EVAL(cond, t, f)
+#define _NV_IF(cond, t, f)  _NV_IF1(_NV_EVAL(cond), _NV_EVAL(t), _NV_EVAL(f))
+
+#if defined(_NV_TARGET_CPP11)
+
+// The below mechanisms were derived from: https://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments/
+
+#  define _NV_ARG32(...) _NV_EVAL(_NV_ARG32_0(__VA_ARGS__))
+#  define _NV_ARG32_0( \
+    _0,                \
+    _1,                \
+    _2,                \
+    _3,                \
+    _4,                \
+    _5,                \
+    _6,                \
+    _7,                \
+    _8,                \
+    _9,                \
+    _10,               \
+    _11,               \
+    _12,               \
+    _13,               \
+    _14,               \
+    _15,               \
+    _16,               \
+    _17,               \
+    _18,               \
+    _19,               \
+    _20,               \
+    _21,               \
+    _22,               \
+    _23,               \
+    _24,               \
+    _25,               \
+    _26,               \
+    _27,               \
+    _28,               \
+    _29,               \
+    _30,               \
+    _31,               \
+    ...)               \
+    _31
+
+#  define _NV_HAS_COMMA(...) \
+    _NV_ARG32(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0)
+
+#  define _NV_TRIGGER_PARENTHESIS_(...) ,
+
+#  define _NV_ISEMPTY(...)                                                                                            \
+    _NV_ISEMPTY0(/* test if there is just one argument, eventually an empty                                           \
+                    one */                                                                                            \
+                 _NV_EVAL(_NV_HAS_COMMA(__VA_ARGS__)), /* test if _TRIGGER_PARENTHESIS_ together with the argument    \
+                                                          adds a comma */                                             \
+                 _NV_EVAL(_NV_HAS_COMMA(_NV_TRIGGER_PARENTHESIS_ __VA_ARGS__)), /* test if the argument together with \
+                                                                                   a parenthesis adds a comma */      \
+                 _NV_EVAL(_NV_HAS_COMMA(__VA_ARGS__(/*empty*/))), /* test if placing it between _TRIGGER_PARENTHESIS_ \
+                                                                     and the parenthesis adds a comma */              \
+                 _NV_EVAL(_NV_HAS_COMMA(_NV_TRIGGER_PARENTHESIS_ __VA_ARGS__(/*empty*/))))
+
+#  define _NV_PASTE5(_0, _1, _2, _3, _4) _0##_1##_2##_3##_4
+#  define _NV_ISEMPTY0(_0, _1, _2, _3)   _NV_HAS_COMMA(_NV_PASTE5(_NV_IS_EMPTY_CASE_, _0, _1, _2, _3))
+#  define _NV_IS_EMPTY_CASE_0001         ,
+
+#  define _NV_REMOVE_PAREN(...) _NV_REMOVE_PAREN1(__VA_ARGS__)
+#  define _NV_REMOVE_PAREN1(...) \
+    _NV_STRIP_PAREN(_NV_IF(_NV_TEST_PAREN(__VA_ARGS__), (_NV_STRIP_PAREN(__VA_ARGS__)), (__VA_ARGS__)))
+
+#  define _NV_STRIP_PAREN2(...) __VA_ARGS__
+#  define _NV_STRIP_PAREN1(...) _NV_STRIP_PAREN2 __VA_ARGS__
+#  define _NV_STRIP_PAREN(...)  _NV_STRIP_PAREN1(__VA_ARGS__)
+
+#  define _NV_TEST_PAREN(...)  _NV_TEST_PAREN1(__VA_ARGS__)
+#  define _NV_TEST_PAREN1(...) _NV_TEST_PAREN2(_NV_TEST_PAREN_DUMMY __VA_ARGS__)
+#  define _NV_TEST_PAREN2(...) _NV_TEST_PAREN3(_NV_CONCAT_EVAL(_, __VA_ARGS__))
+#  define _NV_TEST_PAREN3(...) _NV_EVAL(_NV_FIRST_ARG(__VA_ARGS__))
+
+#  define __NV_PAREN_YES 1
+#  define __NV_PAREN_NO  0
+
+#  define _NV_TEST_PAREN_DUMMY(...) _NV_PAREN_YES
+#  define __NV_TEST_PAREN_DUMMY     __NV_PAREN_NO,
+
+#  define _NV_FIRST_ARG1(x, ...) x
+#  define _NV_FIRST_ARG(x, ...)  _NV_FIRST_ARG1(x)
+
+#  define _NV_REMOVE_FIRST_ARGS1(...)   __VA_ARGS__
+#  define _NV_REMOVE_FIRST_ARGS(x, ...) _NV_REMOVE_FIRST_ARGS1(__VA_ARGS__)
+
+#  define _NV_NUM_ARGS(...)  _NV_NUM_ARGS0(__VA_ARGS__)
+#  define _NV_NUM_ARGS0(...) _NV_EVAL(_NV_NUM_ARGS1(__VA_ARGS__))
+#  define _NV_NUM_ARGS1(...) _NV_IF(_NV_ISEMPTY(__VA_ARGS__), 0, _NV_NUM_ARGS2(__VA_ARGS__))
+#  define _NV_NUM_ARGS2(...) \
+    _NV_ARG32(               \
+      __VA_ARGS__,           \
+      31,                    \
+      30,                    \
+      29,                    \
+      28,                    \
+      27,                    \
+      26,                    \
+      25,                    \
+      24,                    \
+      23,                    \
+      22,                    \
+      21,                    \
+      20,                    \
+      19,                    \
+      18,                    \
+      17,                    \
+      16,                    \
+      15,                    \
+      14,                    \
+      13,                    \
+      12,                    \
+      11,                    \
+      10,                    \
+      9,                     \
+      8,                     \
+      7,                     \
+      6,                     \
+      5,                     \
+      4,                     \
+      3,                     \
+      2,                     \
+      1,                     \
+      0)
+
+#  define _NV_DISPATCH_N_IMPL1(name, ...)        _NV_EVAL(name(__VA_ARGS__))
+#  define _NV_DISPATCH_N_IMPL0(depth, name, ...) _NV_DISPATCH_N_IMPL1(_NV_CONCAT_EVAL(name, depth), __VA_ARGS__)
+#  define _NV_DISPATCH_N_IMPL(name, ...)         _NV_DISPATCH_N_IMPL0(_NV_NUM_ARGS(__VA_ARGS__), name, __VA_ARGS__)
+#  define _NV_DISPATCH_N_ARY(name, ...)          _NV_DISPATCH_N_IMPL(name, __VA_ARGS__)
+
+#endif // C++11

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/nv/detail/__target_macros

@@ -0,0 +1,610 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _NV__TARGET_MACROS
+#define _NV__TARGET_MACROS
+
+#include <nv/detail/__preprocessor>
+
+#if defined(__GNUC__)
+#  pragma GCC system_header
+#endif
+
+#define _NV_TARGET_ARCH_TO_SELECTOR_350  nv::target::sm_35
+#define _NV_TARGET_ARCH_TO_SELECTOR_370  nv::target::sm_37
+#define _NV_TARGET_ARCH_TO_SELECTOR_500  nv::target::sm_50
+#define _NV_TARGET_ARCH_TO_SELECTOR_520  nv::target::sm_52
+#define _NV_TARGET_ARCH_TO_SELECTOR_530  nv::target::sm_53
+#define _NV_TARGET_ARCH_TO_SELECTOR_600  nv::target::sm_60
+#define _NV_TARGET_ARCH_TO_SELECTOR_610  nv::target::sm_61
+#define _NV_TARGET_ARCH_TO_SELECTOR_620  nv::target::sm_62
+#define _NV_TARGET_ARCH_TO_SELECTOR_700  nv::target::sm_70
+#define _NV_TARGET_ARCH_TO_SELECTOR_720  nv::target::sm_72
+#define _NV_TARGET_ARCH_TO_SELECTOR_750  nv::target::sm_75
+#define _NV_TARGET_ARCH_TO_SELECTOR_800  nv::target::sm_80
+#define _NV_TARGET_ARCH_TO_SELECTOR_860  nv::target::sm_86
+#define _NV_TARGET_ARCH_TO_SELECTOR_870  nv::target::sm_87
+#define _NV_TARGET_ARCH_TO_SELECTOR_890  nv::target::sm_89
+#define _NV_TARGET_ARCH_TO_SELECTOR_900  nv::target::sm_90
+#define _NV_TARGET_ARCH_TO_SELECTOR_1000 nv::target::sm_100
+#define _NV_TARGET_ARCH_TO_SELECTOR_1010 nv::target::sm_101
+#define _NV_TARGET_ARCH_TO_SELECTOR_1200 nv::target::sm_120
+
+#define _NV_TARGET_ARCH_TO_SM_350  35
+#define _NV_TARGET_ARCH_TO_SM_370  37
+#define _NV_TARGET_ARCH_TO_SM_500  50
+#define _NV_TARGET_ARCH_TO_SM_520  52
+#define _NV_TARGET_ARCH_TO_SM_530  53
+#define _NV_TARGET_ARCH_TO_SM_600  60
+#define _NV_TARGET_ARCH_TO_SM_610  61
+#define _NV_TARGET_ARCH_TO_SM_620  62
+#define _NV_TARGET_ARCH_TO_SM_700  70
+#define _NV_TARGET_ARCH_TO_SM_720  72
+#define _NV_TARGET_ARCH_TO_SM_750  75
+#define _NV_TARGET_ARCH_TO_SM_800  80
+#define _NV_TARGET_ARCH_TO_SM_860  86
+#define _NV_TARGET_ARCH_TO_SM_870  87
+#define _NV_TARGET_ARCH_TO_SM_890  89
+#define _NV_TARGET_ARCH_TO_SM_900  90
+#define _NV_TARGET_ARCH_TO_SM_1000 100
+#define _NV_TARGET_ARCH_TO_SM_1010 101
+#define _NV_TARGET_ARCH_TO_SM_1200 120
+
+// Only enable when compiling for CUDA/stdpar
+#if defined(_NV_COMPILER_NVCXX) && defined(_NVHPC_CUDA)
+
+#  define _NV_TARGET_VAL_SM_35  nv::target::sm_35
+#  define _NV_TARGET_VAL_SM_37  nv::target::sm_37
+#  define _NV_TARGET_VAL_SM_50  nv::target::sm_50
+#  define _NV_TARGET_VAL_SM_52  nv::target::sm_52
+#  define _NV_TARGET_VAL_SM_53  nv::target::sm_53
+#  define _NV_TARGET_VAL_SM_60  nv::target::sm_60
+#  define _NV_TARGET_VAL_SM_61  nv::target::sm_61
+#  define _NV_TARGET_VAL_SM_62  nv::target::sm_62
+#  define _NV_TARGET_VAL_SM_70  nv::target::sm_70
+#  define _NV_TARGET_VAL_SM_72  nv::target::sm_72
+#  define _NV_TARGET_VAL_SM_75  nv::target::sm_75
+#  define _NV_TARGET_VAL_SM_80  nv::target::sm_80
+#  define _NV_TARGET_VAL_SM_86  nv::target::sm_86
+#  define _NV_TARGET_VAL_SM_87  nv::target::sm_87
+#  define _NV_TARGET_VAL_SM_89  nv::target::sm_89
+#  define _NV_TARGET_VAL_SM_90  nv::target::sm_90
+#  define _NV_TARGET_VAL_SM_100 nv::target::sm_100
+#  define _NV_TARGET_VAL_SM_101 nv::target::sm_101
+#  define _NV_TARGET_VAL_SM_120 nv::target::sm_120
+
+#  define _NV_TARGET___NV_IS_HOST   nv::target::is_host
+#  define _NV_TARGET___NV_IS_DEVICE nv::target::is_device
+
+#  define _NV_TARGET___NV_ANY_TARGET (nv::target::any_target)
+#  define _NV_TARGET___NV_NO_TARGET  (nv::target::no_target)
+
+#  if defined(NV_TARGET_SM_INTEGER_LIST)
+#    define NV_TARGET_MINIMUM_SM_SELECTOR _NV_FIRST_ARG(NV_TARGET_SM_SELECTOR_LIST)
+#    define NV_TARGET_MINIMUM_SM_INTEGER  _NV_FIRST_ARG(NV_TARGET_SM_INTEGER_LIST)
+#    define __CUDA_MINIMUM_ARCH__         _NV_CONCAT_EVAL(_NV_FIRST_ARG(NV_TARGET_SM_INTEGER_LIST), 0)
+#  endif
+
+#  define _NV_TARGET_PROVIDES(q)   nv::target::provides(q)
+#  define _NV_TARGET_IS_EXACTLY(q) nv::target::is_exactly(q)
+
+#elif defined(_NV_COMPILER_NVCC) || defined(_NV_COMPILER_CLANG_CUDA)
+
+#  define _NV_TARGET_VAL_SM_35  350
+#  define _NV_TARGET_VAL_SM_37  370
+#  define _NV_TARGET_VAL_SM_50  500
+#  define _NV_TARGET_VAL_SM_52  520
+#  define _NV_TARGET_VAL_SM_53  530
+#  define _NV_TARGET_VAL_SM_60  600
+#  define _NV_TARGET_VAL_SM_61  610
+#  define _NV_TARGET_VAL_SM_62  620
+#  define _NV_TARGET_VAL_SM_70  700
+#  define _NV_TARGET_VAL_SM_72  720
+#  define _NV_TARGET_VAL_SM_75  750
+#  define _NV_TARGET_VAL_SM_80  800
+#  define _NV_TARGET_VAL_SM_86  860
+#  define _NV_TARGET_VAL_SM_87  870
+#  define _NV_TARGET_VAL_SM_89  890
+#  define _NV_TARGET_VAL_SM_90  900
+#  define _NV_TARGET_VAL_SM_100 1000
+#  define _NV_TARGET_VAL_SM_101 1010
+#  define _NV_TARGET_VAL_SM_120 1200
+
+#  if defined(__CUDA_ARCH__)
+#    define _NV_TARGET_VAL                __CUDA_ARCH__
+#    define NV_TARGET_MINIMUM_SM_SELECTOR _NV_CONCAT_EVAL(_NV_TARGET_ARCH_TO_SELECTOR_, __CUDA_ARCH__)
+#    define NV_TARGET_MINIMUM_SM_INTEGER  _NV_CONCAT_EVAL(_NV_TARGET_ARCH_TO_SM_, __CUDA_ARCH__)
+#    define __CUDA_MINIMUM_ARCH__         __CUDA_ARCH__
+#  endif
+
+#  if defined(__CUDA_ARCH__)
+#    define _NV_TARGET_IS_HOST   0
+#    define _NV_TARGET_IS_DEVICE 1
+#  else
+#    define _NV_TARGET_IS_HOST   1
+#    define _NV_TARGET_IS_DEVICE 0
+#  endif
+
+#  if defined(_NV_TARGET_VAL)
+#    define _NV_DEVICE_CHECK(q) (q)
+#  else
+#    define _NV_DEVICE_CHECK(q) (0)
+#  endif
+
+#  define _NV_TARGET_PROVIDES(q)   _NV_DEVICE_CHECK(_NV_TARGET_VAL >= q)
+#  define _NV_TARGET_IS_EXACTLY(q) _NV_DEVICE_CHECK(_NV_TARGET_VAL == q)
+
+// NVCC/NVCXX not being used, only host dispatches allowed
+#else
+
+#  define _NV_COMPILER_NVCC
+
+#  define _NV_TARGET_VAL_SM_35  350
+#  define _NV_TARGET_VAL_SM_37  370
+#  define _NV_TARGET_VAL_SM_50  500
+#  define _NV_TARGET_VAL_SM_52  520
+#  define _NV_TARGET_VAL_SM_53  530
+#  define _NV_TARGET_VAL_SM_60  600
+#  define _NV_TARGET_VAL_SM_61  610
+#  define _NV_TARGET_VAL_SM_62  620
+#  define _NV_TARGET_VAL_SM_70  700
+#  define _NV_TARGET_VAL_SM_72  720
+#  define _NV_TARGET_VAL_SM_75  750
+#  define _NV_TARGET_VAL_SM_80  800
+#  define _NV_TARGET_VAL_SM_86  860
+#  define _NV_TARGET_VAL_SM_87  870
+#  define _NV_TARGET_VAL_SM_89  890
+#  define _NV_TARGET_VAL_SM_90  900
+#  define _NV_TARGET_VAL_SM_100 1000
+#  define _NV_TARGET_VAL_SM_101 1010
+#  define _NV_TARGET_VAL_SM_120 1200
+
+#  define _NV_TARGET_VAL 0
+
+#  define _NV_TARGET_IS_HOST   1
+#  define _NV_TARGET_IS_DEVICE 0
+
+#  define _NV_DEVICE_CHECK(q) (false)
+
+#  define _NV_TARGET_PROVIDES(q)   _NV_DEVICE_CHECK(_NV_TARGET_VAL >= q)
+#  define _NV_TARGET_IS_EXACTLY(q) _NV_DEVICE_CHECK(_NV_TARGET_VAL == q)
+
+#endif
+
+#define _NV_TARGET___NV_PROVIDES_SM_35  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_35))
+#define _NV_TARGET___NV_PROVIDES_SM_37  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_37))
+#define _NV_TARGET___NV_PROVIDES_SM_50  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_50))
+#define _NV_TARGET___NV_PROVIDES_SM_52  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_52))
+#define _NV_TARGET___NV_PROVIDES_SM_53  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_53))
+#define _NV_TARGET___NV_PROVIDES_SM_60  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_60))
+#define _NV_TARGET___NV_PROVIDES_SM_61  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_61))
+#define _NV_TARGET___NV_PROVIDES_SM_62  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_62))
+#define _NV_TARGET___NV_PROVIDES_SM_70  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_70))
+#define _NV_TARGET___NV_PROVIDES_SM_72  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_72))
+#define _NV_TARGET___NV_PROVIDES_SM_75  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_75))
+#define _NV_TARGET___NV_PROVIDES_SM_80  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_80))
+#define _NV_TARGET___NV_PROVIDES_SM_86  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_86))
+#define _NV_TARGET___NV_PROVIDES_SM_87  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_87))
+#define _NV_TARGET___NV_PROVIDES_SM_89  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_89))
+#define _NV_TARGET___NV_PROVIDES_SM_90  (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_90))
+#define _NV_TARGET___NV_PROVIDES_SM_100 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_100))
+#define _NV_TARGET___NV_PROVIDES_SM_101 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_101))
+#define _NV_TARGET___NV_PROVIDES_SM_120 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_120))
+
+#define _NV_TARGET___NV_IS_EXACTLY_SM_35  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_35))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_37  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_37))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_50  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_50))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_52  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_52))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_53  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_53))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_60  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_60))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_61  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_61))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_62  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_62))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_70  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_70))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_72  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_72))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_75  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_75))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_80  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_80))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_86  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_86))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_87  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_87))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_89  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_89))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_90  (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_90))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_100 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_100))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_101 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_101))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_120 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_120))
+
+#define NV_PROVIDES_SM_35  __NV_PROVIDES_SM_35
+#define NV_PROVIDES_SM_37  __NV_PROVIDES_SM_37
+#define NV_PROVIDES_SM_50  __NV_PROVIDES_SM_50
+#define NV_PROVIDES_SM_52  __NV_PROVIDES_SM_52
+#define NV_PROVIDES_SM_53  __NV_PROVIDES_SM_53
+#define NV_PROVIDES_SM_60  __NV_PROVIDES_SM_60
+#define NV_PROVIDES_SM_61  __NV_PROVIDES_SM_61
+#define NV_PROVIDES_SM_62  __NV_PROVIDES_SM_62
+#define NV_PROVIDES_SM_70  __NV_PROVIDES_SM_70
+#define NV_PROVIDES_SM_72  __NV_PROVIDES_SM_72
+#define NV_PROVIDES_SM_75  __NV_PROVIDES_SM_75
+#define NV_PROVIDES_SM_80  __NV_PROVIDES_SM_80
+#define NV_PROVIDES_SM_86  __NV_PROVIDES_SM_86
+#define NV_PROVIDES_SM_87  __NV_PROVIDES_SM_87
+#define NV_PROVIDES_SM_89  __NV_PROVIDES_SM_89
+#define NV_PROVIDES_SM_90  __NV_PROVIDES_SM_90
+#define NV_PROVIDES_SM_100 __NV_PROVIDES_SM_100
+#define NV_PROVIDES_SM_101 __NV_PROVIDES_SM_101
+#define NV_PROVIDES_SM_120 __NV_PROVIDES_SM_120
+
+#define NV_IS_EXACTLY_SM_35  __NV_IS_EXACTLY_SM_35
+#define NV_IS_EXACTLY_SM_37  __NV_IS_EXACTLY_SM_37
+#define NV_IS_EXACTLY_SM_50  __NV_IS_EXACTLY_SM_50
+#define NV_IS_EXACTLY_SM_52  __NV_IS_EXACTLY_SM_52
+#define NV_IS_EXACTLY_SM_53  __NV_IS_EXACTLY_SM_53
+#define NV_IS_EXACTLY_SM_60  __NV_IS_EXACTLY_SM_60
+#define NV_IS_EXACTLY_SM_61  __NV_IS_EXACTLY_SM_61
+#define NV_IS_EXACTLY_SM_62  __NV_IS_EXACTLY_SM_62
+#define NV_IS_EXACTLY_SM_70  __NV_IS_EXACTLY_SM_70
+#define NV_IS_EXACTLY_SM_72  __NV_IS_EXACTLY_SM_72
+#define NV_IS_EXACTLY_SM_75  __NV_IS_EXACTLY_SM_75
+#define NV_IS_EXACTLY_SM_80  __NV_IS_EXACTLY_SM_80
+#define NV_IS_EXACTLY_SM_86  __NV_IS_EXACTLY_SM_86
+#define NV_IS_EXACTLY_SM_87  __NV_IS_EXACTLY_SM_87
+#define NV_IS_EXACTLY_SM_89  __NV_IS_EXACTLY_SM_89
+#define NV_IS_EXACTLY_SM_90  __NV_IS_EXACTLY_SM_90
+#define NV_IS_EXACTLY_SM_100 __NV_IS_EXACTLY_SM_100
+#define NV_IS_EXACTLY_SM_101 __NV_IS_EXACTLY_SM_101
+#define NV_IS_EXACTLY_SM_120 __NV_IS_EXACTLY_SM_120
+
+// Disable SM_90a support on non-supporting compilers.
+// Will re-enable for nvcc below.
+#define NV_HAS_FEATURE_SM_90a  NV_NO_TARGET
+#define NV_HAS_FEATURE_SM_100a NV_NO_TARGET
+#define NV_HAS_FEATURE_SM_101a NV_NO_TARGET
+
+#define NV_IS_HOST   __NV_IS_HOST
+#define NV_IS_DEVICE __NV_IS_DEVICE
+
+#define NV_ANY_TARGET __NV_ANY_TARGET
+#define NV_NO_TARGET  __NV_NO_TARGET
+
+// Platform invoke mechanisms
+#if defined(_NV_COMPILER_NVCXX) && defined(_NVHPC_CUDA)
+
+#  define _NV_ARCH_COND(q) (_NV_TARGET_##q)
+
+#  define _NV_BLOCK_EXPAND(...) _NV_REMOVE_PAREN(__VA_ARGS__)
+
+#  define _NV_TARGET_IF(cond, t, ...) \
+    (if target _NV_ARCH_COND(cond) { _NV_BLOCK_EXPAND(t) } else {_NV_BLOCK_EXPAND(__VA_ARGS__)})
+
+#elif defined(_NV_COMPILER_NVCC) || defined(_NV_COMPILER_CLANG_CUDA)
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_35)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_35 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_35 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_37)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_37 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_37 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_50)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_50 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_50 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_52)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_52 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_52 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_53)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_53 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_53 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_60)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_60 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_60 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_61)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_61 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_61 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_62)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_62 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_62 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_70)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_70 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_70 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_72)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_72 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_72 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_75)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_75 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_75 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_80)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_80 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_80 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_86)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_86 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_86 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_87)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_87 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_87 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_89)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_89 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_89 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_90)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_90 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_90 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_100)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_100 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_100 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_101)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_101 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_101 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_120)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_120 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_120 0
+#  endif
+
+// Re-enable sm_90a support in nvcc.
+#  undef NV_HAS_FEATURE_SM_90a
+#  define NV_HAS_FEATURE_SM_90a __NV_HAS_FEATURE_SM_90a
+#  if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 900) && defined(__CUDA_ARCH_FEAT_SM90_ALL))
+#    define _NV_TARGET_BOOL___NV_HAS_FEATURE_SM_90a 1
+#  else
+#    define _NV_TARGET_BOOL___NV_HAS_FEATURE_SM_90a 0
+#  endif
+
+// Re-enable sm_100a support in nvcc.
+#  undef NV_HAS_FEATURE_SM_100a
+#  define NV_HAS_FEATURE_SM_100a __NV_HAS_FEATURE_SM_100a
+#  if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 1000) && defined(__CUDA_ARCH_FEAT_SM100_ALL))
+#    define _NV_TARGET_BOOL___NV_HAS_FEATURE_SM_100a 1
+#  else
+#    define _NV_TARGET_BOOL___NV_HAS_FEATURE_SM_100a 0
+#  endif
+
+// Re-enable sm_101a support in nvcc.
+#  undef NV_HAS_FEATURE_SM_101a
+#  define NV_HAS_FEATURE_SM_101a __NV_HAS_FEATURE_SM_101a
+#  if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 1010) && defined(__CUDA_ARCH_FEAT_SM101_ALL))
+#    define _NV_TARGET_BOOL___NV_HAS_FEATURE_SM_101a 1
+#  else
+#    define _NV_TARGET_BOOL___NV_HAS_FEATURE_SM_101a 0
+#  endif
+
+#  if (_NV_TARGET_IS_HOST)
+#    define _NV_TARGET_BOOL___NV_IS_HOST   1
+#    define _NV_TARGET_BOOL___NV_IS_DEVICE 0
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_HOST   0
+#    define _NV_TARGET_BOOL___NV_IS_DEVICE 1
+#  endif
+
+#  define _NV_TARGET_BOOL___NV_ANY_TARGET 1
+#  define _NV_TARGET_BOOL___NV_NO_TARGET  0
+
+// NVCC Greater than stuff
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_35)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_35 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_35 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_37)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_37 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_37 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_50)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_50 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_50 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_52)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_52 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_52 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_53)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_53 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_53 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_60)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_60 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_60 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_61)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_61 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_61 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_62)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_62 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_62 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_70)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_70 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_70 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_72)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_72 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_72 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_75)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_75 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_75 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_80)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_80 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_80 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_86)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_86 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_86 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_87)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_87 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_87 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_89)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_89 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_89 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_90)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_90 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_90 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_100)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_100 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_100 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_101)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_101 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_101 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_120)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_120 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_120 0
+#  endif
+
+#  define _NV_ARCH_COND_CAT1(cond) _NV_TARGET_BOOL_##cond
+#  define _NV_ARCH_COND_CAT(cond)  _NV_EVAL(_NV_ARCH_COND_CAT1(cond))
+
+#  define _NV_TARGET_EMPTY_PARAM ;
+
+#  if defined(_NV_TARGET_CPP11)
+
+#    define _NV_BLOCK_EXPAND(...)       {_NV_REMOVE_PAREN(__VA_ARGS__)}
+#    define _NV_TARGET_IF(cond, t, ...) _NV_IF(_NV_ARCH_COND_CAT(cond), t, __VA_ARGS__)
+
+#  else // <C++11 fallback
+
+#    define _NV_BLOCK_EXPAND(x) {x}
+
+#    define _NV_TARGET_IF(cond, t)         _NV_IF(_NV_ARCH_COND_CAT(cond), t, _NV_TARGET_EMPTY_PARAM)
+#    define _NV_TARGET_IF_ELSE(cond, t, f) _NV_IF(_NV_ARCH_COND_CAT(cond), t, f)
+
+#  endif
+
+#endif // _NV_COMPILER_NVCC
+
+#if defined(_NV_TARGET_CPP11)
+
+#  define _NV_TARGET_DISPATCH_HANDLE0()
+#  define _NV_TARGET_DISPATCH_HANDLE2(q, fn)       _NV_TARGET_IF(q, fn)
+#  define _NV_TARGET_DISPATCH_HANDLE4(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE2(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE6(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE4(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE8(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE6(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE10(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE8(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE12(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE10(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE14(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE12(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE16(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE14(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE18(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE16(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE20(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE18(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE22(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE20(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE24(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE22(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE26(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE24(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE28(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE26(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE30(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE28(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE32(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE30(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE34(q, fn, ...) _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE32(__VA_ARGS__))
+
+#  define _NV_TARGET_DISPATCH(...) _NV_BLOCK_EXPAND(_NV_DISPATCH_N_ARY(_NV_TARGET_DISPATCH_HANDLE, __VA_ARGS__))
+
+// NV_IF_TARGET supports a false statement provided as a variadic macro
+#  define NV_IF_TARGET(cond, ...)       _NV_BLOCK_EXPAND(_NV_TARGET_IF(cond, __VA_ARGS__))
+#  define NV_IF_ELSE_TARGET(cond, t, f) _NV_BLOCK_EXPAND(_NV_TARGET_IF(cond, t, f))
+#  define NV_DISPATCH_TARGET(...)       _NV_TARGET_DISPATCH(__VA_ARGS__)
+
+#else // <C++11 fallback
+
+// NV_IF_TARGET does not support a fallback false statement in C++03 or C dialects
+#  define NV_IF_TARGET(cond, t)         _NV_BLOCK_EXPAND(_NV_TARGET_IF(cond, t))
+#  define NV_IF_ELSE_TARGET(cond, t, f) _NV_BLOCK_EXPAND(_NV_TARGET_IF_ELSE(cond, t, f))
+
+#endif
+
+#endif // _NV__TARGET_MACROS

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/nv/target

@@ -0,0 +1,232 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+// This header contains a preview of a portability system that enables
+// CUDA C++ development with NVC++, NVCC, and supported host compilers.
+// These interfaces are not guaranteed to be stable.
+
+#ifndef __NV_TARGET_H
+#define __NV_TARGET_H
+
+#if defined(__NVCC__) || defined(__CUDACC_RTC__)
+#  define _NV_COMPILER_NVCC
+#elif defined(__NVCOMPILER) && __cplusplus >= 201103L
+#  define _NV_COMPILER_NVCXX
+#elif defined(__clang__) && defined(__CUDA__) && defined(__CUDA_ARCH__)
+// clang compiling CUDA code, device mode.
+#  define _NV_COMPILER_CLANG_CUDA
+#endif
+
+#if ((defined(__cplusplus) && __cplusplus >= 201103L) || (defined(_MSC_VER) && _MSVC_LANG >= 201103L))
+#  define _NV_TARGET_CPP11
+#endif
+
+// Hide `if target` support from NVRTC
+#if defined(_NV_TARGET_CPP11) && !defined(__CUDACC_RTC__)
+
+#  if defined(_NV_COMPILER_NVCXX)
+#    define _NV_BITSET_ATTRIBUTE [[nv::__target_bitset]]
+#  else
+#    define _NV_BITSET_ATTRIBUTE
+#  endif
+
+namespace nv
+{
+namespace target
+{
+namespace detail
+{
+
+typedef unsigned long long base_int_t;
+
+// No host specialization
+constexpr base_int_t all_hosts = 1;
+
+// NVIDIA GPUs
+constexpr base_int_t sm_35_bit  = 1 << 1;
+constexpr base_int_t sm_37_bit  = 1 << 2;
+constexpr base_int_t sm_50_bit  = 1 << 3;
+constexpr base_int_t sm_52_bit  = 1 << 4;
+constexpr base_int_t sm_53_bit  = 1 << 5;
+constexpr base_int_t sm_60_bit  = 1 << 6;
+constexpr base_int_t sm_61_bit  = 1 << 7;
+constexpr base_int_t sm_62_bit  = 1 << 8;
+constexpr base_int_t sm_70_bit  = 1 << 9;
+constexpr base_int_t sm_72_bit  = 1 << 10;
+constexpr base_int_t sm_75_bit  = 1 << 11;
+constexpr base_int_t sm_80_bit  = 1 << 12;
+constexpr base_int_t sm_86_bit  = 1 << 13;
+constexpr base_int_t sm_87_bit  = 1 << 14;
+constexpr base_int_t sm_89_bit  = 1 << 15;
+constexpr base_int_t sm_90_bit  = 1 << 16;
+constexpr base_int_t sm_100_bit = 1 << 17;
+constexpr base_int_t sm_101_bit = 1 << 18;
+constexpr base_int_t sm_120_bit = 1 << 19;
+constexpr base_int_t all_devices =
+  sm_35_bit | sm_37_bit | sm_50_bit | sm_52_bit | sm_53_bit | sm_60_bit | sm_61_bit | sm_62_bit | sm_70_bit | sm_72_bit
+  | sm_75_bit | sm_80_bit | sm_86_bit | sm_87_bit | sm_89_bit | sm_90_bit | sm_100_bit | sm_101_bit | sm_120_bit;
+
+// Store a set of targets as a set of bits
+struct _NV_BITSET_ATTRIBUTE target_description
+{
+  base_int_t targets;
+
+  constexpr target_description(base_int_t a)
+      : targets(a)
+  {}
+};
+
+// The type of the user-visible names of the NVIDIA GPU targets
+enum class sm_selector : base_int_t
+{
+  sm_35  = 35,
+  sm_37  = 37,
+  sm_50  = 50,
+  sm_52  = 52,
+  sm_53  = 53,
+  sm_60  = 60,
+  sm_61  = 61,
+  sm_62  = 62,
+  sm_70  = 70,
+  sm_72  = 72,
+  sm_75  = 75,
+  sm_80  = 80,
+  sm_86  = 86,
+  sm_87  = 87,
+  sm_89  = 89,
+  sm_90  = 90,
+  sm_100 = 100,
+  sm_101 = 101,
+  sm_120 = 120,
+};
+
+constexpr base_int_t toint(sm_selector a)
+{
+  return static_cast<base_int_t>(a);
+}
+
+constexpr base_int_t bitexact(sm_selector a)
+{
+  return toint(a) == 35  ? sm_35_bit
+       : toint(a) == 37  ? sm_37_bit
+       : toint(a) == 50  ? sm_50_bit
+       : toint(a) == 52  ? sm_52_bit
+       : toint(a) == 53  ? sm_53_bit
+       : toint(a) == 60  ? sm_60_bit
+       : toint(a) == 61  ? sm_61_bit
+       : toint(a) == 62  ? sm_62_bit
+       : toint(a) == 70  ? sm_70_bit
+       : toint(a) == 72  ? sm_72_bit
+       : toint(a) == 75  ? sm_75_bit
+       : toint(a) == 80  ? sm_80_bit
+       : toint(a) == 86  ? sm_86_bit
+       : toint(a) == 87  ? sm_87_bit
+       : toint(a) == 89  ? sm_89_bit
+       : toint(a) == 90  ? sm_90_bit
+       : toint(a) == 100 ? sm_100_bit
+       : toint(a) == 101 ? sm_101_bit
+       : toint(a) == 120 ? sm_120_bit
+                         : 0;
+}
+
+constexpr base_int_t bitrounddown(sm_selector a)
+{
+  return toint(a) >= 120 ? sm_120_bit
+       : toint(a) >= 101 ? sm_101_bit
+       : toint(a) >= 100 ? sm_100_bit
+       : toint(a) >= 90  ? sm_90_bit
+       : toint(a) >= 89  ? sm_89_bit
+       : toint(a) >= 87  ? sm_87_bit
+       : toint(a) >= 86  ? sm_86_bit
+       : toint(a) >= 80  ? sm_80_bit
+       : toint(a) >= 75  ? sm_75_bit
+       : toint(a) >= 72  ? sm_72_bit
+       : toint(a) >= 70  ? sm_70_bit
+       : toint(a) >= 62  ? sm_62_bit
+       : toint(a) >= 61  ? sm_61_bit
+       : toint(a) >= 60  ? sm_60_bit
+       : toint(a) >= 53  ? sm_53_bit
+       : toint(a) >= 52  ? sm_52_bit
+       : toint(a) >= 50  ? sm_50_bit
+       : toint(a) >= 37  ? sm_37_bit
+       : toint(a) >= 35  ? sm_35_bit
+                         : 0;
+}
+
+// Public API for NVIDIA GPUs
+
+constexpr target_description is_exactly(sm_selector a)
+{
+  return target_description(bitexact(a));
+}
+
+constexpr target_description provides(sm_selector a)
+{
+  return target_description(~(bitrounddown(a) - 1) & all_devices);
+}
+
+// Boolean operations on target sets
+
+constexpr target_description operator&&(target_description a, target_description b)
+{
+  return target_description(a.targets & b.targets);
+}
+
+constexpr target_description operator||(target_description a, target_description b)
+{
+  return target_description(a.targets | b.targets);
+}
+
+constexpr target_description operator!(target_description a)
+{
+  return target_description(~a.targets & (all_devices | all_hosts));
+}
+} // namespace detail
+
+using detail::sm_selector;
+using detail::target_description;
+
+// The predicates for basic host/device selection
+constexpr target_description is_host    = target_description(detail::all_hosts);
+constexpr target_description is_device  = target_description(detail::all_devices);
+constexpr target_description any_target = target_description(detail::all_hosts | detail::all_devices);
+constexpr target_description no_target  = target_description(0);
+
+// The public names for NVIDIA GPU architectures
+constexpr sm_selector sm_35  = sm_selector::sm_35;
+constexpr sm_selector sm_37  = sm_selector::sm_37;
+constexpr sm_selector sm_50  = sm_selector::sm_50;
+constexpr sm_selector sm_52  = sm_selector::sm_52;
+constexpr sm_selector sm_53  = sm_selector::sm_53;
+constexpr sm_selector sm_60  = sm_selector::sm_60;
+constexpr sm_selector sm_61  = sm_selector::sm_61;
+constexpr sm_selector sm_62  = sm_selector::sm_62;
+constexpr sm_selector sm_70  = sm_selector::sm_70;
+constexpr sm_selector sm_72  = sm_selector::sm_72;
+constexpr sm_selector sm_75  = sm_selector::sm_75;
+constexpr sm_selector sm_80  = sm_selector::sm_80;
+constexpr sm_selector sm_86  = sm_selector::sm_86;
+constexpr sm_selector sm_87  = sm_selector::sm_87;
+constexpr sm_selector sm_89  = sm_selector::sm_89;
+constexpr sm_selector sm_90  = sm_selector::sm_90;
+constexpr sm_selector sm_100 = sm_selector::sm_100;
+constexpr sm_selector sm_101 = sm_selector::sm_101;
+constexpr sm_selector sm_120 = sm_selector::sm_120;
+
+using detail::is_exactly;
+using detail::provides;
+} // namespace target
+} // namespace nv
+
+#endif // C++11  && !defined(__CUDACC_RTC__)
+
+#include <nv/detail/__target_macros>
+
+#endif // __NV_TARGET_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/adjacent_difference.h

@@ -0,0 +1,251 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file adjacent_difference.h
+ *  \brief Compute difference between consecutive elements of a range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup transformations Transformations
+ *  \{
+ */
+
+/*! \p adjacent_difference calculates the differences of adjacent elements in the
+ *  range <tt>[first, last)</tt>. That is, <tt>\*first</tt> is assigned to
+ *  <tt>\*result</tt>, and, for each iterator \p i in the range
+ *  <tt>[first + 1, last)</tt>, the difference of <tt>\*i</tt> and <tt>*(i - 1)</tt>
+ *  is assigned to <tt>\*(result + (i - first))</tt>.
+ *
+ *  This version of \p adjacent_difference uses <tt>operator-</tt> to calculate
+ *  differences.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \return The iterator <tt>result + (last - first)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \c x and \c y are objects of \p InputIterator's \c value_type, then \c x - \c is defined, and \p
+ * InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types, and the return
+ * type of <tt>x - y</tt> is convertible to a type in \p OutputIterator's set of \c value_types. \tparam OutputIterator
+ * is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \remark Note that \p result is permitted to be the same iterator as \p first. This is
+ *          useful for computing differences "in place".
+ *
+ *  The following code snippet demonstrates how to use \p adjacent_difference to compute
+ *  the difference between adjacent elements of a range using the \p thrust::device execution policy:
+ *
+ *  \code
+ *  #include <thrust/adjacent_difference.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
+ *  thrust::device_vector<int> d_data(h_data, h_data + 8);
+ *  thrust::device_vector<int> d_result(8);
+ *
+ *  thrust::adjacent_difference(thrust::device, d_data.begin(), d_data.end(), d_result.begin());
+ *
+ *  // d_result is now [1, 1, -1, 1, -1, 1, -1, 1]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
+ *  \see inclusive_scan
+ */
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator adjacent_difference(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result);
+
+/*! \p adjacent_difference calculates the differences of adjacent elements in the
+ *  range <tt>[first, last)</tt>. That is, <tt>*first</tt> is assigned to
+ *  <tt>\*result</tt>, and, for each iterator \p i in the range
+ *  <tt>[first + 1, last)</tt>, <tt>binary_op(\*i, \*(i - 1))</tt> is assigned to
+ *  <tt>\*(result + (i - first))</tt>.
+ *
+ *  This version of \p adjacent_difference uses the binary function \p binary_op to
+ *  calculate differences.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \param binary_op The binary function used to compute differences.
+ *  \return The iterator <tt>result + (last - first)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \p InputIterator's \c value_type is convertible to \p BinaryFunction's \c first_argument_type and
+ * \c second_argument_type, and \p InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of
+ * \c value_types. \tparam OutputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. \tparam BinaryFunction's \c
+ * result_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *
+ *  \remark Note that \p result is permitted to be the same iterator as \p first. This is
+ *          useful for computing differences "in place".
+ *
+ *  The following code snippet demonstrates how to use \p adjacent_difference to compute
+ *  the sum between adjacent elements of a range using the \p thrust::device execution policy:
+ *
+ *  \code
+ *  #include <thrust/adjacent_difference.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
+ *  thrust::device_vector<int> d_data(h_data, h_data + 8);
+ *  thrust::device_vector<int> d_result(8);
+ *
+ *  thrust::adjacent_difference(thrust::device, d_data.begin(), d_data.end(), d_result.begin(), thrust::plus<int>());
+ *
+ *  // d_result is now [1, 3, 3, 3, 3, 3, 3, 3]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
+ *  \see inclusive_scan
+ */
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename BinaryFunction>
+_CCCL_HOST_DEVICE OutputIterator adjacent_difference(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result,
+  BinaryFunction binary_op);
+
+/*! \p adjacent_difference calculates the differences of adjacent elements in the
+ *  range <tt>[first, last)</tt>. That is, <tt>\*first</tt> is assigned to
+ *  <tt>\*result</tt>, and, for each iterator \p i in the range
+ *  <tt>[first + 1, last)</tt>, the difference of <tt>\*i</tt> and <tt>*(i - 1)</tt>
+ *  is assigned to <tt>\*(result + (i - first))</tt>.
+ *
+ *  This version of \p adjacent_difference uses <tt>operator-</tt> to calculate
+ *  differences.
+ *
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \return The iterator <tt>result + (last - first)</tt>
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \c x and \c y are objects of \p InputIterator's \c value_type, then \c x - \c is defined, and \p
+ * InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types, and the return
+ * type of <tt>x - y</tt> is convertible to a type in \p OutputIterator's set of \c value_types. \tparam OutputIterator
+ * is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \remark Note that \p result is permitted to be the same iterator as \p first. This is
+ *          useful for computing differences "in place".
+ *
+ *  The following code snippet demonstrates how to use \p adjacent_difference to compute
+ *  the difference between adjacent elements of a range.
+ *
+ *  \code
+ *  #include <thrust/adjacent_difference.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
+ *  thrust::device_vector<int> d_data(h_data, h_data + 8);
+ *  thrust::device_vector<int> d_result(8);
+ *
+ *  thrust::adjacent_difference(d_data.begin(), d_data.end(), d_result.begin());
+ *
+ *  // d_result is now [1, 1, -1, 1, -1, 1, -1, 1]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
+ *  \see inclusive_scan
+ */
+template <typename InputIterator, typename OutputIterator>
+OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result);
+
+/*! \p adjacent_difference calculates the differences of adjacent elements in the
+ *  range <tt>[first, last)</tt>. That is, <tt>*first</tt> is assigned to
+ *  <tt>\*result</tt>, and, for each iterator \p i in the range
+ *  <tt>[first + 1, last)</tt>, <tt>binary_op(\*i, \*(i - 1))</tt> is assigned to
+ *  <tt>\*(result + (i - first))</tt>.
+ *
+ *  This version of \p adjacent_difference uses the binary function \p binary_op to
+ *  calculate differences.
+ *
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \param binary_op The binary function used to compute differences.
+ *  \return The iterator <tt>result + (last - first)</tt>
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \p InputIterator's \c value_type is convertible to \p BinaryFunction's \c first_argument_type and
+ * \c second_argument_type, and \p InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of
+ * \c value_types. \tparam OutputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. \tparam BinaryFunction's \c
+ * result_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *
+ *  \remark Note that \p result is permitted to be the same iterator as \p first. This is
+ *          useful for computing differences "in place".
+ *
+ *  The following code snippet demonstrates how to use \p adjacent_difference to compute
+ *  the sum between adjacent elements of a range.
+ *
+ *  \code
+ *  #include <thrust/adjacent_difference.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
+ *  thrust::device_vector<int> d_data(h_data, h_data + 8);
+ *  thrust::device_vector<int> d_result(8);
+ *
+ *  thrust::adjacent_difference(d_data.begin(), d_data.end(), d_result.begin(), thrust::plus<int>());
+ *
+ *  // d_result is now [1, 3, 3, 3, 3, 3, 3, 3]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
+ *  \see inclusive_scan
+ */
+template <typename InputIterator, typename OutputIterator, typename BinaryFunction>
+OutputIterator
+adjacent_difference(InputIterator first, InputIterator last, OutputIterator result, BinaryFunction binary_op);
+
+/*! \}
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/adjacent_difference.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/advance.h

@@ -0,0 +1,147 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file advance.h
+ *  \brief Advance an iterator by a given distance.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \p advance(i, n) increments the iterator \p i by the distance \p n.
+ *  If <tt>n > 0</tt> it is equivalent to executing <tt>++i</tt> \p n
+ *  times, and if <tt>n < 0</tt> it is equivalent to executing <tt>--i</tt>
+ *  \p n times. If <tt>n == 0</tt>, the call has no effect.
+ *
+ *  \param i The iterator to be advanced.
+ *  \param n The distance by which to advance the iterator.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>. \tparam Distance is an integral type that is convertible to \p InputIterator's distance type.
+ *
+ *  \pre \p n shall be negative only for bidirectional and random access iterators.
+ *
+ *  The following code snippet demonstrates how to use \p advance to increment
+ *  an iterator a given number of times.
+ *
+ *  \code
+ *  #include <thrust/advance.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec(13);
+ *  thrust::device_vector<int>::iterator iter = vec.begin();
+ *
+ *  thrust::advance(iter, 7);
+ *
+ *  // iter - vec.begin() == 7
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/advance
+ */
+template <typename InputIterator, typename Distance>
+_CCCL_HOST_DEVICE void advance(InputIterator& i, Distance n);
+
+/*! \p next(i, n) returns the \p n th successor of the iterator \p i.
+ *
+ *  \param i An iterator.
+ *  \param n The number of elements to advance.
+ *
+ *  \tparam InputIterator must meet the <a
+ * href="https://en.cppreference.com/w/cpp/named_req/InputIterator">InputIterator</a>.
+ *
+ *  \pre \p n shall be negative only for bidirectional and random access iterators.
+ *
+ *  The following code snippet demonstrates how to use \p next.
+ *
+ *  \code
+ *  #include <thrust/advance.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec(13);
+ *  thrust::device_vector<int>::iterator i0 = vec.begin();
+ *
+ *  auto i1 = thrust::next(i0);
+ *
+ *  // i0 - vec.begin() == 0
+ *  // i1 - vec.begin() == 1
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/next
+ */
+#if 0 // Doxygen only
+template <typename InputIterator, typename Distance>
+_CCCL_HOST_DEVICE
+InputIterator next(
+  InputIterator i
+, typename iterator_traits<InputIterator>::difference_type n = 1
+);
+#endif
+
+/*! \p prev(i, n) returns the \p n th predecessor of the iterator \p i.
+ *
+ *  \param i An iterator.
+ *  \param n The number of elements to descend.
+ *
+ *  \tparam BidirectionalIterator must meet the <a
+ * href="https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator">BidirectionalIterator</a>.
+ *
+ *  The following code snippet demonstrates how to use \p prev.
+ *
+ *  \code
+ *  #include <thrust/advance.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec(13);
+ *  thrust::device_vector<int>::iterator i0 = vec.end();
+ *
+ *  auto i1 = thrust::prev(i0);
+ *
+ *  // vec.end() - i0 == 0
+ *  // vec.end() - i1 == 1
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/prev
+ */
+#if 0 // Doxygen only
+template <typename BidirectionalIterator, typename Distance>
+_CCCL_HOST_DEVICE
+BidirectionalIterator prev(
+  BidirectionalIterator i
+, typename iterator_traits<BidirectionalIterator>::difference_type n = 1
+);
+#endif
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/advance.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/allocate_unique.h

@@ -0,0 +1,350 @@
+// Copyright (c) 2018 NVIDIA Corporation
+// Author: Bryce Adelstein Lelbach <brycelelbach@gmail.com>
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/memory_algorithms.h>
+#include <thrust/detail/memory_wrapper.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/type_deduction.h>
+
+#include <cuda/std/utility>
+
+THRUST_NAMESPACE_BEGIN
+
+// wg21.link/p0316r0
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace detail
+{
+
+template <typename Allocator, typename Pointer>
+void allocator_delete_impl(Allocator const& alloc, Pointer p, std::false_type)
+{
+  using traits =
+    typename detail::allocator_traits<typename std::remove_cv<typename std::remove_reference<Allocator>::type>::type>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  if (nullptr != pointer_traits<Pointer>::get(p))
+  {
+    traits::destroy(alloc_T, thrust::raw_pointer_cast(p));
+    traits::deallocate(alloc_T, p, 1);
+  }
+}
+
+template <typename Allocator, typename Pointer>
+void allocator_delete_impl(Allocator const& alloc, Pointer p, std::true_type)
+{
+  using traits =
+    typename detail::allocator_traits<typename std::remove_cv<typename std::remove_reference<Allocator>::type>::type>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  if (nullptr != pointer_traits<Pointer>::get(p))
+  {
+    traits::deallocate(alloc_T, p, 1);
+  }
+}
+
+} // namespace detail
+
+template <typename T, typename Allocator, bool Uninitialized = false>
+struct allocator_delete final
+{
+  using allocator_type =
+    typename std::remove_cv<typename std::remove_reference<Allocator>::type>::type::template rebind<T>::other;
+  using pointer = typename detail::allocator_traits<allocator_type>::pointer;
+
+  template <typename UAllocator>
+  allocator_delete(UAllocator&& other) noexcept
+      : alloc_(THRUST_FWD(other))
+  {}
+
+  template <typename U, typename UAllocator>
+  allocator_delete(allocator_delete<U, UAllocator> const& other) noexcept
+      : alloc_(other.get_allocator())
+  {}
+  template <typename U, typename UAllocator>
+  allocator_delete(allocator_delete<U, UAllocator>&& other) noexcept
+      : alloc_(std::move(other.get_allocator()))
+  {}
+
+  template <typename U, typename UAllocator>
+  allocator_delete& operator=(allocator_delete<U, UAllocator> const& other) noexcept
+  {
+    alloc_ = other.get_allocator();
+    return *this;
+  }
+  template <typename U, typename UAllocator>
+  allocator_delete& operator=(allocator_delete<U, UAllocator>&& other) noexcept
+  {
+    alloc_ = std::move(other.get_allocator());
+    return *this;
+  }
+
+  void operator()(pointer p)
+  {
+    std::integral_constant<bool, Uninitialized> ic;
+
+    detail::allocator_delete_impl(get_allocator(), p, ic);
+  }
+
+  allocator_type& get_allocator() noexcept
+  {
+    return alloc_;
+  }
+  allocator_type const& get_allocator() const noexcept
+  {
+    return alloc_;
+  }
+
+  void swap(allocator_delete& other) noexcept
+  {
+    using ::cuda::std::swap;
+    swap(alloc_, other.alloc_);
+  }
+
+private:
+  allocator_type alloc_;
+};
+
+template <typename T, typename Allocator>
+using uninitialized_allocator_delete = allocator_delete<T, Allocator, true>;
+
+namespace detail
+{
+
+template <typename Allocator, typename Pointer, typename Size>
+void array_allocator_delete_impl(Allocator const& alloc, Pointer p, Size count, std::false_type)
+{
+  using traits =
+    typename detail::allocator_traits<typename std::remove_cv<typename std::remove_reference<Allocator>::type>::type>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  if (nullptr != pointer_traits<Pointer>::get(p))
+  {
+    destroy_n(alloc_T, p, count);
+    traits::deallocate(alloc_T, p, count);
+  }
+}
+
+template <typename Allocator, typename Pointer, typename Size>
+void array_allocator_delete_impl(Allocator const& alloc, Pointer p, Size count, std::true_type)
+{
+  using traits =
+    typename detail::allocator_traits<typename std::remove_cv<typename std::remove_reference<Allocator>::type>::type>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  if (nullptr != pointer_traits<Pointer>::get(p))
+  {
+    traits::deallocate(alloc_T, p, count);
+  }
+}
+
+} // namespace detail
+
+template <typename T, typename Allocator, bool Uninitialized = false>
+struct array_allocator_delete final
+{
+  using allocator_type =
+    typename std::remove_cv<typename std::remove_reference<Allocator>::type>::type::template rebind<T>::other;
+  using pointer = typename detail::allocator_traits<allocator_type>::pointer;
+
+  template <typename UAllocator>
+  array_allocator_delete(UAllocator&& other, std::size_t n) noexcept
+      : alloc_(THRUST_FWD(other))
+      , count_(n)
+  {}
+
+  template <typename U, typename UAllocator>
+  array_allocator_delete(array_allocator_delete<U, UAllocator> const& other) noexcept
+      : alloc_(other.get_allocator())
+      , count_(other.count_)
+  {}
+  template <typename U, typename UAllocator>
+  array_allocator_delete(array_allocator_delete<U, UAllocator>&& other) noexcept
+      : alloc_(std::move(other.get_allocator()))
+      , count_(other.count_)
+  {}
+
+  template <typename U, typename UAllocator>
+  array_allocator_delete& operator=(array_allocator_delete<U, UAllocator> const& other) noexcept
+  {
+    alloc_ = other.get_allocator();
+    count_ = other.count_;
+    return *this;
+  }
+  template <typename U, typename UAllocator>
+  array_allocator_delete& operator=(array_allocator_delete<U, UAllocator>&& other) noexcept
+  {
+    alloc_ = std::move(other.get_allocator());
+    count_ = other.count_;
+    return *this;
+  }
+
+  void operator()(pointer p)
+  {
+    std::integral_constant<bool, Uninitialized> ic;
+
+    detail::array_allocator_delete_impl(get_allocator(), p, count_, ic);
+  }
+
+  allocator_type& get_allocator() noexcept
+  {
+    return alloc_;
+  }
+  allocator_type const& get_allocator() const noexcept
+  {
+    return alloc_;
+  }
+
+  void swap(array_allocator_delete& other) noexcept
+  {
+    using ::cuda::std::swap;
+    swap(alloc_, other.alloc_);
+    swap(count_, other.count_);
+  }
+
+private:
+  allocator_type alloc_;
+  std::size_t count_;
+};
+
+template <typename T, typename Allocator>
+using uninitialized_array_allocator_delete = array_allocator_delete<T, Allocator, true>;
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename Pointer, typename Lambda>
+struct tagged_deleter : Lambda
+{
+  _CCCL_HOST_DEVICE tagged_deleter(Lambda&& l)
+      : Lambda(THRUST_FWD(l))
+  {}
+
+  using pointer = Pointer;
+};
+
+template <typename Pointer, typename Lambda>
+_CCCL_HOST_DEVICE tagged_deleter<Pointer, Lambda> make_tagged_deleter(Lambda&& l)
+{
+  return tagged_deleter<Pointer, Lambda>(THRUST_FWD(l));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, typename Allocator, typename... Args>
+_CCCL_HOST std::unique_ptr<
+  T,
+  allocator_delete<T,
+                   typename detail::allocator_traits<typename std::remove_cv<
+                     typename std::remove_reference<Allocator>::type>::type>::template rebind_traits<T>::allocator_type>>
+allocate_unique(Allocator const& alloc, Args&&... args)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<typename std::remove_reference<Allocator>::type>::type>::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  auto hold_deleter = make_tagged_deleter<typename traits::pointer>([&alloc_T](typename traits::pointer p) {
+    traits::deallocate(alloc_T, p, 1);
+  });
+  using hold_t      = std::unique_ptr<T, decltype(hold_deleter)>;
+  auto hold         = hold_t(traits::allocate(alloc_T, 1), hold_deleter);
+
+  traits::construct(alloc_T, thrust::raw_pointer_cast(hold.get()), THRUST_FWD(args)...);
+  auto deleter = allocator_delete<T, typename traits::allocator_type>(alloc);
+  return std::unique_ptr<T, decltype(deleter)>(hold.release(), std::move(deleter));
+}
+
+template <typename T, typename Allocator>
+_CCCL_HOST
+std::unique_ptr<T,
+                uninitialized_allocator_delete<
+                  T,
+                  typename detail::allocator_traits<typename std::remove_cv<
+                    typename std::remove_reference<Allocator>::type>::type>::template rebind_traits<T>::allocator_type>>
+uninitialized_allocate_unique(Allocator const& alloc)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<typename std::remove_reference<Allocator>::type>::type>::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  auto hold_deleter = make_tagged_deleter<typename traits::pointer>([&alloc_T](typename traits::pointer p) {
+    traits::deallocate(alloc_T, p, 1);
+  });
+  using hold_t      = std::unique_ptr<T, decltype(hold_deleter)>;
+  auto hold         = hold_t(traits::allocate(alloc_T, 1), hold_deleter);
+
+  auto deleter = uninitialized_allocator_delete<T, typename traits::allocator_type>(alloc_T);
+  return std::unique_ptr<T, decltype(deleter)>(hold.release(), std::move(deleter));
+}
+
+template <typename T, typename Allocator, typename Size, typename... Args>
+_CCCL_HOST std::unique_ptr<
+  T[],
+  array_allocator_delete<T,
+                         typename detail::allocator_traits<typename std::remove_cv<typename std::remove_reference<
+                           Allocator>::type>::type>::template rebind_traits<T>::allocator_type>>
+allocate_unique_n(Allocator const& alloc, Size n, Args&&... args)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<typename std::remove_reference<Allocator>::type>::type>::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  auto hold_deleter = make_tagged_deleter<typename traits::pointer>([n, &alloc_T](typename traits::pointer p) {
+    traits::deallocate(alloc_T, p, n);
+  });
+  using hold_t      = std::unique_ptr<T[], decltype(hold_deleter)>;
+  auto hold         = hold_t(traits::allocate(alloc_T, n), hold_deleter);
+
+  uninitialized_construct_n_with_allocator(alloc_T, hold.get(), n, THRUST_FWD(args)...);
+  auto deleter = array_allocator_delete<T, typename traits::allocator_type>(alloc_T, n);
+  return std::unique_ptr<T[], decltype(deleter)>(hold.release(), std::move(deleter));
+}
+
+template <typename T, typename Allocator, typename Size>
+_CCCL_HOST
+std::unique_ptr<T[],
+                uninitialized_array_allocator_delete<
+                  T,
+                  typename detail::allocator_traits<typename std::remove_cv<
+                    typename std::remove_reference<Allocator>::type>::type>::template rebind_traits<T>::allocator_type>>
+uninitialized_allocate_unique_n(Allocator const& alloc, Size n)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<typename std::remove_reference<Allocator>::type>::type>::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  auto hold_deleter = make_tagged_deleter<typename traits::pointer>([n, &alloc_T](typename traits::pointer p) {
+    traits::deallocate(alloc_T, p, n);
+  });
+  using hold_t      = std::unique_ptr<T[], decltype(hold_deleter)>;
+  auto hold         = hold_t(traits::allocate(alloc_T, n), hold_deleter);
+
+  auto deleter = uninitialized_array_allocator_delete<T, typename traits::allocator_type>(alloc_T, n);
+  return std::unique_ptr<T[], decltype(deleter)>(hold.release(), std::move(deleter));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/binary_search.h

@@ -0,0 +1,1887 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file binary_search.h
+ *  \brief Search for values in sorted ranges.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+/*! \addtogroup searching
+ *  \ingroup algorithms
+ *  \{
+ */
+
+/*! \addtogroup binary_search Binary Search
+ *  \ingroup searching
+ *  \{
+ */
+
+//////////////////////
+// Scalar Functions //
+//////////////////////
+
+/*! \p lower_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the first position where value could be
+ * inserted without violating the ordering. This version of
+ * \p lower_bound uses <tt>operator<</tt> for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>*j < value</tt>.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return The furthermost iterator \c i, such that <tt>*i < value</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam LessThanComparable is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 0); // returns input.begin()
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 1); // returns input.begin() + 1
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 2); // returns input.begin() + 1
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 3); // returns input.begin() + 2
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 8); // returns input.begin() + 4
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 9); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+_CCCL_HOST_DEVICE ForwardIterator lower_bound(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  const LessThanComparable& value);
+
+/*! \p lower_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the first position where value could be
+ * inserted without violating the ordering. This version of
+ * \p lower_bound uses <tt>operator<</tt> for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>*j < value</tt>.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return The furthermost iterator \c i, such that <tt>*i < value</tt>.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam LessThanComparable is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::lower_bound(input.begin(), input.end(), 0); // returns input.begin()
+ *  thrust::lower_bound(input.begin(), input.end(), 1); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 2); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 3); // returns input.begin() + 2
+ *  thrust::lower_bound(input.begin(), input.end(), 8); // returns input.begin() + 4
+ *  thrust::lower_bound(input.begin(), input.end(), 9); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class LessThanComparable>
+ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const LessThanComparable& value);
+
+/*! \p lower_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the first position where value could be
+ * inserted without violating the ordering. This version of
+ * \p lower_bound uses function object \c comp for comparison
+ * and returns the furthermost iterator \c i in <tt>[first, last)</tt>
+ * such that, for every iterator \c j in <tt>[first, i)</tt>,
+ * <tt>comp(*j, value)</tt> is \c true.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return The furthermost iterator \c i, such that <tt>comp(*i, value)</tt> is \c true.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam T is comparable to \p ForwardIterator's \c value_type. \tparam StrictWeakOrdering is a model of
+ * <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::lower_bound(input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin()
+ *  thrust::lower_bound(input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
+ *  thrust::lower_bound(input.begin(), input.end(), 8, thrust::less<int>()); // returns input.begin() + 4
+ *  thrust::lower_bound(input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+_CCCL_HOST_DEVICE ForwardIterator lower_bound(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  const T& value,
+  StrictWeakOrdering comp);
+
+/*! \p lower_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the first position where value could be
+ * inserted without violating the ordering. This version of
+ * \p lower_bound uses function object \c comp for comparison
+ * and returns the furthermost iterator \c i in <tt>[first, last)</tt>
+ * such that, for every iterator \c j in <tt>[first, i)</tt>,
+ * <tt>comp(*j, value)</tt> is \c true.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return The furthermost iterator \c i, such that <tt>comp(*i, value)</tt> is \c true.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam T is comparable to \p ForwardIterator's \c value_type. \tparam StrictWeakOrdering is a model of
+ * <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::lower_bound(input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin()
+ *  thrust::lower_bound(input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
+ *  thrust::lower_bound(input.begin(), input.end(), 8, thrust::less<int>()); // returns input.begin() + 4
+ *  thrust::lower_bound(input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class T, class StrictWeakOrdering>
+ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& value, StrictWeakOrdering comp);
+
+/*! \p upper_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the last position where value could be
+ * inserted without violating the ordering. This version of
+ * \p upper_bound uses <tt>operator<</tt> for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>value < *j</tt>
+ * is \c false.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return The furthermost iterator \c i, such that <tt>value < *i</tt> is \c false.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam LessThanComparable is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelism:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 0); // returns input.begin() + 1
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 1); // returns input.begin() + 1
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 2); // returns input.begin() + 2
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 3); // returns input.begin() + 2
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 8); // returns input.end()
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 9); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+_CCCL_HOST_DEVICE ForwardIterator upper_bound(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  const LessThanComparable& value);
+
+/*! \p upper_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the last position where value could be
+ * inserted without violating the ordering. This version of
+ * \p upper_bound uses <tt>operator<</tt> for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>value < *j</tt>
+ * is \c false.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return The furthermost iterator \c i, such that <tt>value < *i</tt> is \c false.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam LessThanComparable is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::upper_bound(input.begin(), input.end(), 0); // returns input.begin() + 1
+ *  thrust::upper_bound(input.begin(), input.end(), 1); // returns input.begin() + 1
+ *  thrust::upper_bound(input.begin(), input.end(), 2); // returns input.begin() + 2
+ *  thrust::upper_bound(input.begin(), input.end(), 3); // returns input.begin() + 2
+ *  thrust::upper_bound(input.begin(), input.end(), 8); // returns input.end()
+ *  thrust::upper_bound(input.begin(), input.end(), 9); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class LessThanComparable>
+ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const LessThanComparable& value);
+
+/*! \p upper_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the last position where value could be
+ * inserted without violating the ordering. This version of
+ * \p upper_bound uses function object \c comp for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>comp(value, *j)</tt>
+ * is \c false.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return The furthermost iterator \c i, such that <tt>comp(value, *i)</tt> is \c false.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam T is comparable to \p ForwardIterator's \c value_type. \tparam StrictWeakOrdering is a model of
+ * <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin() +
+ * 1 thrust::upper_bound(thrust::device, input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() +
+ * 1 thrust::upper_bound(thrust::device, input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() +
+ * 2 thrust::upper_bound(thrust::device, input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() +
+ * 2 thrust::upper_bound(thrust::device, input.begin(), input.end(), 8, thrust::less<int>()); // returns input.end()
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+_CCCL_HOST_DEVICE ForwardIterator upper_bound(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  const T& value,
+  StrictWeakOrdering comp);
+
+/*! \p upper_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the last position where value could be
+ * inserted without violating the ordering. This version of
+ * \p upper_bound uses function object \c comp for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>comp(value, *j)</tt>
+ * is \c false.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return The furthermost iterator \c i, such that <tt>comp(value, *i)</tt> is \c false.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam T is comparable to \p ForwardIterator's \c value_type. \tparam StrictWeakOrdering is a model of
+ * <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::upper_bound(input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::upper_bound(input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::upper_bound(input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 2
+ *  thrust::upper_bound(input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
+ *  thrust::upper_bound(input.begin(), input.end(), 8, thrust::less<int>()); // returns input.end()
+ *  thrust::upper_bound(input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class T, class StrictWeakOrdering>
+ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& value, StrictWeakOrdering comp);
+
+/*! \p binary_search is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  Specifically, this version returns \c true if and only if
+ * there exists an iterator \c i in <tt>[first, last)</tt> such that
+ * <tt>*i < value</tt> and <tt>value < *i</tt> are both \c false.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return \c true if an equivalent element exists in <tt>[first, last)</tt>, otherwise \c false.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam LessThanComparable is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 0); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 1); // returns false
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 2); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 3); // returns false
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 8); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 9); // returns false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+_CCCL_HOST_DEVICE bool binary_search(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  const LessThanComparable& value);
+
+/*! \p binary_search is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  Specifically, this version returns \c true if and only if
+ * there exists an iterator \c i in <tt>[first, last)</tt> such that
+ * <tt>*i < value</tt> and <tt>value < *i</tt> are both \c false.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return \c true if an equivalent element exists in <tt>[first, last)</tt>, otherwise \c false.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam LessThanComparable is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::binary_search(input.begin(), input.end(), 0); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 1); // returns false
+ *  thrust::binary_search(input.begin(), input.end(), 2); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 3); // returns false
+ *  thrust::binary_search(input.begin(), input.end(), 8); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 9); // returns false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <class ForwardIterator, class LessThanComparable>
+bool binary_search(ForwardIterator first, ForwardIterator last, const LessThanComparable& value);
+
+/*! \p binary_search is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  Specifically, this version returns \c true if and only if
+ * there exists an iterator \c i in <tt>[first, last)</tt> such that
+ * <tt>comp(*i, value)</tt> and <tt>comp(value, *i)</tt> are both \c false.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return \c true if an equivalent element exists in <tt>[first, last)</tt>, otherwise \c false.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam T is comparable to \p ForwardIterator's \c value_type. \tparam StrictWeakOrdering is a model of
+ * <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 0, thrust::less<int>()); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 1, thrust::less<int>()); // returns false
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 2, thrust::less<int>()); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 3, thrust::less<int>()); // returns false
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 8, thrust::less<int>()); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 9, thrust::less<int>()); // returns false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+_CCCL_HOST_DEVICE bool binary_search(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  const T& value,
+  StrictWeakOrdering comp);
+
+/*! \p binary_search is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  Specifically, this version returns \c true if and only if
+ * there exists an iterator \c i in <tt>[first, last)</tt> such that
+ * <tt>comp(*i, value)</tt> and <tt>comp(value, *i)</tt> are both \c false.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return \c true if an equivalent element exists in <tt>[first, last)</tt>, otherwise \c false.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam T is comparable to \p ForwardIterator's \c value_type. \tparam StrictWeakOrdering is a model of
+ * <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::binary_search(input.begin(), input.end(), 0, thrust::less<int>()); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 1, thrust::less<int>()); // returns false
+ *  thrust::binary_search(input.begin(), input.end(), 2, thrust::less<int>()); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 3, thrust::less<int>()); // returns false
+ *  thrust::binary_search(input.begin(), input.end(), 8, thrust::less<int>()); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 9, thrust::less<int>()); // returns false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <class ForwardIterator, class T, class StrictWeakOrdering>
+bool binary_search(ForwardIterator first, ForwardIterator last, const T& value, StrictWeakOrdering comp);
+
+/*! \p equal_range is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. The
+ * value returned by \p equal_range is essentially a combination of
+ * the values returned by \p lower_bound and \p upper_bound: it returns
+ * a \p pair of iterators \c i and \c j such that \c i is the first
+ * position where value could be inserted without violating the
+ * ordering and \c j is the last position where value could be inserted
+ * without violating the ordering. It follows that every element in the
+ * range <tt>[i, j)</tt> is equivalent to value, and that
+ * <tt>[i, j)</tt> is the largest subrange of <tt>[first, last)</tt> that
+ * has this property.
+ *
+ * This version of \p equal_range returns a \p pair of iterators
+ * <tt>[i, j)</tt>, where \c i is the furthermost iterator in
+ * <tt>[first, last)</tt> such that, for every iterator \c k in
+ * <tt>[first, i)</tt>, <tt>*k < value</tt>.  \c j is the furthermost
+ * iterator in <tt>[first, last)</tt> such that, for every iterator
+ * \c k in <tt>[first, j)</tt>, <tt>value < *k</tt> is \c false.
+ * For every iterator \c k in <tt>[i, j)</tt>, neither
+ * <tt>value < *k</tt> nor <tt>*k < value</tt> is \c true.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return A \p pair of iterators <tt>[i, j)</tt> that define the range of equivalent elements.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam LessThanComparable is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p equal_range
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 0); // returns [input.begin(), input.begin() + 1)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 1); // returns [input.begin() + 1, input.begin() +
+ * 1) thrust::equal_range(thrust::device, input.begin(), input.end(), 2); // returns [input.begin() + 1, input.begin() +
+ * 2) thrust::equal_range(thrust::device, input.begin(), input.end(), 3); // returns [input.begin() + 2, input.begin() +
+ * 2) thrust::equal_range(thrust::device, input.begin(), input.end(), 8); // returns [input.begin() + 4, input.end())
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 9); // returns [input.end(), input.end())
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal_range
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+_CCCL_HOST_DEVICE thrust::pair<ForwardIterator, ForwardIterator> equal_range(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  const LessThanComparable& value);
+
+/*! \p equal_range is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. The
+ * value returned by \p equal_range is essentially a combination of
+ * the values returned by \p lower_bound and \p upper_bound: it returns
+ * a \p pair of iterators \c i and \c j such that \c i is the first
+ * position where value could be inserted without violating the
+ * ordering and \c j is the last position where value could be inserted
+ * without violating the ordering. It follows that every element in the
+ * range <tt>[i, j)</tt> is equivalent to value, and that
+ * <tt>[i, j)</tt> is the largest subrange of <tt>[first, last)</tt> that
+ * has this property.
+ *
+ * This version of \p equal_range returns a \p pair of iterators
+ * <tt>[i, j)</tt>, where \c i is the furthermost iterator in
+ * <tt>[first, last)</tt> such that, for every iterator \c k in
+ * <tt>[first, i)</tt>, <tt>*k < value</tt>.  \c j is the furthermost
+ * iterator in <tt>[first, last)</tt> such that, for every iterator
+ * \c k in <tt>[first, j)</tt>, <tt>value < *k</tt> is \c false.
+ * For every iterator \c k in <tt>[i, j)</tt>, neither
+ * <tt>value < *k</tt> nor <tt>*k < value</tt> is \c true.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return A \p pair of iterators <tt>[i, j)</tt> that define the range of equivalent elements.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam LessThanComparable is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p equal_range
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::equal_range(input.begin(), input.end(), 0); // returns [input.begin(), input.begin() + 1)
+ *  thrust::equal_range(input.begin(), input.end(), 1); // returns [input.begin() + 1, input.begin() + 1)
+ *  thrust::equal_range(input.begin(), input.end(), 2); // returns [input.begin() + 1, input.begin() + 2)
+ *  thrust::equal_range(input.begin(), input.end(), 3); // returns [input.begin() + 2, input.begin() + 2)
+ *  thrust::equal_range(input.begin(), input.end(), 8); // returns [input.begin() + 4, input.end())
+ *  thrust::equal_range(input.begin(), input.end(), 9); // returns [input.end(), input.end())
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal_range
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class LessThanComparable>
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(ForwardIterator first, ForwardIterator last, const LessThanComparable& value);
+
+/*! \p equal_range is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. The
+ * value returned by \p equal_range is essentially a combination of
+ * the values returned by \p lower_bound and \p upper_bound: it returns
+ * a \p pair of iterators \c i and \c j such that \c i is the first
+ * position where value could be inserted without violating the
+ * ordering and \c j is the last position where value could be inserted
+ * without violating the ordering. It follows that every element in the
+ * range <tt>[i, j)</tt> is equivalent to value, and that
+ * <tt>[i, j)</tt> is the largest subrange of <tt>[first, last)</tt> that
+ * has this property.
+ *
+ * This version of \p equal_range returns a \p pair of iterators
+ * <tt>[i, j)</tt>. \c i is the furthermost iterator in
+ * <tt>[first, last)</tt> such that, for every iterator \c k in
+ * <tt>[first, i)</tt>, <tt>comp(*k, value)</tt> is \c true.
+ * \c j is the furthermost iterator in <tt>[first, last)</tt> such
+ * that, for every iterator \c k in <tt>[first, last)</tt>,
+ * <tt>comp(value, *k)</tt> is \c false. For every iterator \c k
+ * in <tt>[i, j)</tt>, neither <tt>comp(value, *k)</tt> nor
+ * <tt>comp(*k, value)</tt> is \c true.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return A \p pair of iterators <tt>[i, j)</tt> that define the range of equivalent elements.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam T is comparable to \p ForwardIterator's \c value_type. \tparam StrictWeakOrdering is a model of
+ * <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p equal_range
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 0, thrust::less<int>()); // returns [input.begin(),
+ * input.begin() + 1) thrust::equal_range(thrust::device, input.begin(), input.end(), 1, thrust::less<int>()); //
+ * returns [input.begin() + 1, input.begin() + 1) thrust::equal_range(thrust::device, input.begin(), input.end(), 2,
+ * thrust::less<int>()); // returns [input.begin() + 1, input.begin() + 2) thrust::equal_range(thrust::device,
+ * input.begin(), input.end(), 3, thrust::less<int>()); // returns [input.begin() + 2, input.begin() + 2)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 8, thrust::less<int>()); // returns [input.begin() +
+ * 4, input.end()) thrust::equal_range(thrust::device, input.begin(), input.end(), 9, thrust::less<int>()); // returns
+ * [input.end(), input.end()) \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal_range
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+_CCCL_HOST_DEVICE thrust::pair<ForwardIterator, ForwardIterator> equal_range(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  const T& value,
+  StrictWeakOrdering comp);
+
+/*! \p equal_range is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. The
+ * value returned by \p equal_range is essentially a combination of
+ * the values returned by \p lower_bound and \p upper_bound: it returns
+ * a \p pair of iterators \c i and \c j such that \c i is the first
+ * position where value could be inserted without violating the
+ * ordering and \c j is the last position where value could be inserted
+ * without violating the ordering. It follows that every element in the
+ * range <tt>[i, j)</tt> is equivalent to value, and that
+ * <tt>[i, j)</tt> is the largest subrange of <tt>[first, last)</tt> that
+ * has this property.
+ *
+ * This version of \p equal_range returns a \p pair of iterators
+ * <tt>[i, j)</tt>. \c i is the furthermost iterator in
+ * <tt>[first, last)</tt> such that, for every iterator \c k in
+ * <tt>[first, i)</tt>, <tt>comp(*k, value)</tt> is \c true.
+ * \c j is the furthermost iterator in <tt>[first, last)</tt> such
+ * that, for every iterator \c k in <tt>[first, last)</tt>,
+ * <tt>comp(value, *k)</tt> is \c false. For every iterator \c k
+ * in <tt>[i, j)</tt>, neither <tt>comp(value, *k)</tt> nor
+ * <tt>comp(*k, value)</tt> is \c true.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return A \p pair of iterators <tt>[i, j)</tt> that define the range of equivalent elements.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam T is comparable to \p ForwardIterator's \c value_type. \tparam StrictWeakOrdering is a model of
+ * <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p equal_range
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::equal_range(input.begin(), input.end(), 0, thrust::less<int>()); // returns [input.begin(), input.begin() +
+ * 1) thrust::equal_range(input.begin(), input.end(), 1, thrust::less<int>()); // returns [input.begin() + 1,
+ * input.begin() + 1) thrust::equal_range(input.begin(), input.end(), 2, thrust::less<int>()); // returns [input.begin()
+ * + 1, input.begin() + 2) thrust::equal_range(input.begin(), input.end(), 3, thrust::less<int>()); // returns
+ * [input.begin() + 2, input.begin() + 2) thrust::equal_range(input.begin(), input.end(), 8, thrust::less<int>()); //
+ * returns [input.begin() + 4, input.end()) thrust::equal_range(input.begin(), input.end(), 9, thrust::less<int>()); //
+ * returns [input.end(), input.end()) \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal_range
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class T, class StrictWeakOrdering>
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(ForwardIterator first, ForwardIterator last, const T& value, StrictWeakOrdering comp);
+
+/*! \addtogroup vectorized_binary_search Vectorized Searches
+ *  \ingroup binary_search
+ *  \{
+ */
+
+//////////////////////
+// Vector Functions //
+//////////////////////
+
+/*! \p lower_bound is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for multiple values in a ordered range using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::lower_bound(thrust::device,
+ *                      input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin());
+ *
+ *  // output is now [0, 1, 1, 2, 4, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator lower_bound(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result);
+
+/*! \p lower_bound is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::lower_bound(input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin());
+ *
+ *  // output is now [0, 1, 1, 2, 4, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator>
+OutputIterator lower_bound(
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result);
+
+/*! \p lower_bound is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.  This version of
+ * \p lower_bound uses function object \c comp for comparison.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is comparable to \p ForwardIterator's \c value_type. \tparam OutputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. and \c ForwardIterator's
+ * difference_type is convertible to \c OutputIterator's \c value_type. \tparam StrictWeakOrdering is a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::lower_bound(input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin(),
+ *                      thrust::less<int>());
+ *
+ *  // output is now [0, 1, 1, 2, 4, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy,
+          typename ForwardIterator,
+          typename InputIterator,
+          typename OutputIterator,
+          typename StrictWeakOrdering>
+_CCCL_HOST_DEVICE OutputIterator lower_bound(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result,
+  StrictWeakOrdering comp);
+
+/*! \p lower_bound is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.  This version of
+ * \p lower_bound uses function object \c comp for comparison.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is comparable to \p ForwardIterator's \c value_type. \tparam OutputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. and \c ForwardIterator's
+ * difference_type is convertible to \c OutputIterator's \c value_type. \tparam StrictWeakOrdering is a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::lower_bound(input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin(),
+ *                      thrust::less<int>());
+ *
+ *  // output is now [0, 1, 1, 2, 4, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator, class StrictWeakOrdering>
+OutputIterator lower_bound(
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result,
+  StrictWeakOrdering comp);
+
+/*! \p upper_bound is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of last position where value could
+ * be inserted without violating the ordering.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for multiple values in a ordered range using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::upper_bound(thrust::device,
+ *                      input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin());
+ *
+ *  // output is now [1, 1, 2, 2, 5, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator upper_bound(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result);
+
+/*! \p upper_bound is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of last position where value could
+ * be inserted without violating the ordering.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::upper_bound(input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin());
+ *
+ *  // output is now [1, 1, 2, 2, 5, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator>
+OutputIterator upper_bound(
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result);
+
+/*! \p upper_bound is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.  This version of
+ * \p upper_bound uses function object \c comp for comparison.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is comparable to \p ForwardIterator's \c value_type. \tparam OutputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. and \c ForwardIterator's
+ * difference_type is convertible to \c OutputIterator's \c value_type. \tparam StrictWeakOrdering is a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for multiple values in a ordered range using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::upper_bound(thrust::device,
+ *                      input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin(),
+ *                      thrust::less<int>());
+ *
+ *  // output is now [1, 1, 2, 2, 5, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy,
+          typename ForwardIterator,
+          typename InputIterator,
+          typename OutputIterator,
+          typename StrictWeakOrdering>
+_CCCL_HOST_DEVICE OutputIterator upper_bound(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result,
+  StrictWeakOrdering comp);
+
+/*! \p upper_bound is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.  This version of
+ * \p upper_bound uses function object \c comp for comparison.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is comparable to \p ForwardIterator's \c value_type. \tparam OutputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. and \c ForwardIterator's
+ * difference_type is convertible to \c OutputIterator's \c value_type. \tparam StrictWeakOrdering is a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::upper_bound(input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin(),
+ *                      thrust::less<int>());
+ *
+ *  // output is now [1, 1, 2, 2, 5, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator, class StrictWeakOrdering>
+OutputIterator upper_bound(
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result,
+  StrictWeakOrdering comp);
+
+/*! \p binary_search is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. and bool is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for multiple values in a ordered range using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<bool> output(6);
+ *
+ *  thrust::binary_search(thrust::device,
+ *                        input.begin(), input.end(),
+ *                        values.begin(), values.end(),
+ *                        output.begin());
+ *
+ *  // output is now [true, false, true, false, true, false]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator binary_search(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result);
+
+/*! \p binary_search is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. and bool is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<bool> output(6);
+ *
+ *  thrust::binary_search(input.begin(), input.end(),
+ *                        values.begin(), values.end(),
+ *                        output.begin());
+ *
+ *  // output is now [true, false, true, false, true, false]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator>
+OutputIterator binary_search(
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result);
+
+/*! \p binary_search is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  This version of \p binary_search uses function object
+ * \c comp for comparison.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. and bool is convertible to \c OutputIterator's \c value_type. \tparam StrictWeakOrdering is a model of
+ * <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for multiple values in a ordered range using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<bool> output(6);
+ *
+ *  thrust::binary_search(thrust::device,
+ *                        input.begin(), input.end(),
+ *                        values.begin(), values.end(),
+ *                        output.begin(),
+ *                        thrust::less<T>());
+ *
+ *  // output is now [true, false, true, false, true, false]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <typename DerivedPolicy,
+          typename ForwardIterator,
+          typename InputIterator,
+          typename OutputIterator,
+          typename StrictWeakOrdering>
+_CCCL_HOST_DEVICE OutputIterator binary_search(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result,
+  StrictWeakOrdering comp);
+
+/*! \p binary_search is a vectorized version of binary search: for each
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  This version of \p binary_search uses function object
+ * \c comp for comparison.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>. \tparam InputIterator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>. and \c InputIterator's \c
+ * value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. and bool is convertible to \c OutputIterator's \c value_type. \tparam StrictWeakOrdering is a model of
+ * <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0;
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<bool> output(6);
+ *
+ *  thrust::binary_search(input.begin(), input.end(),
+ *                        values.begin(), values.end(),
+ *                        output.begin(),
+ *                        thrust::less<T>());
+ *
+ *  // output is now [true, false, true, false, true, false]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator, class StrictWeakOrdering>
+OutputIterator binary_search(
+  ForwardIterator first,
+  ForwardIterator last,
+  InputIterator values_first,
+  InputIterator values_last,
+  OutputIterator result,
+  StrictWeakOrdering comp);
+
+/*! \} // end vectorized_binary_search
+ */
+
+/*! \} // end binary_search
+ */
+
+/*! \} // end searching
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/binary_search.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/complex.h

@@ -0,0 +1,854 @@
+/*
+ *  Copyright 2008-2019 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file complex.h
+ *  \brief Complex numbers
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/type_traits.h>
+#include <thrust/type_traits/is_trivially_relocatable.h>
+
+#include <cmath>
+#include <complex>
+#include <sstream>
+
+#define THRUST_STD_COMPLEX_REAL(z) \
+  reinterpret_cast<const typename ::cuda::std::remove_reference_t<decltype(z)>::value_type(&)[2]>(z)[0]
+#define THRUST_STD_COMPLEX_IMAG(z) \
+  reinterpret_cast<const typename ::cuda::std::remove_reference_t<decltype(z)>::value_type(&)[2]>(z)[1]
+#define THRUST_STD_COMPLEX_DEVICE _CCCL_DEVICE
+
+THRUST_NAMESPACE_BEGIN
+
+/*
+ *  Calls to the standard math library from inside the thrust namespace
+ *  with real arguments require explicit scope otherwise they will fail
+ *  to resolve as it will find the equivalent complex function but then
+ *  fail to match the template, and give up looking for other scopes.
+ */
+
+/*! \addtogroup numerics
+ *  \{
+ */
+
+/*! \addtogroup complex_numbers Complex Numbers
+ *  \{
+ */
+
+/*! \p complex is the Thrust equivalent to <tt>std::complex</tt>. It is
+ *  functionally identical to it, but can also be used in device code which
+ *  <tt>std::complex</tt> currently cannot.
+ *
+ *  \tparam T The type used to hold the real and imaginary parts. Should be
+ *  <tt>float</tt> or <tt>double</tt>. Others types are not supported.
+ *
+ */
+template <typename T>
+struct complex
+{
+public:
+  /*! \p value_type is the type of \p complex's real and imaginary parts.
+   */
+  using value_type = T;
+
+  /* --- Constructors --- */
+
+  /*! Construct a complex number with an imaginary part of 0.
+   *
+   *  \param re The real part of the number.
+   */
+  _CCCL_HOST_DEVICE complex(const T& re);
+
+  /*! Construct a complex number from its real and imaginary parts.
+   *
+   *  \param re The real part of the number.
+   *  \param im The imaginary part of the number.
+   */
+  _CCCL_HOST_DEVICE complex(const T& re, const T& im);
+
+  /*! Default construct a complex number.
+   */
+  complex() = default;
+
+  /*! This copy constructor copies from a \p complex with a type that is
+   *  convertible to this \p complex's \c value_type.
+   *
+   *  \param z The \p complex to copy from.
+   */
+  complex(const complex<T>& z) = default;
+
+  /*! This converting copy constructor copies from a \p complex with a type
+   *  that is convertible to this \p complex's \c value_type.
+   *
+   *  \param z The \p complex to copy from.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST_DEVICE complex(const complex<U>& z);
+
+  /*! This converting copy constructor copies from a <tt>std::complex</tt> with
+   *  a type that is convertible to this \p complex's \c value_type.
+   *
+   *  \param z The \p complex to copy from.
+   */
+  _CCCL_HOST THRUST_STD_COMPLEX_DEVICE complex(const std::complex<T>& z);
+
+  /*! This converting copy constructor copies from a <tt>std::complex</tt> with
+   *  a type that is convertible to this \p complex's \c value_type.
+   *
+   *  \param z The \p complex to copy from.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST THRUST_STD_COMPLEX_DEVICE complex(const std::complex<U>& z);
+
+  /* --- Assignment Operators --- */
+
+  /*! Assign `re` to the real part of this \p complex and set the imaginary part
+   *  to 0.
+   *
+   *  \param re The real part of the number.
+   */
+  _CCCL_HOST_DEVICE complex& operator=(const T& re);
+
+  /*! Assign `z.real()` and `z.imag()` to the real and imaginary parts of this
+   *  \p complex respectively.
+   *
+   *  \param z The \p complex to copy from.
+   */
+  complex& operator=(const complex<T>& z) = default;
+
+  /*! Assign `z.real()` and `z.imag()` to the real and imaginary parts of this
+   *  \p complex respectively.
+   *
+   *  \param z The \p complex to copy from.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST_DEVICE complex& operator=(const complex<U>& z);
+
+  /*! Assign `z.real()` and `z.imag()` to the real and imaginary parts of this
+   *  \p complex respectively.
+   *
+   *  \param z The \p complex to copy from.
+   */
+  _CCCL_HOST THRUST_STD_COMPLEX_DEVICE complex& operator=(const std::complex<T>& z);
+
+  /*! Assign `z.real()` and `z.imag()` to the real and imaginary parts of this
+   *  \p complex respectively.
+   *
+   *  \param z The \p complex to copy from.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST THRUST_STD_COMPLEX_DEVICE complex& operator=(const std::complex<U>& z);
+
+  /* --- Compound Assignment Operators --- */
+
+  /*! Adds a \p complex to this \p complex and assigns the result to this
+   *  \p complex.
+   *
+   *  \param z The \p complex to be added.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST_DEVICE complex<T>& operator+=(const complex<U>& z);
+
+  /*! Subtracts a \p complex from this \p complex and assigns the result to
+   *  this \p complex.
+   *
+   *  \param z The \p complex to be subtracted.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST_DEVICE complex<T>& operator-=(const complex<U>& z);
+
+  /*! Multiplies this \p complex by another \p complex and assigns the result
+   *  to this \p complex.
+   *
+   *  \param z The \p complex to be multiplied.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST_DEVICE complex<T>& operator*=(const complex<U>& z);
+
+  /*! Divides this \p complex by another \p complex and assigns the result to
+   *  this \p complex.
+   *
+   *  \param z The \p complex to be divided.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST_DEVICE complex<T>& operator/=(const complex<U>& z);
+
+  /*! Adds a scalar to this \p complex and assigns the result to this
+   *  \p complex.
+   *
+   *  \param z The \p complex to be added.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST_DEVICE complex<T>& operator+=(const U& z);
+
+  /*! Subtracts a scalar from this \p complex and assigns the result to
+   *  this \p complex.
+   *
+   *  \param z The scalar to be subtracted.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST_DEVICE complex<T>& operator-=(const U& z);
+
+  /*! Multiplies this \p complex by a scalar and assigns the result
+   *  to this \p complex.
+   *
+   *  \param z The scalar to be multiplied.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST_DEVICE complex<T>& operator*=(const U& z);
+
+  /*! Divides this \p complex by a scalar and assigns the result to
+   *  this \p complex.
+   *
+   *  \param z The scalar to be divided.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  _CCCL_HOST_DEVICE complex<T>& operator/=(const U& z);
+
+  /* --- Getter functions ---
+   * The volatile ones are there to help for example
+   * with certain reductions optimizations
+   */
+
+  /*! Returns the real part of this \p complex.
+   */
+  _CCCL_HOST_DEVICE T real() const volatile
+  {
+    return data.x;
+  }
+
+  /*! Returns the imaginary part of this \p complex.
+   */
+  _CCCL_HOST_DEVICE T imag() const volatile
+  {
+    return data.y;
+  }
+
+  /*! Returns the real part of this \p complex.
+   */
+  _CCCL_HOST_DEVICE T real() const
+  {
+    return data.x;
+  }
+
+  /*! Returns the imaginary part of this \p complex.
+   */
+  _CCCL_HOST_DEVICE T imag() const
+  {
+    return data.y;
+  }
+
+  /* --- Setter functions ---
+   * The volatile ones are there to help for example
+   * with certain reductions optimizations
+   */
+
+  /*! Sets the real part of this \p complex.
+   *
+   *  \param re The new real part of this \p complex.
+   */
+  _CCCL_HOST_DEVICE void real(T re) volatile
+  {
+    data.x = re;
+  }
+
+  /*! Sets the imaginary part of this \p complex.
+   *
+   *  \param im The new imaginary part of this \p complex.e
+   */
+  _CCCL_HOST_DEVICE void imag(T im) volatile
+  {
+    data.y = im;
+  }
+
+  /*! Sets the real part of this \p complex.
+   *
+   *  \param re The new real part of this \p complex.
+   */
+  _CCCL_HOST_DEVICE void real(T re)
+  {
+    data.x = re;
+  }
+
+  /*! Sets the imaginary part of this \p complex.
+   *
+   *  \param im The new imaginary part of this \p complex.
+   */
+  _CCCL_HOST_DEVICE void imag(T im)
+  {
+    data.y = im;
+  }
+
+  /* --- Casting functions --- */
+
+  /*! Casts this \p complex to a <tt>std::complex</tt> of the same type.
+   */
+  _CCCL_HOST operator std::complex<T>() const
+  {
+    return std::complex<T>(real(), imag());
+  }
+
+private:
+#if _CCCL_CUDA_COMPILER(NVCC, <, 11, 7)
+  struct __align__(sizeof(T) * 2) storage
+#elif _CCCL_COMPILER(ICC)
+  struct storage
+#else // !(_CCCL_COMPILER(ICC) || _CCCL_CUDA_COMPILER(NVCC, <, 11, 7))
+  struct alignas(sizeof(T) * 2) storage
+#endif // !(_CCCL_COMPILER(ICC) || _CCCL_CUDA_COMPILER(NVCC, <, 11, 7))
+  {
+    T x;
+    T y;
+  }
+#if _CCCL_COMPILER(ICC)
+  __attribute__((aligned(sizeof(T) * 2)))
+#endif // _CCCL_COMPILER(ICC)
+  ;
+  storage data;
+};
+
+/* --- General Functions --- */
+
+/*! Returns the magnitude (also known as absolute value) of a \p complex.
+ *
+ *  \param z The \p complex from which to calculate the absolute value.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE T abs(const complex<T>& z);
+
+/*! Returns the phase angle (also known as argument) in radians of a \p complex.
+ *
+ *  \param z The \p complex from which to calculate the phase angle.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE T arg(const complex<T>& z);
+
+/*! Returns the square of the magnitude of a \p complex.
+ *
+ *  \param z The \p complex from which to calculate the norm.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE T norm(const complex<T>& z);
+
+/*! Returns the complex conjugate of a \p complex.
+ *
+ *  \param z The \p complex from which to calculate the complex conjugate.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> conj(const complex<T>& z);
+
+/*! Returns a \p complex with the specified magnitude and phase.
+ *
+ *  \param m The magnitude of the returned \p complex.
+ *  \param theta The phase of the returned \p complex in radians.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> polar(const T0& m, const T1& theta = T1());
+
+/*! Returns the projection of a \p complex on the Riemann sphere.
+ *  For all finite \p complex it returns the argument. For \p complexs
+ *  with a non finite part returns (INFINITY,+/-0) where the sign of
+ *  the zero matches the sign of the imaginary part of the argument.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> proj(const T& z);
+
+/* --- Binary Arithmetic operators --- */
+
+/*! Adds two \p complex numbers.
+ *
+ *  The value types of the two \p complex types should be compatible and the
+ *  type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator+(const complex<T0>& x, const complex<T1>& y);
+
+/*! Adds a scalar to a \p complex number.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The \p complex.
+ *  \param y The scalar.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator+(const complex<T0>& x, const T1& y);
+
+/*! Adds a \p complex number to a scalar.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The scalar.
+ *  \param y The \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator+(const T0& x, const complex<T1>& y);
+
+/*! Subtracts two \p complex numbers.
+ *
+ *  The value types of the two \p complex types should be compatible and the
+ *  type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The first \p complex (minuend).
+ *  \param y The second \p complex (subtrahend).
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator-(const complex<T0>& x, const complex<T1>& y);
+
+/*! Subtracts a scalar from a \p complex number.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The \p complex (minuend).
+ *  \param y The scalar (subtrahend).
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator-(const complex<T0>& x, const T1& y);
+
+/*! Subtracts a \p complex number from a scalar.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The scalar (minuend).
+ *  \param y The \p complex (subtrahend).
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator-(const T0& x, const complex<T1>& y);
+
+/*! Multiplies two \p complex numbers.
+ *
+ *  The value types of the two \p complex types should be compatible and the
+ *  type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator*(const complex<T0>& x, const complex<T1>& y);
+
+/*! Multiplies a \p complex number by a scalar.
+ *
+ *  \param x The \p complex.
+ *  \param y The scalar.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator*(const complex<T0>& x, const T1& y);
+
+/*! Multiplies a scalar by a \p complex number.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The scalar.
+ *  \param y The \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator*(const T0& x, const complex<T1>& y);
+
+/*! Divides two \p complex numbers.
+ *
+ *  The value types of the two \p complex types should be compatible and the
+ *  type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The numerator (dividend).
+ *  \param y The denomimator (divisor).
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator/(const complex<T0>& x, const complex<T1>& y);
+
+/*! Divides a \p complex number by a scalar.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The complex numerator (dividend).
+ *  \param y The scalar denomimator (divisor).
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator/(const complex<T0>& x, const T1& y);
+
+/*! Divides a scalar by a \p complex number.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The scalar numerator (dividend).
+ *  \param y The complex denomimator (divisor).
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> operator/(const T0& x, const complex<T1>& y);
+
+/* --- Unary Arithmetic operators --- */
+
+/*! Unary plus, returns its \p complex argument.
+ *
+ *  \param y The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> operator+(const complex<T>& y);
+
+/*! Unary minus, returns the additive inverse (negation) of its \p complex
+ * argument.
+ *
+ *  \param y The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> operator-(const complex<T>& y);
+
+/* --- Exponential Functions --- */
+
+/*! Returns the complex exponential of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> exp(const complex<T>& z);
+
+/*! Returns the complex natural logarithm of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> log(const complex<T>& z);
+
+/*! Returns the complex base 10 logarithm of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> log10(const complex<T>& z);
+
+/* --- Power Functions --- */
+
+/*! Returns a \p complex number raised to another.
+ *
+ *  The value types of the two \p complex types should be compatible and the
+ *  type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The base.
+ *  \param y The exponent.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> pow(const complex<T0>& x, const complex<T1>& y);
+
+/*! Returns a \p complex number raised to a scalar.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The base.
+ *  \param y The exponent.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> pow(const complex<T0>& x, const T1& y);
+
+/*! Returns a scalar raised to a \p complex number.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The base.
+ *  \param y The exponent.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE complex<::cuda::std::common_type_t<T0, T1>> pow(const T0& x, const complex<T1>& y);
+
+/*! Returns the complex square root of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> sqrt(const complex<T>& z);
+
+/* --- Trigonometric Functions --- */
+
+/*! Returns the complex cosine of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> cos(const complex<T>& z);
+
+/*! Returns the complex sine of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> sin(const complex<T>& z);
+
+/*! Returns the complex tangent of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> tan(const complex<T>& z);
+
+/* --- Hyperbolic Functions --- */
+
+/*! Returns the complex hyperbolic cosine of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> cosh(const complex<T>& z);
+
+/*! Returns the complex hyperbolic sine of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> sinh(const complex<T>& z);
+
+/*! Returns the complex hyperbolic tangent of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> tanh(const complex<T>& z);
+
+/* --- Inverse Trigonometric Functions --- */
+
+/*! Returns the complex arc cosine of a \p complex number.
+ *
+ *  The range of the real part of the result is [0, Pi] and
+ *  the range of the imaginary part is [-inf, +inf]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> acos(const complex<T>& z);
+
+/*! Returns the complex arc sine of a \p complex number.
+ *
+ *  The range of the real part of the result is [-Pi/2, Pi/2] and
+ *  the range of the imaginary part is [-inf, +inf]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> asin(const complex<T>& z);
+
+/*! Returns the complex arc tangent of a \p complex number.
+ *
+ *  The range of the real part of the result is [-Pi/2, Pi/2] and
+ *  the range of the imaginary part is [-inf, +inf]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> atan(const complex<T>& z);
+
+/* --- Inverse Hyperbolic Functions --- */
+
+/*! Returns the complex inverse hyperbolic cosine of a \p complex number.
+ *
+ *  The range of the real part of the result is [0, +inf] and
+ *  the range of the imaginary part is [-Pi, Pi]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> acosh(const complex<T>& z);
+
+/*! Returns the complex inverse hyperbolic sine of a \p complex number.
+ *
+ *  The range of the real part of the result is [-inf, +inf] and
+ *  the range of the imaginary part is [-Pi/2, Pi/2]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> asinh(const complex<T>& z);
+
+/*! Returns the complex inverse hyperbolic tangent of a \p complex number.
+ *
+ *  The range of the real part of the result is [-inf, +inf] and
+ *  the range of the imaginary part is [-Pi/2, Pi/2]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+_CCCL_HOST_DEVICE complex<T> atanh(const complex<T>& z);
+
+/* --- Stream Operators --- */
+
+/*! Writes to an output stream a \p complex number in the form (real, imaginary).
+ *
+ *  \param os The output stream.
+ *  \param z The \p complex number to output.
+ */
+template <typename T, typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const complex<T>& z);
+
+/*! Reads a \p complex number from an input stream.
+ *
+ *  The recognized formats are:
+ * - real
+ * - (real)
+ * - (real, imaginary)
+ *
+ * The values read must be convertible to the \p complex's \c value_type
+ *
+ *  \param is The input stream.
+ *  \param z The \p complex number to set.
+ */
+template <typename T, typename CharT, typename Traits>
+_CCCL_HOST std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, complex<T>& z);
+
+/* --- Equality Operators --- */
+
+/*! Returns true if two \p complex numbers are equal and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE bool operator==(const complex<T0>& x, const complex<T1>& y);
+
+/*! Returns true if two \p complex numbers are equal and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST THRUST_STD_COMPLEX_DEVICE bool operator==(const complex<T0>& x, const std::complex<T1>& y);
+
+/*! Returns true if two \p complex numbers are equal and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST THRUST_STD_COMPLEX_DEVICE bool operator==(const std::complex<T0>& x, const complex<T1>& y);
+
+/*! Returns true if the imaginary part of the \p complex number is zero and
+ *  the real part is equal to the scalar. Returns false otherwise.
+ *
+ *  \param x The scalar.
+ *  \param y The \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE bool operator==(const T0& x, const complex<T1>& y);
+
+/*! Returns true if the imaginary part of the \p complex number is zero and
+ *  the real part is equal to the scalar. Returns false otherwise.
+ *
+ *  \param x The \p complex.
+ *  \param y The scalar.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE bool operator==(const complex<T0>& x, const T1& y);
+
+/*! Returns true if two \p complex numbers are different and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE bool operator!=(const complex<T0>& x, const complex<T1>& y);
+
+/*! Returns true if two \p complex numbers are different and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST THRUST_STD_COMPLEX_DEVICE bool operator!=(const complex<T0>& x, const std::complex<T1>& y);
+
+/*! Returns true if two \p complex numbers are different and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST THRUST_STD_COMPLEX_DEVICE bool operator!=(const std::complex<T0>& x, const complex<T1>& y);
+
+/*! Returns true if the imaginary part of the \p complex number is not zero or
+ *  the real part is different from the scalar. Returns false otherwise.
+ *
+ *  \param x The scalar.
+ *  \param y The \p complex.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE bool operator!=(const T0& x, const complex<T1>& y);
+
+/*! Returns true if the imaginary part of the \p complex number is not zero or
+ *  the real part is different from the scalar. Returns false otherwise.
+ *
+ *  \param x The \p complex.
+ *  \param y The scalar.
+ */
+template <typename T0, typename T1>
+_CCCL_HOST_DEVICE bool operator!=(const complex<T0>& x, const T1& y);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/complex/complex.inl>
+
+#undef THRUST_STD_COMPLEX_REAL
+#undef THRUST_STD_COMPLEX_IMAG
+#undef THRUST_STD_COMPLEX_DEVICE
+
+/*! \} // complex_numbers
+ */
+
+/*! \} // numerics
+ */

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/count.h

@@ -0,0 +1,246 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file count.h
+ *  \brief Counting elements in a range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+/*! \addtogroup reductions
+ *  \ingroup algorithms
+ *  \{
+ */
+
+/*! \addtogroup counting
+ *  \ingroup reductions
+ *  \{
+ */
+
+/*! \p count finds the number of elements in <tt>[first,last)</tt> that are equal
+ *  to \p value. More precisely, \p count returns the number of iterators \c i in
+ *  <tt>[first, last)</tt> such that <tt>*i == value</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param value The value to be counted.
+ *  \return The number of elements equal to \p value.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a> and \c InputIterator's \c value_type must be a model of must be a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>. \tparam
+ * EqualityComparable must be a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a> and can be compared for
+ * equality with \c InputIterator's \c value_type
+ *
+ *  The following code snippet demonstrates how to use \p count to
+ *  count the number of instances in a range of a value of interest using the \p thrust::device execution policy:
+ *
+ *  \code
+ *  #include <thrust/count.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  // put 3 1s in a device_vector
+ *  thrust::device_vector<int> vec(5,0);
+ *  vec[1] = 1;
+ *  vec[3] = 1;
+ *  vec[4] = 1;
+ *
+ *  // count the 1s
+ *  int result = thrust::count(thrust::device, vec.begin(), vec.end(), 1);
+ *  // result == 3
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/count
+ */
+template <typename DerivedPolicy, typename InputIterator, typename EqualityComparable>
+_CCCL_HOST_DEVICE typename thrust::iterator_traits<InputIterator>::difference_type
+count(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+      InputIterator first,
+      InputIterator last,
+      const EqualityComparable& value);
+
+/*! \p count finds the number of elements in <tt>[first,last)</tt> that are equal
+ *  to \p value. More precisely, \p count returns the number of iterators \c i in
+ *  <tt>[first, last)</tt> such that <tt>*i == value</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param value The value to be counted.
+ *  \return The number of elements equal to \p value.
+ *
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a> and \c InputIterator's \c value_type must be a model of must be a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>. \tparam
+ * EqualityComparable must be a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a> and can be compared for
+ * equality with \c InputIterator's \c value_type
+ *
+ *  The following code snippet demonstrates how to use \p count to
+ *  count the number of instances in a range of a value of interest.
+ *  \code
+ *  #include <thrust/count.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  // put 3 1s in a device_vector
+ *  thrust::device_vector<int> vec(5,0);
+ *  vec[1] = 1;
+ *  vec[3] = 1;
+ *  vec[4] = 1;
+ *
+ *  // count the 1s
+ *  int result = thrust::count(vec.begin(), vec.end(), 1);
+ *  // result == 3
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/count
+ */
+template <typename InputIterator, typename EqualityComparable>
+typename thrust::iterator_traits<InputIterator>::difference_type
+count(InputIterator first, InputIterator last, const EqualityComparable& value);
+
+/*! \p count_if finds the number of elements in <tt>[first,last)</tt> for which
+ *  a predicate is \c true. More precisely, \p count_if returns the number of iterators
+ *  \c i in <tt>[first, last)</tt> such that <tt>pred(*i) == true</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param pred The predicate.
+ *  \return The number of elements where \p pred is \c true.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a> and \c InputIterator's \c value_type must be convertible to \c Predicate's \c argument_type. \tparam
+ * Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p count to
+ *  count the number of odd numbers in a range using the \p thrust::device execution policy:
+ *
+ *  \code
+ *  #include <thrust/count.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_odd
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int &x)
+ *    {
+ *      return x & 1;
+ *    }
+ *  };
+ *  ...
+ *  // fill a device_vector with even & odd numbers
+ *  thrust::device_vector<int> vec(5);
+ *  vec[0] = 0;
+ *  vec[1] = 1;
+ *  vec[2] = 2;
+ *  vec[3] = 3;
+ *  vec[4] = 4;
+ *
+ *  // count the odd elements in vec
+ *  int result = thrust::count_if(thrust::device, vec.begin(), vec.end(), is_odd());
+ *  // result == 2
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/count
+ */
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+_CCCL_HOST_DEVICE typename thrust::iterator_traits<InputIterator>::difference_type
+count_if(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+         InputIterator first,
+         InputIterator last,
+         Predicate pred);
+
+/*! \p count_if finds the number of elements in <tt>[first,last)</tt> for which
+ *  a predicate is \c true. More precisely, \p count_if returns the number of iterators
+ *  \c i in <tt>[first, last)</tt> such that <tt>pred(*i) == true</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param pred The predicate.
+ *  \return The number of elements where \p pred is \c true.
+ *
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a> and \c InputIterator's \c value_type must be convertible to \c Predicate's \c argument_type. \tparam
+ * Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p count to
+ *  count the number of odd numbers in a range.
+ *  \code
+ *  #include <thrust/count.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  struct is_odd
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int &x)
+ *    {
+ *      return x & 1;
+ *    }
+ *  };
+ *  ...
+ *  // fill a device_vector with even & odd numbers
+ *  thrust::device_vector<int> vec(5);
+ *  vec[0] = 0;
+ *  vec[1] = 1;
+ *  vec[2] = 2;
+ *  vec[3] = 3;
+ *  vec[4] = 4;
+ *
+ *  // count the odd elements in vec
+ *  int result = thrust::count_if(vec.begin(), vec.end(), is_odd());
+ *  // result == 2
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/count
+ */
+template <typename InputIterator, typename Predicate>
+typename thrust::iterator_traits<InputIterator>::difference_type
+count_if(InputIterator first, InputIterator last, Predicate pred);
+
+/*! \} // end counting
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/count.h>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/device_delete.h

@@ -0,0 +1,59 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief Deletes variables in device memory.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/device_ptr.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+/*! \p device_delete deletes a \p device_ptr allocated with
+ *  \p device_new.
+ *
+ *  \param ptr The \p device_ptr to delete, assumed to have
+ *         been allocated with \p device_new.
+ *  \param n The number of objects to destroy at \p ptr. Defaults to \c 1
+ *         similar to \p device_new.
+ *
+ *  \see device_ptr
+ *  \see device_new
+ */
+template <typename T>
+inline void device_delete(thrust::device_ptr<T> ptr, const size_t n = 1);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/device_delete.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/device_free.h

@@ -0,0 +1,72 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief Deallocates storage allocated by \p device_malloc.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/device_ptr.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+/*! \p device_free deallocates memory allocated by the function \p device_malloc.
+ *
+ *  \param ptr A \p device_ptr pointing to memory to be deallocated.
+ *
+ *  The following code snippet demonstrates how to use \p device_free to
+ *  deallocate memory allocated by \p device_malloc.
+ *
+ *  \code
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/device_free.h>
+ *  ...
+ *  // allocate some integers with device_malloc
+ *  const int N = 100;
+ *  thrust::device_ptr<int> int_array = thrust::device_malloc<int>(N);
+ *
+ *  // manipulate integers
+ *  ...
+ *
+ *  // deallocate with device_free
+ *  thrust::device_free(int_array);
+ *  \endcode
+ *
+ *  \see device_ptr
+ *  \see device_malloc
+ */
+inline void device_free(thrust::device_ptr<void> ptr);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/device_free.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/device_make_unique.h

@@ -0,0 +1,56 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file device_make_unique.h
+ *  \brief A factory function for creating `unique_ptr`s to device objects.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/allocate_unique.h>
+#include <thrust/detail/type_deduction.h>
+#include <thrust/device_allocator.h>
+#include <thrust/device_new.h>
+#include <thrust/device_ptr.h>
+
+THRUST_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, typename... Args>
+_CCCL_HOST auto device_make_unique(Args&&... args)
+  -> decltype(uninitialized_allocate_unique<T>(::cuda::std::declval<device_allocator<T>>()))
+{
+  // FIXME: This is crude - we construct an unnecessary T on the host for
+  // `device_new`. We need a proper dispatched `construct` algorithm to
+  // do this properly.
+  auto p = uninitialized_allocate_unique<T>(device_allocator<T>());
+  device_new<T>(p.get(), T(THRUST_FWD(args)...));
+  return p;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/device_malloc.h

@@ -0,0 +1,108 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief Allocates storage in device memory.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/device_ptr.h>
+
+#include <cstddef> // for std::size_t
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+/*! This version of \p device_malloc allocates sequential device storage
+ *  for bytes.
+ *
+ *  \param n The number of bytes to allocate sequentially
+ *           in device memory.
+ *  \return A \p device_ptr to the newly allocated memory.
+ *
+ *  The following code snippet demonstrates how to use \p device_malloc to
+ *  allocate a range of device memory.
+ *
+ *  \code
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/device_free.h>
+ *  ...
+ *  // allocate some memory with device_malloc
+ *  const int N = 100;
+ *  thrust::device_ptr<void> void_ptr = thrust::device_malloc(N);
+ *
+ *  // manipulate memory
+ *  ...
+ *
+ *  // deallocate with device_free
+ *  thrust::device_free(void_ptr);
+ *  \endcode
+ *
+ *  \see device_ptr
+ *  \see device_free
+ */
+inline thrust::device_ptr<void> device_malloc(const std::size_t n);
+
+/*! This version of \p device_malloc allocates sequential device storage for
+ *  new objects of the given type.
+ *
+ *  \param n The number of objects of type T to allocate
+ *           sequentially in device memory.
+ *  \return A \p device_ptr to the newly allocated memory.
+ *
+ *  The following code snippet demonstrates how to use \p device_malloc to
+ *  allocate a range of device memory.
+ *
+ *  \code
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/device_free.h>
+ *  ...
+ *  // allocate some integers with device_malloc
+ *  const int N = 100;
+ *  thrust::device_ptr<int> int_array = thrust::device_malloc<int>(N);
+ *
+ *  // manipulate integers
+ *  ...
+ *
+ *  // deallocate with device_free
+ *  thrust::device_free(int_array);
+ *  \endcode
+ *
+ *  \see device_ptr
+ *  \see device_free
+ */
+template <typename T>
+inline thrust::device_ptr<T> device_malloc(const std::size_t n);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/device_malloc.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/device_malloc_allocator.h

@@ -0,0 +1,193 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief An allocator which allocates storage with \p device_malloc.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/device_free.h>
+#include <thrust/device_malloc.h>
+#include <thrust/device_ptr.h>
+#include <thrust/device_reference.h>
+
+#include <limits>
+#include <stdexcept>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declarations to WAR circular #includes
+#ifndef _CCCL_DOXYGEN_INVOKED // Do not document
+template <typename>
+class device_ptr;
+template <typename T>
+device_ptr<T> device_malloc(const std::size_t n);
+#endif // _CCCL_DOXYGEN_INVOKED
+
+/*! \addtogroup allocators Allocators
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! \p device_malloc_allocator is a device memory allocator that employs the
+ *  \p device_malloc function for allocation.
+ *
+ *  \p device_malloc_allocator is deprecated in favor of <tt>thrust::mr</tt>
+ *      memory resource-based allocators.
+ *
+ *  \see device_malloc
+ *  \see device_ptr
+ *  \see device_allocator
+ *  \see https://en.cppreference.com/w/cpp/memory/allocator
+ */
+template <typename T>
+class device_malloc_allocator
+{
+public:
+  /*! Type of element allocated, \c T. */
+  using value_type = T;
+
+  /*! Pointer to allocation, \c device_ptr<T>. */
+  using pointer = device_ptr<T>;
+
+  /*! \c const pointer to allocation, \c device_ptr<const T>. */
+  using const_pointer = device_ptr<const T>;
+
+  /*! Reference to allocated element, \c device_reference<T>. */
+  using reference = device_reference<T>;
+
+  /*! \c const reference to allocated element, \c device_reference<const T>. */
+  using const_reference = device_reference<const T>;
+
+  /*! Type of allocation size, \c std::size_t. */
+  using size_type = std::size_t;
+
+  /*! Type of allocation difference, \c pointer::difference_type. */
+  using difference_type = typename pointer::difference_type;
+
+  /*! The \p rebind metafunction provides the type of a \p device_malloc_allocator
+   *  instantiated with another type.
+   *
+   *  \tparam U The other type to use for instantiation.
+   */
+  template <typename U>
+  struct rebind
+  {
+    /*! The alias \p other gives the type of the rebound \p device_malloc_allocator.
+     */
+    using other = device_malloc_allocator<U>;
+  }; // end rebind
+
+  /*! No-argument constructor has no effect. */
+  _CCCL_HOST_DEVICE inline device_malloc_allocator() {}
+
+  /*! No-argument destructor has no effect. */
+  _CCCL_HOST_DEVICE inline ~device_malloc_allocator() {}
+
+  /*! Copy constructor has no effect. */
+  _CCCL_HOST_DEVICE inline device_malloc_allocator(device_malloc_allocator const&) {}
+
+  /*! Constructor from other \p device_malloc_allocator has no effect. */
+  template <typename U>
+  _CCCL_HOST_DEVICE inline device_malloc_allocator(device_malloc_allocator<U> const&)
+  {}
+
+  device_malloc_allocator& operator=(const device_malloc_allocator&) = default;
+
+  /*! Returns the address of an allocated object.
+   *  \return <tt>&r</tt>.
+   */
+  _CCCL_HOST_DEVICE inline pointer address(reference r)
+  {
+    return &r;
+  }
+
+  /*! Returns the address an allocated object.
+   *  \return <tt>&r</tt>.
+   */
+  _CCCL_HOST_DEVICE inline const_pointer address(const_reference r)
+  {
+    return &r;
+  }
+
+  /*! Allocates storage for \p cnt objects.
+   *  \param cnt The number of objects to allocate.
+   *  \return A \p pointer to uninitialized storage for \p cnt objects.
+   *  \note Memory allocated by this function must be deallocated with \p deallocate.
+   */
+  _CCCL_HOST inline pointer allocate(size_type cnt, const_pointer = const_pointer(static_cast<T*>(0)))
+  {
+    if (cnt > this->max_size())
+    {
+      throw std::bad_alloc();
+    } // end if
+
+    return pointer(device_malloc<T>(cnt));
+  } // end allocate()
+
+  /*! Deallocates storage for objects allocated with \p allocate.
+   *  \param p A \p pointer to the storage to deallocate.
+   *  \param cnt The size of the previous allocation.
+   *  \note Memory deallocated by this function must previously have been
+   *        allocated with \p allocate.
+   */
+  _CCCL_HOST inline void deallocate(pointer p, size_type cnt) noexcept
+  {
+    // silence unused parameter warning while still leaving the parameter name for Doxygen
+    (void) (cnt);
+
+    device_free(p);
+  } // end deallocate()
+
+  /*! Returns the largest value \c n for which <tt>allocate(n)</tt> might succeed.
+   *  \return The largest value \c n for which <tt>allocate(n)</tt> might succeed.
+   */
+  inline size_type max_size() const
+  {
+    return (std::numeric_limits<size_type>::max)() / sizeof(T);
+  } // end max_size()
+
+  /*! Compares against another \p device_malloc_allocator for equality.
+   *  \return \c true
+   */
+  _CCCL_HOST_DEVICE inline bool operator==(device_malloc_allocator const&) const
+  {
+    return true;
+  }
+
+  /*! Compares against another \p device_malloc_allocator for inequality.
+   *  \return \c false
+   */
+  _CCCL_HOST_DEVICE inline bool operator!=(device_malloc_allocator const& a) const
+  {
+    return !operator==(a);
+  }
+}; // end device_malloc_allocator
+
+/*! \} // allocators
+ */
+
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/device_new.h

@@ -0,0 +1,91 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file device_new.h
+ *  \brief Constructs new elements in device memory
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 this for size_t
+#include <thrust/device_ptr.h>
+
+#include <cstddef>
+
+THRUST_NAMESPACE_BEGIN
+
+/*!
+ *  \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+/*! \p device_new implements the placement \c new operator for types
+ *  resident in device memory. \p device_new calls <tt>T</tt>'s null
+ *  constructor on a array of objects in device memory.
+ *  No memory is allocated by this function.
+ *
+ *  \param  p A \p device_ptr to a region of device memory into which
+ *          to construct one or many <tt>T</tt>s.
+ *  \param  n The number of objects to construct at \p p.
+ *  \return p, casted to <tt>T</tt>'s type.
+ *
+ *  \see device_ptr
+ */
+template <typename T>
+device_ptr<T> device_new(device_ptr<void> p, const size_t n = 1);
+
+/*! \p device_new implements the placement new operator for types
+ *  resident in device memory. \p device_new calls <tt>T</tt>'s copy
+ *  constructor on a array of objects in device memory. No memory is
+ *  allocated by this function.
+ *
+ *  \param  p A \p device_ptr to a region of device memory into which to
+ *          construct one or many <tt>T</tt>s.
+ *  \param exemplar The value from which to copy.
+ *  \param  n The number of objects to construct at \p p.
+ *  \return p, casted to <tt>T</tt>'s type.
+ *
+ *  \see device_ptr
+ *  \see fill
+ */
+template <typename T>
+device_ptr<T> device_new(device_ptr<void> p, const T& exemplar, const size_t n = 1);
+
+/*! \p device_new implements the new operator for types resident in device memory.
+ *  It allocates device memory large enough to hold \p n new objects of type \c T.
+ *
+ *  \param n The number of objects to allocate. Defaults to \c 1.
+ *  \return A \p device_ptr to the newly allocated region of device memory.
+ */
+template <typename T>
+device_ptr<T> device_new(const size_t n = 1);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/device_new.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/device_new_allocator.h

@@ -0,0 +1,181 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief An allocator which allocates storage with \p device_new.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/device_delete.h>
+#include <thrust/device_new.h>
+#include <thrust/device_ptr.h>
+#include <thrust/device_reference.h>
+
+#include <cuda/std/cstdint>
+#include <cuda/std/limits>
+
+#include <stdexcept>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup allocators Allocators
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! \p device_new_allocator is a device memory allocator that employs the
+ *  \p device_new function for allocation.
+ *
+ *  \see device_new
+ *  \see device_ptr
+ *  \see https://en.cppreference.com/w/cpp/memory/allocator
+ */
+template <typename T>
+class device_new_allocator
+{
+public:
+  /*! Type of element allocated, \c T. */
+  using value_type = T;
+
+  /*! Pointer to allocation, \c device_ptr<T>. */
+  using pointer = device_ptr<T>;
+
+  /*! \c const pointer to allocation, \c device_ptr<const T>. */
+  using const_pointer = device_ptr<const T>;
+
+  /*! Reference to allocated element, \c device_reference<T>. */
+  using reference = device_reference<T>;
+
+  /*! \c const reference to allocated element, \c device_reference<const T>. */
+  using const_reference = device_reference<const T>;
+
+  /*! Type of allocation size, \c ::cuda::std::size_t. */
+  using size_type = ::cuda::std::size_t;
+
+  /*! Type of allocation difference, \c pointer::difference_type. */
+  using difference_type = typename pointer::difference_type;
+
+  /*! The \p rebind metafunction provides the type of a \p device_new_allocator
+   *  instantiated with another type.
+   *
+   *  \tparam U The other type to use for instantiation.
+   */
+  template <typename U>
+  struct rebind
+  {
+    /*! The alias \p other gives the type of the rebound \p device_new_allocator.
+     */
+    using other = device_new_allocator<U>;
+  }; // end rebind
+
+  /*! No-argument constructor has no effect. */
+  _CCCL_HOST_DEVICE inline device_new_allocator() {}
+
+  /*! No-argument destructor has no effect. */
+  _CCCL_HOST_DEVICE inline ~device_new_allocator() {}
+
+  /*! Copy constructor has no effect. */
+  _CCCL_HOST_DEVICE inline device_new_allocator(device_new_allocator const&) {}
+
+  /*! Constructor from other \p device_malloc_allocator has no effect. */
+  template <typename U>
+  _CCCL_HOST_DEVICE inline device_new_allocator(device_new_allocator<U> const&)
+  {}
+
+  /*! Returns the address of an allocated object.
+   *  \return <tt>&r</tt>.
+   */
+  _CCCL_HOST_DEVICE inline pointer address(reference r)
+  {
+    return &r;
+  }
+
+  /*! Returns the address an allocated object.
+   *  \return <tt>&r</tt>.
+   */
+  _CCCL_HOST_DEVICE inline const_pointer address(const_reference r)
+  {
+    return &r;
+  }
+
+  /*! Allocates storage for \p cnt objects.
+   *  \param cnt The number of objects to allocate.
+   *  \return A \p pointer to uninitialized storage for \p cnt objects.
+   *  \note Memory allocated by this function must be deallocated with \p deallocate.
+   */
+  _CCCL_HOST inline pointer allocate(size_type cnt, const_pointer = const_pointer(static_cast<T*>(0)))
+  {
+    if (cnt > this->max_size())
+    {
+      throw std::bad_alloc();
+    } // end if
+
+    // use "::operator new" rather than keyword new
+    return pointer(device_new<T>(cnt));
+  } // end allocate()
+
+  /*! Deallocates storage for objects allocated with \p allocate.
+   *  \param p A \p pointer to the storage to deallocate.
+   *  \param cnt The size of the previous allocation.
+   *  \note Memory deallocated by this function must previously have been
+   *        allocated with \p allocate.
+   */
+  _CCCL_HOST inline void deallocate(pointer p, size_type cnt) noexcept
+  {
+    // use "::operator delete" rather than keyword delete
+    (void) cnt;
+    device_delete(p);
+  } // end deallocate()
+
+  /*! Returns the largest value \c n for which <tt>allocate(n)</tt> might succeed.
+   *  \return The largest value \c n for which <tt>allocate(n)</tt> might succeed.
+   */
+  _CCCL_HOST_DEVICE inline size_type max_size() const
+  {
+    return ::cuda::std::numeric_limits<size_type>::max THRUST_PREVENT_MACRO_SUBSTITUTION() / sizeof(T);
+  } // end max_size()
+
+  /*! Compares against another \p device_malloc_allocator for equality.
+   *  \return \c true
+   */
+  _CCCL_HOST_DEVICE inline bool operator==(device_new_allocator const&)
+  {
+    return true;
+  }
+
+  /*! Compares against another \p device_malloc_allocator for inequality.
+   *  \return \c false
+   */
+  _CCCL_HOST_DEVICE inline bool operator!=(device_new_allocator const& a)
+  {
+    return !operator==(a);
+  }
+}; // end device_new_allocator
+
+/*! \} // allocators
+ */
+
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/device_reference.h

@@ -0,0 +1,977 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A reference to an object which resides in memory associated with the
+ *  device system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/reference.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/device_ptr.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+/*! \p device_reference acts as a reference-like object to an object stored in device memory.
+ *  \p device_reference is not intended to be used directly; rather, this type
+ *  is the result of dereferencing a \p device_ptr. Similarly, taking the address of
+ *  a \p device_reference yields a \p device_ptr.
+ *
+ *  \p device_reference may often be used from host code in place of operations defined on
+ *  its associated \c value_type. For example, when \p device_reference refers to an
+ *  arithmetic type, arithmetic operations on it are legal:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> vec(1, 13);
+ *
+ *    thrust::device_reference<int> ref_to_thirteen = vec[0];
+ *
+ *    int x = ref_to_thirteen + 1;
+ *
+ *    // x is 14
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Similarly, we can print the value of \c ref_to_thirteen in the above code by using an
+ *  \c iostream:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <iostream>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> vec(1, 13);
+ *
+ *    thrust::device_reference<int> ref_to_thirteen = vec[0];
+ *
+ *    std::cout << ref_to_thirteen << std::endl;
+ *
+ *    // 13 is printed
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Of course, we needn't explicitly create a \p device_reference in the previous
+ *  example, because one is returned by \p device_vector's bracket operator. A more natural
+ *  way to print the value of a \p device_vector element might be:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <iostream>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> vec(1, 13);
+ *
+ *    std::cout << vec[0] << std::endl;
+ *
+ *    // 13 is printed
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  These kinds of operations should be used sparingly in performance-critical code, because
+ *  they imply a potentially expensive copy between host and device space.
+ *
+ *  Some operations which are possible with regular objects are impossible with their
+ *  corresponding \p device_reference objects due to the requirements of the C++ language. For
+ *  example, because the member access operator cannot be overloaded, member variables and functions
+ *  of a referent object cannot be directly accessed through its \p device_reference.
+ *
+ *  The following code, which generates a compiler error, illustrates:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *
+ *  struct foo
+ *  {
+ *    int x;
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<foo> foo_vec(1);
+ *
+ *    thrust::device_reference<foo> foo_ref = foo_vec[0];
+ *
+ *    foo_ref.x = 13; // ERROR: x cannot be accessed through foo_ref
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Instead, a host space copy must be created to access \c foo's \c x member:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *
+ *  struct foo
+ *  {
+ *    int x;
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<foo> foo_vec(1);
+ *
+ *    // create a local host-side foo object
+ *    foo host_foo;
+ *    host_foo.x = 13;
+ *
+ *    thrust::device_reference<foo> foo_ref = foo_vec[0];
+ *
+ *    foo_ref = host_foo;
+ *
+ *    // foo_ref's x member is 13
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Another common case where a \p device_reference cannot directly be used in place of
+ *  its referent object occurs when passing them as parameters to functions like \c printf
+ *  which have varargs parameters. Because varargs parameters must be Plain Old Data, a
+ *  \p device_reference to a POD type requires a cast when passed to \c printf:
+ *
+ *  \code
+ *  #include <stdio.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> vec(1,13);
+ *
+ *    // vec[0] must be cast to int when passing to printf
+ *    printf("%d\n", (int) vec[0]);
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see device_ptr
+ *  \see device_vector
+ */
+template <typename T>
+class device_reference : public thrust::reference<T, thrust::device_ptr<T>, thrust::device_reference<T>>
+{
+private:
+  using super_t = thrust::reference<T, thrust::device_ptr<T>, thrust::device_reference<T>>;
+
+public:
+  /*! The type of the value referenced by this type of \p device_reference.
+   */
+  using value_type = typename super_t::value_type;
+
+  /*! The type of the expression <tt>&ref</tt>, where <tt>ref</tt> is a \p device_reference.
+   */
+  using pointer = typename super_t::pointer;
+
+  /*! This copy constructor accepts a const reference to another
+   *  \p device_reference. After this \p device_reference is constructed,
+   *  it shall refer to the same object as \p other.
+   *
+   *  \param other A \p device_reference to copy from.
+   *
+   *  The following code snippet demonstrates the semantics of this
+   *  copy constructor.
+   *
+   *  \code
+   *  #include <thrust/device_vector.h>
+   *  #include <assert.h>
+   *  ...
+   *  thrust::device_vector<int> v(1,0);
+   *  thrust::device_reference<int> ref = v[0];
+   *
+   *  // ref equals the object at v[0]
+   *  assert(ref == v[0]);
+   *
+   *  // the address of ref equals the address of v[0]
+   *  assert(&ref == &v[0]);
+   *
+   *  // modifying v[0] modifies ref
+   *  v[0] = 13;
+   *  assert(ref == 13);
+   *  \endcode
+   *
+   *  \note This constructor is templated primarily to allow initialization of
+   *  <tt>device_reference<const T></tt> from <tt>device_reference<T></tt>.
+   */
+  template <typename OtherT>
+  _CCCL_HOST_DEVICE
+  device_reference(const device_reference<OtherT>& other,
+                   thrust::detail::enable_if_convertible_t<typename device_reference<OtherT>::pointer, pointer>* = 0)
+      : super_t(other)
+  {}
+
+  /*! This copy constructor initializes this \p device_reference
+   *  to refer to an object pointed to by the given \p device_ptr. After
+   *  this \p device_reference is constructed, it shall refer to the
+   *  object pointed to by \p ptr.
+   *
+   *  \param ptr A \p device_ptr to copy from.
+   *
+   *  The following code snippet demonstrates the semantic of this
+   *  copy constructor.
+   *
+   *  \code
+   *  #include <thrust/device_vector.h>
+   *  #include <assert.h>
+   *  ...
+   *  thrust::device_vector<int> v(1,0);
+   *  thrust::device_ptr<int> ptr = &v[0];
+   *  thrust::device_reference<int> ref(ptr);
+   *
+   *  // ref equals the object pointed to by ptr
+   *  assert(ref == *ptr);
+   *
+   *  // the address of ref equals ptr
+   *  assert(&ref == ptr);
+   *
+   *  // modifying *ptr modifies ref
+   *  *ptr = 13;
+   *  assert(ref == 13);
+   *  \endcode
+   */
+  _CCCL_HOST_DEVICE explicit device_reference(const pointer& ptr)
+      : super_t(ptr)
+  {}
+
+  /*! This assignment operator assigns the value of the object referenced by
+   *  the given \p device_reference to the object referenced by this
+   *  \p device_reference.
+   *
+   *  \param other The \p device_reference to assign from.
+   *  \return <tt>*this</tt>
+   */
+  template <typename OtherT>
+  _CCCL_HOST_DEVICE device_reference& operator=(const device_reference<OtherT>& other)
+  {
+    return super_t::operator=(other);
+  }
+
+  /*! Assignment operator assigns the value of the given value to the
+   *  value referenced by this \p device_reference.
+   *
+   *  \param x The value to assign from.
+   *  \return <tt>*this</tt>
+   */
+  _CCCL_HOST_DEVICE device_reference& operator=(const value_type& x)
+  {
+    return super_t::operator=(x);
+  }
+
+// declare these members for the purpose of Doxygenating them
+// they actually exist in a base class
+#if 0
+    /*! Address-of operator returns a \p device_ptr pointing to the object
+     *  referenced by this \p device_reference. It does not return the
+     *  address of this \p device_reference.
+     *
+     *  \return A \p device_ptr pointing to the object this
+     *  \p device_reference references.
+     */
+    _CCCL_HOST_DEVICE
+    pointer operator&(void) const;
+
+    /*! Conversion operator converts this \p device_reference to T
+     *  by returning a copy of the object referenced by this
+     *  \p device_reference.
+     *
+     *  \return A copy of the object referenced by this \p device_reference.
+     */
+    _CCCL_HOST_DEVICE
+    operator value_type (void) const;
+
+    /*! swaps the value this \p device_reference references with another.
+     *  \p other The other \p device_reference with which to swap.
+     */
+    _CCCL_HOST_DEVICE
+    void swap(device_reference &other);
+
+    /*! Prefix increment operator increments the object referenced by this
+     *  \p device_reference.
+     *
+     *  \return <tt>*this</tt>
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's prefix increment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *
+     *  // increment ref
+     *  ++ref;
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *  \endcode
+     *
+     *  \note The increment executes as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator++(void);
+
+    /*! Postfix increment operator copies the object referenced by this
+     *  \p device_reference, increments the object referenced by this
+     *  \p device_reference, and returns the copy.
+     *
+     *  \return A copy of the object referenced by this \p device_reference
+     *          before being incremented.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's postfix increment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // increment ref
+     *  int x = ref++;
+     *
+     *  // x equals 0
+     *  assert(x == 0)
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *  \endcode
+     *
+     *  \note The increment executes as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    value_type operator++(int);
+
+    /*! Addition assignment operator add-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the add-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's addition assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // add-assign ref
+     *  ref += 5;
+     *
+     *  // ref equals 5
+     *  assert(ref == 5);
+     *
+     *  // the object pointed to by ptr equals 5
+     *  assert(*ptr == 5);
+     *
+     *  // v[0] equals 5
+     *  assert(v[0] == 5);
+     *  \endcode
+     *
+     *  \note The add-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator+=(const T &rhs);
+
+    /*! Prefix decrement operator decrements the object referenced by this
+     *  \p device_reference.
+     *
+     *  \return <tt>*this</tt>
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's prefix decrement operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // decrement ref
+     *  --ref;
+     *
+     *  // ref equals -1
+     *  assert(ref == -1);
+     *
+     *  // the object pointed to by ptr equals -1
+     *  assert(*ptr == -1);
+     *
+     *  // v[0] equals -1
+     *  assert(v[0] == -1);
+     *  \endcode
+     *
+     *  \note The decrement executes as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator--(void);
+
+    /*! Postfix decrement operator copies the object referenced by this
+     *  \p device_reference, decrements the object referenced by this
+     *  \p device_reference, and returns the copy.
+     *
+     *  \return A copy of the object referenced by this \p device_reference
+     *          before being decremented.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's postfix decrement operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // decrement ref
+     *  int x = ref--;
+     *
+     *  // x equals 0
+     *  assert(x == 0)
+     *
+     *  // ref equals -1
+     *  assert(ref == -1);
+     *
+     *  // the object pointed to by ptr equals -1
+     *  assert(*ptr == -1);
+     *
+     *  // v[0] equals -1
+     *  assert(v[0] == -1);
+     *  \endcode
+     *
+     *  \note The decrement executes as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    value_type operator--(int);
+
+    /*! Subtraction assignment operator subtract-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the subtraction-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's addition assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // subtract-assign ref
+     *  ref -= 5;
+     *
+     *  // ref equals -5
+     *  assert(ref == -5);
+     *
+     *  // the object pointed to by ptr equals -5
+     *  assert(*ptr == -5);
+     *
+     *  // v[0] equals -5
+     *  assert(v[0] == -5);
+     *  \endcode
+     *
+     *  \note The subtract-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator-=(const T &rhs);
+
+    /*! Multiplication assignment operator multiply-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the multiply-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's multiply assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,1);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *
+     *  // multiply-assign ref
+     *  ref *= 5;
+     *
+     *  // ref equals 5
+     *  assert(ref == 5);
+     *
+     *  // the object pointed to by ptr equals 5
+     *  assert(*ptr == 5);
+     *
+     *  // v[0] equals 5
+     *  assert(v[0] == 5);
+     *  \endcode
+     *
+     *  \note The multiply-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator*=(const T &rhs);
+
+    /*! Division assignment operator divide-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the divide-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's divide assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,5);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 5
+     *  assert(ref == 5);
+     *
+     *  // the object pointed to by ptr equals 5
+     *  assert(*ptr == 5);
+     *
+     *  // v[0] equals 5
+     *  assert(v[0] == 5);
+     *
+     *  // divide-assign ref
+     *  ref /= 5;
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *  \endcode
+     *
+     *  \note The divide-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator/=(const T &rhs);
+
+    /*! Modulation assignment operator modulus-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the divide-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's divide assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,5);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 5
+     *  assert(ref == 5);
+     *
+     *  // the object pointed to by ptr equals 5
+     *  assert(*ptr == 5);
+     *
+     *  // v[0] equals 5
+     *  assert(v[0] == 5);
+     *
+     *  // modulus-assign ref
+     *  ref %= 5;
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *  \endcode
+     *
+     *  \note The modulus-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator%=(const T &rhs);
+
+    /*! Bitwise left shift assignment operator left shift-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the left shift-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's left shift assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,1);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *
+     *  // left shift-assign ref
+     *  ref <<= 1;
+     *
+     *  // ref equals 2
+     *  assert(ref == 2);
+     *
+     *  // the object pointed to by ptr equals 2
+     *  assert(*ptr == 2);
+     *
+     *  // v[0] equals 2
+     *  assert(v[0] == 2);
+     *  \endcode
+     *
+     *  \note The left shift-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator<<=(const T &rhs);
+
+    /*! Bitwise right shift assignment operator right shift-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the right shift-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's right shift assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,2);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 2
+     *  assert(ref == 2);
+     *
+     *  // the object pointed to by ptr equals 2
+     *  assert(*ptr == 2);
+     *
+     *  // v[0] equals 2
+     *  assert(v[0] == 2);
+     *
+     *  // right shift-assign ref
+     *  ref >>= 1;
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *  \endcode
+     *
+     *  \note The right shift-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator>>=(const T &rhs);
+
+    /*! Bitwise AND assignment operator AND-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the AND-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's AND assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,1);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *
+     *  // right AND-assign ref
+     *  ref &= 0;
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *  \endcode
+     *
+     *  \note The AND-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator&=(const T &rhs);
+
+    /*! Bitwise OR assignment operator OR-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the OR-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's OR assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // right OR-assign ref
+     *  ref |= 1;
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *  \endcode
+     *
+     *  \note The OR-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator|=(const T &rhs);
+
+    /*! Bitwise XOR assignment operator XOR-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the XOR-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's XOR assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,1);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *
+     *  // right XOR-assign ref
+     *  ref ^= 1;
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *  \endcode
+     *
+     *  \note The XOR-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator^=(const T &rhs);
+#endif // end doxygen-only members
+
+  /*! swaps the value of one \p device_reference with another.
+   *  \p x The first \p device_reference of interest.
+   *  \p y The second \p device_reference of interest.
+   */
+  _CCCL_HOST_DEVICE friend void swap(device_reference& x, device_reference& y) noexcept(noexcept(x.swap(y)))
+  {
+    x.swap(y);
+  }
+}; // end device_reference
+
+// declare these methods for the purpose of Doxygenating them
+// they actually are defined for a base class
+#ifdef _CCCL_DOXYGEN_INVOKED
+/*! Writes to an output stream the value of a \p device_reference.
+ *
+ *  \param os The output stream.
+ *  \param y The \p device_reference to output.
+ *  \return os.
+ */
+template <typename T, typename charT, typename traits>
+std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& os, const device_reference<T>& y);
+#endif
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/device_vector.h

@@ -0,0 +1,547 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A dynamically-sizable array of elements which resides in memory
+ *         accessible to devices.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/vector_base.h>
+#include <thrust/device_allocator.h>
+
+#include <initializer_list>
+#include <utility>
+#include <vector>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup containers Containers
+ *  \{
+ */
+
+/*! A \p device_vector is a container that supports random access to elements,
+ *  constant time removal of elements at the end, and linear time insertion
+ *  and removal of elements at the beginning or in the middle. The number of
+ *  elements in a \p device_vector may vary dynamically; memory management is
+ *  automatic. The memory associated with a \p device_vector resides in the
+ *  memory accessible to devices.
+ *
+ *  \see https://en.cppreference.com/w/cpp/container/vector
+ *  \see device_allocator
+ *  \see host_vector
+ *  \see universal_vector
+ */
+template <typename T, typename Alloc = thrust::device_allocator<T>>
+class device_vector : public detail::vector_base<T, Alloc>
+{
+private:
+  using Parent = detail::vector_base<T, Alloc>;
+
+public:
+  /*! \cond
+   */
+  using size_type  = typename Parent::size_type;
+  using value_type = typename Parent::value_type;
+  /*! \endcond
+   */
+
+  /*! This constructor creates an empty \p device_vector.
+   */
+  device_vector()
+      : Parent()
+  {}
+
+  /*! This constructor creates an empty \p device_vector.
+   *  \param alloc The allocator to use by this device_vector.
+   */
+  device_vector(const Alloc& alloc)
+      : Parent(alloc)
+  {}
+
+  /*! The destructor erases the elements.
+   */
+  //  Define an empty destructor to explicitly specify
+  //  its execution space qualifier, as a workaround for nvcc warning
+  ~device_vector() {}
+
+  /*! This constructor creates a \p device_vector with the given
+   *  size.
+   *  \param n The number of elements to initially create.
+   */
+  explicit device_vector(size_type n)
+      : Parent(n)
+  {}
+
+  /*! This constructor creates a \p device_vector with the given
+   *  size.
+   *  \param n The number of elements to initially create.
+   *  \param alloc The allocator to use by this device_vector.
+   */
+  explicit device_vector(size_type n, const Alloc& alloc)
+      : Parent(n, alloc)
+  {}
+
+  /*! This constructor creates a \p device_vector with copies
+   *  of an exemplar element.
+   *  \param n The number of elements to initially create.
+   *  \param value An element to copy.
+   */
+  explicit device_vector(size_type n, const value_type& value)
+      : Parent(n, value)
+  {}
+
+  /*! This constructor creates a \p device_vector with copies
+   *  of an exemplar element.
+   *  \param n The number of elements to initially create.
+   *  \param value An element to copy.
+   *  \param alloc The allocator to use by this device_vector.
+   */
+  explicit device_vector(size_type n, const value_type& value, const Alloc& alloc)
+      : Parent(n, value, alloc)
+  {}
+
+  /*! Copy constructor copies from an exemplar \p device_vector.
+   *  \param v The \p device_vector to copy.
+   */
+  device_vector(const device_vector& v)
+      : Parent(v)
+  {}
+
+  /*! Copy constructor copies from an exemplar \p device_vector.
+   *  \param v The \p device_vector to copy.
+   *  \param alloc The allocator to use by this device_vector.
+   */
+  device_vector(const device_vector& v, const Alloc& alloc)
+      : Parent(v, alloc)
+  {}
+
+  /*! Move constructor moves from another \p device_vector.
+   *  \param v The device_vector to move.
+   */
+  device_vector(device_vector&& v)
+      : Parent(std::move(v))
+  {}
+
+  /*! Move constructor moves from another \p device_vector.
+   *  \param v The device_vector to move.
+   *  \param alloc The allocator to use by this device_vector.
+   */
+  device_vector(device_vector&& v, const Alloc& alloc)
+      : Parent(std::move(v), alloc)
+  {}
+
+  /*! Copy assign operator copies another \p device_vector with the same type.
+   *  \param v The \p device_vector to copy.
+   */
+  device_vector& operator=(const device_vector& v)
+  {
+    Parent::operator=(v);
+    return *this;
+  }
+
+  /*! Move assign operator moves from another \p device_vector.
+   *  \param v The device_vector to move.
+   */
+  device_vector& operator=(device_vector&& v)
+  {
+    Parent::operator=(std::move(v));
+    return *this;
+  }
+
+  /*! Copy constructor copies from an exemplar \p device_vector with different type.
+   *  \param v The \p device_vector to copy.
+   */
+  template <typename OtherT, typename OtherAlloc>
+  explicit device_vector(const device_vector<OtherT, OtherAlloc>& v)
+      : Parent(v)
+  {}
+
+  /*! Assign operator copies from an exemplar \p device_vector with different type.
+   *  \param v The \p device_vector to copy.
+   */
+  template <typename OtherT, typename OtherAlloc>
+  device_vector& operator=(const device_vector<OtherT, OtherAlloc>& v)
+  {
+    Parent::operator=(v);
+    return *this;
+  }
+
+  /*! Copy constructor copies from an exemplar \c std::vector.
+   *  \param v The <tt>std::vector</tt> to copy.
+   */
+  template <typename OtherT, typename OtherAlloc>
+  device_vector(const std::vector<OtherT, OtherAlloc>& v)
+      : Parent(v)
+  {}
+
+  /*! Assign operator copies from an exemplar <tt>std::vector</tt>.
+   *  \param v The <tt>std::vector</tt> to copy.
+   */
+  template <typename OtherT, typename OtherAlloc>
+  device_vector& operator=(const std::vector<OtherT, OtherAlloc>& v)
+  {
+    Parent::operator=(v);
+    return *this;
+  }
+
+  /*! Copy construct from a \p vector_base whose element type is convertible
+   *  to \c T.
+   *
+   *  \param v The \p vector_base to copy.
+   */
+  template <typename OtherT, typename OtherAlloc>
+  device_vector(const detail::vector_base<OtherT, OtherAlloc>& v)
+      : Parent(v)
+  {}
+
+  /*! Assign a \p vector_base whose element type is convertible to \c T.
+   *  \param v The \p vector_base to copy.
+   */
+  template <typename OtherT, typename OtherAlloc>
+  device_vector& operator=(const detail::vector_base<OtherT, OtherAlloc>& v)
+  {
+    Parent::operator=(v);
+    return *this;
+  }
+
+  /*! This constructor builds a \p device_vector from an intializer_list.
+   *  \param il The intializer_list.
+   */
+  device_vector(std::initializer_list<T> il)
+      : Parent(il)
+  {}
+
+  /*! This constructor builds a \p device_vector from an intializer_list.
+   *  \param il The intializer_list.
+   *  \param alloc The allocator to use by this device_vector.
+   */
+  device_vector(std::initializer_list<T> il, const Alloc& alloc)
+      : Parent(il, alloc)
+  {}
+
+  /*! Assign an \p intializer_list with a matching element type
+   *  \param il The intializer_list.
+   */
+  device_vector& operator=(std::initializer_list<T> il)
+  {
+    Parent::operator=(il);
+    return *this;
+  }
+
+  /*! This constructor builds a \p device_vector from a range.
+   *  \param first The beginning of the range.
+   *  \param last The end of the range.
+   */
+  template <typename InputIterator>
+  device_vector(InputIterator first, InputIterator last)
+      : Parent(first, last)
+  {}
+
+  /*! This constructor builds a \p device_vector from a range.
+   *  \param first The beginning of the range.
+   *  \param last The end of the range.
+   *  \param alloc The allocator to use by this device_vector.
+   */
+  template <typename InputIterator>
+  device_vector(InputIterator first, InputIterator last, const Alloc& alloc)
+      : Parent(first, last, alloc)
+  {}
+
+  /*! Exchanges the values of two vectors.
+   *  \p x The first \p device_vector of interest.
+   *  \p y The second \p device_vector of interest.
+   */
+  friend void swap(device_vector& a, device_vector& b) noexcept(noexcept(a.swap(b)))
+  {
+    a.swap(b);
+  }
+
+// declare these members for the purpose of Doxygenating them
+// they actually exist in a base class
+#if 0
+    /*! \brief Resizes this vector to the specified number of elements.
+     *  \param new_size Number of elements this vector should contain.
+     *  \param x Data with which new elements should be populated.
+     *  \throw std::length_error If n exceeds max_size().
+     *
+     *  This method will resize this vector to the specified number of
+     *  elements.  If the number is smaller than this vector's current
+     *  size this vector is truncated, otherwise this vector is
+     *  extended and new elements are populated with given data.
+     */
+    void resize(size_type new_size, const value_type &x = value_type());
+
+    /*! Returns the number of elements in this vector.
+     */
+    size_type size() const;
+
+    /*! Returns the size() of the largest possible vector.
+     *  \return The largest possible return value of size().
+     */
+    size_type max_size() const;
+
+    /*! \brief If n is less than or equal to capacity(), this call has no effect.
+     *         Otherwise, this method is a request for allocation of additional memory. If
+     *         the request is successful, then capacity() is greater than or equal to
+     *         n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
+     *  \throw std::length_error If n exceeds max_size().
+     */
+    void reserve(size_type n);
+
+    /*! Returns the number of elements which have been reserved in this
+     *  vector.
+     */
+    size_type capacity() const;
+
+    /*! This method shrinks the capacity of this vector to exactly
+     *  fit its elements.
+     */
+    void shrink_to_fit();
+
+    /*! \brief Subscript access to the data contained in this vector_dev.
+     *  \param n The index of the element for which data should be accessed.
+     *  \return Read/write reference to data.
+     *
+     *  This operator allows for easy, array-style, data access.
+     *  Note that data access with this operator is unchecked and
+     *  out_of_range lookups are not defined.
+     */
+    reference operator[](size_type n);
+
+    /*! \brief Subscript read access to the data contained in this vector_dev.
+     *  \param n The index of the element for which data should be accessed.
+     *  \return Read reference to data.
+     *
+     *  This operator allows for easy, array-style, data access.
+     *  Note that data access with this operator is unchecked and
+     *  out_of_range lookups are not defined.
+     */
+    const_reference operator[](size_type n) const;
+
+    /*! This method returns an iterator pointing to the beginning of
+     *  this vector.
+     *  \return mStart
+     */
+    iterator begin();
+
+    /*! This method returns a const_iterator pointing to the beginning
+     *  of this vector.
+     *  \return mStart
+     */
+    const_iterator begin() const;
+
+    /*! This method returns a const_iterator pointing to the beginning
+     *  of this vector.
+     *  \return mStart
+     */
+    const_iterator cbegin() const;
+
+    /*! This method returns a reverse_iterator pointing to the beginning of
+     *  this vector's reversed sequence.
+     *  \return A reverse_iterator pointing to the beginning of this
+     *          vector's reversed sequence.
+     */
+    reverse_iterator rbegin();
+
+    /*! This method returns a const_reverse_iterator pointing to the beginning of
+     *  this vector's reversed sequence.
+     *  \return A const_reverse_iterator pointing to the beginning of this
+     *          vector's reversed sequence.
+     */
+    const_reverse_iterator rbegin() const;
+
+    /*! This method returns a const_reverse_iterator pointing to the beginning of
+     *  this vector's reversed sequence.
+     *  \return A const_reverse_iterator pointing to the beginning of this
+     *          vector's reversed sequence.
+     */
+    const_reverse_iterator crbegin() const;
+
+    /*! This method returns an iterator pointing to one element past the
+     *  last of this vector.
+     *  \return begin() + size().
+     */
+    iterator end();
+
+    /*! This method returns a const_iterator pointing to one element past the
+     *  last of this vector.
+     *  \return begin() + size().
+     */
+    const_iterator end() const;
+
+    /*! This method returns a const_iterator pointing to one element past the
+     *  last of this vector.
+     *  \return begin() + size().
+     */
+    const_iterator cend() const;
+
+    /*! This method returns a reverse_iterator pointing to one element past the
+     *  last of this vector's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    reverse_iterator rend();
+
+    /*! This method returns a const_reverse_iterator pointing to one element past the
+     *  last of this vector's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    const_reverse_iterator rend() const;
+
+    /*! This method returns a const_reverse_iterator pointing to one element past the
+     *  last of this vector's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    const_reverse_iterator crend() const;
+
+    /*! This method returns a const_reference referring to the first element of this
+     *  vector.
+     *  \return The first element of this vector.
+     */
+    const_reference front() const;
+
+    /*! This method returns a reference pointing to the first element of this
+     *  vector.
+     *  \return The first element of this vector.
+     */
+    reference front();
+
+    /*! This method returns a const reference pointing to the last element of
+     *  this vector.
+     *  \return The last element of this vector.
+     */
+    const_reference back() const;
+
+    /*! This method returns a reference referring to the last element of
+     *  this vector_dev.
+     *  \return The last element of this vector.
+     */
+    reference back();
+
+    /*! This method returns a pointer to this vector's first element.
+     *  \return A pointer to the first element of this vector.
+     */
+    pointer data();
+
+    /*! This method returns a const_pointer to this vector's first element.
+     *  \return a const_pointer to the first element of this vector.
+     */
+    const_pointer data() const;
+
+    /*! This method resizes this vector to 0.
+     */
+    void clear();
+
+    /*! This method returns true iff size() == 0.
+     *  \return true if size() == 0; false, otherwise.
+     */
+    bool empty() const;
+
+    /*! This method appends the given element to the end of this vector.
+     *  \param x The element to append.
+     */
+    void push_back(const value_type &x);
+
+    /*! This method erases the last element of this vector, invalidating
+     *  all iterators and references to it.
+     */
+    void pop_back();
+
+    /*! This method swaps the contents of this device_vector with another vector.
+     *  \param v The vector with which to swap.
+     */
+    void swap(device_vector &v);
+
+    /*! This method removes the element at position pos.
+     *  \param pos The position of the element of interest.
+     *  \return An iterator pointing to the new location of the element that followed the element
+     *          at position pos.
+     */
+    iterator erase(iterator pos);
+
+    /*! This method removes the range of elements [first,last) from this vector.
+     *  \param first The beginning of the range of elements to remove.
+     *  \param last The end of the range of elements to remove.
+     *  \return An iterator pointing to the new location of the element that followed the last
+     *          element in the sequence [first,last).
+     */
+    iterator erase(iterator first, iterator last);
+
+    /*! This method inserts a single copy of a given exemplar value at the
+     *  specified position in this vector.
+     *  \param position The insertion position.
+     *  \param x The exemplar element to copy & insert.
+     *  \return An iterator pointing to the newly inserted element.
+     */
+    iterator insert(iterator position, const T &x);
+
+    /*! This method inserts a copy of an exemplar value to a range at the
+     *  specified position in this vector.
+     *  \param position The insertion position
+     *  \param n The number of insertions to perform.
+     *  \param x The value to replicate and insert.
+     */
+    void insert(iterator position, size_type n, const T &x);
+
+    /*! This method inserts a copy of an input range at the specified position
+     *  in this vector.
+     *  \param position The insertion position.
+     *  \param first The beginning of the range to copy.
+     *  \param last  The end of the range to copy.
+     *
+     *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator>Input Iterator</a>,
+     *                        and \p InputIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>.
+     */
+    template<typename InputIterator>
+    void insert(iterator position, InputIterator first, InputIterator last);
+
+    /*! This version of \p assign replicates a given exemplar
+     *  \p n times into this vector.
+     *  \param n The number of times to copy \p x.
+     *  \param x The exemplar element to replicate.
+     */
+    void assign(size_type n, const T &x);
+
+    /*! This version of \p assign makes this vector a copy of a given input range.
+     *  \param first The beginning of the range to copy.
+     *  \param last  The end of the range to copy.
+     *
+     *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input Iterator</a>.
+     */
+    template<typename InputIterator>
+    void assign(InputIterator first, InputIterator last);
+
+    /*! This method returns a copy of this vector's allocator.
+     *  \return A copy of the allocator used by this vector.
+     */
+    allocator_type get_allocator() const;
+#endif // end doxygen-only members
+};
+
+/*! \} // containres
+ */
+
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/equal.h

@@ -0,0 +1,247 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file equal.h
+ *  \brief Equality between ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup comparisons
+ *  \ingroup reductions
+ *  \{
+ */
+
+/*! \p equal returns \c true if the two ranges <tt>[first1, last1)</tt>
+ *  and <tt>[first2, first2 + (last1 - first1))</tt> are identical when
+ *  compared element-by-element, and otherwise returns \c false.
+ *
+ *  This version of \p equal returns \c true if and only if for every
+ *  iterator \c i in <tt>[first1, last1)</tt>, <tt>*i == *(first2 + (i - first1))</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \return \c true, if the sequences are equal; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \p InputIterator1's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>, and \p
+ * InputIterator1's \c value_type can be compared for equality with \c InputIterator2's \c value_type. \tparam
+ * InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>, and \p
+ * InputIterator2's \c value_type can be compared for equality with \c InputIterator1's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p equal to test
+ *  two ranges for equality using the \p thrust::host execution policy:
+ *
+ *  \code
+ *  #include <thrust/equal.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[7] = {3, 1, 4, 1, 5, 9, 3};
+ *  int A2[7] = {3, 1, 4, 2, 8, 5, 7};
+ *  ...
+ *  bool result = thrust::equal(thrust::host, A1, A1 + 7, A2);
+ *
+ *  // result == false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal
+ */
+template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2>
+_CCCL_HOST_DEVICE bool
+equal(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+      InputIterator1 first1,
+      InputIterator1 last1,
+      InputIterator2 first2);
+
+/*! \p equal returns \c true if the two ranges <tt>[first1, last1)</tt>
+ *  and <tt>[first2, first2 + (last1 - first1))</tt> are identical when
+ *  compared element-by-element, and otherwise returns \c false.
+ *
+ *  This version of \p equal returns \c true if and only if for every
+ *  iterator \c i in <tt>[first1, last1)</tt>, <tt>*i == *(first2 + (i - first1))</tt>.
+ *
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \return \c true, if the sequences are equal; \c false, otherwise.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \p InputIterator1's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>, and \p
+ * InputIterator1's \c value_type can be compared for equality with \c InputIterator2's \c value_type. \tparam
+ * InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>, and \p
+ * InputIterator2's \c value_type can be compared for equality with \c InputIterator1's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p equal to test
+ *  two ranges for equality.
+ *
+ *  \code
+ *  #include <thrust/equal.h>
+ *  ...
+ *  int A1[7] = {3, 1, 4, 1, 5, 9, 3};
+ *  int A2[7] = {3, 1, 4, 2, 8, 5, 7};
+ *  ...
+ *  bool result = thrust::equal(A1, A1 + 7, A2);
+ *
+ *  // result == false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal
+ */
+template <typename InputIterator1, typename InputIterator2>
+bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
+
+/*! \p equal returns \c true if the two ranges <tt>[first1, last1)</tt>
+ *  and <tt>[first2, first2 + (last1 - first1))</tt> are identical when
+ *  compared element-by-element, and otherwise returns \c false.
+ *
+ *  This version of \p equal returns \c true if and only if for every
+ *  iterator \c i in <tt>[first1, last1)</tt>,
+ *  <tt>binary_pred(*i, *(first2 + (i - first1)))</tt> is \c true.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param binary_pred Binary predicate used to test element equality.
+ *  \return \c true, if the sequences are equal; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \p InputIterator1's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \p InputIterator2's \c value_type is convertible to \p BinaryPredicate's \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary
+ * Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p equal to compare the
+ *  elements in two ranges modulo 2 using the \p thrust::host execution policy.
+ *
+ *  \code
+ *  #include <thrust/equal.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  struct compare_modulo_two
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x, int y) const
+ *    {
+ *      return (x % 2) == (y % 2);
+ *    }
+ *  };
+ *  ...
+ *  int x[6] = {0, 2, 4, 6, 8, 10};
+ *  int y[6] = {1, 3, 5, 7, 9, 11};
+ *
+ *  bool result = thrust::equal(x, x + 6, y, compare_modulo_two());
+ *
+ *  // result is false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal
+ */
+template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
+_CCCL_HOST_DEVICE bool
+equal(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+      InputIterator1 first1,
+      InputIterator1 last1,
+      InputIterator2 first2,
+      BinaryPredicate binary_pred);
+
+/*! \p equal returns \c true if the two ranges <tt>[first1, last1)</tt>
+ *  and <tt>[first2, first2 + (last1 - first1))</tt> are identical when
+ *  compared element-by-element, and otherwise returns \c false.
+ *
+ *  This version of \p equal returns \c true if and only if for every
+ *  iterator \c i in <tt>[first1, last1)</tt>,
+ *  <tt>binary_pred(*i, *(first2 + (i - first1)))</tt> is \c true.
+ *
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param binary_pred Binary predicate used to test element equality.
+ *  \return \c true, if the sequences are equal; \c false, otherwise.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \p InputIterator1's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \p InputIterator2's \c value_type is convertible to \p BinaryPredicate's \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary
+ * Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p equal to compare the
+ *  elements in two ranges modulo 2.
+ *
+ *  \code
+ *  #include <thrust/equal.h>
+ *
+ *  struct compare_modulo_two
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x, int y) const
+ *    {
+ *      return (x % 2) == (y % 2);
+ *    }
+ *  };
+ *  ...
+ *  int x[6] = {0, 2, 4, 6, 8, 10};
+ *  int y[6] = {1, 3, 5, 7, 9, 11};
+ *
+ *  bool result = thrust::equal(x, x + 5, y, compare_modulo_two());
+ *
+ *  // result is true
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal
+ */
+template <typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
+bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binary_pred);
+
+/*! \} // end comparisons
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/equal.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/event.h

@@ -0,0 +1,35 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/event.h
+ *  \brief `thrust::event`, an asynchronous handle type.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/future.h>
+
+// TODO: Actually separate `<thrust/future.h>` into two headers.

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/execution_policy.h

@@ -0,0 +1,384 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/execution_policy.h
+ *  \brief Thrust execution policies.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execute_with_allocator.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/seq.h>
+
+//! \cond
+
+// #include the host system's execution_policy header
+#define __THRUST_HOST_SYSTEM_EXECUTION_POLICY_HEADER <__THRUST_HOST_SYSTEM_ROOT/execution_policy.h>
+#include __THRUST_HOST_SYSTEM_EXECUTION_POLICY_HEADER
+#undef __THRUST_HOST_SYSTEM_EXECUTION_POLICY_HEADER
+
+// #include the device system's execution_policy.h header
+#define __THRUST_DEVICE_SYSTEM_EXECUTION_POLICY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/execution_policy.h>
+#include __THRUST_DEVICE_SYSTEM_EXECUTION_POLICY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_EXECUTION_POLICY_HEADER
+
+//! \endcond
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+using host_t = thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::detail::par_t;
+
+using device_t = thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::detail::par_t;
+
+} // namespace detail
+
+/*! \endcond
+ */
+
+/*! \addtogroup execution_policies Parallel Execution Policies
+ *  \{
+ */
+
+// define execution_policy for the purpose of Doxygenating it
+// it is actually defined elsewhere
+#if 0
+/*! \p execution_policy is the base class for all Thrust parallel execution policies
+ *  like \p thrust::host, \p thrust::device, and each backend system's tag type.
+ *
+ *  Custom user-defined backends should derive a policy from this type in order to
+ *  interoperate with Thrust algorithm dispatch.
+ *
+ *  The following code snippet demonstrates how to derive a standalone custom execution policy
+ *  from \p thrust::execution_policy to implement a backend which only implements \p for_each:
+ *
+ *  \code
+ *  #include <thrust/execution_policy.h>
+ *  #include <iostream>
+ *
+ *  // define a type derived from thrust::execution_policy to distinguish our custom execution policy:
+ *  struct my_policy : thrust::execution_policy<my_policy> {};
+ *
+ *  // overload for_each on my_policy
+ *  template<typename Iterator, typename Function>
+ *  Iterator for_each(my_policy, Iterator first, Iterator last, Function f)
+ *  {
+ *    std::cout << "Hello, world from for_each(my_policy)!" << std::endl;
+ *
+ *    for(; first < last; ++first)
+ *    {
+ *      f(*first);
+ *    }
+ *
+ *    return first;
+ *  }
+ *
+ *  struct ignore_argument
+ *  {
+ *    void operator()(int) {}
+ *  };
+ *
+ *  int main()
+ *  {
+ *    int data[4];
+ *
+ *    // dispatch thrust::for_each using our custom policy:
+ *    my_policy exec;
+ *    thrust::for_each(exec, data, data + 4, ignore_argument());
+ *
+ *    // can't dispatch thrust::transform because no overload exists for my_policy:
+ *    //thrust::transform(exec, data, data, + 4, data, thrust::identity<int>()); // error!
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see host_execution_policy
+ *  \see device_execution_policy
+ */
+template<typename DerivedPolicy>
+struct execution_policy : thrust::detail::execution_policy_base<DerivedPolicy>
+{};
+#endif
+
+/*! \p host_execution_policy is the base class for all Thrust parallel execution policies
+ *  which are derived from Thrust's default host backend system configured with the \p THRUST_HOST_SYSTEM
+ *  macro.
+ *
+ *  Custom user-defined backends which wish to inherit the functionality of Thrust's host backend system
+ *  should derive a policy from this type in order to interoperate with Thrust algorithm dispatch.
+ *
+ *  The following code snippet demonstrates how to derive a standalone custom execution policy from
+ *  \p thrust::host_execution_policy to implement a backend which specializes \p for_each while inheriting
+ *  the behavior of every other algorithm from the host system:
+ *
+ *  \code
+ *  #include <thrust/execution_policy.h>
+ *  #include <iostream>
+ *
+ *  // define a type derived from thrust::host_execution_policy to distinguish our custom execution policy:
+ *  struct my_policy : thrust::host_execution_policy<my_policy> {};
+ *
+ *  // overload for_each on my_policy
+ *  template<typename Iterator, typename Function>
+ *  Iterator for_each(my_policy, Iterator first, Iterator last, Function f)
+ *  {
+ *    std::cout << "Hello, world from for_each(my_policy)!" << std::endl;
+ *
+ *    for(; first < last; ++first)
+ *    {
+ *      f(*first);
+ *    }
+ *
+ *    return first;
+ *  }
+ *
+ *  struct ignore_argument
+ *  {
+ *    void operator()(int) {}
+ *  };
+ *
+ *  int main()
+ *  {
+ *    int data[4];
+ *
+ *    // dispatch thrust::for_each using our custom policy:
+ *    my_policy exec;
+ *    thrust::for_each(exec, data, data + 4, ignore_argument());
+ *
+ *    // dispatch thrust::transform whose behavior our policy inherits
+ *    thrust::transform(exec, data, data, + 4, data, thrust::identity<int>());
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see execution_policy
+ *  \see device_execution_policy
+ */
+template <typename DerivedPolicy>
+struct host_execution_policy : thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::execution_policy<DerivedPolicy>
+{};
+
+/*! \p device_execution_policy is the base class for all Thrust parallel execution policies
+ *  which are derived from Thrust's default device backend system configured with the \p THRUST_DEVICE_SYSTEM
+ *  macro.
+ *
+ *  Custom user-defined backends which wish to inherit the functionality of Thrust's device backend system
+ *  should derive a policy from this type in order to interoperate with Thrust algorithm dispatch.
+ *
+ *  The following code snippet demonstrates how to derive a standalone custom execution policy from
+ *  \p thrust::device_execution_policy to implement a backend which specializes \p for_each while inheriting
+ *  the behavior of every other algorithm from the device system:
+ *
+ *  \code
+ *  #include <thrust/execution_policy.h>
+ *  #include <iostream>
+ *
+ *  // define a type derived from thrust::device_execution_policy to distinguish our custom execution policy:
+ *  struct my_policy : thrust::device_execution_policy<my_policy> {};
+ *
+ *  // overload for_each on my_policy
+ *  template<typename Iterator, typename Function>
+ *  Iterator for_each(my_policy, Iterator first, Iterator last, Function f)
+ *  {
+ *    std::cout << "Hello, world from for_each(my_policy)!" << std::endl;
+ *
+ *    for(; first < last; ++first)
+ *    {
+ *      f(*first);
+ *    }
+ *
+ *    return first;
+ *  }
+ *
+ *  struct ignore_argument
+ *  {
+ *    void operator()(int) {}
+ *  };
+ *
+ *  int main()
+ *  {
+ *    int data[4];
+ *
+ *    // dispatch thrust::for_each using our custom policy:
+ *    my_policy exec;
+ *    thrust::for_each(exec, data, data + 4, ignore_argument());
+ *
+ *    // dispatch thrust::transform whose behavior our policy inherits
+ *    thrust::transform(exec, data, data, + 4, data, thrust::identity<int>());
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see execution_policy
+ *  \see host_execution_policy
+ */
+template <typename DerivedPolicy>
+struct device_execution_policy : thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::execution_policy<DerivedPolicy>
+{};
+
+/*! \p thrust::host is the default parallel execution policy associated with Thrust's host backend system
+ *  configured by the \p THRUST_HOST_SYSTEM macro.
+ *
+ *  Instead of relying on implicit algorithm dispatch through iterator system tags, users may directly target
+ *  algorithm dispatch at Thrust's host system by providing \p thrust::host as an algorithm parameter.
+ *
+ *  Explicit dispatch can be useful in avoiding the introduction of data copies into containers such as
+ *  \p thrust::host_vector.
+ *
+ *  Note that even though \p thrust::host targets the host CPU, it is a parallel execution policy. That is,
+ *  the order that an algorithm invokes functors or dereferences iterators is not defined.
+ *
+ *  The type of \p thrust::host is implementation-defined.
+ *
+ *  The following code snippet demonstrates how to use \p thrust::host to explicitly dispatch an invocation
+ *  of \p thrust::for_each to the host backend system:
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdio>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  int vec[] = { 0, 1, 2 };
+ *
+ *  thrust::for_each(thrust::host, vec, vec + 3, printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see host_execution_policy
+ *  \see thrust::device
+ */
+static const detail::host_t host;
+
+/*! \p thrust::device is the default parallel execution policy associated with Thrust's device backend system
+ *  configured by the \p THRUST_DEVICE_SYSTEM macro.
+ *
+ *  Instead of relying on implicit algorithm dispatch through iterator system tags, users may directly target
+ *  algorithm dispatch at Thrust's device system by providing \p thrust::device as an algorithm parameter.
+ *
+ *  Explicit dispatch can be useful in avoiding the introduction of data copies into containers such as
+ *  \p thrust::device_vector or to avoid wrapping e.g. raw pointers allocated by the CUDA API with types
+ *  such as \p thrust::device_ptr.
+ *
+ *  The user must take care to guarantee that the iterators provided to an algorithm are compatible with
+ *  the device backend system. For example, raw pointers allocated by <tt>std::malloc</tt> typically
+ *  cannot be dereferenced by a GPU. For this reason, raw pointers allocated by host APIs should not be mixed
+ *  with a \p thrust::device algorithm invocation when the device backend is CUDA.
+ *
+ *  The type of \p thrust::device is implementation-defined.
+ *
+ *  The following code snippet demonstrates how to use \p thrust::device to explicitly dispatch an invocation
+ *  of \p thrust::for_each to the device backend system:
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdio>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  thrust::device_vector<int> vec(3);
+ *  vec[0] = 0; vec[1] = 1; vec[2] = 2;
+ *
+ *  thrust::for_each(thrust::device, vec.begin(), vec.end(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see host_execution_policy
+ *  \see thrust::device
+ */
+_CCCL_GLOBAL_CONSTANT detail::device_t device;
+
+// define seq for the purpose of Doxygenating it
+// it is actually defined elsewhere
+#if 0
+/*! \p thrust::seq is an execution policy which requires an algorithm invocation to execute sequentially
+ *  in the current thread. It can not be configured by a compile-time macro.
+ *
+ *  The type of \p thrust::seq is implementation-defined.
+ *
+ *  The following code snippet demonstrates how to use \p thrust::seq to explicitly execute an invocation
+ *  of \p thrust::for_each sequentially:
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <vector>
+ *  #include <cstdio>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  std::vector<int> vec(3);
+ *  vec[0] = 0; vec[1] = 1; vec[2] = 2;
+ *
+ *  thrust::for_each(thrust::seq, vec.begin(), vec.end(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in sequential order
+ *  \endcode
+ *
+ *  \see thrust::host
+ *  \see thrust::device
+ */
+static const detail::seq_t seq;
+#endif
+
+/*! \}
+ */
+
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/extrema.h

@@ -0,0 +1,800 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file extrema.h
+ *  \brief Functions for computing computing extremal values
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! This version of \p min returns the smaller of two values, given a comparison operation.
+ *  \param lhs The first value to compare.
+ *  \param rhs The second value to compare.
+ *  \param comp A comparison operation.
+ *  \return The smaller element.
+ *
+ *  \tparam T is convertible to \p BinaryPredicate's first argument type and to its second argument type.
+ *  \tparam BinaryPredicate is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p min to compute the smaller of two
+ *  key-value objects.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value a = {13, 0};
+ *  key_value b = { 7, 1);
+ *
+ *  key_value smaller = thrust::min(a, b, compare_key_value());
+ *
+ *  // smaller is {7, 1}
+ *  \endcode
+ *
+ *  \note Returns the first argument when the arguments are equivalent.
+ *  \see max
+ */
+template <typename T, typename BinaryPredicate>
+_CCCL_HOST_DEVICE T min THRUST_PREVENT_MACRO_SUBSTITUTION(const T& lhs, const T& rhs, BinaryPredicate comp);
+
+/*! This version of \p min returns the smaller of two values.
+ *  \param lhs The first value to compare.
+ *  \param rhs The second value to compare.
+ *  \return The smaller element.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan
+ * Comparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p min to compute the smaller of two
+ *  integers.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  int a = 13;
+ *  int b = 7;
+ *
+ *  int smaller = thrust::min(a, b);
+ *
+ *  // smaller is 7
+ *  \endcode
+ *
+ *  \note Returns the first argument when the arguments are equivalent.
+ *  \see max
+ */
+template <typename T>
+_CCCL_HOST_DEVICE T min THRUST_PREVENT_MACRO_SUBSTITUTION(const T& lhs, const T& rhs);
+
+/*! This version of \p max returns the larger of two values, given a comparison operation.
+ *  \param lhs The first value to compare.
+ *  \param rhs The second value to compare.
+ *  \param comp A comparison operation.
+ *  \return The larger element.
+ *
+ *  \tparam T is convertible to \p BinaryPredicate's first argument type and to its second argument type.
+ *  \tparam BinaryPredicate is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p max to compute the larger of two
+ *  key-value objects.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value a = {13, 0};
+ *  key_value b = { 7, 1);
+ *
+ *  key_value larger = thrust::max(a, b, compare_key_value());
+ *
+ *  // larger is {13, 0}
+ *  \endcode
+ *
+ *  \note Returns the first argument when the arguments are equivalent.
+ *  \see min
+ */
+template <typename T, typename BinaryPredicate>
+_CCCL_HOST_DEVICE T max THRUST_PREVENT_MACRO_SUBSTITUTION(const T& lhs, const T& rhs, BinaryPredicate comp);
+
+/*! This version of \p max returns the larger of two values.
+ *  \param lhs The first value to compare.
+ *  \param rhs The second value to compare.
+ *  \return The larger element.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan
+ * Comparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p max to compute the larger of two
+ *  integers.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  int a = 13;
+ *  int b = 7;
+ *
+ *  int larger = thrust::min(a, b);
+ *
+ *  // larger is 13
+ *  \endcode
+ *
+ *  \note Returns the first argument when the arguments are equivalent.
+ *  \see min
+ */
+template <typename T>
+_CCCL_HOST_DEVICE T max THRUST_PREVENT_MACRO_SUBSTITUTION(const T& lhs, const T& rhs);
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup extrema
+ *  \ingroup reductions
+ *  \{
+ */
+
+/*! \p min_element finds the smallest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value smaller
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p min_element differ in how they define whether one element is
+ *  less than another. This version compares objects using \c operator<. Specifically,
+ *  this version of \p min_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>*j < *i</tt> is
+ *  \c false.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return An iterator pointing to the smallest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \c ForwardIterator's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int *result = thrust::min_element(thrust::host, data, data + 6);
+ *
+ *  // result is data + 1
+ *  // *result is 0
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/min_element
+ */
+template <typename DerivedPolicy, typename ForwardIterator>
+_CCCL_HOST_DEVICE ForwardIterator min_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, ForwardIterator first, ForwardIterator last);
+
+/*! \p min_element finds the smallest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value smaller
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p min_element differ in how they define whether one element is
+ *  less than another. This version compares objects using \c operator<. Specifically,
+ *  this version of \p min_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>*j < *i</tt> is
+ *  \c false.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return An iterator pointing to the smallest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \c ForwardIterator's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int *result = thrust::min_element(data, data + 6);
+ *
+ *  // result is data + 1
+ *  // *result is 0
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/min_element
+ */
+template <typename ForwardIterator>
+ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
+
+/*! \p min_element finds the smallest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value smaller
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p min_element differ in how they define whether one element is
+ *  less than another. This version compares objects using a function object \p comp.
+ *  Specifically, this version of \p min_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>comp(*j, *i)</tt> is
+ *  \c false.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return An iterator pointing to the smallest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \p ForwardIterator's \c value_type is convertible to both \p comp's \c first_argument_type and \c
+ * second_argument_type. \tparam BinaryPredicate is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p min_element to find the smallest element
+ *  of a collection of key-value pairs using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  key_value *smallest = thrust::min_element(thrust::host, data, data + 4, compare_key_value());
+ *
+ *  // smallest == data + 1
+ *  // *smallest == {0,7}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/min_element
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+_CCCL_HOST_DEVICE ForwardIterator min_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  BinaryPredicate comp);
+
+/*! \p min_element finds the smallest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value smaller
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p min_element differ in how they define whether one element is
+ *  less than another. This version compares objects using a function object \p comp.
+ *  Specifically, this version of \p min_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>comp(*j, *i)</tt> is
+ *  \c false.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return An iterator pointing to the smallest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \p ForwardIterator's \c value_type is convertible to both \p comp's \c first_argument_type and \c
+ * second_argument_type. \tparam BinaryPredicate is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p min_element to find the smallest element
+ *  of a collection of key-value pairs.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  key_value *smallest = thrust::min_element(data, data + 4, compare_key_value());
+ *
+ *  // smallest == data + 1
+ *  // *smallest == {0,7}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/min_element
+ */
+template <typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator min_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp);
+
+/*! \p max_element finds the largest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value larger
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p max_element differ in how they define whether one element is
+ *  greater than another. This version compares objects using \c operator<. Specifically,
+ *  this version of \p max_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>*i < *j</tt> is
+ *  \c false.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return An iterator pointing to the largest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam A Thrust backend system.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \c ForwardIterator's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int *result = thrust::max_element(thrust::host, data, data + 6);
+ *
+ *  // *result == 3
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/max_element
+ */
+template <typename DerivedPolicy, typename ForwardIterator>
+_CCCL_HOST_DEVICE ForwardIterator max_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, ForwardIterator first, ForwardIterator last);
+
+/*! \p max_element finds the largest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value larger
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p max_element differ in how they define whether one element is
+ *  greater than another. This version compares objects using \c operator<. Specifically,
+ *  this version of \p max_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>*i < *j</tt> is
+ *  \c false.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return An iterator pointing to the largest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \c ForwardIterator's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int *result = thrust::max_element(data, data + 6);
+ *
+ *  // *result == 3
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/max_element
+ */
+template <typename ForwardIterator>
+ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
+
+/*! \p max_element finds the largest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value larger
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p max_element differ in how they define whether one element is
+ *  less than another. This version compares objects using a function object \p comp.
+ *  Specifically, this version of \p max_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>comp(*i, *j)</tt> is
+ *  \c false.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return An iterator pointing to the largest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \p ForwardIterator's \c value_type is convertible to both \p comp's \c first_argument_type and \c
+ * second_argument_type. \tparam BinaryPredicate is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p max_element to find the largest element
+ *  of a collection of key-value pairs using the \p thrust::host execution policy for parallelization.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  key_value *largest = thrust::max_element(thrust::host, data, data + 4, compare_key_value());
+ *
+ *  // largest == data + 3
+ *  // *largest == {6,1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/max_element
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+_CCCL_HOST_DEVICE ForwardIterator max_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  BinaryPredicate comp);
+
+/*! \p max_element finds the largest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value larger
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p max_element differ in how they define whether one element is
+ *  less than another. This version compares objects using a function object \p comp.
+ *  Specifically, this version of \p max_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>comp(*i, *j)</tt> is
+ *  \c false.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return An iterator pointing to the largest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \p ForwardIterator's \c value_type is convertible to both \p comp's \c first_argument_type and \c
+ * second_argument_type. \tparam BinaryPredicate is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p max_element to find the largest element
+ *  of a collection of key-value pairs.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  key_value *largest = thrust::max_element(data, data + 4, compare_key_value());
+ *
+ *  // largest == data + 3
+ *  // *largest == {6,1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/max_element
+ */
+template <typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator max_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp);
+
+/*! \p minmax_element finds the smallest and largest elements in the range <tt>[first, last)</tt>.
+ *  It returns a pair of iterators <tt>(imin, imax)</tt> where \c imin is the same iterator
+ *  returned by \p min_element and \c imax is the same iterator returned by \p max_element.
+ *  This function is potentially more efficient than separate calls to \p min_element and \p max_element.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return A pair of iterator pointing to the smallest and largest elements of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \c ForwardIterator's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  thrust::pair<int *, int *> result = thrust::minmax_element(thrust::host, data, data + 6);
+ *
+ *  // result.first is data + 1
+ *  // result.second is data + 5
+ *  // *result.first is 0
+ *  // *result.second is 3
+ *  \endcode
+ *
+ *  \see min_element
+ *  \see max_element
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf
+ */
+template <typename DerivedPolicy, typename ForwardIterator>
+_CCCL_HOST_DEVICE thrust::pair<ForwardIterator, ForwardIterator> minmax_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, ForwardIterator first, ForwardIterator last);
+
+/*! \p minmax_element finds the smallest and largest elements in the range <tt>[first, last)</tt>.
+ *  It returns a pair of iterators <tt>(imin, imax)</tt> where \c imin is the same iterator
+ *  returned by \p min_element and \c imax is the same iterator returned by \p max_element.
+ *  This function is potentially more efficient than separate calls to \p min_element and \p max_element.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return A pair of iterator pointing to the smallest and largest elements of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \c ForwardIterator's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  thrust::pair<int *, int *> result = thrust::minmax_element(data, data + 6);
+ *
+ *  // result.first is data + 1
+ *  // result.second is data + 5
+ *  // *result.first is 0
+ *  // *result.second is 3
+ *  \endcode
+ *
+ *  \see min_element
+ *  \see max_element
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf
+ */
+template <typename ForwardIterator>
+thrust::pair<ForwardIterator, ForwardIterator> minmax_element(ForwardIterator first, ForwardIterator last);
+
+/*! \p minmax_element finds the smallest and largest elements in the range <tt>[first, last)</tt>.
+ *  It returns a pair of iterators <tt>(imin, imax)</tt> where \c imin is the same iterator
+ *  returned by \p min_element and \c imax is the same iterator returned by \p max_element.
+ *  This function is potentially more efficient than separate calls to \p min_element and \p max_element.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return A pair of iterator pointing to the smallest and largest elements of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \p ForwardIterator's \c value_type is convertible to both \p comp's \c first_argument_type and \c
+ * second_argument_type. \tparam BinaryPredicate is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p minmax_element to find the smallest and largest elements
+ *  of a collection of key-value pairs using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/pair.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  thrust::pair<key_value*,key_value*> extrema = thrust::minmax_element(thrust::host, data, data + 4,
+ * compare_key_value());
+ *
+ *  // extrema.first   == data + 1
+ *  // *extrema.first  == {0,7}
+ *  // extrema.second  == data + 3
+ *  // *extrema.second == {6,1}
+ *  \endcode
+ *
+ *  \see min_element
+ *  \see max_element
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+_CCCL_HOST_DEVICE thrust::pair<ForwardIterator, ForwardIterator> minmax_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  ForwardIterator first,
+  ForwardIterator last,
+  BinaryPredicate comp);
+
+/*! \p minmax_element finds the smallest and largest elements in the range <tt>[first, last)</tt>.
+ *  It returns a pair of iterators <tt>(imin, imax)</tt> where \c imin is the same iterator
+ *  returned by \p min_element and \c imax is the same iterator returned by \p max_element.
+ *  This function is potentially more efficient than separate calls to \p min_element and \p max_element.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return A pair of iterator pointing to the smallest and largest elements of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \p ForwardIterator's \c value_type is convertible to both \p comp's \c first_argument_type and \c
+ * second_argument_type. \tparam BinaryPredicate is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p minmax_element to find the smallest and largest elements
+ *  of a collection of key-value pairs.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/pair.h>
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  thrust::pair<key_value*,key_value*> extrema = thrust::minmax_element(data, data + 4, compare_key_value());
+ *
+ *  // extrema.first   == data + 1
+ *  // *extrema.first  == {0,7}
+ *  // extrema.second  == data + 3
+ *  // *extrema.second == {6,1}
+ *  \endcode
+ *
+ *  \see min_element
+ *  \see max_element
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf
+ */
+template <typename ForwardIterator, typename BinaryPredicate>
+thrust::pair<ForwardIterator, ForwardIterator>
+minmax_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp);
+
+/*! \} // end extrema
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/extrema.inl>
+#include <thrust/detail/minmax.h>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/fill.h

@@ -0,0 +1,201 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file fill.h
+ *  \brief Fills a range with a constant value
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup transformations
+ *  \addtogroup filling
+ *  \ingroup transformations
+ *  \{
+ */
+
+/*! \p fill assigns the value \p value to every element in
+ *  the range <tt>[first, last)</tt>. That is, for every
+ *  iterator \c i in <tt>[first, last)</tt>, it performs
+ *  the assignment <tt>*i = value</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param value The value to be copied.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \p ForwardIterator is mutable. \tparam T is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>, and \p T's \c value_type is
+ * convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p fill to set a thrust::device_vector's
+ *  elements to a given value using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/fill.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> v(4);
+ *  thrust::fill(thrust::device, v.begin(), v.end(), 137);
+ *
+ *  // v[0] == 137, v[1] == 137, v[2] == 137, v[3] == 137
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/fill
+ *  \see \c fill_n
+ *  \see \c uninitialized_fill
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename T>
+_CCCL_HOST_DEVICE void
+fill(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+     ForwardIterator first,
+     ForwardIterator last,
+     const T& value);
+
+/*! \p fill assigns the value \p value to every element in
+ *  the range <tt>[first, last)</tt>. That is, for every
+ *  iterator \c i in <tt>[first, last)</tt>, it performs
+ *  the assignment <tt>*i = value</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param value The value to be copied.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \p ForwardIterator is mutable. \tparam T is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>, and \p T's \c value_type is
+ * convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p fill to set a thrust::device_vector's
+ *  elements to a given value.
+ *
+ *  \code
+ *  #include <thrust/fill.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> v(4);
+ *  thrust::fill(v.begin(), v.end(), 137);
+ *
+ *  // v[0] == 137, v[1] == 137, v[2] == 137, v[3] == 137
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/fill
+ *  \see \c fill_n
+ *  \see \c uninitialized_fill
+ */
+template <typename ForwardIterator, typename T>
+_CCCL_HOST_DEVICE void fill(ForwardIterator first, ForwardIterator last, const T& value);
+
+/*! \p fill_n assigns the value \p value to every element in
+ *  the range <tt>[first, first+n)</tt>. That is, for every
+ *  iterator \c i in <tt>[first, first+n)</tt>, it performs
+ *  the assignment <tt>*i = value</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param n The size of the sequence.
+ *  \param value The value to be copied.
+ *  \return <tt>first + n</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. \tparam T is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>, and \p T's \c value_type is
+ * convertible to a type in \p OutputIterator's set of \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p fill to set a thrust::device_vector's
+ *  elements to a given value using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/fill.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> v(4);
+ *  thrust::fill_n(thrust::device, v.begin(), v.size(), 137);
+ *
+ *  // v[0] == 137, v[1] == 137, v[2] == 137, v[3] == 137
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/fill_n
+ *  \see \c fill
+ *  \see \c uninitialized_fill_n
+ */
+template <typename DerivedPolicy, typename OutputIterator, typename Size, typename T>
+_CCCL_HOST_DEVICE OutputIterator
+fill_n(const thrust::detail::execution_policy_base<DerivedPolicy>& exec, OutputIterator first, Size n, const T& value);
+
+/*! \p fill_n assigns the value \p value to every element in
+ *  the range <tt>[first, first+n)</tt>. That is, for every
+ *  iterator \c i in <tt>[first, first+n)</tt>, it performs
+ *  the assignment <tt>*i = value</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param n The size of the sequence.
+ *  \param value The value to be copied.
+ *  \return <tt>first + n</tt>
+ *
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. \tparam T is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>, and \p T's \c value_type is
+ * convertible to a type in \p OutputIterator's set of \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p fill to set a thrust::device_vector's
+ *  elements to a given value.
+ *
+ *  \code
+ *  #include <thrust/fill.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> v(4);
+ *  thrust::fill_n(v.begin(), v.size(), 137);
+ *
+ *  // v[0] == 137, v[1] == 137, v[2] == 137, v[3] == 137
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/fill_n
+ *  \see \c fill
+ *  \see \c uninitialized_fill_n
+ */
+template <typename OutputIterator, typename Size, typename T>
+_CCCL_HOST_DEVICE OutputIterator fill_n(OutputIterator first, Size n, const T& value);
+
+/*! \} // end filling
+ *  \} // transformations
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/fill.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/for_each.h

@@ -0,0 +1,266 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/for_each.h
+ *  \brief Applies a function to each element in a range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup modifying
+ *  \ingroup transformations
+ *  \{
+ */
+
+/*! \p for_each applies the function object \p f to each element
+ *  in the range <tt>[first, last)</tt>; \p f's return value, if any,
+ *  is ignored. Unlike the C++ Standard Template Library function
+ *  <tt>std::for_each</tt>, this version offers no guarantee on
+ *  order of execution. For this reason, this version of \p for_each
+ *  does not return a copy of the function object.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param f The function object to apply to the range <tt>[first, last)</tt>.
+ *  \return last
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input
+ * Iterator</a>, and \p InputIterator's \c value_type is convertible to \p UnaryFunction's \c argument_type. \tparam
+ * UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary
+ * Function</a>, and \p UnaryFunction does not apply any non-constant operation through its argument.
+ *
+ *  The following code snippet demonstrates how to use \p for_each to print the elements
+ *  of a \p thrust::device_vector using the \p thrust::device parallelization policy:
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdio>
+ *  ...
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      // note that using printf in a __device__ function requires
+ *      // code compiled for a GPU with compute capability 2.0 or
+ *      // higher (nvcc --arch=sm_20)
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  thrust::device_vector<int> d_vec(3);
+ *  d_vec[0] = 0; d_vec[1] = 1; d_vec[2] = 2;
+ *
+ *  thrust::for_each(thrust::device, d_vec.begin(), d_vec.end(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see for_each_n
+ *  \see https://en.cppreference.com/w/cpp/algorithm/for_each
+ */
+template <typename DerivedPolicy, typename InputIterator, typename UnaryFunction>
+_CCCL_HOST_DEVICE InputIterator for_each(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  UnaryFunction f);
+
+/*! \p for_each_n applies the function object \p f to each element
+ *  in the range <tt>[first, first + n)</tt>; \p f's return value, if any,
+ *  is ignored. Unlike the C++ Standard Template Library function
+ *  <tt>std::for_each</tt>, this version offers no guarantee on
+ *  order of execution.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param n The size of the input sequence.
+ *  \param f The function object to apply to the range <tt>[first, first + n)</tt>.
+ *  \return <tt>first + n</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input
+ * Iterator</a>, and \p InputIterator's \c value_type is convertible to \p UnaryFunction's \c argument_type. \tparam
+ * Size is an integral type. \tparam UnaryFunction is a model of <a
+ * href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>, and \p UnaryFunction
+ * does not apply any non-constant operation through its argument.
+ *
+ *  The following code snippet demonstrates how to use \p for_each_n to print the elements
+ *  of a \p device_vector using the \p thrust::device parallelization policy.
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdio>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      // note that using printf in a __device__ function requires
+ *      // code compiled for a GPU with compute capability 2.0 or
+ *      // higher (nvcc --arch=sm_20)
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  thrust::device_vector<int> d_vec(3);
+ *  d_vec[0] = 0; d_vec[1] = 1; d_vec[2] = 2;
+ *
+ *  thrust::for_each_n(thrust::device, d_vec.begin(), d_vec.size(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see for_each
+ *  \see https://en.cppreference.com/w/cpp/algorithm/for_each
+ */
+template <typename DerivedPolicy, typename InputIterator, typename Size, typename UnaryFunction>
+_CCCL_HOST_DEVICE InputIterator for_each_n(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, InputIterator first, Size n, UnaryFunction f);
+
+/*! \p for_each applies the function object \p f to each element
+ *  in the range <tt>[first, last)</tt>; \p f's return value, if any,
+ *  is ignored. Unlike the C++ Standard Template Library function
+ *  <tt>std::for_each</tt>, this version offers no guarantee on
+ *  order of execution. For this reason, this version of \p for_each
+ *  does not return a copy of the function object.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param f The function object to apply to the range <tt>[first, last)</tt>.
+ *  \return last
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input
+ * Iterator</a>, and \p InputIterator's \c value_type is convertible to \p UnaryFunction's \c argument_type. \tparam
+ * UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary
+ * Function</a>, and \p UnaryFunction does not apply any non-constant operation through its argument.
+ *
+ *  The following code snippet demonstrates how to use \p for_each to print the elements
+ *  of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <stdio.h>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      // note that using printf in a __device__ function requires
+ *      // code compiled for a GPU with compute capability 2.0 or
+ *      // higher (nvcc --arch=sm_20)
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  thrust::device_vector<int> d_vec(3);
+ *  d_vec[0] = 0; d_vec[1] = 1; d_vec[2] = 2;
+ *
+ *  thrust::for_each(d_vec.begin(), d_vec.end(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see for_each_n
+ *  \see https://en.cppreference.com/w/cpp/algorithm/for_each
+ */
+template <typename InputIterator, typename UnaryFunction>
+InputIterator for_each(InputIterator first, InputIterator last, UnaryFunction f);
+
+/*! \p for_each_n applies the function object \p f to each element
+ *  in the range <tt>[first, first + n)</tt>; \p f's return value, if any,
+ *  is ignored. Unlike the C++ Standard Template Library function
+ *  <tt>std::for_each</tt>, this version offers no guarantee on
+ *  order of execution.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param n The size of the input sequence.
+ *  \param f The function object to apply to the range <tt>[first, first + n)</tt>.
+ *  \return <tt>first + n</tt>
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input
+ * Iterator</a>, and \p InputIterator's \c value_type is convertible to \p UnaryFunction's \c argument_type. \tparam
+ * Size is an integral type. \tparam UnaryFunction is a model of <a
+ * href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>, and \p UnaryFunction
+ * does not apply any non-constant operation through its argument.
+ *
+ *  The following code snippet demonstrates how to use \p for_each_n to print the elements
+ *  of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <stdio.h>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      // note that using printf in a __device__ function requires
+ *      // code compiled for a GPU with compute capability 2.0 or
+ *      // higher (nvcc --arch=sm_20)
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  thrust::device_vector<int> d_vec(3);
+ *  d_vec[0] = 0; d_vec[1] = 1; d_vec[2] = 2;
+ *
+ *  thrust::for_each_n(d_vec.begin(), d_vec.size(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see for_each
+ *  \see https://en.cppreference.com/w/cpp/algorithm/for_each
+ */
+template <typename InputIterator, typename Size, typename UnaryFunction>
+InputIterator for_each_n(InputIterator first, Size n, UnaryFunction f);
+
+/*! \} // end modifying
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/for_each.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/future.h

@@ -0,0 +1,183 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/future.h
+ *  \brief `thrust::future`, an asynchronous value type.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/cpp14_required.h>
+
+#if _CCCL_STD_VER >= 2014
+
+#  include <thrust/detail/static_assert.h>
+#  include <thrust/execution_policy.h>
+
+#  include <utility>
+
+/*
+// #include the host system's pointer.h header.
+#define __THRUST_HOST_SYSTEM_POINTER_HEADER <__THRUST_HOST_SYSTEM_ROOT/pointer.h>
+  #include __THRUST_HOST_SYSTEM_POINTER_HEADER
+#undef __THRUST_HOST_SYSTEM_POINTER_HEADER
+*/
+
+// #include the device system's pointer.h header.
+#  define __THRUST_DEVICE_SYSTEM_POINTER_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/pointer.h>
+#  include __THRUST_DEVICE_SYSTEM_POINTER_HEADER
+#  undef __THRUST_DEVICE_SYSTEM_POINTER_HEADER
+
+/*
+// #include the host system's future.h header.
+#define __THRUST_HOST_SYSTEM_FUTURE_HEADER <__THRUST_HOST_SYSTEM_ROOT/future.h>
+  #include __THRUST_HOST_SYSTEM_FUTURE_HEADER
+#undef __THRUST_HOST_SYSTEM_FUTURE_HEADER
+*/
+
+// #include the device system's future.h header.
+#  define __THRUST_DEVICE_SYSTEM_FUTURE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/future.h>
+#  include __THRUST_DEVICE_SYSTEM_FUTURE_HEADER
+#  undef __THRUST_DEVICE_SYSTEM_FUTURE_HEADER
+
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+THRUST_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+
+// `select_unique_(future|event)_type` is a hook for choosing the
+// `unique_eager_event`/`unique_eager_future` type for a system. `decltype` is
+// used to determine the return type of an ADL call to
+// `select_unique_eager_(future|event)_type(system)`; that return type should
+// be the correct event/future type for `system`. Overloads should only be
+// declared, not defined.
+
+namespace unimplemented
+{
+
+struct CCCL_DEPRECATED no_unique_eager_event_type_found
+{};
+
+CCCL_DEPRECATED _CCCL_HOST inline no_unique_eager_event_type_found unique_eager_event_type(...) noexcept;
+
+struct CCCL_DEPRECATED no_unique_eager_future_type_found
+{};
+
+template <typename T>
+CCCL_DEPRECATED _CCCL_HOST no_unique_eager_future_type_found unique_eager_future_type(...) noexcept;
+
+} // namespace unimplemented
+
+namespace unique_eager_event_type_detail
+{
+
+using unimplemented::unique_eager_event_type;
+
+template <typename System>
+using select CCCL_DEPRECATED = decltype(unique_eager_event_type(std::declval<System>()));
+
+} // namespace unique_eager_event_type_detail
+
+namespace unique_eager_future_type_detail
+{
+
+using unimplemented::unique_eager_future_type;
+
+template <typename System, typename T>
+using select CCCL_DEPRECATED = decltype(unique_eager_future_type<T>(std::declval<System>()));
+
+} // namespace unique_eager_future_type_detail
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename System>
+using unique_eager_event CCCL_DEPRECATED = unique_eager_event_type_detail::select<System>;
+
+template <typename System>
+using event CCCL_DEPRECATED = unique_eager_event<System>;
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename System, typename T>
+using unique_eager_future CCCL_DEPRECATED = unique_eager_future_type_detail::select<System, T>;
+
+template <typename System, typename T>
+using future CCCL_DEPRECATED = unique_eager_future<System, T>;
+
+/*
+///////////////////////////////////////////////////////////////////////////////
+
+using host_unique_eager_event = unique_eager_event_type_detail::select<
+  thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::tag
+>;
+using host_event = host_unique_eager_event;
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+using host_unique_eager_future = unique_eager_future_type_detail::select<
+  thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::tag, T
+>;
+template <typename T>
+using host_future = host_unique_eager_future<T>;
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+
+using device_unique_eager_event CCCL_DEPRECATED =
+  unique_eager_event_type_detail::select<thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::tag>;
+
+using device_event CCCL_DEPRECATED = device_unique_eager_event;
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+using device_unique_eager_future CCCL_DEPRECATED =
+  unique_eager_future_type_detail::select<thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::tag, T>;
+
+template <typename T>
+using device_future CCCL_DEPRECATED = device_unique_eager_future<T>;
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct CCCL_DEPRECATED new_stream_t final
+{};
+
+#  ifndef CCCL_HEADER_MACRO_CHECK
+// when building header tests, we get a deprecation warning from cudafe1.stub.c if we deprecate a global variable
+CCCL_DEPRECATED
+#  endif
+_CCCL_GLOBAL_CONSTANT new_stream_t new_stream{};
+
+///////////////////////////////////////////////////////////////////////////////
+
+using thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::when_all;
+
+///////////////////////////////////////////////////////////////////////////////
+
+_CCCL_SUPPRESS_DEPRECATED_POP
+THRUST_NAMESPACE_END
+
+#endif

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/generate.h

@@ -0,0 +1,197 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file generate.h
+ *  \brief Fills a range with values "generated" from a function of no arguments
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup transformations
+ *  \{
+ */
+
+/*! \p generate assigns the result of invoking \p gen, a function object that takes no arguments,
+ *  to each element in the range <tt>[first,last)</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element in the range of interest.
+ *  \param last The last element in the range of interest.
+ *  \param gen A function argument, taking no parameters, used to generate values to assign to
+ *             elements in the range <tt>[first,last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \p ForwardIterator is mutable. \tparam Generator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/utility/functional">Generator</a>, and \p Generator's \c result_type is
+ * convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to fill a \c host_vector with random numbers,
+ *  using the standard C library function \c rand using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/generate.h>
+ *  #include <thrust/host_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdlib>
+ *  ...
+ *  thrust::host_vector<int> v(10);
+ *  srand(13);
+ *  thrust::generate(thrust::host, v.begin(), v.end(), rand);
+ *
+ *  // the elements of v are now pseudo-random numbers
+ *  \endcode
+ *
+ *  \see generate_n
+ *  \see https://en.cppreference.com/w/cpp/algorithm/generate
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename Generator>
+_CCCL_HOST_DEVICE void
+generate(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+         ForwardIterator first,
+         ForwardIterator last,
+         Generator gen);
+
+/*! \p generate assigns the result of invoking \p gen, a function object that takes no arguments,
+ *  to each element in the range <tt>[first,last)</tt>.
+ *
+ *  \param first The first element in the range of interest.
+ *  \param last The last element in the range of interest.
+ *  \param gen A function argument, taking no parameters, used to generate values to assign to
+ *             elements in the range <tt>[first,last)</tt>.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward
+ * Iterator</a>, and \p ForwardIterator is mutable. \tparam Generator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/utility/functional">Generator</a>, and \p Generator's \c result_type is
+ * convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to fill a \c host_vector with random numbers,
+ *  using the standard C library function \c rand.
+ *
+ *  \code
+ *  #include <thrust/generate.h>
+ *  #include <thrust/host_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdlib>
+ *  ...
+ *  thrust::host_vector<int> v(10);
+ *  srand(13);
+ *  thrust::generate(v.begin(), v.end(), rand);
+ *
+ *  // the elements of v are now pseudo-random numbers
+ *  \endcode
+ *
+ *  \see generate_n
+ *  \see https://en.cppreference.com/w/cpp/algorithm/generate
+ */
+template <typename ForwardIterator, typename Generator>
+void generate(ForwardIterator first, ForwardIterator last, Generator gen);
+
+/*! \p generate_n assigns the result of invoking \p gen, a function object that takes no arguments,
+ *  to each element in the range <tt>[first,first + n)</tt>. The return value is <tt>first + n</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element in the range of interest.
+ *  \param n The size of the range of interest.
+ *  \param gen A function argument, taking no parameters, used to generate values to assign to
+ *             elements in the range <tt>[first,first + n)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. \tparam Size is an integral type (either signed or unsigned). \tparam Generator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/utility/functional">Generator</a>, and \p Generator's \c result_type is
+ * convertible to a type in \p OutputIterator's set of \c value_types.
+ *
+ *  The following code snippet demonstrates how to fill a \c host_vector with random numbers,
+ *  using the standard C library function \c rand using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/generate.h>
+ *  #include <thrust/host_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdlib>
+ *  ...
+ *  thrust::host_vector<int> v(10);
+ *  srand(13);
+ *  thrust::generate_n(thrust::host, v.begin(), 10, rand);
+ *
+ *  // the elements of v are now pseudo-random numbers
+ *  \endcode
+ *
+ *  \see generate
+ *  \see https://en.cppreference.com/w/cpp/algorithm/generate
+ */
+template <typename DerivedPolicy, typename OutputIterator, typename Size, typename Generator>
+_CCCL_HOST_DEVICE OutputIterator generate_n(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, OutputIterator first, Size n, Generator gen);
+
+/*! \p generate_n assigns the result of invoking \p gen, a function object that takes no arguments,
+ *  to each element in the range <tt>[first,first + n)</tt>. The return value is <tt>first + n</tt>.
+ *
+ *  \param first The first element in the range of interest.
+ *  \param n The size of the range of interest.
+ *  \param gen A function argument, taking no parameters, used to generate values to assign to
+ *             elements in the range <tt>[first,first + n)</tt>.
+ *
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. \tparam Size is an integral type (either signed or unsigned). \tparam Generator is a model of <a
+ * href="https://en.cppreference.com/w/cpp/utility/functional">Generator</a>, and \p Generator's \c result_type is
+ * convertible to a type in \p OutputIterator's set of \c value_types.
+ *
+ *  The following code snippet demonstrates how to fill a \c host_vector with random numbers,
+ *  using the standard C library function \c rand.
+ *
+ *  \code
+ *  #include <thrust/generate.h>
+ *  #include <thrust/host_vector.h>
+ *  #include <stdlib.h>
+ *  ...
+ *  thrust::host_vector<int> v(10);
+ *  srand(13);
+ *  thrust::generate_n(v.begin(), 10, rand);
+ *
+ *  // the elements of v are now pseudo-random numbers
+ *  \endcode
+ *
+ *  \see generate
+ *  \see https://en.cppreference.com/w/cpp/algorithm/generate
+ */
+template <typename OutputIterator, typename Size, typename Generator>
+OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
+
+/*! \} // end transformations
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/generate.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/inner_product.h

@@ -0,0 +1,268 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file inner_product.h
+ *  \brief Mathematical inner product between ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup transformed_reductions Transformed Reductions
+ *  \ingroup reductions
+ *  \{
+ */
+
+/*! \p inner_product calculates an inner product of the ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, first2 + (last1 - first1))</tt>.
+ *
+ *  Specifically, this version of \p inner_product computes the sum
+ *  <tt>init + (*first1 * *first2) + (*(first1+1) * *(first2+1)) + ... </tt>
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1 The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param init Initial value of the result.
+ *  \return The inner product of sequences <tt>[first1, last1)</tt>
+ *          and <tt>[first2, last2)</tt> plus \p init.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \tparam InputIterator2 is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>, \tparam OutputType is a model of
+ * <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>, and if \c x is an object of type
+ * \p OutputType, and \c y is an object of \p InputIterator1's \c value_type, and \c z is an object of \p
+ * InputIterator2's \c value_type, then <tt>x + y * z</tt> is defined and is convertible to \p OutputType.
+ *
+ *  The following code demonstrates how to use \p inner_product to
+ *  compute the dot product of two vectors using the \p thrust::host execution policy for parallelization.
+ *
+ *  \code
+ *  #include <thrust/inner_product.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  float vec1[3] = {1.0f, 2.0f, 5.0f};
+ *  float vec2[3] = {4.0f, 1.0f, 5.0f};
+ *
+ *  float result = thrust::inner_product(thrust::host, vec1, vec1 + 3, vec2, 0.0f);
+ *
+ *  // result == 31.0f
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/inner_product
+ */
+template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputType>
+_CCCL_HOST_DEVICE OutputType inner_product(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator1 first1,
+  InputIterator1 last1,
+  InputIterator2 first2,
+  OutputType init);
+
+/*! \p inner_product calculates an inner product of the ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, first2 + (last1 - first1))</tt>.
+ *
+ *  Specifically, this version of \p inner_product computes the sum
+ *  <tt>init + (*first1 * *first2) + (*(first1+1) * *(first2+1)) + ... </tt>
+ *
+ *  Unlike the C++ Standard Template Library function <tt>std::inner_product</tt>,
+ *  this version offers no guarantee on order of execution.
+ *
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1 The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param init Initial value of the result.
+ *  \return The inner product of sequences <tt>[first1, last1)</tt>
+ *          and <tt>[first2, last2)</tt> plus \p init.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \tparam InputIterator2 is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>, \tparam OutputType is a model of
+ * <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>, and if \c x is an object of type
+ * \p OutputType, and \c y is an object of \p InputIterator1's \c value_type, and \c z is an object of \p
+ * InputIterator2's \c value_type, then <tt>x + y * z</tt> is defined and is convertible to \p OutputType.
+ *
+ *  The following code demonstrates how to use \p inner_product to
+ *  compute the dot product of two vectors.
+ *
+ *  \code
+ *  #include <thrust/inner_product.h>
+ *  ...
+ *  float vec1[3] = {1.0f, 2.0f, 5.0f};
+ *  float vec2[3] = {4.0f, 1.0f, 5.0f};
+ *
+ *  float result = thrust::inner_product(vec1, vec1 + 3, vec2, 0.0f);
+ *
+ *  // result == 31.0f
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/inner_product
+ */
+template <typename InputIterator1, typename InputIterator2, typename OutputType>
+OutputType inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputType init);
+
+/*! \p inner_product calculates an inner product of the ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, first2 + (last1 - first1))</tt>.
+ *
+ *  This version of \p inner_product is identical to the first, except that is uses
+ *  two user-supplied function objects instead of \c operator+ and \c operator*.
+ *
+ *  Specifically, this version of \p inner_product computes the sum
+ *  <tt>binary_op1( init, binary_op2(*first1, *first2) ), ... </tt>
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1 The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param init Initial value of the result.
+ *  \param binary_op1 Generalized addition operation.
+ *  \param binary_op2 Generalized multiplication operation.
+ *  \return The inner product of sequences <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \p InputIterator1's \c value_type is convertible to \p BinaryFunction2's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>. and \p InputIterator2's \c value_type is convertible to \p BinaryFunction2's \c second_argument_type.
+ *  \tparam OutputType is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>, and \p OutputType is convertible to
+ * \p BinaryFunction1's \c first_argument_type. \tparam BinaryFunction1 is a model of <a
+ * href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>, and \p
+ * BinaryFunction1's \c return_type is convertible to \p OutputType. \tparam BinaryFunction2 is a model of <a
+ * href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>, and \p
+ * BinaryFunction2's \c return_type is convertible to \p BinaryFunction1's \c second_argument_type.
+ *
+ *  \code
+ *  #include <thrust/inner_product.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  float vec1[3] = {1.0f, 2.0f, 5.0f};
+ *  float vec2[3] = {4.0f, 1.0f, 5.0f};
+ *
+ *  float init = 0.0f;
+ *  thrust::plus<float>       binary_op1;
+ *  thrust::multiplies<float> binary_op2;
+ *
+ *  float result = thrust::inner_product(thrust::host, vec1, vec1 + 3, vec2, init, binary_op1, binary_op2);
+ *
+ *  // result == 31.0f
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/inner_product
+ */
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputType,
+          typename BinaryFunction1,
+          typename BinaryFunction2>
+_CCCL_HOST_DEVICE OutputType inner_product(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator1 first1,
+  InputIterator1 last1,
+  InputIterator2 first2,
+  OutputType init,
+  BinaryFunction1 binary_op1,
+  BinaryFunction2 binary_op2);
+
+/*! \p inner_product calculates an inner product of the ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, first2 + (last1 - first1))</tt>.
+ *
+ *  This version of \p inner_product is identical to the first, except that is uses
+ *  two user-supplied function objects instead of \c operator+ and \c operator*.
+ *
+ *  Specifically, this version of \p inner_product computes the sum
+ *  <tt>binary_op1( init, binary_op2(*first1, *first2) ), ... </tt>
+ *
+ *  Unlike the C++ Standard Template Library function <tt>std::inner_product</tt>,
+ *  this version offers no guarantee on order of execution.
+ *
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1 The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param init Initial value of the result.
+ *  \param binary_op1 Generalized addition operation.
+ *  \param binary_op2 Generalized multiplication operation.
+ *  \return The inner product of sequences <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, and \p InputIterator1's \c value_type is convertible to \p BinaryFunction2's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>. and \p InputIterator2's \c value_type is convertible to \p BinaryFunction2's \c second_argument_type.
+ *  \tparam OutputType is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>, and \p OutputType is convertible to
+ * \p BinaryFunction1's \c first_argument_type. \tparam BinaryFunction1 is a model of <a
+ * href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>, and \p
+ * BinaryFunction1's \c return_type is convertible to \p OutputType. \tparam BinaryFunction2 is a model of <a
+ * href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>, and \p
+ * BinaryFunction2's \c return_type is convertible to \p BinaryFunction1's \c second_argument_type.
+ *
+ *  \code
+ *  #include <thrust/inner_product.h>
+ *  ...
+ *  float vec1[3] = {1.0f, 2.0f, 5.0f};
+ *  float vec2[3] = {4.0f, 1.0f, 5.0f};
+ *
+ *  float init = 0.0f;
+ *  thrust::plus<float>       binary_op1;
+ *  thrust::multiplies<float> binary_op2;
+ *
+ *  float result = thrust::inner_product(vec1, vec1 + 3, vec2, init, binary_op1, binary_op2);
+ *
+ *  // result == 31.0f
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/inner_product
+ */
+template <typename InputIterator1,
+          typename InputIterator2,
+          typename OutputType,
+          typename BinaryFunction1,
+          typename BinaryFunction2>
+OutputType inner_product(
+  InputIterator1 first1,
+  InputIterator1 last1,
+  InputIterator2 first2,
+  OutputType init,
+  BinaryFunction1 binary_op1,
+  BinaryFunction2 binary_op2);
+
+/*! \} // end transformed_reductions
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/inner_product.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/logical.h

@@ -0,0 +1,290 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file logical.h
+ *  \brief Logical operations on ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup logical
+ *  \ingroup reductions
+ *  \{
+ */
+
+/*! \p all_of determines whether all elements in a range satisfy a predicate.
+ *  Specifically, \p all_of returns \c true if <tt>pred(*i)</tt> is \c true
+ *  for every iterator \c i in the range <tt>[first, last)</tt> and
+ *  \c false otherwise.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if all elements satisfy the predicate; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \tparam Predicate must be a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::all_of(thrust::host, A, A + 2, thrust::identity<bool>()); // returns true
+ *  thrust::all_of(thrust::host, A, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  // empty range
+ *  thrust::all_of(thrust::host, A, A, thrust::identity<bool>()); // returns false
+ *
+ *  \endcode
+ *
+ *  \see any_of
+ *  \see none_of
+ *  \see transform_reduce
+ */
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+_CCCL_HOST_DEVICE bool
+all_of(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+       InputIterator first,
+       InputIterator last,
+       Predicate pred);
+
+/*! \p all_of determines whether all elements in a range satisfy a predicate.
+ * Specifically, \p all_of returns \c true if <tt>pred(*i)</tt> is \c true
+ * for every iterator \c i in the range <tt>[first, last)</tt> and
+ * \c false otherwise.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if all elements satisfy the predicate; \c false, otherwise.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \tparam Predicate must be a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::all_of(A, A + 2, thrust::identity<bool>()); // returns true
+ *  thrust::all_of(A, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  // empty range
+ *  thrust::all_of(A, A, thrust::identity<bool>()); // returns false
+ *
+ *  \endcode
+ *
+ *  \see any_of
+ *  \see none_of
+ *  \see transform_reduce
+ */
+template <typename InputIterator, typename Predicate>
+bool all_of(InputIterator first, InputIterator last, Predicate pred);
+
+/*! \p any_of determines whether any element in a range satisfies a predicate.
+ *  Specifically, \p any_of returns \c true if <tt>pred(*i)</tt> is \c true
+ *  for any iterator \c i in the range <tt>[first, last)</tt> and
+ *  \c false otherwise.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if any element satisfies the predicate; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \tparam Predicate must be a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::any_of(thrust::host, A, A + 2, thrust::identity<bool>()); // returns true
+ *  thrust::any_of(thrust::host, A, A + 3, thrust::identity<bool>()); // returns true
+ *
+ *  thrust::any_of(thrust::host, A + 2, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  // empty range
+ *  thrust::any_of(thrust::host, A, A, thrust::identity<bool>()); // returns false
+ *  \endcode
+ *
+ *  \see all_of
+ *  \see none_of
+ *  \see transform_reduce
+ */
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+_CCCL_HOST_DEVICE bool
+any_of(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+       InputIterator first,
+       InputIterator last,
+       Predicate pred);
+
+/*! \p any_of determines whether any element in a range satisfies a predicate.
+ * Specifically, \p any_of returns \c true if <tt>pred(*i)</tt> is \c true
+ * for any iterator \c i in the range <tt>[first, last)</tt> and
+ * \c false otherwise.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if any element satisfies the predicate; \c false, otherwise.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \tparam Predicate must be a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::any_of(A, A + 2, thrust::identity<bool>()); // returns true
+ *  thrust::any_of(A, A + 3, thrust::identity<bool>()); // returns true
+ *
+ *  thrust::any_of(A + 2, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  // empty range
+ *  thrust::any_of(A, A, thrust::identity<bool>()); // returns false
+ *  \endcode
+ *
+ *  \see all_of
+ *  \see none_of
+ *  \see transform_reduce
+ */
+template <typename InputIterator, typename Predicate>
+bool any_of(InputIterator first, InputIterator last, Predicate pred);
+
+/*! \p none_of determines whether no element in a range satisfies a predicate.
+ *  Specifically, \p none_of returns \c true if there is no iterator \c i in
+ *  the range <tt>[first, last)</tt> such that <tt>pred(*i)</tt> is \c true,
+ *  and \c false otherwise.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if no element satisfies the predicate; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \tparam Predicate must be a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::none_of(thrust::host, A, A + 2, thrust::identity<bool>()); // returns false
+ *  thrust::none_of(thrust::host, A, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  thrust::none_of(thrust::host, A + 2, A + 3, thrust::identity<bool>()); // returns true
+ *
+ *  // empty range
+ *  thrust::none_of(thrust::host, A, A, thrust::identity<bool>()); // returns true
+ *  \endcode
+ *
+ *  \see all_of
+ *  \see any_of
+ *  \see transform_reduce
+ */
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+_CCCL_HOST_DEVICE bool
+none_of(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+        InputIterator first,
+        InputIterator last,
+        Predicate pred);
+
+/*! \p none_of determines whether no element in a range satisfies a predicate.
+ *  Specifically, \p none_of returns \c true if there is no iterator \c i in
+ *  the range <tt>[first, last)</tt> such that <tt>pred(*i)</tt> is \c true,
+ *  and \c false otherwise.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if no element satisfies the predicate; \c false, otherwise.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \tparam Predicate must be a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::none_of(A, A + 2, thrust::identity<bool>()); // returns false
+ *  thrust::none_of(A, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  thrust::none_of(A + 2, A + 3, thrust::identity<bool>()); // returns true
+ *
+ *  // empty range
+ *  thrust::none_of(A, A, thrust::identity<bool>()); // returns true
+ *  \endcode
+ *
+ *  \see all_of
+ *  \see any_of
+ *  \see transform_reduce
+ */
+template <typename InputIterator, typename Predicate>
+bool none_of(InputIterator first, InputIterator last, Predicate pred);
+
+/*! \} // end logical
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/logical.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/memory.h

@@ -0,0 +1,395 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/memory.h
+ *  \brief Abstractions for Thrust's memory model.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/pointer.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/raw_reference_cast.h>
+#include <thrust/detail/reference.h>
+#include <thrust/detail/temporary_buffer.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+// define pointer for the purpose of Doxygenating it
+// it is actually defined elsewhere
+#if 0
+/*! \p pointer stores a pointer to an object allocated in memory. Like \p device_ptr, this
+ *  type ensures type safety when dispatching standard algorithms on ranges resident in memory.
+ *
+ *  \p pointer generalizes \p device_ptr by relaxing the backend system associated with the \p pointer.
+ *  Instead of the backend system specified by \p THRUST_DEVICE_SYSTEM, \p pointer's
+ *  system is given by its second template parameter, \p Tag. For the purpose of Thrust dispatch,
+ *  <tt>device_ptr<Element></tt> and <tt>pointer<Element,device_system_tag></tt> are considered equivalent.
+ *
+ *  The raw pointer encapsulated by a \p pointer may be obtained through its <tt>get</tt> member function
+ *  or the \p raw_pointer_cast free function.
+ *
+ *  \tparam Element specifies the type of the pointed-to object.
+ *
+ *  \tparam Tag specifies the system with which this \p pointer is associated. This may be any Thrust
+ *          backend system, or a user-defined tag.
+ *
+ *  \tparam Reference allows the client to specify the reference type returned upon derereference.
+ *          By default, this type is <tt>reference<Element,pointer></tt>.
+ *
+ *  \tparam Derived allows the client to specify the name of the derived type when \p pointer is used as
+ *          a base class. This is useful to ensure that arithmetic on values of the derived type return
+ *          values of the derived type as a result. By default, this type is <tt>pointer<Element,Tag,Reference></tt>.
+ *
+ *  \note \p pointer is not a smart pointer; it is the client's responsibility to deallocate memory
+ *        pointer to by \p pointer.
+ *
+ *  \see device_ptr
+ *  \see reference
+ *  \see raw_pointer_cast
+ */
+template<typename Element, typename Tag, typename Reference = thrust::use_default, typename Derived = thrust::use_default>
+  class pointer
+{
+  public:
+    /*! The type of the raw pointer
+     */
+    using raw_pointer = typename super_t::base_type;
+
+    /*! \p pointer's default constructor initializes its encapsulated pointer to \c 0
+     */
+    _CCCL_HOST_DEVICE
+    pointer();
+
+    /*! This constructor allows construction of a <tt>pointer<const T, ...></tt> from a <tt>T*</tt>.
+     *
+     *  \param ptr A raw pointer to copy from, presumed to point to a location in \p Tag's memory.
+     *  \tparam OtherElement \p OtherElement shall be convertible to \p Element.
+     */
+    template<typename OtherElement>
+    _CCCL_HOST_DEVICE
+    explicit pointer(OtherElement *ptr);
+
+    /*! This constructor allows initialization from another pointer-like object.
+     *
+     *  \param other The \p OtherPointer to copy.
+     *
+     *  \tparam OtherPointer The tag associated with \p OtherPointer shall be convertible to \p Tag,
+     *                       and its element type shall be convertible to \p Element.
+     */
+    template<typename OtherPointer>
+    _CCCL_HOST_DEVICE
+    pointer(const OtherPointer &other,
+            typename thrust::detail::enable_if_pointer_is_convertible<
+              OtherPointer,
+              pointer<Element,Tag,Reference,Derived>
+            >::type * = 0);
+
+    /*! Assignment operator allows assigning from another pointer-like object whose element type
+     *  is convertible to \c Element.
+     *
+     *  \param other The other pointer-like object to assign from.
+     *  \return <tt>*this</tt>
+     *
+     *  \tparam OtherPointer The tag associated with \p OtherPointer shall be convertible to \p Tag,
+     *                       and its element type shall be convertible to \p Element.
+     */
+    template<typename OtherPointer>
+    _CCCL_HOST_DEVICE
+    typename thrust::detail::enable_if_pointer_is_convertible<
+      OtherPointer,
+      pointer,
+      derived_type &
+    >::type
+    operator=(const OtherPointer &other);
+
+    /*! \p get returns this \p pointer's encapsulated raw pointer.
+     *  \return This \p pointer's raw pointer.
+     */
+    _CCCL_HOST_DEVICE
+    Element *get() const;
+};
+#endif
+
+#ifndef _CCCL_DOXYGEN_INVOKED // Doxygen cannot handle both versions
+
+/*! This version of \p malloc allocates untyped uninitialized storage associated with a given system.
+ *
+ *  \param system The Thrust system with which to associate the storage.
+ *  \param n The number of bytes of storage to allocate.
+ *  \return If allocation succeeds, a pointer to the allocated storage; a null pointer otherwise.
+ *          The pointer must be deallocated with \p thrust::free.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *
+ *  \pre \p DerivedPolicy must be publicly derived from <tt>thrust::execution_policy<DerivedPolicy></tt>.
+ *
+ *  The following code snippet demonstrates how to use \p malloc to allocate a range of memory
+ *  associated with Thrust's device system.
+ *
+ *  \code
+ *  #include <thrust/memory.h>
+ *  ...
+ *  // allocate some memory with thrust::malloc
+ *  const int N = 100;
+ *  thrust::device_system_tag device_sys;
+ *  thrust::pointer<void,thrust::device_space_tag> void_ptr = thrust::malloc(device_sys, N);
+ *
+ *  // manipulate memory
+ *  ...
+ *
+ *  // deallocate void_ptr with thrust::free
+ *  thrust::free(device_sys, void_ptr);
+ *  \endcode
+ *
+ *  \see free
+ *  \see device_malloc
+ */
+template <typename DerivedPolicy>
+_CCCL_HOST_DEVICE pointer<void, DerivedPolicy>
+malloc(const thrust::detail::execution_policy_base<DerivedPolicy>& system, std::size_t n);
+
+#endif // _CCCL_DOXYGEN_INVOKED
+
+/*! This version of \p malloc allocates typed uninitialized storage associated with a given system.
+ *
+ *  \param system The Thrust system with which to associate the storage.
+ *  \param n The number of elements of type \c T which the storage should accommodate.
+ *  \return If allocation succeeds, a pointer to an allocation large enough to accommodate \c n
+ *          elements of type \c T; a null pointer otherwise.
+ *          The pointer must be deallocated with \p thrust::free.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *
+ *  \pre \p DerivedPolicy must be publicly derived from <tt>thrust::execution_policy<DerivedPolicy></tt>.
+ *
+ *  The following code snippet demonstrates how to use \p malloc to allocate a range of memory
+ *  to accommodate integers associated with Thrust's device system.
+ *
+ *  \code
+ *  #include <thrust/memory.h>
+ *  ...
+ *  // allocate storage for 100 ints with thrust::malloc
+ *  const int N = 100;
+ *  thrust::device_system_tag device_sys;
+ *  thrust::pointer<int,thrust::device_system_tag> ptr = thrust::malloc<int>(device_sys, N);
+ *
+ *  // manipulate memory
+ *  ...
+ *
+ *  // deallocate ptr with thrust::free
+ *  thrust::free(device_sys, ptr);
+ *  \endcode
+ *
+ *  \see free
+ *  \see device_malloc
+ */
+template <typename T, typename DerivedPolicy>
+_CCCL_HOST_DEVICE pointer<T, DerivedPolicy>
+malloc(const thrust::detail::execution_policy_base<DerivedPolicy>& system, std::size_t n);
+
+/*! \p get_temporary_buffer returns a pointer to storage associated with a given Thrust system sufficient to store up to
+ *  \p n objects of type \c T. If not enough storage is available to accommodate \p n objects, an implementation may
+ * return a smaller buffer. The number of objects the returned buffer can accommodate is also returned.
+ *
+ *  Thrust uses \p get_temporary_buffer internally when allocating temporary storage required by algorithm
+ * implementations.
+ *
+ *  The storage allocated with \p get_temporary_buffer must be returned to the system with \p return_temporary_buffer.
+ *
+ *  \param system The Thrust system with which to associate the storage.
+ *  \param n The requested number of objects of type \c T the storage should accommodate.
+ *  \return A pair \c p such that <tt>p.first</tt> is a pointer to the allocated storage and <tt>p.second</tt> is the
+ * number of contiguous objects of type \c T that the storage can accommodate. If no storage can be allocated,
+ * <tt>p.first</tt> if no storage can be obtained. The storage must be returned to the system using \p
+ * return_temporary_buffer.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *
+ *  \pre \p DerivedPolicy must be publicly derived from <tt>thrust::execution_policy<DerivedPolicy></tt>.
+ *
+ *  The following code snippet demonstrates how to use \p get_temporary_buffer to allocate a range of memory
+ *  to accommodate integers associated with Thrust's device system.
+ *
+ *  \code
+ *  #include <thrust/memory.h>
+ *  ...
+ *  // allocate storage for 100 ints with thrust::get_temporary_buffer
+ *  const int N = 100;
+ *
+ *  using ptr_and_size_t = thrust::pair<
+ *    thrust::pointer<int,thrust::device_system_tag>,
+ *    std::ptrdiff_t
+ *  >;
+ *
+ *  thrust::device_system_tag device_sys;
+ *  ptr_and_size_t ptr_and_size = thrust::get_temporary_buffer<int>(device_sys, N);
+ *
+ *  // manipulate up to 100 ints
+ *  for(int i = 0; i < ptr_and_size.second; ++i)
+ *  {
+ *    *ptr_and_size.first = i;
+ *  }
+ *
+ *  // deallocate storage with thrust::return_temporary_buffer
+ *  thrust::return_temporary_buffer(device_sys, ptr_and_size.first);
+ *  \endcode
+ *
+ *  \see malloc
+ *  \see return_temporary_buffer
+ */
+template <typename T, typename DerivedPolicy>
+_CCCL_HOST_DEVICE
+thrust::pair<thrust::pointer<T, DerivedPolicy>, typename thrust::pointer<T, DerivedPolicy>::difference_type>
+get_temporary_buffer(const thrust::detail::execution_policy_base<DerivedPolicy>& system,
+                     typename thrust::pointer<T, DerivedPolicy>::difference_type n);
+
+/*! \p free deallocates the storage previously allocated by \p thrust::malloc.
+ *
+ *  \param system The Thrust system with which the storage is associated.
+ *  \param ptr A pointer previously returned by \p thrust::malloc. If \p ptr is null, \p free
+ *         does nothing.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *
+ *  \pre \p ptr shall have been returned by a previous call to <tt>thrust::malloc(system, n)</tt> or
+ * <tt>thrust::malloc<T>(system, n)</tt> for some type \c T.
+ *
+ *  The following code snippet demonstrates how to use \p free to deallocate a range of memory
+ *  previously allocated with \p thrust::malloc.
+ *
+ *  \code
+ *  #include <thrust/memory.h>
+ *  ...
+ *  // allocate storage for 100 ints with thrust::malloc
+ *  const int N = 100;
+ *  thrust::device_system_tag device_sys;
+ *  thrust::pointer<int,thrust::device_system_tag> ptr = thrust::malloc<int>(device_sys, N);
+ *
+ *  // mainpulate memory
+ *  ...
+ *
+ *  // deallocate ptr with thrust::free
+ *  thrust::free(device_sys, ptr);
+ *  \endcode
+ */
+template <typename DerivedPolicy, typename Pointer>
+_CCCL_HOST_DEVICE void free(const thrust::detail::execution_policy_base<DerivedPolicy>& system, Pointer ptr);
+
+/*! \p return_temporary_buffer deallocates storage associated with a given Thrust system previously allocated by \p
+ * get_temporary_buffer.
+ *
+ *  Thrust uses \p return_temporary_buffer internally when deallocating temporary storage required by algorithm
+ * implementations.
+ *
+ *  \param system The Thrust system with which the storage is associated.
+ *  \param p A pointer previously returned by \p thrust::get_temporary_buffer. If \p ptr is null, \p
+ * return_temporary_buffer does nothing.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *
+ *  \pre \p p shall have been previously allocated by \p thrust::get_temporary_buffer.
+ *
+ *  The following code snippet demonstrates how to use \p return_temporary_buffer to deallocate a range of memory
+ *  previously allocated by \p get_temporary_buffer.
+ *
+ *  \code
+ *  #include <thrust/memory.h>
+ *  ...
+ *  // allocate storage for 100 ints with thrust::get_temporary_buffer
+ *  const int N = 100;
+ *
+ *  using ptr_and_size_t = thrust::pair<
+ *    thrust::pointer<int,thrust::device_system_tag>,
+ *    std::ptrdiff_t
+ *  >;
+ *
+ *  thrust::device_system_tag device_sys;
+ *  ptr_and_size_t ptr_and_size = thrust::get_temporary_buffer<int>(device_sys, N);
+ *
+ *  // manipulate up to 100 ints
+ *  for(int i = 0; i < ptr_and_size.second; ++i)
+ *  {
+ *    *ptr_and_size.first = i;
+ *  }
+ *
+ *  // deallocate storage with thrust::return_temporary_buffer
+ *  thrust::return_temporary_buffer(device_sys, ptr_and_size.first);
+ *  \endcode
+ *
+ *  \see free
+ *  \see get_temporary_buffer
+ */
+template <typename DerivedPolicy, typename Pointer>
+_CCCL_HOST_DEVICE void return_temporary_buffer(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& system, Pointer p, std::ptrdiff_t n);
+
+/*! \p raw_pointer_cast creates a "raw" pointer from a pointer-like type,
+ *  simply returning the wrapped pointer, should it exist.
+ *
+ *  \param ptr The pointer of interest.
+ *  \return <tt>ptr.get()</tt>, if the expression is well formed; <tt>ptr</tt>, otherwise.
+ *  \see raw_reference_cast
+ */
+template <typename Pointer>
+_CCCL_HOST_DEVICE typename thrust::detail::pointer_traits<Pointer>::raw_pointer raw_pointer_cast(Pointer ptr);
+
+/*! \p raw_reference_cast creates a "raw" reference from a wrapped reference type,
+ *  simply returning the underlying reference, should it exist.
+ *
+ *  If the argument is not a reference wrapper, the result is a reference to the argument.
+ *
+ *  \param ref The reference of interest.
+ *  \return <tt>*thrust::raw_pointer_cast(&ref)</tt>.
+ *  \note There are two versions of \p raw_reference_cast. One for <tt>const</tt> references,
+ *        and one for non-<tt>const</tt>.
+ *  \see raw_pointer_cast
+ */
+template <typename T>
+_CCCL_HOST_DEVICE typename detail::raw_reference<T>::type raw_reference_cast(T& ref);
+
+/*! \p raw_reference_cast creates a "raw" reference from a wrapped reference type,
+ *  simply returning the underlying reference, should it exist.
+ *
+ *  If the argument is not a reference wrapper, the result is a reference to the argument.
+ *
+ *  \param ref The reference of interest.
+ *  \return <tt>*thrust::raw_pointer_cast(&ref)</tt>.
+ *  \note There are two versions of \p raw_reference_cast. One for <tt>const</tt> references,
+ *        and one for non-<tt>const</tt>.
+ *  \see raw_pointer_cast
+ */
+template <typename T>
+_CCCL_HOST_DEVICE typename detail::raw_reference<const T>::type raw_reference_cast(const T& ref);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/merge.h

@@ -0,0 +1,725 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file merge.h
+ *  \brief Merging sorted ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#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 <thrust/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup merging Merging
+ *  \ingroup algorithms
+ *  \{
+ */
+
+/*! \p merge combines two sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>
+ *  into a single sorted range. That is, it copies from <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt> into <tt>[result, result + (last1 - first1) + (last2 - first2))</tt>
+ *  such that the resulting range is in ascending order. \p merge is stable, meaning both that the
+ *  relative order of elements within each input range is preserved, and that for equivalent elements
+ *  in both input ranges the element from the first range precedes the element from the second. The
+ *  return value is <tt>result + (last1 - first1) + (last2 - first2)</tt>.
+ *
+ *  This version of \p merge compares elements using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the merged output.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \p InputIterator1 and \p InputIterator2 have the same \c value_type, \p InputIterator1's \c value_type
+ * is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>, the
+ * ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements, and \p
+ * InputIterator1's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types. \tparam
+ * InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>, the ordering on \p
+ * InputIterator2's \c value_type is a strict weak ordering, as defined in the <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements, and \p
+ * InputIterator2's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types. \tparam
+ * OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to
+ * <tt>operator<</tt>. \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge to compute the merger of two sorted sets of integers using the \p thrust::host execution policy for
+ * parallelization:
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[6] = {1, 3, 5, 7, 9, 11};
+ *  int A2[7] = {1, 1, 2, 3, 5,  8, 13};
+ *
+ *  int result[13];
+ *
+ *  int *result_end =
+ *    thrust::merge(thrust::host,
+ *                  A1, A1 + 6,
+ *                  A2, A2 + 7,
+ *                  result);
+ *  // result = {1, 1, 1, 2, 3, 3, 5, 5, 7, 8, 9, 11, 13}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/merge
+ *  \see \p set_union
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template <typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator merge(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator1 first1,
+  InputIterator1 last1,
+  InputIterator2 first2,
+  InputIterator2 last2,
+  OutputIterator result);
+
+/*! \p merge combines two sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>
+ *  into a single sorted range. That is, it copies from <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt> into <tt>[result, result + (last1 - first1) + (last2 - first2))</tt>
+ *  such that the resulting range is in ascending order. \p merge is stable, meaning both that the
+ *  relative order of elements within each input range is preserved, and that for equivalent elements
+ *  in both input ranges the element from the first range precedes the element from the second. The
+ *  return value is <tt>result + (last1 - first1) + (last2 - first2)</tt>.
+ *
+ *  This version of \p merge compares elements using \c operator<.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the merged output.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \p InputIterator1 and \p InputIterator2 have the same \c value_type, \p InputIterator1's \c value_type
+ * is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>, the
+ * ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements, and \p
+ * InputIterator1's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types. \tparam
+ * InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>, the ordering on \p
+ * InputIterator2's \c value_type is a strict weak ordering, as defined in the <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements, and \p
+ * InputIterator2's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types. \tparam
+ * OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to
+ * <tt>operator<</tt>. \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge to compute the merger of two sorted sets of integers.
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  ...
+ *  int A1[6] = {1, 3, 5, 7, 9, 11};
+ *  int A2[7] = {1, 1, 2, 3, 5,  8, 13};
+ *
+ *  int result[13];
+ *
+ *  int *result_end = thrust::merge(A1, A1 + 6, A2, A2 + 7, result);
+ *  // result = {1, 1, 1, 2, 3, 3, 5, 5, 7, 8, 9, 11, 13}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/merge
+ *  \see \p set_union
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template <typename InputIterator1, typename InputIterator2, typename OutputIterator>
+OutputIterator
+merge(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);
+
+/*! \p merge combines two sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>
+ *  into a single sorted range. That is, it copies from <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt> into <tt>[result, result + (last1 - first1) + (last2 - first2))</tt>
+ *  such that the resulting range is in ascending order. \p merge is stable, meaning both that the
+ *  relative order of elements within each input range is preserved, and that for equivalent elements
+ *  in both input ranges the element from the first range precedes the element from the second. The
+ *  return value is <tt>result + (last1 - first1) + (last2 - first2)</tt>.
+ *
+ *  This version of \p merge compares elements using a function object \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the merged output.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \p InputIterator1's \c value_type is convertible to \p StrictWeakCompare's \c first_argument_type. and
+ * \p InputIterator1's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types. \tparam
+ * InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertible to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. \tparam StrictWeakCompare is a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge to compute the merger of two sets of integers sorted in
+ *  descending order using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[6] = {11, 9, 7, 5, 3, 1};
+ *  int A2[7] = {13, 8, 5, 3, 2, 1, 1};
+ *
+ *  int result[13];
+ *
+ *  int *result_end = thrust::merge(thrust::host,
+ *                                  A1, A1 + 6,
+ *                                  A2, A2 + 7,
+ *                                  result,
+ *                                  thrust::greater<int>());
+ *  // result = {13, 11, 9, 8, 7, 5, 5, 3, 3, 2, 1, 1, 1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/merge
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator,
+          typename StrictWeakCompare>
+_CCCL_HOST_DEVICE OutputIterator merge(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator1 first1,
+  InputIterator1 last1,
+  InputIterator2 first2,
+  InputIterator2 last2,
+  OutputIterator result,
+  StrictWeakCompare comp);
+
+/*! \p merge combines two sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>
+ *  into a single sorted range. That is, it copies from <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt> into <tt>[result, result + (last1 - first1) + (last2 - first2))</tt>
+ *  such that the resulting range is in ascending order. \p merge is stable, meaning both that the
+ *  relative order of elements within each input range is preserved, and that for equivalent elements
+ *  in both input ranges the element from the first range precedes the element from the second. The
+ *  return value is <tt>result + (last1 - first1) + (last2 - first2)</tt>.
+ *
+ *  This version of \p merge compares elements using a function object \p comp.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the merged output.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \p InputIterator1's \c value_type is convertible to \p StrictWeakCompare's \c first_argument_type. and
+ * \p InputIterator1's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types. \tparam
+ * InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertible to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output
+ * Iterator</a>. \tparam StrictWeakCompare is a model of <a
+ * href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge to compute the merger of two sets of integers sorted in
+ *  descending order.
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A1[6] = {11, 9, 7, 5, 3, 1};
+ *  int A2[7] = {13, 8, 5, 3, 2, 1, 1};
+ *
+ *  int result[13];
+ *
+ *  int *result_end = thrust::merge(A1, A1 + 6, A2, A2 + 7, result, thrust::greater<int>());
+ *  // result = {13, 11, 9, 8, 7, 5, 5, 3, 3, 2, 1, 1, 1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/merge
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template <typename InputIterator1, typename InputIterator2, typename OutputIterator, typename StrictWeakCompare>
+OutputIterator
+merge(InputIterator1 first1,
+      InputIterator1 last1,
+      InputIterator2 first2,
+      InputIterator2 last2,
+      OutputIterator result,
+      StrictWeakCompare comp);
+
+/*! \p merge_by_key performs a key-value merge. That is, \p merge_by_key copies elements from
+ *  <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> into a single range,
+ *  <tt>[keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending key order.
+ *
+ *  At the same time, \p merge_by_key copies elements from the two associated ranges <tt>[values_first1 + (keys_last1 -
+ * keys_first1))</tt> and <tt>[values_first2 + (keys_last2 - keys_first2))</tt> into a single range, <tt>[values_result,
+ * values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that the resulting range is in
+ * ascending order implied by each input element's associated key.
+ *
+ *  \p merge_by_key is stable, meaning both that the relative order of elements within each input range is
+ *  preserved, and that for equivalent elements in all input key ranges the element from the first range
+ *  precedes the element from the second.
+ *
+ *  The return value is is <tt>(keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>
+ *  and <tt>(values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the merged output range of keys.
+ *  \param values_result The beginning of the merged output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \p InputIterator1 and \p InputIterator2 have the same \c value_type, \p InputIterator1's \c value_type
+ * is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>, the
+ * ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements, and \p
+ * InputIterator1's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types. \tparam
+ * InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>, the ordering on \p
+ * InputIterator2's \c value_type is a strict weak ordering, as defined in the <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements, and \p
+ * InputIterator2's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types. \tparam
+ * InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c
+ * value_types. \tparam InputIterator4 is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>, and \p InputIterator4's \c
+ * value_type is convertible to a type in \p OutputIterator2's set of \c value_types. \tparam OutputIterator1 is a model
+ * of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. \tparam OutputIterator2
+ * is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with
+ * respect to <tt>operator<</tt>. \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge_by_key to compute the merger of two sets of integers sorted in
+ *  ascending order using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {1, 3, 5, 7, 9, 11};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[7] = {1, 1, 2, 3, 5, 8, 13};
+ *  int B_vals[7] = {1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int keys_result[13];
+ *  int vals_result[13];
+ *
+ *  thrust::pair<int*,int*> end =
+ *    thrust::merge_by_key(thrust::host,
+ *                         A_keys, A_keys + 6,
+ *                         B_keys, B_keys + 7,
+ *                         A_vals, B_vals,
+ *                         keys_result, vals_result);
+ *
+ *  // keys_result = {1, 1, 1, 2, 3, 3, 5, 5, 7, 8, 9, 11, 13}
+ *  // vals_result = {0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,  0,  1}
+ *  \endcode
+ *
+ *  \see merge
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename InputIterator3,
+          typename InputIterator4,
+          typename OutputIterator1,
+          typename OutputIterator2>
+_CCCL_HOST_DEVICE thrust::pair<OutputIterator1, OutputIterator2> merge_by_key(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator1 keys_first1,
+  InputIterator1 keys_last1,
+  InputIterator2 keys_first2,
+  InputIterator2 keys_last2,
+  InputIterator3 values_first1,
+  InputIterator4 values_first2,
+  OutputIterator1 keys_result,
+  OutputIterator2 values_result);
+
+/*! \p merge_by_key performs a key-value merge. That is, \p merge_by_key copies elements from
+ *  <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> into a single range,
+ *  <tt>[keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending key order.
+ *
+ *  At the same time, \p merge_by_key copies elements from the two associated ranges <tt>[values_first1 + (keys_last1 -
+ * keys_first1))</tt> and <tt>[values_first2 + (keys_last2 - keys_first2))</tt> into a single range, <tt>[values_result,
+ * values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that the resulting range is in
+ * ascending order implied by each input element's associated key.
+ *
+ *  \p merge_by_key is stable, meaning both that the relative order of elements within each input range is
+ *  preserved, and that for equivalent elements in all input key ranges the element from the first range
+ *  precedes the element from the second.
+ *
+ *  The return value is is <tt>(keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>
+ *  and <tt>(values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the merged output range of keys.
+ *  \param values_result The beginning of the merged output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \p InputIterator1 and \p InputIterator2 have the same \c value_type, \p InputIterator1's \c value_type
+ * is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>, the
+ * ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements, and \p
+ * InputIterator1's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types. \tparam
+ * InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>, the ordering on \p
+ * InputIterator2's \c value_type is a strict weak ordering, as defined in the <a
+ * href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements, and \p
+ * InputIterator2's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types. \tparam
+ * InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c
+ * value_types. \tparam InputIterator4 is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>, and \p InputIterator4's \c
+ * value_type is convertible to a type in \p OutputIterator2's set of \c value_types. \tparam OutputIterator1 is a model
+ * of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. \tparam OutputIterator2
+ * is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with
+ * respect to <tt>operator<</tt>. \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge_by_key to compute the merger of two sets of integers sorted in
+ *  ascending order.
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A_keys[6] = {1, 3, 5, 7, 9, 11};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[7] = {1, 1, 2, 3, 5, 8, 13};
+ *  int B_vals[7] = {1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int keys_result[13];
+ *  int vals_result[13];
+ *
+ *  thrust::pair<int*,int*> end = thrust::merge_by_key(A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, B_vals,
+ * keys_result, vals_result);
+ *
+ *  // keys_result = {1, 1, 1, 2, 3, 3, 5, 5, 7, 8, 9, 11, 13}
+ *  // vals_result = {0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,  0,  1}
+ *  \endcode
+ *
+ *  \see merge
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template <typename InputIterator1,
+          typename InputIterator2,
+          typename InputIterator3,
+          typename InputIterator4,
+          typename OutputIterator1,
+          typename OutputIterator2>
+thrust::pair<OutputIterator1, OutputIterator2> merge_by_key(
+  InputIterator1 keys_first1,
+  InputIterator1 keys_last1,
+  InputIterator2 keys_first2,
+  InputIterator2 keys_last2,
+  InputIterator3 values_first1,
+  InputIterator4 values_first2,
+  OutputIterator1 keys_result,
+  OutputIterator2 values_result);
+
+/*! \p merge_by_key performs a key-value merge. That is, \p merge_by_key copies elements from
+ *  <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> into a single range,
+ *  <tt>[keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending key order.
+ *
+ *  At the same time, \p merge_by_key copies elements from the two associated ranges <tt>[values_first1 + (keys_last1 -
+ * keys_first1))</tt> and <tt>[values_first2 + (keys_last2 - keys_first2))</tt> into a single range, <tt>[values_result,
+ * values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that the resulting range is in
+ * ascending order implied by each input element's associated key.
+ *
+ *  \p merge_by_key is stable, meaning both that the relative order of elements within each input range is
+ *  preserved, and that for equivalent elements in all input key ranges the element from the first range
+ *  precedes the element from the second.
+ *
+ *  The return value is is <tt>(keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>
+ *  and <tt>(values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>.
+ *
+ *  This version of \p merge_by_key compares key elements using a function object \p comp.
+ *
+ *  The algorithm's execution is parallelized using \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the merged output range of keys.
+ *  \param values_result The beginning of the merged output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \p InputIterator1's \c value_type is convertible to \p StrictWeakCompare's \c first_argument_type. and
+ * \p InputIterator1's \c value_type is convertible to a type in \p OutputIterator1's set of \c value_types. \tparam
+ * InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertible to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertible to a type in \p OutputIterator1's set of \c
+ * value_types. \tparam InputIterator3 is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>, and \p InputIterator3's \c
+ * value_type is convertible to a type in \p OutputIterator2's set of \c value_types. \tparam InputIterator4 is a model
+ * of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>, and \p InputIterator4's \c
+ * value_type is convertible to a type in \p OutputIterator2's set of \c value_types. \tparam OutputIterator1 is a model
+ * of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. \tparam OutputIterator2
+ * is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. \tparam
+ * StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak
+ * Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with
+ * respect to \p comp. \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge_by_key to compute the merger of two sets of integers sorted in
+ *  descending order using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {11, 9, 7, 5, 3, 1};
+ *  int A_vals[6] = { 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[7] = {13, 8, 5, 3, 2, 1, 1};
+ *  int B_vals[7] = { 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int keys_result[13];
+ *  int vals_result[13];
+ *
+ *  thrust::pair<int*,int*> end =
+ *    thrust::merge_by_key(thrust::host,
+ *                         A_keys, A_keys + 6,
+ *                         B_keys, B_keys + 7,
+ *                         A_vals, B_vals,
+ *                         keys_result, vals_result,
+ *                         thrust::greater<int>());
+ *
+ *  // keys_result = {13, 11, 9, 8, 7, 5, 5, 3, 3, 2, 1, 1, 1}
+ *  // vals_result = { 1,  0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1}
+ *  \endcode
+ *
+ *  \see merge
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename InputIterator3,
+          typename InputIterator4,
+          typename OutputIterator1,
+          typename OutputIterator2,
+          typename Compare>
+_CCCL_HOST_DEVICE thrust::pair<OutputIterator1, OutputIterator2> merge_by_key(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator1 keys_first1,
+  InputIterator1 keys_last1,
+  InputIterator2 keys_first2,
+  InputIterator2 keys_last2,
+  InputIterator3 values_first1,
+  InputIterator4 values_first2,
+  OutputIterator1 keys_result,
+  OutputIterator2 values_result,
+  Compare comp);
+
+/*! \p merge_by_key performs a key-value merge. That is, \p merge_by_key copies elements from
+ *  <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> into a single range,
+ *  <tt>[keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending key order.
+ *
+ *  At the same time, \p merge_by_key copies elements from the two associated ranges <tt>[values_first1 + (keys_last1 -
+ * keys_first1))</tt> and <tt>[values_first2 + (keys_last2 - keys_first2))</tt> into a single range, <tt>[values_result,
+ * values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that the resulting range is in
+ * ascending order implied by each input element's associated key.
+ *
+ *  \p merge_by_key is stable, meaning both that the relative order of elements within each input range is
+ *  preserved, and that for equivalent elements in all input key ranges the element from the first range
+ *  precedes the element from the second.
+ *
+ *  The return value is is <tt>(keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>
+ *  and <tt>(values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>.
+ *
+ *  This version of \p merge_by_key compares key elements using a function object \p comp.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the merged output range of keys.
+ *  \param values_result The beginning of the merged output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input
+ * Iterator</a>, \p InputIterator1's \c value_type is convertible to \p StrictWeakCompare's \c first_argument_type. and
+ * \p InputIterator1's \c value_type is convertible to a type in \p OutputIterator1's set of \c value_types. \tparam
+ * InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertible to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertible to a type in \p OutputIterator1's set of \c
+ * value_types. \tparam InputIterator3 is a model of <a
+ * href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>, and \p InputIterator3's \c
+ * value_type is convertible to a type in \p OutputIterator2's set of \c value_types. \tparam InputIterator4 is a model
+ * of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>, and \p InputIterator4's \c
+ * value_type is convertible to a type in \p OutputIterator2's set of \c value_types. \tparam OutputIterator1 is a model
+ * of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. \tparam OutputIterator2
+ * is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>. \tparam
+ * StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak
+ * Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with
+ * respect to \p comp. \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge_by_key to compute the merger of two sets of integers sorted in
+ *  descending order.
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A_keys[6] = {11, 9, 7, 5, 3, 1};
+ *  int A_vals[6] = { 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[7] = {13, 8, 5, 3, 2, 1, 1};
+ *  int B_vals[7] = { 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int keys_result[13];
+ *  int vals_result[13];
+ *
+ *  thrust::pair<int*,int*> end = thrust::merge_by_key(A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, B_vals,
+ * keys_result, vals_result, thrust::greater<int>());
+ *
+ *  // keys_result = {13, 11, 9, 8, 7, 5, 5, 3, 3, 2, 1, 1, 1}
+ *  // vals_result = { 1,  0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1}
+ *  \endcode
+ *
+ *  \see merge
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template <typename InputIterator1,
+          typename InputIterator2,
+          typename InputIterator3,
+          typename InputIterator4,
+          typename OutputIterator1,
+          typename OutputIterator2,
+          typename StrictWeakCompare>
+thrust::pair<OutputIterator1, OutputIterator2> merge_by_key(
+  InputIterator1 keys_first1,
+  InputIterator1 keys_last1,
+  InputIterator2 keys_first2,
+  InputIterator2 keys_last2,
+  InputIterator3 values_first1,
+  InputIterator4 values_first2,
+  OutputIterator1 keys_result,
+  OutputIterator2 values_result,
+  StrictWeakCompare comp);
+
+/*! \} // merging
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/merge.inl>