Add files using upload-large-folder tool

.gitattributes

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

vllm/lib/python3.10/site-packages/cupy/_core/_fusion_kernel.cpython-310-x86_64-linux-gnu.so

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

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

@@ -0,0 +1,158 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA__MEMORY_RESOURCE_GET_PROPERTY_H
+#define _CUDA__MEMORY_RESOURCE_GET_PROPERTY_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if !_CCCL_COMPILER(MSVC2017) && defined(LIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE)
+
+#  include <cuda/std/__concepts/same_as.h>
+#  include <cuda/std/__type_traits/remove_const_ref.h>
+#  include <cuda/std/__type_traits/void_t.h>
+#  include <cuda/std/__utility/declval.h>
+
+#  if _CCCL_STD_VER >= 2014
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+//! @brief The \c has_property concept verifies that a Resource satisfies a given Property
+//! @rst
+//! For \c has_property we require the following free function to be callable
+//!
+//! .. code cpp::
+//!
+//!    get_property(const Resource& res, Property prop);
+//!
+//! @endrst
+template <class _Resource, class _Property>
+_CCCL_CONCEPT has_property = _CCCL_REQUIRES_EXPR((_Resource, _Property), const _Resource& __res, _Property __prop)(
+  ((void) get_property(__res, __prop)));
+
+template <class _Property>
+using __property_value_t = typename _Property::value_type;
+
+//! @brief The \c property_with_value concept verifies that a Property is stateful and signals this through the
+//! `value_type` alias
+//! @rst
+//! .. code cpp::
+//!
+//!    struct stateless_property {};
+//!    static_assert(!cuda::property_with_value<stateless_property>);
+//!
+//!    struct stateful_property { using value_type = int; };
+//!    static_assert(!cuda::property_with_value<stateful_property>);
+//!
+//! @endrst
+template <class _Property>
+_CCCL_CONCEPT property_with_value = _CCCL_REQUIRES_EXPR((_Property))(typename(__property_value_t<_Property>));
+
+//! @brief The \c has_property_with concept verifies that a Resource satisfies a given stateful Property
+//! @rst
+//! For \c has_property_with we require the following free function to be callable and its return type to exactly match
+//! the ``value_type`` of the Property
+//!
+//! .. code cpp::
+//!
+//!    struct stateless_property {};
+//!    constexpr void get_property(const Resource& res, stateless_property) {}
+//!
+//!    // The resource must be stateful
+//!    static_assert(!cuda::has_property_with<Resource, stateless_property, int>);
+//!
+//!    struct stateful_property { using value_type = int; };
+//!    constexpr int get_property(const Resource& res, stateful_property) {}
+//!
+//!    // The resource is stateful and has the correct return type
+//!    static_assert(cuda::has_property_with<Resource, stateful_property, int>);
+//!
+//!    // The resource is stateful but the return type is incorrect
+//!    static_assert(!cuda::has_property_with<Resource, stateful_property, double>);
+//!
+//!    constexpr double get_property(const OtherResource& res, stateful_property) {}
+//!
+//!    // The resource is stateful but the value_type does not match the `get_property` return type
+//!    static_assert(!cuda::has_property_with<OtherResource, stateful_property, double>);
+//!
+//! @endrst
+template <class _Resource, class _Property, class _Return>
+_CCCL_CONCEPT_FRAGMENT(
+  __has_property_with_,
+  requires(const _Resource& __res)(requires(property_with_value<_Property>),
+                                   requires(_CUDA_VSTD::same_as<_Return, decltype(get_property(__res, _Property{}))>)));
+template <class _Resource, class _Property, class _Return>
+_CCCL_CONCEPT has_property_with = _CCCL_FRAGMENT(__has_property_with_, _Resource, _Property, _Return);
+
+template <class _Resource, class _Upstream>
+_CCCL_CONCEPT_FRAGMENT(
+  __has_upstream_resource_,
+  requires(const _Resource& __res)(
+    requires(_CUDA_VSTD::same_as<_CUDA_VSTD::__remove_const_ref_t<decltype(__res.upstream_resource())>, _Upstream>)));
+template <class _Resource, class _Upstream>
+_CCCL_CONCEPT __has_upstream_resource = _CCCL_FRAGMENT(__has_upstream_resource_, _Resource, _Upstream);
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CPO(__forward_property)
+template <class _Derived, class _Upstream>
+struct __fn
+{
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_TEMPLATE(class _Property)
+  _CCCL_REQUIRES((!property_with_value<_Property>) _CCCL_AND has_property<_Upstream, _Property>)
+  _LIBCUDACXX_HIDE_FROM_ABI friend constexpr void get_property(const _Derived&, _Property) noexcept {}
+
+  // The indirection is needed, otherwise the compiler might believe that _Derived is an incomplete type
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_TEMPLATE(class _Property, class _Derived2 = _Derived)
+  _CCCL_REQUIRES(property_with_value<_Property> _CCCL_AND has_property<_Upstream, _Property> _CCCL_AND
+                   __has_upstream_resource<_Derived2, _Upstream>)
+  _LIBCUDACXX_HIDE_FROM_ABI friend constexpr __property_value_t<_Property>
+  get_property(const _Derived& __res, _Property __prop)
+  {
+    return get_property(__res.upstream_resource(), __prop);
+  }
+};
+_LIBCUDACXX_END_NAMESPACE_CPO
+
+//! @brief The \c forward_property CRTP template allows Derived to forward all properties of Upstream
+//! @rst
+//! .. code cpp::
+//!
+//!    class UpstreamWithProperties;
+//!
+//!    class DerivedClass : cuda::forward_properties<DerivedClass, UpstreamWithProperties> {
+//!      // This method is needed to forward stateful properties
+//!      UpstreamWithProperties& upstream_resource() const { ... }
+//!    };
+//!
+//! .. note::
+//!
+//!    In order to forward stateful properties, a type needs do implement an `upstream_resource()` method that returns
+//!    an instance of the upstream.
+//!
+//! @endrst
+template <class _Derived, class _Upstream>
+using forward_property = __forward_property::__fn<_Derived, _Upstream>;
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#  endif // _CCCL_STD_VER >= 2014
+
+#endif // !_CCCL_COMPILER(MSVC2017) && LIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE
+
+#endif //_CUDA__MEMORY_RESOURCE_GET_PROPERTY_H

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

@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA__MEMORY_RESOURCE_PROPERTIES_H
+#define _CUDA__MEMORY_RESOURCE_PROPERTIES_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/type_set.h>
+#include <cuda/std/cstddef>
+
+#if !_CCCL_COMPILER(MSVC2017) && defined(LIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE)
+
+#  if _CCCL_STD_VER >= 2014
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA_MR
+
+//! @brief The default alignment by a cudaMalloc{...} call
+_CCCL_INLINE_VAR constexpr size_t default_cuda_malloc_alignment = 256;
+
+//! @brief The default alignment by a cudaMallocHost{...} call
+_CCCL_INLINE_VAR constexpr size_t default_cuda_malloc_host_alignment = alignof(_CUDA_VSTD::max_align_t);
+
+//! @brief The device_accessible property signals that the allocated memory is device accessible
+struct device_accessible
+{};
+
+//! @brief The device_accessible property signals that the allocated memory is host accessible
+struct host_accessible
+{};
+
+//! @brief determines whether a set of properties signals host accessible memory.
+template <class... _Properties>
+_CCCL_INLINE_VAR constexpr bool __is_host_accessible =
+  _CUDA_VSTD::__type_set_contains_v<_CUDA_VSTD::__make_type_set<_Properties...>, host_accessible>;
+
+//! @brief determines whether a set of properties signals device accessible memory.
+template <class... _Properties>
+_CCCL_INLINE_VAR constexpr bool __is_device_accessible =
+  _CUDA_VSTD::__type_set_contains_v<_CUDA_VSTD::__make_type_set<_Properties...>, device_accessible>;
+
+//! @brief determines whether a set of properties signals host device accessible memory.
+template <class... _Properties>
+_CCCL_INLINE_VAR constexpr bool __is_host_device_accessible =
+  _CUDA_VSTD::__type_set_contains_v<_CUDA_VSTD::__make_type_set<_Properties...>, host_accessible, device_accessible>;
+
+//! @brief verifies that a set of properties contains at least one execution space property
+template <class... _Properties>
+_CCCL_INLINE_VAR constexpr bool __contains_execution_space_property =
+  __is_host_accessible<_Properties...> || __is_device_accessible<_Properties...>;
+
+_LIBCUDACXX_END_NAMESPACE_CUDA_MR
+
+#  endif // _CCCL_STD_VER >= 2014
+
+#endif // !_CCCL_COMPILER(MSVC2017) && LIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE
+
+#endif //_CUDA__MEMORY_RESOURCE_PROPERTIES_H

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

@@ -0,0 +1,81 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___EXCEPTION_CUDA_ERROR_H
+#define _LIBCUDACXX___EXCEPTION_CUDA_ERROR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__exception/terminate.h>
+
+#if !_CCCL_COMPILER(NVRTC)
+#  include <cstdio>
+#  include <stdexcept>
+#endif // !_CCCL_COMPILER(NVRTC)
+
+#include <nv/target>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+/**
+ * @brief Exception thrown when a CUDA error is encountered.
+ */
+#ifndef _CCCL_NO_EXCEPTIONS
+class cuda_error : public ::std::runtime_error
+{
+private:
+  struct __msg_storage
+  {
+    char __buffer[256];
+  };
+
+  static char* __format_cuda_error(const int __status, const char* __msg, char* __msg_buffer) noexcept
+  {
+    ::snprintf(__msg_buffer, 256, "cudaError %d: %s", __status, __msg);
+    return __msg_buffer;
+  }
+
+public:
+  cuda_error(const int __status, const char* __msg, __msg_storage __msg_buffer = {0}) noexcept
+      : ::std::runtime_error(__format_cuda_error(__status, __msg, __msg_buffer.__buffer))
+  {}
+};
+
+_CCCL_NORETURN _LIBCUDACXX_HIDE_FROM_ABI void __throw_cuda_error(const int __status, const char* __msg)
+{
+  NV_IF_ELSE_TARGET(NV_IS_HOST,
+                    (throw ::cuda::cuda_error(__status, __msg);),
+                    ((void) __status; (void) __msg; _CUDA_VSTD_NOVERSION::terminate();))
+}
+#else // ^^^ !_CCCL_NO_EXCEPTIONS ^^^ / vvv _CCCL_NO_EXCEPTIONS vvv
+class cuda_error
+{
+public:
+  _LIBCUDACXX_HIDE_FROM_ABI cuda_error(const int, const char*) noexcept {}
+};
+
+_CCCL_NORETURN _LIBCUDACXX_HIDE_FROM_ABI void __throw_cuda_error(const int, const char*)
+{
+  _CUDA_VSTD_NOVERSION::terminate();
+}
+#endif // _CCCL_NO_EXCEPTIONS
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _LIBCUDACXX___EXCEPTION_CUDA_ERROR_H

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

