Add files using upload-large-folder tool

.gitattributes

@@ -1769,3 +1769,4 @@ vllm/lib/python3.10/site-packages/cupy/_core/flags.cpython-310-x86_64-linux-gnu.
 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.a filter=lfs diff=lfs merge=lfs -text

vllm/lib/libcrypto.a

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

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

@@ -0,0 +1,37 @@
+/*
+ *  Copyright 2020 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.
+ */
+
+#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
+
+// When a compiler uses Thrust as part of its implementation of Standard C++
+// algorithms, a cycle of included files may result when Thrust code tries to
+// use a standard algorithm.  Having a macro that is defined only when Thrust
+// is including an algorithms-related header gives the compiler a chance to
+// detect and break the cycle of includes.
+
+#define THRUST_INCLUDING_ALGORITHMS_HEADER
+#include <algorithm>
+#undef THRUST_INCLUDING_ALGORITHMS_HEADER

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/allocator_traits.h

@@ -0,0 +1,350 @@
+/*
+ *  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.
+ */
+
+// allocator_traits::rebind_alloc and allocator::rebind_traits are from libc++,
+// dual licensed under the MIT and the University of Illinois Open Source
+// Licenses.
+
+#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/memory_wrapper.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/has_member_function.h>
+#include <thrust/detail/type_traits/has_nested_type.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+// forward declaration for has_member_system
+template <typename Alloc>
+struct allocator_system;
+
+namespace allocator_traits_detail
+{
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_value_type, value_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_pointer, pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_pointer, const_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_reference, reference)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_reference, const_reference)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_void_pointer, void_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_void_pointer, const_void_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_difference_type, difference_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_size_type, size_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_copy_assignment, propagate_on_container_copy_assignment)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_move_assignment, propagate_on_container_move_assignment)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_swap, propagate_on_container_swap)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_system_type, system_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_is_always_equal, is_always_equal)
+__THRUST_DEFINE_HAS_MEMBER_FUNCTION(has_member_system_impl, system)
+
+template <typename Alloc, typename U>
+struct has_rebind
+{
+  using yes_type = char;
+  using no_type  = int;
+
+  template <typename S>
+  static yes_type test(typename S::template rebind<U>::other*);
+  template <typename S>
+  static no_type test(...);
+
+  static bool const value = sizeof(test<U>(0)) == sizeof(yes_type);
+
+  using type = thrust::detail::integral_constant<bool, value>;
+};
+
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+
+// The following fields of std::allocator have been deprecated (since C++17).
+// There's no way to detect it other than explicit specialization.
+#if _CCCL_STD_VER >= 2017
+#  define THRUST_SPECIALIZE_DEPRECATED(trait_name)    \
+    template <typename T>                             \
+    struct trait_name<std::allocator<T>> : false_type \
+    {};
+
+THRUST_SPECIALIZE_DEPRECATED(has_is_always_equal)
+THRUST_SPECIALIZE_DEPRECATED(has_pointer)
+THRUST_SPECIALIZE_DEPRECATED(has_const_pointer)
+THRUST_SPECIALIZE_DEPRECATED(has_reference)
+THRUST_SPECIALIZE_DEPRECATED(has_const_reference)
+
+#  undef THRUST_SPECIALIZE_DEPRECATED
+
+template <typename T, typename U>
+struct has_rebind<std::allocator<T>, U> : false_type
+{};
+#endif
+
+template <typename T>
+struct nested_pointer
+{
+  using type = typename T::pointer;
+};
+
+template <typename T>
+struct nested_const_pointer
+{
+  using type = typename T::const_pointer;
+};
+
+template <typename T>
+struct nested_reference
+{
+  using type = typename T::reference;
+};
+
+template <typename T>
+struct nested_const_reference
+{
+  using type = typename T::const_reference;
+};
+
+template <typename T>
+struct nested_void_pointer
+{
+  using type = typename T::void_pointer;
+};
+
+template <typename T>
+struct nested_const_void_pointer
+{
+  using type = typename T::const_void_pointer;
+};
+
+template <typename T>
+struct nested_difference_type
+{
+  using type = typename T::difference_type;
+};
+
+template <typename T>
+struct nested_size_type
+{
+  using type = typename T::size_type;
+};
+
+template <typename T>
+struct nested_propagate_on_container_copy_assignment
+{
+  using type = typename T::propagate_on_container_copy_assignment;
+};
+
+template <typename T>
+struct nested_propagate_on_container_move_assignment
+{
+  using type = typename T::propagate_on_container_move_assignment;
+};
+
+template <typename T>
+struct nested_propagate_on_container_swap
+{
+  using type = typename T::propagate_on_container_swap;
+};
+
+template <typename T>
+struct nested_is_always_equal
+{
+  using type = typename T::is_always_equal;
+};
+
+template <typename T>
+struct nested_system_type
+{
+  using type = typename T::system_type;
+};
+
+template <typename Alloc>
+struct has_member_system
+{
+  using system_type = typename allocator_system<Alloc>::type;
+
+  using type              = typename has_member_system_impl<Alloc, system_type&()>::type;
+  static const bool value = type::value;
+};
+
+_CCCL_SUPPRESS_DEPRECATED_POP
+
+template <class Alloc, class U, bool = has_rebind<Alloc, U>::value>
+struct rebind_alloc
+{
+  using type = typename Alloc::template rebind<U>::other;
+};
+
+template <template <typename, typename...> class Alloc, typename T, typename... Args, typename U>
+struct rebind_alloc<Alloc<T, Args...>, U, true>
+{
+  using type = typename Alloc<T, Args...>::template rebind<U>::other;
+};
+
+template <template <typename, typename...> class Alloc, typename T, typename... Args, typename U>
+struct rebind_alloc<Alloc<T, Args...>, U, false>
+{
+  using type = Alloc<U, Args...>;
+};
+
+} // namespace allocator_traits_detail
+
+template <typename Alloc>
+struct allocator_traits
+{
+  using allocator_type = Alloc;
+
+  using value_type = typename allocator_type::value_type;
+
+  using pointer = typename eval_if<allocator_traits_detail::has_pointer<allocator_type>::value,
+                                   allocator_traits_detail::nested_pointer<allocator_type>,
+                                   identity_<value_type*>>::type;
+
+private:
+  template <typename T>
+  struct rebind_pointer
+  {
+    using type = typename pointer_traits<pointer>::template rebind<T>::other;
+  };
+
+public:
+  using const_pointer =
+    typename eval_if<allocator_traits_detail::has_const_pointer<allocator_type>::value,
+                     allocator_traits_detail::nested_const_pointer<allocator_type>,
+                     rebind_pointer<const value_type>>::type;
+
+  using void_pointer =
+    typename eval_if<allocator_traits_detail::has_void_pointer<allocator_type>::value,
+                     allocator_traits_detail::nested_void_pointer<allocator_type>,
+                     rebind_pointer<void>>::type;
+
+  using const_void_pointer =
+    typename eval_if<allocator_traits_detail::has_const_void_pointer<allocator_type>::value,
+                     allocator_traits_detail::nested_const_void_pointer<allocator_type>,
+                     rebind_pointer<const void>>::type;
+
+  using difference_type =
+    typename eval_if<allocator_traits_detail::has_difference_type<allocator_type>::value,
+                     allocator_traits_detail::nested_difference_type<allocator_type>,
+                     pointer_difference<pointer>>::type;
+
+  using size_type = typename eval_if<allocator_traits_detail::has_size_type<allocator_type>::value,
+                                     allocator_traits_detail::nested_size_type<allocator_type>,
+                                     ::cuda::std::make_unsigned<difference_type>>::type;
+
+  using propagate_on_container_copy_assignment =
+    typename eval_if<allocator_traits_detail::has_propagate_on_container_copy_assignment<allocator_type>::value,
+                     allocator_traits_detail::nested_propagate_on_container_copy_assignment<allocator_type>,
+                     identity_<false_type>>::type;
+
+  using propagate_on_container_move_assignment =
+    typename eval_if<allocator_traits_detail::has_propagate_on_container_move_assignment<allocator_type>::value,
+                     allocator_traits_detail::nested_propagate_on_container_move_assignment<allocator_type>,
+                     identity_<false_type>>::type;
+
+  using propagate_on_container_swap =
+    typename eval_if<allocator_traits_detail::has_propagate_on_container_swap<allocator_type>::value,
+                     allocator_traits_detail::nested_propagate_on_container_swap<allocator_type>,
+                     identity_<false_type>>::type;
+
+  using is_always_equal =
+    typename eval_if<allocator_traits_detail::has_is_always_equal<allocator_type>::value,
+                     allocator_traits_detail::nested_is_always_equal<allocator_type>,
+                     ::cuda::std::is_empty<allocator_type>>::type;
+
+  using system_type =
+    typename eval_if<allocator_traits_detail::has_system_type<allocator_type>::value,
+                     allocator_traits_detail::nested_system_type<allocator_type>,
+                     thrust::iterator_system<pointer>>::type;
+
+  // XXX rebind and rebind_traits are alias templates
+  //     and so are omitted while c++11 is unavailable
+
+  template <typename U>
+  using rebind_alloc = typename allocator_traits_detail::rebind_alloc<allocator_type, U>::type;
+
+  template <typename U>
+  using rebind_traits = allocator_traits<rebind_alloc<U>>;
+
+  // We define this nested type alias for compatibility with the C++03-style
+  // rebind_* mechanisms.
+  using other = allocator_traits;
+
+  // Deprecated std::allocator aliases that we need:
+  using reference       = typename thrust::detail::pointer_traits<pointer>::reference;
+  using const_reference = typename thrust::detail::pointer_traits<const_pointer>::reference;
+
+  inline _CCCL_HOST_DEVICE static pointer allocate(allocator_type& a, size_type n);
+
+  inline _CCCL_HOST_DEVICE static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint);
+
+  inline _CCCL_HOST_DEVICE static void deallocate(allocator_type& a, pointer p, size_type n) noexcept;
+
+  // XXX should probably change T* to pointer below and then relax later
+
+  template <typename T>
+  inline _CCCL_HOST_DEVICE static void construct(allocator_type& a, T* p);
+
+  template <typename T, typename Arg1>
+  inline _CCCL_HOST_DEVICE static void construct(allocator_type& a, T* p, const Arg1& arg1);
+
+  template <typename T, typename... Args>
+  inline _CCCL_HOST_DEVICE static void construct(allocator_type& a, T* p, Args&&... args);
+
+  template <typename T>
+  inline _CCCL_HOST_DEVICE static void destroy(allocator_type& a, T* p) noexcept;
+
+  inline _CCCL_HOST_DEVICE static size_type max_size(const allocator_type& a);
+}; // end allocator_traits
+
+// we consider a type an allocator if T::value_type exists
+// it doesn't make much sense (containers, which are not allocators, will fulfill this requirement),
+// but allocator_traits is specified to work for any type with that nested alias
+template <typename T>
+struct is_allocator : allocator_traits_detail::has_value_type<T>
+{};
+
+// XXX consider moving this non-standard functionality inside allocator_traits
+template <typename Alloc>
+struct allocator_system
+{
+  // the type of the allocator's system
+  using type = typename eval_if<allocator_traits_detail::has_system_type<Alloc>::value,
+                                allocator_traits_detail::nested_system_type<Alloc>,
+                                thrust::iterator_system<typename allocator_traits<Alloc>::pointer>>::type;
+
+  // the type that get returns
+  using get_result_type =
+    typename eval_if<allocator_traits_detail::has_member_system<Alloc>::value,
+                     ::cuda::std::add_lvalue_reference<type>,
+                     identity_<type>>::type;
+
+  _CCCL_HOST_DEVICE inline static get_result_type get(Alloc& a);
+};
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/allocator_traits.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/allocator_traits.inl