@@ -0,0 +1,69 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___EXCEPTION_TERMINATE_H
+#define _LIBCUDACXX___EXCEPTION_TERMINATE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/cstdlib> // ::exit
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_MSVC(4702) // unreachable code
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD_NOVERSION // purposefully not using versioning namespace
+
+_CCCL_NORETURN _LIBCUDACXX_HIDE_FROM_ABI void __cccl_terminate() noexcept
+{
+  NV_IF_ELSE_TARGET(NV_IS_HOST, (::exit(-1);), (__trap();))
+  _CCCL_UNREACHABLE();
+}
+
+#if 0 // Expose once atomic is universally available
+
+typedef void (*terminate_handler)();
+
+#  ifdef __CUDA_ARCH__
+__device__
+#  endif // __CUDA_ARCH__
+  static _LIBCUDACXX_SAFE_STATIC _CUDA_VSTD::atomic<terminate_handler>
+    __cccl_terminate_handler{&__cccl_terminate};
+
+_LIBCUDACXX_HIDE_FROM_ABI  terminate_handler set_terminate(terminate_handler __func) noexcept
+{
+  return __cccl_terminate_handler.exchange(__func);
+}
+_LIBCUDACXX_HIDE_FROM_ABI  terminate_handler get_terminate() noexcept
+{
+  return __cccl_terminate_handler.load(__func);
+}
+
+#endif
+
+_CCCL_NORETURN _LIBCUDACXX_HIDE_FROM_ABI void terminate() noexcept
+{
+  __cccl_terminate();
+  _CCCL_UNREACHABLE();
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD_NOVERSION
+
+_CCCL_DIAG_POP
+
+#endif // _LIBCUDACXX___EXCEPTION_TERMINATE_H

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

@@ -0,0 +1,51 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_ADDRESSOF_H
+#define _LIBCUDACXX___MEMORY_ADDRESSOF_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// addressof
+// NVCXX has the builtin defined but did not mark it as supported
+#if defined(_CCCL_BUILTIN_ADDRESSOF)
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 _LIBCUDACXX_NO_CFI _Tp* addressof(_Tp& __x) noexcept
+{
+  return _CCCL_BUILTIN_ADDRESSOF(__x);
+}
+
+#else
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_NO_CFI _Tp* addressof(_Tp& __x) noexcept
+{
+  return reinterpret_cast<_Tp*>(const_cast<char*>(&reinterpret_cast<const volatile char&>(__x)));
+}
+
+#endif // defined(_CCCL_BUILTIN_ADDRESSOF)
+
+template <class _Tp>
+_Tp* addressof(const _Tp&&) noexcept = delete;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_ADDRESSOF_H

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

@@ -0,0 +1,55 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_ALIGN_H
+#define _LIBCUDACXX___MEMORY_ALIGN_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/cstddef>
+#include <cuda/std/cstdint>
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_MSVC(4146) // unary minus operator applied to unsigned type, result still unsigned
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+_LIBCUDACXX_HIDE_FROM_ABI void* align(size_t __alignment, size_t __size, void*& __ptr, size_t& __space)
+{
+  if (__space < __size)
+  {
+    return nullptr;
+  }
+
+  const auto __intptr  = reinterpret_cast<uintptr_t>(__ptr);
+  const auto __aligned = (__intptr - 1u + __alignment) & -__alignment;
+  const auto __diff    = __aligned - __intptr;
+  if (__diff > (__space - __size))
+  {
+    return nullptr;
+  }
+  __space -= __diff;
+  return __ptr = reinterpret_cast<void*>(__aligned);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_CCCL_DIAG_POP
+
+#endif // _LIBCUDACXX___MEMORY_ALIGN_H

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

@@ -0,0 +1,77 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_ALLOCATE_AT_LEAST_H
+#define _LIBCUDACXX___MEMORY_ALLOCATE_AT_LEAST_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__memory/allocator_traits.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _CCCL_STD_VER >= 2023
+template <class _Pointer>
+struct allocation_result
+{
+  _Pointer ptr;
+  size_t count;
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(allocation_result);
+
+template <class _Alloc>
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr allocation_result<typename allocator_traits<_Alloc>::pointer>
+allocate_at_least(_Alloc& __alloc, size_t __n)
+{
+  if constexpr (requires { __alloc.allocate_at_least(__n); })
+  {
+    return __alloc.allocate_at_least(__n);
+  }
+  else
+  {
+    return {__alloc.allocate(__n), __n};
+  }
+}
+
+template <class _Alloc>
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr auto __allocate_at_least(_Alloc& __alloc, size_t __n)
+{
+  return _CUDA_VSTD::allocate_at_least(__alloc, __n);
+}
+#else // ^^^ _CCCL_STD_VER >= 2023 ^^^ / vvv _CCCL_STD_VER < 2023 vvv
+template <class _Pointer>
+struct __allocation_result
+{
+  _Pointer ptr;
+  size_t count;
+};
+
+template <class _Alloc>
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr __allocation_result<typename allocator_traits<_Alloc>::pointer>
+__allocate_at_least(_Alloc& __alloc, size_t __n)
+{
+  return {__alloc.allocate(__n), __n};
+}
+
+#endif // _CCCL_STD_VER >= 2023
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_ALLOCATE_AT_LEAST_H

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

@@ -0,0 +1,96 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_ALLOCATION_GUARD_H
+#define _LIBCUDACXX___MEMORY_ALLOCATION_GUARD_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__memory/allocator_traits.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// Helper class to allocate memory using an Allocator in an exception safe
+// manner.
+//
+// The intended usage of this class is as follows:
+//
+// 0
+// 1     __allocation_guard<SomeAllocator> guard(alloc, 10);
+// 2     do_some_initialization_that_may_throw(guard.__get());
+// 3     save_allocated_pointer_in_a_noexcept_operation(guard.__release_ptr());
+// 4
+//
+// If line (2) throws an exception during initialization of the memory, the
+// guard's destructor will be called, and the memory will be released using
+// Allocator deallocation. Otherwise, we release the memory from the guard on
+// line (3) in an operation that can't throw -- after that, the guard is not
+// responsible for the memory anymore.
+//
+// This is similar to a unique_ptr, except it's easier to use with a
+// custom allocator.
+
+_CCCL_NV_DIAG_SUPPRESS(2659) // constexpr non-static member function will not be implicitly 'const' in C++14
+
+template <class _Alloc>
+struct __allocation_guard
+{
+  using _Pointer = typename allocator_traits<_Alloc>::pointer;
+  using _Size    = typename allocator_traits<_Alloc>::size_type;
+
+  template <class _AllocT> // we perform the allocator conversion inside the constructor
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 explicit __allocation_guard(_AllocT __alloc, _Size __n)
+      : __alloc_(_CUDA_VSTD::move(__alloc))
+      , __n_(__n)
+      , __ptr_(allocator_traits<_Alloc>::allocate(__alloc_, __n_)) // initialization order is important
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 ~__allocation_guard() noexcept
+  {
+    if (__ptr_ != nullptr)
+    {
+      allocator_traits<_Alloc>::deallocate(__alloc_, __ptr_, __n_);
+    }
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 _Pointer __release_ptr() noexcept
+  { // not called __release() because it's a keyword in objective-c++
+    _Pointer __tmp = __ptr_;
+    __ptr_         = nullptr;
+    return __tmp;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr _Pointer __get() const noexcept
+  {
+    return __ptr_;
+  }
+
+private:
+  _Alloc __alloc_;
+  _Size __n_;
+  _Pointer __ptr_;
+};
+
+_CCCL_NV_DIAG_DEFAULT(2659)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_ALLOCATION_GUARD_H

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

@@ -0,0 +1,318 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_ALLOCATOR_H
+#define _LIBCUDACXX___MEMORY_ALLOCATOR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__memory/addressof.h>
+#include <cuda/std/__memory/allocate_at_least.h>
+#include <cuda/std/__memory/allocator_traits.h>
+#include <cuda/std/__new_>
+#include <cuda/std/__type_traits/is_constant_evaluated.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__type_traits/is_volatile.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/cstddef>
+
+#if defined(_CCCL_HAS_CONSTEXPR_ALLOCATION) && !_CCCL_COMPILER(NVRTC)
+#  include <memory>
+#endif // _CCCL_HAS_CONSTEXPR_ALLOCATION && !_CCCL_COMPILER(NVRTC)
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+class allocator;
+
+#if _CCCL_STD_VER <= 2017
+// These specializations shouldn't be marked _LIBCUDACXX_DEPRECATED_IN_CXX17.
+// Specializing allocator<void> is deprecated, but not using it.
+template <>
+class _CCCL_TYPE_VISIBILITY_DEFAULT allocator<void>
+{
+public:
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef void* pointer;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef const void* const_pointer;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef void value_type;
+
+  template <class _Up>
+  struct _LIBCUDACXX_DEPRECATED_IN_CXX17 rebind
+  {
+    typedef allocator<_Up> other;
+  };
+};
+
+template <>
+class _CCCL_TYPE_VISIBILITY_DEFAULT allocator<const void>
+{
+public:
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef const void* pointer;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef const void* const_pointer;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef const void value_type;
+
+  template <class _Up>
+  struct _LIBCUDACXX_DEPRECATED_IN_CXX17 rebind
+  {
+    typedef allocator<_Up> other;
+  };
+};
+#endif // _CCCL_STD_VER <= 2017
+
+// This class provides a non-trivial default constructor to the class that derives from it
+// if the condition is satisfied.
+//
+// The second template parameter exists to allow giving a unique type to __non_trivial_if,
+// which makes it possible to avoid breaking the ABI when making this a base class of an
+// existing class. Without that, imagine we have classes D1 and D2, both of which used to
+// have no base classes, but which now derive from __non_trivial_if. The layout of a class
+// that inherits from both D1 and D2 will change because the two __non_trivial_if base
+// classes are not allowed to share the same address.
+//
+// By making those __non_trivial_if base classes unique, we work around this problem and
+// it is safe to start deriving from __non_trivial_if in existing classes.
+template <bool _Cond, class _Unique>
+struct __non_trivial_if
+{};
+
+template <class _Unique>
+struct __non_trivial_if<true, _Unique>
+{
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr __non_trivial_if() noexcept {}
+};
+
+// allocator
+//
+// Note: For ABI compatibility between C++20 and previous standards, we make
+//       allocator<void> trivial in C++20.
+
+template <class _Tp>
+class _CCCL_TYPE_VISIBILITY_DEFAULT allocator : private __non_trivial_if<!_CCCL_TRAIT(is_void, _Tp), allocator<_Tp>>
+{
+  static_assert(!_CCCL_TRAIT(is_volatile, _Tp), "std::allocator does not support volatile types");
+
+public:
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef _Tp value_type;
+  typedef true_type propagate_on_container_move_assignment;
+  typedef true_type is_always_equal;
+
+  _CCCL_CONSTEXPR_CXX20 allocator() noexcept = default;
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 allocator(const allocator<_Up>&) noexcept
+  {}
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20_ALLOCATION _Tp* allocate(size_t __n)
+  {
+    if (__n > allocator_traits<allocator>::max_size(*this))
+    {
+      __throw_bad_array_new_length();
+    }
+#if defined(_CCCL_HAS_CONSTEXPR_ALLOCATION)
+    if (_CUDA_VSTD::is_constant_evaluated())
+    {
+      return ::std::allocator<_Tp>{}.allocate(__n);
+    }
+#endif // _CCCL_HAS_CONSTEXPR_ALLOCATION
+    {
+      return static_cast<_Tp*>(_CUDA_VSTD::__cccl_allocate(__n * sizeof(_Tp), _LIBCUDACXX_ALIGNOF(_Tp)));
+    }
+  }
+
+#if _CCCL_STD_VER >= 2023
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr allocation_result<_Tp*> allocate_at_least(size_t __n)
+  {
+    return {allocate(__n), __n};
+  }
+#endif // _CCCL_HAS_CONSTEXPR_ALLOCATION
+
+  _CCCL_EXEC_CHECK_DISABLE
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20_ALLOCATION void deallocate(_Tp* __p, size_t __n) noexcept
+  {
+#if defined(_CCCL_HAS_CONSTEXPR_ALLOCATION)
+    if (_CUDA_VSTD::is_constant_evaluated())
+    {
+      return ::std::allocator<_Tp>{}.deallocate(__p, __n);
+    }
+    else
+#endif // _CCCL_STD_VER >= 2020
+    {
+      _CUDA_VSTD::__cccl_deallocate((void*) __p, __n * sizeof(_Tp), _LIBCUDACXX_ALIGNOF(_Tp));
+    }
+  }
+
+  // C++20 Removed members
+#if _CCCL_STD_VER <= 2017
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef _Tp* pointer;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef _Tp& reference;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
+
+  template <class _Up>
+  struct _LIBCUDACXX_DEPRECATED_IN_CXX17 rebind
+  {
+    typedef allocator<_Up> other;
+  };
+
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 _LIBCUDACXX_HIDE_FROM_ABI pointer address(reference __x) const noexcept
+  {
+    return _CUDA_VSTD::addressof(__x);
+  }
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 _LIBCUDACXX_HIDE_FROM_ABI const_pointer address(const_reference __x) const noexcept
+  {
+    return _CUDA_VSTD::addressof(__x);
+  }
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_DEPRECATED_IN_CXX17 _Tp* allocate(size_t __n, const void*)
+  {
+    return allocate(__n);
+  }
+
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 _LIBCUDACXX_HIDE_FROM_ABI size_type max_size() const noexcept
+  {
+    return size_type(~0) / sizeof(_Tp);
+  }
+
+  template <class _Up, class... _Args>
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 _LIBCUDACXX_HIDE_FROM_ABI void construct(_Up* __p, _Args&&... __args)
+  {
+    ::new ((void*) __p) _Up(_CUDA_VSTD::forward<_Args>(__args)...);
+  }
+
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 _LIBCUDACXX_HIDE_FROM_ABI void destroy(pointer __p) noexcept
+  {
+    __p->~_Tp();
+  }
+#endif // _CCCL_STD_VER <= 2017
+};
+
+template <class _Tp>
+class _CCCL_TYPE_VISIBILITY_DEFAULT allocator<const _Tp>
+    : private __non_trivial_if<!_CCCL_TRAIT(is_void, _Tp), allocator<const _Tp>>
+{
+  static_assert(!_CCCL_TRAIT(is_volatile, _Tp), "std::allocator does not support volatile types");
+
+public:
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef const _Tp value_type;
+  typedef true_type propagate_on_container_move_assignment;
+  typedef true_type is_always_equal;
+
+  _CCCL_CONSTEXPR_CXX20 allocator() noexcept = default;
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 allocator(const allocator<_Up>&) noexcept
+  {}
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 const _Tp* allocate(size_t __n)
+  {
+    if (__n > allocator_traits<allocator>::max_size(*this))
+    {
+      __throw_bad_array_new_length();
+    }
+    if (_CUDA_VSTD::is_constant_evaluated())
+    {
+      return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp)));
+    }
+    else
+    {
+      return static_cast<const _Tp*>(_CUDA_VSTD::__cccl_allocate(__n * sizeof(_Tp), _LIBCUDACXX_ALIGNOF(_Tp)));
+    }
+  }
+
+#if _CCCL_STD_VER >= 2023
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr allocation_result<const _Tp*> allocate_at_least(size_t __n)
+  {
+    return {allocate(__n), __n};
+  }
+#endif // _CCCL_STD_VER >= 2023
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void deallocate(const _Tp* __p, size_t __n) noexcept
+  {
+    if (_CUDA_VSTD::is_constant_evaluated())
+    {
+      ::operator delete(const_cast<_Tp*>(__p));
+    }
+    else
+    {
+      _CUDA_VSTD::__cccl_deallocate((void*) const_cast<_Tp*>(__p), __n * sizeof(_Tp), _LIBCUDACXX_ALIGNOF(_Tp));
+    }
+  }
+
+  // C++20 Removed members
+#if _CCCL_STD_VER <= 2017
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef const _Tp* pointer;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef const _Tp& reference;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
+
+  template <class _Up>
+  struct _LIBCUDACXX_DEPRECATED_IN_CXX17 rebind
+  {
+    typedef allocator<_Up> other;
+  };
+
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 _LIBCUDACXX_HIDE_FROM_ABI const_pointer address(const_reference __x) const noexcept
+  {
+    return _CUDA_VSTD::addressof(__x);
+  }
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_DEPRECATED_IN_CXX17 const _Tp* allocate(size_t __n, const void*)
+  {
+    return allocate(__n);
+  }
+
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 _LIBCUDACXX_HIDE_FROM_ABI size_type max_size() const noexcept
+  {
+    return size_type(~0) / sizeof(_Tp);
+  }
+
+  template <class _Up, class... _Args>
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 _LIBCUDACXX_HIDE_FROM_ABI void construct(_Up* __p, _Args&&... __args)
+  {
+    ::new ((void*) __p) _Up(_CUDA_VSTD::forward<_Args>(__args)...);
+  }
+
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 _LIBCUDACXX_HIDE_FROM_ABI void destroy(pointer __p) noexcept
+  {
+    __p->~_Tp();
+  }
+#endif // _CCCL_STD_VER <= 2017
+};
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator==(const allocator<_Tp>&, const allocator<_Up>&) noexcept
+{
+  return true;
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) noexcept
+{
+  return false;
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_ALLOCATOR_H

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

@@ -0,0 +1,80 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_ALLOCATOR_ARG_T_H
+#define _LIBCUDACXX___FUNCTIONAL_ALLOCATOR_ARG_T_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__memory/uses_allocator.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_constructible.h>
+#include <cuda/std/__type_traits/remove_cvref.h>
+#include <cuda/std/__utility/forward.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct _CCCL_TYPE_VISIBILITY_DEFAULT allocator_arg_t
+{
+  _CCCL_HIDE_FROM_ABI explicit allocator_arg_t() = default;
+};
+
+_CCCL_INLINE_VAR constexpr allocator_arg_t allocator_arg = allocator_arg_t();
+
+// allocator construction
+
+template <class _Tp, class _Alloc, class... _Args>
+struct __uses_alloc_ctor_imp
+{
+  typedef _CCCL_NODEBUG_ALIAS remove_cvref_t<_Alloc> _RawAlloc;
+  static const bool __ua = uses_allocator<_Tp, _RawAlloc>::value;
+  static const bool __ic = is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
+  static const int value = __ua ? 2 - __ic : 0;
+};
+
+template <class _Tp, class _Alloc, class... _Args>
+struct __uses_alloc_ctor : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
+{};
+
+template <class _Tp, class _Allocator, class... _Args>
+_LIBCUDACXX_HIDE_FROM_ABI void
+__user_alloc_construct_impl(integral_constant<int, 0>, _Tp* __storage, const _Allocator&, _Args&&... __args)
+{
+  new (__storage) _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+}
+
+// FIXME: This should have a version which takes a non-const alloc.
+template <class _Tp, class _Allocator, class... _Args>
+_LIBCUDACXX_HIDE_FROM_ABI void
+__user_alloc_construct_impl(integral_constant<int, 1>, _Tp* __storage, const _Allocator& __a, _Args&&... __args)
+{
+  new (__storage) _Tp(allocator_arg, __a, _CUDA_VSTD::forward<_Args>(__args)...);
+}
+
+// FIXME: This should have a version which takes a non-const alloc.
+template <class _Tp, class _Allocator, class... _Args>
+_LIBCUDACXX_HIDE_FROM_ABI void
+__user_alloc_construct_impl(integral_constant<int, 2>, _Tp* __storage, const _Allocator& __a, _Args&&... __args)
+{
+  new (__storage) _Tp(_CUDA_VSTD::forward<_Args>(__args)..., __a);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_ALLOCATOR_ARG_T_H

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

@@ -0,0 +1,55 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_ALLOCATOR_DESTRUCTOR_H
+#define _LIBCUDACXX___MEMORY_ALLOCATOR_DESTRUCTOR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__memory/allocator_traits.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Alloc>
+class __allocator_destructor
+{
+  typedef _CCCL_NODEBUG_ALIAS allocator_traits<_Alloc> __alloc_traits;
+
+public:
+  typedef _CCCL_NODEBUG_ALIAS typename __alloc_traits::pointer pointer;
+  typedef _CCCL_NODEBUG_ALIAS typename __alloc_traits::size_type size_type;
+
+private:
+  _Alloc& __alloc_;
+  size_type __s_;
+
+public:
+  _LIBCUDACXX_HIDE_FROM_ABI __allocator_destructor(_Alloc& __a, size_type __s) noexcept
+      : __alloc_(__a)
+      , __s_(__s)
+  {}
+  _LIBCUDACXX_HIDE_FROM_ABI void operator()(pointer __p) noexcept
+  {
+    __alloc_traits::deallocate(__alloc_, __p, __s_);
+  }
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_ALLOCATOR_DESTRUCTOR_H

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

@@ -0,0 +1,581 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_ALLOCATOR_TRAITS_H
+#define _LIBCUDACXX___MEMORY_ALLOCATOR_TRAITS_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__memory/construct_at.h>
+#include <cuda/std/__memory/pointer_traits.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/is_copy_constructible.h>
+#include <cuda/std/__type_traits/is_empty.h>
+#include <cuda/std/__type_traits/is_move_constructible.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/is_trivially_move_constructible.h>
+#include <cuda/std/__type_traits/make_unsigned.h>
+#include <cuda/std/__type_traits/remove_reference.h>
+#include <cuda/std/__type_traits/void_t.h>
+#include <cuda/std/__utility/declval.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/detail/libcxx/include/cstring>
+#include <cuda/std/limits>
+
+_CCCL_PUSH_MACROS
+
+_CCCL_NV_DIAG_SUPPRESS(1215)
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_NO_VARIABLE_TEMPLATES)
+#  define _LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(NAME, PROPERTY)   \
+    template <class _Tp, class = void>                           \
+    struct NAME : false_type                                     \
+    {};                                                          \
+    template <class _Tp>                                         \
+    struct NAME<_Tp, void_t<typename _Tp::PROPERTY>> : true_type \
+    {}
+#else // ^^^ _CCCL_NO_VARIABLE_TEMPLATES ^^^ / vvv !_CCCL_NO_VARIABLE_TEMPLATES vvv
+#  define _LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(NAME, PROPERTY) \
+    template <class _Tp, class = void>                         \
+    _CCCL_INLINE_VAR constexpr bool NAME##_v = false;          \
+    template <class _Tp>                                       \
+    _CCCL_INLINE_VAR constexpr bool NAME##_v<_Tp, void_t<typename _Tp::PROPERTY>> = true;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+// __pointer
+_LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(__has_pointer, pointer);
+template <class _Tp,
+          class _Alloc,
+          class _RawAlloc = remove_reference_t<_Alloc>,
+          bool            = _CCCL_TRAIT(__has_pointer, _RawAlloc)>
+struct __pointer
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _RawAlloc::pointer;
+};
+template <class _Tp, class _Alloc, class _RawAlloc>
+struct __pointer<_Tp, _Alloc, _RawAlloc, false>
+{
+  using type _CCCL_NODEBUG_ALIAS = _Tp*;
+};
+
+// __const_pointer
+_LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(__has_const_pointer, const_pointer);
+template <class _Tp, class _Ptr, class _Alloc, bool = _CCCL_TRAIT(__has_const_pointer, _Alloc)>
+struct __const_pointer
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _Alloc::const_pointer;
+};
+template <class _Tp, class _Ptr, class _Alloc>
+struct __const_pointer<_Tp, _Ptr, _Alloc, false>
+{
+  using type _CCCL_NODEBUG_ALIAS = typename pointer_traits<_Ptr>::template rebind<const _Tp>;
+};
+
+// __void_pointer
+_LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(__has_void_pointer, void_pointer);
+template <class _Ptr, class _Alloc, bool = _CCCL_TRAIT(__has_void_pointer, _Alloc)>
+struct __void_pointer
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _Alloc::void_pointer;
+};
+template <class _Ptr, class _Alloc>
+struct __void_pointer<_Ptr, _Alloc, false>
+{
+  using type _CCCL_NODEBUG_ALIAS = typename pointer_traits<_Ptr>::template rebind<void>;
+};
+
+// __const_void_pointer
+_LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(__has_const_void_pointer, const_void_pointer);
+template <class _Ptr, class _Alloc, bool = _CCCL_TRAIT(__has_const_void_pointer, _Alloc)>
+struct __const_void_pointer
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _Alloc::const_void_pointer;
+};
+template <class _Ptr, class _Alloc>
+struct __const_void_pointer<_Ptr, _Alloc, false>
+{
+  using type _CCCL_NODEBUG_ALIAS = typename pointer_traits<_Ptr>::template rebind<const void>;
+};
+
+// __size_type
+_LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(__has_size_type, size_type);
+template <class _Alloc, class _DiffType, bool = _CCCL_TRAIT(__has_size_type, _Alloc)>
+struct __size_type : make_unsigned<_DiffType>
+{};
+template <class _Alloc, class _DiffType>
+struct __size_type<_Alloc, _DiffType, true>
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _Alloc::size_type;
+};
+
+// __alloc_traits_difference_type
+_LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(__has_alloc_traits_difference_type, difference_type);
+template <class _Alloc, class _Ptr, bool = _CCCL_TRAIT(__has_alloc_traits_difference_type, _Alloc)>
+struct __alloc_traits_difference_type
+{
+  using type _CCCL_NODEBUG_ALIAS = typename pointer_traits<_Ptr>::difference_type;
+};
+template <class _Alloc, class _Ptr>
+struct __alloc_traits_difference_type<_Alloc, _Ptr, true>
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _Alloc::difference_type;
+};
+
+// __propagate_on_container_copy_assignment
+_LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_copy_assignment,
+                                     propagate_on_container_copy_assignment);
+template <class _Alloc, bool = _CCCL_TRAIT(__has_propagate_on_container_copy_assignment, _Alloc)>
+struct __propagate_on_container_copy_assignment : false_type
+{};
+template <class _Alloc>
+struct __propagate_on_container_copy_assignment<_Alloc, true>
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _Alloc::propagate_on_container_copy_assignment;
+};
+
+// __propagate_on_container_move_assignment
+_LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_move_assignment,
+                                     propagate_on_container_move_assignment);
+template <class _Alloc, bool = _CCCL_TRAIT(__has_propagate_on_container_move_assignment, _Alloc)>
+struct __propagate_on_container_move_assignment : false_type
+{};
+template <class _Alloc>
+struct __propagate_on_container_move_assignment<_Alloc, true>
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _Alloc::propagate_on_container_move_assignment;
+};
+
+// __propagate_on_container_swap
+_LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_swap, propagate_on_container_swap);
+template <class _Alloc, bool = _CCCL_TRAIT(__has_propagate_on_container_swap, _Alloc)>
+struct __propagate_on_container_swap : false_type
+{};
+template <class _Alloc>
+struct __propagate_on_container_swap<_Alloc, true>
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _Alloc::propagate_on_container_swap;
+};
+
+// __is_always_equal
+_LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX(__has_is_always_equal, is_always_equal);
+template <class _Alloc, bool = _CCCL_TRAIT(__has_is_always_equal, _Alloc)>
+struct __is_always_equal : is_empty<_Alloc>
+{};
+template <class _Alloc>
+struct __is_always_equal<_Alloc, true>
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _Alloc::is_always_equal;
+};
+
+// __allocator_traits_rebind
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+template <class _Tp, class _Up, class = void>
+struct __has_rebind_other : false_type
+{};
+template <class _Tp, class _Up>
+struct __has_rebind_other<_Tp, _Up, void_t<typename _Tp::template rebind<_Up>::other>> : true_type
+{};
+
+template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
+struct __allocator_traits_rebind
+{
+  static_assert(__has_rebind_other<_Tp, _Up>::value, "This allocator has to implement rebind");
+  using type _CCCL_NODEBUG_ALIAS = typename _Tp::template rebind<_Up>::other;
+};
+template <template <class, class...> class _Alloc, class _Tp, class... _Args, class _Up>
+struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true>
+{
+  using type _CCCL_NODEBUG_ALIAS = typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other;
+};
+template <template <class, class...> class _Alloc, class _Tp, class... _Args, class _Up>
+struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false>
+{
+  using type _CCCL_NODEBUG_ALIAS = _Alloc<_Up, _Args...>;
+};
+_CCCL_SUPPRESS_DEPRECATED_POP
+
+template <class _Alloc, class _Tp>
+using __allocator_traits_rebind_t = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
+
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+
+// __has_allocate_hint
+template <class _Alloc, class _SizeType, class _ConstVoidPtr, class = void>
+struct __has_allocate_hint : false_type
+{};
+
+template <class _Alloc, class _SizeType, class _ConstVoidPtr>
+struct __has_allocate_hint<_Alloc,
+                           _SizeType,
+                           _ConstVoidPtr,
+                           decltype((void) _CUDA_VSTD::declval<_Alloc>().allocate(
+                             _CUDA_VSTD::declval<_SizeType>(), _CUDA_VSTD::declval<_ConstVoidPtr>()))> : true_type
+{};
+
+// __has_construct
+template <class, class _Alloc, class... _Args>
+struct __has_construct_impl : false_type
+{};
+
+template <class _Alloc, class... _Args>
+struct __has_construct_impl<decltype((void) _CUDA_VSTD::declval<_Alloc>().construct(_CUDA_VSTD::declval<_Args>()...)),
+                            _Alloc,
+                            _Args...> : true_type
+{};
+
+template <class _Alloc, class... _Args>
+struct __has_construct : __has_construct_impl<void, _Alloc, _Args...>
+{};
+
+// __has_destroy
+template <class _Alloc, class _Pointer, class = void>
+struct __has_destroy : false_type
+{};
+
+template <class _Alloc, class _Pointer>
+struct __has_destroy<_Alloc,
+                     _Pointer,
+                     decltype((void) _CUDA_VSTD::declval<_Alloc>().destroy(_CUDA_VSTD::declval<_Pointer>()))>
+    : true_type
+{};
+
+// __has_max_size
+template <class _Alloc, class = void>
+struct __has_max_size : false_type
+{};
+
+template <class _Alloc>
+struct __has_max_size<_Alloc, decltype((void) _CUDA_VSTD::declval<_Alloc&>().max_size())> : true_type
+{};
+
+// __has_select_on_container_copy_construction
+template <class _Alloc, class = void>
+struct __has_select_on_container_copy_construction : false_type
+{};
+
+template <class _Alloc>
+struct __has_select_on_container_copy_construction<
+  _Alloc,
+  decltype((void) _CUDA_VSTD::declval<_Alloc>().select_on_container_copy_construction())> : true_type
+{};
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI constexpr _Tp* __to_raw_pointer(_Tp* __p) noexcept
+{
+  return __p;
+}
+
+#if _CCCL_STD_VER <= 2017
+template <class _Pointer>
+_LIBCUDACXX_HIDE_FROM_ABI typename pointer_traits<_Pointer>::element_type* __to_raw_pointer(_Pointer __p) noexcept
+{
+  return _CUDA_VSTD::__to_raw_pointer(__p.operator->());
+}
+#else // ^^^ C++17 ^^^ / vvv C++20 vvv
+template <class _Pointer>
+_LIBCUDACXX_HIDE_FROM_ABI auto
+__to_raw_pointer(const _Pointer& __p) noexcept -> decltype(pointer_traits<_Pointer>::to_address(__p))
+{
+  return pointer_traits<_Pointer>::to_address(__p);
+}
+
+template <class _Pointer, class... _None>
+_LIBCUDACXX_HIDE_FROM_ABI auto __to_raw_pointer(const _Pointer& __p, _None...) noexcept
+{
+  return _CUDA_VSTD::__to_raw_pointer(__p.operator->());
+}
+#endif // _CCCL_STD_VER >= 2020
+
+_CCCL_SUPPRESS_DEPRECATED_POP
+
+// __is_default_allocator
+template <class _Tp>
+struct __is_default_allocator : false_type
+{};
+
+template <class>
+class allocator;
+
+template <class _Tp>
+struct __is_default_allocator<allocator<_Tp>> : true_type
+{};
+// __is_cpp17_move_insertable
+template <class _Alloc, class = void>
+struct __is_cpp17_move_insertable : is_move_constructible<typename _Alloc::value_type>
+{};
+
+template <class _Alloc>
+struct __is_cpp17_move_insertable<
+  _Alloc,
+  enable_if_t<!__is_default_allocator<_Alloc>::value
+              && __has_construct<_Alloc, typename _Alloc::value_type*, typename _Alloc::value_type&&>::value>>
+    : true_type
+{};
+
+// __is_cpp17_copy_insertable
+template <class _Alloc, class = void>
+struct __is_cpp17_copy_insertable
+    : integral_constant<bool,
+                        is_copy_constructible<typename _Alloc::value_type>::value
+                          && __is_cpp17_move_insertable<_Alloc>::value>
+{};
+
+template <class _Alloc>
+struct __is_cpp17_copy_insertable<
+  _Alloc,
+  enable_if_t<!__is_default_allocator<_Alloc>::value
+              && __has_construct<_Alloc, typename _Alloc::value_type*, const typename _Alloc::value_type&>::value>>
+    : __is_cpp17_move_insertable<_Alloc>
+{};
+
+template <class _Alloc>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT allocator_traits
+{
+  using allocator_type     = _Alloc;
+  using value_type         = typename allocator_type::value_type;
+  using pointer            = typename __pointer<value_type, allocator_type>::type;
+  using const_pointer      = typename __const_pointer<value_type, pointer, allocator_type>::type;
+  using void_pointer       = typename __void_pointer<pointer, allocator_type>::type;
+  using const_void_pointer = typename __const_void_pointer<pointer, allocator_type>::type;
+  using difference_type    = typename __alloc_traits_difference_type<allocator_type, pointer>::type;
+  using size_type          = typename __size_type<allocator_type, difference_type>::type;
+  using propagate_on_container_copy_assignment =
+    typename __propagate_on_container_copy_assignment<allocator_type>::type;
+  using propagate_on_container_move_assignment =
+    typename __propagate_on_container_move_assignment<allocator_type>::type;
+  using propagate_on_container_swap = typename __propagate_on_container_swap<allocator_type>::type;
+  using is_always_equal             = typename __is_always_equal<allocator_type>::type;
+
+  template <class _Tp>
+  using rebind_alloc = __allocator_traits_rebind_t<allocator_type, _Tp>;
+  template <class _Tp>
+  using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static pointer
+  allocate(allocator_type& __a, size_type __n)
+  {
+    return __a.allocate(__n);
+  }
+
+  template <class _Ap = _Alloc, enable_if_t<__has_allocate_hint<_Ap, size_type, const_void_pointer>::value, int> = 0>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static pointer
+  allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
+  {
+    _CCCL_SUPPRESS_DEPRECATED_PUSH
+    return __a.allocate(__n, __hint);
+    _CCCL_SUPPRESS_DEPRECATED_POP
+  }
+  template <class _Ap                                                                         = _Alloc,
+            class                                                                             = void,
+            enable_if_t<!__has_allocate_hint<_Ap, size_type, const_void_pointer>::value, int> = 0>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static pointer
+  allocate(allocator_type& __a, size_type __n, const_void_pointer)
+  {
+    return __a.allocate(__n);
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static void
+  deallocate(allocator_type& __a, pointer __p, size_type __n) noexcept
+  {
+    __a.deallocate(__p, __n);
+  }
+
+  template <class _Tp, class... _Args, enable_if_t<__has_construct<allocator_type, _Tp*, _Args...>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args)
+  {
+    _CCCL_SUPPRESS_DEPRECATED_PUSH
+    __a.construct(__p, _CUDA_VSTD::forward<_Args>(__args)...);
+    _CCCL_SUPPRESS_DEPRECATED_POP
+  }
+  template <class _Tp,
+            class... _Args,
+            class                                                                     = void,
+            enable_if_t<!__has_construct<allocator_type, _Tp*, _Args...>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static void construct(allocator_type&, _Tp* __p, _Args&&... __args)
+  {
+#if _CCCL_STD_VER >= 2020
+    _CUDA_VSTD::construct_at(__p, _CUDA_VSTD::forward<_Args>(__args)...);
+#else
+    ::new ((void*) __p) _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+#endif
+  }
+
+  template <class _Tp, enable_if_t<__has_destroy<allocator_type, _Tp*>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static void destroy(allocator_type& __a, _Tp* __p) noexcept
+  {
+    _CCCL_SUPPRESS_DEPRECATED_PUSH
+    __a.destroy(__p);
+    _CCCL_SUPPRESS_DEPRECATED_POP
+  }
+  template <class _Tp, class = void, enable_if_t<!__has_destroy<allocator_type, _Tp*>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static void destroy(allocator_type&, _Tp* __p) noexcept
+  {
+#if _CCCL_STD_VER >= 2020
+    _CUDA_VSTD::destroy_at(__p);
+#else
+    __p->~_Tp();
+#endif
+  }
+
+  _CCCL_SUPPRESS_DEPRECATED_PUSH
+  template <class _Ap = _Alloc, enable_if_t<__has_max_size<const _Ap>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static size_type max_size(const allocator_type& __a) noexcept
+  {
+    return __a.max_size();
+  }
+  _CCCL_SUPPRESS_DEPRECATED_POP
+  template <class _Ap = _Alloc, class = void, enable_if_t<!__has_max_size<const _Ap>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static size_type max_size(const allocator_type&) noexcept
+  {
+    return numeric_limits<size_type>::max() / sizeof(value_type);
+  }
+
+  template <class _Ap = _Alloc, enable_if_t<__has_select_on_container_copy_construction<const _Ap>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static allocator_type
+  select_on_container_copy_construction(const allocator_type& __a)
+  {
+    return __a.select_on_container_copy_construction();
+  }
+  template <class _Ap                                                                        = _Alloc,
+            class                                                                            = void,
+            enable_if_t<!__has_select_on_container_copy_construction<const _Ap>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static allocator_type
+  select_on_container_copy_construction(const allocator_type& __a)
+  {
+    return __a;
+  }
+
+  template <class _Ptr>
+  _LIBCUDACXX_HIDE_FROM_ABI static void
+  __construct_forward_with_exception_guarantees(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2)
+  {
+    static_assert(__is_cpp17_move_insertable<allocator_type>::value,
+                  "The specified type does not meet the requirements of Cpp17MoveInsertible");
+    for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)
+    {
+      construct(__a,
+                _CUDA_VSTD::__to_raw_pointer(__begin2),
+#ifdef _CCCL_NO_EXCEPTIONS
+                _CUDA_VSTD::move(*__begin1)
+#else // ^^^ _CCCL_NO_EXCEPTIONS ^^^ / vvv !_CCCL_NO_EXCEPTIONS vvv
+                _CUDA_VSTD::move_if_noexcept(*__begin1)
+#endif // !_CCCL_NO_EXCEPTIONS
+      );
+    }
+  }
+
+  template <class _Tp>
+  _LIBCUDACXX_HIDE_FROM_ABI static enable_if_t<
+    (__is_default_allocator<allocator_type>::value || !__has_construct<allocator_type, _Tp*, _Tp>::value)
+      && is_trivially_move_constructible<_Tp>::value,
+    void>
+  __construct_forward_with_exception_guarantees(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2)
+  {
+    ptrdiff_t _Np = __end1 - __begin1;
+    if (_Np > 0)
+    {
+      _CUDA_VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp));
+      __begin2 += _Np;
+    }
+  }
+
+  template <class _Iter, class _Ptr>
+  _LIBCUDACXX_HIDE_FROM_ABI static void
+  __construct_range_forward(allocator_type& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2)
+  {
+    for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)
+    {
+      construct(__a, _CUDA_VSTD::__to_raw_pointer(__begin2), *__begin1);
+    }
+  }
+
+  template <class _SourceTp,
+            class _DestTp,
+            class _RawSourceTp = remove_const_t<_SourceTp>,
+            class _RawDestTp   = remove_const_t<_DestTp>>
+  _LIBCUDACXX_HIDE_FROM_ABI static enable_if_t<
+    is_trivially_move_constructible<_DestTp>::value && is_same<_RawSourceTp, _RawDestTp>::value
+      && (__is_default_allocator<allocator_type>::value || !__has_construct<allocator_type, _DestTp*, _SourceTp&>::value),
+    void>
+  __construct_range_forward(allocator_type&, _SourceTp* __begin1, _SourceTp* __end1, _DestTp*& __begin2)
+  {
+    ptrdiff_t _Np = __end1 - __begin1;
+    if (_Np > 0)
+    {
+      _CUDA_VSTD::memcpy(const_cast<_RawDestTp*>(__begin2), __begin1, _Np * sizeof(_DestTp));
+      __begin2 += _Np;
+    }
+  }
+
+  template <class _Ptr>
+  _LIBCUDACXX_HIDE_FROM_ABI static void
+  __construct_backward_with_exception_guarantees(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2)
+  {
+    static_assert(__is_cpp17_move_insertable<allocator_type>::value,
+                  "The specified type does not meet the requirements of Cpp17MoveInsertable");
+    while (__end1 != __begin1)
+    {
+      construct(__a,
+                _CUDA_VSTD::__to_raw_pointer(__end2 - 1),
+#ifdef _CCCL_NO_EXCEPTIONS
+                _CUDA_VSTD::move(*--__end1)
+#else // ^^^ _CCCL_NO_EXCEPTIONS ^^^ / vvv !_CCCL_NO_EXCEPTIONS vvv
+                _CUDA_VSTD::move_if_noexcept(*--__end1)
+#endif // !_CCCL_NO_EXCEPTIONS
+      );
+      --__end2;
+    }
+  }
+
+  template <class _Tp>
+  _LIBCUDACXX_HIDE_FROM_ABI static enable_if_t<
+    (__is_default_allocator<allocator_type>::value || !__has_construct<allocator_type, _Tp*, _Tp>::value)
+      && is_trivially_move_constructible<_Tp>::value,
+    void>
+  __construct_backward_with_exception_guarantees(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2)
+  {
+    ptrdiff_t _Np = __end1 - __begin1;
+    __end2 -= _Np;
+    if (_Np > 0)
+    {
+      _CUDA_VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp));
+    }
+  }
+};
+
+template <class _Traits, class _Tp>
+using __rebind_alloc _CCCL_NODEBUG_ALIAS = typename _Traits::template rebind_alloc<_Tp>;
+
+template <class _Traits, class _Tp>
+struct __rebind_alloc_helper
+{
+  typedef _CCCL_NODEBUG_ALIAS typename _Traits::template rebind_alloc<_Tp> type;
+};
+
+#undef _LIBCUDACXX_ALLOCATOR_TRAITS_HAS_XXX
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_CCCL_NV_DIAG_DEFAULT(1215)
+
+_CCCL_POP_MACROS
+
+#endif // _LIBCUDACXX___MEMORY_ALLOCATOR_TRAITS_H

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