@@ -0,0 +1,370 @@
+/*
+ *  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.
+ */
+
+#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/integer_traits.h>
+#include <thrust/detail/memory_wrapper.h>
+#include <thrust/detail/type_deduction.h>
+#include <thrust/detail/type_traits/is_call_possible.h>
+
+#include <new>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+// std::allocator's member functions are deprecated in C++17 and removed in
+// C++20, so we can't just use the generic implementation for allocator_traits
+// that calls the allocator's member functions.
+// Instead, specialize allocator_traits for std::allocator and defer to
+// std::allocator_traits<std::allocator> and let the STL do whatever it needs
+// to for the current c++ version. Manually forward the calls to suppress
+// host/device warnings.
+template <typename T>
+struct allocator_traits<std::allocator<T>> : public std::allocator_traits<std::allocator<T>>
+{
+private:
+  using superclass = std::allocator_traits<std::allocator<T>>;
+
+public:
+  using allocator_type                         = typename superclass::allocator_type;
+  using value_type                             = typename superclass::value_type;
+  using pointer                                = typename superclass::pointer;
+  using const_pointer                          = typename superclass::const_pointer;
+  using void_pointer                           = typename superclass::void_pointer;
+  using const_void_pointer                     = typename superclass::const_void_pointer;
+  using difference_type                        = typename superclass::difference_type;
+  using size_type                              = typename superclass::size_type;
+  using propagate_on_container_swap            = typename superclass::propagate_on_container_swap;
+  using propagate_on_container_copy_assignment = typename superclass::propagate_on_container_copy_assignment;
+  using propagate_on_container_move_assignment = typename superclass::propagate_on_container_move_assignment;
+
+  // std::allocator_traits added this in C++17, but thrust::allocator_traits defines
+  // it unconditionally.
+  using is_always_equal =
+    typename eval_if<allocator_traits_detail::has_is_always_equal<allocator_type>::value,
+                     allocator_traits_detail::nested_is_always_equal<allocator_type>,
+                     ::cuda::std::is_empty<allocator_type>>::type;
+
+  // std::allocator_traits doesn't provide these, but
+  // thrust::detail::allocator_traits does. These used to be part of the
+  // std::allocator API but were deprecated in C++17.
+  using reference       = typename thrust::detail::pointer_traits<pointer>::reference;
+  using const_reference = typename thrust::detail::pointer_traits<const_pointer>::reference;
+
+  template <typename U>
+  using rebind_alloc = std::allocator<U>;
+  template <typename U>
+  using rebind_traits = allocator_traits<std::allocator<U>>;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE static pointer allocate(allocator_type& a, size_type n)
+  {
+    return superclass::allocate(a, n);
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint)
+  {
+    return superclass::allocate(a, n, hint);
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE static void deallocate(allocator_type& a, pointer p, size_type n) noexcept
+  {
+    superclass::deallocate(a, p, n);
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename U, typename... Args>
+  _CCCL_HOST_DEVICE static void construct(allocator_type& a, U* p, Args&&... args)
+  {
+    superclass::construct(a, p, THRUST_FWD(args)...);
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename U>
+  _CCCL_HOST_DEVICE static void destroy(allocator_type& a, U* p) noexcept
+  {
+    superclass::destroy(a, p);
+  }
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_HOST_DEVICE static size_type max_size(const allocator_type& a)
+  {
+    return superclass::max_size(a);
+  }
+};
+
+namespace allocator_traits_detail
+{
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_allocate_with_hint_impl, allocate)
+
+template <typename Alloc>
+class has_member_allocate_with_hint
+{
+  using pointer            = typename allocator_traits<Alloc>::pointer;
+  using size_type          = typename allocator_traits<Alloc>::size_type;
+  using const_void_pointer = typename allocator_traits<Alloc>::const_void_pointer;
+
+public:
+  using type = typename has_member_allocate_with_hint_impl<Alloc, pointer(size_type, const_void_pointer)>::type;
+  static const bool value = type::value;
+};
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_allocate_with_hint<Alloc>::value,
+                                           typename allocator_traits<Alloc>::pointer>
+allocate(Alloc& a,
+         typename allocator_traits<Alloc>::size_type n,
+         typename allocator_traits<Alloc>::const_void_pointer hint)
+{
+  return a.allocate(n, hint);
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_allocate_with_hint<Alloc>::value,
+                                           typename allocator_traits<Alloc>::pointer>
+allocate(Alloc& a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer)
+{
+  return a.allocate(n);
+}
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct1_impl, construct)
+
+template <typename Alloc, typename T>
+struct has_member_construct1 : has_member_construct1_impl<Alloc, void(T*)>
+{};
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_construct1<Alloc, T>::value> construct(Alloc& a, T* p)
+{
+  a.construct(p);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_construct1<Alloc, T>::value> construct(Alloc&, T* p)
+{
+  ::new (static_cast<void*>(p)) T();
+}
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct2_impl, construct)
+
+template <typename Alloc, typename T, typename Arg1>
+struct has_member_construct2 : has_member_construct2_impl<Alloc, void(T*, const Arg1&)>
+{};
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T, typename Arg1>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_construct2<Alloc, T, Arg1>::value>
+construct(Alloc& a, T* p, const Arg1& arg1)
+{
+  a.construct(p, arg1);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T, typename Arg1>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_construct2<Alloc, T, Arg1>::value>
+construct(Alloc&, T* p, const Arg1& arg1)
+{
+  ::new (static_cast<void*>(p)) T(arg1);
+}
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_constructN_impl, construct)
+
+template <typename Alloc, typename T, typename... Args>
+struct has_member_constructN : has_member_constructN_impl<Alloc, void(T*, Args...)>
+{};
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T, typename... Args>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_constructN<Alloc, T, Args...>::value>
+construct(Alloc& a, T* p, Args&&... args)
+{
+  a.construct(p, THRUST_FWD(args)...);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T, typename... Args>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_constructN<Alloc, T, Args...>::value>
+construct(Alloc&, T* p, Args&&... args)
+{
+  ::new (static_cast<void*>(p)) T(THRUST_FWD(args)...);
+}
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_destroy_impl, destroy)
+
+template <typename Alloc, typename T>
+struct has_member_destroy : has_member_destroy_impl<Alloc, void(T*)>
+{};
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_destroy<Alloc, T>::value> destroy(Alloc& a, T* p)
+{
+  a.destroy(p);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename Alloc, typename T>
+inline _CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_destroy<Alloc, T>::value> destroy(Alloc&, T* p)
+{
+  p->~T();
+}
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_max_size_impl, max_size)
+
+template <typename Alloc>
+class has_member_max_size
+{
+  using size_type = typename allocator_traits<Alloc>::size_type;
+
+public:
+  using type              = typename has_member_max_size_impl<Alloc, size_type()>::type;
+  static const bool value = type::value;
+};
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_max_size<Alloc>::value, typename allocator_traits<Alloc>::size_type>
+max_size(const Alloc& a)
+{
+  return a.max_size();
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_max_size<Alloc>::value,
+                                           typename allocator_traits<Alloc>::size_type>
+max_size(const Alloc&)
+{
+  using size_type = typename allocator_traits<Alloc>::size_type;
+  return thrust::detail::integer_traits<size_type>::const_max;
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<has_member_system<Alloc>::value, typename allocator_system<Alloc>::type&>
+system(Alloc& a)
+{
+  // return the allocator's system
+  return a.system();
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<!has_member_system<Alloc>::value, typename allocator_system<Alloc>::type>
+system(Alloc&)
+{
+  // return a copy of a value-initialized system
+  return typename allocator_system<Alloc>::type();
+}
+
+} // namespace allocator_traits_detail
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE typename allocator_traits<Alloc>::pointer
+allocator_traits<Alloc>::allocate(Alloc& a, typename allocator_traits<Alloc>::size_type n)
+{
+  struct workaround_warnings
+  {
+    _CCCL_EXEC_CHECK_DISABLE
+    static _CCCL_HOST_DEVICE typename allocator_traits<Alloc>::pointer
+    allocate(Alloc& a, typename allocator_traits<Alloc>::size_type n)
+    {
+      return a.allocate(n);
+    }
+  };
+
+  return workaround_warnings::allocate(a, n);
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE typename allocator_traits<Alloc>::pointer allocator_traits<Alloc>::allocate(
+  Alloc& a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint)
+{
+  return allocator_traits_detail::allocate(a, n, hint);
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE void allocator_traits<Alloc>::deallocate(
+  Alloc& a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n) noexcept
+{
+  struct workaround_warnings
+  {
+    _CCCL_EXEC_CHECK_DISABLE
+    static _CCCL_HOST_DEVICE void deallocate(
+      Alloc& a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n) noexcept
+    {
+      return a.deallocate(p, n);
+    }
+  };
+
+  return workaround_warnings::deallocate(a, p, n);
+}
+
+template <typename Alloc>
+template <typename T>
+_CCCL_HOST_DEVICE void allocator_traits<Alloc>::construct(allocator_type& a, T* p)
+{
+  return allocator_traits_detail::construct(a, p);
+}
+
+template <typename Alloc>
+template <typename T, typename Arg1>
+_CCCL_HOST_DEVICE void allocator_traits<Alloc>::construct(allocator_type& a, T* p, const Arg1& arg1)
+{
+  return allocator_traits_detail::construct(a, p, arg1);
+}
+
+template <typename Alloc>
+template <typename T, typename... Args>
+_CCCL_HOST_DEVICE void allocator_traits<Alloc>::construct(allocator_type& a, T* p, Args&&... args)
+{
+  return allocator_traits_detail::construct(a, p, THRUST_FWD(args)...);
+}
+
+template <typename Alloc>
+template <typename T>
+_CCCL_HOST_DEVICE void allocator_traits<Alloc>::destroy(allocator_type& a, T* p) noexcept
+{
+  return allocator_traits_detail::destroy(a, p);
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE typename allocator_traits<Alloc>::size_type allocator_traits<Alloc>::max_size(const allocator_type& a)
+{
+  return allocator_traits_detail::max_size(a);
+}
+
+template <typename Alloc>
+_CCCL_HOST_DEVICE typename allocator_system<Alloc>::get_result_type allocator_system<Alloc>::get(Alloc& a)
+{
+  return allocator_traits_detail::system(a);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/copy_construct_range.h

@@ -0,0 +1,45 @@
+/*
+ *  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.
+ */
+
+#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
+namespace detail
+{
+
+template <typename System, typename Allocator, typename InputIterator, typename Pointer>
+_CCCL_HOST_DEVICE Pointer copy_construct_range(
+  thrust::execution_policy<System>& from_system, Allocator& a, InputIterator first, InputIterator last, Pointer result);
+
+template <typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+_CCCL_HOST_DEVICE Pointer copy_construct_range_n(
+  thrust::execution_policy<System>& from_system, Allocator& a, InputIterator first, Size n, Pointer result);
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/copy_construct_range.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/copy_construct_range.inl

@@ -0,0 +1,242 @@
+/*
+ *  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.
+ */
+
+#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/advance.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/copy.h>
+#include <thrust/detail/memory_wrapper.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/distance.h>
+#include <thrust/for_each.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/tuple.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+template <typename Allocator, typename InputType, typename OutputType>
+struct copy_construct_with_allocator
+{
+  Allocator& a;
+
+  _CCCL_HOST_DEVICE copy_construct_with_allocator(Allocator& a)
+      : a(a)
+  {}
+
+  template <typename Tuple>
+  inline _CCCL_HOST_DEVICE void operator()(Tuple t)
+  {
+    const InputType& in = thrust::get<0>(t);
+    OutputType& out     = thrust::get<1>(t);
+
+    allocator_traits<Allocator>::construct(a, &out, in);
+  }
+};
+
+// we need to use allocator_traits<Allocator>::construct() to
+// copy construct a T if either:
+// 1. Allocator has a 2-argument construct() member or
+// 2. T has a non-trivial copy constructor
+template <typename Allocator, typename T>
+struct needs_copy_construct_via_allocator
+    : integral_constant<bool,
+                        (has_member_construct2<Allocator, T, T>::value
+                         || !::cuda::std::is_trivially_copy_constructible<T>::value)>
+{};
+
+// we know that std::allocator::construct's only effect is to call T's
+// copy constructor, so we needn't consider or use its construct() member for copy construction
+template <typename U, typename T>
+struct needs_copy_construct_via_allocator<std::allocator<U>, T>
+    : integral_constant<bool, !::cuda::std::is_trivially_copy_constructible<T>::value>
+{};
+
+// XXX it's regrettable that this implementation is copied almost
+//     exactly from system::detail::generic::uninitialized_copy
+//     perhaps generic::uninitialized_copy could call this routine
+//     with a default allocator
+template <typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
+_CCCL_HOST_DEVICE enable_if_convertible_t<FromSystem, ToSystem, Pointer> uninitialized_copy_with_allocator(
+  Allocator& a,
+  const thrust::execution_policy<FromSystem>&,
+  const thrust::execution_policy<ToSystem>& to_system,
+  InputIterator first,
+  InputIterator last,
+  Pointer result)
+{
+  // zip up the iterators
+  using IteratorTuple = thrust::tuple<InputIterator, Pointer>;
+  using ZipIterator   = thrust::zip_iterator<IteratorTuple>;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first, result));
+  ZipIterator end   = begin;
+
+  // get a zip_iterator pointing to the end
+  const typename thrust::iterator_difference<InputIterator>::type n = thrust::distance(first, last);
+  thrust::advance(end, n);
+
+  // create a functor
+  using InputType  = typename iterator_traits<InputIterator>::value_type;
+  using OutputType = typename iterator_traits<Pointer>::value_type;
+
+  // do the for_each
+  // note we use to_system to dispatch the for_each
+  thrust::for_each(to_system, begin, end, copy_construct_with_allocator<Allocator, InputType, OutputType>(a));
+
+  // return the end of the output range
+  return thrust::get<1>(end.get_iterator_tuple());
+}
+
+// XXX it's regrettable that this implementation is copied almost
+//     exactly from system::detail::generic::uninitialized_copy_n
+//     perhaps generic::uninitialized_copy_n could call this routine
+//     with a default allocator
+template <typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
+_CCCL_HOST_DEVICE enable_if_convertible_t<FromSystem, ToSystem, Pointer> uninitialized_copy_with_allocator_n(
+  Allocator& a,
+  const thrust::execution_policy<FromSystem>&,
+  const thrust::execution_policy<ToSystem>& to_system,
+  InputIterator first,
+  Size n,
+  Pointer result)
+{
+  // zip up the iterators
+  using IteratorTuple = thrust::tuple<InputIterator, Pointer>;
+  using ZipIterator   = thrust::zip_iterator<IteratorTuple>;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first, result));
+
+  // create a functor
+  using InputType  = typename iterator_traits<InputIterator>::value_type;
+  using OutputType = typename iterator_traits<Pointer>::value_type;
+
+  // do the for_each_n
+  // note we use to_system to dispatch the for_each_n
+  ZipIterator end =
+    thrust::for_each_n(to_system, begin, n, copy_construct_with_allocator<Allocator, InputType, OutputType>(a));
+
+  // return the end of the output range
+  return thrust::get<1>(end.get_iterator_tuple());
+}
+
+template <typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
+_CCCL_HOST_DEVICE typename disable_if_convertible<FromSystem, ToSystem, Pointer>::type uninitialized_copy_with_allocator(
+  Allocator&,
+  const thrust::execution_policy<FromSystem>& from_system,
+  const thrust::execution_policy<ToSystem>& to_system,
+  InputIterator first,
+  InputIterator last,
+  Pointer result)
+{
+  // the systems aren't trivially interoperable
+  // just call two_system_copy and hope for the best
+  return thrust::detail::two_system_copy(from_system, to_system, first, last, result);
+} // end uninitialized_copy_with_allocator()
+
+template <typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
+_CCCL_HOST_DEVICE typename disable_if_convertible<FromSystem, ToSystem, Pointer>::type
+uninitialized_copy_with_allocator_n(
+  Allocator&,
+  const thrust::execution_policy<FromSystem>& from_system,
+  const thrust::execution_policy<ToSystem>& to_system,
+  InputIterator first,
+  Size n,
+  Pointer result)
+{
+  // the systems aren't trivially interoperable
+  // just call two_system_copy_n and hope for the best
+  return thrust::detail::two_system_copy_n(from_system, to_system, first, n, result);
+} // end uninitialized_copy_with_allocator_n()
+
+template <typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
+_CCCL_HOST_DEVICE
+typename disable_if<needs_copy_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value,
+                    Pointer>::type
+copy_construct_range(thrust::execution_policy<FromSystem>& from_system,
+                     Allocator& a,
+                     InputIterator first,
+                     InputIterator last,
+                     Pointer result)
+{
+  // just call two_system_copy
+  return thrust::detail::two_system_copy(from_system, allocator_system<Allocator>::get(a), first, last, result);
+}
+
+template <typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+_CCCL_HOST_DEVICE
+typename disable_if<needs_copy_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value,
+                    Pointer>::type
+copy_construct_range_n(
+  thrust::execution_policy<FromSystem>& from_system, Allocator& a, InputIterator first, Size n, Pointer result)
+{
+  // just call two_system_copy_n
+  return thrust::detail::two_system_copy_n(from_system, allocator_system<Allocator>::get(a), first, n, result);
+}
+
+template <typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
+_CCCL_HOST_DEVICE ::cuda::std::
+  enable_if_t<needs_copy_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value, Pointer>
+  copy_construct_range(thrust::execution_policy<FromSystem>& from_system,
+                       Allocator& a,
+                       InputIterator first,
+                       InputIterator last,
+                       Pointer result)
+{
+  return uninitialized_copy_with_allocator(a, from_system, allocator_system<Allocator>::get(a), first, last, result);
+}
+
+template <typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+_CCCL_HOST_DEVICE ::cuda::std::
+  enable_if_t<needs_copy_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value, Pointer>
+  copy_construct_range_n(
+    thrust::execution_policy<FromSystem>& from_system, Allocator& a, InputIterator first, Size n, Pointer result)
+{
+  return uninitialized_copy_with_allocator_n(a, from_system, allocator_system<Allocator>::get(a), first, n, result);
+}
+
+} // namespace allocator_traits_detail
+
+template <typename System, typename Allocator, typename InputIterator, typename Pointer>
+_CCCL_HOST_DEVICE Pointer copy_construct_range(
+  thrust::execution_policy<System>& from_system, Allocator& a, InputIterator first, InputIterator last, Pointer result)
+{
+  return allocator_traits_detail::copy_construct_range(from_system, a, first, last, result);
+}
+
+template <typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+_CCCL_HOST_DEVICE Pointer copy_construct_range_n(
+  thrust::execution_policy<System>& from_system, Allocator& a, InputIterator first, Size n, Pointer result)
+{
+  return allocator_traits_detail::copy_construct_range_n(from_system, a, first, n, result);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/destroy_range.h

@@ -0,0 +1,39 @@
+/*
+ *  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.
+ */
+
+#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
+namespace detail
+{
+
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE inline void destroy_range(Allocator& a, Pointer p, Size n) noexcept;
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/destroy_range.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/destroy_range.inl

@@ -0,0 +1,137 @@
+/*
+ *  Copyright 2008-2021 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.
+ */
+
+#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/allocator/destroy_range.h>
+#include <thrust/detail/memory_wrapper.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+// destroy_range has three cases:
+// if Allocator has an effectful member function destroy:
+//   1. destroy via the allocator
+// else
+//   2. if T has a non-trivial destructor, destroy the range without using the allocator
+//   3. if T has a trivial destructor, do a no-op
+
+template <typename Allocator, typename T>
+struct has_effectful_member_destroy : has_member_destroy<Allocator, T>
+{};
+
+// std::allocator::destroy's only effect is to invoke its argument's destructor
+template <typename U, typename T>
+struct has_effectful_member_destroy<std::allocator<U>, T> : thrust::detail::false_type
+{};
+
+// case 1: Allocator has an effectful 1-argument member function "destroy"
+template <typename Allocator, typename Pointer>
+struct enable_if_destroy_range_case1
+    : ::cuda::std::enable_if<has_effectful_member_destroy<Allocator, typename pointer_element<Pointer>::type>::value>
+{};
+
+// case 2: Allocator has no member function "destroy", but T has a non-trivial destructor
+template <typename Allocator, typename Pointer>
+struct enable_if_destroy_range_case2
+    : ::cuda::std::enable_if<!has_effectful_member_destroy<Allocator, typename pointer_element<Pointer>::type>::value
+                             && !::cuda::std::is_trivially_destructible<typename pointer_element<Pointer>::type>::value>
+{};
+
+// case 3: Allocator has no member function "destroy", and T has a trivial destructor
+template <typename Allocator, typename Pointer>
+struct enable_if_destroy_range_case3
+    : ::cuda::std::enable_if<!has_effectful_member_destroy<Allocator, typename pointer_element<Pointer>::type>::value
+                             && ::cuda::std::is_trivially_destructible<typename pointer_element<Pointer>::type>::value>
+{};
+
+template <typename Allocator>
+struct destroy_via_allocator
+{
+  Allocator& a;
+
+  _CCCL_HOST_DEVICE destroy_via_allocator(Allocator& a) noexcept
+      : a(a)
+  {}
+
+  template <typename T>
+  inline _CCCL_HOST_DEVICE void operator()(T& x) noexcept
+  {
+    allocator_traits<Allocator>::destroy(a, &x);
+  }
+};
+
+// destroy_range case 1: destroy via allocator
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE typename enable_if_destroy_range_case1<Allocator, Pointer>::type
+destroy_range(Allocator& a, Pointer p, Size n) noexcept
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, destroy_via_allocator<Allocator>(a));
+}
+
+// we must prepare for His coming
+struct gozer
+{
+  _CCCL_EXEC_CHECK_DISABLE
+  template <typename T>
+  inline _CCCL_HOST_DEVICE void operator()(T& x) noexcept
+  {
+    x.~T();
+  }
+};
+
+// destroy_range case 2: destroy without the allocator
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE typename enable_if_destroy_range_case2<Allocator, Pointer>::type
+destroy_range(Allocator& a, Pointer p, Size n) noexcept
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, gozer());
+}
+
+// destroy_range case 3: no-op
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE typename enable_if_destroy_range_case3<Allocator, Pointer>::type
+destroy_range(Allocator&, Pointer, Size) noexcept
+{
+  // no op
+}
+
+} // namespace allocator_traits_detail
+
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE void destroy_range(Allocator& a, Pointer p, Size n) noexcept
+{
+  return allocator_traits_detail::destroy_range(a, p, n);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/fill_construct_range.h

@@ -0,0 +1,39 @@
+/*
+ *  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.
+ */
+
+#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
+namespace detail
+{
+
+template <typename Allocator, typename Pointer, typename Size, typename T>
+_CCCL_HOST_DEVICE inline void fill_construct_range(Allocator& a, Pointer p, Size n, const T& value);
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/fill_construct_range.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/fill_construct_range.inl

@@ -0,0 +1,99 @@
+/*
+ *  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.
+ */
+
+#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_wrapper.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+#include <thrust/uninitialized_fill.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+// fill_construct_range has 2 cases:
+// if Allocator has an effectful member function construct:
+//   1. construct via the allocator
+// else
+//   2. construct via uninitialized_fill
+
+template <typename Allocator, typename T, typename Arg1>
+struct has_effectful_member_construct2 : has_member_construct2<Allocator, T, Arg1>
+{};
+
+// std::allocator::construct's only effect is to invoke placement new
+template <typename U, typename T, typename Arg1>
+struct has_effectful_member_construct2<std::allocator<U>, T, Arg1> : thrust::detail::false_type
+{};
+
+template <typename Allocator, typename Arg1>
+struct construct2_via_allocator
+{
+  Allocator& a;
+  Arg1 arg;
+
+  _CCCL_HOST_DEVICE construct2_via_allocator(Allocator& a, const Arg1& arg)
+      : a(a)
+      , arg(arg)
+  {}
+
+  template <typename T>
+  inline _CCCL_HOST_DEVICE void operator()(T& x)
+  {
+    allocator_traits<Allocator>::construct(a, &x, arg);
+  }
+};
+
+template <typename Allocator, typename Pointer, typename Size, typename T>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<
+  has_effectful_member_construct2<Allocator, typename pointer_element<Pointer>::type, T>::value>
+fill_construct_range(Allocator& a, Pointer p, Size n, const T& value)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, construct2_via_allocator<Allocator, T>(a, value));
+}
+
+template <typename Allocator, typename Pointer, typename Size, typename T>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<
+  !has_effectful_member_construct2<Allocator, typename pointer_element<Pointer>::type, T>::value>
+fill_construct_range(Allocator& a, Pointer p, Size n, const T& value)
+{
+  thrust::uninitialized_fill_n(allocator_system<Allocator>::get(a), p, n, value);
+}
+
+} // namespace allocator_traits_detail
+
+template <typename Alloc, typename Pointer, typename Size, typename T>
+_CCCL_HOST_DEVICE void fill_construct_range(Alloc& a, Pointer p, Size n, const T& value)
+{
+  return allocator_traits_detail::fill_construct_range(a, p, n, value);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/malloc_allocator.h

@@ -0,0 +1,53 @@
+/*
+ *  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.
+ */
+
+#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/tagged_allocator.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename System, typename Pointer>
+class malloc_allocator : public thrust::detail::tagged_allocator<T, System, Pointer>
+{
+private:
+  using super_t = thrust::detail::tagged_allocator<T, System, Pointer>;
+
+public:
+  using pointer   = typename super_t::pointer;
+  using size_type = typename super_t::size_type;
+
+  pointer allocate(size_type cnt);
+
+  void deallocate(pointer p, size_type n) noexcept;
+};
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/malloc_allocator.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/malloc_allocator.inl

@@ -0,0 +1,68 @@
+/*
+ *  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.
+ */
+
+#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/malloc_allocator.h>
+#include <thrust/detail/malloc_and_free.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/system/detail/bad_alloc.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename System, typename Pointer>
+typename malloc_allocator<T, System, Pointer>::pointer
+malloc_allocator<T, System, Pointer>::allocate(typename malloc_allocator<T, System, Pointer>::size_type cnt)
+{
+  using thrust::system::detail::generic::select_system;
+
+  // XXX should use a hypothetical thrust::static_pointer_cast here
+  System system;
+
+  pointer result = thrust::malloc<T>(select_system(system), cnt);
+
+  if (result.get() == 0)
+  {
+    throw thrust::system::detail::bad_alloc("malloc_allocator::allocate: malloc failed");
+  } // end if
+
+  return result;
+} // end malloc_allocator::allocate()
+
+template <typename T, typename System, typename Pointer>
+void malloc_allocator<T, System, Pointer>::deallocate(typename malloc_allocator<T, System, Pointer>::pointer p,
+                                                      typename malloc_allocator<T, System, Pointer>::size_type) noexcept
+{
+  using thrust::system::detail::generic::select_system;
+
+  System system;
+  thrust::free(select_system(system), p);
+} // end malloc_allocator
+
+} // namespace detail
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/no_throw_allocator.h

@@ -0,0 +1,76 @@
+/*
+ *  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.
+ */
+
+#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 <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename BaseAllocator>
+struct no_throw_allocator : BaseAllocator
+{
+private:
+  using super_t = BaseAllocator;
+
+public:
+  inline _CCCL_HOST_DEVICE no_throw_allocator(const BaseAllocator& other = BaseAllocator())
+      : super_t(other)
+  {}
+
+  template <typename U>
+  struct rebind
+  {
+    using other = no_throw_allocator<typename super_t::template rebind<U>::other>;
+  }; // end rebind
+
+  _CCCL_HOST_DEVICE void deallocate(typename super_t::pointer p, typename super_t::size_type n) noexcept
+  {
+    NV_IF_TARGET(
+      NV_IS_HOST,
+      (try { super_t::deallocate(p, n); } // end try
+       catch (...){
+         // catch anything
+       } // end catch
+       ),
+      (super_t::deallocate(p, n);));
+  } // end deallocate()
+
+  inline _CCCL_HOST_DEVICE bool operator==(no_throw_allocator const& other)
+  {
+    return super_t::operator==(other);
+  }
+
+  inline _CCCL_HOST_DEVICE bool operator!=(no_throw_allocator const& other)
+  {
+    return super_t::operator!=(other);
+  }
+}; // end no_throw_allocator
+
+} // namespace detail
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/tagged_allocator.h