@@ -0,0 +1,53 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_ASSUME_ALIGNED_H
+#define _LIBCUDACXX___MEMORY_ASSUME_ALIGNED_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__bit/has_single_bit.h>
+#include <cuda/std/__type_traits/is_constant_evaluated.h>
+#include <cuda/std/cstddef> // size_t
+#include <cuda/std/cstdint> // uintptr_t
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <size_t _Align, class _Tp>
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 _Tp* assume_aligned(_Tp* __ptr) noexcept
+{
+  static_assert(_CUDA_VSTD::has_single_bit(_Align), "std::assume_aligned requires the alignment to be a power of 2!");
+#if defined(_CCCL_BUILTIN_IS_CONSTANT_EVALUATED) && defined(_CCCL_BUILTIN_ASSUME_ALIGNED)
+  if (!_CCCL_BUILTIN_IS_CONSTANT_EVALUATED())
+  {
+#  if !_CCCL_COMPILER(MSVC) // MSVC checks within the builtin
+    _CCCL_ASSERT(reinterpret_cast<uintptr_t>(__ptr) % _Align == 0, "Alignment assumption is violated");
+#  endif // !_CCCL_COMPILER(MSVC)
+    return static_cast<_Tp*>(_CCCL_BUILTIN_ASSUME_ALIGNED(__ptr, _Align));
+  }
+  else
+#endif // _CCCL_BUILTIN_IS_CONSTANT_EVALUATED && _CCCL_BUILTIN_ASSUME_ALIGNED
+  {
+    return __ptr;
+  }
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_ASSUME_ALIGNED_H

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

@@ -0,0 +1,83 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_BUILTIN_NEW_ALLOCATOR_H
+#define _LIBCUDACXX___MEMORY_BUILTIN_NEW_ALLOCATOR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__memory/unique_ptr.h>
+#include <cuda/std/__new_>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// __builtin_new_allocator -- A non-templated helper for allocating and
+// deallocating memory using __builtin_operator_new and
+// __builtin_operator_delete. It should be used in preference to
+// `std::allocator<T>` to avoid additional instantiations.
+struct __builtin_new_allocator
+{
+  struct __builtin_new_deleter
+  {
+    typedef void* pointer_type;
+
+    _LIBCUDACXX_HIDE_FROM_ABI constexpr explicit __builtin_new_deleter(size_t __size, size_t __align) noexcept
+        : __size_(__size)
+        , __align_(__align)
+    {}
+
+    _LIBCUDACXX_HIDE_FROM_ABI void operator()(void* __p) const noexcept
+    {
+      _CUDA_VSTD::__cccl_deallocate(__p, __size_, __align_);
+    }
+
+  private:
+    size_t __size_;
+    size_t __align_;
+  };
+
+  typedef unique_ptr<void, __builtin_new_deleter> __holder_t;
+
+  _LIBCUDACXX_HIDE_FROM_ABI static __holder_t __allocate_bytes(size_t __s, size_t __align)
+  {
+    return __holder_t(_CUDA_VSTD::__cccl_allocate(__s, __align), __builtin_new_deleter(__s, __align));
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI static void __deallocate_bytes(void* __p, size_t __s, size_t __align) noexcept
+  {
+    _CUDA_VSTD::__cccl_deallocate(__p, __s, __align);
+  }
+
+  template <class _Tp>
+  _CCCL_NODEBUG_ALIAS _LIBCUDACXX_HIDE_FROM_ABI static __holder_t __allocate_type(size_t __n)
+  {
+    return __allocate_bytes(__n * sizeof(_Tp), _LIBCUDACXX_ALIGNOF(_Tp));
+  }
+
+  template <class _Tp>
+  _CCCL_NODEBUG_ALIAS _LIBCUDACXX_HIDE_FROM_ABI static void __deallocate_type(void* __p, size_t __n) noexcept
+  {
+    __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCUDACXX_ALIGNOF(_Tp));
+  }
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_BUILTIN_NEW_ALLOCATOR_H

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

@@ -0,0 +1,227 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_COMPRESSED_PAIR_H
+#define _LIBCUDACXX___MEMORY_COMPRESSED_PAIR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__fwd/get.h>
+#include <cuda/std/__fwd/tuple.h>
+#include <cuda/std/__tuple_dir/tuple_indices.h>
+#include <cuda/std/__type_traits/decay.h>
+#include <cuda/std/__type_traits/dependent_type.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/is_default_constructible.h>
+#include <cuda/std/__type_traits/is_empty.h>
+#include <cuda/std/__type_traits/is_final.h>
+#include <cuda/std/__type_traits/is_nothrow_constructible.h>
+#include <cuda/std/__type_traits/is_nothrow_default_constructible.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/is_swappable.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/__utility/piecewise_construct.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// Tag used to default initialize one or both of the pair's elements.
+struct __default_init_tag
+{};
+struct __value_init_tag
+{};
+
+template <class _Tp, int _Idx, bool _CanBeEmptyBase = _CCCL_TRAIT(is_empty, _Tp) && !_CCCL_TRAIT(is_final, _Tp)>
+struct __compressed_pair_elem
+{
+  using _ParamT         = _Tp;
+  using reference       = _Tp&;
+  using const_reference = const _Tp&;
+
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr explicit __compressed_pair_elem(__default_init_tag) noexcept(
+    _CCCL_TRAIT(is_nothrow_default_constructible, _Tp))
+  {}
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr explicit __compressed_pair_elem(__value_init_tag) noexcept(
+    _CCCL_TRAIT(is_nothrow_default_constructible, _Tp))
+      : __value_()
+  {}
+
+  template <class _Up, enable_if_t<!_CCCL_TRAIT(is_same, __compressed_pair_elem, decay_t<_Up>), int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr explicit __compressed_pair_elem(_Up&& __u) noexcept(
+    _CCCL_TRAIT(is_nothrow_constructible, _Tp, _Up))
+      : __value_(_CUDA_VSTD::forward<_Up>(__u))
+  {}
+
+  template <class... _Args, size_t... _Indices>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX17 explicit __compressed_pair_elem(
+    piecewise_construct_t,
+    tuple<_Args...> __args,
+    __tuple_indices<_Indices...>) noexcept(_CCCL_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+      : __value_(_CUDA_VSTD::forward<_Args>(_CUDA_VSTD::get<_Indices>(__args))...)
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 reference __get() noexcept
+  {
+    return __value_;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr const_reference __get() const noexcept
+  {
+    return __value_;
+  }
+
+private:
+  _Tp __value_;
+};
+
+template <class _Tp, int _Idx>
+struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp
+{
+  using _ParamT         = _Tp;
+  using reference       = _Tp&;
+  using const_reference = const _Tp&;
+  using __value_type    = _Tp;
+
+  _CCCL_HIDE_FROM_ABI explicit constexpr __compressed_pair_elem() = default;
+
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr explicit __compressed_pair_elem(__default_init_tag) noexcept(
+    _CCCL_TRAIT(is_nothrow_default_constructible, _Tp))
+  {}
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr explicit __compressed_pair_elem(__value_init_tag) noexcept(
+    _CCCL_TRAIT(is_nothrow_default_constructible, _Tp))
+      : __value_type()
+  {}
+
+  template <class _Up, enable_if_t<!_CCCL_TRAIT(is_same, __compressed_pair_elem, decay_t<_Up>), int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr explicit __compressed_pair_elem(_Up&& __u) noexcept(
+    _CCCL_TRAIT(is_nothrow_constructible, _Tp, _Up))
+      : __value_type(_CUDA_VSTD::forward<_Up>(__u))
+  {}
+
+  template <class... _Args, size_t... _Indices>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX17 __compressed_pair_elem(
+    piecewise_construct_t,
+    tuple<_Args...> __args,
+    __tuple_indices<_Indices...>) noexcept(_CCCL_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+      : __value_type(_CUDA_VSTD::forward<_Args>(_CUDA_VSTD::get<_Indices>(__args))...)
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 reference __get() noexcept
+  {
+    return *this;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr const_reference __get() const noexcept
+  {
+    return *this;
+  }
+};
+
+template <class _T1, class _T2>
+class __compressed_pair
+    : private __compressed_pair_elem<_T1, 0>
+    , private __compressed_pair_elem<_T2, 1>
+{
+public:
+  // NOTE: This static assert should never fire because __compressed_pair
+  // is *almost never* used in a scenario where it's possible for T1 == T2.
+  // (The exception is std::function where it is possible that the function
+  //  object and the allocator have the same type).
+  static_assert((!_CCCL_TRAIT(is_same, _T1, _T2)),
+                "__compressed_pair cannot be instantiated when T1 and T2 are the same type; "
+                "The current implementation is NOT ABI-compatible with the previous implementation for this "
+                "configuration");
+
+  using _Base1 _CCCL_NODEBUG_ALIAS = __compressed_pair_elem<_T1, 0>;
+  using _Base2 _CCCL_NODEBUG_ALIAS = __compressed_pair_elem<_T2, 1>;
+
+  template <bool _Dummy = true,
+            class       = enable_if_t<__dependent_type<is_default_constructible<_T1>, _Dummy>::value
+                                      && __dependent_type<is_default_constructible<_T2>, _Dummy>::value>>
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr explicit __compressed_pair() noexcept(
+    _CCCL_TRAIT(is_nothrow_default_constructible, _T1) && _CCCL_TRAIT(is_nothrow_default_constructible, _T2))
+      : _Base1(__value_init_tag())
+      , _Base2(__value_init_tag())
+  {}
+
+  template <class _U1, class _U2>
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr explicit __compressed_pair(_U1&& __t1, _U2&& __t2) noexcept(
+    _CCCL_TRAIT(is_constructible, _T1, _U1) && _CCCL_TRAIT(is_constructible, _T2, _U2))
+      : _Base1(_CUDA_VSTD::forward<_U1>(__t1))
+      , _Base2(_CUDA_VSTD::forward<_U2>(__t2))
+  {}
+
+  template <class... _Args1, class... _Args2>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX17 explicit __compressed_pair(
+    piecewise_construct_t __pc,
+    tuple<_Args1...> __first_args,
+    tuple<_Args2...> __second_args) noexcept(_CCCL_TRAIT(is_constructible, _T1, _Args1...)
+                                             && _CCCL_TRAIT(is_constructible, _T2, _Args2...))
+      : _Base1(__pc, _CUDA_VSTD::move(__first_args), typename __make_tuple_indices<sizeof...(_Args1)>::type())
+      , _Base2(__pc, _CUDA_VSTD::move(__second_args), typename __make_tuple_indices<sizeof...(_Args2)>::type())
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 typename _Base1::reference first() noexcept
+  {
+    return static_cast<_Base1&>(*this).__get();
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr typename _Base1::const_reference first() const noexcept
+  {
+    return static_cast<_Base1 const&>(*this).__get();
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 typename _Base2::reference second() noexcept
+  {
+    return static_cast<_Base2&>(*this).__get();
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr typename _Base2::const_reference second() const noexcept
+  {
+    return static_cast<_Base2 const&>(*this).__get();
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr static _Base1* __get_first_base(__compressed_pair* __pair) noexcept
+  {
+    return static_cast<_Base1*>(__pair);
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr static _Base2* __get_second_base(__compressed_pair* __pair) noexcept
+  {
+    return static_cast<_Base2*>(__pair);
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void
+  swap(__compressed_pair& __x) noexcept(__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value)
+  {
+    using _CUDA_VSTD::swap;
+    swap(first(), __x.first());
+    swap(second(), __x.second());
+  }
+};
+
+template <class _T1, class _T2>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void swap(
+  __compressed_pair<_T1, _T2>& __x,
+  __compressed_pair<_T1, _T2>& __y) noexcept(__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value)
+{
+  __x.swap(__y);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_COMPRESSED_PAIR_H

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

@@ -0,0 +1,268 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_CONSTRUCT_AT_H
+#define _LIBCUDACXX___MEMORY_CONSTRUCT_AT_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__iterator/access.h>
+#include <cuda/std/__memory/addressof.h>
+#include <cuda/std/__memory/voidify.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_arithmetic.h>
+#include <cuda/std/__type_traits/is_array.h>
+#include <cuda/std/__type_traits/is_constant_evaluated.h>
+#include <cuda/std/__type_traits/is_trivially_constructible.h>
+#include <cuda/std/__type_traits/is_trivially_destructible.h>
+#include <cuda/std/__type_traits/is_trivially_move_assignable.h>
+#include <cuda/std/__type_traits/void_t.h>
+#include <cuda/std/__utility/declval.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/__utility/move.h>
+
+#if _CCCL_CUDA_COMPILER(CLANG)
+#  include <new>
+#endif // _CCCL_CUDA_COMPILER(CLANG)
+
+#if _CCCL_STD_VER >= 2020 // need to backfill ::std::construct_at
+#  if !_CCCL_COMPILER(NVRTC)
+#    include <memory>
+#  endif // _CCCL_COMPILER(NVRTC)
+
+#  ifndef __cpp_lib_constexpr_dynamic_alloc
+namespace std
+{
+_CCCL_EXEC_CHECK_DISABLE
+template <class _Tp,
+          class... _Args,
+          class = decltype(::new(_CUDA_VSTD::declval<void*>()) _Tp(_CUDA_VSTD::declval<_Args>()...))>
+_LIBCUDACXX_HIDE_FROM_ABI constexpr _Tp* construct_at(_Tp* __location, _Args&&... __args)
+{
+#    if defined(_CCCL_BUILTIN_ADDRESSOF)
+  return ::new (_CUDA_VSTD::__voidify(*__location)) _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+#    else
+  return ::new (const_cast<void*>(static_cast<const volatile void*>(__location)))
+    _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+#    endif
+}
+} // namespace std
+#  endif // __cpp_lib_constexpr_dynamic_alloc
+#endif // _CCCL_STD_VER >= 2020
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// There is a performance issue with placement new, where EDG based compiler insert a nullptr check that is superfluous
+// Because this is a noticeable performance regression, we specialize it for certain types
+// This is possible because we are calling ::new ignoring any user defined overloads of operator placement new
+namespace __detail
+{
+// We cannot allow narrowing conversions between arithmetic types as the assignment will give errors
+template <class _To, class...>
+struct __is_narrowing_impl : false_type
+{};
+
+template <class _To, class _From>
+struct __is_narrowing_impl<_To, _From> : true_type
+{};
+
+// This is a bit hacky, but we rely on the fact that arithmetic types cannot have more than one argument to their
+// constructor
+template <class _To, class _From>
+struct __is_narrowing_impl<_To, _From, void_t<decltype(_To{_CUDA_VSTD::declval<_From>()})>> : false_type
+{};
+
+template <class _Tp, class... _Args>
+using __is_narrowing = _If<_CCCL_TRAIT(is_arithmetic, _Tp), __is_narrowing_impl<_Tp, _Args...>, false_type>;
+
+// The destination type must be trivially constructible from the arguments and also trivially assignable, because we
+// technically move assign in the optimization
+template <class _Tp, class... _Args>
+struct __can_optimize_construct_at
+    : integral_constant<bool,
+                        _CCCL_TRAIT(is_trivially_constructible, _Tp, _Args...)
+                          && _CCCL_TRAIT(is_trivially_move_assignable, _Tp) && !__is_narrowing<_Tp, _Args...>::value>
+{};
+} // namespace __detail
+
+// construct_at
+#if _CCCL_STD_VER >= 2020
+
+_CCCL_EXEC_CHECK_DISABLE
+template <class _Tp,
+          class... _Args,
+          class = decltype(::new(_CUDA_VSTD::declval<void*>()) _Tp(_CUDA_VSTD::declval<_Args>()...))>
+_LIBCUDACXX_HIDE_FROM_ABI
+_CCCL_CONSTEXPR_CXX20 enable_if_t<!__detail::__can_optimize_construct_at<_Tp, _Args...>::value, _Tp*>
+construct_at(_Tp* __location, _Args&&... __args)
+{
+  _CCCL_ASSERT(__location != nullptr, "null pointer given to construct_at");
+  // Need to go through `std::construct_at` as that is the explicitly blessed function
+  if (_CUDA_VSTD::is_constant_evaluated())
+  {
+    return ::std::construct_at(__location, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+  return ::new (_CUDA_VSTD::__voidify(*__location)) _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <class _Tp,
+          class... _Args,
+          class = decltype(::new(_CUDA_VSTD::declval<void*>()) _Tp(_CUDA_VSTD::declval<_Args>()...))>
+_LIBCUDACXX_HIDE_FROM_ABI
+_CCCL_CONSTEXPR_CXX20 enable_if_t<__detail::__can_optimize_construct_at<_Tp, _Args...>::value, _Tp*>
+construct_at(_Tp* __location, _Args&&... __args)
+{
+  _CCCL_ASSERT(__location != nullptr, "null pointer given to construct_at");
+  // Need to go through `std::construct_at` as that is the explicitly blessed function
+  if (_CUDA_VSTD::is_constant_evaluated())
+  {
+    return ::std::construct_at(__location, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+  *__location = _Tp{_CUDA_VSTD::forward<_Args>(__args)...};
+  return __location;
+}
+
+#endif // _CCCL_STD_VER >= 2020
+
+_CCCL_EXEC_CHECK_DISABLE
+template <class _Tp, class... _Args>
+_LIBCUDACXX_HIDE_FROM_ABI
+_CCCL_CONSTEXPR_CXX20 enable_if_t<!__detail::__can_optimize_construct_at<_Tp, _Args...>::value, _Tp*>
+__construct_at(_Tp* __location, _Args&&... __args)
+{
+  _CCCL_ASSERT(__location != nullptr, "null pointer given to construct_at");
+#if _CCCL_STD_VER >= 2020
+  // Need to go through `std::construct_at` as that is the explicitly blessed function
+  if (_CUDA_VSTD::is_constant_evaluated())
+  {
+    return ::std::construct_at(__location, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+#endif // _CCCL_STD_VER >= 2020
+  return ::new (_CUDA_VSTD::__voidify(*__location)) _Tp(_CUDA_VSTD::forward<_Args>(__args)...);
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <class _Tp, class... _Args>
+_LIBCUDACXX_HIDE_FROM_ABI
+_CCCL_CONSTEXPR_CXX20 enable_if_t<__detail::__can_optimize_construct_at<_Tp, _Args...>::value, _Tp*>
+__construct_at(_Tp* __location, _Args&&... __args)
+{
+  _CCCL_ASSERT(__location != nullptr, "null pointer given to construct_at");
+#if _CCCL_STD_VER >= 2020
+  // Need to go through `std::construct_at` as that is the explicitly blessed function
+  if (_CUDA_VSTD::is_constant_evaluated())
+  {
+    return ::std::construct_at(__location, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+#endif // _CCCL_STD_VER >= 2020
+  *__location = _Tp{_CUDA_VSTD::forward<_Args>(__args)...};
+  return __location;
+}
+
+// destroy_at
+
+// The internal functions are available regardless of the language version (with the exception of the `__destroy_at`
+// taking an array).
+template <class _ForwardIterator>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 _ForwardIterator __destroy(_ForwardIterator, _ForwardIterator);
+
+_CCCL_EXEC_CHECK_DISABLE
+template <class _Tp,
+          enable_if_t<!_CCCL_TRAIT(is_array, _Tp), int>                  = 0,
+          enable_if_t<!_CCCL_TRAIT(is_trivially_destructible, _Tp), int> = 0>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void __destroy_at(_Tp* __loc)
+{
+  _CCCL_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
+  __loc->~_Tp();
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template <class _Tp,
+          enable_if_t<!_CCCL_TRAIT(is_array, _Tp), int>                 = 0,
+          enable_if_t<_CCCL_TRAIT(is_trivially_destructible, _Tp), int> = 0>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void __destroy_at(_Tp* __loc)
+{
+  _CCCL_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
+  (void) __loc;
+}
+
+template <class _Tp, enable_if_t<_CCCL_TRAIT(is_array, _Tp), int> = 0>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void __destroy_at(_Tp* __loc)
+{
+  _CCCL_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
+  _CUDA_VSTD::__destroy(_CUDA_VSTD::begin(*__loc), _CUDA_VSTD::end(*__loc));
+}
+
+template <class _ForwardIterator>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 _ForwardIterator
+__destroy(_ForwardIterator __first, _ForwardIterator __last)
+{
+  for (; __first != __last; ++__first)
+  {
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(*__first));
+  }
+  return __first;
+}
+
+template <class _BidirectionalIterator>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 _BidirectionalIterator
+__reverse_destroy(_BidirectionalIterator __first, _BidirectionalIterator __last)
+{
+  while (__last != __first)
+  {
+    --__last;
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(*__last));
+  }
+  return __last;
+}
+
+template <class _Tp, enable_if_t<!_CCCL_TRAIT(is_array, _Tp), int> = 0>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void destroy_at(_Tp* __loc)
+{
+  _CCCL_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
+  __loc->~_Tp();
+}
+
+template <class _Tp, enable_if_t<_CCCL_TRAIT(is_array, _Tp), int> = 0>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void destroy_at(_Tp* __loc)
+{
+  _CUDA_VSTD::__destroy_at(__loc);
+}
+
+template <class _ForwardIterator>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void destroy(_ForwardIterator __first, _ForwardIterator __last) noexcept
+{
+  (void) _CUDA_VSTD::__destroy(_CUDA_VSTD::move(__first), _CUDA_VSTD::move(__last));
+}
+
+template <class _ForwardIterator, class _Size>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 _ForwardIterator destroy_n(_ForwardIterator __first, _Size __n)
+{
+  for (; __n > 0; (void) ++__first, --__n)
+  {
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(*__first));
+  }
+  return __first;
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_CONSTRUCT_AT_H

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

@@ -0,0 +1,87 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_DESTRUCT_N_H
+#define _LIBCUDACXX___MEMORY_DESTRUCT_N_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_trivially_destructible.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct __destruct_n
+{
+private:
+  size_t __size_;
+
+  template <class _Tp>
+  _LIBCUDACXX_HIDE_FROM_ABI void __process(_Tp* __p, false_type) noexcept
+  {
+    for (size_t __i = 0; __i < __size_; ++__i, ++__p)
+    {
+      __p->~_Tp();
+    }
+  }
+
+  template <class _Tp>
+  _LIBCUDACXX_HIDE_FROM_ABI void __process(_Tp*, true_type) noexcept
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI void __incr(false_type) noexcept
+  {
+    ++__size_;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI void __incr(true_type) noexcept {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI void __set(size_t __s, false_type) noexcept
+  {
+    __size_ = __s;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI void __set(size_t, true_type) noexcept {}
+
+public:
+  _LIBCUDACXX_HIDE_FROM_ABI explicit __destruct_n(size_t __s) noexcept
+      : __size_(__s)
+  {}
+
+  template <class _Tp>
+  _LIBCUDACXX_HIDE_FROM_ABI void __incr() noexcept
+  {
+    __incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());
+  }
+
+  template <class _Tp>
+  _LIBCUDACXX_HIDE_FROM_ABI void __set(size_t __s, _Tp*) noexcept
+  {
+    __set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());
+  }
+
+  template <class _Tp>
+  _LIBCUDACXX_HIDE_FROM_ABI void operator()(_Tp* __p) noexcept
+  {
+    __process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());
+  }
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_DESTRUCT_N_H

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

@@ -0,0 +1,250 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_POINTER_TRAITS_H
+#define _LIBCUDACXX___MEMORY_POINTER_TRAITS_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__memory/addressof.h>
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/conjunction.h>
+#include <cuda/std/__type_traits/decay.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_class.h>
+#include <cuda/std/__type_traits/is_function.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__type_traits/void_t.h>
+#include <cuda/std/__utility/declval.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class = void>
+struct __has_element_type : false_type
+{};
+
+template <class _Tp>
+struct __has_element_type<_Tp, void_t<typename _Tp::element_type>> : true_type
+{};
+
+template <class _Ptr, bool = __has_element_type<_Ptr>::value>
+struct __pointer_traits_element_type;
+
+template <class _Ptr>
+struct __pointer_traits_element_type<_Ptr, true>
+{
+  typedef _CCCL_NODEBUG_ALIAS typename _Ptr::element_type type;
+};
+
+template <template <class, class...> class _Sp, class _Tp, class... _Args>
+struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true>
+{
+  typedef _CCCL_NODEBUG_ALIAS typename _Sp<_Tp, _Args...>::element_type type;
+};
+
+template <template <class, class...> class _Sp, class _Tp, class... _Args>
+struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false>
+{
+  typedef _CCCL_NODEBUG_ALIAS _Tp type;
+};
+
+template <class _Tp, class = void>
+struct __has_difference_type : false_type
+{};
+
+template <class _Tp>
+struct __has_difference_type<_Tp, void_t<typename _Tp::difference_type>> : true_type
+{};
+
+template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
+struct __pointer_traits_difference_type
+{
+  typedef _CCCL_NODEBUG_ALIAS ptrdiff_t type;
+};
+
+template <class _Ptr>
+struct __pointer_traits_difference_type<_Ptr, true>
+{
+  typedef _CCCL_NODEBUG_ALIAS typename _Ptr::difference_type type;
+};
+
+template <class _Tp, class _Up>
+struct __has_rebind
+{
+private:
+  template <class _Xp>
+  _LIBCUDACXX_HIDE_FROM_ABI static false_type __test(...);
+  _CCCL_SUPPRESS_DEPRECATED_PUSH
+  template <class _Xp>
+  _LIBCUDACXX_HIDE_FROM_ABI static true_type __test(typename _Xp::template rebind<_Up>* = 0);
+  _CCCL_SUPPRESS_DEPRECATED_POP
+
+public:
+  static const bool value = decltype(__test<_Tp>(0))::value;
+};
+
+template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
+struct __pointer_traits_rebind
+{
+  typedef _CCCL_NODEBUG_ALIAS typename _Tp::template rebind<_Up> type;
+};
+
+template <template <class, class...> class _Sp, class _Tp, class... _Args, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true>
+{
+  typedef _CCCL_NODEBUG_ALIAS typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
+};
+
+template <template <class, class...> class _Sp, class _Tp, class... _Args, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false>
+{
+  typedef _Sp<_Up, _Args...> type;
+};
+
+template <class _Ptr>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT pointer_traits
+{
+  typedef _Ptr pointer;
+  typedef typename __pointer_traits_element_type<pointer>::type element_type;
+  typedef typename __pointer_traits_difference_type<pointer>::type difference_type;
+
+  template <class _Up>
+  using rebind = typename __pointer_traits_rebind<pointer, _Up>::type;
+
+private:
+  struct __nat
+  {};
+
+public:
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static pointer
+  pointer_to(conditional_t<is_void<element_type>::value, __nat, element_type>& __r)
+  {
+    return pointer::pointer_to(__r);
+  }
+};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT pointer_traits<_Tp*>
+{
+  typedef _Tp* pointer;
+  typedef _Tp element_type;
+  typedef ptrdiff_t difference_type;
+
+  template <class _Up>
+  using rebind = _Up*;
+
+private:
+  struct __nat
+  {};
+
+public:
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 static pointer
+  pointer_to(conditional_t<is_void<element_type>::value, __nat, element_type>& __r) noexcept
+  {
+    return _CUDA_VSTD::addressof(__r);
+  }
+};
+
+template <class _From, class _To>
+struct __rebind_pointer
+{
+  typedef typename pointer_traits<_From>::template rebind<_To> type;
+};
+
+// to_address
+
+template <class _Pointer, class = void>
+struct __to_address_helper;
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI constexpr _Tp* __to_address(_Tp* __p) noexcept
+{
+  static_assert(!is_function<_Tp>::value, "_Tp is a function type");
+  return __p;
+}
+
+template <class _Pointer, class = void>
+struct _HasToAddress : false_type
+{};
+
+template <class _Pointer>
+struct _HasToAddress<_Pointer, decltype((void) pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))>
+    : true_type
+{};
+
+template <class _Pointer, class = void>
+struct _HasArrow : false_type
+{};
+
+template <class _Pointer>
+struct _HasArrow<_Pointer, decltype((void) declval<const _Pointer&>().operator->())> : true_type
+{};
+
+template <class _Pointer>
+struct _IsFancyPointer
+{
+  static const bool value = _HasArrow<_Pointer>::value || _HasToAddress<_Pointer>::value;
+};
+
+// enable_if is needed here to avoid instantiating checks for fancy pointers on raw pointers
+template <class _Pointer, class = enable_if_t<_And<is_class<_Pointer>, _IsFancyPointer<_Pointer>>::value>>
+_LIBCUDACXX_HIDE_FROM_ABI constexpr decay_t<decltype(__to_address_helper<_Pointer>::__call(declval<const _Pointer&>()))>
+__to_address(const _Pointer& __p) noexcept
+{
+  return __to_address_helper<_Pointer>::__call(__p);
+}
+
+template <class _Pointer, class>
+struct __to_address_helper
+{
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr static decltype(_CUDA_VSTD::__to_address(declval<const _Pointer&>().operator->()))
+  __call(const _Pointer& __p) noexcept
+  {
+    return _CUDA_VSTD::__to_address(__p.operator->());
+  }
+};
+
+template <class _Pointer>
+struct __to_address_helper<_Pointer, decltype((void) pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))>
+{
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr static decltype(pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))
+  __call(const _Pointer& __p) noexcept
+  {
+    return pointer_traits<_Pointer>::to_address(__p);
+  }
+};
+
+#if _CCCL_STD_VER > 2011
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI constexpr auto to_address(_Tp* __p) noexcept
+{
+  return _CUDA_VSTD::__to_address(__p);
+}
+
+template <class _Pointer>
+_LIBCUDACXX_HIDE_FROM_ABI constexpr auto
+to_address(const _Pointer& __p) noexcept -> decltype(_CUDA_VSTD::__to_address(__p))
+{
+  return _CUDA_VSTD::__to_address(__p);
+}
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_POINTER_TRAITS_H

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

@@ -0,0 +1,672 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_UNINITIALIZED_ALGORITHMS_H
+#define _LIBCUDACXX___MEMORY_UNINITIALIZED_ALGORITHMS_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__algorithm/copy.h>
+#include <cuda/std/__algorithm/iterator_operations.h>
+#include <cuda/std/__algorithm/move.h>
+#include <cuda/std/__algorithm/unwrap_iter.h>
+#include <cuda/std/__algorithm/unwrap_range.h>
+#include <cuda/std/__memory/addressof.h>
+#include <cuda/std/__memory/allocator_traits.h>
+#include <cuda/std/__memory/construct_at.h>
+#include <cuda/std/__memory/pointer_traits.h>
+#include <cuda/std/__memory/voidify.h>
+#include <cuda/std/__new_>
+#include <cuda/std/__type_traits/extent.h>
+#include <cuda/std/__type_traits/is_array.h>
+#include <cuda/std/__type_traits/is_constant_evaluated.h>
+#include <cuda/std/__type_traits/is_trivially_copy_assignable.h>
+#include <cuda/std/__type_traits/is_trivially_copy_constructible.h>
+#include <cuda/std/__type_traits/is_trivially_move_assignable.h>
+#include <cuda/std/__type_traits/is_trivially_move_constructible.h>
+#include <cuda/std/__type_traits/is_unbounded_array.h>
+#include <cuda/std/__type_traits/negation.h>
+#include <cuda/std/__type_traits/remove_const.h>
+#include <cuda/std/__type_traits/remove_extent.h>
+#include <cuda/std/__utility/exception_guard.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/__utility/pair.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct __always_false
+{
+  template <class... _Args>
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr bool operator()(_Args&&...) const noexcept
+  {
+    return false;
+  }
+};
+
+template <class _ForwardIterator>
+struct __simple_rollback
+{
+  _ForwardIterator& __first_;
+  _ForwardIterator& __current_;
+
+  _LIBCUDACXX_HIDE_FROM_ABI __simple_rollback(_ForwardIterator& __first, _ForwardIterator& __current)
+      : __first_(__first)
+      , __current_(__current)
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI void operator()() const noexcept
+  {
+    _CUDA_VSTD::__destroy(__first_, __current_);
+  }
+};
+
+// uninitialized_copy
+
+template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _EndPredicate>
+_LIBCUDACXX_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> __uninitialized_copy(
+  _InputIterator __ifirst, _Sentinel1 __ilast, _ForwardIterator __ofirst, _EndPredicate __stop_copying)
+{
+  _ForwardIterator __idx = __ofirst;
+  auto __guard           = __make_exception_guard(__simple_rollback<_ForwardIterator>{__ofirst, __idx});
+  for (; __ifirst != __ilast && !__stop_copying(__idx); ++__ifirst, (void) ++__idx)
+  {
+    ::new (_CUDA_VSTD::__voidify(*__idx)) _ValueType(*__ifirst);
+  }
+  __guard.__complete();
+
+  return pair<_InputIterator, _ForwardIterator>(_CUDA_VSTD::move(__ifirst), _CUDA_VSTD::move(__idx));
+}
+
+template <class _InputIterator, class _ForwardIterator>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator
+uninitialized_copy(_InputIterator __ifirst, _InputIterator __ilast, _ForwardIterator __ofirst)
+{
+  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+  auto __result = _CUDA_VSTD::__uninitialized_copy<_ValueType>(
+    _CUDA_VSTD::move(__ifirst), _CUDA_VSTD::move(__ilast), _CUDA_VSTD::move(__ofirst), __always_false{});
+  return _CUDA_VSTD::move(__result.second);
+}
+
+// uninitialized_copy_n
+
+template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _EndPredicate>
+_LIBCUDACXX_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+__uninitialized_copy_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst, _EndPredicate __stop_copying)
+{
+  _ForwardIterator __idx = __ofirst;
+  auto __guard           = __make_exception_guard(__simple_rollback<_ForwardIterator>{__ofirst, __idx});
+  for (; __n > 0 && !__stop_copying(__idx); ++__ifirst, (void) ++__idx, (void) --__n)
+  {
+    ::new (_CUDA_VSTD::__voidify(*__idx)) _ValueType(*__ifirst);
+  }
+  __guard.__complete();
+
+  return pair<_InputIterator, _ForwardIterator>(_CUDA_VSTD::move(__ifirst), _CUDA_VSTD::move(__idx));
+}
+
+template <class _InputIterator, class _Size, class _ForwardIterator>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator
+uninitialized_copy_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst)
+{
+  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+  auto __result = _CUDA_VSTD::__uninitialized_copy_n<_ValueType>(
+    _CUDA_VSTD::move(__ifirst), __n, _CUDA_VSTD::move(__ofirst), __always_false{});
+  return _CUDA_VSTD::move(__result.second);
+}
+
+// uninitialized_fill
+
+template <class _ValueType, class _ForwardIterator, class _Sentinel, class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator
+__uninitialized_fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __x)
+{
+  _ForwardIterator __idx = __first;
+  auto __guard           = __make_exception_guard(__simple_rollback<_ForwardIterator>{__first, __idx});
+  for (; __idx != __last; ++__idx)
+  {
+    ::new (_CUDA_VSTD::__voidify(*__idx)) _ValueType(__x);
+  }
+  __guard.__complete();
+
+  return __idx;
+}
+
+template <class _ForwardIterator, class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI void uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x)
+{
+  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+  (void) _CUDA_VSTD::__uninitialized_fill<_ValueType>(__first, __last, __x);
+}
+
+// uninitialized_fill_n
+
+template <class _ValueType, class _ForwardIterator, class _Size, class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator __uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+{
+  _ForwardIterator __idx = __first;
+  auto __guard           = __make_exception_guard(__simple_rollback<_ForwardIterator>{__first, __idx});
+  for (; __n > 0; ++__idx, (void) --__n)
+  {
+    ::new (_CUDA_VSTD::__voidify(*__idx)) _ValueType(__x);
+  }
+  __guard.__complete();
+
+  return __idx;
+}
+
+template <class _ForwardIterator, class _Size, class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+{
+  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+  return _CUDA_VSTD::__uninitialized_fill_n<_ValueType>(__first, __n, __x);
+}
+
+// uninitialized_default_construct
+
+template <class _ValueType, class _ForwardIterator, class _Sentinel>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator __uninitialized_default_construct(_ForwardIterator __first, _Sentinel __last)
+{
+  auto __idx   = __first;
+  auto __guard = __make_exception_guard(__simple_rollback<_ForwardIterator>{__first, __idx});
+  for (; __idx != __last; ++__idx)
+  {
+    ::new (_CUDA_VSTD::__voidify(*__idx)) _ValueType;
+  }
+  __guard.__complete();
+
+  return __idx;
+}
+
+template <class _ForwardIterator>
+_LIBCUDACXX_HIDE_FROM_ABI void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last)
+{
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  (void) _CUDA_VSTD::__uninitialized_default_construct<_ValueType>(_CUDA_VSTD::move(__first), _CUDA_VSTD::move(__last));
+}
+
+// uninitialized_default_construct_n
+
+template <class _ValueType, class _ForwardIterator, class _Size>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator __uninitialized_default_construct_n(_ForwardIterator __first, _Size __n)
+{
+  auto __idx   = __first;
+  auto __guard = __make_exception_guard(__simple_rollback<_ForwardIterator>{__first, __idx});
+  for (; __n > 0; ++__idx, (void) --__n)
+  {
+    ::new (_CUDA_VSTD::__voidify(*__idx)) _ValueType;
+  }
+  __guard.__complete();
+
+  return __idx;
+}
+
+template <class _ForwardIterator, class _Size>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n)
+{
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  return _CUDA_VSTD::__uninitialized_default_construct_n<_ValueType>(_CUDA_VSTD::move(__first), __n);
+}
+
+// uninitialized_value_construct
+
+template <class _ValueType, class _ForwardIterator, class _Sentinel>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator __uninitialized_value_construct(_ForwardIterator __first, _Sentinel __last)
+{
+  auto __idx   = __first;
+  auto __guard = __make_exception_guard(__simple_rollback<_ForwardIterator>{__first, __idx});
+  for (; __idx != __last; ++__idx)
+  {
+    ::new (_CUDA_VSTD::__voidify(*__idx)) _ValueType();
+  }
+  __guard.__complete();
+
+  return __idx;
+}
+
+template <class _ForwardIterator>
+_LIBCUDACXX_HIDE_FROM_ABI void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last)
+{
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  (void) _CUDA_VSTD::__uninitialized_value_construct<_ValueType>(_CUDA_VSTD::move(__first), _CUDA_VSTD::move(__last));
+}
+
+// uninitialized_value_construct_n
+
+template <class _ValueType, class _ForwardIterator, class _Size>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator __uninitialized_value_construct_n(_ForwardIterator __first, _Size __n)
+{
+  auto __idx   = __first;
+  auto __guard = __make_exception_guard(__simple_rollback<_ForwardIterator>{__first, __idx});
+  for (; __n > 0; ++__idx, (void) --__n)
+  {
+    ::new (_CUDA_VSTD::__voidify(*__idx)) _ValueType();
+  }
+  __guard.__complete();
+
+  return __idx;
+}
+
+template <class _ForwardIterator, class _Size>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n)
+{
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  return _CUDA_VSTD::__uninitialized_value_construct_n<_ValueType>(_CUDA_VSTD::move(__first), __n);
+}
+
+// uninitialized_move
+
+template <class _ValueType,
+          class _IterOps,
+          class _InputIterator,
+          class _Sentinel1,
+          class _ForwardIterator,
+          class _EndPredicate>
+_LIBCUDACXX_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> __uninitialized_move(
+  _InputIterator __ifirst, _Sentinel1 __ilast, _ForwardIterator __ofirst, _EndPredicate __stop_moving)
+{
+  auto __idx   = __ofirst;
+  auto __guard = __make_exception_guard(__simple_rollback<_ForwardIterator>{__ofirst, __idx});
+  for (; __ifirst != __ilast && !__stop_moving(__idx); ++__idx, (void) ++__ifirst)
+  {
+    ::new (_CUDA_VSTD::__voidify(*__idx)) _ValueType(_IterOps::__iter_move(__ifirst));
+  }
+  __guard.__complete();
+
+  return {_CUDA_VSTD::move(__ifirst), _CUDA_VSTD::move(__idx)};
+}
+
+template <class _InputIterator, class _ForwardIterator>
+_LIBCUDACXX_HIDE_FROM_ABI _ForwardIterator
+uninitialized_move(_InputIterator __ifirst, _InputIterator __ilast, _ForwardIterator __ofirst)
+{
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  auto __result    = _CUDA_VSTD::__uninitialized_move<_ValueType, _IterOps<_ClassicAlgPolicy>>(
+    _CUDA_VSTD::move(__ifirst), _CUDA_VSTD::move(__ilast), _CUDA_VSTD::move(__ofirst), __always_false{});
+  return _CUDA_VSTD::move(__result.second);
+}
+
+// uninitialized_move_n
+
+template <class _ValueType, class _IterOps, class _InputIterator, class _Size, class _ForwardIterator, class _EndPredicate>
+_LIBCUDACXX_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+__uninitialized_move_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst, _EndPredicate __stop_moving)
+{
+  auto __idx   = __ofirst;
+  auto __guard = __make_exception_guard(__simple_rollback<_ForwardIterator>{__ofirst, __idx});
+  for (; __n > 0 && !__stop_moving(__idx); ++__idx, (void) ++__ifirst, --__n)
+  {
+    ::new (_CUDA_VSTD::__voidify(*__idx)) _ValueType(_IterOps::__iter_move(__ifirst));
+  }
+  __guard.__complete();
+
+  return {_CUDA_VSTD::move(__ifirst), _CUDA_VSTD::move(__idx)};
+}
+
+template <class _InputIterator, class _Size, class _ForwardIterator>
+_LIBCUDACXX_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+uninitialized_move_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst)
+{
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  return _CUDA_VSTD::__uninitialized_move_n<_ValueType, _IterOps<_ClassicAlgPolicy>>(
+    _CUDA_VSTD::move(__ifirst), __n, _CUDA_VSTD::move(__ofirst), __always_false{});
+}
+
+// TODO: Rewrite this to iterate left to right and use reverse_iterators when calling
+// Destroys every element in the range [first, last) FROM RIGHT TO LEFT using allocator
+// destruction. If elements are themselves C-style arrays, they are recursively destroyed
+// in the same manner.
+//
+// This function assumes that destructors do not throw, and that the allocator is bound to
+// the correct type.
+template <class _Alloc, class _BidirIter, enable_if_t<__is_cpp17_bidirectional_iterator<_BidirIter>::value, int> = 0>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void
+__allocator_destroy_multidimensional(_Alloc& __alloc, _BidirIter __first, _BidirIter __last) noexcept
+{
+  using _ValueType = typename iterator_traits<_BidirIter>::value_type;
+  static_assert(_CCCL_TRAIT(is_same, typename allocator_traits<_Alloc>::value_type, _ValueType),
+                "The allocator should already be rebound to the correct type");
+
+  if (__first == __last)
+  {
+    return;
+  }
+
+  _CCCL_IF_CONSTEXPR (_CCCL_TRAIT(is_array, _ValueType))
+  {
+    static_assert(!__cccl_is_unbounded_array<_ValueType>::value,
+                  "arrays of unbounded arrays don't exist, but if they did we would mess up here");
+
+    using _Element = remove_extent_t<_ValueType>;
+    __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
+    do
+    {
+      --__last;
+      auto&& __array = *__last;
+      _CUDA_VSTD::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + _CCCL_TRAIT(extent, _ValueType));
+    } while (__last != __first);
+  }
+  else
+  {
+    do
+    {
+      --__last;
+      allocator_traits<_Alloc>::destroy(__alloc, _CUDA_VSTD::addressof(*__last));
+    } while (__last != __first);
+  }
+}
+
+// Constructs the object at the given location using the allocator's construct method.
+//
+// If the object being constructed is an array, each element of the array is allocator-constructed,
+// recursively. If an exception is thrown during the construction of an array, the initialized
+// elements are destroyed in reverse order of initialization using allocator destruction.
+//
+// This function assumes that the allocator is bound to the correct type.
+template <class _Alloc, class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void
+__allocator_construct_at_multidimensional(_Alloc& __alloc, _Tp* __loc)
+{
+  static_assert(_CCCL_TRAIT(is_same, typename allocator_traits<_Alloc>::value_type, _Tp),
+                "The allocator should already be rebound to the correct type");
+
+  _CCCL_IF_CONSTEXPR (_CCCL_TRAIT(is_array, _Tp))
+  {
+    using _Element = remove_extent_t<_Tp>;
+    __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
+    size_t __i   = 0;
+    _Tp& __array = *__loc;
+
+    // If an exception is thrown, destroy what we have constructed so far in reverse order.
+    auto __guard = _CUDA_VSTD::__make_exception_guard([&]() {
+      _CUDA_VSTD::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + __i);
+    });
+
+    for (; __i != _CCCL_TRAIT(extent, _Tp); ++__i)
+    {
+      _CUDA_VSTD::__allocator_construct_at_multidimensional(__elem_alloc, _CUDA_VSTD::addressof(__array[__i]));
+    }
+    __guard.__complete();
+  }
+  else
+  {
+    allocator_traits<_Alloc>::construct(__alloc, __loc);
+  }
+}
+
+// Constructs the object at the given location using the allocator's construct method, passing along
+// the provided argument.
+//
+// If the object being constructed is an array, the argument is also assumed to be an array. Each
+// each element of the array being constructed is allocator-constructed from the corresponding
+// element of the argument array. If an exception is thrown during the construction of an array,
+// the initialized elements are destroyed in reverse order of initialization using allocator
+// destruction.
+//
+// This function assumes that the allocator is bound to the correct type.
+template <class _Alloc, class _Tp, class _Arg>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void
+__allocator_construct_at_multidimensional(_Alloc& __alloc, _Tp* __loc, _Arg const& __arg)
+{
+  static_assert(_CCCL_TRAIT(is_same, typename allocator_traits<_Alloc>::value_type, _Tp),
+                "The allocator should already be rebound to the correct type");
+
+  _CCCL_IF_CONSTEXPR (_CCCL_TRAIT(is_array, _Tp))
+  {
+    static_assert(_CCCL_TRAIT(is_array, _Arg),
+                  "Provided non-array initialization argument to __allocator_construct_at_multidimensional when "
+                  "trying to construct an array.");
+
+    using _Element = remove_extent_t<_Tp>;
+    __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
+    size_t __i   = 0;
+    _Tp& __array = *__loc;
+
+    // If an exception is thrown, destroy what we have constructed so far in reverse order.
+    auto __guard = _CUDA_VSTD::__make_exception_guard([&]() {
+      _CUDA_VSTD::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + __i);
+    });
+    for (; __i != _CCCL_TRAIT(extent, _Tp); ++__i)
+    {
+      _CUDA_VSTD::__allocator_construct_at_multidimensional(
+        __elem_alloc, _CUDA_VSTD::addressof(__array[__i]), __arg[__i]);
+    }
+    __guard.__complete();
+  }
+  else
+  {
+    allocator_traits<_Alloc>::construct(__alloc, __loc, __arg);
+  }
+}
+
+// Given a range starting at it and containing n elements, initializes each element in the
+// range from left to right using the construct method of the allocator (rebound to the
+// correct type).
+//
+// If an exception is thrown, the initialized elements are destroyed in reverse order of
+// initialization using allocator_traits destruction. If the elements in the range are C-style
+// arrays, they are initialized element-wise using allocator construction, and recursively so.
+template <class _Alloc, class _BidirIter, class _Tp, class _Size = typename iterator_traits<_BidirIter>::difference_type>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void
+__uninitialized_allocator_fill_n_multidimensional(_Alloc& __alloc, _BidirIter __it, _Size __n, _Tp const& __value)
+{
+  using _ValueType = typename iterator_traits<_BidirIter>::value_type;
+  __allocator_traits_rebind_t<_Alloc, _ValueType> __value_alloc(__alloc);
+  _BidirIter __begin = __it;
+
+  // If an exception is thrown, destroy what we have constructed so far in reverse order.
+  auto __guard = _CUDA_VSTD::__make_exception_guard([&]() {
+    _CUDA_VSTD::__allocator_destroy_multidimensional(__value_alloc, __begin, __it);
+  });
+  for (; __n != 0; --__n, ++__it)
+  {
+    _CUDA_VSTD::__allocator_construct_at_multidimensional(__value_alloc, _CUDA_VSTD::addressof(*__it), __value);
+  }
+  __guard.__complete();
+}
+
+// Same as __uninitialized_allocator_fill_n_multidimensional, but doesn't pass any initialization argument
+// to the allocator's construct method, which results in value initialization.
+template <class _Alloc, class _BidirIter, class _Size = typename iterator_traits<_BidirIter>::difference_type>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void
+__uninitialized_allocator_value_construct_n_multidimensional(_Alloc& __alloc, _BidirIter __it, _Size __n)
+{
+  using _ValueType = typename iterator_traits<_BidirIter>::value_type;
+  __allocator_traits_rebind_t<_Alloc, _ValueType> __value_alloc(__alloc);
+  _BidirIter __begin = __it;
+
+  // If an exception is thrown, destroy what we have constructed so far in reverse order.
+  auto __guard = _CUDA_VSTD::__make_exception_guard([&]() {
+    _CUDA_VSTD::__allocator_destroy_multidimensional(__value_alloc, __begin, __it);
+  });
+  for (; __n != 0; --__n, ++__it)
+  {
+    _CUDA_VSTD::__allocator_construct_at_multidimensional(__value_alloc, _CUDA_VSTD::addressof(*__it));
+  }
+  __guard.__complete();
+}
+
+// Destroy all elements in [__first, __last) from left to right using allocator destruction.
+template <class _Alloc, class _Iter, class _Sent>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void __allocator_destroy(_Alloc& __alloc, _Iter __first, _Sent __last)
+{
+  for (; __first != __last; ++__first)
+  {
+    allocator_traits<_Alloc>::destroy(__alloc, _CUDA_VSTD::__to_address(__first));
+  }
+}
+
+template <class _Alloc, class _Iter>
+class _AllocatorDestroyRangeReverse
+{
+public:
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14
+  _AllocatorDestroyRangeReverse(_Alloc& __alloc, _Iter& __first, _Iter& __last)
+      : __alloc_(__alloc)
+      , __first_(__first)
+      , __last_(__last)
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void operator()() const
+  {
+    _CUDA_VSTD::__allocator_destroy(
+      __alloc_, _CUDA_VSTD::reverse_iterator<_Iter>(__last_), _CUDA_VSTD::reverse_iterator<_Iter>(__first_));
+  }
+
+private:
+  _Alloc& __alloc_;
+  _Iter& __first_;
+  _Iter& __last_;
+};
+
+// Copy-construct [__first1, __last1) in [__first2, __first2 + N), where N is distance(__first1, __last1).
+//
+// The caller has to ensure that __first2 can hold at least N uninitialized elements. If an exception is thrown the
+// already copied elements are destroyed in reverse order of their construction.
+template <class _Alloc, class _Iter1, class _Sent1, class _Iter2>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 _Iter2
+__uninitialized_allocator_copy_impl(_Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2)
+{
+  auto __destruct_first = __first2;
+  auto __guard          = _CUDA_VSTD::__make_exception_guard(
+    _AllocatorDestroyRangeReverse<_Alloc, _Iter2>(__alloc, __destruct_first, __first2));
+  while (__first1 != __last1)
+  {
+    allocator_traits<_Alloc>::construct(__alloc, _CUDA_VSTD::__to_address(__first2), *__first1);
+    ++__first1;
+    ++__first2;
+  }
+  __guard.__complete();
+  return __first2;
+}
+
+template <class _Alloc, class _Type>
+struct __allocator_has_trivial_copy_construct : _Not<__has_construct<_Alloc, _Type*, const _Type&>>
+{};
+
+template <class _Type>
+struct __allocator_has_trivial_copy_construct<allocator<_Type>, _Type> : true_type
+{};
+
+template <
+  class _Alloc,
+  class _In,
+  class _RawTypeIn = remove_const_t<_In>,
+  class _Out,
+  enable_if_t<
+    // using _RawTypeIn because of the allocator<T const> extension
+    _CCCL_TRAIT(is_trivially_copy_constructible, _RawTypeIn) && _CCCL_TRAIT(is_trivially_copy_assignable, _RawTypeIn)
+    && _CCCL_TRAIT(is_same, remove_const_t<_In>, remove_const_t<_Out>)
+    && __allocator_has_trivial_copy_construct<_Alloc, _RawTypeIn>::value>* = nullptr>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 _Out*
+__uninitialized_allocator_copy_impl(_Alloc&, _In* __first1, _In* __last1, _Out* __first2)
+{
+  if (_CUDA_VSTD::is_constant_evaluated())
+  {
+    while (__first1 != __last1)
+    {
+      _CUDA_VSTD::__construct_at(_CUDA_VSTD::__to_address(__first2), *__first1);
+      ++__first1;
+      ++__first2;
+    }
+    return __first2;
+  }
+  else
+  {
+    return _CUDA_VSTD::copy(__first1, __last1, __first2);
+  }
+}
+
+template <class _Alloc, class _Iter1, class _Sent1, class _Iter2>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 _Iter2
+__uninitialized_allocator_copy(_Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2)
+{
+  auto __unwrapped_range = _CUDA_VSTD::__unwrap_range(__first1, __last1);
+  auto __result          = _CUDA_VSTD::__uninitialized_allocator_copy_impl(
+    __alloc, __unwrapped_range.first, __unwrapped_range.second, _CUDA_VSTD::__unwrap_iter(__first2));
+  return _CUDA_VSTD::__rewrap_iter(__first2, __result);
+}
+
+// Move-construct the elements [__first1, __last1) into [__first2, __first2 + N)
+// if the move constructor is noexcept, where N is distance(__first1, __last1).
+//
+// Otherwise try to copy all elements. If an exception is thrown the already copied
+// elements are destroyed in reverse order of their construction.
+template <class _Alloc, class _Iter1, class _Sent1, class _Iter2>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 _Iter2
+__uninitialized_allocator_move_if_noexcept(_Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2)
+{
+  static_assert(__is_cpp17_move_insertable<_Alloc>::value,
+                "The specified type does not meet the requirements of Cpp17MoveInsertable");
+  auto __destruct_first = __first2;
+  auto __guard          = _CUDA_VSTD::__make_exception_guard(
+    _AllocatorDestroyRangeReverse<_Alloc, _Iter2>(__alloc, __destruct_first, __first2));
+  while (__first1 != __last1)
+  {
+#ifndef _CCCL_NO_EXCEPTIONS
+    allocator_traits<_Alloc>::construct(
+      __alloc, _CUDA_VSTD::__to_address(__first2), _CUDA_VSTD::move_if_noexcept(*__first1));
+#else // ^^^ !_CCCL_NO_EXCEPTIONS ^^^ / vvv _CCCL_NO_EXCEPTIONS vvv
+    allocator_traits<_Alloc>::construct(__alloc, _CUDA_VSTD::__to_address(__first2), _CUDA_VSTD::move(*__first1));
+#endif // _CCCL_NO_EXCEPTIONS
+    ++__first1;
+    ++__first2;
+  }
+  __guard.__complete();
+  return __first2;
+}
+
+template <class _Alloc, class _Type>
+struct __allocator_has_trivial_move_construct : _Not<__has_construct<_Alloc, _Type*, _Type&&>>
+{};
+
+template <class _Type>
+struct __allocator_has_trivial_move_construct<allocator<_Type>, _Type> : true_type
+{};
+
+#if !_CCCL_COMPILER(GCC)
+template <class _Alloc,
+          class _Iter1,
+          class _Iter2,
+          class _Type = typename iterator_traits<_Iter1>::value_type,
+          class       = enable_if_t<_CCCL_TRAIT(is_trivially_move_constructible, _Type)
+                                    && _CCCL_TRAIT(is_trivially_move_assignable, _Type)
+                                    && __allocator_has_trivial_move_construct<_Alloc, _Type>::value>>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 _Iter2
+__uninitialized_allocator_move_if_noexcept(_Alloc&, _Iter1 __first1, _Iter1 __last1, _Iter2 __first2)
+{
+  if (_CUDA_VSTD::is_constant_evaluated())
+  {
+    while (__first1 != __last1)
+    {
+      _CUDA_VSTD::__construct_at(_CUDA_VSTD::__to_address(__first2), _CUDA_VSTD::move(*__first1));
+      ++__first1;
+      ++__first2;
+    }
+    return __first2;
+  }
+  else
+  {
+    return _CUDA_VSTD::move(__first1, __last1, __first2);
+  }
+}
+#endif // !_CCCL_COMPILER(GCC)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_UNINITIALIZED_ALGORITHMS_H

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

@@ -0,0 +1,761 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_UNIQUE_PTR_H
+#define _LIBCUDACXX___MEMORY_UNIQUE_PTR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/cstddef>
+#ifndef _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+#  include <cuda/std/__compare/compare_three_way.h>
+#  include <cuda/std/__compare/compare_three_way_result.h>
+#  include <cuda/std/__compare/three_way_comparable.h>
+#endif // _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+#include <cuda/std/__functional/hash.h>
+#include <cuda/std/__functional/operations.h>
+#include <cuda/std/__memory/allocator_traits.h> // __pointer
+#include <cuda/std/__memory/compressed_pair.h>
+#include <cuda/std/__type_traits/add_lvalue_reference.h>
+#include <cuda/std/__type_traits/common_type.h>
+#include <cuda/std/__type_traits/dependent_type.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_array.h>
+#include <cuda/std/__type_traits/is_assignable.h>
+#include <cuda/std/__type_traits/is_constructible.h>
+#include <cuda/std/__type_traits/is_convertible.h>
+#include <cuda/std/__type_traits/is_default_constructible.h>
+#include <cuda/std/__type_traits/is_function.h>
+#include <cuda/std/__type_traits/is_pointer.h>
+#include <cuda/std/__type_traits/is_reference.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/is_swappable.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__type_traits/remove_extent.h>
+#include <cuda/std/__type_traits/type_identity.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/__utility/move.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT default_delete
+{
+  static_assert(!_CCCL_TRAIT(is_function, _Tp), "default_delete cannot be instantiated for function types");
+
+  _CCCL_HIDE_FROM_ABI constexpr default_delete() noexcept = default;
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20
+  default_delete(const default_delete<_Up>&, enable_if_t<_CCCL_TRAIT(is_convertible, _Up*, _Tp*), int> = 0) noexcept
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void operator()(_Tp* __ptr) const noexcept
+  {
+    static_assert(sizeof(_Tp) >= 0, "cannot delete an incomplete type");
+    static_assert(!is_void<_Tp>::value, "cannot delete an incomplete type");
+    delete __ptr;
+  }
+};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT default_delete<_Tp[]>
+{
+  _CCCL_HIDE_FROM_ABI constexpr default_delete() noexcept = default;
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 default_delete(
+    const default_delete<_Up[]>&, enable_if_t<_CCCL_TRAIT(is_convertible, _Up (*)[], _Tp (*)[]), int> = 0) noexcept
+  {}
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 enable_if_t<_CCCL_TRAIT(is_convertible, _Up (*)[], _Tp (*)[]), void>
+  operator()(_Up* __ptr) const noexcept
+  {
+    static_assert(sizeof(_Up) >= 0, "cannot delete an incomplete type");
+    delete[] __ptr;
+  }
+};
+
+template <class _Deleter>
+struct __unique_ptr_deleter_sfinae
+{
+  static_assert(!_CCCL_TRAIT(is_reference, _Deleter), "incorrect specialization");
+  typedef const _Deleter& __lval_ref_type;
+  typedef _Deleter&& __good_rval_ref_type;
+  typedef true_type __enable_rval_overload;
+};
+
+template <class _Deleter>
+struct __unique_ptr_deleter_sfinae<_Deleter const&>
+{
+  typedef const _Deleter& __lval_ref_type;
+  typedef const _Deleter&& __bad_rval_ref_type;
+  typedef false_type __enable_rval_overload;
+};
+
+template <class _Deleter>
+struct __unique_ptr_deleter_sfinae<_Deleter&>
+{
+  typedef _Deleter& __lval_ref_type;
+  typedef _Deleter&& __bad_rval_ref_type;
+  typedef false_type __enable_rval_overload;
+};
+
+#if defined(_LIBCUDACXX_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI)
+#  define _LIBCUDACXX_UNIQUE_PTR_TRIVIAL_ABI __attribute__((__trivial_abi__))
+#else
+#  define _LIBCUDACXX_UNIQUE_PTR_TRIVIAL_ABI
+#endif
+
+template <class _Tp, class _Dp = default_delete<_Tp>>
+class _LIBCUDACXX_UNIQUE_PTR_TRIVIAL_ABI _CCCL_TYPE_VISIBILITY_DEFAULT unique_ptr
+{
+public:
+  typedef _Tp element_type;
+  typedef _Dp deleter_type;
+  typedef _CCCL_NODEBUG_ALIAS typename __pointer<_Tp, deleter_type>::type pointer;
+
+  static_assert(!_CCCL_TRAIT(is_rvalue_reference, deleter_type),
+                "the specified deleter type cannot be an rvalue reference");
+
+private:
+  __compressed_pair<pointer, deleter_type> __ptr_;
+
+  struct __nat
+  {
+    int __for_bool_;
+  };
+
+  typedef _CCCL_NODEBUG_ALIAS __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
+
+  template <bool _Dummy>
+  using _LValRefType _CCCL_NODEBUG_ALIAS = typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
+
+  template <bool _Dummy>
+  using _GoodRValRefType _CCCL_NODEBUG_ALIAS = typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
+
+  template <bool _Dummy>
+  using _BadRValRefType _CCCL_NODEBUG_ALIAS = typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
+
+  template <bool _Dummy, class _Deleter = typename __dependent_type<type_identity<deleter_type>, _Dummy>::type>
+  using _EnableIfDeleterDefaultConstructible _CCCL_NODEBUG_ALIAS =
+    typename enable_if<is_default_constructible<_Deleter>::value && !is_pointer<_Deleter>::value>::type;
+
+  template <class _ArgType>
+  using _EnableIfDeleterConstructible _CCCL_NODEBUG_ALIAS =
+    typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;
+
+  template <class _UPtr, class _Up>
+  using _EnableIfMoveConvertible _CCCL_NODEBUG_ALIAS =
+    typename enable_if<is_convertible<typename _UPtr::pointer, pointer>::value && !is_array<_Up>::value>::type;
+
+  template <class _UDel>
+  using _EnableIfDeleterConvertible _CCCL_NODEBUG_ALIAS =
+    typename enable_if<(is_reference<_Dp>::value && is_same<_Dp, _UDel>::value)
+                       || (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)>::type;
+
+  template <class _UDel>
+  using _EnableIfDeleterAssignable = typename enable_if<is_assignable<_Dp&, _UDel&&>::value>::type;
+
+public:
+  template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy>>
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr unique_ptr() noexcept
+      : __ptr_(__value_init_tag(), __value_init_tag())
+  {}
+
+  template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy>>
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr unique_ptr(nullptr_t) noexcept
+      : __ptr_(__value_init_tag(), __value_init_tag())
+  {}
+
+  template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 explicit unique_ptr(pointer __p) noexcept
+      : __ptr_(__p, __value_init_tag())
+  {}
+
+  template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr(pointer __p, _LValRefType<_Dummy> __d) noexcept
+      : __ptr_(__p, __d)
+  {}
+
+  template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) noexcept
+      : __ptr_(__p, _CUDA_VSTD::move(__d))
+  {
+    static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
+  }
+
+  template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy>>>
+  _LIBCUDACXX_HIDE_FROM_ABI unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete;
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr(unique_ptr&& __u) noexcept
+      : __ptr_(__u.release(), _CUDA_VSTD::forward<deleter_type>(__u.get_deleter()))
+  {}
+
+  template <class _Up,
+            class _Ep,
+            class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
+            class = _EnableIfDeleterConvertible<_Ep>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+      : __ptr_(__u.release(), _CUDA_VSTD::forward<_Ep>(__u.get_deleter()))
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr& operator=(unique_ptr&& __u) noexcept
+  {
+    reset(__u.release());
+    __ptr_.second() = _CUDA_VSTD::forward<deleter_type>(__u.get_deleter());
+    return *this;
+  }
+
+  template <class _Up,
+            class _Ep,
+            class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
+            class = _EnableIfDeleterAssignable<_Ep>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
+  {
+    reset(__u.release());
+    __ptr_.second() = _CUDA_VSTD::forward<_Ep>(__u.get_deleter());
+    return *this;
+  }
+
+  unique_ptr(unique_ptr const&)            = delete;
+  unique_ptr& operator=(unique_ptr const&) = delete;
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 ~unique_ptr()
+  {
+    reset();
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr& operator=(nullptr_t) noexcept
+  {
+    reset();
+    return *this;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 add_lvalue_reference_t<_Tp> operator*() const
+  {
+    return *__ptr_.first();
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 pointer operator->() const noexcept
+  {
+    return __ptr_.first();
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 pointer get() const noexcept
+  {
+    return __ptr_.first();
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 deleter_type& get_deleter() noexcept
+  {
+    return __ptr_.second();
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 const deleter_type& get_deleter() const noexcept
+  {
+    return __ptr_.second();
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 explicit operator bool() const noexcept
+  {
+    return __ptr_.first() != nullptr;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 pointer release() noexcept
+  {
+    pointer __t    = __ptr_.first();
+    __ptr_.first() = pointer();
+    return __t;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void reset(pointer __p = pointer()) noexcept
+  {
+    pointer __tmp  = __ptr_.first();
+    __ptr_.first() = __p;
+    if (__tmp)
+    {
+      __ptr_.second()(__tmp);
+    }
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void swap(unique_ptr& __u) noexcept
+  {
+    __ptr_.swap(__u.__ptr_);
+  }
+};
+
+template <class _Tp, class _Dp>
+class _LIBCUDACXX_UNIQUE_PTR_TRIVIAL_ABI _CCCL_TYPE_VISIBILITY_DEFAULT unique_ptr<_Tp[], _Dp>
+{
+public:
+  typedef _Tp element_type;
+  typedef _Dp deleter_type;
+  typedef typename __pointer<_Tp, deleter_type>::type pointer;
+
+private:
+  __compressed_pair<pointer, deleter_type> __ptr_;
+
+  template <class _From>
+  struct _CheckArrayPointerConversion : is_same<_From, pointer>
+  {};
+
+  template <class _FromElem>
+  struct _CheckArrayPointerConversion<_FromElem*>
+      : integral_constant<
+          bool,
+          is_same<_FromElem*, pointer>::value
+            || (is_same<pointer, element_type*>::value && is_convertible<_FromElem (*)[], element_type (*)[]>::value)>
+  {};
+
+  typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
+
+  template <bool _Dummy>
+  using _LValRefType _CCCL_NODEBUG_ALIAS = typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
+
+  template <bool _Dummy>
+  using _GoodRValRefType _CCCL_NODEBUG_ALIAS = typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
+
+  template <bool _Dummy>
+  using _BadRValRefType _CCCL_NODEBUG_ALIAS = typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
+
+  template <bool _Dummy, class _Deleter = typename __dependent_type<type_identity<deleter_type>, _Dummy>::type>
+  using _EnableIfDeleterDefaultConstructible _CCCL_NODEBUG_ALIAS =
+    typename enable_if<is_default_constructible<_Deleter>::value && !is_pointer<_Deleter>::value>::type;
+
+  template <class _ArgType>
+  using _EnableIfDeleterConstructible _CCCL_NODEBUG_ALIAS =
+    typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;
+
+  template <class _Pp>
+  using _EnableIfPointerConvertible _CCCL_NODEBUG_ALIAS =
+    typename enable_if<_CheckArrayPointerConversion<_Pp>::value>::type;
+
+  template <class _UPtr, class _Up, class _ElemT = typename _UPtr::element_type>
+  using _EnableIfMoveConvertible _CCCL_NODEBUG_ALIAS = typename enable_if<
+    is_array<_Up>::value && is_same<pointer, element_type*>::value && is_same<typename _UPtr::pointer, _ElemT*>::value
+    && is_convertible<_ElemT (*)[], element_type (*)[]>::value>::type;
+
+  template <class _UDel>
+  using _EnableIfDeleterConvertible _CCCL_NODEBUG_ALIAS =
+    typename enable_if<(is_reference<_Dp>::value && is_same<_Dp, _UDel>::value)
+                       || (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)>::type;
+
+  template <class _UDel>
+  using _EnableIfDeleterAssignable _CCCL_NODEBUG_ALIAS = typename enable_if<is_assignable<_Dp&, _UDel&&>::value>::type;
+
+public:
+  template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy>>
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr unique_ptr() noexcept
+      : __ptr_(__value_init_tag(), __value_init_tag())
+  {}
+
+  template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy>>
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr unique_ptr(nullptr_t) noexcept
+      : __ptr_(__value_init_tag(), __value_init_tag())
+  {}
+
+  template <class _Pp,
+            bool _Dummy = true,
+            class       = _EnableIfDeleterDefaultConstructible<_Dummy>,
+            class       = _EnableIfPointerConvertible<_Pp>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 explicit unique_ptr(_Pp __p) noexcept
+      : __ptr_(__p, __value_init_tag())
+  {}
+
+  template <class _Pp,
+            bool _Dummy = true,
+            class       = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>,
+            class       = _EnableIfPointerConvertible<_Pp>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) noexcept
+      : __ptr_(__p, __d)
+  {}
+
+  template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) noexcept
+      : __ptr_(nullptr, __d)
+  {}
+
+  template <class _Pp,
+            bool _Dummy = true,
+            class       = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>,
+            class       = _EnableIfPointerConvertible<_Pp>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) noexcept
+      : __ptr_(__p, _CUDA_VSTD::move(__d))
+  {
+    static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
+  }
+
+  template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) noexcept
+      : __ptr_(nullptr, _CUDA_VSTD::move(__d))
+  {
+    static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
+  }
+
+  template <class _Pp,
+            bool _Dummy = true,
+            class       = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy>>,
+            class       = _EnableIfPointerConvertible<_Pp>>
+  _LIBCUDACXX_HIDE_FROM_ABI unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete;
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr(unique_ptr&& __u) noexcept
+      : __ptr_(__u.release(), _CUDA_VSTD::forward<deleter_type>(__u.get_deleter()))
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr& operator=(unique_ptr&& __u) noexcept
+  {
+    reset(__u.release());
+    __ptr_.second() = _CUDA_VSTD::forward<deleter_type>(__u.get_deleter());
+    return *this;
+  }
+
+  template <class _Up,
+            class _Ep,
+            class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
+            class = _EnableIfDeleterConvertible<_Ep>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+      : __ptr_(__u.release(), _CUDA_VSTD::forward<_Ep>(__u.get_deleter()))
+  {}
+
+  template <class _Up,
+            class _Ep,
+            class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
+            class = _EnableIfDeleterAssignable<_Ep>>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
+  {
+    reset(__u.release());
+    __ptr_.second() = _CUDA_VSTD::forward<_Ep>(__u.get_deleter());
+    return *this;
+  }
+
+public:
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 ~unique_ptr()
+  {
+    reset();
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 unique_ptr& operator=(nullptr_t) noexcept
+  {
+    reset();
+    return *this;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 add_lvalue_reference_t<_Tp> operator[](size_t __i) const
+  {
+    return __ptr_.first()[__i];
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 pointer get() const noexcept
+  {
+    return __ptr_.first();
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 deleter_type& get_deleter() noexcept
+  {
+    return __ptr_.second();
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 const deleter_type& get_deleter() const noexcept
+  {
+    return __ptr_.second();
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 explicit operator bool() const noexcept
+  {
+    return __ptr_.first() != nullptr;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 pointer release() noexcept
+  {
+    pointer __t    = __ptr_.first();
+    __ptr_.first() = pointer();
+    return __t;
+  }
+
+  template <class _Pp, enable_if_t<_CheckArrayPointerConversion<_Pp>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void reset(_Pp __p) noexcept
+  {
+    pointer __tmp  = __ptr_.first();
+    __ptr_.first() = __p;
+    if (__tmp)
+    {
+      __ptr_.second()(__tmp);
+    }
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void reset(nullptr_t = nullptr) noexcept
+  {
+    pointer __tmp  = __ptr_.first();
+    __ptr_.first() = nullptr;
+    if (__tmp)
+    {
+      __ptr_.second()(__tmp);
+    }
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void swap(unique_ptr& __u) noexcept
+  {
+    __ptr_.swap(__u.__ptr_);
+  }
+};
+
+template <class _Tp, class _Dp>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 enable_if_t<__is_swappable<_Dp>::value, void>
+swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) noexcept
+{
+  __x.swap(__y);
+}
+
+template <class _T1, class _D1, class _T2, class _D2>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool
+operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
+{
+  return __x.get() == __y.get();
+}
+
+#if _CCCL_STD_VER <= 2017
+template <class _T1, class _D1, class _T2, class _D2>
+_LIBCUDACXX_HIDE_FROM_ABI
+
+  bool
+  operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
+{
+  return !(__x == __y);
+}
+#endif
+
+template <class _T1, class _D1, class _T2, class _D2>
+_LIBCUDACXX_HIDE_FROM_ABI
+
+  bool
+  operator<(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
+{
+  typedef typename unique_ptr<_T1, _D1>::pointer _P1;
+  typedef typename unique_ptr<_T2, _D2>::pointer _P2;
+  typedef typename common_type<_P1, _P2>::type _Vp;
+  return less<_Vp>()(__x.get(), __y.get());
+}
+
+template <class _T1, class _D1, class _T2, class _D2>
+_LIBCUDACXX_HIDE_FROM_ABI
+
+  bool
+  operator>(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
+{
+  return __y < __x;
+}
+
+template <class _T1, class _D1, class _T2, class _D2>
+_LIBCUDACXX_HIDE_FROM_ABI
+
+  bool
+  operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
+{
+  return !(__y < __x);
+}
+
+template <class _T1, class _D1, class _T2, class _D2>
+_LIBCUDACXX_HIDE_FROM_ABI
+
+  bool
+  operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
+{
+  return !(__x < __y);
+}
+
+#ifndef _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+#  if _CCCL_STD_VER >= 2020
+template <class _T1, class _D1, class _T2, class _D2>
+  requires three_way_comparable_with<typename unique_ptr<_T1, _D1>::pointer, typename unique_ptr<_T2, _D2>::pointer>
+_LIBCUDACXX_HIDE_FROM_ABI
+compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer, typename unique_ptr<_T2, _D2>::pointer>
+operator<=>(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
+{
+  return compare_three_way()(__x.get(), __y.get());
+}
+#  endif // _CCCL_STD_VER >= 2020
+#endif // _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) noexcept
+{
+  return !__x;
+}
+
+#if _CCCL_STD_VER <= 2017
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI
+
+  bool
+  operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) noexcept
+{
+  return !__x;
+}
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI
+
+  bool
+  operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) noexcept
+{
+  return static_cast<bool>(__x);
+}
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI
+
+  bool
+  operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) noexcept
+{
+  return static_cast<bool>(__x);
+}
+#endif // _CCCL_STD_VER <= 2017
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t)
+{
+  typedef typename unique_ptr<_T1, _D1>::pointer _P1;
+  return less<_P1>()(__x.get(), nullptr);
+}
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x)
+{
+  typedef typename unique_ptr<_T1, _D1>::pointer _P1;
+  return less<_P1>()(nullptr, __x.get());
+}
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t)
+{
+  return nullptr < __x;
+}
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x)
+{
+  return __x < nullptr;
+}
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
+{
+  return !(nullptr < __x);
+}
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
+{
+  return !(__x < nullptr);
+}
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
+{
+  return !(__x < nullptr);
+}
+
+template <class _T1, class _D1>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 bool operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
+{
+  return !(nullptr < __x);
+}
+
+#ifndef _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+#  if _CCCL_STD_VER >= 2020
+template <class _T1, class _D1>
+  requires three_way_comparable<typename unique_ptr<_T1, _D1>::pointer>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer>
+operator<=>(const unique_ptr<_T1, _D1>& __x, nullptr_t)
+{
+  return compare_three_way()(__x.get(), static_cast<typename unique_ptr<_T1, _D1>::pointer>(nullptr));
+}
+#  endif // _CCCL_STD_VER >= 2020
+#endif // _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+
+template <class _Tp>
+struct __unique_if
+{
+  typedef unique_ptr<_Tp> __unique_single;
+};
+
+template <class _Tp>
+struct __unique_if<_Tp[]>
+{
+  typedef unique_ptr<_Tp[]> __unique_array_unknown_bound;
+};
+
+template <class _Tp, size_t _Np>
+struct __unique_if<_Tp[_Np]>
+{
+  typedef void __unique_array_known_bound;
+};
+
+template <class _Tp, class... _Args>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 typename __unique_if<_Tp>::__unique_single make_unique(_Args&&... __args)
+{
+  return unique_ptr<_Tp>(new _Tp(_CUDA_VSTD::forward<_Args>(__args)...));
+}
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 typename __unique_if<_Tp>::__unique_array_unknown_bound
+make_unique(size_t __n)
+{
+  typedef remove_extent_t<_Tp> _Up;
+  return unique_ptr<_Tp>(new _Up[__n]());
+}
+
+template <class _Tp, class... _Args>
+_LIBCUDACXX_HIDE_FROM_ABI typename __unique_if<_Tp>::__unique_array_known_bound make_unique(_Args&&...) = delete;
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 typename __unique_if<_Tp>::__unique_single make_unique_for_overwrite()
+{
+  return unique_ptr<_Tp>(new _Tp);
+}
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 typename __unique_if<_Tp>::__unique_array_unknown_bound
+make_unique_for_overwrite(size_t __n)
+{
+  return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__n]);
+}
+
+template <class _Tp, class... _Args>
+_LIBCUDACXX_HIDE_FROM_ABI typename __unique_if<_Tp>::__unique_array_known_bound
+make_unique_for_overwrite(_Args&&...) = delete;
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT hash;
+
+#ifndef __cuda_std__
+template <class _Tp, class _Dp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT hash<unique_ptr<_Tp, _Dp>>
+{
+#  if _CCCL_STD_VER <= 2017 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef unique_ptr<_Tp, _Dp> argument_type;
+  _LIBCUDACXX_DEPRECATED_IN_CXX17 typedef size_t result_type;
+#  endif
+
+  _LIBCUDACXX_HIDE_FROM_ABI size_t operator()(const unique_ptr<_Tp, _Dp>& __ptr) const
+  {
+    typedef typename unique_ptr<_Tp, _Dp>::pointer pointer;
+    return hash<pointer>()(__ptr.get());
+  }
+};
+#endif // __cuda_std__
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_UNIQUE_PTR_H

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

@@ -0,0 +1,70 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_USES_ALLOCATOR_H
+#define _LIBCUDACXX___MEMORY_USES_ALLOCATOR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/is_convertible.h>
+#include <cuda/std/__type_traits/void_t.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp, class = void>
+struct __has_allocator_type : false_type
+{};
+template <class _Tp>
+struct __has_allocator_type<_Tp, void_t<typename _Tp::allocator_type>> : true_type
+{};
+
+template <class _Tp, class _Alloc, bool = _CCCL_TRAIT(__has_allocator_type, _Tp)>
+struct __uses_allocator : false_type
+{};
+template <class _Tp, class _Alloc>
+struct __uses_allocator<_Tp, _Alloc, true> : is_convertible<_Alloc, typename _Tp::allocator_type>
+{};
+#else // ^^^ _CCCL_NO_VARIABLE_TEMPLATES ^^^ / vvv !_CCCL_NO_VARIABLE_TEMPLATES vvv
+template <class _Tp, class = void>
+_CCCL_INLINE_VAR constexpr bool __has_allocator_type_v = false;
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool __has_allocator_type_v<_Tp, void_t<typename _Tp::allocator_type>> = true;
+
+template <class _Tp, class _Alloc, bool = _CCCL_TRAIT(__has_allocator_type, _Tp)>
+_CCCL_INLINE_VAR constexpr bool __uses_allocator_v = false;
+template <class _Tp, class _Alloc>
+_CCCL_INLINE_VAR constexpr bool __uses_allocator_v<_Tp, _Alloc, true> =
+  is_convertible_v<_Alloc, typename _Tp::allocator_type>;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+template <class _Tp, class _Alloc>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT uses_allocator
+    : public integral_constant<bool, _CCCL_TRAIT(__uses_allocator, _Tp, _Alloc)>
+{};
+
+#if _CCCL_STD_VER >= 2014
+template <class _Tp, class _Alloc>
+_CCCL_INLINE_VAR constexpr bool uses_allocator_v = _CCCL_TRAIT(__uses_allocator, _Tp, _Alloc);
+#endif // _CCCL_STD_VER >= 2014
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_USES_ALLOCATOR_H

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

@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___MEMORY_VOIDIFY_H
+#define _LIBCUDACXX___MEMORY_VOIDIFY_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__memory/addressof.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <typename _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 void* __voidify(_Tp& __from)
+{
+  // Cast away cv-qualifiers to allow modifying elements of a range through const iterators.
+  return const_cast<void*>(static_cast<const volatile void*>(_CUDA_VSTD::addressof(__from)));
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MEMORY_VOIDIFY_H

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

@@ -0,0 +1,317 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___STRING_STRING_VIEW_H
+#define _LIBCUDACXX___STRING_STRING_VIEW_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#ifndef _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+#  include <cuda/std/compare>
+#endif
+#include <cuda/std/__type_traits/is_constant_evaluated.h>
+#include <cuda/std/cstddef>
+#include <cuda/std/detail/libcxx/include/__string>
+#include <cuda/std/detail/libcxx/include/stdexcept>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct __string_view
+{
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr __string_view(char const* __str, size_t __len) noexcept
+      : __str_(__str)
+      , __len_(__len)
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr explicit __string_view(char const* __str) noexcept
+      : __str_(__str)
+      , __len_(__strlen_(__str))
+  {}
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr size_t size() const noexcept
+  {
+    return __len_;
+  }
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr char const* data() const noexcept
+  {
+    return __str_;
+  }
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr char const* begin() const noexcept
+  {
+    return __str_;
+  }
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr char const* end() const noexcept
+  {
+    return __str_ + __len_;
+  }
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr char const& operator[](ptrdiff_t __n) const noexcept
+  {
+    return __str_[__n];
+  }
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr __string_view substr(ptrdiff_t __start, ptrdiff_t __stop) const
+  {
+    return __string_view(__str_ + __check_offset(__start, __len_), __check_offset(__stop - __start, __len_));
+  }
+
+  // C++11 constexpr string comparison
+#if _CCCL_STD_VER < 2014 || __cpp_constexpr < 201304L
+
+private:
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static constexpr int
+  __compare_(char const* __s1, size_t __len1, char const* __s2, size_t __len2, size_t __n) noexcept
+  {
+    return __n ? (*__s1 - *__s2 ? *__s1 - *__s2 : __compare_(__s1 + 1, __len1, __s2 + 1, __len2, __n - 1))
+               : int(__len1) - int(__len2);
+  }
+
+  template <bool _Forward>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static constexpr ptrdiff_t __try_find(
+    size_t __i,
+    const char* __needle,
+    size_t __needle_size,
+    char const* __haystack_begin,
+    char const* __haystack_end,
+    char const* __it) noexcept
+  {
+    return __i == __needle_size //
+           ? (_Forward ? __it - __haystack_begin : __it - __haystack_end - 1)
+           : __needle[__i] != (_Forward ? __it : __it - 1)[__i]
+               ? -1
+               : __try_find<_Forward>(__i + 1, __needle, __needle_size, __haystack_begin, __haystack_end, __it);
+  }
+
+  template <bool _Forward>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static constexpr ptrdiff_t __find(
+    ptrdiff_t __found,
+    const char* __needle,
+    size_t __needle_size,
+    char const* __haystack_begin,
+    char const* __haystack_end,
+    char const* __it) noexcept
+  {
+    return __found != -1 //
+           ? __found
+           : __it == __haystack_end
+               ? -1
+               : __find<_Forward>(
+                   __try_find<_Forward>(0, __needle, __needle_size, __haystack_begin, __haystack_end, __it),
+                   __needle,
+                   __needle_size,
+                   __haystack_begin,
+                   __haystack_end,
+                   (_Forward ? __it + 1 : __it - 1));
+  }
+
+public:
+  template <size_t _Np>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr ptrdiff_t find(const char (&__other)[_Np]) const noexcept
+  {
+    return (_Np - 1) > __len_
+           ? -1
+           : __find<true>(-1, __other, _Np - 1, __str_, __str_ + __len_ - (_Np - 1) + 1, __str_);
+  }
+
+  template <size_t _Np>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr ptrdiff_t find_end(const char (&__other)[_Np]) const noexcept
+  {
+    return (_Np - 1) > __len_
+           ? -1
+           : __find<false>(
+               -1, __other, _Np - 1, __str_ + __len_ - (_Np - 1) + 1, __str_, __str_ + __len_ - (_Np - 1) + 1);
+  }
+
+#else // ^^^ C++11 ^^^ / vvv C++14 and beyond vvv
+
+private:
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static constexpr int
+  __compare_(char const* __s1, size_t __len1, char const* __s2, size_t __len2, size_t __n) noexcept
+  {
+    if (__n)
+    {
+      for (;; ++__s1, ++__s2)
+      {
+        if (*__s1 < *__s2)
+        {
+          return -1;
+        }
+        if (*__s2 < *__s1)
+        {
+          return 1;
+        }
+        if (0 == --__n)
+        {
+          break;
+        }
+      }
+    }
+    return int(__len1) - int(__len2);
+  }
+
+  template <bool _Forward>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static constexpr ptrdiff_t
+  __find(const char* __needle, size_t __needle_size, const char* __haystack_begin, const char* __haystack_end) noexcept
+  {
+    char const* __it = __haystack_begin;
+    for (; __it != __haystack_end; (_Forward ? ++__it : --__it))
+    {
+      size_t __i = 0;
+      for (; __i != __needle_size; ++__i)
+      {
+        if ((_Forward ? __it : __it - 1)[__i] != __needle[__i])
+        {
+          break;
+        }
+      }
+      if (__i == __needle_size)
+      {
+        return _Forward ? __it - __haystack_begin : __it - __haystack_end - 1;
+      }
+    }
+    return -1;
+  }
+
+public:
+  template <size_t _Np>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr ptrdiff_t find(const char (&__other)[_Np]) const noexcept
+  {
+    return ((_Np - 1) > __len_) ? -1 : __find<true>(__other, _Np - 1, __str_, __str_ + __len_ - (_Np - 1) + 1);
+  }
+
+  template <size_t _Np>
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr ptrdiff_t find_end(const char (&__other)[_Np]) const noexcept
+  {
+    return ((_Np - 1) > __len_) ? -1 : __find<false>(__other, _Np - 1, __str_ + __len_ - (_Np - 1) + 1, __str_);
+  }
+
+#endif // ^^^ C++14 and beyond ^^^
+
+private:
+  // This overload is selected when we're not in a constant evaluated context.
+  // Compare the two strings' addresses as a shortcut, and fall back to a string
+  // comparison it they are not equal.
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI int __compare(__string_view const& __other, false_type) const noexcept
+  {
+    return __str_ == __other.__str_
+           ? int(__len_) - int(__other.__len_)
+           : __compare_(__str_, __len_, __other.__str_, __other.__len_, (__min_) (__len_, __other.__len_));
+  }
+
+  // This overload is selected when we're in a constant evaluated context. We
+  // cannot compare the two strings' addresses so fall back to a string
+  // comparison.
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr int
+  __compare(__string_view const& __other, true_type) const noexcept
+  {
+    return __compare_(__str_, __len_, __other.__str_, __other.__len_, (__min_) (__len_, __other.__len_));
+  }
+
+public:
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr int compare(__string_view const& __other) const noexcept
+  {
+    // If we're in a constant evaluated context, we cannot compare the __str_
+    // members for equality.
+    return __compare(__other, bool_constant<__cccl_default_is_constant_evaluated()>());
+  }
+
+  _CCCL_NODISCARD_FRIEND _LIBCUDACXX_HIDE_FROM_ABI constexpr bool
+  operator==(__string_view const& __lhs, __string_view const& __rhs) noexcept
+  {
+    return __lhs.__len_ == __rhs.__len_ && __lhs.compare(__rhs) == 0;
+  }
+
+#ifndef _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+
+  _CCCL_NODISCARD_FRIEND _LIBCUDACXX_HIDE_FROM_ABI constexpr auto
+  operator<=>(__string_view const& __lhs, __string_view const& __rhs) noexcept
+  {
+    return __lhs.compare(__rhs) <=> 0;
+  }
+
+#else // ^^^ !_LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR ^^^ / vvv _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+
+  _CCCL_NODISCARD_FRIEND _LIBCUDACXX_HIDE_FROM_ABI constexpr bool
+  operator!=(__string_view const& __lhs, __string_view const& __rhs) noexcept
+  {
+    return !(__lhs == __rhs);
+  }
+
+  _CCCL_NODISCARD_FRIEND _LIBCUDACXX_HIDE_FROM_ABI constexpr bool
+  operator<(__string_view const& __lhs, __string_view const& __rhs) noexcept
+  {
+    return __lhs.compare(__rhs) < 0;
+  }
+
+  _CCCL_NODISCARD_FRIEND _LIBCUDACXX_HIDE_FROM_ABI constexpr bool
+  operator<=(__string_view const& __lhs, __string_view const& __rhs) noexcept
+  {
+    return __lhs.compare(__rhs) <= 0;
+  }
+
+  _CCCL_NODISCARD_FRIEND _LIBCUDACXX_HIDE_FROM_ABI constexpr bool
+  operator>(__string_view const& __lhs, __string_view const& __rhs) noexcept
+  {
+    return __lhs.compare(__rhs) > 0;
+  }
+
+  _CCCL_NODISCARD_FRIEND _LIBCUDACXX_HIDE_FROM_ABI constexpr bool
+  operator>=(__string_view const& __lhs, __string_view const& __rhs) noexcept
+  {
+    return __lhs.compare(__rhs) >= 0;
+  }
+
+#endif // _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+
+private:
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static constexpr size_t __min_(size_t __x, size_t __y) noexcept
+  {
+    return __x < __y ? __x : __y;
+  }
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static constexpr size_t
+  __strlen_0x_(char const* __str, size_t __len) noexcept
+  {
+    return *__str ? __strlen_0x_(__str + 1, __len + 1) : __len;
+  }
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static constexpr size_t __strlen_(char const* __str) noexcept
+  {
+#if _CCCL_STD_VER >= 2014
+    return _CUDA_VSTD::char_traits<char>::length(__str);
+#else
+    return __strlen_0x_(__str, 0);
+#endif
+  }
+
+  _CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI static constexpr size_t __check_offset(ptrdiff_t __diff, size_t __len)
+  {
+    return __diff < 0 || static_cast<size_t>(__diff) > __len
+           ? (_CUDA_VSTD::__throw_out_of_range("__string_view index out of range"), size_t(0))
+           : static_cast<size_t>(__diff);
+  }
+
+  char const* __str_;
+  size_t __len_;
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___STRING_STRING_VIEW_H

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

@@ -0,0 +1,109 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___THREAD_THREADING_SUPPORT_H
+#define _LIBCUDACXX___THREAD_THREADING_SUPPORT_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if !defined(_LIBCUDACXX_HAS_NO_THREADS)
+
+#  include <cuda/std/chrono>
+
+#  if defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)
+#    include <cuda/std/__thread/threading_support_external.h>
+#  endif // _LIBCUDACXX_HAS_THREAD_API_EXTERNAL
+
+#  if defined(_LIBCUDACXX_HAS_THREAD_API_CUDA)
+#    include <cuda/std/__thread/threading_support_cuda.h>
+#  elif defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)
+#    include <cuda/std/__thread/threading_support_pthread.h>
+#  elif defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)
+#    include <cuda/std/__thread/threading_support_win32.h>
+#  else // ^^^ _LIBCUDACXX_HAS_THREAD_API_WIN32 ^^^ / vvv Unknown Thread API vvv
+#    error "Unknown Thread API"
+#  endif // Unknown Thread API
+
+_CCCL_PUSH_MACROS
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#  define _LIBCUDACXX_POLLING_COUNT 16
+
+#  if defined(__aarch64__)
+#    define __LIBCUDACXX_ASM_THREAD_YIELD (asm volatile("yield" :::);)
+#  elif defined(__x86_64__)
+#    define __LIBCUDACXX_ASM_THREAD_YIELD (asm volatile("pause" :::);)
+#  else // ^^^ __x86_64__ ^^^ / vvv !__x86_64__ vvv
+#    define __LIBCUDACXX_ASM_THREAD_YIELD (;)
+#  endif // !__x86_64__
+
+_LIBCUDACXX_HIDE_FROM_ABI void __cccl_thread_yield_processor()
+{
+  NV_IF_TARGET(NV_IS_HOST, __LIBCUDACXX_ASM_THREAD_YIELD)
+}
+
+template <class _Fn>
+_LIBCUDACXX_HIDE_FROM_ABI bool __cccl_thread_poll_with_backoff(
+  _Fn&& __f, _CUDA_VSTD::chrono::nanoseconds __max = _CUDA_VSTD::chrono::nanoseconds::zero())
+{
+  _CUDA_VSTD::chrono::high_resolution_clock::time_point const __start =
+    _CUDA_VSTD::chrono::high_resolution_clock::now();
+  for (int __count = 0;;)
+  {
+    if (__f())
+    {
+      return true;
+    }
+    if (__count < _LIBCUDACXX_POLLING_COUNT)
+    {
+      if (__count > (_LIBCUDACXX_POLLING_COUNT >> 1))
+      {
+        _CUDA_VSTD::__cccl_thread_yield_processor();
+      }
+      __count += 1;
+      continue;
+    }
+    _CUDA_VSTD::chrono::high_resolution_clock::duration const __elapsed =
+      _CUDA_VSTD::chrono::high_resolution_clock::now() - __start;
+    if (__max != _CUDA_VSTD::chrono::nanoseconds::zero() && __max < __elapsed)
+    {
+      return false;
+    }
+    _CUDA_VSTD::chrono::nanoseconds const __step = __elapsed / 4;
+    if (__step >= _CUDA_VSTD::chrono::milliseconds(1))
+    {
+      _CUDA_VSTD::__cccl_thread_sleep_for(_CUDA_VSTD::chrono::milliseconds(1));
+    }
+    else if (__step >= _CUDA_VSTD::chrono::microseconds(10))
+    {
+      _CUDA_VSTD::__cccl_thread_sleep_for(__step);
+    }
+    else
+    {
+      _CUDA_VSTD::__cccl_thread_yield();
+    }
+  }
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_CCCL_POP_MACROS
+
+#endif // !_LIBCUDACXX_HAS_NO_THREADS
+
+#endif // _LIBCUDACXX___THREAD_THREADING_SUPPORT_H

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

@@ -0,0 +1,48 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___THREAD_THREADING_SUPPORT_CUDA_H
+#define _LIBCUDACXX___THREAD_THREADING_SUPPORT_CUDA_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if !defined(_LIBCUDACXX_HAS_NO_THREADS) && defined(_LIBCUDACXX_HAS_THREAD_API_CUDA)
+
+#  include <cuda/std/chrono>
+#  include <cuda/std/climits>
+
+_CCCL_PUSH_MACROS
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+_LIBCUDACXX_HIDE_FROM_ABI void __cccl_thread_yield() {}
+
+_LIBCUDACXX_HIDE_FROM_ABI void __cccl_thread_sleep_for(_CUDA_VSTD::chrono::nanoseconds __ns)
+{
+  NV_IF_TARGET(NV_IS_DEVICE,
+               (auto const __step = __ns.count(); assert(__step < numeric_limits<unsigned>::max());
+                asm volatile("nanosleep.u32 %0;" ::"r"((unsigned) __step)
+                             :);))
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_CCCL_POP_MACROS
+
+#endif // !_LIBCUDACXX_HAS_NO_THREADS && _LIBCUDACXX_HAS_THREAD_API_CUDA
+
+#endif // _LIBCUDACXX___THREAD_THREADING_SUPPORT_CUDA_H

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

@@ -0,0 +1,41 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___THREAD_THREADING_SUPPORT_EXTERNAL_H
+#define _LIBCUDACXX___THREAD_THREADING_SUPPORT_EXTERNAL_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if !defined(_LIBCUDACXX_HAS_NO_THREADS) && defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)
+
+#  include <cuda/std/chrono>
+
+_CCCL_PUSH_MACROS
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+_LIBCUDACXX_HIDE_FROM_ABI void __cccl_thread_yield();
+
+_LIBCUDACXX_HIDE_FROM_ABI void __cccl_thread_sleep_for(_CUDA_VSTD::chrono::nanoseconds __ns);
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_CCCL_POP_MACROS
+
+#endif // !_LIBCUDACXX_HAS_NO_THREADS && _LIBCUDACXX_HAS_THREAD_API_EXTERNAL
+
+#endif // _LIBCUDACXX___THREAD_THREADING_SUPPORT_EXTERNAL_H

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

@@ -0,0 +1,184 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___THREAD_THREADING_SUPPORT_PTHREAD_H
+#define _LIBCUDACXX___THREAD_THREADING_SUPPORT_PTHREAD_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if !defined(_LIBCUDACXX_HAS_NO_THREADS) && defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)
+
+#  include <cuda/std/chrono>
+#  include <cuda/std/climits>
+
+#  include <errno.h>
+#  include <pthread.h>
+#  include <sched.h>
+#  include <semaphore.h>
+#  if defined(__APPLE__)
+#    include <dispatch/dispatch.h>
+#  endif // __APPLE__
+#  if defined(__linux__)
+#    include <linux/futex.h>
+#    include <sys/syscall.h>
+#    include <unistd.h>
+#  endif // __linux__
+
+_CCCL_PUSH_MACROS
+
+typedef ::timespec __cccl_timespec_t;
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// Mutex
+typedef pthread_mutex_t __cccl_mutex_t;
+#  define _LIBCUDACXX_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+
+typedef pthread_mutex_t __cccl_recursive_mutex_t;
+
+// Condition Variable
+typedef pthread_cond_t __cccl_condvar_t;
+#  define _LIBCUDACXX_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER
+
+// Semaphore
+#  if defined(__APPLE__)
+typedef dispatch_semaphore_t __cccl_semaphore_t;
+#    define _LIBCUDACXX_SEMAPHORE_MAX numeric_limits<long>::max()
+#  else // ^^^ __APPLE__ ^^^ / vvv !__APPLE__ vvv
+typedef sem_t __cccl_semaphore_t;
+#    define _LIBCUDACXX_SEMAPHORE_MAX SEM_VALUE_MAX
+#  endif // !__APPLE__
+
+// Execute once
+typedef pthread_once_t __cccl_exec_once_flag;
+#  define _LIBCUDACXX_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT
+
+// Thread id
+typedef pthread_t __cccl_thread_id;
+
+// Thread
+#  define _LIBCUDACXX_NULL_THREAD 0U
+
+typedef pthread_t __cccl_thread_t;
+
+// Thread Local Storage
+typedef pthread_key_t __cccl_tls_key;
+
+#  define _LIBCUDACXX_TLS_DESTRUCTOR_CC
+
+_LIBCUDACXX_HIDE_FROM_ABI __cccl_timespec_t __cccl_to_timespec(const _CUDA_VSTD::chrono::nanoseconds& __ns)
+{
+  using namespace chrono;
+  seconds __s = duration_cast<seconds>(__ns);
+  __cccl_timespec_t __ts;
+  typedef decltype(__ts.tv_sec) ts_sec;
+  constexpr ts_sec __ts_sec_max = numeric_limits<ts_sec>::max();
+
+  if (__s.count() < __ts_sec_max)
+  {
+    __ts.tv_sec  = static_cast<ts_sec>(__s.count());
+    __ts.tv_nsec = static_cast<decltype(__ts.tv_nsec)>((__ns - __s).count());
+  }
+  else
+  {
+    __ts.tv_sec  = __ts_sec_max;
+    __ts.tv_nsec = 999999999; // (10^9 - 1)
+  }
+  return __ts;
+}
+
+// Semaphore
+#  if defined(__APPLE__)
+
+_LIBCUDACXX_HIDE_FROM_ABI bool __cccl_semaphore_init(__cccl_semaphore_t* __sem, int __init)
+{
+  return (*__sem = dispatch_semaphore_create(__init)) != nullptr;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI bool __cccl_semaphore_destroy(__cccl_semaphore_t* __sem)
+{
+  dispatch_release(*__sem);
+  return true;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI bool __cccl_semaphore_post(__cccl_semaphore_t* __sem)
+{
+  dispatch_semaphore_signal(*__sem);
+  return true;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI bool __cccl_semaphore_wait(__cccl_semaphore_t* __sem)
+{
+  return dispatch_semaphore_wait(*__sem, DISPATCH_TIME_FOREVER) == 0;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI bool
+__cccl_semaphore_wait_timed(__cccl_semaphore_t* __sem, _CUDA_VSTD::chrono::nanoseconds const& __ns)
+{
+  return dispatch_semaphore_wait(*__sem, dispatch_time(DISPATCH_TIME_NOW, __ns.count())) == 0;
+}
+
+#  else // ^^^ __APPLE__ ^^^ / vvv !__APPLE__ vvv
+
+_LIBCUDACXX_HIDE_FROM_ABI bool __cccl_semaphore_init(__cccl_semaphore_t* __sem, int __init)
+{
+  return sem_init(__sem, 0, __init) == 0;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI bool __cccl_semaphore_destroy(__cccl_semaphore_t* __sem)
+{
+  return sem_destroy(__sem) == 0;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI bool __cccl_semaphore_post(__cccl_semaphore_t* __sem)
+{
+  return sem_post(__sem) == 0;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI bool __cccl_semaphore_wait(__cccl_semaphore_t* __sem)
+{
+  return sem_wait(__sem) == 0;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI bool
+__cccl_semaphore_wait_timed(__cccl_semaphore_t* __sem, _CUDA_VSTD::chrono::nanoseconds const& __ns)
+{
+  __cccl_timespec_t __ts = __cccl_to_timespec(__ns);
+  return sem_timedwait(__sem, &__ts) == 0;
+}
+
+#  endif // !__APPLE__
+
+_LIBCUDACXX_HIDE_FROM_ABI void __cccl_thread_yield()
+{
+  sched_yield();
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI void __cccl_thread_sleep_for(_CUDA_VSTD::chrono::nanoseconds __ns)
+{
+  __cccl_timespec_t __ts = __cccl_to_timespec(__ns);
+  while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR)
+    ;
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_CCCL_POP_MACROS
+
+#endif // !_LIBCUDACXX_HAS_NO_THREADS
+
+#endif // _LIBCUDACXX___THREAD_THREADING_SUPPORT_PTHREAD_H

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

@@ -0,0 +1,89 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___THREAD_THREADING_SUPPORT_WIN32_H
+#define _LIBCUDACXX___THREAD_THREADING_SUPPORT_WIN32_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if !defined(_LIBCUDACXX_HAS_NO_THREADS) && defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)
+
+#  include <cuda/std/chrono>
+
+#  include <process.h>
+#  include <windows.h>
+
+_CCCL_PUSH_MACROS
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// Mutex
+typedef void* __cccl_mutex_t;
+#  define _LIBCUDACXX_MUTEX_INITIALIZER 0
+
+#  if defined(_M_IX86) || defined(__i386__) || defined(_M_ARM) || defined(__arm__)
+typedef void* __cccl_recursive_mutex_t[6];
+#  elif defined(_M_AMD64) || defined(__x86_64__) || defined(_M_ARM64) || defined(__aarch64__)
+typedef void* __cccl_recursive_mutex_t[5];
+#  else
+#    error Unsupported architecture
+#  endif
+
+// Condition Variable
+typedef void* __cccl_condvar_t;
+#  define _LIBCUDACXX_CONDVAR_INITIALIZER 0
+
+// Semaphore
+typedef void* __cccl_semaphore_t;
+
+// Execute Once
+typedef void* __cccl_exec_once_flag;
+#  define _LIBCUDACXX_EXEC_ONCE_INITIALIZER 0
+
+// Thread ID
+typedef long __cccl_thread_id;
+
+// Thread
+#  define _LIBCUDACXX_NULL_THREAD 0U
+
+typedef void* __cccl_thread_t;
+
+// Thread Local Storage
+typedef long __cccl_tls_key;
+
+#  define _LIBCUDACXX_TLS_DESTRUCTOR_CC __stdcall
+
+_LIBCUDACXX_HIDE_FROM_ABI void __cccl_thread_yield()
+{
+  SwitchToThread();
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI void __cccl_thread_sleep_for(chrono::nanoseconds __ns)
+{
+  using namespace chrono;
+  // round-up to the nearest millisecond
+  milliseconds __ms = duration_cast<milliseconds>(__ns + chrono::nanoseconds(999999));
+  Sleep(static_cast<DWORD>(__ms.count()));
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_CCCL_POP_MACROS
+
+#endif // !_LIBCUDACXX_HAS_NO_THREADS && _LIBCUDACXX_HAS_THREAD_API_WIN32
+
+#endif // _LIBCUDACXX___THREAD_THREADING_SUPPORT_H

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

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_CV_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_CV_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT add_cv
+{
+  typedef _CCCL_NODEBUG_ALIAS const volatile _Tp type;
+};
+
+template <class _Tp>
+using add_cv_t _CCCL_NODEBUG_ALIAS = typename add_cv<_Tp>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_CV_H

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

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/is_referenceable.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_ADD_LVALUE_REFERENCE) && !defined(_LIBCUDACXX_USE_ADD_LVALUE_REFERENCE_FALLBACK)
+
+template <class _Tp>
+using add_lvalue_reference_t _CCCL_NODEBUG_ALIAS = _CCCL_BUILTIN_ADD_LVALUE_REFERENCE(_Tp);
+
+#else // ^^^ _CCCL_BUILTIN_ADD_LVALUE_REFERENCE ^^^ / vvv !_CCCL_BUILTIN_ADD_LVALUE_REFERENCE vvv
+
+template <class _Tp, bool = __cccl_is_referenceable<_Tp>::value>
+struct __add_lvalue_reference_impl
+{
+  typedef _CCCL_NODEBUG_ALIAS _Tp type;
+};
+template <class _Tp>
+struct __add_lvalue_reference_impl<_Tp, true>
+{
+  typedef _CCCL_NODEBUG_ALIAS _Tp& type;
+};
+
+template <class _Tp>
+using add_lvalue_reference_t _CCCL_NODEBUG_ALIAS = typename __add_lvalue_reference_impl<_Tp>::type;
+
+#endif // !_CCCL_BUILTIN_ADD_LVALUE_REFERENCE
+
+template <class _Tp>
+struct add_lvalue_reference
+{
+  using type _CCCL_NODEBUG_ALIAS = add_lvalue_reference_t<_Tp>;
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H

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

@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_POINTER_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_POINTER_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/is_referenceable.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__type_traits/remove_cv.h>
+#include <cuda/std/__type_traits/remove_reference.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_ADD_POINTER) && !defined(_LIBCUDACXX_USE_ADD_POINTER_FALLBACK)
+
+template <class _Tp>
+using add_pointer_t _CCCL_NODEBUG_ALIAS = _CCCL_BUILTIN_ADD_POINTER(_Tp);
+
+#else // ^^^ _CCCL_BUILTIN_ADD_POINTER ^^^ / vvv !_CCCL_BUILTIN_ADD_POINTER vvv
+template <class _Tp, bool = __cccl_is_referenceable<_Tp>::value || is_void<_Tp>::value>
+struct __add_pointer_impl
+{
+  typedef _CCCL_NODEBUG_ALIAS remove_reference_t<_Tp>* type;
+};
+template <class _Tp>
+struct __add_pointer_impl<_Tp, false>
+{
+  typedef _CCCL_NODEBUG_ALIAS _Tp type;
+};
+
+template <class _Tp>
+using add_pointer_t _CCCL_NODEBUG_ALIAS = typename __add_pointer_impl<_Tp>::type;
+
+#endif // !_CCCL_BUILTIN_ADD_POINTER
+
+template <class _Tp>
+struct add_pointer
+{
+  using type _CCCL_NODEBUG_ALIAS = add_pointer_t<_Tp>;
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_POINTER_H

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

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ALIGNED_UNION_H
+#define _LIBCUDACXX___TYPE_TRAITS_ALIGNED_UNION_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/aligned_storage.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <size_t _I0, size_t... _In>
+struct __static_max;
+
+template <size_t _I0>
+struct __static_max<_I0>
+{
+  static const size_t value = _I0;
+};
+
+template <size_t _I0, size_t _I1, size_t... _In>
+struct __static_max<_I0, _I1, _In...>
+{
+  static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value : __static_max<_I1, _In...>::value;
+};
+
+template <size_t _Len, class _Type0, class... _Types>
+struct aligned_union
+{
+  static const size_t alignment_value =
+    __static_max<_LIBCUDACXX_PREFERRED_ALIGNOF(_Type0), _LIBCUDACXX_PREFERRED_ALIGNOF(_Types)...>::value;
+  static const size_t __len = __static_max<_Len, sizeof(_Type0), sizeof(_Types)...>::value;
+  typedef typename aligned_storage<__len, alignment_value>::type type;
+};
+
+template <size_t _Len, class... _Types>
+using aligned_union_t _CCCL_NODEBUG_ALIAS = typename aligned_union<_Len, _Types...>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ALIGNED_UNION_H

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

@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_CAN_EXTRACT_KEY_H
+#define _LIBCUDACXX___TYPE_TRAITS_CAN_EXTRACT_KEY_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__fwd/pair.h>
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/remove_const.h>
+#include <cuda/std/__type_traits/remove_const_ref.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// These traits are used in __tree and __hash_table
+struct __extract_key_fail_tag
+{};
+struct __extract_key_self_tag
+{};
+struct __extract_key_first_tag
+{};
+
+template <class _ValTy, class _Key, class _RawValTy = __remove_const_ref_t<_ValTy>>
+struct __can_extract_key
+    : conditional_t<_IsSame<_RawValTy, _Key>::value, __extract_key_self_tag, __extract_key_fail_tag>
+{};
+
+template <class _Pair, class _Key, class _First, class _Second>
+struct __can_extract_key<_Pair, _Key, pair<_First, _Second>>
+    : conditional_t<_IsSame<remove_const_t<_First>, _Key>::value, __extract_key_first_tag, __extract_key_fail_tag>
+{};
+
+// __can_extract_map_key uses true_type/false_type instead of the tags.
+// It returns true if _Key != _ContainerValueTy (the container is a map not a set)
+// and _ValTy == _Key.
+template <class _ValTy, class _Key, class _ContainerValueTy, class _RawValTy = __remove_const_ref_t<_ValTy>>
+struct __can_extract_map_key : integral_constant<bool, _IsSame<_RawValTy, _Key>::value>
+{};
+
+// This specialization returns __extract_key_fail_tag for non-map containers
+// because _Key == _ContainerValueTy
+template <class _ValTy, class _Key, class _RawValTy>
+struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy> : false_type
+{};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_CAN_EXTRACT_KEY_H

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

@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_CONDITIONAL_H
+#define _LIBCUDACXX___TYPE_TRAITS_CONDITIONAL_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <bool>
+struct _IfImpl;
+
+template <>
+struct _IfImpl<true>
+{
+  template <class _IfRes, class _ElseRes>
+  using _Select _CCCL_NODEBUG_ALIAS = _IfRes;
+};
+
+template <>
+struct _IfImpl<false>
+{
+  template <class _IfRes, class _ElseRes>
+  using _Select _CCCL_NODEBUG_ALIAS = _ElseRes;
+};
+
+template <bool _Cond, class _IfRes, class _ElseRes>
+using _If _CCCL_NODEBUG_ALIAS = typename _IfImpl<_Cond>::template _Select<_IfRes, _ElseRes>;
+
+template <bool _Bp, class _If, class _Then>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT conditional
+{
+  typedef _If type;
+};
+template <class _If, class _Then>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT conditional<false, _If, _Then>
+{
+  typedef _Then type;
+};
+
+template <bool _Bp, class _If, class _Then>
+using conditional_t _CCCL_NODEBUG_ALIAS = typename conditional<_Bp, _If, _Then>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_CONDITIONAL_H

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

@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_DECAY_H
+#define _LIBCUDACXX___TYPE_TRAITS_DECAY_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/add_pointer.h>
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/is_array.h>
+#include <cuda/std/__type_traits/is_function.h>
+#include <cuda/std/__type_traits/is_referenceable.h>
+#include <cuda/std/__type_traits/remove_cv.h>
+#include <cuda/std/__type_traits/remove_extent.h>
+#include <cuda/std/__type_traits/remove_reference.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_DECAY) && !defined(_LIBCUDACXX_USE_DECAY_FALLBACK)
+template <class _Tp>
+struct decay
+{
+  using type _CCCL_NODEBUG_ALIAS = _CCCL_BUILTIN_DECAY(_Tp);
+};
+
+template <class _Tp>
+using decay_t _CCCL_NODEBUG_ALIAS = _CCCL_BUILTIN_DECAY(_Tp);
+
+#else // ^^^ _CCCL_BUILTIN_DECAY ^^^ / vvv !_CCCL_BUILTIN_DECAY vvv
+
+template <class _Up, bool>
+struct __decay_impl
+{
+  typedef _CCCL_NODEBUG_ALIAS remove_cv_t<_Up> type;
+};
+
+template <class _Up>
+struct __decay_impl<_Up, true>
+{
+public:
+  typedef _CCCL_NODEBUG_ALIAS conditional_t<is_array<_Up>::value,
+                                            remove_extent_t<_Up>*,
+                                            conditional_t<is_function<_Up>::value, add_pointer_t<_Up>, remove_cv_t<_Up>>>
+    type;
+};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT decay
+{
+private:
+  typedef _CCCL_NODEBUG_ALIAS remove_reference_t<_Tp> _Up;
+
+public:
+  typedef _CCCL_NODEBUG_ALIAS typename __decay_impl<_Up, __cccl_is_referenceable<_Up>::value>::type type;
+};
+
+template <class _Tp>
+using decay_t _CCCL_NODEBUG_ALIAS = typename decay<_Tp>::type;
+
+#endif // !_CCCL_BUILTIN_DECAY
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_DECAY_H

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

@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_FOLD_H
+#define _LIBCUDACXX___TYPE_TRAITS_FOLD_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/negation.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if !defined(_CCCL_NO_FOLD_EXPRESSIONS)
+
+// Use fold expressions when possible to implement __fold_and[_v] and
+// __fold_or[_v].
+template <bool... _Preds>
+_CCCL_INLINE_VAR constexpr bool __fold_and_v = (_Preds && ...);
+
+template <bool... _Preds>
+_CCCL_INLINE_VAR constexpr bool __fold_or_v = (_Preds || ...);
+
+template <bool... _Preds>
+using __fold_and = bool_constant<bool((_Preds && ...))>; // cast to bool to avoid error from gcc < 8
+
+template <bool... _Preds>
+using __fold_or = bool_constant<bool((_Preds || ...))>; // cast to bool to avoid error from gcc < 8
+
+#else // ^^^ !_CCCL_NO_FOLD_EXPRESSIONS / _CCCL_NO_FOLD_EXPRESSIONS vvv
+
+// Otherwise, we can use a helper class to implement __fold_and and __fold_or.
+template <bool... _Preds>
+struct __fold_helper;
+
+template <bool... _Preds>
+using __fold_and = _IsSame<__fold_helper<true, _Preds...>, __fold_helper<_Preds..., true>>;
+
+template <bool... _Preds>
+using __fold_or = _Not<_IsSame<__fold_helper<false, _Preds...>, __fold_helper<_Preds..., false>>>;
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <bool... _Preds>
+_CCCL_INLINE_VAR constexpr bool __fold_and_v = __fold_and<_Preds...>::value;
+
+template <bool... _Preds>
+_CCCL_INLINE_VAR constexpr bool __fold_or_v = __fold_or<_Preds...>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // _CCCL_NO_FOLD_EXPRESSIONS
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_FOLD_H

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

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H
+#define _LIBCUDACXX___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_HAS_VIRTUAL_DESTRUCTOR) && !defined(_LIBCUDACXX_USE_HAS_VIRTUAL_DESTRUCTOR_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT has_virtual_destructor
+    : public integral_constant<bool, _CCCL_BUILTIN_HAS_VIRTUAL_DESTRUCTOR(_Tp)>
+{};
+
+#else
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT has_virtual_destructor : public false_type
+{};
+
+#endif // defined(_CCCL_BUILTIN_HAS_VIRTUAL_DESTRUCTOR) && !defined(_LIBCUDACXX_USE_HAS_VIRTUAL_DESTRUCTOR_FALLBACK)
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool has_virtual_destructor_v = has_virtual_destructor<_Tp>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H

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

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_ABSTRACT_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_ABSTRACT_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_abstract : public integral_constant<bool, __is_abstract(_Tp)>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_abstract_v = __is_abstract(_Tp);
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_ABSTRACT_H

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

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_ARRAY_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_ARRAY_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// TODO: Clang incorrectly reports that __is_array is true for T[0].
+//       Re-enable the branch once https://llvm.org/PR54705 is fixed.
+#if defined(_CCCL_BUILTIN_IS_ARRAY) && !defined(_LIBCUDACXX_USE_IS_ARRAY_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_array : public integral_constant<bool, _CCCL_BUILTIN_IS_ARRAY(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_array_v = _CCCL_BUILTIN_IS_ARRAY(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_array : public false_type
+{};
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_array<_Tp[]> : public true_type
+{};
+template <class _Tp, size_t _Np>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_array<_Tp[_Np]> : public true_type
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_array_v = is_array<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_ARRAY) && !defined(_LIBCUDACXX_USE_IS_ARRAY_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_ARRAY_H

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

@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_ASSIGNABLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_ASSIGNABLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__utility/declval.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <typename, typename _Tp>
+struct __select_2nd
+{
+  typedef _CCCL_NODEBUG_ALIAS _Tp type;
+};
+
+#if defined(_CCCL_BUILTIN_IS_ASSIGNABLE) && !defined(_LIBCUDACXX_USE_IS_ASSIGNABLE_FALLBACK)
+
+template <class _T1, class _T2>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_assignable
+    : public integral_constant<bool, _CCCL_BUILTIN_IS_ASSIGNABLE(_T1, _T2)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _T1, class _T2>
+_CCCL_INLINE_VAR constexpr bool is_assignable_v = _CCCL_BUILTIN_IS_ASSIGNABLE(_T1, _T2);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp, class _Arg>
+_LIBCUDACXX_HIDE_FROM_ABI
+typename __select_2nd<decltype((_CUDA_VSTD::declval<_Tp>() = _CUDA_VSTD::declval<_Arg>())), true_type>::type
+__is_assignable_test(int);
+
+template <class, class>
+_LIBCUDACXX_HIDE_FROM_ABI false_type __is_assignable_test(...);
+
+template <class _Tp, class _Arg, bool = is_void<_Tp>::value || is_void<_Arg>::value>
+struct __is_assignable_imp : public decltype((_CUDA_VSTD::__is_assignable_test<_Tp, _Arg>(0)))
+{};
+
+template <class _Tp, class _Arg>
+struct __is_assignable_imp<_Tp, _Arg, true> : public false_type
+{};
+
+template <class _Tp, class _Arg>
+struct is_assignable : public __is_assignable_imp<_Tp, _Arg>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp, class _Arg>
+_CCCL_INLINE_VAR constexpr bool is_assignable_v = is_assignable<_Tp, _Arg>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_ASSIGNABLE) && !defined(_LIBCUDACXX_USE_IS_ASSIGNABLE_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_ASSIGNABLE_H

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

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_COMPOUND_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_COMPOUND_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_fundamental.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_COMPOUND) && !defined(_LIBCUDACXX_USE_IS_COMPOUND_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_compound : public integral_constant<bool, _CCCL_BUILTIN_IS_COMPOUND(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_compound_v = _CCCL_BUILTIN_IS_COMPOUND(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else // ^^^ _CCCL_BUILTIN_IS_COMPOUND ^^^ / vvv !_CCCL_BUILTIN_IS_COMPOUND vvv
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_compound : public integral_constant<bool, !is_fundamental<_Tp>::value>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_compound_v = is_compound<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // !_CCCL_BUILTIN_IS_COMPOUND
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_COMPOUND_H

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

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_CONST_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_CONST_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_CONST) && !defined(_LIBCUDACXX_USE_IS_CONST_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_const : public integral_constant<bool, _CCCL_BUILTIN_IS_CONST(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_const_v = _CCCL_BUILTIN_IS_CONST(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else // ^^^ _CCCL_BUILTIN_IS_CONST ^^^ / vvv !_CCCL_BUILTIN_IS_CONST vvv
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_const : public false_type
+{};
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_const<_Tp const> : public true_type
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_const_v = is_const<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // !_CCCL_BUILTIN_IS_CONST
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_CONST_H

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

@@ -0,0 +1,214 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+// SPDX-FileCopyrightText: Copyright (c) Microsoft Corporation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_CONVERTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_CONVERTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_array.h>
+#include <cuda/std/__type_traits/is_function.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__type_traits/remove_reference.h>
+#include <cuda/std/__utility/declval.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_CONVERTIBLE_TO) && !defined(_LIBCUDACXX_USE_IS_CONVERTIBLE_FALLBACK)
+
+template <class _T1, class _T2>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_convertible
+    : public integral_constant<bool, _CCCL_BUILTIN_IS_CONVERTIBLE_TO(_T1, _T2)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _T1, class _T2>
+_CCCL_INLINE_VAR constexpr bool is_convertible_v = _CCCL_BUILTIN_IS_CONVERTIBLE_TO(_T1, _T2);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#  if _CCCL_COMPILER(MSVC) // Workaround for DevCom-1627396
+template <class _Ty>
+struct is_convertible<_Ty&, volatile _Ty&> : true_type
+{};
+
+template <class _Ty>
+struct is_convertible<volatile _Ty&, volatile _Ty&> : true_type
+{};
+
+template <class _Ty>
+struct is_convertible<_Ty&, const volatile _Ty&> : true_type
+{};
+
+template <class _Ty>
+struct is_convertible<volatile _Ty&, const volatile _Ty&> : true_type
+{};
+
+template <class _Ty>
+_CCCL_INLINE_VAR constexpr bool is_convertible_v<_Ty&, volatile _Ty&> = true;
+
+template <class _Ty>
+_CCCL_INLINE_VAR constexpr bool is_convertible_v<volatile _Ty&, volatile _Ty&> = true;
+
+template <class _Ty>
+_CCCL_INLINE_VAR constexpr bool is_convertible_v<_Ty&, const volatile _Ty&> = true;
+
+template <class _Ty>
+_CCCL_INLINE_VAR constexpr bool is_convertible_v<volatile _Ty&, const volatile _Ty&> = true;
+#  endif // _CCCL_COMPILER(MSVC)
+
+#else // ^^^ _CCCL_BUILTIN_IS_CONVERTIBLE_TO ^^^ / vvv !_CCCL_BUILTIN_IS_CONVERTIBLE_TO vvv
+
+namespace __is_convertible_imp
+{
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_NVHPC(volatile_func_param_deprecated)
+_CCCL_NV_DIAG_SUPPRESS(volatile_func_param_deprecated)
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI void __test_convert(_Tp);
+
+_CCCL_NV_DIAG_DEFAULT(volatile_func_param_deprecated)
+_CCCL_DIAG_POP
+
+template <class _From, class _To, class = void>
+struct __is_convertible_test : public false_type
+{};
+
+template <class _From, class _To>
+struct __is_convertible_test<
+  _From,
+  _To,
+  decltype(_CUDA_VSTD::__is_convertible_imp::__test_convert<_To>(_CUDA_VSTD::declval<_From>()))> : public true_type
+{};
+
+template <class _Tp,
+          bool _IsArray    = is_array<_Tp>::value,
+          bool _IsFunction = is_function<_Tp>::value,
+          bool _IsVoid     = is_void<_Tp>::value>
+struct __is_array_function_or_void
+{
+  enum
+  {
+    value = 0
+  };
+};
+template <class _Tp>
+struct __is_array_function_or_void<_Tp, true, false, false>
+{
+  enum
+  {
+    value = 1
+  };
+};
+template <class _Tp>
+struct __is_array_function_or_void<_Tp, false, true, false>
+{
+  enum
+  {
+    value = 2
+  };
+};
+template <class _Tp>
+struct __is_array_function_or_void<_Tp, false, false, true>
+{
+  enum
+  {
+    value = 3
+  };
+};
+} // namespace __is_convertible_imp
+
+template <class _Tp, unsigned = __is_convertible_imp::__is_array_function_or_void<remove_reference_t<_Tp>>::value>
+struct __is_convertible_check
+{
+  static const size_t __v = 0;
+};
+
+template <class _Tp>
+struct __is_convertible_check<_Tp, 0>
+{
+  static const size_t __v = sizeof(_Tp);
+};
+
+template <class _T1,
+          class _T2,
+          unsigned _T1_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T1>::value,
+          unsigned _T2_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T2>::value>
+struct __is_convertible_fallback
+    : public integral_constant<bool, __is_convertible_imp::__is_convertible_test<_T1, _T2>::value>
+{};
+
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 0, 1> : public false_type
+{};
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 1, 1> : public false_type
+{};
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 2, 1> : public false_type
+{};
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 3, 1> : public false_type
+{};
+
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 0, 2> : public false_type
+{};
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 1, 2> : public false_type
+{};
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 2, 2> : public false_type
+{};
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 3, 2> : public false_type
+{};
+
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 0, 3> : public false_type
+{};
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 1, 3> : public false_type
+{};
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 2, 3> : public false_type
+{};
+template <class _T1, class _T2>
+struct __is_convertible_fallback<_T1, _T2, 3, 3> : public true_type
+{};
+
+template <class _T1, class _T2>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_convertible : public __is_convertible_fallback<_T1, _T2>
+{
+  static const size_t __complete_check1 = __is_convertible_check<_T1>::__v;
+  static const size_t __complete_check2 = __is_convertible_check<_T2>::__v;
+};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _From, class _To>
+_CCCL_INLINE_VAR constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // !_CCCL_BUILTIN_IS_CONVERTIBLE_TO
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_CONVERTIBLE_H

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

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/add_const.h>
+#include <cuda/std/__type_traits/add_lvalue_reference.h>
+#include <cuda/std/__type_traits/is_assignable.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_copy_assignable
+    : public is_assignable<add_lvalue_reference_t<_Tp>, add_lvalue_reference_t<typename add_const<_Tp>::type>>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H

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

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/add_const.h>
+#include <cuda/std/__type_traits/add_lvalue_reference.h>
+#include <cuda/std/__type_traits/is_constructible.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_copy_constructible
+    : public is_constructible<_Tp, add_lvalue_reference_t<typename add_const<_Tp>::type>>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H

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

@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_EMPTY_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_EMPTY_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_class.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_EMPTY) && !defined(_LIBCUDACXX_USE_IS_EMPTY_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_empty : public integral_constant<bool, _CCCL_BUILTIN_IS_EMPTY(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_empty_v = _CCCL_BUILTIN_IS_EMPTY(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct __is_empty1 : public _Tp
+{
+  double __lx;
+};
+
+struct __is_empty2
+{
+  double __lx;
+};
+
+template <class _Tp, bool = _CCCL_TRAIT(is_class, _Tp)>
+struct __cccl_empty : public integral_constant<bool, sizeof(__is_empty1<_Tp>) == sizeof(__is_empty2)>
+{};
+
+template <class _Tp>
+struct __cccl_empty<_Tp, false> : public false_type
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_empty : public __cccl_empty<_Tp>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_empty_v = is_empty<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_EMPTY) && !defined(_LIBCUDACXX_USE_IS_EMPTY_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_EMPTY_H

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

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_FLOATING_POINT_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_FLOATING_POINT_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/remove_cv.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __cccl_is_floating_point : public false_type
+{};
+template <>
+struct __cccl_is_floating_point<float> : public true_type
+{};
+template <>
+struct __cccl_is_floating_point<double> : public true_type
+{};
+template <>
+struct __cccl_is_floating_point<long double> : public true_type
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_floating_point : public __cccl_is_floating_point<remove_cv_t<_Tp>>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_FLOATING_POINT_H

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

@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_FUNCTIONAL_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_FUNCTIONAL_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_const.h>
+#include <cuda/std/__type_traits/is_reference.h>
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_MSVC(4180) // qualifier applied to function type has no meaning; ignored
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_FUNCTION) && !defined(_LIBCUDACXX_USE_IS_FUNCTION_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_function : integral_constant<bool, _CCCL_BUILTIN_IS_FUNCTION(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_function_v = _CCCL_BUILTIN_IS_FUNCTION(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_function
+    : public integral_constant<bool, !(is_reference<_Tp>::value || is_const<const _Tp>::value)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_function_v = is_function<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_FUNCTION) && !defined(_LIBCUDACXX_USE_IS_FUNCTION_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_CCCL_DIAG_POP
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_FUNCTIONAL_H