@@ -0,0 +1,102 @@
+/*
+ *  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.
+ */
+
+#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/pointer_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename Tag, typename Pointer>
+class tagged_allocator;
+
+template <typename Tag, typename Pointer>
+class tagged_allocator<void, Tag, Pointer>
+{
+public:
+  using value_type      = void;
+  using pointer         = typename thrust::detail::pointer_traits<Pointer>::template rebind<void>::other;
+  using const_pointer   = typename thrust::detail::pointer_traits<Pointer>::template rebind<const void>::other;
+  using size_type       = std::size_t;
+  using difference_type = typename thrust::detail::pointer_traits<Pointer>::difference_type;
+  using system_type     = Tag;
+
+  template <typename U>
+  struct rebind
+  {
+    using other = tagged_allocator<U, Tag, Pointer>;
+  }; // end rebind
+};
+
+template <typename T, typename Tag, typename Pointer>
+class tagged_allocator
+{
+public:
+  using value_type      = T;
+  using pointer         = typename thrust::detail::pointer_traits<Pointer>::template rebind<T>::other;
+  using const_pointer   = typename thrust::detail::pointer_traits<Pointer>::template rebind<const T>::other;
+  using reference       = typename thrust::iterator_reference<pointer>::type;
+  using const_reference = typename thrust::iterator_reference<const_pointer>::type;
+  using size_type       = std::size_t;
+  using difference_type = typename thrust::detail::pointer_traits<pointer>::difference_type;
+  using system_type     = Tag;
+
+  template <typename U>
+  struct rebind
+  {
+    using other = tagged_allocator<U, Tag, Pointer>;
+  }; // end rebind
+
+  _CCCL_HOST_DEVICE inline tagged_allocator();
+
+  _CCCL_HOST_DEVICE inline tagged_allocator(const tagged_allocator&);
+
+  template <typename U, typename OtherPointer>
+  _CCCL_HOST_DEVICE inline tagged_allocator(const tagged_allocator<U, Tag, OtherPointer>&);
+
+  _CCCL_HOST_DEVICE inline ~tagged_allocator();
+
+  _CCCL_HOST_DEVICE pointer address(reference x) const;
+
+  _CCCL_HOST_DEVICE const_pointer address(const_reference x) const;
+
+  size_type max_size() const;
+};
+
+template <typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
+_CCCL_HOST_DEVICE bool
+operator==(const tagged_allocator<T1, Pointer1, Tag>&, const tagged_allocator<T2, Pointer2, Tag>&);
+
+template <typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
+_CCCL_HOST_DEVICE bool
+operator!=(const tagged_allocator<T1, Pointer1, Tag>&, const tagged_allocator<T2, Pointer2, Tag>&);
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/tagged_allocator.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/tagged_allocator.inl

@@ -0,0 +1,86 @@
+/*
+ *  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.
+ */
+
+#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/tagged_allocator.h>
+
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename Tag, typename Pointer>
+_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::tagged_allocator()
+{}
+
+template <typename T, typename Tag, typename Pointer>
+_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::tagged_allocator(const tagged_allocator<T, Tag, Pointer>&)
+{}
+
+template <typename T, typename Tag, typename Pointer>
+template <typename U, typename OtherPointer>
+_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::tagged_allocator(const tagged_allocator<U, Tag, OtherPointer>&)
+{}
+
+template <typename T, typename Tag, typename Pointer>
+_CCCL_HOST_DEVICE tagged_allocator<T, Tag, Pointer>::~tagged_allocator()
+{}
+
+template <typename T, typename Tag, typename Pointer>
+_CCCL_HOST_DEVICE typename tagged_allocator<T, Tag, Pointer>::pointer
+tagged_allocator<T, Tag, Pointer>::address(reference x) const
+{
+  return &x;
+}
+
+template <typename T, typename Tag, typename Pointer>
+_CCCL_HOST_DEVICE typename tagged_allocator<T, Tag, Pointer>::const_pointer
+tagged_allocator<T, Tag, Pointer>::address(const_reference x) const
+{
+  return &x;
+}
+
+template <typename T, typename Tag, typename Pointer>
+typename tagged_allocator<T, Tag, Pointer>::size_type tagged_allocator<T, Tag, Pointer>::max_size() const
+{
+  return (std::numeric_limits<size_type>::max)() / sizeof(T);
+}
+
+template <typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
+_CCCL_HOST_DEVICE bool operator==(const tagged_allocator<T1, Pointer1, Tag>&, const tagged_allocator<T2, Pointer2, Tag>&)
+{
+  return true;
+}
+
+template <typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
+_CCCL_HOST_DEVICE bool operator!=(const tagged_allocator<T1, Pointer1, Tag>&, const tagged_allocator<T2, Pointer2, Tag>&)
+{
+  return false;
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/temporary_allocator.h

@@ -0,0 +1,79 @@
+/*
+ *  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.
+ */
+
+#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/allocator/tagged_allocator.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/memory.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+// XXX the pointer parameter given to tagged_allocator should be related to
+//     the type of the expression get_temporary_buffer(system, n).first
+//     without decltype, compromise on pointer<T,System>
+template <typename T, typename System>
+class temporary_allocator : public thrust::detail::tagged_allocator<T, System, thrust::pointer<T, System>>
+{
+private:
+  using super_t = thrust::detail::tagged_allocator<T, System, thrust::pointer<T, System>>;
+
+  System& m_system;
+
+public:
+  using pointer   = typename super_t::pointer;
+  using size_type = typename super_t::size_type;
+
+  inline _CCCL_HOST_DEVICE temporary_allocator(const temporary_allocator& other)
+      : super_t()
+      , m_system(other.m_system)
+  {}
+
+  inline _CCCL_HOST_DEVICE explicit temporary_allocator(thrust::execution_policy<System>& system)
+      : super_t()
+      , m_system(thrust::detail::derived_cast(system))
+  {}
+
+  _CCCL_HOST_DEVICE pointer allocate(size_type cnt);
+
+  _CCCL_HOST_DEVICE void deallocate(pointer p, size_type n) noexcept;
+
+  _CCCL_HOST_DEVICE inline System& system()
+  {
+    return m_system;
+  } // end system()
+
+private:
+  using pointer_and_size = thrust::pair<pointer, size_type>;
+}; // end temporary_allocator
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/temporary_allocator.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/temporary_allocator.inl

@@ -0,0 +1,81 @@
+/*
+ *  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.
+ */
+
+#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/temporary_allocator.h>
+#include <thrust/detail/temporary_buffer.h>
+#include <thrust/system/detail/bad_alloc.h>
+
+#include <cassert>
+
+#include <nv/target>
+
+#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+#  if (defined(_NVHPC_CUDA) || defined(__CUDA_ARCH__))
+#    include <thrust/system/cuda/detail/terminate.h>
+#  endif // NVCC device pass or NVC++
+#endif // CUDA
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename T, typename System>
+_CCCL_HOST_DEVICE typename temporary_allocator<T, System>::pointer
+temporary_allocator<T, System>::allocate(typename temporary_allocator<T, System>::size_type cnt)
+{
+  pointer_and_size result = thrust::get_temporary_buffer<T>(system(), cnt);
+
+  // handle failure
+  if (result.second < cnt)
+  {
+    // deallocate and throw
+    // note that we pass cnt to deallocate, not a value derived from result.second
+    deallocate(result.first, cnt);
+
+#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+    NV_IF_TARGET(NV_IS_HOST,
+                 (throw thrust::system::detail::bad_alloc("temporary_buffer::allocate: get_temporary_buffer failed");),
+                 ( // NV_IS_DEVICE
+                   thrust::system::cuda::detail::terminate_with_message("temporary_buffer::allocate: "
+                                                                        "get_temporary_buffer failed");));
+#else
+    throw thrust::system::detail::bad_alloc("temporary_buffer::allocate: get_temporary_buffer failed");
+#endif
+  } // end if
+
+  return result.first;
+} // end temporary_allocator::allocate()
+
+template <typename T, typename System>
+_CCCL_HOST_DEVICE void temporary_allocator<T, System>::deallocate(
+  typename temporary_allocator<T, System>::pointer p, typename temporary_allocator<T, System>::size_type n) noexcept
+{
+  return thrust::return_temporary_buffer(system(), p, n);
+} // end temporary_allocator
+
+} // namespace detail
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/value_initialize_range.h

@@ -0,0 +1,39 @@
+/*
+ *  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.
+ */
+
+#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
+namespace detail
+{
+
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE inline void value_initialize_range(Allocator& a, Pointer p, Size n);
+
+} // namespace detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/value_initialize_range.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/allocator/value_initialize_range.inl

@@ -0,0 +1,98 @@
+/*
+ *  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.
+ */
+
+#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/type_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+#include <thrust/uninitialized_fill.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+template <typename Allocator>
+struct construct1_via_allocator
+{
+  Allocator& a;
+
+  _CCCL_HOST_DEVICE construct1_via_allocator(Allocator& a)
+      : a(a)
+  {}
+
+  template <typename T>
+  inline _CCCL_HOST_DEVICE void operator()(T& x)
+  {
+    allocator_traits<Allocator>::construct(a, &x);
+  }
+};
+
+// we need to construct T via the allocator if...
+template <typename Allocator, typename T>
+struct needs_default_construct_via_allocator
+    : ::cuda::std::disjunction<has_member_construct1<Allocator, T>, // if the Allocator does something interesting
+                                                                    // or if T's default constructor does something
+                                                                    // interesting
+                               thrust::detail::not_<::cuda::std::is_trivially_default_constructible<T>>>
+{};
+
+// we know that std::allocator::construct's only effect is to call T's
+// default constructor, so we needn't use it for default construction
+// unless T's constructor does something interesting
+template <typename U, typename T>
+struct needs_default_construct_via_allocator<std::allocator<U>, T>
+    : thrust::detail::not_<::cuda::std::is_trivially_default_constructible<T>>
+{};
+
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE ::cuda::std::enable_if_t<
+  needs_default_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value>
+value_initialize_range(Allocator& a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, construct1_via_allocator<Allocator>(a));
+}
+
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE
+typename disable_if<needs_default_construct_via_allocator<Allocator, typename pointer_element<Pointer>::type>::value>::type
+value_initialize_range(Allocator& a, Pointer p, Size n)
+{
+  thrust::uninitialized_fill_n(allocator_system<Allocator>::get(a), p, n, typename pointer_element<Pointer>::type());
+}
+
+} // namespace allocator_traits_detail
+
+template <typename Allocator, typename Pointer, typename Size>
+_CCCL_HOST_DEVICE void value_initialize_range(Allocator& a, Pointer p, Size n)
+{
+  return allocator_traits_detail::value_initialize_range(a, p, n);
+}
+
+} // namespace detail
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,875 @@
+/*
+ *  Copyright 2008-2013 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.
+ */
+
+/*-
+ * Copyright (c) 2012 Stephen Montgomery-Smith <stephen@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Adapted from FreeBSD by Filipe Maia <filipe.c.maia@gmail.com>:
+ *    freebsd/lib/msun/src/catrig.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+#include <cfloat>
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+_CCCL_HOST_DEVICE inline void raise_inexact()
+{
+  const volatile float tiny = 7.888609052210118054117286e-31; /* 0x1p-100; */
+  // needs the volatile to prevent compiler from ignoring it
+  volatile float junk = 1 + tiny;
+  (void) junk;
+}
+
+_CCCL_HOST_DEVICE inline complex<double> clog_for_large_values(complex<double> z);
+
+/*
+ * Testing indicates that all these functions are accurate up to 4 ULP.
+ * The functions casin(h) and cacos(h) are about 2.5 times slower than asinh.
+ * The functions catan(h) are a little under 2 times slower than atanh.
+ *
+ * The code for casinh, casin, cacos, and cacosh comes first.  The code is
+ * rather complicated, and the four functions are highly interdependent.
+ *
+ * The code for catanh and catan comes at the end.  It is much simpler than
+ * the other functions, and the code for these can be disconnected from the
+ * rest of the code.
+ */
+
+/*
+ *			================================
+ *			| casinh, casin, cacos, cacosh |
+ *			================================
+ */
+
+/*
+ * The algorithm is very close to that in "Implementing the complex arcsine
+ * and arccosine functions using exception handling" by T. E. Hull, Thomas F.
+ * Fairgrieve, and Ping Tak Peter Tang, published in ACM Transactions on
+ * Mathematical Software, Volume 23 Issue 3, 1997, Pages 299-335,
+ * http://dl.acm.org/citation.cfm?id=275324.
+ *
+ * Throughout we use the convention z = x + I*y.
+ *
+ * casinh(z) = sign(x)*log(A+sqrt(A*A-1)) + I*asin(B)
+ * where
+ * A = (|z+I| + |z-I|) / 2
+ * B = (|z+I| - |z-I|) / 2 = y/A
+ *
+ * These formulas become numerically unstable:
+ *   (a) for Re(casinh(z)) when z is close to the line segment [-I, I] (that
+ *       is, Re(casinh(z)) is close to 0);
+ *   (b) for Im(casinh(z)) when z is close to either of the intervals
+ *       [I, I*infinity) or (-I*infinity, -I] (that is, |Im(casinh(z))| is
+ *       close to PI/2).
+ *
+ * These numerical problems are overcome by defining
+ * f(a, b) = (hypot(a, b) - b) / 2 = a*a / (hypot(a, b) + b) / 2
+ * Then if A < A_crossover, we use
+ *   log(A + sqrt(A*A-1)) = log1p((A-1) + sqrt((A-1)*(A+1)))
+ *   A-1 = f(x, 1+y) + f(x, 1-y)
+ * and if B > B_crossover, we use
+ *   asin(B) = atan2(y, sqrt(A*A - y*y)) = atan2(y, sqrt((A+y)*(A-y)))
+ *   A-y = f(x, y+1) + f(x, y-1)
+ * where without loss of generality we have assumed that x and y are
+ * non-negative.
+ *
+ * Much of the difficulty comes because the intermediate computations may
+ * produce overflows or underflows.  This is dealt with in the paper by Hull
+ * et al by using exception handling.  We do this by detecting when
+ * computations risk underflow or overflow.  The hardest part is handling the
+ * underflows when computing f(a, b).
+ *
+ * Note that the function f(a, b) does not appear explicitly in the paper by
+ * Hull et al, but the idea may be found on pages 308 and 309.  Introducing the
+ * function f(a, b) allows us to concentrate many of the clever tricks in this
+ * paper into one function.
+ */
+
+/*
+ * Function f(a, b, hypot_a_b) = (hypot(a, b) - b) / 2.
+ * Pass hypot(a, b) as the third argument.
+ */
+_CCCL_HOST_DEVICE inline double f(double a, double b, double hypot_a_b)
+{
+  if (b < 0)
+  {
+    return ((hypot_a_b - b) / 2);
+  }
+  if (b == 0)
+  {
+    return (a / 2);
+  }
+  return (a * a / (hypot_a_b + b) / 2);
+}
+
+/*
+ * All the hard work is contained in this function.
+ * x and y are assumed positive or zero, and less than RECIP_EPSILON.
+ * Upon return:
+ * rx = Re(casinh(z)) = -Im(cacos(y + I*x)).
+ * B_is_usable is set to 1 if the value of B is usable.
+ * If B_is_usable is set to 0, sqrt_A2my2 = sqrt(A*A - y*y), and new_y = y.
+ * If returning sqrt_A2my2 has potential to result in an underflow, it is
+ * rescaled, and new_y is similarly rescaled.
+ */
+_CCCL_HOST_DEVICE inline void
+do_hard_work(double x, double y, double* rx, int* B_is_usable, double* B, double* sqrt_A2my2, double* new_y)
+{
+  double R, S, A; /* A, B, R, and S are as in Hull et al. */
+  double Am1, Amy; /* A-1, A-y. */
+  const double A_crossover   = 10; /* Hull et al suggest 1.5, but 10 works better */
+  const double FOUR_SQRT_MIN = 5.966672584960165394632772e-154; /* =0x1p-509; >= 4 * sqrt(DBL_MIN) */
+  const double B_crossover   = 0.6417; /* suggested by Hull et al */
+
+  R = hypot(x, y + 1); /* |z+I| */
+  S = hypot(x, y - 1); /* |z-I| */
+
+  /* A = (|z+I| + |z-I|) / 2 */
+  A = (R + S) / 2;
+  /*
+   * Mathematically A >= 1.  There is a small chance that this will not
+   * be so because of rounding errors.  So we will make certain it is
+   * so.
+   */
+  if (A < 1)
+  {
+    A = 1;
+  }
+
+  if (A < A_crossover)
+  {
+    /*
+     * Am1 = fp + fm, where fp = f(x, 1+y), and fm = f(x, 1-y).
+     * rx = log1p(Am1 + sqrt(Am1*(A+1)))
+     */
+    if (y == 1 && x < DBL_EPSILON * DBL_EPSILON / 128)
+    {
+      /*
+       * fp is of order x^2, and fm = x/2.
+       * A = 1 (inexactly).
+       */
+      *rx = sqrt(x);
+    }
+    else if (x >= DBL_EPSILON * fabs(y - 1))
+    {
+      /*
+       * Underflow will not occur because
+       * x >= DBL_EPSILON^2/128 >= FOUR_SQRT_MIN
+       */
+      Am1 = f(x, 1 + y, R) + f(x, 1 - y, S);
+      *rx = log1p(Am1 + sqrt(Am1 * (A + 1)));
+    }
+    else if (y < 1)
+    {
+      /*
+       * fp = x*x/(1+y)/4, fm = x*x/(1-y)/4, and
+       * A = 1 (inexactly).
+       */
+      *rx = x / sqrt((1 - y) * (1 + y));
+    }
+    else
+    { /* if (y > 1) */
+      /*
+       * A-1 = y-1 (inexactly).
+       */
+      *rx = log1p((y - 1) + sqrt((y - 1) * (y + 1)));
+    }
+  }
+  else
+  {
+    *rx = log(A + sqrt(A * A - 1));
+  }
+
+  *new_y = y;
+
+  if (y < FOUR_SQRT_MIN)
+  {
+    /*
+     * Avoid a possible underflow caused by y/A.  For casinh this
+     * would be legitimate, but will be picked up by invoking atan2
+     * later on.  For cacos this would not be legitimate.
+     */
+    *B_is_usable = 0;
+    *sqrt_A2my2  = A * (2 / DBL_EPSILON);
+    *new_y       = y * (2 / DBL_EPSILON);
+    return;
+  }
+
+  /* B = (|z+I| - |z-I|) / 2 = y/A */
+  *B           = y / A;
+  *B_is_usable = 1;
+
+  if (*B > B_crossover)
+  {
+    *B_is_usable = 0;
+    /*
+     * Amy = fp + fm, where fp = f(x, y+1), and fm = f(x, y-1).
+     * sqrt_A2my2 = sqrt(Amy*(A+y))
+     */
+    if (y == 1 && x < DBL_EPSILON / 128)
+    {
+      /*
+       * fp is of order x^2, and fm = x/2.
+       * A = 1 (inexactly).
+       */
+      *sqrt_A2my2 = sqrt(x) * sqrt((A + y) / 2);
+    }
+    else if (x >= DBL_EPSILON * fabs(y - 1))
+    {
+      /*
+       * Underflow will not occur because
+       * x >= DBL_EPSILON/128 >= FOUR_SQRT_MIN
+       * and
+       * x >= DBL_EPSILON^2 >= FOUR_SQRT_MIN
+       */
+      Amy         = f(x, y + 1, R) + f(x, y - 1, S);
+      *sqrt_A2my2 = sqrt(Amy * (A + y));
+    }
+    else if (y > 1)
+    {
+      /*
+       * fp = x*x/(y+1)/4, fm = x*x/(y-1)/4, and
+       * A = y (inexactly).
+       *
+       * y < RECIP_EPSILON.  So the following
+       * scaling should avoid any underflow problems.
+       */
+      *sqrt_A2my2 = x * (4 / DBL_EPSILON / DBL_EPSILON) * y / sqrt((y + 1) * (y - 1));
+      *new_y      = y * (4 / DBL_EPSILON / DBL_EPSILON);
+    }
+    else
+    { /* if (y < 1) */
+      /*
+       * fm = 1-y >= DBL_EPSILON, fp is of order x^2, and
+       * A = 1 (inexactly).
+       */
+      *sqrt_A2my2 = sqrt((1 - y) * (1 + y));
+    }
+  }
+}
+
+/*
+ * casinh(z) = z + O(z^3)   as z -> 0
+ *
+ * casinh(z) = sign(x)*clog(sign(x)*z) + O(1/z^2)   as z -> infinity
+ * The above formula works for the imaginary part as well, because
+ * Im(casinh(z)) = sign(x)*atan2(sign(x)*y, fabs(x)) + O(y/z^3)
+ *    as z -> infinity, uniformly in y
+ */
+_CCCL_HOST_DEVICE inline complex<double> casinh(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry, B, sqrt_A2my2, new_y;
+  int B_is_usable;
+  complex<double> w;
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  const double m_ln2         = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+  x                          = z.real();
+  y                          = z.imag();
+  ax                         = fabs(x);
+  ay                         = fabs(y);
+
+  if (isnan(x) || isnan(y))
+  {
+    /* casinh(+-Inf + I*NaN) = +-Inf + I*NaN */
+    if (isinf(x))
+    {
+      return (complex<double>(x, y + y));
+    }
+    /* casinh(NaN + I*+-Inf) = opt(+-)Inf + I*NaN */
+    if (isinf(y))
+    {
+      return (complex<double>(y, x + x));
+    }
+    /* casinh(NaN + I*0) = NaN + I*0 */
+    if (y == 0)
+    {
+      return (complex<double>(x + x, y));
+    }
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0.0), x + 0.0 + (y + 0.0)));
+  }
+
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
+  {
+    /* clog...() will raise inexact unless x or y is infinite. */
+    if (signbit(x) == 0)
+    {
+      w = clog_for_large_values(z) + m_ln2;
+    }
+    else
+    {
+      w = clog_for_large_values(-z) + m_ln2;
+    }
+    return (complex<double>(copysign(w.real(), x), copysign(w.imag(), y)));
+  }
+
+  /* Avoid spuriously raising inexact for z = 0. */
+  if (x == 0 && y == 0)
+  {
+    return (z);
+  }
+
+  /* All remaining cases are inexact. */
+  raise_inexact();
+
+  const double SQRT_6_EPSILON = 3.6500241499888571e-8; /*  0x13988e1409212e.0p-77 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+  {
+    return (z);
+  }
+
+  do_hard_work(ax, ay, &rx, &B_is_usable, &B, &sqrt_A2my2, &new_y);
+  if (B_is_usable)
+  {
+    ry = asin(B);
+  }
+  else
+  {
+    ry = atan2(new_y, sqrt_A2my2);
+  }
+  return (complex<double>(copysign(rx, x), copysign(ry, y)));
+}
+
+/*
+ * casin(z) = reverse(casinh(reverse(z)))
+ * where reverse(x + I*y) = y + I*x = I*conj(z).
+ */
+_CCCL_HOST_DEVICE inline complex<double> casin(complex<double> z)
+{
+  complex<double> w = casinh(complex<double>(z.imag(), z.real()));
+
+  return (complex<double>(w.imag(), w.real()));
+}
+
+/*
+ * cacos(z) = PI/2 - casin(z)
+ * but do the computation carefully so cacos(z) is accurate when z is
+ * close to 1.
+ *
+ * cacos(z) = PI/2 - z + O(z^3)   as z -> 0
+ *
+ * cacos(z) = -sign(y)*I*clog(z) + O(1/z^2)   as z -> infinity
+ * The above formula works for the real part as well, because
+ * Re(cacos(z)) = atan2(fabs(y), x) + O(y/z^3)
+ *    as z -> infinity, uniformly in y
+ */
+_CCCL_HOST_DEVICE inline complex<double> cacos(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry, B, sqrt_A2mx2, new_x;
+  int sx, sy;
+  int B_is_usable;
+  complex<double> w;
+  const double pio2_hi          = 1.5707963267948966e0; /*  0x1921fb54442d18.0p-52 */
+  const volatile double pio2_lo = 6.1232339957367659e-17; /*  0x11a62633145c07.0p-106 */
+  const double m_ln2            = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+
+  x  = z.real();
+  y  = z.imag();
+  sx = signbit(x);
+  sy = signbit(y);
+  ax = fabs(x);
+  ay = fabs(y);
+
+  if (isnan(x) || isnan(y))
+  {
+    /* cacos(+-Inf + I*NaN) = NaN + I*opt(-)Inf */
+    if (isinf(x))
+    {
+      return (complex<double>(y + y, -infinity<double>()));
+    }
+    /* cacos(NaN + I*+-Inf) = NaN + I*-+Inf */
+    if (isinf(y))
+    {
+      return (complex<double>(x + x, -y));
+    }
+    /* cacos(0 + I*NaN) = PI/2 + I*NaN with inexact */
+    if (x == 0)
+    {
+      return (complex<double>(pio2_hi + pio2_lo, y + y));
+    }
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0), x + 0.0 + (y + 0)));
+  }
+
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
+  {
+    /* clog...() will raise inexact unless x or y is infinite. */
+    w  = clog_for_large_values(z);
+    rx = fabs(w.imag());
+    ry = w.real() + m_ln2;
+    if (sy == 0)
+    {
+      ry = -ry;
+    }
+    return (complex<double>(rx, ry));
+  }
+
+  /* Avoid spuriously raising inexact for z = 1. */
+  if (x == 1.0 && y == 0.0)
+  {
+    return (complex<double>(0, -y));
+  }
+
+  /* All remaining cases are inexact. */
+  raise_inexact();
+
+  const double SQRT_6_EPSILON = 3.6500241499888571e-8; /*  0x13988e1409212e.0p-77 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+  {
+    return (complex<double>(pio2_hi - (x - pio2_lo), -y));
+  }
+
+  do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x);
+  if (B_is_usable)
+  {
+    if (sx == 0)
+    {
+      rx = acos(B);
+    }
+    else
+    {
+      rx = acos(-B);
+    }
+  }
+  else
+  {
+    if (sx == 0)
+    {
+      rx = atan2(sqrt_A2mx2, new_x);
+    }
+    else
+    {
+      rx = atan2(sqrt_A2mx2, -new_x);
+    }
+  }
+  if (sy == 0)
+  {
+    ry = -ry;
+  }
+  return (complex<double>(rx, ry));
+}
+
+/*
+ * cacosh(z) = I*cacos(z) or -I*cacos(z)
+ * where the sign is chosen so Re(cacosh(z)) >= 0.
+ */
+_CCCL_HOST_DEVICE inline complex<double> cacosh(complex<double> z)
+{
+  complex<double> w;
+  double rx, ry;
+
+  w  = cacos(z);
+  rx = w.real();
+  ry = w.imag();
+  /* cacosh(NaN + I*NaN) = NaN + I*NaN */
+  if (isnan(rx) && isnan(ry))
+  {
+    return (complex<double>(ry, rx));
+  }
+  /* cacosh(NaN + I*+-Inf) = +Inf + I*NaN */
+  /* cacosh(+-Inf + I*NaN) = +Inf + I*NaN */
+  if (isnan(rx))
+  {
+    return (complex<double>(fabs(ry), rx));
+  }
+  /* cacosh(0 + I*NaN) = NaN + I*NaN */
+  if (isnan(ry))
+  {
+    return (complex<double>(ry, ry));
+  }
+  return (complex<double>(fabs(ry), copysign(rx, z.imag())));
+}
+
+/*
+ * Optimized version of clog() for |z| finite and larger than ~RECIP_EPSILON.
+ */
+_CCCL_HOST_DEVICE inline complex<double> clog_for_large_values(complex<double> z)
+{
+  double x, y;
+  double ax, ay, t;
+  const double m_e = 2.7182818284590452e0; /*  0x15bf0a8b145769.0p-51 */
+
+  x  = z.real();
+  y  = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+  if (ax < ay)
+  {
+    t  = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  /*
+   * Avoid overflow in hypot() when x and y are both very large.
+   * Divide x and y by E, and then add 1 to the logarithm.  This depends
+   * on E being larger than sqrt(2).
+   * Dividing by E causes an insignificant loss of accuracy; however
+   * this method is still poor since it is unnecessarily slow.
+   */
+  if (ax > DBL_MAX / 2)
+  {
+    return (complex<double>(log(hypot(x / m_e, y / m_e)) + 1, atan2(y, x)));
+  }
+
+  /*
+   * Avoid overflow when x or y is large.  Avoid underflow when x or
+   * y is small.
+   */
+  const double QUARTER_SQRT_MAX = 5.966672584960165394632772e-154; /* = 0x1p509; <= sqrt(DBL_MAX) / 4 */
+  const double SQRT_MIN         = 1.491668146240041348658193e-154; /* = 0x1p-511; >= sqrt(DBL_MIN) */
+  if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN)
+  {
+    return (complex<double>(log(hypot(x, y)), atan2(y, x)));
+  }
+
+  return (complex<double>(log(ax * ax + ay * ay) / 2, atan2(y, x)));
+}
+
+/*
+ *				=================
+ *				| catanh, catan |
+ *				=================
+ */
+
+/*
+ * sum_squares(x,y) = x*x + y*y (or just x*x if y*y would underflow).
+ * Assumes x*x and y*y will not overflow.
+ * Assumes x and y are finite.
+ * Assumes y is non-negative.
+ * Assumes fabs(x) >= DBL_EPSILON.
+ */
+_CCCL_HOST_DEVICE inline double sum_squares(double x, double y)
+{
+  const double SQRT_MIN = 1.491668146240041348658193e-154; /* = 0x1p-511; >= sqrt(DBL_MIN) */
+  /* Avoid underflow when y is small. */
+  if (y < SQRT_MIN)
+  {
+    return (x * x);
+  }
+
+  return (x * x + y * y);
+}
+
+/*
+ * real_part_reciprocal(x, y) = Re(1/(x+I*y)) = x/(x*x + y*y).
+ * Assumes x and y are not NaN, and one of x and y is larger than
+ * RECIP_EPSILON.  We avoid unwarranted underflow.  It is important to not use
+ * the code creal(1/z), because the imaginary part may produce an unwanted
+ * underflow.
+ * This is only called in a context where inexact is always raised before
+ * the call, so no effort is made to avoid or force inexact.
+ */
+_CCCL_HOST_DEVICE inline double real_part_reciprocal(double x, double y)
+{
+  double scale;
+  uint32_t hx, hy;
+  int32_t ix, iy;
+
+  /*
+   * This code is inspired by the C99 document n1124.pdf, Section G.5.1,
+   * example 2.
+   */
+  get_high_word(hx, x);
+  ix = hx & 0x7ff00000;
+  get_high_word(hy, y);
+  iy = hy & 0x7ff00000;
+  // #define	BIAS	(DBL_MAX_EXP - 1)
+  const int BIAS = DBL_MAX_EXP - 1;
+  /* XXX more guard digits are useful iff there is extra precision. */
+  // #define	CUTOFF	(DBL_MANT_DIG / 2 + 1)	/* just half or 1 guard digit */
+  const int CUTOFF = (DBL_MANT_DIG / 2 + 1);
+  if (ix - iy >= CUTOFF << 20 || isinf(x))
+  {
+    return (1 / x); /* +-Inf -> +-0 is special */
+  }
+  if (iy - ix >= CUTOFF << 20)
+  {
+    return (x / y / y); /* should avoid double div, but hard */
+  }
+  if (ix <= (BIAS + DBL_MAX_EXP / 2 - CUTOFF) << 20)
+  {
+    return (x / (x * x + y * y));
+  }
+  scale = 1;
+  set_high_word(scale, 0x7ff00000 - ix); /* 2**(1-ilogb(x)) */
+  x *= scale;
+  y *= scale;
+  return (x / (x * x + y * y) * scale);
+}
+
+/*
+ * catanh(z) = log((1+z)/(1-z)) / 2
+ *           = log1p(4*x / |z-1|^2) / 4
+ *             + I * atan2(2*y, (1-x)*(1+x)-y*y) / 2
+ *
+ * catanh(z) = z + O(z^3)   as z -> 0
+ *
+ * catanh(z) = 1/z + sign(y)*I*PI/2 + O(1/z^3)   as z -> infinity
+ * The above formula works for the real part as well, because
+ * Re(catanh(z)) = x/|z|^2 + O(x/z^4)
+ *    as z -> infinity, uniformly in x
+ */
+_CCCL_HOST_DEVICE inline complex<double> catanh(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry;
+  const volatile double pio2_lo = 6.1232339957367659e-17; /*  0x11a62633145c07.0p-106 */
+  const double pio2_hi          = 1.5707963267948966e0; /*  0x1921fb54442d18.0p-52 */
+
+  x  = z.real();
+  y  = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+
+  /* This helps handle many cases. */
+  if (y == 0 && ax <= 1)
+  {
+    return (complex<double>(atanh(x), y));
+  }
+
+  /* To ensure the same accuracy as atan(), and to filter out z = 0. */
+  if (x == 0)
+  {
+    return (complex<double>(x, atan(y)));
+  }
+
+  if (isnan(x) || isnan(y))
+  {
+    /* catanh(+-Inf + I*NaN) = +-0 + I*NaN */
+    if (isinf(x))
+    {
+      return (complex<double>(copysign(0.0, x), y + y));
+    }
+    /* catanh(NaN + I*+-Inf) = sign(NaN)0 + I*+-PI/2 */
+    if (isinf(y))
+    {
+      return (complex<double>(copysign(0.0, x), copysign(pio2_hi + pio2_lo, y)));
+    }
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0), x + 0.0 + (y + 0)));
+  }
+
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
+  {
+    return (complex<double>(real_part_reciprocal(x, y), copysign(pio2_hi + pio2_lo, y)));
+  }
+
+  const double SQRT_3_EPSILON = 2.5809568279517849e-8; /*  0x1bb67ae8584caa.0p-78 */
+  if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2)
+  {
+    /*
+     * z = 0 was filtered out above.  All other cases must raise
+     * inexact, but this is the only only that needs to do it
+     * explicitly.
+     */
+    raise_inexact();
+    return (z);
+  }
+
+  const double m_ln2 = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+  if (ax == 1 && ay < DBL_EPSILON)
+  {
+    rx = (m_ln2 - log(ay)) / 2;
+  }
+  else
+  {
+    rx = log1p(4 * ax / sum_squares(ax - 1, ay)) / 4;
+  }
+
+  if (ax == 1)
+  {
+    ry = atan2(2.0, -ay) / 2;
+  }
+  else if (ay < DBL_EPSILON)
+  {
+    ry = atan2(2 * ay, (1 - ax) * (1 + ax)) / 2;
+  }
+  else
+  {
+    ry = atan2(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2;
+  }
+
+  return (complex<double>(copysign(rx, x), copysign(ry, y)));
+}
+
+/*
+ * catan(z) = reverse(catanh(reverse(z)))
+ * where reverse(x + I*y) = y + I*x = I*conj(z).
+ */
+_CCCL_HOST_DEVICE inline complex<double> catan(complex<double> z)
+{
+  complex<double> w = catanh(complex<double>(z.imag(), z.real()));
+  return (complex<double>(w.imag(), w.real()));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> acos(const complex<ValueType>& z)
+{
+  const complex<ValueType> ret = thrust::asin(z);
+  const ValueType pi           = ValueType(3.14159265358979323846);
+  return complex<ValueType>(pi / 2 - ret.real(), -ret.imag());
+}
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> asin(const complex<ValueType>& z)
+{
+  const complex<ValueType> i(0, 1);
+  return -i * asinh(i * z);
+}
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> atan(const complex<ValueType>& z)
+{
+  const complex<ValueType> i(0, 1);
+  return -i * thrust::atanh(i * z);
+}
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> acosh(const complex<ValueType>& z)
+{
+  thrust::complex<ValueType> ret(
+    (z.real() - z.imag()) * (z.real() + z.imag()) - ValueType(1.0), ValueType(2.0) * z.real() * z.imag());
+  ret = thrust::sqrt(ret);
+  if (z.real() < ValueType(0.0))
+  {
+    ret = -ret;
+  }
+  ret += z;
+  ret = thrust::log(ret);
+  if (ret.real() < ValueType(0.0))
+  {
+    ret = -ret;
+  }
+  return ret;
+}
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> asinh(const complex<ValueType>& z)
+{
+  return thrust::log(thrust::sqrt(z * z + ValueType(1)) + z);
+}
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> atanh(const complex<ValueType>& z)
+{
+  ValueType imag2 = z.imag() * z.imag();
+  ValueType n     = ValueType(1.0) + z.real();
+  n               = imag2 + n * n;
+
+  ValueType d = ValueType(1.0) - z.real();
+  d           = imag2 + d * d;
+  complex<ValueType> ret(ValueType(0.25) * (std::log(n) - std::log(d)), 0);
+
+  d = ValueType(1.0) - z.real() * z.real() - imag2;
+
+  ret.imag(ValueType(0.5) * std::atan2(ValueType(2.0) * z.imag(), d));
+  return ret;
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> acos(const complex<double>& z)
+{
+  return detail::complex::cacos(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> asin(const complex<double>& z)
+{
+  return detail::complex::casin(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> atan(const complex<double>& z)
+{
+  return detail::complex::catan(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> acosh(const complex<double>& z)
+{
+  return detail::complex::cacosh(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> asinh(const complex<double>& z)
+{
+  return detail::complex::casinh(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> atanh(const complex<double>& z)
+{
+  return detail::complex::catanh(z);
+}
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,195 @@
+/*
+ *  Copyright 2008-2013 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.
+ */
+
+/*-
+ * Copyright (c) 2011 David Schultz <das@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_cexp.c
+ *    lib/msun/src/k_exp.c
+ *
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+/*
+ * Compute exp(x), scaled to avoid spurious overflow.  An exponent is
+ * returned separately in 'expt'.
+ *
+ * Input:  ln(DBL_MAX) <= x < ln(2 * DBL_MAX / DBL_MIN_DENORM) ~= 1454.91
+ * Output: 2**1023 <= y < 2**1024
+ */
+_CCCL_HOST_DEVICE inline double frexp_exp(double x, int* expt)
+{
+  const uint32_t k  = 1799; /* constant for reduction */
+  const double kln2 = 1246.97177782734161156; /* k * ln2 */
+
+  double exp_x;
+  uint32_t hx;
+
+  /*
+   * We use exp(x) = exp(x - kln2) * 2**k, carefully chosen to
+   * minimize |exp(kln2) - 2**k|.  We also scale the exponent of
+   * exp_x to MAX_EXP so that the result can be multiplied by
+   * a tiny number without losing accuracy due to denormalization.
+   */
+  exp_x = exp(x - kln2);
+  get_high_word(hx, exp_x);
+  *expt = (hx >> 20) - (0x3ff + 1023) + k;
+  set_high_word(exp_x, (hx & 0xfffff) | ((0x3ff + 1023) << 20));
+  return (exp_x);
+}
+
+_CCCL_HOST_DEVICE inline complex<double> ldexp_cexp(complex<double> z, int expt)
+{
+  double x, y, exp_x, scale1, scale2;
+  int ex_expt, half_expt;
+
+  x     = z.real();
+  y     = z.imag();
+  exp_x = frexp_exp(x, &ex_expt);
+  expt += ex_expt;
+
+  /*
+   * Arrange so that scale1 * scale2 == 2**expt.  We use this to
+   * compensate for scalbn being horrendously slow.
+   */
+  half_expt = expt / 2;
+  insert_words(scale1, (0x3ff + half_expt) << 20, 0);
+  half_expt = expt - half_expt;
+  insert_words(scale2, (0x3ff + half_expt) << 20, 0);
+
+  return (complex<double>(cos(y) * exp_x * scale1 * scale2, sin(y) * exp_x * scale1 * scale2));
+}
+
+_CCCL_HOST_DEVICE inline complex<double> cexp(const complex<double>& z)
+{
+  double x, y, exp_x;
+  uint32_t hx, hy, lx, ly;
+
+  const uint32_t exp_ovfl = 0x40862e42, /* high bits of MAX_EXP * ln2 ~= 710 */
+    cexp_ovfl             = 0x4096b8e4; /* (MAX_EXP - MIN_DENORM_EXP) * ln2 */
+
+  x = z.real();
+  y = z.imag();
+
+  extract_words(hy, ly, y);
+  hy &= 0x7fffffff;
+
+  /* cexp(x + I 0) = exp(x) + I 0 */
+  if ((hy | ly) == 0)
+  {
+    return (complex<double>(exp(x), y));
+  }
+  extract_words(hx, lx, x);
+  /* cexp(0 + I y) = cos(y) + I sin(y) */
+  if (((hx & 0x7fffffff) | lx) == 0)
+  {
+    return (complex<double>(cos(y), sin(y)));
+  }
+
+  if (hy >= 0x7ff00000)
+  {
+    if (lx != 0 || (hx & 0x7fffffff) != 0x7ff00000)
+    {
+      /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */
+      return (complex<double>(y - y, y - y));
+    }
+    else if (hx & 0x80000000)
+    {
+      /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */
+      return (complex<double>(0.0, 0.0));
+    }
+    else
+    {
+      /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */
+      return (complex<double>(x, y - y));
+    }
+  }
+
+  if (hx >= exp_ovfl && hx <= cexp_ovfl)
+  {
+    /*
+     * x is between 709.7 and 1454.3, so we must scale to avoid
+     * overflow in exp(x).
+     */
+    return (ldexp_cexp(z, 0));
+  }
+  else
+  {
+    /*
+     * Cases covered here:
+     *  -  x < exp_ovfl and exp(x) won't overflow (common case)
+     *  -  x > cexp_ovfl, so exp(x) * s overflows for all s > 0
+     *  -  x = +-Inf (generated by exp())
+     *  -  x = NaN (spurious inexact exception from y)
+     */
+    exp_x = std::exp(x);
+    return (complex<double>(exp_x * cos(y), exp_x * sin(y)));
+  }
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> exp(const complex<ValueType>& z)
+{
+  return polar(std::exp(z.real()), z.imag());
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> exp(const complex<double>& z)
+{
+  return detail::complex::cexp(z);
+}
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,173 @@
+/*
+ *  Copyright 2008-2013 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.
+ */
+
+/*-
+ * Copyright (c) 2011 David Schultz <das@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_cexpf.c
+ *    lib/msun/src/k_exp.c
+ *
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+_CCCL_HOST_DEVICE inline float frexp_expf(float x, int* expt)
+{
+  const uint32_t k = 235; /* constant for reduction */
+  const float kln2 = 162.88958740F; /* k * ln2 */
+
+  // should this be a double instead?
+  float exp_x;
+  uint32_t hx;
+
+  exp_x = expf(x - kln2);
+  get_float_word(hx, exp_x);
+  *expt = (hx >> 23) - (0x7f + 127) + k;
+  set_float_word(exp_x, (hx & 0x7fffff) | ((0x7f + 127) << 23));
+  return (exp_x);
+}
+
+_CCCL_HOST_DEVICE inline complex<float> ldexp_cexpf(complex<float> z, int expt)
+{
+  float x, y, exp_x, scale1, scale2;
+  int ex_expt, half_expt;
+
+  x     = z.real();
+  y     = z.imag();
+  exp_x = frexp_expf(x, &ex_expt);
+  expt += ex_expt;
+
+  half_expt = expt / 2;
+  set_float_word(scale1, (0x7f + half_expt) << 23);
+  half_expt = expt - half_expt;
+  set_float_word(scale2, (0x7f + half_expt) << 23);
+
+  return (complex<float>(std::cos(y) * exp_x * scale1 * scale2, std::sin(y) * exp_x * scale1 * scale2));
+}
+
+_CCCL_HOST_DEVICE inline complex<float> cexpf(const complex<float>& z)
+{
+  float x, y, exp_x;
+  uint32_t hx, hy;
+
+  const uint32_t exp_ovfl = 0x42b17218, /* MAX_EXP * ln2 ~= 88.722839355 */
+    cexp_ovfl             = 0x43400074; /* (MAX_EXP - MIN_DENORM_EXP) * ln2 */
+
+  x = z.real();
+  y = z.imag();
+
+  get_float_word(hy, y);
+  hy &= 0x7fffffff;
+
+  /* cexp(x + I 0) = exp(x) + I 0 */
+  if (hy == 0)
+  {
+    return (complex<float>(std::exp(x), y));
+  }
+  get_float_word(hx, x);
+  /* cexp(0 + I y) = cos(y) + I sin(y) */
+  if ((hx & 0x7fffffff) == 0)
+  {
+    return (complex<float>(std::cos(y), std::sin(y)));
+  }
+  if (hy >= 0x7f800000)
+  {
+    if ((hx & 0x7fffffff) != 0x7f800000)
+    {
+      /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */
+      return (complex<float>(y - y, y - y));
+    }
+    else if (hx & 0x80000000)
+    {
+      /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */
+      return (complex<float>(0.0, 0.0));
+    }
+    else
+    {
+      /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */
+      return (complex<float>(x, y - y));
+    }
+  }
+
+  if (hx >= exp_ovfl && hx <= cexp_ovfl)
+  {
+    /*
+     * x is between 88.7 and 192, so we must scale to avoid
+     * overflow in expf(x).
+     */
+    return (ldexp_cexpf(z, 0));
+  }
+  else
+  {
+    /*
+     * Cases covered here:
+     *  -  x < exp_ovfl and exp(x) won't overflow (common case)
+     *  -  x > cexp_ovfl, so exp(x) * s overflows for all s > 0
+     *  -  x = +-Inf (generated by exp())
+     *  -  x = NaN (spurious inexact exception from y)
+     */
+    exp_x = std::exp(x);
+    return (complex<float>(exp_x * std::cos(y), exp_x * std::sin(y)));
+  }
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> exp(const complex<float>& z)
+{
+  return detail::complex::cexpf(z);
+}
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,210 @@
+/*
+ *  Copyright 2008-2021 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.
+ */
+
+/*-
+ * Copyright (c) 2012 Stephen Montgomery-Smith <stephen@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSDs msun:*/
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+/* round down to 8 = 24/3 bits */
+_CCCL_HOST_DEVICE inline float trim(float x)
+{
+  uint32_t hx;
+  get_float_word(hx, x);
+  hx &= 0xffff0000;
+  float ret;
+  set_float_word(ret, hx);
+  return ret;
+}
+
+_CCCL_HOST_DEVICE inline complex<float> clogf(const complex<float>& z)
+{
+  // Adapted from FreeBSDs msun
+  float x, y;
+  float ax, ay;
+  float x0, y0, x1, y1, x2, y2, t, hm1;
+  float val[12];
+  int i, sorted;
+  const float e = 2.7182818284590452354f;
+
+  x = z.real();
+  y = z.imag();
+
+  /* Handle NaNs using the general formula to mix them right. */
+  if (x != x || y != y)
+  {
+    return (complex<float>(std::log(norm(z)), std::atan2(y, x)));
+  }
+
+  ax = std::abs(x);
+  ay = std::abs(y);
+  if (ax < ay)
+  {
+    t  = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  /*
+   * To avoid unnecessary overflow, if x and y are very large, divide x
+   * and y by M_E, and then add 1 to the logarithm.  This depends on
+   * M_E being larger than sqrt(2).
+   * There is a potential loss of accuracy caused by dividing by M_E,
+   * but this case should happen extremely rarely.
+   */
+  // For high values of ay -> hypotf(FLT_MAX,ay) = inf
+  // We expect that for values at or below ay = 1e34f this should not happen
+  if (ay > 1e34f)
+  {
+    return (complex<float>(std::log(hypotf(x / e, y / e)) + 1.0f, std::atan2(y, x)));
+  }
+  if (ax == 1.f)
+  {
+    if (ay < 1e-19f)
+    {
+      return (complex<float>((ay * 0.5f) * ay, std::atan2(y, x)));
+    }
+    return (complex<float>(log1pf(ay * ay) * 0.5f, std::atan2(y, x)));
+  }
+
+  /*
+   * Because atan2 and hypot conform to C99, this also covers all the
+   * edge cases when x or y are 0 or infinite.
+   */
+  if (ax < 1e-6f || ay < 1e-6f || ax > 1e6f || ay > 1e6f)
+  {
+    return (complex<float>(std::log(hypotf(x, y)), std::atan2(y, x)));
+  }
+
+  /*
+   * From this point on, we don't need to worry about underflow or
+   * overflow in calculating ax*ax or ay*ay.
+   */
+
+  /* Some easy cases. */
+
+  if (ax >= 1.0f)
+  {
+    return (complex<float>(log1pf((ax - 1.f) * (ax + 1.f) + ay * ay) * 0.5f, atan2(y, x)));
+  }
+
+  if (ax * ax + ay * ay <= 0.7f)
+  {
+    return (complex<float>(std::log(ax * ax + ay * ay) * 0.5f, std::atan2(y, x)));
+  }
+
+  /*
+   * Take extra care so that ULP of real part is small if hypot(x,y) is
+   * moderately close to 1.
+   */
+
+  x0 = trim(ax);
+  ax = ax - x0;
+  x1 = trim(ax);
+  x2 = ax - x1;
+  y0 = trim(ay);
+  ay = ay - y0;
+  y1 = trim(ay);
+  y2 = ay - y1;
+
+  val[0]  = x0 * x0;
+  val[1]  = y0 * y0;
+  val[2]  = 2 * x0 * x1;
+  val[3]  = 2 * y0 * y1;
+  val[4]  = x1 * x1;
+  val[5]  = y1 * y1;
+  val[6]  = 2 * x0 * x2;
+  val[7]  = 2 * y0 * y2;
+  val[8]  = 2 * x1 * x2;
+  val[9]  = 2 * y1 * y2;
+  val[10] = x2 * x2;
+  val[11] = y2 * y2;
+
+  /* Bubble sort. */
+
+  do
+  {
+    sorted = 1;
+    for (i = 0; i < 11; i++)
+    {
+      if (val[i] < val[i + 1])
+      {
+        sorted     = 0;
+        t          = val[i];
+        val[i]     = val[i + 1];
+        val[i + 1] = t;
+      }
+    }
+  } while (!sorted);
+
+  hm1 = -1;
+  for (i = 0; i < 12; i++)
+  {
+    hm1 += val[i];
+  }
+  return (complex<float>(0.5f * log1pf(hm1), atan2(y, x)));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> log(const complex<float>& z)
+{
+  return detail::complex::clogf(z);
+}
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,226 @@
+/*
+ *  Copyright 2008-2013 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.
+ */
+
+/*-
+ * Copyright (c) 2005 Bruce D. Evans and Steven G. Kargl
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_csinh.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/cexp.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+_CCCL_HOST_DEVICE inline complex<double> csinh(const complex<double>& z)
+{
+  double x, y, h;
+  uint32_t hx, hy, ix, iy, lx, ly;
+  const double huge = 8.98846567431157953864652595395e+307; // 0x1p1023;
+
+  x = z.real();
+  y = z.imag();
+
+  extract_words(hx, lx, x);
+  extract_words(hy, ly, y);
+
+  ix = 0x7fffffff & hx;
+  iy = 0x7fffffff & hy;
+
+  /* Handle the nearly-non-exceptional cases where x and y are finite. */
+  if (ix < 0x7ff00000 && iy < 0x7ff00000)
+  {
+    if ((iy | ly) == 0)
+    {
+      return (complex<double>(sinh(x), y));
+    }
+    if (ix < 0x40360000) /* small x: normal case */
+    {
+      return (complex<double>(sinh(x) * cos(y), cosh(x) * sin(y)));
+    }
+
+    /* |x| >= 22, so cosh(x) ~= exp(|x|) */
+    if (ix < 0x40862e42)
+    {
+      /* x < 710: exp(|x|) won't overflow */
+      h = exp(fabs(x)) * 0.5;
+      return (complex<double>(copysign(h, x) * cos(y), h * sin(y)));
+    }
+    else if (ix < 0x4096bbaa)
+    {
+      /* x < 1455: scale to avoid overflow */
+      complex<double> z_ = ldexp_cexp(complex<double>(fabs(x), y), -1);
+      return (complex<double>(z_.real() * copysign(1.0, x), z_.imag()));
+    }
+    else
+    {
+      /* x >= 1455: the result always overflows */
+      h = huge * x;
+      return (complex<double>(h * cos(y), h * h * sin(y)));
+    }
+  }
+
+  /*
+   * sinh(+-0 +- I Inf) = sign(d(+-0, dNaN))0 + I dNaN.
+   * The sign of 0 in the result is unspecified.  Choice = normally
+   * the same as dNaN.  Raise the invalid floating-point exception.
+   *
+   * sinh(+-0 +- I NaN) = sign(d(+-0, NaN))0 + I d(NaN).
+   * The sign of 0 in the result is unspecified.  Choice = normally
+   * the same as d(NaN).
+   */
+  if ((ix | lx) == 0 && iy >= 0x7ff00000)
+  {
+    return (complex<double>(copysign(0.0, x * (y - y)), y - y));
+  }
+
+  /*
+   * sinh(+-Inf +- I 0) = +-Inf + I +-0.
+   *
+   * sinh(NaN +- I 0)   = d(NaN) + I +-0.
+   */
+  if ((iy | ly) == 0 && ix >= 0x7ff00000)
+  {
+    if (((hx & 0xfffff) | lx) == 0)
+    {
+      return (complex<double>(x, y));
+    }
+    return (complex<double>(x, copysign(0.0, y)));
+  }
+
+  /*
+   * sinh(x +- I Inf) = dNaN + I dNaN.
+   * Raise the invalid floating-point exception for finite nonzero x.
+   *
+   * sinh(x + I NaN) = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception for finite
+   * nonzero x.  Choice = don't raise (except for signaling NaNs).
+   */
+  if (ix < 0x7ff00000 && iy >= 0x7ff00000)
+  {
+    return (complex<double>(y - y, x * (y - y)));
+  }
+
+  /*
+   * sinh(+-Inf + I NaN)  = +-Inf + I d(NaN).
+   * The sign of Inf in the result is unspecified.  Choice = normally
+   * the same as d(NaN).
+   *
+   * sinh(+-Inf +- I Inf) = +Inf + I dNaN.
+   * The sign of Inf in the result is unspecified.  Choice = always +.
+   * Raise the invalid floating-point exception.
+   *
+   * sinh(+-Inf + I y)   = +-Inf cos(y) + I Inf sin(y)
+   */
+  if (ix >= 0x7ff00000 && ((hx & 0xfffff) | lx) == 0)
+  {
+    if (iy >= 0x7ff00000)
+    {
+      return (complex<double>(x * x, x * (y - y)));
+    }
+    return (complex<double>(x * cos(y), infinity<double>() * sin(y)));
+  }
+
+  /*
+   * sinh(NaN + I NaN)  = d(NaN) + I d(NaN).
+   *
+   * sinh(NaN +- I Inf) = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception.
+   * Choice = raise.
+   *
+   * sinh(NaN + I y)    = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception for finite
+   * nonzero y.  Choice = don't raise (except for signaling NaNs).
+   */
+  return (complex<double>((x * x) * (y - y), (x + x) * (y - y)));
+}
+
+_CCCL_HOST_DEVICE inline complex<double> csin(complex<double> z)
+{
+  /* csin(z) = -I * csinh(I * z) */
+  z = csinh(complex<double>(-z.imag(), z.real()));
+  return (complex<double>(z.imag(), -z.real()));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> sin(const complex<ValueType>& z)
+{
+  const ValueType re = z.real();
+  const ValueType im = z.imag();
+  return complex<ValueType>(std::sin(re) * std::cosh(im), std::cos(re) * std::sinh(im));
+}
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> sinh(const complex<ValueType>& z)
+{
+  const ValueType re = z.real();
+  const ValueType im = z.imag();
+  return complex<ValueType>(std::sinh(re) * std::cos(im), std::cosh(re) * std::sin(im));
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> sin(const complex<double>& z)
+{
+  return detail::complex::csin(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> sinh(const complex<double>& z)
+{
+  return detail::complex::csinh(z);
+}
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,166 @@
+/*
+ *  Copyright 2008-2013 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.
+ */
+
+/*-
+ * Copyright (c) 2005 Bruce D. Evans and Steven G. Kargl
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_csinhf.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/cexp.h>
+#include <thrust/detail/complex/cexpf.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+_CCCL_HOST_DEVICE inline complex<float> csinhf(const complex<float>& z)
+{
+  float x, y, h;
+  uint32_t hx, hy, ix, iy;
+
+  const float huge = 1.70141183460469231731687303716e+38; // 0x1p127;
+
+  x = z.real();
+  y = z.imag();
+
+  get_float_word(hx, x);
+  get_float_word(hy, y);
+
+  ix = 0x7fffffff & hx;
+  iy = 0x7fffffff & hy;
+
+  if (ix < 0x7f800000 && iy < 0x7f800000)
+  {
+    if (iy == 0)
+    {
+      return (complex<float>(sinhf(x), y));
+    }
+    if (ix < 0x41100000) /* small x: normal case */
+    {
+      return (complex<float>(sinhf(x) * cosf(y), coshf(x) * sinf(y)));
+    }
+
+    /* |x| >= 9, so cosh(x) ~= exp(|x|) */
+    if (ix < 0x42b17218)
+    {
+      /* x < 88.7: expf(|x|) won't overflow */
+      h = expf(fabsf(x)) * 0.5f;
+      return (complex<float>(copysignf(h, x) * cosf(y), h * sinf(y)));
+    }
+    else if (ix < 0x4340b1e7)
+    {
+      /* x < 192.7: scale to avoid overflow */
+      complex<float> z_ = ldexp_cexpf(complex<float>(fabsf(x), y), -1);
+      return (complex<float>(z_.real() * copysignf(1.0f, x), z_.imag()));
+    }
+    else
+    {
+      /* x >= 192.7: the result always overflows */
+      h = huge * x;
+      return (complex<float>(h * cosf(y), h * h * sinf(y)));
+    }
+  }
+
+  if (ix == 0 && iy >= 0x7f800000)
+  {
+    return (complex<float>(copysignf(0, x * (y - y)), y - y));
+  }
+
+  if (iy == 0 && ix >= 0x7f800000)
+  {
+    if ((hx & 0x7fffff) == 0)
+    {
+      return (complex<float>(x, y));
+    }
+    return (complex<float>(x, copysignf(0.0f, y)));
+  }
+
+  if (ix < 0x7f800000 && iy >= 0x7f800000)
+  {
+    return (complex<float>(y - y, x * (y - y)));
+  }
+
+  if (ix >= 0x7f800000 && (hx & 0x7fffff) == 0)
+  {
+    if (iy >= 0x7f800000)
+    {
+      return (complex<float>(x * x, x * (y - y)));
+    }
+    return (complex<float>(x * cosf(y), infinity<float>() * sinf(y)));
+  }
+
+  return (complex<float>((x * x) * (y - y), (x + x) * (y - y)));
+}
+
+_CCCL_HOST_DEVICE inline complex<float> csinf(complex<float> z)
+{
+  z = csinhf(complex<float>(-z.imag(), z.real()));
+  return (complex<float>(z.imag(), -z.real()));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> sin(const complex<float>& z)
+{
+  return detail::complex::csinf(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> sinh(const complex<float>& z)
+{
+  return detail::complex::csinhf(z);
+}
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,208 @@
+/*
+ *  Copyright 2008-2013 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.
+ */
+
+/*-
+ * Copyright (c) 2011 David Schultz
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Adapted from FreeBSD by Filipe Maia <filipe.c.maia@gmail.com>:
+ *    freebsd/lib/msun/src/s_ctanh.c
+ */
+
+/*
+ * Hyperbolic tangent of a complex argument z = x + i y.
+ *
+ * The algorithm is from:
+ *
+ *   W. Kahan.  Branch Cuts for Complex Elementary Functions or Much
+ *   Ado About Nothing's Sign Bit.  In The State of the Art in
+ *   Numerical Analysis, pp. 165 ff.  Iserles and Powell, eds., 1987.
+ *
+ * Method:
+ *
+ *   Let t    = tan(x)
+ *       beta = 1/cos^2(y)
+ *       s    = sinh(x)
+ *       rho  = cosh(x)
+ *
+ *   We have:
+ *
+ *   tanh(z) = sinh(z) / cosh(z)
+ *
+ *             sinh(x) cos(y) + i cosh(x) sin(y)
+ *           = ---------------------------------
+ *             cosh(x) cos(y) + i sinh(x) sin(y)
+ *
+ *             cosh(x) sinh(x) / cos^2(y) + i tan(y)
+ *           = -------------------------------------
+ *                    1 + sinh^2(x) / cos^2(y)
+ *
+ *             beta rho s + i t
+ *           = ----------------
+ *               1 + beta s^2
+ *
+ * Modifications:
+ *
+ *   I omitted the original algorithm's handling of overflow in tan(x) after
+ *   verifying with nearpi.c that this can't happen in IEEE single or double
+ *   precision.  I also handle large x differently.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+_CCCL_HOST_DEVICE inline complex<double> ctanh(const complex<double>& z)
+{
+  double x, y;
+  double t, beta, s, rho, denom;
+  uint32_t hx, ix, lx;
+
+  x = z.real();
+  y = z.imag();
+
+  extract_words(hx, lx, x);
+  ix = hx & 0x7fffffff;
+
+  /*
+   * ctanh(NaN + i 0) = NaN + i 0
+   *
+   * ctanh(NaN + i y) = NaN + i NaN		for y != 0
+   *
+   * The imaginary part has the sign of x*sin(2*y), but there's no
+   * special effort to get this right.
+   *
+   * ctanh(+-Inf +- i Inf) = +-1 +- 0
+   *
+   * ctanh(+-Inf + i y) = +-1 + 0 sin(2y)		for y finite
+   *
+   * The imaginary part of the sign is unspecified.  This special
+   * case is only needed to avoid a spurious invalid exception when
+   * y is infinite.
+   */
+  if (ix >= 0x7ff00000)
+  {
+    if ((ix & 0xfffff) | lx) /* x is NaN */
+    {
+      return (complex<double>(x, (y == 0 ? y : x * y)));
+    }
+    set_high_word(x, hx - 0x40000000); /* x = copysign(1, x) */
+    return (complex<double>(x, copysign(0.0, isinf(y) ? y : sin(y) * cos(y))));
+  }
+
+  /*
+   * ctanh(x + i NAN) = NaN + i NaN
+   * ctanh(x +- i Inf) = NaN + i NaN
+   */
+  if (!isfinite(y))
+  {
+    return (complex<double>(y - y, y - y));
+  }
+
+  /*
+   * ctanh(+-huge + i +-y) ~= +-1 +- i 2sin(2y)/exp(2x), using the
+   * approximation sinh^2(huge) ~= exp(2*huge) / 4.
+   * We use a modified formula to avoid spurious overflow.
+   */
+  if (ix >= 0x40360000)
+  { /* x >= 22 */
+    double exp_mx = exp(-fabs(x));
+    return (complex<double>(copysign(1.0, x), 4.0 * sin(y) * cos(y) * exp_mx * exp_mx));
+  }
+
+  /* Kahan's algorithm */
+  t     = tan(y);
+  beta  = 1.0 + t * t; /* = 1 / cos^2(y) */
+  s     = sinh(x);
+  rho   = sqrt(1.0 + s * s); /* = cosh(x) */
+  denom = 1.0 + beta * s * s;
+  return (complex<double>((beta * rho * s) / denom, t / denom));
+}
+
+_CCCL_HOST_DEVICE inline complex<double> ctan(complex<double> z)
+{
+  /* ctan(z) = -I * ctanh(I * z) */
+  z = ctanh(complex<double>(-z.imag(), z.real()));
+  return (complex<double>(z.imag(), -z.real()));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> tan(const complex<ValueType>& z)
+{
+  return sin(z) / cos(z);
+}
+
+template <typename ValueType>
+_CCCL_HOST_DEVICE inline complex<ValueType> tanh(const complex<ValueType>& z)
+{
+  // This implementation seems better than the simple sin/cos
+  return (thrust::exp(ValueType(2) * z) - ValueType(1)) / (thrust::exp(ValueType(2) * z) + ValueType(1));
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> tan(const complex<double>& z)
+{
+  return detail::complex::ctan(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<double> tanh(const complex<double>& z)
+{
+  return detail::complex::ctanh(z);
+}
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,133 @@
+/*
+ *  Copyright 2008-2013 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.
+ */
+
+/*-
+ * Copyright (c) 2011 David Schultz
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Adapted from FreeBSD by Filipe Maia, filipe.c.maia@gmail.com:
+ *    freebsd/lib/msun/src/s_ctanhf.c
+ */
+
+/*
+ * Hyperbolic tangent of a complex argument z.  See ctanh.c for details.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+using thrust::complex;
+
+_CCCL_HOST_DEVICE inline complex<float> ctanhf(const complex<float>& z)
+{
+  float x, y;
+  float t, beta, s, rho, denom;
+  uint32_t hx, ix;
+
+  x = z.real();
+  y = z.imag();
+
+  get_float_word(hx, x);
+  ix = hx & 0x7fffffff;
+
+  if (ix >= 0x7f800000)
+  {
+    if (ix & 0x7fffff)
+    {
+      return (complex<float>(x, (y == 0.0f ? y : x * y)));
+    }
+    set_float_word(x, hx - 0x40000000);
+    return (complex<float>(x, copysignf(0, isinf(y) ? y : sinf(y) * cosf(y))));
+  }
+
+  if (!isfinite(y))
+  {
+    return (complex<float>(y - y, y - y));
+  }
+
+  if (ix >= 0x41300000)
+  { /* x >= 11 */
+    float exp_mx = expf(-fabsf(x));
+    return (complex<float>(copysignf(1.0f, x), 4.0f * sinf(y) * cosf(y) * exp_mx * exp_mx));
+  }
+
+  t     = tanf(y);
+  beta  = 1.0f + t * t;
+  s     = sinhf(x);
+  rho   = sqrtf(1.0f + s * s);
+  denom = 1.0f + beta * s * s;
+  return (complex<float>((beta * rho * s) / denom, t / denom));
+}
+
+_CCCL_HOST_DEVICE inline complex<float> ctanf(complex<float> z)
+{
+  z = ctanhf(complex<float>(-z.imag(), z.real()));
+  return (complex<float>(z.imag(), -z.real()));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> tan(const complex<float>& z)
+{
+  return detail::complex::ctanf(z);
+}
+
+template <>
+_CCCL_HOST_DEVICE inline complex<float> tanh(const complex<float>& z)
+{
+  return detail::complex::ctanhf(z);
+}
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,31 @@
+/*
+ *  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 config.h
+ *  \brief Defines platform configuration.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/config.h> // IWYU pragma: export
+#include <thrust/version.h> // IWYU pragma: export
+
+#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

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/compiler.h

@@ -0,0 +1,119 @@
+/*
+ *  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 compiler.h
+ *  \brief Compiler-specific configuration
+ */
+
+#pragma once
+
+// Internal config header that is only included through thrust/detail/config/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
+
+// enumerate host compilers we know about
+//! deprecated [Since 2.7]
+#define THRUST_HOST_COMPILER_UNKNOWN 0
+//! deprecated [Since 2.7]
+#define THRUST_HOST_COMPILER_MSVC 1
+//! deprecated [Since 2.7]
+#define THRUST_HOST_COMPILER_GCC 2
+//! deprecated [Since 2.7]
+#define THRUST_HOST_COMPILER_CLANG 3
+//! deprecated [Since 2.7]
+#define THRUST_HOST_COMPILER_INTEL 4
+
+// enumerate device compilers we know about
+//! deprecated [Since 2.7]
+#define THRUST_DEVICE_COMPILER_UNKNOWN 0
+//! deprecated [Since 2.7]
+#define THRUST_DEVICE_COMPILER_MSVC 1
+//! deprecated [Since 2.7]
+#define THRUST_DEVICE_COMPILER_GCC 2
+//! deprecated [Since 2.7]
+#define THRUST_DEVICE_COMPILER_CLANG 3
+//! deprecated [Since 2.7]
+#define THRUST_DEVICE_COMPILER_NVCC 4
+
+// figure out which host compiler we're using
+#if _CCCL_COMPILER(MSVC)
+//! deprecated [Since 2.7]
+#  define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_MSVC
+//! deprecated [Since 2.7]
+#  define THRUST_MSVC_VERSION _MSC_VER
+//! deprecated [Since 2.7]
+#  define THRUST_MSVC_VERSION_FULL _MSC_FULL_VER
+#elif _CCCL_COMPILER(ICC)
+//! deprecated [Since 2.7]
+#  define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_INTEL
+#elif _CCCL_COMPILER(CLANG)
+//! deprecated [Since 2.7]
+#  define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_CLANG
+//! deprecated [Since 2.7]
+#  define THRUST_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
+#elif _CCCL_COMPILER(GCC)
+//! deprecated [Since 2.7]
+#  define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_GCC
+//! deprecated [Since 2.7]
+#  define THRUST_GCC_VERSION   (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#  if _CCCL_COMPILER(GCC, >=, 5)
+//! deprecated [Since 2.7]
+#    define THRUST_MODERN_GCC
+#  else
+//! deprecated [Since 2.7]
+#    define THRUST_LEGACY_GCC
+#  endif
+#else
+//! deprecated [Since 2.7]
+#  define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_UNKNOWN
+#endif // TRUST_HOST_COMPILER
+
+// figure out which device compiler we're using
+#if defined(__CUDACC__) || defined(_NVHPC_CUDA)
+//! deprecated [Since 2.7]
+#  define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_NVCC
+#elif _CCCL_COMPILER(MSVC)
+//! deprecated [Since 2.7]
+#  define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_MSVC
+#elif _CCCL_COMPILER(GCC)
+//! deprecated [Since 2.7]
+#  define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_GCC
+#elif _CCCL_COMPILER(CLANG)
+// CUDA-capable clang should behave similar to NVCC.
+#  if defined(__CUDA__)
+//! deprecated [Since 2.7]
+#    define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_NVCC
+#  else
+//! deprecated [Since 2.7]
+#    define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_CLANG
+#  endif
+#else
+//! deprecated [Since 2.7]
+#  define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_UNKNOWN
+#endif
+
+// is the device compiler capable of compiling omp?
+#if defined(_OPENMP) || defined(_NVHPC_STDPAR_OPENMP)
+#  define THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE THRUST_TRUE
+#else
+#  define THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE THRUST_FALSE
+#endif // _OPENMP

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/compiler_fence.h

@@ -0,0 +1,79 @@
+/*
+ *  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.
+ */
+
+#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/preprocessor.h>
+
+#if _CCCL_COMPILER(MSVC)
+#  pragma message( \
+    "warning: The functionality in this header is unsafe, deprecated, and will soon be removed. Use C++11 atomics instead.")
+#else
+#warning The functionality in this header is unsafe, deprecated, and will soon be removed. Use C++11 or C11 atomics instead.
+#endif
+
+// msvc case
+#if _CCCL_COMPILER(MSVC)
+
+#  ifndef _DEBUG
+
+#    include <intrin.h>
+#    pragma intrinsic(_ReadWriteBarrier)
+#    define __thrust_compiler_fence() _ReadWriteBarrier()
+#  else
+
+#    define __thrust_compiler_fence() \
+      do                              \
+      {                               \
+      } while (0)
+
+#  endif // _DEBUG
+
+// gcc case
+#elif _CCCL_COMPILER(GCC)
+
+#  if _CCCL_COMPILER(GCC, >=, 4, 2) // atomic built-ins were introduced ~4.2
+#    define __thrust_compiler_fence() __sync_synchronize()
+#  else
+// allow the code to compile without any guarantees
+#    define __thrust_compiler_fence() \
+      do                              \
+      {                               \
+      } while (0)
+#  endif // _CCCL_COMPILER(GCC, >=, 4, 2)
+
+// unknown case
+#elif _CCCL_COMPILER(CLANG)
+#  define __thrust_compiler_fence() __sync_synchronize()
+#else
+
+// allow the code to compile without any guarantees
+#  define __thrust_compiler_fence() \
+    do                              \
+    {                               \
+    } while (0)
+
+#endif

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

@@ -0,0 +1,45 @@
+/*
+ *  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 config.h
+ *  \brief Defines platform configuration.
+ */
+
+#pragma once
+
+// For _CCCL_IMPLICIT_SYSTEM_HEADER
+#include <cuda/__cccl_config> // IWYU pragma: export
+
+#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
+
+// NOTE: The order of these #includes matters.
+
+#include <thrust/detail/config/compiler.h> // IWYU pragma: export
+#include <thrust/detail/config/cpp_compatibility.h> // IWYU pragma: export
+#include <thrust/detail/config/cpp_dialect.h> // IWYU pragma: export
+#include <thrust/detail/config/simple_defines.h> // IWYU pragma: export
+// host_system.h & device_system.h must be #included as early as possible because other config headers depend on it
+#include <thrust/detail/config/host_system.h> // IWYU pragma: export
+
+#include <thrust/detail/config/device_system.h> // IWYU pragma: export
+#include <thrust/detail/config/global_workarounds.h> // IWYU pragma: export
+#include <thrust/detail/config/namespace.h> // IWYU pragma: export

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/cpp_compatibility.h

@@ -0,0 +1,61 @@
+/*
+ *  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.
+ */
+
+#pragma once
+
+// Internal config header that is only included through thrust/detail/config/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
+
+// deprecated [Since 2.8.0]
+#define THRUST_NODISCARD _CCCL_NODISCARD
+// deprecated [Since 2.8.0]
+#define THRUST_INLINE_CONSTANT _CCCL_GLOBAL_CONSTANT
+// deprecated [Since 2.8.0]
+#define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static constexpr
+
+// These definitions were intended for internal use only and are now obsolete.
+// If you relied on them, consider porting your code to use the functionality
+// in libcu++'s <nv/target> header.
+// For a temporary workaround, define THRUST_PROVIDE_LEGACY_ARCH_MACROS to make
+// them available again. These should be considered deprecated and will be
+// fully removed in a future version.
+#ifdef THRUST_PROVIDE_LEGACY_ARCH_MACROS
+#  ifndef THRUST_IS_DEVICE_CODE
+#    if defined(_NVHPC_CUDA)
+#      define THRUST_IS_DEVICE_CODE      __builtin_is_device_code()
+#      define THRUST_IS_HOST_CODE        (!__builtin_is_device_code())
+#      define THRUST_INCLUDE_DEVICE_CODE 1
+#      define THRUST_INCLUDE_HOST_CODE   1
+#    elif defined(__CUDA_ARCH__)
+#      define THRUST_IS_DEVICE_CODE      1
+#      define THRUST_IS_HOST_CODE        0
+#      define THRUST_INCLUDE_DEVICE_CODE 1
+#      define THRUST_INCLUDE_HOST_CODE   0
+#    else
+#      define THRUST_IS_DEVICE_CODE      0
+#      define THRUST_IS_HOST_CODE        1
+#      define THRUST_INCLUDE_DEVICE_CODE 0
+#      define THRUST_INCLUDE_HOST_CODE   1
+#    endif
+#  endif
+#endif // THRUST_PROVIDE_LEGACY_ARCH_MACROS

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/cpp_dialect.h

@@ -0,0 +1,100 @@
+/*
+ *  Copyright 2020 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 cpp_dialect.h
+ *  \brief Detect the version of the C++ standard used by the compiler.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/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/config/compiler.h> // IWYU pragma: export
+
+// Deprecation warnings may be silenced by defining the following macros. These
+// may be combined.
+// - CCCL_IGNORE_DEPRECATED_CPP_DIALECT:
+//   Ignore all deprecated C++ dialects and outdated compilers.
+// - CCCL_IGNORE_DEPRECATED_CPP_11:
+//   Ignore deprecation warnings when compiling with C++11. C++03 and outdated
+//   compilers will still issue warnings.
+// - CCCL_IGNORE_DEPRECATED_CPP_14:
+//   Ignore deprecation warnings when compiling with C++14. C++03 and outdated
+//   compilers will still issue warnings.
+// - CCCL_IGNORE_DEPRECATED_COMPILER
+//   Ignore deprecation warnings when using deprecated compilers. Compiling
+//   with C++03, C++11 and C++14 will still issue warnings.
+
+#define THRUST_CPP_DIALECT _CCCL_STD_VER
+
+// Define THRUST_COMPILER_DEPRECATION macro:
+#if _CCCL_COMPILER(MSVC) || _CCCL_COMPILER(NVRTC)
+#  define THRUST_COMP_DEPR_IMPL(msg) _CCCL_PRAGMA(message(__FILE__ ":" _CCCL_TO_STRING(__LINE__) ": warning: " #msg))
+#else // clang / gcc:
+#  define THRUST_COMP_DEPR_IMPL(msg) _CCCL_PRAGMA(GCC warning #msg)
+#endif
+
+// clang-format off
+#define THRUST_COMPILER_DEPRECATION(REQ) \
+  THRUST_COMP_DEPR_IMPL(Thrust requires at least REQ. Define CCCL_IGNORE_DEPRECATED_COMPILER to suppress this message.)
+
+#define THRUST_COMPILER_DEPRECATION_SOFT(REQ, CUR)                                                        \
+  THRUST_COMP_DEPR_IMPL(                                                                                  \
+    Thrust requires at least REQ. CUR is deprecated but still supported. CUR support will be removed in a \
+      future release. Define CCCL_IGNORE_DEPRECATED_CPP_DIALECT to suppress this message.)
+// clang-format on
+
+#ifndef CCCL_IGNORE_DEPRECATED_COMPILER
+
+// Compiler checks:
+#  if _CCCL_COMPILER(GCC, <, 5)
+THRUST_COMPILER_DEPRECATION(GCC 5.0);
+#  elif _CCCL_COMPILER(CLANG, <, 7)
+THRUST_COMPILER_DEPRECATION(Clang 7.0);
+#  elif _CCCL_COMPILER(MSVC, <, 19, 10)
+// <2017. Hard upgrade message:
+THRUST_COMPILER_DEPRECATION(MSVC 2019(19.20 / 16.0 / 14.20));
+#  elif _CCCL_COMPILER(MSVC2017)
+// >=2017, <2019. Soft deprecation message:
+THRUST_COMPILER_DEPRECATION_SOFT(MSVC 2019(19.20 / 16.0 / 14.20), MSVC 2017);
+#  endif
+
+#endif // CCCL_IGNORE_DEPRECATED_COMPILER
+
+#if _CCCL_STD_VER < 2011
+// <C++11. Hard upgrade message:
+THRUST_COMPILER_DEPRECATION(C++ 17);
+#elif _CCCL_STD_VER == 2011 && !defined(CCCL_IGNORE_DEPRECATED_CPP_11)
+// =C++11. Soft upgrade message:
+THRUST_COMPILER_DEPRECATION_SOFT(C++ 17, C++ 11);
+#elif _CCCL_STD_VER == 2014 && !defined(CCCL_IGNORE_DEPRECATED_CPP_14)
+// =C++14. Soft upgrade message:
+THRUST_COMPILER_DEPRECATION_SOFT(C++ 17, C++ 14);
+#endif // _CCCL_STD_VER >= 2017
+
+#undef THRUST_COMPILER_DEPRECATION_SOFT
+#undef THRUST_COMPILER_DEPRECATION
+#undef THRUST_COMP_DEPR_IMPL
+#undef THRUST_COMP_DEPR_IMPL0
+#undef THRUST_COMP_DEPR_IMPL1

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/device_system.h

@@ -0,0 +1,55 @@
+/*
+ *  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.
+ */
+
+#pragma once
+
+// Internal config header that is only included through thrust/detail/config/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
+
+// reserve 0 for undefined
+#define THRUST_DEVICE_SYSTEM_CUDA 1
+#define THRUST_DEVICE_SYSTEM_OMP  2
+#define THRUST_DEVICE_SYSTEM_TBB  3
+#define THRUST_DEVICE_SYSTEM_CPP  4
+
+#ifndef THRUST_DEVICE_SYSTEM
+#  define THRUST_DEVICE_SYSTEM THRUST_DEVICE_SYSTEM_CUDA
+#endif // THRUST_DEVICE_SYSTEM
+
+#ifdef THRUST_DEVICE_BACKEND
+#  error THRUST_DEVICE_BACKEND is no longer supported; use THRUST_DEVICE_SYSTEM instead.
+#endif // THRUST_DEVICE_BACKEND
+
+#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+#  define __THRUST_DEVICE_SYSTEM_NAMESPACE cuda
+#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_OMP
+#  define __THRUST_DEVICE_SYSTEM_NAMESPACE omp
+#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_TBB
+#  define __THRUST_DEVICE_SYSTEM_NAMESPACE tbb
+#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CPP
+#  define __THRUST_DEVICE_SYSTEM_NAMESPACE cpp
+#endif
+
+// clang-format off
+#define __THRUST_DEVICE_SYSTEM_ROOT thrust/system/__THRUST_DEVICE_SYSTEM_NAMESPACE
+// clang-format on

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/global_workarounds.h

@@ -0,0 +1,36 @@
+/*
+ *  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.
+ */
+
+#pragma once
+
+// Internal config header that is only included through thrust/detail/config/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/config/compiler.h>
+
+// XXX workaround gcc 4.8+'s complaints about unused local aliases by silencing them globally
+#if _CCCL_COMPILER(GCC, >=, 4, 8)
+#  if defined(__NVCC__) && (CUDART_VERSION >= 6000)
+#    pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#  endif // nvcc & cuda 6+
+#endif // gcc 4.8

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/host_system.h

@@ -0,0 +1,52 @@
+/*
+ *  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.
+ */
+
+#pragma once
+
+// Internal config header that is only included through thrust/detail/config/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
+
+// reserve 0 for undefined
+#define THRUST_HOST_SYSTEM_CPP 1
+#define THRUST_HOST_SYSTEM_OMP 2
+#define THRUST_HOST_SYSTEM_TBB 3
+
+#ifndef THRUST_HOST_SYSTEM
+#  define THRUST_HOST_SYSTEM THRUST_HOST_SYSTEM_CPP
+#endif // THRUST_HOST_SYSTEM
+
+#ifdef THRUST_HOST_BACKEND
+#  error THRUST_HOST_BACKEND is no longer supported; use THRUST_HOST_SYSTEM instead.
+#endif // THRUST_HOST_BACKEND
+
+#if THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_CPP
+#  define __THRUST_HOST_SYSTEM_NAMESPACE cpp
+#elif THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_OMP
+#  define __THRUST_HOST_SYSTEM_NAMESPACE omp
+#elif THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_TBB
+#  define __THRUST_HOST_SYSTEM_NAMESPACE tbb
+#endif
+
+// clang-format off
+#define __THRUST_HOST_SYSTEM_ROOT thrust/system/__THRUST_HOST_SYSTEM_NAMESPACE
+// clang-format on

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/memory_resource.h

@@ -0,0 +1,44 @@
+/*
+ *  Copyright 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.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/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/alignment.h>
+#include <thrust/detail/config/cpp_compatibility.h>
+
+#include <cstddef>
+
+#define THRUST_MR_DEFAULT_ALIGNMENT alignof(THRUST_NS_QUALIFIER::detail::max_align_t)
+
+#if _CCCL_STD_VER >= 2017
+#  if _CCCL_HAS_INCLUDE(<memory_resource>)
+#    define THRUST_MR_STD_MR_HEADER <memory_resource>
+#    define THRUST_MR_STD_MR_NS     std::pmr
+#  elif _CCCL_HAS_INCLUDE(<experimental/memory_resource>)
+#    define THRUST_MR_STD_MR_HEADER <experimental/memory_resource>
+#    define THRUST_MR_STD_MR_NS     std::experimental::pmr
+#  endif
+#endif

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/namespace.h

@@ -0,0 +1,162 @@
+/*
+ *  Copyright 2021 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.
+ */
+
+#pragma once
+
+// Internal config header that is only included through thrust/detail/config/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/config/device_system.h>
+#include <thrust/version.h>
+
+/**
+ * \file namespace.h
+ * \brief Utilities that allow `thrust::` to be placed inside an
+ * application-specific namespace.
+ */
+
+/**
+ * \def THRUST_CUB_WRAPPED_NAMESPACE
+ * If defined, this value will be used as the name of a namespace that wraps the
+ * `thrust::` and `cub::` namespaces.
+ * This macro should not be used with any other Thrust namespace macros.
+ */
+#ifdef THRUST_CUB_WRAPPED_NAMESPACE
+#  define THRUST_WRAPPED_NAMESPACE THRUST_CUB_WRAPPED_NAMESPACE
+#endif
+
+/**
+ * \def THRUST_WRAPPED_NAMESPACE
+ * If defined, this value will be used as the name of a namespace that wraps the
+ * `thrust::` namespace.
+ * If THRUST_CUB_WRAPPED_NAMESPACE is set, this will inherit that macro's value.
+ * This macro should not be used with any other Thrust namespace macros.
+ */
+#ifdef THRUST_WRAPPED_NAMESPACE
+#  define THRUST_NS_PREFIX             \
+    namespace THRUST_WRAPPED_NAMESPACE \
+    {
+
+#  define THRUST_NS_POSTFIX }
+
+#  define THRUST_NS_QUALIFIER ::THRUST_WRAPPED_NAMESPACE::thrust
+#endif
+
+/**
+ * \def THRUST_NS_PREFIX
+ * This macro is inserted prior to all `namespace thrust { ... }` blocks. It is
+ * derived from THRUST_WRAPPED_NAMESPACE, if set, and will be empty otherwise.
+ * It may be defined by users, in which case THRUST_NS_PREFIX,
+ * THRUST_NS_POSTFIX, and THRUST_NS_QUALIFIER must all be set consistently.
+ */
+#ifndef THRUST_NS_PREFIX
+#  define THRUST_NS_PREFIX
+#endif
+
+/**
+ * \def THRUST_NS_POSTFIX
+ * This macro is inserted following the closing braces of all
+ * `namespace thrust { ... }` block. It is defined appropriately when
+ * THRUST_WRAPPED_NAMESPACE is set, and will be empty otherwise. It may be
+ * defined by users, in which case THRUST_NS_PREFIX, THRUST_NS_POSTFIX, and
+ * THRUST_NS_QUALIFIER must all be set consistently.
+ */
+#ifndef THRUST_NS_POSTFIX
+#  define THRUST_NS_POSTFIX
+#endif
+
+/**
+ * \def THRUST_NS_QUALIFIER
+ * This macro is used to qualify members of thrust:: when accessing them from
+ * outside of their namespace. By default, this is just `::thrust`, and will be
+ * set appropriately when THRUST_WRAPPED_NAMESPACE is defined. This macro may be
+ * defined by users, in which case THRUST_NS_PREFIX, THRUST_NS_POSTFIX, and
+ * THRUST_NS_QUALIFIER must all be set consistently.
+ */
+#ifndef THRUST_NS_QUALIFIER
+#  define THRUST_NS_QUALIFIER ::thrust
+#endif
+
+#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+#  if defined(THRUST_DISABLE_ABI_NAMESPACE) || defined(THRUST_WRAPPED_NAMESPACE)
+#    if !defined(THRUST_WRAPPED_NAMESPACE)
+#      if !defined(THRUST_IGNORE_ABI_NAMESPACE_ERROR)
+#        error "Disabling ABI namespace is unsafe without wrapping namespace"
+#      endif // !defined(THRUST_IGNORE_ABI_NAMESPACE_ERROR)
+#    endif // !defined(THRUST_WRAPPED_NAMESPACE)
+#    define THRUST_DETAIL_ABI_NS_BEGIN
+#    define THRUST_DETAIL_ABI_NS_END
+#  else // not defined(THRUST_DISABLE_ABI_NAMESPACE)
+#    if defined(_NVHPC_CUDA)
+#      define THRUST_DETAIL_ABI_NS_BEGIN                                                                           \
+        inline namespace _CCCL_PP_SPLICE_WITH(_, THRUST, THRUST_VERSION, SM, NV_TARGET_SM_INTEGER_LIST, NVHPC, NS) \
+        {
+#      define THRUST_DETAIL_ABI_NS_END }
+#    else // not defined(_NVHPC_CUDA)
+#      define THRUST_DETAIL_ABI_NS_BEGIN                                                             \
+        inline namespace _CCCL_PP_SPLICE_WITH(_, THRUST, THRUST_VERSION, SM, __CUDA_ARCH_LIST__, NS) \
+        {
+#      define THRUST_DETAIL_ABI_NS_END }
+#    endif // not defined(_NVHPC_CUDA)
+#  endif // not defined(THRUST_DISABLE_ABI_NAMESPACE)
+#else // THRUST_DEVICE_SYSTEM != THRUST_DEVICE_SYSTEM_CUDA
+#  define THRUST_DETAIL_ABI_NS_BEGIN
+#  define THRUST_DETAIL_ABI_NS_END
+#endif // THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+
+/**
+ * \def THRUST_NAMESPACE_BEGIN
+ * This macro is used to open a `thrust::` namespace block, along with any
+ * enclosing namespaces requested by THRUST_WRAPPED_NAMESPACE, etc.
+ * This macro is defined by Thrust and may not be overridden.
+ */
+#define THRUST_NAMESPACE_BEGIN \
+  THRUST_NS_PREFIX             \
+  namespace thrust             \
+  {                            \
+  THRUST_DETAIL_ABI_NS_BEGIN
+
+/**
+ * \def THRUST_NAMESPACE_END
+ * This macro is used to close a `thrust::` namespace block, along with any
+ * enclosing namespaces requested by THRUST_WRAPPED_NAMESPACE, etc.
+ * This macro is defined by Thrust and may not be overridden.
+ */
+#define THRUST_NAMESPACE_END   \
+  THRUST_DETAIL_ABI_NS_END     \
+  } /* end namespace thrust */ \
+  THRUST_NS_POSTFIX
+
+// The following is just here to add docs for the thrust namespace:
+
+THRUST_NS_PREFIX
+
+/*! \namespace thrust
+ *  \brief \p thrust is the top-level namespace which contains all Thrust
+ *         functions and types.
+ */
+namespace thrust
+{
+}
+
+THRUST_NS_POSTFIX

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/config/simple_defines.h

@@ -0,0 +1,43 @@
+/*
+ *  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 simple_defines.h
+ *  \brief Primitive macros without dependencies.
+ */
+
+#pragma once
+
+// Internal config header that is only included through thrust/detail/config/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
+
+#define THRUST_UNKNOWN 0
+#define THRUST_FALSE   0
+#define THRUST_TRUE    1
+
+#define THRUST_UNUSED_VAR(expr) \
+  do                            \
+  {                             \
+    (void) (expr);              \
+  } while (0)
+
+#define THRUST_PREVENT_MACRO_SUBSTITUTION

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy.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.
+ */
+
+#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
+
+template <typename System, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator
+copy(const thrust::detail::execution_policy_base<System>& system,
+     InputIterator first,
+     InputIterator last,
+     OutputIterator result);
+
+template <typename System, typename InputIterator, typename Size, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator
+copy_n(const thrust::detail::execution_policy_base<System>& system, InputIterator first, Size n, OutputIterator result);
+
+template <typename InputIterator, typename OutputIterator>
+OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);
+
+template <typename InputIterator, typename Size, typename OutputIterator>
+OutputIterator copy_n(InputIterator first, Size n, OutputIterator result);
+
+namespace detail
+{
+
+template <typename FromSystem, typename ToSystem, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator two_system_copy(
+  const thrust::execution_policy<FromSystem>& from_system,
+  const thrust::execution_policy<ToSystem>& two_system,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result);
+
+template <typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator two_system_copy_n(
+  const thrust::execution_policy<FromSystem>& from_system,
+  const thrust::execution_policy<ToSystem>& two_system,
+  InputIterator first,
+  Size n,
+  OutputIterator result);
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/copy.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy.inl

@@ -0,0 +1,123 @@
+/*
+ *  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.
+ */
+
+#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/copy.h>
+#include <thrust/system/detail/adl/copy.h>
+#include <thrust/system/detail/generic/copy.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator
+copy(const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+     InputIterator first,
+     InputIterator last,
+     OutputIterator result)
+{
+  using thrust::system::detail::generic::copy;
+  return copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result);
+} // end copy()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename Size, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator copy_n(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, InputIterator first, Size n, OutputIterator result)
+{
+  using thrust::system::detail::generic::copy_n;
+  return copy_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, result);
+} // end copy_n()
+
+namespace detail
+{
+
+_CCCL_EXEC_CHECK_DISABLE // because we might call e.g. std::ostream_iterator's constructor
+template <typename System1, typename System2, typename InputIterator, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator two_system_copy(
+  const thrust::execution_policy<System1>& system1,
+  const thrust::execution_policy<System2>& system2,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  return thrust::copy(
+    select_system(thrust::detail::derived_cast(thrust::detail::strip_const(system1)),
+                  thrust::detail::derived_cast(thrust::detail::strip_const(system2))),
+    first,
+    last,
+    result);
+} // end two_system_copy()
+
+_CCCL_EXEC_CHECK_DISABLE // because we might call e.g. std::ostream_iterator's constructor
+template <typename System1, typename System2, typename InputIterator, typename Size, typename OutputIterator>
+_CCCL_HOST_DEVICE OutputIterator two_system_copy_n(
+  const thrust::execution_policy<System1>& system1,
+  const thrust::execution_policy<System2>& system2,
+  InputIterator first,
+  Size n,
+  OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  return thrust::copy_n(
+    select_system(thrust::detail::derived_cast(thrust::detail::strip_const(system1)),
+                  thrust::detail::derived_cast(thrust::detail::strip_const(system2))),
+    first,
+    n,
+    result);
+} // end two_system_copy_n()
+
+} // namespace detail
+
+template <typename InputIterator, typename OutputIterator>
+OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result)
+{
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::detail::two_system_copy(system1, system2, first, last, result);
+} // end copy()
+
+template <typename InputIterator, typename Size, typename OutputIterator>
+OutputIterator copy_n(InputIterator first, Size n, OutputIterator result)
+{
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::detail::two_system_copy_n(system1, system2, first, n, result);
+} // end copy_n()
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,62 @@
+/*
+ *  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.
+ */
+
+#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
+
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate>
+_CCCL_HOST_DEVICE OutputIterator copy_if(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result,
+  Predicate pred);
+
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator,
+          typename Predicate>
+_CCCL_HOST_DEVICE OutputIterator copy_if(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator1 first,
+  InputIterator1 last,
+  InputIterator2 stencil,
+  OutputIterator result,
+  Predicate pred);
+
+template <typename InputIterator, typename OutputIterator, typename Predicate>
+OutputIterator copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
+
+template <typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+OutputIterator
+copy_if(InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/copy_if.inl>

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/copy_if.inl

@@ -0,0 +1,98 @@
+/*
+ *  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.
+ */
+
+#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/copy_if.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/adl/copy_if.h>
+#include <thrust/system/detail/generic/copy_if.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate>
+_CCCL_HOST_DEVICE OutputIterator copy_if(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result,
+  Predicate pred)
+{
+  using thrust::system::detail::generic::copy_if;
+  return copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, pred);
+} // end copy_if()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator,
+          typename Predicate>
+_CCCL_HOST_DEVICE OutputIterator copy_if(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+  InputIterator1 first,
+  InputIterator1 last,
+  InputIterator2 stencil,
+  OutputIterator result,
+  Predicate pred)
+{
+  using thrust::system::detail::generic::copy_if;
+  return copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, result, pred);
+} // end copy_if()
+
+template <typename InputIterator, typename OutputIterator, typename Predicate>
+OutputIterator copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System1 = typename thrust::iterator_system<InputIterator>::type;
+  using System2 = typename thrust::iterator_system<OutputIterator>::type;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::copy_if(select_system(system1, system2), first, last, result, pred);
+} // end copy_if()
+
+template <typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+OutputIterator
+copy_if(InputIterator1 first, InputIterator1 last, InputIterator2 stencil, OutputIterator result, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System1 = typename thrust::iterator_system<InputIterator1>::type;
+  using System2 = typename thrust::iterator_system<InputIterator2>::type;
+  using System3 = typename thrust::iterator_system<OutputIterator>::type;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::copy_if(select_system(system1, system2, system3), first, last, stencil, result, pred);
+} // end copy_if()
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,56 @@
+/*
+ *  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.
+ */
+
+#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
+
+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);
+
+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);
+
+template <typename InputIterator, typename EqualityComparable>
+typename thrust::iterator_traits<InputIterator>::difference_type
+count(InputIterator first, InputIterator last, const EqualityComparable& value);
+
+template <typename InputIterator, typename Predicate>
+typename thrust::iterator_traits<InputIterator>::difference_type
+count_if(InputIterator first, InputIterator last, Predicate pred);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/count.inl>

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

@@ -0,0 +1,85 @@
+/*
+ *  Copyright 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.
+ */
+
+#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_dependencies.h>
+
+#include <tuple>
+
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <template <typename> class ExecutionPolicyCRTPBase>
+struct CCCL_DEPRECATED dependencies_aware_execution_policy
+{
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  after(Dependencies&&... dependencies) const
+  {
+    return {capture_as_dependency(THRUST_FWD(dependencies))...};
+  }
+
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  after(std::tuple<Dependencies...>& dependencies) const
+  {
+    return {capture_as_dependency(dependencies)};
+  }
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  after(std::tuple<Dependencies...>&& dependencies) const
+  {
+    return {capture_as_dependency(std::move(dependencies))};
+  }
+
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  rebind_after(Dependencies&&... dependencies) const
+  {
+    return {capture_as_dependency(THRUST_FWD(dependencies))...};
+  }
+
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  rebind_after(std::tuple<Dependencies...>& dependencies) const
+  {
+    return {capture_as_dependency(dependencies)};
+  }
+  template <typename... Dependencies>
+  _CCCL_HOST thrust::detail::execute_with_dependencies<ExecutionPolicyCRTPBase, Dependencies...>
+  rebind_after(std::tuple<Dependencies...>&& dependencies) const
+  {
+    return {capture_as_dependency(std::move(dependencies))};
+  }
+};
+
+} // namespace detail
+
+_CCCL_SUPPRESS_DEPRECATED_POP
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,60 @@
+/*
+ *  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.
+ */
+
+#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/malloc_and_free.h>
+#include <thrust/device_malloc.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+thrust::device_ptr<void> device_malloc(const std::size_t n)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using system = thrust::iterator_system<thrust::device_ptr<void>>::type;
+
+  // XXX lower to select_system(system) here
+  system s;
+
+  return thrust::device_ptr<void>(thrust::malloc(s, n).get());
+} // end device_malloc()
+
+template <typename T>
+thrust::device_ptr<T> device_malloc(const std::size_t n)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using system = thrust::iterator_system<thrust::device_ptr<void>>::type;
+
+  // XXX lower to select_system(system) here
+  system s;
+
+  return thrust::device_ptr<T>(thrust::malloc<T>(s, n).get());
+} // end device_malloc()
+
+THRUST_NAMESPACE_END

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/thrust/thrust/detail/distance.inl

@@ -0,0 +1,43 @@
+/*
+ *  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.
+ */
+
+#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/advance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename InputIterator>
+inline _CCCL_HOST_DEVICE typename thrust::iterator_traits<InputIterator>::difference_type
+distance(InputIterator first, InputIterator last)
+{
+  return thrust::system::detail::generic::distance(first, last);
+} // end distance()
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,122 @@
+/*
+ *  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.
+ */
+
+#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/execute_with_allocator_fwd.h>
+#include <thrust/detail/integer_math.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <typename T, typename Allocator, template <typename> class BaseSystem>
+_CCCL_HOST thrust::pair<T*, std::ptrdiff_t>
+get_temporary_buffer(thrust::detail::execute_with_allocator<Allocator, BaseSystem>& system, std::ptrdiff_t n)
+{
+  using naked_allocator = ::cuda::std::remove_reference_t<Allocator>;
+  using alloc_traits    = typename thrust::detail::allocator_traits<naked_allocator>;
+  using void_pointer    = typename alloc_traits::void_pointer;
+  using size_type       = typename alloc_traits::size_type;
+  using value_type      = typename alloc_traits::value_type;
+
+  // How many elements of type value_type do we need to accommodate n elements
+  // of type T?
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  void_pointer ptr = alloc_traits::allocate(system.get_allocator(), num_elements);
+
+  // Return the pointer and the number of elements of type T allocated.
+  return thrust::make_pair(thrust::reinterpret_pointer_cast<T*>(ptr), n);
+}
+
+template <typename Pointer, typename Allocator, template <typename> class BaseSystem>
+_CCCL_HOST void return_temporary_buffer(
+  thrust::detail::execute_with_allocator<Allocator, BaseSystem>& system, Pointer p, std::ptrdiff_t n)
+{
+  using naked_allocator = ::cuda::std::remove_reference_t<Allocator>;
+  using alloc_traits    = typename thrust::detail::allocator_traits<naked_allocator>;
+  using pointer         = typename alloc_traits::pointer;
+  using size_type       = typename alloc_traits::size_type;
+  using value_type      = typename alloc_traits::value_type;
+  using T               = typename thrust::detail::pointer_traits<Pointer>::element_type;
+
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  pointer to_ptr = thrust::reinterpret_pointer_cast<pointer>(p);
+  alloc_traits::deallocate(system.get_allocator(), to_ptr, num_elements);
+}
+
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+template <typename T, template <typename> class BaseSystem, typename Allocator, typename... Dependencies>
+CCCL_DEPRECATED _CCCL_HOST thrust::pair<T*, std::ptrdiff_t> get_temporary_buffer(
+  thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>& system,
+  std::ptrdiff_t n)
+{
+  using naked_allocator = ::cuda::std::remove_reference_t<Allocator>;
+  using alloc_traits    = typename thrust::detail::allocator_traits<naked_allocator>;
+  using void_pointer    = typename alloc_traits::void_pointer;
+  using size_type       = typename alloc_traits::size_type;
+  using value_type      = typename alloc_traits::value_type;
+
+  // How many elements of type value_type do we need to accommodate n elements
+  // of type T?
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  void_pointer ptr = alloc_traits::allocate(system.get_allocator(), num_elements);
+
+  // Return the pointer and the number of elements of type T allocated.
+  return thrust::make_pair(thrust::reinterpret_pointer_cast<T*>(ptr), n);
+}
+
+template <typename Pointer, template <typename> class BaseSystem, typename Allocator, typename... Dependencies>
+_CCCL_HOST void return_temporary_buffer(
+  thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>& system,
+  Pointer p,
+  std::ptrdiff_t n)
+{
+  using naked_allocator = ::cuda::std::remove_reference_t<Allocator>;
+  using alloc_traits    = typename thrust::detail::allocator_traits<naked_allocator>;
+  using pointer         = typename alloc_traits::pointer;
+  using size_type       = typename alloc_traits::size_type;
+  using value_type      = typename alloc_traits::value_type;
+  using T               = typename thrust::detail::pointer_traits<Pointer>::element_type;
+
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  pointer to_ptr = thrust::reinterpret_pointer_cast<pointer>(p);
+  alloc_traits::deallocate(system.get_allocator(), to_ptr, num_elements);
+}
+_CCCL_SUPPRESS_DEPRECATED_POP
+
+} // namespace detail
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,172 @@
+/*
+ *  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.
+ */
+
+#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/extrema.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/adl/extrema.h>
+#include <thrust/system/detail/generic/extrema.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator>
+_CCCL_HOST_DEVICE ForwardIterator min_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::min_element;
+  return min_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end min_element()
+
+_CCCL_EXEC_CHECK_DISABLE
+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)
+{
+  using thrust::system::detail::generic::min_element;
+  return min_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end min_element()
+
+_CCCL_EXEC_CHECK_DISABLE
+template <typename DerivedPolicy, typename ForwardIterator>
+_CCCL_HOST_DEVICE ForwardIterator max_element(
+  const thrust::detail::execution_policy_base<DerivedPolicy>& exec, ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::max_element;
+  return max_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end max_element()
+
+_CCCL_EXEC_CHECK_DISABLE
+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)
+{
+  using thrust::system::detail::generic::max_element;
+  return max_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end max_element()
+
+_CCCL_EXEC_CHECK_DISABLE
+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)
+{
+  using thrust::system::detail::generic::minmax_element;
+  return minmax_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end minmax_element()
+
+_CCCL_EXEC_CHECK_DISABLE
+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)
+{
+  using thrust::system::detail::generic::minmax_element;
+  return minmax_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end minmax_element()
+
+template <typename ForwardIterator>
+ForwardIterator min_element(ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::min_element(select_system(system), first, last);
+} // end min_element()
+
+template <typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator min_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::min_element(select_system(system), first, last, comp);
+} // end min_element()
+
+template <typename ForwardIterator>
+ForwardIterator max_element(ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::max_element(select_system(system), first, last);
+} // end max_element()
+
+template <typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator max_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::max_element(select_system(system), first, last, comp);
+} // end max_element()
+
+template <typename ForwardIterator>
+thrust::pair<ForwardIterator, ForwardIterator> minmax_element(ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::minmax_element(select_system(system), first, last);
+} // end minmax_element()
+
+template <typename ForwardIterator, typename BinaryPredicate>
+thrust::pair<ForwardIterator, ForwardIterator>
+minmax_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  using System = typename thrust::iterator_system<ForwardIterator>::type;
+
+  System system;
+
+  return thrust::minmax_element(select_system(system), first, last, comp);
+} // end minmax_element()
+
+THRUST_NAMESPACE_END