Add files using upload-large-folder tool

cuda_toolkit/include/__algorithm/swap_ranges.h

@@ -0,0 +1,40 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ALGORITHM_SWAP_RANGES_H
+#define _LIBCUDACXX___ALGORITHM_SWAP_RANGES_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__utility/swap.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _ForwardIterator1, class _ForwardIterator2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+_ForwardIterator2 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
+{
+    for(; __first1 != __last1; ++__first1, (void) ++__first2)
+        swap(*__first1, *__first2);
+    return __first2;
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ALGORITHM_SWAP_RANGES_H

cuda_toolkit/include/__cccl/ptx_isa.h

@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 __CCCL_PTX_ISA_H_
+#define __CCCL_PTX_ISA_H_
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <nv/target> // __CUDA_MINIMUM_ARCH__ and friends
+
+/*
+ * Targeting macros
+ *
+ * Information from:
+ * https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#release-notes
+ */
+
+// PTX ISA 8.3 is available from CUDA 12.3, driver r545
+// The first define is for future major versions of CUDACC.
+// We make sure that these get the highest known PTX ISA version.
+#if (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ > 12)) || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 830ULL
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 12 && __CUDACC_VER_MINOR__ >= 3)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 830ULL
+// PTX ISA 8.2 is available from CUDA 12.2, driver r535
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 12 && __CUDACC_VER_MINOR__ >= 2)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 820ULL
+// PTX ISA 8.1 is available from CUDA 12.1, driver r530
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 12 && __CUDACC_VER_MINOR__ >= 1)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 810ULL
+// PTX ISA 8.0 is available from CUDA 12.0, driver r525
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 12 && __CUDACC_VER_MINOR__ >= 0)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 800ULL
+// PTX ISA 7.8 is available from CUDA 11.8, driver r520
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 11 && __CUDACC_VER_MINOR__ >= 8)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 780ULL
+// PTX ISA 7.7 is available from CUDA 11.7, driver r515
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 11 && __CUDACC_VER_MINOR__ >= 7)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 770ULL
+// PTX ISA 7.6 is available from CUDA 11.6, driver r510
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 11 && __CUDACC_VER_MINOR__ >= 6)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 760ULL
+// PTX ISA 7.5 is available from CUDA 11.5, driver r495
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 11 && __CUDACC_VER_MINOR__ >= 5)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 750ULL
+// PTX ISA 7.4 is available from CUDA 11.4, driver r470
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 11 && __CUDACC_VER_MINOR__ >= 4)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 740ULL
+// PTX ISA 7.3 is available from CUDA 11.3, driver r465
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 11 && __CUDACC_VER_MINOR__ >= 3)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 730ULL
+// PTX ISA 7.2 is available from CUDA 11.2, driver r460
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 11 && __CUDACC_VER_MINOR__ >= 2)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 720ULL
+// PTX ISA 7.1 is available from CUDA 11.1, driver r455
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 11 && __CUDACC_VER_MINOR__ >= 1)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 710ULL
+// PTX ISA 7.0 is available from CUDA 11.0, driver r445
+#elif (defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 11 && __CUDACC_VER_MINOR__ >= 0)) \
+  || (!defined(__CUDACC_VER_MAJOR__))
+#  define __cccl_ptx_isa 700ULL
+// Fallback case. Define the ISA version to be zero. This ensures that the macro is always defined.
+#else
+#  define __cccl_ptx_isa 0ULL
+#endif
+
+// We define certain feature test macros depending on availability. When
+// __CUDA_MINIMUM_ARCH__ is not available, we define the following features
+// depending on PTX ISA. This permits checking for the feature in host code.
+// When __CUDA_MINIMUM_ARCH__ is available, we only enable the feature when the
+// hardware supports it.
+#if __cccl_ptx_isa >= 800
+#if (!defined(__CUDA_MINIMUM_ARCH__)) \
+  || (defined(__CUDA_MINIMUM_ARCH__) && 900 <= __CUDA_MINIMUM_ARCH__)
+#  define __cccl_lib_local_barrier_arrive_tx
+#  define __cccl_lib_experimental_ctk12_cp_async_exposure
+#endif
+#endif // __cccl_ptx_isa >= 800
+
+#endif // __CCCL_PTX_ISA_H_

cuda_toolkit/include/__cccl/version.h

@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 __CCCL_VERSION_H
+#define __CCCL_VERSION_H
+
+#define CCCL_VERSION 2003002
+#define CCCL_MAJOR_VERSION (CCCL_VERSION / 1000000)
+#define CCCL_MINOR_VERSION (((CCCL_VERSION / 1000) % 1000))
+#define CCCL_PATCH_VERSION (CCCL_VERSION % 1000)
+
+#if CCCL_PATCH_VERSION > 99
+#error "CCCL patch version cannot be greater than 99 for compatibility with Thrust/CUB's MMMmmmpp format."
+#endif
+
+#endif // __CCCL_VERSION_H

cuda_toolkit/include/__cccl/visibility.h

@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 __CCCL_VISIBILITY_H
+#define __CCCL_VISIBILITY_H
+
+#ifndef __CCCL_CONFIG
+#error "<__cccl/visibility.h> should only be included in from <cuda/__cccl_config>"
+#endif // __CCCL_CONFIG
+
+// We want to ensure that all warning emmiting from this header are supressed
+#if defined(_CCCL_FORCE_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_FORCE_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_FORCE_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// For unknown reasons, nvc++ need to selectively disable this warning
+// We do not want to use our usual macro because that would have push / pop semantics
+#if defined(_CCCL_COMPILER_NVHPC)
+#  pragma nv_diag_suppress 1407
+#endif // _CCCL_COMPILER_NVHPC
+
+// Enable us to hide kernels
+#if defined(_CCCL_COMPILER_MSVC)
+#  define _CCCL_ATTRIBUTE_HIDDEN
+#elif defined(_CCCL_COMPILER_NVRTC)
+#  define _CCCL_ATTRIBUTE_HIDDEN
+#else // ^^^ _CCCL_COMPILER_NVRTC ^^^ / vvv _CCCL_COMPILER_NVRTC vvv
+#  define _CCCL_ATTRIBUTE_HIDDEN __attribute__ ((__visibility__("hidden")))
+#endif // !_CCCL_COMPILER_NVRTC
+
+#if !defined(CCCL_DETAIL_KERNEL_ATTRIBUTES)
+#  define CCCL_DETAIL_KERNEL_ATTRIBUTES __global__ _CCCL_ATTRIBUTE_HIDDEN
+#endif // !CCCL_DETAIL_KERNEL_ATTRIBUTES
+
+#endif // __CCCL_VISIBILITY_H

cuda_toolkit/include/__concepts/_One_of.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___CONCEPTS_ONE_OF_H
+#define _LIBCUDACXX___CONCEPTS_ONE_OF_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__type_traits/disjunction.h"
+#include "../__type_traits/is_same.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 14
+template <class _Ty, class... _Others>
+_LIBCUDACXX_CONCEPT _One_of = (is_same_v<_Ty, _Others> || ...);
+#elif _LIBCUDACXX_STD_VER > 11
+template <class _Ty, class... _Others>
+_LIBCUDACXX_CONCEPT _One_of = _LIBCUDACXX_TRAIT(disjunction, is_same<_Ty, _Others>...);
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_ONE_OF_H

cuda_toolkit/include/__concepts/__concept_macros.h

@@ -0,0 +1,299 @@
+//===----------------------------------------------------------------------===//
+//
+// Copyright (c) Facebook, Inc. and its affiliates.
+// Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+// 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 _CUDA___CONCEPTS
+#define _CUDA___CONCEPTS
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#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 _LIBCUDACXX_STD_VER > 11
+
+#define _LIBCUDACXX_PP_CAT_(_Xp, ...) _Xp##__VA_ARGS__
+#define _LIBCUDACXX_PP_CAT(_Xp, ...) _LIBCUDACXX_PP_CAT_(_Xp, __VA_ARGS__)
+
+#define _LIBCUDACXX_PP_CAT2_(_Xp, ...) _Xp##__VA_ARGS__
+#define _LIBCUDACXX_PP_CAT2(_Xp, ...) _LIBCUDACXX_PP_CAT2_(_Xp, __VA_ARGS__)
+
+#define _LIBCUDACXX_PP_CAT3_(_Xp, ...) _Xp##__VA_ARGS__
+#define _LIBCUDACXX_PP_CAT3(_Xp, ...) _LIBCUDACXX_PP_CAT3_(_Xp, __VA_ARGS__)
+
+#define _LIBCUDACXX_PP_CAT4_(_Xp, ...) _Xp##__VA_ARGS__
+#define _LIBCUDACXX_PP_CAT4(_Xp, ...) _LIBCUDACXX_PP_CAT4_(_Xp, __VA_ARGS__)
+
+#define _LIBCUDACXX_PP_EVAL_(_Xp, _ARGS) _Xp _ARGS
+#define _LIBCUDACXX_PP_EVAL(_Xp, ...) _LIBCUDACXX_PP_EVAL_(_Xp, (__VA_ARGS__))
+
+#define _LIBCUDACXX_PP_EVAL2_(_Xp, _ARGS) _Xp _ARGS
+#define _LIBCUDACXX_PP_EVAL2(_Xp, ...) _LIBCUDACXX_PP_EVAL2_(_Xp, (__VA_ARGS__))
+
+#define _LIBCUDACXX_PP_EXPAND(...) __VA_ARGS__
+#define _LIBCUDACXX_PP_EAT(...)
+
+#define _LIBCUDACXX_PP_CHECK(...)                                              \
+  _LIBCUDACXX_PP_EXPAND(_LIBCUDACXX_PP_CHECK_N(__VA_ARGS__, 0, ))
+#define _LIBCUDACXX_PP_CHECK_N(_Xp, _Num, ...) _Num
+#define _LIBCUDACXX_PP_PROBE(_Xp) _Xp, 1,
+#define _LIBCUDACXX_PP_PROBE_N(_Xp, _Num) _Xp, _Num,
+
+#define _LIBCUDACXX_PP_IS_PAREN(_Xp)                                           \
+  _LIBCUDACXX_PP_CHECK(_LIBCUDACXX_PP_IS_PAREN_PROBE _Xp)
+#define _LIBCUDACXX_PP_IS_PAREN_PROBE(...) _LIBCUDACXX_PP_PROBE(~)
+
+// The final _LIBCUDACXX_PP_EXPAND here is to avoid
+// https://stackoverflow.com/questions/5134523/msvc-doesnt-expand-va-args-correctly
+#define _LIBCUDACXX_PP_COUNT(...)                                              \
+  _LIBCUDACXX_PP_EXPAND(_LIBCUDACXX_PP_COUNT_(                                 \
+      __VA_ARGS__, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, \
+      35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18,  \
+      17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ))            \
+  /**/
+#define _LIBCUDACXX_PP_COUNT_(                                                 \
+    _01, _02, _03, _04, _05, _06, _07, _08, _09, _10, _11, _12, _13, _14, _15, \
+    _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \
+    _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, \
+    _46, _47, _48, _49, _50, _Np, ...)                                         \
+  _Np /**/
+
+#define _LIBCUDACXX_PP_IIF(_BIT) _LIBCUDACXX_PP_CAT_(_LIBCUDACXX_PP_IIF_, _BIT)
+#define _LIBCUDACXX_PP_IIF_0(_TRUE, ...) __VA_ARGS__
+#define _LIBCUDACXX_PP_IIF_1(_TRUE, ...) _TRUE
+
+#define _LIBCUDACXX_PP_LPAREN (
+
+#define _LIBCUDACXX_PP_NOT(_BIT) _LIBCUDACXX_PP_CAT_(_LIBCUDACXX_PP_NOT_, _BIT)
+#define _LIBCUDACXX_PP_NOT_0 1
+#define _LIBCUDACXX_PP_NOT_1 0
+
+#define _LIBCUDACXX_PP_EMPTY()
+#define _LIBCUDACXX_PP_COMMA() ,
+#define _LIBCUDACXX_PP_LBRACE() {
+#define _LIBCUDACXX_PP_RBRACE() }
+#define _LIBCUDACXX_PP_COMMA_IIF(_Xp)                                          \
+  _LIBCUDACXX_PP_IIF(_Xp)(_LIBCUDACXX_PP_EMPTY, _LIBCUDACXX_PP_COMMA)() /**/
+
+#define _LIBCUDACXX_PP_FOR_EACH(_Mp, ...)                                      \
+  _LIBCUDACXX_PP_FOR_EACH_N(_LIBCUDACXX_PP_COUNT(__VA_ARGS__), _Mp, __VA_ARGS__)
+#define _LIBCUDACXX_PP_FOR_EACH_N(_Np, _Mp, ...)                               \
+  _LIBCUDACXX_PP_CAT2(_LIBCUDACXX_PP_FOR_EACH_, _Np)(_Mp, __VA_ARGS__)
+#define _LIBCUDACXX_PP_FOR_EACH_1(_Mp, _1) _Mp(_1)
+#define _LIBCUDACXX_PP_FOR_EACH_2(_Mp, _1, _2) _Mp(_1) _Mp(_2)
+#define _LIBCUDACXX_PP_FOR_EACH_3(_Mp, _1, _2, _3) _Mp(_1) _Mp(_2) _Mp(_3)
+#define _LIBCUDACXX_PP_FOR_EACH_4(_Mp, _1, _2, _3, _4)                         \
+  _Mp(_1) _Mp(_2) _Mp(_3) _Mp(_4)
+#define _LIBCUDACXX_PP_FOR_EACH_5(_Mp, _1, _2, _3, _4, _5)                     \
+  _Mp(_1) _Mp(_2) _Mp(_3) _Mp(_4) _Mp(_5)
+#define _LIBCUDACXX_PP_FOR_EACH_6(_Mp, _1, _2, _3, _4, _5, _6)                 \
+  _Mp(_1) _Mp(_2) _Mp(_3) _Mp(_4) _Mp(_5) _Mp(_6)
+#define _LIBCUDACXX_PP_FOR_EACH_7(_Mp, _1, _2, _3, _4, _5, _6, _7)             \
+  _Mp(_1) _Mp(_2) _Mp(_3) _Mp(_4) _Mp(_5) _Mp(_6) _Mp(_7)
+#define _LIBCUDACXX_PP_FOR_EACH_8(_Mp, _1, _2, _3, _4, _5, _6, _7, _8)         \
+  _Mp(_1) _Mp(_2) _Mp(_3) _Mp(_4) _Mp(_5) _Mp(_6) _Mp(_7) _Mp(_8)
+
+#define _LIBCUDACXX_PP_PROBE_EMPTY_PROBE__LIBCUDACXX_PP_PROBE_EMPTY            \
+  _LIBCUDACXX_PP_PROBE(~)
+
+#define _LIBCUDACXX_PP_PROBE_EMPTY()
+#define _LIBCUDACXX_PP_IS_NOT_EMPTY(...)                                       \
+  _LIBCUDACXX_PP_EVAL(                                                         \
+      _LIBCUDACXX_PP_CHECK,                                                    \
+      _LIBCUDACXX_PP_CAT(_LIBCUDACXX_PP_PROBE_EMPTY_PROBE_,                    \
+                         _LIBCUDACXX_PP_PROBE_EMPTY __VA_ARGS__()))            \
+  /**/
+
+#define _LIBCUDACXX_PP_TAIL(_, ...) __VA_ARGS__
+
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M0(_REQ)                             \
+  _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_(_REQ)(_REQ)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M1(_REQ) _LIBCUDACXX_PP_EXPAND _REQ
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_(...)                                \
+  { _LIBCUDACXX_PP_FOR_EACH(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M, __VA_ARGS__) }
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_(_REQ)                        \
+  _LIBCUDACXX_PP_CAT3(                                                         \
+      _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_,                               \
+      _LIBCUDACXX_PP_EVAL(                                                     \
+          _LIBCUDACXX_PP_CHECK,                                                \
+          _LIBCUDACXX_PP_CAT3(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_PROBE_, \
+                              _REQ)))                                          \
+  /**/
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_PROBE_requires                \
+  _LIBCUDACXX_PP_PROBE_N(~, 1)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_PROBE_noexcept                \
+  _LIBCUDACXX_PP_PROBE_N(~, 2)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_PROBE_typename                \
+  _LIBCUDACXX_PP_PROBE_N(~, 3)
+
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_0 _LIBCUDACXX_PP_EXPAND
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_1                             \
+  _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_OR_NOEXCEPT
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_2                             \
+  _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_OR_NOEXCEPT
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_3                             \
+  _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_OR_NOEXCEPT
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_OR_NOEXCEPT(_REQ)           \
+  _LIBCUDACXX_PP_CAT4(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_, _REQ)
+#define _LIBCUDACXX_PP_EAT_TYPENAME_PROBE_typename _LIBCUDACXX_PP_PROBE(~)
+#define _LIBCUDACXX_PP_EAT_TYPENAME_SELECT_(_Xp, ...)                          \
+  _LIBCUDACXX_PP_CAT3(                                                         \
+      _LIBCUDACXX_PP_EAT_TYPENAME_SELECT_,                                     \
+      _LIBCUDACXX_PP_EVAL(                                                     \
+          _LIBCUDACXX_PP_CHECK,                                                \
+          _LIBCUDACXX_PP_CAT3(_LIBCUDACXX_PP_EAT_TYPENAME_PROBE_, _Xp)))
+#define _LIBCUDACXX_PP_EAT_TYPENAME_(...)                                      \
+  _LIBCUDACXX_PP_EVAL2(_LIBCUDACXX_PP_EAT_TYPENAME_SELECT_, __VA_ARGS__, )     \
+  (__VA_ARGS__)
+#define _LIBCUDACXX_PP_EAT_TYPENAME_SELECT_0(...) __VA_ARGS__
+#define _LIBCUDACXX_PP_EAT_TYPENAME_SELECT_1(...)                              \
+  _LIBCUDACXX_PP_CAT3(_LIBCUDACXX_PP_EAT_TYPENAME_, __VA_ARGS__)
+#define _LIBCUDACXX_PP_EAT_TYPENAME_typename
+
+#if (defined(__cpp_concepts) && _LIBCUDACXX_STD_VER >= 20) ||                  \
+    defined(_LIBCUDACXX_DOXYGEN_INVOKED)
+
+#define _LIBCUDACXX_CONCEPT concept
+
+#define _LIBCUDACXX_CONCEPT_FRAGMENT(_NAME, ...)                               \
+  concept _NAME =                                                              \
+      _LIBCUDACXX_PP_CAT(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_, __VA_ARGS__)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_requires(...)                        \
+  requires(__VA_ARGS__) _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M(_REQ)                              \
+  _LIBCUDACXX_PP_CAT2(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M,                     \
+                      _LIBCUDACXX_PP_IS_PAREN(_REQ))                           \
+  (_REQ);
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_requires(...)               \
+  requires __VA_ARGS__
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_typename(...)               \
+  typename _LIBCUDACXX_PP_EAT_TYPENAME_(__VA_ARGS__)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_noexcept(...)               \
+  { __VA_ARGS__ }                                                              \
+  noexcept
+
+#define _LIBCUDACXX_FRAGMENT(_NAME, ...) _NAME<__VA_ARGS__>
+
+#else
+
+#define _LIBCUDACXX_CONCEPT _LIBCUDACXX_INLINE_VAR constexpr bool
+
+#define _LIBCUDACXX_CONCEPT_FRAGMENT(_NAME, ...)                               \
+  _LIBCUDACXX_INLINE_VISIBILITY auto _NAME##_LIBCUDACXX_CONCEPT_FRAGMENT_impl_ \
+          _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_##__VA_ARGS__ > {}                 \
+  template <typename... _As>                                                   \
+  _LIBCUDACXX_INLINE_VISIBILITY char _NAME##_LIBCUDACXX_CONCEPT_FRAGMENT_(     \
+      _Concept::_Tag<_As...> *,                                                \
+      decltype(&_NAME##_LIBCUDACXX_CONCEPT_FRAGMENT_impl_<_As...>));           \
+  _LIBCUDACXX_INLINE_VISIBILITY char(                                          \
+      &_NAME##_LIBCUDACXX_CONCEPT_FRAGMENT_(...))[2] /**/
+#if defined(_MSC_VER) && !defined(__clang__)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_TRUE(...)                                 \
+  _Concept::_Is_true<decltype(_LIBCUDACXX_PP_FOR_EACH(                         \
+      _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M, __VA_ARGS__) void())>()
+#else
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_TRUE(...)                                 \
+  !(decltype(_LIBCUDACXX_PP_FOR_EACH(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M,      \
+                                     __VA_ARGS__) void(),                      \
+             false){})
+#endif
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_requires(...)                        \
+  (__VA_ARGS__)->_Concept::_Enable_if_t < _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_2_
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_2_(...)                              \
+  _LIBCUDACXX_CONCEPT_FRAGMENT_TRUE(__VA_ARGS__)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M(_REQ)                              \
+  _LIBCUDACXX_PP_CAT2(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M,                     \
+                      _LIBCUDACXX_PP_IS_PAREN(_REQ))                           \
+  (_REQ),
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_requires(...)               \
+  _Concept::_Requires<__VA_ARGS__>
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_typename(...)               \
+  static_cast<_Concept::_Tag<__VA_ARGS__> *>(nullptr)
+#if defined(_LIBCUDACXX_COMPILER_GCC)
+// GCC can't mangle noexcept expressions, so just check that the
+// expression is well-formed.
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70790
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_noexcept(...) __VA_ARGS__
+#else
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_noexcept(...)               \
+  _Concept::_Requires<noexcept(__VA_ARGS__)>
+#endif
+
+#define _LIBCUDACXX_FRAGMENT(_NAME, ...)                                       \
+  (1u == sizeof(_NAME##_LIBCUDACXX_CONCEPT_FRAGMENT_(                          \
+             static_cast<_Concept::_Tag<__VA_ARGS__> *>(nullptr), nullptr)))
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// _LIBCUDACXX_TEMPLATE
+// Usage:
+//   _LIBCUDACXX_TEMPLATE(typename A, typename _Bp)
+//     _LIBCUDACXX_REQUIRES( Concept1<A> _LIBCUDACXX_AND Concept2<_Bp>)
+//   void foo(A a, _Bp b)
+//   {}
+#if (defined(__cpp_concepts) && _LIBCUDACXX_STD_VER >= 20)
+#define _LIBCUDACXX_TEMPLATE(...) template <__VA_ARGS__>
+#define _LIBCUDACXX_REQUIRES(...) requires __VA_ARGS__
+#define _LIBCUDACXX_AND &&
+#define _LIBCUDACXX_TRAILING_REQUIRES(...) -> __VA_ARGS__ requires _LIBCUDACXX_PP_EXPAND
+#else
+#define _LIBCUDACXX_TEMPLATE(...) template <__VA_ARGS__
+#define _LIBCUDACXX_REQUIRES(...)                                              \
+  , bool _LIBCUDACXX_true_ = true,                                             \
+         _Concept::_Enable_if_t <__VA_ARGS__ &&                                \
+             _LIBCUDACXX_true_,                                                \
+         int > = 0 > /**/
+#define _LIBCUDACXX_AND \
+  && _LIBCUDACXX_true_, int > = 0, _Concept::_Enable_if_t <
+#define _LIBCUDACXX_TRAILING_REQUIRES_AUX_(...)                                \
+  , __VA_ARGS__>
+#define _LIBCUDACXX_TRAILING_REQUIRES(...)                                     \
+  -> _Concept::_Requires_t<__VA_ARGS__ _LIBCUDACXX_TRAILING_REQUIRES_AUX_
+#endif
+
+namespace _Concept {
+template <bool> struct _Select {};
+
+template <> struct _Select<true> { template <class _Tp> using type = _Tp; };
+
+template <bool _Bp, class _Tp = void>
+using _Enable_if_t = typename _Select<_Bp>::template type<_Tp>;
+
+template <class _Tp, bool _Bp>
+using _Requires_t = typename _Select<_Bp>::template type<_Tp>;
+
+template <typename...> struct _Tag;
+template <class>
+_LIBCUDACXX_INLINE_VISIBILITY inline constexpr bool _Is_true() {
+  return true;
+}
+
+#if defined(_LIBCUDACXX_COMPILER_CLANG) || defined(_LIBCUDACXX_COMPILER_MSVC)
+template <bool _Bp>
+_LIBCUDACXX_INLINE_VISIBILITY _Concept::_Enable_if_t<_Bp> _Requires() {}
+#else
+template <bool _Bp, _Concept::_Enable_if_t<_Bp, int> = 0>
+_LIBCUDACXX_INLINE_VAR constexpr int _Requires = 0;
+#endif
+} // namespace _Concept
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+#endif //_CUDA___CONCEPTS

cuda_toolkit/include/__concepts/arithmetic.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___CONCEPTS_ARITHMETIC_H
+#define _LIBCUDACXX___CONCEPTS_ARITHMETIC_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__type_traits/is_arithmetic.h"
+#include "../__type_traits/is_floating_point.h"
+#include "../__type_traits/is_integral.h"
+#include "../__type_traits/is_signed_integer.h"
+#include "../__type_traits/is_signed.h"
+#include "../__type_traits/is_unsigned_integer.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concepts.arithmetic], arithmetic concepts
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT integral = _LIBCUDACXX_TRAIT(is_integral, _Tp);
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT signed_integral = integral<_Tp> && _LIBCUDACXX_TRAIT(is_signed, _Tp);
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT floating_point = _LIBCUDACXX_TRAIT(is_floating_point, _Tp);
+
+// Concept helpers for the internal type traits for the fundamental types.
+template <class _Tp>
+_LIBCUDACXX_CONCEPT __libcpp_unsigned_integer = __libcpp_is_unsigned_integer<_Tp>::value;
+template <class _Tp>
+_LIBCUDACXX_CONCEPT __libcpp_signed_integer = __libcpp_is_signed_integer<_Tp>::value;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_ARITHMETIC_H

cuda_toolkit/include/__concepts/assignable.h

@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_ASSIGNABLE_H
+#define _LIBCUDACXX___CONCEPTS_ASSIGNABLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/common_reference_with.h"
+#include "../__concepts/same_as.h"
+#include "../__type_traits/is_reference.h"
+#include "../__type_traits/make_const_lvalue_ref.h"
+#include "../__utility/forward.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.assignable]
+
+template<class _Lhs, class _Rhs>
+concept assignable_from =
+  is_lvalue_reference_v<_Lhs> &&
+  common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
+  requires (_Lhs __lhs, _Rhs&& __rhs) {
+    { __lhs = _CUDA_VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
+  };
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Lhs, class _Rhs>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __assignable_from_,
+  requires(_Lhs __lhs, _Rhs&& __rhs)(
+    requires(_LIBCUDACXX_TRAIT(is_lvalue_reference, _Lhs)),
+    requires(common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>>),
+    requires(same_as<_Lhs, decltype(__lhs = _CUDA_VSTD::forward<_Rhs>(__rhs))>)
+  ));
+
+template<class _Lhs, class _Rhs>
+_LIBCUDACXX_CONCEPT assignable_from = _LIBCUDACXX_FRAGMENT(__assignable_from_, _Lhs, _Rhs);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_ASSIGNABLE_H

cuda_toolkit/include/__concepts/boolean_testable.h

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_BOOLEAN_TESTABLE_H
+#define _LIBCUDACXX___CONCEPTS_BOOLEAN_TESTABLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/convertible_to.h"
+#include "../__utility/forward.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concepts.booleantestable]
+
+template<class _Tp>
+concept __boolean_testable_impl = convertible_to<_Tp, bool>;
+
+template<class _Tp>
+concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
+  { !_CUDA_VSTD::forward<_Tp>(__t) } -> __boolean_testable_impl;
+};
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT __boolean_testable_impl = convertible_to<_Tp, bool>;
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __boolean_testable_,
+  requires(_Tp&& __t)(
+    requires(__boolean_testable_impl<_Tp>),
+    requires(__boolean_testable_impl<decltype(!_CUDA_VSTD::forward<_Tp>(__t))>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT __boolean_testable = _LIBCUDACXX_FRAGMENT(__boolean_testable_, _Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_BOOLEAN_TESTABLE_H

cuda_toolkit/include/__concepts/class_or_enum.h

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_CLASS_OR_ENUM_H
+#define _LIBCUDACXX___CONCEPTS_CLASS_OR_ENUM_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__type_traits/is_class.h"
+#include "../__type_traits/is_enum.h"
+#include "../__type_traits/is_union.h"
+#include "../__type_traits/remove_cvref.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT __class_or_enum = _LIBCUDACXX_TRAIT(is_class, _Tp) || _LIBCUDACXX_TRAIT(is_union, _Tp) || _LIBCUDACXX_TRAIT(is_enum, _Tp);
+
+// Work around Clang bug https://llvm.org/PR52970
+// TODO: remove this workaround once libc++ no longer has to support Clang 13 (it was fixed in Clang 14).
+template<class _Tp>
+_LIBCUDACXX_CONCEPT __workaround_52970 = _LIBCUDACXX_TRAIT(is_class, remove_cvref_t<_Tp>) || _LIBCUDACXX_TRAIT(is_union, remove_cvref_t<_Tp>);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_CLASS_OR_ENUM_H

cuda_toolkit/include/__concepts/common_reference_with.h

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_COMMON_REFERENCE_WITH_H
+#define _LIBCUDACXX___CONCEPTS_COMMON_REFERENCE_WITH_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/convertible_to.h"
+#include "../__concepts/same_as.h"
+#include "../__type_traits/common_reference.h"
+#include "../__type_traits/copy_cv.h"
+#include "../__type_traits/copy_cvref.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.commonref]
+
+template<class _Tp, class _Up>
+concept common_reference_with =
+  same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
+  convertible_to<_Tp, common_reference_t<_Tp, _Up>> &&
+  convertible_to<_Up, common_reference_t<_Tp, _Up>>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __common_reference_exists_,
+  requires()(
+    typename(common_reference_t<_Tp, _Up>),
+    typename(common_reference_t<_Up, _Tp>)
+  ));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT _Common_reference_exists = _LIBCUDACXX_FRAGMENT(__common_reference_exists_, _Tp, _Up);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __common_reference_with_,
+  requires()(
+    requires(_Common_reference_exists<_Tp, _Up>),
+    requires(same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>>),
+    requires(convertible_to<_Tp, common_reference_t<_Tp, _Up>>),
+    requires(convertible_to<_Up, common_reference_t<_Tp, _Up>>)
+  ));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT common_reference_with = _LIBCUDACXX_FRAGMENT(__common_reference_with_, _Tp, _Up);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_COMMON_REFERENCE_WITH_H

cuda_toolkit/include/__concepts/common_with.h

@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_COMMON_WITH_H
+#define _LIBCUDACXX___CONCEPTS_COMMON_WITH_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/common_reference_with.h"
+#include "../__concepts/same_as.h"
+#include "../__type_traits/add_lvalue_reference.h"
+#include "../__type_traits/common_type.h"
+#include "../__utility/declval.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.common]
+
+template<class _Tp, class _Up>
+concept common_with =
+  same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
+  requires {
+    static_cast<common_type_t<_Tp, _Up>>(_CUDA_VSTD::declval<_Tp>());
+    static_cast<common_type_t<_Tp, _Up>>(_CUDA_VSTD::declval<_Up>());
+  } &&
+  common_reference_with<
+    add_lvalue_reference_t<const _Tp>,
+    add_lvalue_reference_t<const _Up>> &&
+  common_reference_with<
+    add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
+    common_reference_t<
+      add_lvalue_reference_t<const _Tp>,
+      add_lvalue_reference_t<const _Up>>>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __common_type_exists_,
+  requires()(
+    typename(common_type_t<_Tp, _Up>),
+    typename(common_type_t<_Up, _Tp>)
+  ));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT _Common_type_exists = _LIBCUDACXX_FRAGMENT(__common_type_exists_, _Tp, _Up);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __common_type_constructible_,
+  requires()(
+    requires(_Common_type_exists<_Tp, _Up>),
+    static_cast<common_type_t<_Tp, _Up>>(_CUDA_VSTD::declval<_Tp>()),
+    static_cast<common_type_t<_Tp, _Up>>(_CUDA_VSTD::declval<_Up>())
+  ));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT _Common_type_constructible = _LIBCUDACXX_FRAGMENT(__common_type_constructible_, _Tp, _Up);
+
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __common_with_,
+  requires()(
+    requires(_Common_type_constructible<_Tp, _Up>),
+    requires(same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>>),
+    requires(common_reference_with<
+              add_lvalue_reference_t<const _Tp>,
+              add_lvalue_reference_t<const _Up>>),
+    requires(common_reference_with<
+              add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
+              common_reference_t<
+                add_lvalue_reference_t<const _Tp>,
+                add_lvalue_reference_t<const _Up>>>)));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT common_with = _LIBCUDACXX_FRAGMENT(__common_with_, _Tp, _Up);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_COMMON_WITH_H

cuda_toolkit/include/__concepts/constructible.h

@@ -0,0 +1,125 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_CONSTRUCTIBLE_H
+#define _LIBCUDACXX___CONCEPTS_CONSTRUCTIBLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/convertible_to.h"
+#include "../__concepts/destructible.h"
+#include "../__type_traits/add_lvalue_reference.h"
+#include "../__type_traits/is_constructible.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.constructible]
+template<class _Tp, class... _Args>
+concept constructible_from =
+    destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
+
+// [concept.default.init]
+template<class _Tp>
+concept __default_initializable = requires { ::new _Tp; };
+
+template<class _Tp>
+concept default_initializable = constructible_from<_Tp> &&
+    requires { _Tp{}; } && __default_initializable<_Tp>;
+
+// [concept.moveconstructible]
+template<class _Tp>
+concept move_constructible =
+  constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
+
+// [concept.copyconstructible]
+template<class _Tp>
+concept copy_constructible =
+  move_constructible<_Tp> &&
+  constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
+  constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
+  constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, class... _Args>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __constructible_from_,
+  requires()(
+    requires(destructible<_Tp>),
+    requires(_LIBCUDACXX_TRAIT(is_constructible, _Tp, _Args...))
+  ));
+
+template<class _Tp, class... _Args>
+_LIBCUDACXX_CONCEPT constructible_from = _LIBCUDACXX_FRAGMENT(__constructible_from_, _Tp, _Args...);
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __default_initializable_,
+  requires()(
+    (::new _Tp)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT __default_initializable = _LIBCUDACXX_FRAGMENT(__default_initializable_, _Tp);
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Default_initializable_,
+  requires(_Tp = _Tp{}) (
+    requires(constructible_from<_Tp>),
+    requires(__default_initializable<_Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT default_initializable = _LIBCUDACXX_FRAGMENT(_Default_initializable_, _Tp);
+
+// [concept.moveconstructible]
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __move_constructible_,
+  requires()(
+    requires(constructible_from<_Tp, _Tp>),
+    requires(convertible_to<_Tp, _Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT move_constructible = _LIBCUDACXX_FRAGMENT(__move_constructible_, _Tp);
+
+// [concept.copyconstructible]
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __copy_constructible_,
+  requires()(
+    requires(move_constructible<_Tp>),
+    requires(constructible_from<_Tp, add_lvalue_reference_t<_Tp>> && convertible_to<add_lvalue_reference_t<_Tp>, _Tp>),
+    requires(constructible_from<_Tp, const add_lvalue_reference_t<_Tp>> && convertible_to<const add_lvalue_reference_t<_Tp>, _Tp>),
+    requires(constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT copy_constructible =  _LIBCUDACXX_FRAGMENT(__copy_constructible_, _Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_CONSTRUCTIBLE_H

cuda_toolkit/include/__concepts/convertible_to.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___CONCEPTS_CONVERTIBLE_TO_H
+#define _LIBCUDACXX___CONCEPTS_CONVERTIBLE_TO_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__utility/declval.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.convertible]
+
+template<class _From, class _To>
+concept convertible_to =
+  is_convertible_v<_From, _To> &&
+  requires {
+    static_cast<_To>(_CUDA_VSTD::declval<_From>());
+  };
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+_LIBCUDACXX_NV_DIAG_SUPPRESS(1211) // nonstandard cast to array type ignored
+#endif // _LIBCUDACXX_COMPILER_MSVC
+
+// We cannot put this conversion check with the other constraint, as types with deleted operator will break here
+template<class _From, class _To>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __test_conversion_,
+  requires()(
+    static_cast<_To>(_CUDA_VSTD::declval<_From>())
+  ));
+
+template<class _From, class _To>
+_LIBCUDACXX_CONCEPT __test_conversion = _LIBCUDACXX_FRAGMENT(__test_conversion_, _From, _To);
+
+template<class _From, class _To>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __convertible_to_,
+  requires()(
+    requires(_LIBCUDACXX_TRAIT(is_convertible, _From, _To)),
+    requires(__test_conversion<_From, _To>)
+  ));
+
+template<class _From, class _To>
+_LIBCUDACXX_CONCEPT convertible_to = _LIBCUDACXX_FRAGMENT(__convertible_to_, _From, _To);
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+_LIBCUDACXX_NV_DIAG_DEFAULT(1211) // nonstandard cast to array type ignored
+#endif // _LIBCUDACXX_COMPILER_MSVC
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_CONVERTIBLE_TO_H

cuda_toolkit/include/__concepts/copyable.h

@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_COPYABLE_H
+#define _LIBCUDACXX___CONCEPTS_COPYABLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/assignable.h"
+#include "../__concepts/constructible.h"
+#include "../__concepts/movable.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concepts.object]
+
+template<class _Tp>
+concept copyable =
+  copy_constructible<_Tp> &&
+  movable<_Tp> &&
+  assignable_from<_Tp&, _Tp&> &&
+  assignable_from<_Tp&, const _Tp&> &&
+  assignable_from<_Tp&, const _Tp>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __copyable_,
+  requires()(
+    requires(copy_constructible<_Tp>),
+    requires(movable<_Tp>),
+    requires(assignable_from<_Tp&, _Tp&>),
+    requires(assignable_from<_Tp&, const _Tp&>),
+    requires(assignable_from<_Tp&, const _Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT copyable = _LIBCUDACXX_FRAGMENT(__copyable_,_Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_COPYABLE_H

cuda_toolkit/include/__concepts/derived_from.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___CONCEPTS_DERIVED_FROM_H
+#define _LIBCUDACXX___CONCEPTS_DERIVED_FROM_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__type_traits/add_pointer.h"
+#include "../__type_traits/is_base_of.h"
+#include "../__type_traits/is_convertible.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.derived]
+
+template<class _Dp, class _Bp>
+concept derived_from =
+  is_base_of_v<_Bp, _Dp> &&
+  is_convertible_v<const volatile _Dp*, const volatile _Bp*>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Dp, class _Bp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __derived_from_,
+  requires()(
+    requires(_LIBCUDACXX_TRAIT(is_base_of, _Bp, _Dp)),
+    requires(_LIBCUDACXX_TRAIT(is_convertible, add_pointer_t<const volatile _Dp>, add_pointer_t<const volatile _Bp>))
+  ));
+
+template<class _Dp, class _Bp>
+_LIBCUDACXX_CONCEPT derived_from = _LIBCUDACXX_FRAGMENT(__derived_from_, _Dp, _Bp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_DERIVED_FROM_H

cuda_toolkit/include/__concepts/destructible.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___CONCEPTS_DESTRUCTIBLE_H
+#define _LIBCUDACXX___CONCEPTS_DESTRUCTIBLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_destructible.h"
+#include "../__type_traits/is_object.h"
+#include "../__type_traits/is_nothrow_destructible.h"
+#include "../__type_traits/void_t.h"
+#include "../__utility/declval.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT destructible = __is_nothrow_destructible(_Tp);
+
+#else // ^^^ _LIBCUDACXX_COMPILER_MSVC ^^^ / vvv !_LIBCUDACXX_COMPILER_MSVC vvv
+
+template<class _Tp, class = void, class = void>
+_LIBCUDACXX_INLINE_VAR constexpr bool __destructible_impl = false;
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool __destructible_impl<_Tp,
+                                   __enable_if_t<_LIBCUDACXX_TRAIT(is_object, _Tp)>,
+#if defined(_LIBCUDACXX_COMPILER_GCC)
+                                   __enable_if_t<_LIBCUDACXX_TRAIT(is_destructible, _Tp)>>
+#else // ^^^ defined(_LIBCUDACXX_COMPILER_GCC) ^^^ / vvv !_LIBCUDACXX_COMPILER_GCC vvv
+                                   __void_t<decltype(_CUDA_VSTD::declval<_Tp>().~_Tp())>>
+#endif // !_LIBCUDACXX_COMPILER_GCC
+                                   = noexcept(_CUDA_VSTD::declval<_Tp>().~_Tp());
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool __destructible = __destructible_impl<_Tp>;
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool __destructible<_Tp&> = true;
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool __destructible<_Tp&&> = true;
+
+template<class _Tp, size_t _Nm>
+_LIBCUDACXX_INLINE_VAR constexpr bool __destructible<_Tp[_Nm]> = __destructible<_Tp>;
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT destructible = __destructible<_Tp>;
+
+#endif // !_LIBCUDACXX_COMPILER_MSVC
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_DESTRUCTIBLE_H

cuda_toolkit/include/__concepts/different_from.h

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_DIFFERENT_FROM_H
+#define _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/same_as.h"
+#include "../__type_traits/remove_cvref.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT __different_from = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H

cuda_toolkit/include/__concepts/equality_comparable.h

@@ -0,0 +1,111 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_EQUALITY_COMPARABLE_H
+#define _LIBCUDACXX___CONCEPTS_EQUALITY_COMPARABLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/boolean_testable.h"
+#include "../__concepts/common_reference_with.h"
+#include "../__type_traits/common_reference.h"
+#include "../__type_traits/make_const_lvalue_ref.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.equalitycomparable]
+
+template<class _Tp, class _Up>
+concept __weakly_equality_comparable_with =
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+    { __t == __u } -> __boolean_testable;
+    { __t != __u } -> __boolean_testable;
+    { __u == __t } -> __boolean_testable;
+    { __u != __t } -> __boolean_testable;
+  };
+
+template<class _Tp>
+concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
+
+template<class _Tp, class _Up>
+concept equality_comparable_with =
+  equality_comparable<_Tp> && equality_comparable<_Up> &&
+  common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
+  equality_comparable<
+    common_reference_t<
+      __make_const_lvalue_ref<_Tp>,
+      __make_const_lvalue_ref<_Up>>> &&
+  __weakly_equality_comparable_with<_Tp, _Up>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __with_lvalue_reference_,
+  requires()(
+    typename(__make_const_lvalue_ref<_Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT _With_lvalue_reference = _LIBCUDACXX_FRAGMENT(__with_lvalue_reference_, _Tp);
+
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __weakly_equality_comparable_with_,
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u)(
+    requires(_With_lvalue_reference<_Tp>),
+    requires(_With_lvalue_reference<_Up>),
+    requires(__boolean_testable<decltype(__t == __u)>),
+    requires(__boolean_testable<decltype(__t != __u)>),
+    requires(__boolean_testable<decltype(__u == __t)>),
+    requires(__boolean_testable<decltype(__u != __t)>)
+  ));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT __weakly_equality_comparable_with =
+  _LIBCUDACXX_FRAGMENT(__weakly_equality_comparable_with_, _Tp, _Up);
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __equality_comparable_with_,
+  requires()(
+    requires(equality_comparable<_Tp>),
+    requires(equality_comparable<_Up>),
+    requires(common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>),
+    requires(equality_comparable<
+    common_reference_t<
+      __make_const_lvalue_ref<_Tp>,
+      __make_const_lvalue_ref<_Up>>>),
+    requires(__weakly_equality_comparable_with<_Tp, _Up>)));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT equality_comparable_with = _LIBCUDACXX_FRAGMENT(__equality_comparable_with_, _Tp, _Up);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_EQUALITY_COMPARABLE_H

cuda_toolkit/include/__concepts/invocable.h

@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_INVOCABLE_H
+#define _LIBCUDACXX___CONCEPTS_INVOCABLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__functional/invoke.h"
+#include "../__utility/forward.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.invocable]
+
+template<class _Fn, class... _Args>
+concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
+  _CUDA_VSTD::__invoke(_CUDA_VSTD::forward<_Fn>(__fn), _CUDA_VSTD::forward<_Args>(__args)...); // not required to be equality preserving
+};
+
+// [concept.regular.invocable]
+
+template<class _Fn, class... _Args>
+concept regular_invocable = invocable<_Fn, _Args...>;
+
+template <class _Fun, class... _Args>
+concept __invoke_constructible = requires(_Fun&& __fun, _Args&&... __args) {
+    static_cast<remove_cvref_t<invoke_result_t<_Fun, _Args...>>>(
+        _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...));
+};
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Invocable_,
+  requires(_Fn&& __fn, _Args&&... __args)(
+    (_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__fn), _CUDA_VSTD::forward<_Args>(__args)...))
+  ));
+
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT invocable = _LIBCUDACXX_FRAGMENT(_Invocable_, _Fn, _Args...);
+
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT regular_invocable = invocable<_Fn, _Args...>;
+
+template <class _Fun, class... _Args>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __invoke_constructible_,
+  requires(_Fun&& __fun, _Args&&... __args)(
+    (static_cast<__remove_cvref_t<invoke_result_t<_Fun, _Args...>>>(
+        _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)))
+  ));
+template <class _Fun, class... _Args>
+_LIBCUDACXX_CONCEPT __invoke_constructible = _LIBCUDACXX_FRAGMENT(__invoke_constructible_, _Fun, _Args...);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_INVOCABLE_H

cuda_toolkit/include/__concepts/movable.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___CONCEPTS_MOVABLE_H
+#define _LIBCUDACXX___CONCEPTS_MOVABLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/assignable.h"
+#include "../__concepts/constructible.h"
+#include "../__concepts/swappable.h"
+#include "../__type_traits/is_object.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+template<class _Tp>
+concept movable =
+  is_object_v<_Tp> &&
+  move_constructible<_Tp>&&
+  assignable_from<_Tp&, _Tp> &&
+  swappable<_Tp>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+// [concepts.object]
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Movable_,
+  requires()(//
+    requires(is_object_v<_Tp>),
+    requires(move_constructible<_Tp>),
+    requires(assignable_from<_Tp&, _Tp>),
+    requires(swappable<_Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT movable = _LIBCUDACXX_FRAGMENT(_Movable_, _Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_MOVABLE_H

cuda_toolkit/include/__concepts/predicate.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___CONCEPTS_PREDICATE_H
+#define _LIBCUDACXX___CONCEPTS_PREDICATE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/boolean_testable.h"
+#include "../__concepts/invocable.h"
+#include "../__functional/invoke.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+template<class _Fn, class... _Args>
+concept predicate =
+  regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+// [concept.predicate]
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Predicate_,
+  requires()(//
+    requires(regular_invocable<_Fn, _Args...>),
+    requires(__boolean_testable<invoke_result_t<_Fn, _Args...>>)
+  ));
+
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT predicate = _LIBCUDACXX_FRAGMENT(_Predicate_, _Fn, _Args...);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_PREDICATE_H

cuda_toolkit/include/__concepts/regular.h

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_REGULAR_H
+#define _LIBCUDACXX___CONCEPTS_REGULAR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/equality_comparable.h"
+#include "../__concepts/semiregular.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.object]
+
+template<class _Tp>
+concept regular = semiregular<_Tp> && equality_comparable<_Tp>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+// [concept.object]
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __regular_,
+  requires()(
+    requires(semiregular<_Tp>),
+    requires(equality_comparable<_Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT regular = _LIBCUDACXX_FRAGMENT(__regular_, _Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_REGULAR_H

cuda_toolkit/include/__concepts/relation.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___CONCEPTS_RELATION_H
+#define _LIBCUDACXX___CONCEPTS_RELATION_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/predicate.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.relation]
+
+template<class _Rp, class _Tp, class _Up>
+concept relation =
+  predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> &&
+  predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>;
+
+// [concept.equiv]
+
+template<class _Rp, class _Tp, class _Up>
+concept equivalence_relation = relation<_Rp, _Tp, _Up>;
+
+// [concept.strictweakorder]
+
+template<class _Rp, class _Tp, class _Up>
+concept strict_weak_order = relation<_Rp, _Tp, _Up>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Rp, class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __relation_,
+  requires()(
+    requires(predicate<_Rp, _Tp, _Tp>),
+    requires(predicate<_Rp, _Up, _Up>),
+    requires(predicate<_Rp, _Tp, _Up>),
+    requires(predicate<_Rp, _Up, _Tp>)
+  ));
+
+template<class _Rp, class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT relation = _LIBCUDACXX_FRAGMENT(__relation_, _Rp, _Tp, _Up);
+
+// [concept.equiv]
+
+template<class _Rp, class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT equivalence_relation = relation<_Rp, _Tp, _Up>;
+
+// [concept.strictweakorder]
+
+template<class _Rp, class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT strict_weak_order = relation<_Rp, _Tp, _Up>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_RELATION_H

cuda_toolkit/include/__concepts/same_as.h

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_SAME_AS_H
+#define _LIBCUDACXX___CONCEPTS_SAME_AS_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__type_traits/is_same.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concept.same]
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT __same_as_impl = _IsSame<_Tp, _Up>::value;
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_SAME_AS_H

cuda_toolkit/include/__concepts/semiregular.h

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_SEMIREGULAR_H
+#define _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/constructible.h"
+#include "../__concepts/copyable.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.object]
+
+template<class _Tp>
+concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+// [concept.object]
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __semiregular_,
+  requires()(
+    requires(copyable<_Tp>),
+    requires(default_initializable<_Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT semiregular = _LIBCUDACXX_FRAGMENT(__semiregular_, _Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H

cuda_toolkit/include/__concepts/swappable.h

@@ -0,0 +1,228 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_SWAPPABLE_H
+#define _LIBCUDACXX___CONCEPTS_SWAPPABLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/assignable.h"
+#include "../__concepts/class_or_enum.h"
+#include "../__concepts/common_reference_with.h"
+#include "../__concepts/constructible.h"
+#include "../__type_traits/extent.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_nothrow_move_assignable.h"
+#include "../__type_traits/is_nothrow_move_constructible.h"
+#include "../__type_traits/remove_cvref.h"
+#include "../__type_traits/type_identity.h"
+#include "../__type_traits/void_t.h"
+#include "../__utility/declval.h"
+#include "../__utility/exchange.h"
+#include "../__utility/forward.h"
+#include "../__utility/move.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+_LIBCUDACXX_NV_DIAG_SUPPRESS(461) // nonstandard cast to array type ignored
+#endif // _LIBCUDACXX_COMPILER_MSVC
+
+#if _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_BEGIN_NAMESPACE_RANGES
+
+// [concept.swappable]
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CPO(__swap)
+
+  template<class _Tp>
+  void swap(_Tp&, _Tp&) = delete;
+
+#if _LIBCUDACXX_STD_VER > 17
+  template<class _Tp, class _Up>
+  concept __unqualified_swappable_with =
+    (__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
+    requires(_Tp&& __t, _Up&& __u) {
+      swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u));
+    };
+
+  template<class _Tp>
+  concept __exchangeable =
+    !__unqualified_swappable_with<_Tp&, _Tp&> &&
+    move_constructible<_Tp> &&
+    assignable_from<_Tp&, _Tp>;
+
+#else // ^^^ CXX20 ^^^ / vvv CXX17 vvv
+
+  template<class _Tp, class _Up>
+  _LIBCUDACXX_CONCEPT_FRAGMENT(
+    __unqualified_swappable_with_,
+    requires(_Tp&& __t, _Up&& __u)(
+      (swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u)))
+    ));
+
+  template<class _Tp, class _Up>
+  _LIBCUDACXX_CONCEPT __unqualified_swappable_with = _LIBCUDACXX_FRAGMENT(__unqualified_swappable_with_, _Tp, _Up);
+
+  template<class _Tp>
+  _LIBCUDACXX_CONCEPT_FRAGMENT(
+    __exchangeable_,
+    requires()(
+      requires(!__unqualified_swappable_with<_Tp&, _Tp&>),
+      requires(move_constructible<_Tp>),
+      requires(assignable_from<_Tp&, _Tp>)
+    ));
+
+  template<class _Tp>
+  _LIBCUDACXX_CONCEPT __exchangeable = _LIBCUDACXX_FRAGMENT(__exchangeable_, _Tp);
+#endif // _LIBCUDACXX_STD_VER < 20
+
+
+#if _LIBCUDACXX_STD_VER > 17 && !defined(_LIBCUDACXX_COMPILER_NVHPC) // nvbug4051640
+  struct __fn;
+
+_LIBCUDACXX_NV_DIAG_SUPPRESS(2642)
+  template<class _Tp, class _Up, size_t _Size>
+  concept __swappable_arrays =
+    !__unqualified_swappable_with<_Tp(&)[_Size], _Up(&)[_Size]> &&
+    extent_v<_Tp> == extent_v<_Up> &&
+    requires(_Tp(& __t)[_Size], _Up(& __u)[_Size], const __fn& __swap) {
+      __swap(__t[0], __u[0]);
+    };
+_LIBCUDACXX_NV_DIAG_DEFAULT(2642)
+
+#else
+  template<class _Tp, class _Up, size_t _Size, class = void>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __swappable_arrays = false;
+#endif // _LIBCUDACXX_STD_VER < 20 || defined(_LIBCUDACXX_COMPILER_NVHPC)
+
+
+  template<class _Tp, class _Up, class = void>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __noexcept_swappable_arrays = false;
+
+  struct __fn {
+    // 2.1   `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
+    // *The name `swap` is used here unqualified.
+    _LIBCUDACXX_TEMPLATE(class _Tp, class _Up)
+      _LIBCUDACXX_REQUIRES( __unqualified_swappable_with<_Tp, _Up>)
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr void operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u))))
+    {
+      swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u));
+    }
+
+    // 2.2   Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
+    _LIBCUDACXX_TEMPLATE(class _Tp, class _Up, size_t _Size)
+      _LIBCUDACXX_REQUIRES( __swappable_arrays<_Tp, _Up, _Size>)
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr void operator()(_Tp(& __t)[_Size], _Up(& __u)[_Size]) const
+      noexcept(__noexcept_swappable_arrays<_Tp, _Up>)
+    {
+      // TODO(cjdb): replace with `_CUDA_VRANGES::swap_ranges`.
+      for (size_t __i = 0; __i < _Size; ++__i) {
+        (*this)(__t[__i], __u[__i]);
+      }
+    }
+
+    // 2.3   Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
+    _LIBCUDACXX_TEMPLATE(class _Tp)
+      _LIBCUDACXX_REQUIRES( __exchangeable<_Tp>)
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr void operator()(_Tp& __x, _Tp& __y) const
+      noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp) && _LIBCUDACXX_TRAIT(is_nothrow_move_assignable, _Tp))
+    {
+      __y = _CUDA_VSTD::exchange(__x, _CUDA_VSTD::move(__y));
+    }
+  };
+
+#if _LIBCUDACXX_STD_VER < 20 || defined(_LIBCUDACXX_COMPILER_NVHPC)
+  template<class _Tp, class _Up, class _Size>
+  _LIBCUDACXX_CONCEPT_FRAGMENT(
+    __swappable_arrays_,
+    requires(_Tp(& __t)[_Size::value], _Up(& __u)[_Size::value], const __fn& __swap)(
+      requires(!__unqualified_swappable_with<_Tp(&)[_Size::value], _Up(&)[_Size::value]>),
+      requires(_LIBCUDACXX_TRAIT(extent, _Tp) == _LIBCUDACXX_TRAIT(extent, _Up)),
+      (__swap(__t[0], __u[0]))
+    ));
+
+  template<class _Tp, class _Up, size_t _Size>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __swappable_arrays<_Tp, _Up, _Size, void_t<type_identity_t<_Tp>>> =
+    _LIBCUDACXX_FRAGMENT(__swappable_arrays_, _Tp, _Up, _CUDA_VSTD::integral_constant<size_t, _Size>);
+#endif // _LIBCUDACXX_STD_VER < 20 || defined(_LIBCUDACXX_COMPILER_NVHPC)
+
+  template<class _Tp, class _Up>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __noexcept_swappable_arrays<_Tp, _Up, void_t<type_identity_t<_Tp>>> =
+    noexcept(__swap::__fn{}(_CUDA_VSTD::declval<_Tp&>(), _CUDA_VSTD::declval<_Up&>()));
+
+_LIBCUDACXX_END_NAMESPACE_CPO
+
+inline namespace __cpo {
+  _LIBCUDACXX_CPO_ACCESSIBILITY auto swap = __swap::__fn{};
+} // namespace __cpo
+_LIBCUDACXX_END_NAMESPACE_RANGES
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+template<class _Tp>
+concept swappable = requires(_Tp& __a, _Tp& __b) { _CUDA_VRANGES::swap(__a, __b); };
+
+template<class _Tp, class _Up>
+concept swappable_with =
+  common_reference_with<_Tp, _Up> &&
+  requires(_Tp&& __t, _Up&& __u) {
+    _CUDA_VRANGES::swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Tp>(__t));
+    _CUDA_VRANGES::swap(_CUDA_VSTD::forward<_Up>(__u), _CUDA_VSTD::forward<_Up>(__u));
+    _CUDA_VRANGES::swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u));
+    _CUDA_VRANGES::swap(_CUDA_VSTD::forward<_Up>(__u), _CUDA_VSTD::forward<_Tp>(__t));
+  };
+#else
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __swappable_,
+  requires(_Tp& __a, _Tp& __b)(
+    (_CUDA_VRANGES::swap(__a, __b))
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT swappable = _LIBCUDACXX_FRAGMENT(__swappable_, _Tp);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __swappable_with_,
+  requires(_Tp&& __t, _Up&& __u)(
+    requires(common_reference_with<_Tp, _Up>),
+    (_CUDA_VRANGES::swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Tp>(__t))),
+    (_CUDA_VRANGES::swap(_CUDA_VSTD::forward<_Up>(__u), _CUDA_VSTD::forward<_Up>(__u))),
+    (_CUDA_VRANGES::swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u))),
+    (_CUDA_VRANGES::swap(_CUDA_VSTD::forward<_Up>(__u), _CUDA_VSTD::forward<_Tp>(__t)))
+  ));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT swappable_with = _LIBCUDACXX_FRAGMENT(__swappable_with_, _Tp, _Up);
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+_LIBCUDACXX_NV_DIAG_DEFAULT(461) // nonstandard cast to array type ignored
+#endif // _LIBCUDACXX_COMPILER_MSVC
+
+
+#endif // _LIBCUDACXX___CONCEPTS_SWAPPABLE_H

cuda_toolkit/include/__concepts/totally_ordered.h

@@ -0,0 +1,113 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___CONCEPTS_TOTALLY_ORDERED_H
+#define _LIBCUDACXX___CONCEPTS_TOTALLY_ORDERED_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/boolean_testable.h"
+#include "../__concepts/equality_comparable.h"
+#include "../__type_traits/common_reference.h"
+#include "../__type_traits/make_const_lvalue_ref.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.totallyordered]
+
+template<class _Tp, class _Up>
+concept __partially_ordered_with =
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+    { __t <  __u } -> __boolean_testable;
+    { __t >  __u } -> __boolean_testable;
+    { __t <= __u } -> __boolean_testable;
+    { __t >= __u } -> __boolean_testable;
+    { __u <  __t } -> __boolean_testable;
+    { __u >  __t } -> __boolean_testable;
+    { __u <= __t } -> __boolean_testable;
+    { __u >= __t } -> __boolean_testable;
+  };
+
+template<class _Tp>
+concept totally_ordered = equality_comparable<_Tp> && __partially_ordered_with<_Tp, _Tp>;
+
+template<class _Tp, class _Up>
+concept totally_ordered_with =
+  totally_ordered<_Tp> && totally_ordered<_Up> &&
+  equality_comparable_with<_Tp, _Up> &&
+  totally_ordered<
+    common_reference_t<
+      __make_const_lvalue_ref<_Tp>,
+      __make_const_lvalue_ref<_Up>>> &&
+  __partially_ordered_with<_Tp, _Up>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __partially_ordered_with_,
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u)(
+    requires(__boolean_testable<decltype(__t <  __u)>),
+    requires(__boolean_testable<decltype(__t >  __u)>),
+    requires(__boolean_testable<decltype(__t <= __u)>),
+    requires(__boolean_testable<decltype(__t >= __u)>),
+    requires(__boolean_testable<decltype(__u <  __t)>),
+    requires(__boolean_testable<decltype(__u >  __t)>),
+    requires(__boolean_testable<decltype(__u <= __t)>),
+    requires(__boolean_testable<decltype(__u >= __t)>)
+  ));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT __partially_ordered_with = _LIBCUDACXX_FRAGMENT(__partially_ordered_with_, _Tp, _Up);
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __totally_ordered_,
+  requires()(
+    requires(equality_comparable<_Tp>),
+    requires(__partially_ordered_with<_Tp, _Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT totally_ordered = _LIBCUDACXX_FRAGMENT(__totally_ordered_, _Tp);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __totally_ordered_with_,
+  requires()(
+    requires(totally_ordered<_Tp>),
+    requires(totally_ordered<_Up>),
+    requires(equality_comparable_with<_Tp, _Up>),
+    requires(totally_ordered<
+    common_reference_t<
+      __make_const_lvalue_ref<_Tp>,
+      __make_const_lvalue_ref<_Up>>>),
+    requires(__partially_ordered_with<_Tp, _Up>)));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT totally_ordered_with = _LIBCUDACXX_FRAGMENT(__totally_ordered_with_, _Tp, _Up);;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_TOTALLY_ORDERED_H

cuda_toolkit/include/__cuda/atomic.h

@@ -0,0 +1,264 @@
+// -*- 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___CUDA_ATOMIC_H
+#define _LIBCUDACXX___CUDA_ATOMIC_H
+
+#ifndef __cuda_std__
+#error "<__cuda/atomic> should only be included in from <cuda/std/atomic>"
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+using std::__detail::thread_scope;
+using std::__detail::thread_scope_system;
+using std::__detail::thread_scope_device;
+using std::__detail::thread_scope_block;
+using std::__detail::thread_scope_thread;
+
+namespace __detail {
+using std::__detail::__thread_scope_block_tag;
+using std::__detail::__thread_scope_device_tag;
+using std::__detail::__thread_scope_system_tag;
+}
+
+using memory_order = std::memory_order;
+
+constexpr memory_order memory_order_relaxed = std::memory_order_relaxed;
+constexpr memory_order memory_order_consume = std::memory_order_consume;
+constexpr memory_order memory_order_acquire = std::memory_order_acquire;
+constexpr memory_order memory_order_release = std::memory_order_release;
+constexpr memory_order memory_order_acq_rel = std::memory_order_acq_rel;
+constexpr memory_order memory_order_seq_cst = std::memory_order_seq_cst;
+
+// atomic<T>
+
+template <class _Tp, thread_scope _Sco = thread_scope::thread_scope_system>
+struct atomic
+    : public std::__atomic_base<_Tp, _Sco>
+{
+    typedef std::__atomic_base<_Tp, _Sco> __base;
+
+    constexpr atomic() noexcept = default;
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr atomic(_Tp __d) noexcept : __base(__d) {}
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp operator=(_Tp __d) volatile noexcept
+        {__base::store(__d); return __d;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp operator=(_Tp __d) noexcept
+        {__base::store(__d); return __d;}
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp fetch_max(const _Tp & __op, memory_order __m = memory_order_seq_cst) volatile noexcept
+    {
+        return std::__detail::__cxx_atomic_fetch_max(&this->__a_, __op, __m);
+    }
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp fetch_min(const _Tp & __op, memory_order __m = memory_order_seq_cst) volatile noexcept
+    {
+        return std::__detail::__cxx_atomic_fetch_min(&this->__a_, __op, __m);
+    }
+};
+
+// atomic<T*>
+
+template <class _Tp, thread_scope _Sco>
+struct atomic<_Tp*, _Sco>
+    : public std::__atomic_base<_Tp*, _Sco>
+{
+    typedef std::__atomic_base<_Tp*, _Sco> __base;
+
+    constexpr atomic() noexcept = default;
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr atomic(_Tp* __d) noexcept : __base(__d) {}
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator=(_Tp* __d) volatile noexcept
+        {__base::store(__d); return __d;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator=(_Tp* __d) noexcept
+        {__base::store(__d); return __d;}
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst)
+                                                                        volatile noexcept
+        {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) noexcept
+        {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst)
+                                                                        volatile noexcept
+        {return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) noexcept
+        {return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator++(int) volatile noexcept            {return fetch_add(1);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator++(int) noexcept                     {return fetch_add(1);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator--(int) volatile noexcept            {return fetch_sub(1);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator--(int) noexcept                     {return fetch_sub(1);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator++() volatile noexcept               {return fetch_add(1) + 1;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator++() noexcept                        {return fetch_add(1) + 1;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator--() volatile noexcept               {return fetch_sub(1) - 1;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator--() noexcept                        {return fetch_sub(1) - 1;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator+=(ptrdiff_t __op) volatile noexcept {return fetch_add(__op) + __op;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator+=(ptrdiff_t __op) noexcept          {return fetch_add(__op) + __op;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator-=(ptrdiff_t __op) volatile noexcept {return fetch_sub(__op) - __op;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator-=(ptrdiff_t __op) noexcept          {return fetch_sub(__op) - __op;}
+};
+
+// atomic_ref<T>
+
+template <class _Tp, thread_scope _Sco = thread_scope::thread_scope_system>
+struct atomic_ref
+    : public std::__atomic_base_ref<_Tp, _Sco>
+{
+    typedef std::__atomic_base_ref<_Tp, _Sco> __base;
+
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr atomic_ref(_Tp& __d) noexcept : __base(__d) {}
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp operator=(_Tp __d) const volatile noexcept
+        {__base::store(__d); return __d;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp operator=(_Tp __d) const noexcept
+        {__base::store(__d); return __d;}
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp fetch_max(const _Tp & __op, memory_order __m = memory_order_seq_cst) const volatile noexcept
+    {
+        return std::__detail::__cxx_atomic_fetch_max(&this->__a_, __op, __m);
+    }
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp fetch_min(const _Tp & __op, memory_order __m = memory_order_seq_cst) const volatile noexcept
+    {
+        return std::__detail::__cxx_atomic_fetch_min(&this->__a_, __op, __m);
+    }
+};
+
+// atomic_ref<T*>
+
+template <class _Tp, thread_scope _Sco>
+struct atomic_ref<_Tp*, _Sco>
+    : public std::__atomic_base_ref<_Tp*, _Sco>
+{
+    typedef std::__atomic_base_ref<_Tp*, _Sco> __base;
+
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr atomic_ref(_Tp*& __d) noexcept : __base(__d) {}
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator=(_Tp* __d) const volatile noexcept
+        {__base::store(__d); return __d;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator=(_Tp* __d) const noexcept
+        {__base::store(__d); return __d;}
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* fetch_add(ptrdiff_t __op,
+                   memory_order __m = memory_order_seq_cst) const volatile noexcept
+        {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* fetch_add(ptrdiff_t __op,
+                   memory_order __m = memory_order_seq_cst) const noexcept
+        {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* fetch_sub(ptrdiff_t __op,
+                   memory_order __m = memory_order_seq_cst) const volatile noexcept
+        {return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* fetch_sub(ptrdiff_t __op,
+                   memory_order __m = memory_order_seq_cst) const noexcept
+        {return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
+
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator++(int) const volatile noexcept            {return fetch_add(1);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator++(int) const noexcept                     {return fetch_add(1);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator--(int) const volatile noexcept            {return fetch_sub(1);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator--(int) const noexcept                     {return fetch_sub(1);}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator++() const volatile noexcept               {return fetch_add(1) + 1;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator++() const noexcept                        {return fetch_add(1) + 1;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator--() const volatile noexcept               {return fetch_sub(1) - 1;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator--() const noexcept                        {return fetch_sub(1) - 1;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator+=(ptrdiff_t __op) const volatile noexcept {return fetch_add(__op) + __op;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator+=(ptrdiff_t __op) const noexcept          {return fetch_add(__op) + __op;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator-=(ptrdiff_t __op) const volatile noexcept {return fetch_sub(__op) - __op;}
+    _LIBCUDACXX_HOST_DEVICE
+    _Tp* operator-=(ptrdiff_t __op) const noexcept          {return fetch_sub(__op) - __op;}
+};
+
+inline _LIBCUDACXX_HOST_DEVICE void atomic_thread_fence(memory_order __m, thread_scope _Scope = thread_scope::thread_scope_system) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            switch(_Scope) {
+            case thread_scope::thread_scope_system:
+                std::__detail::__atomic_thread_fence_cuda((int)__m, __detail::__thread_scope_system_tag());
+                break;
+            case thread_scope::thread_scope_device:
+                std::__detail::__atomic_thread_fence_cuda((int)__m, __detail::__thread_scope_device_tag());
+                break;
+            case thread_scope::thread_scope_block:
+                std::__detail::__atomic_thread_fence_cuda((int)__m, __detail::__thread_scope_block_tag());
+                break;
+            // Atomics scoped to themselves do not require fencing
+            case thread_scope::thread_scope_thread:
+                break;
+            }
+        ),
+        NV_IS_HOST, (
+            (void) _Scope;
+            std::atomic_thread_fence(__m);
+        )
+    )
+}
+
+inline _LIBCUDACXX_HOST_DEVICE void atomic_signal_fence(memory_order __m) {
+    std::atomic_signal_fence(__m);
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _LIBCUDACXX___CUDA_ATOMIC_H

cuda_toolkit/include/__cuda/atomic_prelude.h

@@ -0,0 +1,56 @@
+// -*- 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___CUDA_ATOMIC_PRELUDE_H
+#define _LIBCUDACXX___CUDA_ATOMIC_PRELUDE_H
+
+#ifndef __cuda_std__
+#error "<__cuda/atomic_prelude> should only be included in from <cuda/std/atomic>"
+#endif // __cuda_std__
+
+#ifndef _LIBCUDACXX_COMPILER_NVRTC
+    #include "../cassert" // TRANSITION: Fix transitive includes
+    #include <atomic>
+    static_assert(ATOMIC_BOOL_LOCK_FREE == 2, "");
+    static_assert(ATOMIC_CHAR_LOCK_FREE == 2, "");
+    static_assert(ATOMIC_CHAR16_T_LOCK_FREE == 2, "");
+    static_assert(ATOMIC_CHAR32_T_LOCK_FREE == 2, "");
+    static_assert(ATOMIC_WCHAR_T_LOCK_FREE == 2, "");
+    static_assert(ATOMIC_SHORT_LOCK_FREE == 2, "");
+    static_assert(ATOMIC_INT_LOCK_FREE == 2, "");
+    static_assert(ATOMIC_LONG_LOCK_FREE == 2, "");
+    static_assert(ATOMIC_LLONG_LOCK_FREE == 2, "");
+    static_assert(ATOMIC_POINTER_LOCK_FREE == 2, "");
+    #undef ATOMIC_BOOL_LOCK_FREE
+    #undef ATOMIC_BOOL_LOCK_FREE
+    #undef ATOMIC_CHAR_LOCK_FREE
+    #undef ATOMIC_CHAR16_T_LOCK_FREE
+    #undef ATOMIC_CHAR32_T_LOCK_FREE
+    #undef ATOMIC_WCHAR_T_LOCK_FREE
+    #undef ATOMIC_SHORT_LOCK_FREE
+    #undef ATOMIC_INT_LOCK_FREE
+    #undef ATOMIC_LONG_LOCK_FREE
+    #undef ATOMIC_LLONG_LOCK_FREE
+    #undef ATOMIC_POINTER_LOCK_FREE
+    #undef ATOMIC_FLAG_INIT
+    #undef ATOMIC_VAR_INIT
+#endif // _LIBCUDACXX_COMPILER_NVRTC
+
+// pre-define lock free query for heterogeneous compatibility
+#ifndef _LIBCUDACXX_ATOMIC_IS_LOCK_FREE
+#define _LIBCUDACXX_ATOMIC_IS_LOCK_FREE(__x) (__x <= 8)
+#endif
+
+#ifndef _LIBCUDACXX_COMPILER_NVRTC
+#include <thread>
+#include <errno.h>
+#endif // _LIBCUDACXX_COMPILER_NVRTC
+
+#endif // _LIBCUDACXX___CUDA_ATOMIC_PRELUDE_H

cuda_toolkit/include/__cuda/barrier.h

@@ -0,0 +1,1257 @@
+// -*- 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___CUDA_BARRIER_H
+#define _LIBCUDACXX___CUDA_BARRIER_H
+
+#ifndef __cuda_std__
+#error "<__cuda/barrier> should only be included in from <cuda/std/barrier>"
+#endif // __cuda_std__
+
+#if defined(__CUDA_MINIMUM_ARCH__) && __CUDA_MINIMUM_ARCH__ < 700
+#  error "CUDA synchronization primitives are only supported for sm_70 and up."
+#endif
+
+#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 "../cstdlib"                // _LIBCUDACXX_UNREACHABLE
+#include "../__type_traits/void_t.h" // _CUDA_VSTD::__void_t
+
+#if defined(_CCCL_CUDA_COMPILER)
+#include "../__cuda/ptx.h"           // cuda::ptx::*
+#endif // _CCCL_CUDA_COMPILER
+
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_OFFSET_IS_ZERO(type, member) !(&(((type *)0)->member))
+#else
+#define _LIBCUDACXX_OFFSET_IS_ZERO(type, member) !offsetof(type, member)
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+// foward declaration required for memcpy_async, pipeline "sync" defined here
+template<thread_scope _Scope>
+class pipeline;
+
+template<_CUDA_VSTD::size_t _Alignment>
+struct aligned_size_t {
+    static constexpr _CUDA_VSTD::size_t align = _Alignment;
+    _CUDA_VSTD::size_t value;
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit aligned_size_t(size_t __s) : value(__s) { }
+    _LIBCUDACXX_INLINE_VISIBILITY
+    operator size_t() const { return value; }
+};
+
+// Type only used for logging purpose
+enum async_contract_fulfillment
+{
+    none,
+    async
+};
+
+// __completion_mechanism allows memcpy_async to report back what completion
+// mechanism it used. This is necessary to determine in which way to synchronize
+// the memcpy_async with a sync object (barrier or pipeline).
+//
+// In addition, we use this enum to create bit flags so that calling functions
+// can specify which completion mechanisms can be used (__sync is always
+// allowed).
+enum class __completion_mechanism {
+    __sync                 = 0,
+    __mbarrier_complete_tx = 1 << 0, // Use powers of two here to support the
+    __async_group          = 1 << 1, // bit flag use case
+    __async_bulk_group     = 1 << 2,
+};
+
+template<thread_scope _Sco, class _CompletionF = _CUDA_VSTD::__empty_completion>
+class barrier : public _CUDA_VSTD::__barrier_base<_CompletionF, _Sco> {
+public:
+    barrier() = default;
+
+    barrier(const barrier &) = delete;
+    barrier & operator=(const barrier &) = delete;
+
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    barrier(_CUDA_VSTD::ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
+        : _CUDA_VSTD::__barrier_base<_CompletionF, _Sco>(__expected, __completion) {
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    friend void init(barrier * __b, _CUDA_VSTD::ptrdiff_t __expected) {
+        _LIBCUDACXX_DEBUG_ASSERT(__expected >= 0, "Cannot initialize barrier with negative arrival count");
+        new (__b) barrier(__expected);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    friend void init(barrier * __b, _CUDA_VSTD::ptrdiff_t __expected, _CompletionF __completion) {
+        _LIBCUDACXX_DEBUG_ASSERT(__expected >= 0, "Cannot initialize barrier with negative arrival count");
+        new (__b) barrier(__expected, __completion);
+    }
+};
+
+struct __block_scope_barrier_base {};
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA_DEVICE
+
+_LIBCUDACXX_DEVICE
+inline _CUDA_VSTD::uint64_t * barrier_native_handle(barrier<thread_scope_block> & b);
+
+_LIBCUDACXX_END_NAMESPACE_CUDA_DEVICE
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+template<>
+class barrier<thread_scope_block, _CUDA_VSTD::__empty_completion> : public __block_scope_barrier_base {
+    using __barrier_base = _CUDA_VSTD::__barrier_base<_CUDA_VSTD::__empty_completion, (int)thread_scope_block>;
+    __barrier_base __barrier;
+
+    _LIBCUDACXX_DEVICE
+    friend inline _CUDA_VSTD::uint64_t * device::_LIBCUDACXX_ABI_NAMESPACE::barrier_native_handle(barrier<thread_scope_block> & b);
+
+template<typename _Barrier>
+friend class _CUDA_VSTD::__barrier_poll_tester_phase;
+template<typename _Barrier>
+friend class _CUDA_VSTD::__barrier_poll_tester_parity;
+
+public:
+    using arrival_token = typename __barrier_base::arrival_token;
+    barrier() = default;
+
+    barrier(const barrier &) = delete;
+    barrier & operator=(const barrier &) = delete;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    barrier(_CUDA_VSTD::ptrdiff_t __expected, _CUDA_VSTD::__empty_completion __completion = _CUDA_VSTD::__empty_completion()) {
+        static_assert(_LIBCUDACXX_OFFSET_IS_ZERO(barrier<thread_scope_block>, __barrier), "fatal error: bad barrier layout");
+        init(this, __expected, __completion);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    ~barrier() {
+        NV_DISPATCH_TARGET(
+            NV_PROVIDES_SM_90, (
+                if (__isShared(&__barrier)) {
+                    asm volatile ("mbarrier.inval.shared.b64 [%0];"
+                        :: "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__barrier)))
+                        : "memory");
+                }
+                else if (__isClusterShared(&__barrier)) {
+                    __trap();
+                }
+            ), NV_PROVIDES_SM_80, (
+                if (__isShared(&__barrier)) {
+                    asm volatile ("mbarrier.inval.shared.b64 [%0];"
+                        :: "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__barrier)))
+                        : "memory");
+                }
+            )
+        )
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    friend void init(barrier * __b, _CUDA_VSTD::ptrdiff_t __expected, _CUDA_VSTD::__empty_completion __completion = _CUDA_VSTD::__empty_completion()) {
+        NV_DISPATCH_TARGET(
+            NV_PROVIDES_SM_90, (
+                if (__isShared(&__b->__barrier)) {
+                    asm volatile ("mbarrier.init.shared.b64 [%0], %1;"
+                        :: "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__b->__barrier))),
+                            "r"(static_cast<_CUDA_VSTD::uint32_t>(__expected))
+                        : "memory");
+                }
+                else if (__isClusterShared(&__b->__barrier))
+                {
+                    __trap();
+                }
+                else
+                {
+                    new (&__b->__barrier) __barrier_base(__expected);
+                }
+            ),
+            NV_PROVIDES_SM_80, (
+                if (__isShared(&__b->__barrier)) {
+                    asm volatile ("mbarrier.init.shared.b64 [%0], %1;"
+                        :: "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__b->__barrier))),
+                            "r"(static_cast<_CUDA_VSTD::uint32_t>(__expected))
+                        : "memory");
+                }
+                else
+                {
+                    new (&__b->__barrier) __barrier_base(__expected);
+                }
+            ), NV_ANY_TARGET, (
+                new (&__b->__barrier) __barrier_base(__expected);
+            )
+        )
+    }
+
+    _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+    arrival_token arrive(_CUDA_VSTD::ptrdiff_t __update = 1) {
+        _LIBCUDACXX_DEBUG_ASSERT(__update >= 0, "Arrival count update must be non-negative.");
+        arrival_token __token = {};
+        NV_DISPATCH_TARGET(
+            NV_PROVIDES_SM_90, (
+                if (!__isClusterShared(&__barrier)) {
+                    return __barrier.arrive(__update);
+                }
+                else if (!__isShared(&__barrier)) {
+                    __trap();
+                }
+                // Cannot use cuda::device::barrier_native_handle here, as it is
+                // only defined for block-scope barriers. This barrier may be a
+                // non-block scoped barrier.
+                auto __bh = reinterpret_cast<_CUDA_VSTD::uint64_t*>(&__barrier);
+                __token = _CUDA_VPTX::mbarrier_arrive(__bh, __update);
+            ), NV_PROVIDES_SM_80, (
+                if (!__isShared(&__barrier)) {
+                    return __barrier.arrive(__update);
+                }
+                auto __bh = reinterpret_cast<_CUDA_VSTD::uint64_t*>(&__barrier);
+                // Need 2 instructions, can't finish barrier with arrive > 1
+                if (__update > 1) {
+                    _CUDA_VPTX::mbarrier_arrive_no_complete(__bh, __update - 1);
+                }
+                __token = _CUDA_VPTX::mbarrier_arrive( __bh);
+            ), NV_IS_DEVICE, (
+                if (!__isShared(&__barrier)) {
+                    return __barrier.arrive(__update);
+                }
+
+                unsigned int __mask = __activemask();
+                unsigned int __activeA = __match_any_sync(__mask, __update);
+                unsigned int __activeB = __match_any_sync(__mask, reinterpret_cast<_CUDA_VSTD::uintptr_t>(&__barrier));
+                unsigned int __active = __activeA & __activeB;
+                int __inc = __popc(__active) * __update;
+
+                unsigned __laneid;
+                asm ("mov.u32 %0, %%laneid;" : "=r"(__laneid));
+                int __leader = __ffs(__active) - 1;
+                // All threads in mask synchronize here, establishing cummulativity to the __leader:
+                __syncwarp(__mask);
+                if(__leader == static_cast<int>(__laneid))
+                {
+                    __token = __barrier.arrive(__inc);
+                }
+                __token = __shfl_sync(__active, __token, __leader);
+            ), NV_IS_HOST, (
+                __token = __barrier.arrive(__update);
+            )
+        )
+        return __token;
+    }
+
+private:
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    inline bool __test_wait_sm_80(arrival_token __token) const {
+        int32_t __ready = 0;
+        NV_DISPATCH_TARGET(
+            NV_PROVIDES_SM_80, (
+                asm volatile ("{\n\t"
+                            ".reg .pred p;\n\t"
+                            "mbarrier.test_wait.shared.b64 p, [%1], %2;\n\t"
+                            "selp.b32 %0, 1, 0, p;\n\t"
+                            "}"
+                        : "=r"(__ready)
+                        : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__barrier))),
+                          "l"(__token)
+                        : "memory");
+            )
+        )
+        return __ready;
+    }
+
+    // Document de drop > uint32_t for __nanosec on public for APIs
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool __try_wait(arrival_token __token) const {
+        NV_DISPATCH_TARGET(
+            NV_PROVIDES_SM_90, (
+                int32_t __ready = 0;
+                if (!__isClusterShared(&__barrier)) {
+                    return _CUDA_VSTD::__call_try_wait(__barrier, _CUDA_VSTD::move(__token));
+                }
+                else if (!__isShared(&__barrier)) {
+                    __trap();
+                }
+                asm volatile ("{\n\t"
+                        ".reg .pred p;\n\t"
+                        "mbarrier.try_wait.shared.b64 p, [%1], %2;\n\t"
+                        "selp.b32 %0, 1, 0, p;\n\t"
+                        "}"
+                    : "=r"(__ready)
+                    : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__barrier))),
+                    "l"(__token)
+                    : "memory");
+                return __ready;
+            ), NV_PROVIDES_SM_80, (
+                if (!__isShared(&__barrier)) {
+                    return _CUDA_VSTD::__call_try_wait(__barrier, _CUDA_VSTD::move(__token));
+                }
+                return __test_wait_sm_80(__token);
+            ), NV_ANY_TARGET, (
+                    return _CUDA_VSTD::__call_try_wait(__barrier, _CUDA_VSTD::move(__token));
+            )
+        )
+    }
+
+    // Document de drop > uint32_t for __nanosec on public for APIs
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool __try_wait(arrival_token __token, _CUDA_VSTD::chrono::nanoseconds __nanosec) const {
+        if (__nanosec.count() < 1) {
+            return __try_wait(_CUDA_VSTD::move(__token));
+        }
+
+        NV_DISPATCH_TARGET(
+            NV_PROVIDES_SM_90, (
+                int32_t __ready = 0;
+                if (!__isClusterShared(&__barrier)) {
+                    return _CUDA_VSTD::__libcpp_thread_poll_with_backoff(
+                        _CUDA_VSTD::__barrier_poll_tester_phase<barrier>(this, _CUDA_VSTD::move(__token)),
+                        __nanosec);
+                }
+                else if (!__isShared(&__barrier)) {
+                    __trap();
+                }
+
+                _CUDA_VSTD::chrono::high_resolution_clock::time_point const __start = _CUDA_VSTD::chrono::high_resolution_clock::now();
+                _CUDA_VSTD::chrono::nanoseconds __elapsed;
+                do {
+                    const _CUDA_VSTD::uint32_t __wait_nsec = static_cast<_CUDA_VSTD::uint32_t>((__nanosec - __elapsed).count());
+                    asm volatile ("{\n\t"
+                            ".reg .pred p;\n\t"
+                            "mbarrier.try_wait.shared.b64 p, [%1], %2, %3;\n\t"
+                            "selp.b32 %0, 1, 0, p;\n\t"
+                            "}"
+                            : "=r"(__ready)
+                            : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__barrier))),
+                            "l"(__token)
+                            "r"(__wait_nsec)
+                            : "memory");
+                    __elapsed = _CUDA_VSTD::chrono::high_resolution_clock::now() - __start;
+                } while (!__ready && (__nanosec > __elapsed));
+                return __ready;
+            ), NV_PROVIDES_SM_80, (
+                bool __ready = 0;
+                if (!__isShared(&__barrier)) {
+                    return _CUDA_VSTD::__libcpp_thread_poll_with_backoff(
+                        _CUDA_VSTD::__barrier_poll_tester_phase<barrier>(this, _CUDA_VSTD::move(__token)),
+                        __nanosec);
+                }
+
+                _CUDA_VSTD::chrono::high_resolution_clock::time_point const __start = _CUDA_VSTD::chrono::high_resolution_clock::now();
+                do {
+                    __ready = __test_wait_sm_80(__token);
+                } while (!__ready &&
+                        __nanosec > (_CUDA_VSTD::chrono::high_resolution_clock::now() - __start));
+                return __ready;
+            ), NV_ANY_TARGET, (
+                return _CUDA_VSTD::__libcpp_thread_poll_with_backoff(
+                        _CUDA_VSTD::__barrier_poll_tester_phase<barrier>(this, _CUDA_VSTD::move(__token)),
+                        _CUDA_VSTD::chrono::nanoseconds(__nanosec));
+            )
+        )
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    inline bool __test_wait_parity_sm_80(bool __phase_parity) const {
+        uint16_t __ready = 0;
+        NV_DISPATCH_TARGET(
+            NV_PROVIDES_SM_80, (
+                asm volatile ("{"
+                    ".reg .pred %%p;"
+                    "mbarrier.test_wait.parity.shared.b64 %%p, [%1], %2;"
+                    "selp.u16 %0, 1, 0, %%p;"
+                    "}"
+                    : "=h"(__ready)
+                    : "r"(static_cast<uint32_t>(__cvta_generic_to_shared(&__barrier))),
+                        "r"(static_cast<uint32_t>(__phase_parity))
+                    : "memory");
+            )
+        )
+        return __ready;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool __try_wait_parity(bool __phase_parity)  const {
+        NV_DISPATCH_TARGET(
+            NV_PROVIDES_SM_90, (
+                if (!__isClusterShared(&__barrier)) {
+                    return _CUDA_VSTD::__call_try_wait_parity(__barrier, __phase_parity);
+                }
+                else if (!__isShared(&__barrier)) {
+                    __trap();
+                }
+                int32_t __ready = 0;
+
+                asm volatile ("{\n\t"
+                        ".reg .pred p;\n\t"
+                        "mbarrier.try_wait.parity.shared.b64 p, [%1], %2;\n\t"
+                        "selp.b32 %0, 1, 0, p;\n\t"
+                        "}"
+                        : "=r"(__ready)
+                        : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__barrier))),
+                          "r"(static_cast<_CUDA_VSTD::uint32_t>(__phase_parity))
+                        :);
+
+                return __ready;
+            ), NV_PROVIDES_SM_80, (
+                if (!__isShared(&__barrier)) {
+                    return _CUDA_VSTD::__call_try_wait_parity(__barrier, __phase_parity);
+                }
+
+                return __test_wait_parity_sm_80(__phase_parity);
+            ), NV_ANY_TARGET, (
+                return _CUDA_VSTD::__call_try_wait_parity(__barrier, __phase_parity);
+            )
+        )
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool __try_wait_parity(bool __phase_parity, _CUDA_VSTD::chrono::nanoseconds __nanosec) const {
+        if (__nanosec.count() < 1) {
+            return __try_wait_parity(__phase_parity);
+        }
+
+        NV_DISPATCH_TARGET(
+            NV_PROVIDES_SM_90, (
+                int32_t __ready = 0;
+                if (!__isClusterShared(&__barrier)) {
+                    return _CUDA_VSTD::__libcpp_thread_poll_with_backoff(
+                            _CUDA_VSTD::__barrier_poll_tester_parity<barrier>(this, __phase_parity),
+                            __nanosec);
+                }
+                else if (!__isShared(&__barrier)) {
+                    __trap();
+                }
+
+                _CUDA_VSTD::chrono::high_resolution_clock::time_point const __start = _CUDA_VSTD::chrono::high_resolution_clock::now();
+                _CUDA_VSTD::chrono::nanoseconds __elapsed;
+                do {
+                    const _CUDA_VSTD::uint32_t __wait_nsec = static_cast<_CUDA_VSTD::uint32_t>((__nanosec - __elapsed).count());
+                    asm volatile ("{\n\t"
+                            ".reg .pred p;\n\t"
+                            "mbarrier.try_wait.parity.shared.b64 p, [%1], %2, %3;\n\t"
+                            "selp.b32 %0, 1, 0, p;\n\t"
+                            "}"
+                            : "=r"(__ready)
+                            : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__barrier))),
+                              "r"(static_cast<_CUDA_VSTD::uint32_t>(__phase_parity)),
+                              "r"(__wait_nsec)
+                            : "memory");
+                    __elapsed = _CUDA_VSTD::chrono::high_resolution_clock::now() - __start;
+                } while (!__ready && (__nanosec > __elapsed));
+
+                return __ready;
+            ), NV_PROVIDES_SM_80, (
+                bool __ready = 0;
+                if (!__isShared(&__barrier)) {
+                    return _CUDA_VSTD::__libcpp_thread_poll_with_backoff(
+                        _CUDA_VSTD::__barrier_poll_tester_parity<barrier>(this, __phase_parity),
+                        __nanosec);
+                }
+
+                _CUDA_VSTD::chrono::high_resolution_clock::time_point const __start = _CUDA_VSTD::chrono::high_resolution_clock::now();
+                do {
+                    __ready = __test_wait_parity_sm_80(__phase_parity);
+                } while (!__ready &&
+                          __nanosec > (_CUDA_VSTD::chrono::high_resolution_clock::now() - __start));
+
+                return __ready;
+            ), NV_ANY_TARGET, (
+                return _CUDA_VSTD::__libcpp_thread_poll_with_backoff(
+                        _CUDA_VSTD::__barrier_poll_tester_parity<barrier>(this, __phase_parity),
+                        __nanosec);
+            )
+        )
+    }
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void wait(arrival_token && __phase) const {
+        _CUDA_VSTD::__libcpp_thread_poll_with_backoff(_CUDA_VSTD::__barrier_poll_tester_phase<barrier>(this, _CUDA_VSTD::move(__phase)));
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void wait_parity(bool __phase_parity) const {
+        _CUDA_VSTD::__libcpp_thread_poll_with_backoff(_CUDA_VSTD::__barrier_poll_tester_parity<barrier>(this, __phase_parity));
+    }
+
+    inline _LIBCUDACXX_INLINE_VISIBILITY
+    void arrive_and_wait() {
+        wait(arrive());
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void arrive_and_drop() {
+        NV_DISPATCH_TARGET(
+            NV_PROVIDES_SM_90, (
+                if (!__isClusterShared(&__barrier)) {
+                    return __barrier.arrive_and_drop();
+                }
+                else if (!__isShared(&__barrier)) {
+                    __trap();
+                }
+
+                asm volatile ("mbarrier.arrive_drop.shared.b64 _, [%0];"
+                    :: "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__barrier)))
+                    : "memory");
+            ), NV_PROVIDES_SM_80, (
+                // Fallback to slowpath on device
+                if (!__isShared(&__barrier)) {
+                    __barrier.arrive_and_drop();
+                    return;
+                }
+
+                asm volatile ("mbarrier.arrive_drop.shared.b64 _, [%0];"
+                    :: "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(&__barrier)))
+                    : "memory");
+            ), NV_ANY_TARGET, (
+                // Fallback to slowpath on device
+                __barrier.arrive_and_drop();
+            )
+        )
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static constexpr ptrdiff_t max() noexcept {
+        return (1 << 20) - 1;
+    }
+
+    template<class _Rep, class _Period>
+    _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+    bool try_wait_for(arrival_token && __token, const _CUDA_VSTD::chrono::duration<_Rep, _Period>& __dur) {
+        auto __nanosec = _CUDA_VSTD::chrono::duration_cast<_CUDA_VSTD::chrono::nanoseconds>(__dur);
+
+        return __try_wait(_CUDA_VSTD::move(__token), __nanosec);
+    }
+
+    template<class _Clock, class _Duration>
+    _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+    bool try_wait_until(arrival_token && __token, const _CUDA_VSTD::chrono::time_point<_Clock, _Duration>& __time) {
+        return try_wait_for(_CUDA_VSTD::move(__token), (__time - _Clock::now()));
+    }
+
+    template<class _Rep, class _Period>
+    _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+    bool try_wait_parity_for(bool __phase_parity, const _CUDA_VSTD::chrono::duration<_Rep, _Period>& __dur) {
+        auto __nanosec = _CUDA_VSTD::chrono::duration_cast<_CUDA_VSTD::chrono::nanoseconds>(__dur);
+
+        return __try_wait_parity(__phase_parity, __nanosec);
+    }
+
+    template<class _Clock, class _Duration>
+    _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+    bool try_wait_parity_until(bool __phase_parity, const _CUDA_VSTD::chrono::time_point<_Clock, _Duration>& __time) {
+        return try_wait_parity_for(__phase_parity, (__time - _Clock::now()));
+    }
+};
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA_DEVICE
+
+_LIBCUDACXX_DEVICE
+inline _CUDA_VSTD::uint64_t * barrier_native_handle(barrier<thread_scope_block> & b) {
+    return reinterpret_cast<_CUDA_VSTD::uint64_t *>(&b.__barrier);
+}
+
+#if defined(_CCCL_CUDA_COMPILER)
+
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE void __cuda_ptx_barrier_arrive_tx_is_not_supported_before_SM_90__();
+_LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_DEVICE inline
+barrier<thread_scope_block>::arrival_token barrier_arrive_tx(
+    barrier<thread_scope_block> & __b,
+    _CUDA_VSTD::ptrdiff_t __arrive_count_update,
+    _CUDA_VSTD::ptrdiff_t __transaction_count_update) {
+
+    _LIBCUDACXX_DEBUG_ASSERT(__isShared(barrier_native_handle(__b)), "Barrier must be located in local shared memory.");
+    _LIBCUDACXX_DEBUG_ASSERT(1 <= __arrive_count_update, "Arrival count update must be at least one.");
+    _LIBCUDACXX_DEBUG_ASSERT(__arrive_count_update <= (1 << 20) - 1, "Arrival count update cannot exceed 2^20 - 1.");
+    _LIBCUDACXX_DEBUG_ASSERT(__transaction_count_update >= 0, "Transaction count update must be non-negative.");
+    // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#contents-of-the-mbarrier-object
+    _LIBCUDACXX_DEBUG_ASSERT(__transaction_count_update <= (1 << 20) - 1, "Transaction count update cannot exceed 2^20 - 1.");
+
+    barrier<thread_scope_block>::arrival_token __token = {};
+    NV_IF_ELSE_TARGET(
+        // On architectures pre-sm90, arrive_tx is not supported.
+        NV_PROVIDES_SM_90, (
+            // We do not check for the statespace of the barrier here. This is
+            // on purpose. This allows debugging tools like memcheck/racecheck
+            // to detect that we are passing a pointer with the wrong state
+            // space to mbarrier.arrive. If we checked for the state space here,
+            // and __trap() if wrong, then those tools would not be able to help
+            // us in release builds. In debug builds, the error would be caught
+            // by the asserts at the top of this function.
+
+            auto __native_handle = barrier_native_handle(__b);
+            auto __bh = __cvta_generic_to_shared(__native_handle);
+            if (__arrive_count_update == 1) {
+                __token = _CUDA_VPTX::mbarrier_arrive_expect_tx(
+                    _CUDA_VPTX::sem_release, _CUDA_VPTX::scope_cta, _CUDA_VPTX::space_shared, __native_handle, __transaction_count_update
+                );
+            } else {
+                asm (
+                    "mbarrier.expect_tx.relaxed.cta.shared::cta.b64 [%0], %1;"
+                    :
+                    : "r"(static_cast<_CUDA_VSTD::uint32_t>(__bh)),
+                      "r"(static_cast<_CUDA_VSTD::uint32_t>(__transaction_count_update))
+                    : "memory");
+                __token = _CUDA_VPTX::mbarrier_arrive(
+                    _CUDA_VPTX::sem_release, _CUDA_VPTX::scope_cta, _CUDA_VPTX::space_shared, __native_handle, __arrive_count_update
+                );
+            }
+        ),(
+            __cuda_ptx_barrier_arrive_tx_is_not_supported_before_SM_90__();
+        )
+    );
+    return __token;
+}
+
+extern "C" _LIBCUDACXX_DEVICE void __cuda_ptx_barrier_expect_tx_is_not_supported_before_SM_90__();
+_LIBCUDACXX_DEVICE inline
+void barrier_expect_tx(
+    barrier<thread_scope_block> & __b,
+    _CUDA_VSTD::ptrdiff_t __transaction_count_update) {
+
+    _LIBCUDACXX_DEBUG_ASSERT(__isShared(barrier_native_handle(__b)), "Barrier must be located in local shared memory.");
+    _LIBCUDACXX_DEBUG_ASSERT(__transaction_count_update >= 0, "Transaction count update must be non-negative.");
+    // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#contents-of-the-mbarrier-object
+    _LIBCUDACXX_DEBUG_ASSERT(__transaction_count_update <= (1 << 20) - 1, "Transaction count update cannot exceed 2^20 - 1.");
+
+    // We do not check for the statespace of the barrier here. This is
+    // on purpose. This allows debugging tools like memcheck/racecheck
+    // to detect that we are passing a pointer with the wrong state
+    // space to mbarrier.arrive. If we checked for the state space here,
+    // and __trap() if wrong, then those tools would not be able to help
+    // us in release builds. In debug builds, the error would be caught
+    // by the asserts at the top of this function.
+    NV_IF_ELSE_TARGET(
+        // On architectures pre-sm90, arrive_tx is not supported.
+        NV_PROVIDES_SM_90, (
+    auto __bh = __cvta_generic_to_shared(barrier_native_handle(__b));
+    asm (
+        "mbarrier.expect_tx.relaxed.cta.shared::cta.b64 [%0], %1;"
+        :
+        : "r"(static_cast<_CUDA_VSTD::uint32_t>(__bh)),
+          "r"(static_cast<_CUDA_VSTD::uint32_t>(__transaction_count_update))
+        : "memory");
+    ),(
+        __cuda_ptx_barrier_expect_tx_is_not_supported_before_SM_90__();
+    ));
+}
+
+extern "C" _LIBCUDACXX_DEVICE void __cuda_ptx_memcpy_async_tx_is_not_supported_before_SM_90__();
+template <typename _Tp, _CUDA_VSTD::size_t _Alignment>
+_LIBCUDACXX_DEVICE inline async_contract_fulfillment memcpy_async_tx(
+    _Tp* __dest,
+    const _Tp* __src,
+    ::cuda::aligned_size_t<_Alignment> __size,
+    ::cuda::barrier<::cuda::thread_scope_block> & __b) {
+    // When compiling with NVCC and GCC 4.8, certain user defined types that _are_ trivially copyable are
+    // incorrectly classified as not trivially copyable. Remove this assertion to allow for their usage with
+    // memcpy_async when compiling with GCC 4.8.
+    // FIXME: remove the #if once GCC 4.8 is no longer supported.
+#if !defined(_LIBCUDACXX_COMPILER_GCC) || _GNUC_VER > 408
+    static_assert(_CUDA_VSTD::is_trivially_copyable<_Tp>::value, "memcpy_async_tx requires a trivially copyable type");
+#endif
+    static_assert(16 <= _Alignment, "mempcy_async_tx expects arguments to be at least 16 byte aligned.");
+
+    _LIBCUDACXX_DEBUG_ASSERT(__isShared(barrier_native_handle(__b)), "Barrier must be located in local shared memory.");
+    _LIBCUDACXX_DEBUG_ASSERT(__isShared(__dest), "dest must point to shared memory.");
+    _LIBCUDACXX_DEBUG_ASSERT(__isGlobal(__src), "src must point to global memory.");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    auto __bh = __cvta_generic_to_shared(barrier_native_handle(__b));
+    if (__isShared(__dest) && __isGlobal(__src)) {
+        asm volatile(
+            "cp.async.bulk.shared::cluster.global.mbarrier::complete_tx::bytes [%0], [%1], %2, [%3];\n"
+            :
+            : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(__dest))),
+              "l"(static_cast<_CUDA_VSTD::uint64_t>(__cvta_generic_to_global(__src))),
+              "r"(static_cast<_CUDA_VSTD::uint32_t>(__size)),
+              "r"(static_cast<_CUDA_VSTD::uint32_t>(__bh))
+            : "memory");
+    } else {
+        // memcpy_async_tx only supports copying from global to shared
+        // or from shared to remote cluster dsmem. To copy to remote
+        // dsmem, we need to arrive on a cluster-scoped barrier, which
+        // is not yet implemented. So we trap in this case as well.
+        _LIBCUDACXX_UNREACHABLE();
+    }
+  ),(
+    __cuda_ptx_memcpy_async_tx_is_not_supported_before_SM_90__();
+  ));
+
+    return async_contract_fulfillment::async;
+}
+#endif // __cccl_ptx_isa >= 800
+#endif // _CCCL_CUDA_COMPILER
+
+_LIBCUDACXX_END_NAMESPACE_CUDA_DEVICE
+
+#if defined(_CCCL_CUDA_COMPILER)
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+template<>
+class barrier<thread_scope_thread, _CUDA_VSTD::__empty_completion> : private barrier<thread_scope_block> {
+    using __base = barrier<thread_scope_block>;
+
+public:
+    using __base::__base;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    friend void init(barrier * __b, _CUDA_VSTD::ptrdiff_t __expected, _CUDA_VSTD::__empty_completion __completion = _CUDA_VSTD::__empty_completion()) {
+        init(static_cast<__base *>(__b), __expected, __completion);
+    }
+
+    using __base::arrive;
+    using __base::wait;
+    using __base::arrive_and_wait;
+    using __base::arrive_and_drop;
+    using __base::max;
+};
+
+template <typename ... _Ty>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr bool __unused(_Ty...) {return true;}
+
+template <typename _Ty>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr bool __unused(_Ty&) {return true;}
+
+// __is_local_smem_barrier returns true if barrier is (1) block-scoped and (2) located in shared memory.
+template<thread_scope _Sco, typename _CompF, bool _Is_mbarrier = (_Sco == thread_scope_block) && _CUDA_VSTD::is_same<_CompF, _CUDA_VSTD::__empty_completion>::value>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool __is_local_smem_barrier(barrier<_Sco, _CompF> & __barrier) {
+    NV_IF_ELSE_TARGET(
+        NV_IS_DEVICE, (
+            return _Is_mbarrier && __isShared(&__barrier);
+        ),(
+            return false;
+        )
+    );
+}
+
+// __try_get_barrier_handle returns barrier handle of block-scoped barriers and a nullptr otherwise.
+template<thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_INLINE_VISIBILITY inline
+_CUDA_VSTD::uint64_t * __try_get_barrier_handle(barrier<_Sco, _CompF> & __barrier) {
+    return nullptr;
+}
+
+template<>
+_LIBCUDACXX_INLINE_VISIBILITY inline
+_CUDA_VSTD::uint64_t * __try_get_barrier_handle<::cuda::thread_scope_block, _CUDA_VSTD::__empty_completion>(barrier<::cuda::thread_scope_block> & __barrier) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            return ::cuda::device::barrier_native_handle(__barrier);
+        ),
+        NV_ANY_TARGET, (
+            return nullptr;
+        )
+    );
+}
+
+// This struct contains functions to defer the completion of a barrier phase
+// or pipeline stage until a specific memcpy_async operation *initiated by
+// this thread* has completed.
+
+// The user is still responsible for arriving and waiting on (or otherwise
+// synchronizing with) the barrier or pipeline barrier to see the results of
+// copies from other threads participating in the synchronization object.
+struct __memcpy_completion_impl {
+
+    template<typename _Group>
+    _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY static
+    async_contract_fulfillment __defer(
+        __completion_mechanism __cm, _Group const & __group, _CUDA_VSTD::size_t __size, barrier<::cuda::thread_scope_block> & __barrier) {
+        // In principle, this is the overload for shared memory barriers. However, a
+        // block-scope barrier may also be located in global memory. Therefore, we
+        // check if the barrier is a non-smem barrier and handle that separately.
+        if (! __is_local_smem_barrier(__barrier)) {
+            return __defer_non_smem_barrier(__cm, __group, __size, __barrier);
+        }
+
+        switch (__cm) {
+            case  __completion_mechanism::__async_group:
+                // Pre-SM80, the async_group mechanism is not available.
+                NV_IF_TARGET(NV_PROVIDES_SM_80, (
+                    // Non-Blocking: unbalance barrier by 1, barrier will be
+                    // rebalanced when all thread-local cp.async instructions
+                    // have completed writing to shared memory.
+                    _CUDA_VSTD::uint64_t * __bh = __try_get_barrier_handle(__barrier);
+
+                    asm volatile ("cp.async.mbarrier.arrive.shared.b64 [%0];"
+                                  :: "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(__bh)))
+                                  : "memory");
+                ));
+                return async_contract_fulfillment::async;
+            case __completion_mechanism::__async_bulk_group:
+                // This completion mechanism should not be used with a shared
+                // memory barrier. Or at least, we do not currently envision
+                // bulk group to be used with shared memory barriers.
+                _LIBCUDACXX_UNREACHABLE();
+            case __completion_mechanism::__mbarrier_complete_tx:
+#if __cccl_ptx_isa >= 800
+                // Pre-sm90, the mbarrier_complete_tx completion mechanism is not available.
+                NV_IF_TARGET(NV_PROVIDES_SM_90, (
+                    // Only perform the expect_tx operation with the leader thread
+                    if (__group.thread_rank() == 0) {
+                        ::cuda::device::barrier_expect_tx(__barrier, __size);
+                    }
+                ));
+#endif // __cccl_ptx_isa >= 800
+                return async_contract_fulfillment::async;
+            case __completion_mechanism::__sync:
+                // sync: In this case, we do not need to do anything. The user will have
+                // to issue `bar.arrive_wait();` to see the effect of the transaction.
+                return async_contract_fulfillment::none;
+            default:
+                // Get rid of "control reaches end of non-void function":
+                _LIBCUDACXX_UNREACHABLE();
+        }
+    }
+
+    template<typename _Group, thread_scope _Sco, typename _CompF>
+    _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY static
+    async_contract_fulfillment __defer(
+        __completion_mechanism __cm, _Group const & __group, _CUDA_VSTD::size_t __size, barrier<_Sco, _CompF> & __barrier) {
+        return __defer_non_smem_barrier(__cm, __group, __size, __barrier);
+    }
+
+    template<typename _Group, thread_scope _Sco, typename _CompF>
+    _LIBCUDACXX_INLINE_VISIBILITY static
+    async_contract_fulfillment __defer_non_smem_barrier(
+        __completion_mechanism __cm, _Group const & __group, _CUDA_VSTD::size_t __size, barrier<_Sco, _CompF> & __barrier) {
+        // Overload for non-smem barriers.
+
+        switch (__cm) {
+            case __completion_mechanism::__async_group:
+                // Pre-SM80, the async_group mechanism is not available.
+                NV_IF_TARGET(NV_PROVIDES_SM_80, (
+                    // Blocking: wait for all thread-local cp.async instructions to have
+                    // completed writing to shared memory.
+                    asm volatile ("cp.async.wait_all;" ::: "memory");
+                ));
+                return async_contract_fulfillment::async;
+            case __completion_mechanism::__mbarrier_complete_tx:
+                // Non-smem barriers do not have an mbarrier_complete_tx mechanism..
+                _LIBCUDACXX_UNREACHABLE();
+            case __completion_mechanism::__async_bulk_group:
+                // This completion mechanism is currently not expected to be used with barriers.
+                _LIBCUDACXX_UNREACHABLE();
+            case  __completion_mechanism::__sync:
+                // sync: In this case, we do not need to do anything.
+                return async_contract_fulfillment::none;
+            default:
+                // Get rid of "control reaches end of non-void function":
+                _LIBCUDACXX_UNREACHABLE();
+        }
+    }
+
+    template<typename _Group, thread_scope _Sco>
+    _LIBCUDACXX_INLINE_VISIBILITY static
+    async_contract_fulfillment __defer(__completion_mechanism __cm, _Group const & __group, _CUDA_VSTD::size_t __size, pipeline<_Sco> & __pipeline) {
+        // pipeline does not sync on memcpy_async, defeat pipeline purpose otherwise
+        __unused(__pipeline);
+        __unused(__size);
+        __unused(__group);
+
+        switch (__cm) {
+            case __completion_mechanism::__async_group:          return async_contract_fulfillment::async;
+            case __completion_mechanism::__async_bulk_group:     return async_contract_fulfillment::async;
+            case __completion_mechanism::__mbarrier_complete_tx: return async_contract_fulfillment::async;
+            case __completion_mechanism::__sync:                 return async_contract_fulfillment::none;
+            default:
+                // Get rid of "control reaches end of non-void function":
+                _LIBCUDACXX_UNREACHABLE();
+        }
+    }
+};
+
+/***********************************************************************
+ * memcpy_async code:
+ *
+ * A call to cuda::memcpy_async(dest, src, size, barrier) can dispatch to any of
+ * these PTX instructions:
+ *
+ * 1. normal synchronous copy (fallback)
+ * 2. cp.async:      shared  <- global
+ * 3. cp.async.bulk: shared  <- global
+ * 4. TODO: cp.async.bulk: global  <- shared
+ * 5. TODO: cp.async.bulk: cluster <- shared
+ *
+ * Which of these options is chosen, depends on:
+ *
+ * 1. The alignment of dest, src, and size;
+ * 2. The direction of the copy
+ * 3. The current compute capability
+ * 4. The requested completion mechanism
+ *
+ * PTX has 3 asynchronous completion mechanisms:
+ *
+ * 1. Async group           - local to a thread. Used by cp.async
+ * 2. Bulk async group      - local to a thread. Used by cp.async.bulk (shared -> global)
+ * 3. mbarrier::complete_tx - shared memory barier. Used by cp.async.bulk (other directions)
+ *
+ * The code is organized as follows:
+ *
+ * 1. Asynchronous copy mechanisms that wrap the PTX instructions
+ *
+ * 2. Device memcpy_async implementation per copy direction (global to shared,
+ *    shared to global, etc). Dispatches to fastest mechanism based on requested
+ *    completion mechanism(s), pointer alignment, and architecture.
+ *
+ * 3. Host and device memcpy_async implementations. Host implementation is
+ *    basically a memcpy wrapper; device implementation dispatches based on the
+ *    direction of the copy.
+ *
+ * 4. __memcpy_async_barrier:
+ *    a) Sets the allowed completion mechanisms based on the barrier location
+ *    b) Calls the host or device memcpy_async implementation
+ *    c) If necessary, synchronizes with the barrier based on the returned
+ *    completion mechanism.
+ *
+ * 5. The public memcpy_async function overloads. Call into
+ *    __memcpy_async_barrier.
+ *
+ ***********************************************************************/
+
+/***********************************************************************
+ * Asynchronous copy mechanisms:
+ *
+ * 1. cp.async.bulk: shared  <- global
+ * 2. TODO: cp.async.bulk: cluster <- shared
+ * 3. TODO: cp.async.bulk: global  <- shared
+ * 4. cp.async:      shared  <- global
+ * 5. normal synchronous copy (fallback)
+ ***********************************************************************/
+
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE void __cuda_ptx_cp_async_bulk_shared_global_is_not_supported_before_SM_90__();
+template <typename _Group>
+inline __device__
+void __cp_async_bulk_shared_global(const _Group &__g, char * __dest, const char * __src, size_t __size, uint64_t *__bar_handle) {
+    // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-bulk
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    if (__g.thread_rank() == 0) {
+        asm volatile(
+            "cp.async.bulk.shared::cluster.global.mbarrier::complete_tx::bytes [%0], [%1], %2, [%3];\n"
+            :
+            : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(__dest))),
+              "l"(static_cast<_CUDA_VSTD::uint64_t>(__cvta_generic_to_global(__src))),
+              "r"(static_cast<_CUDA_VSTD::uint32_t>(__size)),
+              "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(__bar_handle)))
+            : "memory");
+    }
+  ),(
+    __cuda_ptx_cp_async_bulk_shared_global_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+extern "C" _LIBCUDACXX_DEVICE void __cuda_ptx_cp_async_shared_global_is_not_supported_before_SM_80__();
+template <size_t _Copy_size>
+inline __device__
+void __cp_async_shared_global(char * __dest, const char * __src) {
+    // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async
+
+    // If `if constexpr` is not available, this function gets instantiated even
+    // if is not called. Do not static_assert in that case.
+#if _LIBCUDACXX_STD_VER >= 17
+    static_assert(_Copy_size == 4 || _Copy_size == 8 || _Copy_size == 16, "cp.async.shared.global requires a copy size of 4, 8, or 16.");
+#endif // _LIBCUDACXX_STD_VER >= 17
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_80,(
+    asm volatile(
+        "cp.async.ca.shared.global [%0], [%1], %2, %2;"
+        :
+        : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(__dest))),
+          "l"(static_cast<_CUDA_VSTD::uint64_t>(__cvta_generic_to_global(__src))),
+          "n"(_Copy_size)
+        : "memory");
+  ),(
+    __cuda_ptx_cp_async_shared_global_is_not_supported_before_SM_80__();
+  ));
+}
+
+template <>
+inline __device__
+void __cp_async_shared_global<16>(char * __dest, const char * __src) {
+    // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async
+    // When copying 16 bytes, it is possible to skip L1 cache (.cg).
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_80,(
+    asm volatile(
+        "cp.async.cg.shared.global [%0], [%1], %2, %2;"
+        :
+        : "r"(static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(__dest))),
+          "l"(static_cast<_CUDA_VSTD::uint64_t>(__cvta_generic_to_global(__src))),
+          "n"(16)
+        : "memory");
+  ),(
+    __cuda_ptx_cp_async_shared_global_is_not_supported_before_SM_80__();
+  ));
+}
+
+template <size_t _Alignment, typename _Group>
+inline __device__
+void __cp_async_shared_global_mechanism(_Group __g, char * __dest, const char * __src, _CUDA_VSTD::size_t __size) {
+    // If `if constexpr` is not available, this function gets instantiated even
+    // if is not called. Do not static_assert in that case.
+#if _LIBCUDACXX_STD_VER >= 17
+    static_assert(4 <= _Alignment, "cp.async requires at least 4-byte alignment");
+#endif // _LIBCUDACXX_STD_VER >= 17
+
+    // Maximal copy size is 16.
+    constexpr int __copy_size = (_Alignment > 16) ? 16 : _Alignment;
+    // We use an int offset here, because we are copying to shared memory,
+    // which is easily addressable using int.
+    const int __group_size = __g.size();
+    const int __group_rank = __g.thread_rank();
+    const int __stride = __group_size * __copy_size;
+    for (int __offset = __group_rank *  __copy_size; __offset < static_cast<int>(__size); __offset += __stride) {
+        __cp_async_shared_global<__copy_size>(__dest + __offset, __src + __offset);
+    }
+}
+
+template <size_t _Copy_size>
+struct __copy_chunk {
+    _ALIGNAS(_Copy_size) char data[_Copy_size];
+};
+
+template <size_t _Alignment, typename _Group>
+inline __host__ __device__
+void __cp_async_fallback_mechanism(_Group __g, char * __dest, const char * __src, _CUDA_VSTD::size_t __size) {
+    // Maximal copy size is 16 bytes
+    constexpr _CUDA_VSTD::size_t __copy_size = (_Alignment > 16) ? 16 : _Alignment;
+    using __chunk_t = __copy_chunk<__copy_size>;
+
+    // "Group"-strided loop over memory
+    const size_t __stride = __g.size() * __copy_size;
+
+    // An unroll factor of 64 ought to be enough for anybody. This unroll pragma
+    // is mainly intended to place an upper bound on loop unrolling. The number
+    // is more than high enough for the intended use case: an unroll factor of
+    // 64 allows moving 4 * 64 * 256 = 64kb in one unrolled loop with 256
+    // threads (copying ints). On the other hand, in the unfortunate case that
+    // we have to move 1024 bytes / thread with char width, then we prevent
+    // fully unrolling the loop to 1024 copy instructions. This prevents the
+    // compile times from increasing unreasonably, and also has neglibible
+    // impact on runtime performance.
+_LIBCUDACXX_PRAGMA_UNROLL(64)
+    for (_CUDA_VSTD::size_t __offset = __g.thread_rank() * __copy_size; __offset < __size; __offset += __stride) {
+        __chunk_t tmp = *reinterpret_cast<const __chunk_t *>(__src + __offset);
+        *reinterpret_cast<__chunk_t *>(__dest + __offset) = tmp;
+    }
+}
+
+/***********************************************************************
+ * cuda::memcpy_async dispatch helper functions
+ *
+ * - __get_size_align struct to determine the alignment from a size type.
+ ***********************************************************************/
+
+// The __get_size_align struct provides a way to query the guaranteed
+// "alignment" of a provided size. In this case, an n-byte aligned size means
+// that the size is a multiple of n.
+//
+// Use as follows:
+// static_assert(__get_size_align<size_t>::align == 1)
+// static_assert(__get_size_align<aligned_size_t<n>>::align == n)
+
+// Default impl: always returns 1.
+template <typename, typename = void>
+struct __get_size_align {
+    static constexpr int align = 1;
+};
+
+// aligned_size_t<n> overload: return n.
+template <typename T>
+struct __get_size_align<T, _CUDA_VSTD::__void_t<decltype(T::align)>> {
+    static constexpr int align = T::align;
+};
+
+/***********************************************************************
+ * cuda::memcpy_async dispatch
+ *
+ * The dispatch mechanism takes all the arguments and dispatches to the
+ * fastest asynchronous copy mechanism available.
+ *
+ * It returns a __completion_mechanism that indicates which completion mechanism
+ * was used by the copy mechanism. This value can be used by the sync object to
+ * further synchronize if necessary.
+ *
+ ***********************************************************************/
+
+template<_CUDA_VSTD::size_t _Align, typename _Group>
+_LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_DEVICE inline
+__completion_mechanism __dispatch_memcpy_async_any_to_any(_Group const & __group, char * __dest_char, char const * __src_char, _CUDA_VSTD::size_t __size, uint32_t __allowed_completions, uint64_t* __bar_handle) {
+    __cp_async_fallback_mechanism<_Align>(__group, __dest_char, __src_char, __size);
+    return __completion_mechanism::__sync;
+}
+
+template<_CUDA_VSTD::size_t _Align, typename _Group>
+_LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_DEVICE inline
+__completion_mechanism __dispatch_memcpy_async_global_to_shared(_Group const & __group, char * __dest_char, char const * __src_char, _CUDA_VSTD::size_t __size, uint32_t __allowed_completions, uint64_t* __bar_handle) {
+#if __cccl_ptx_isa >= 800
+    NV_IF_TARGET(NV_PROVIDES_SM_90, (
+        const bool __can_use_complete_tx = __allowed_completions & uint32_t(__completion_mechanism::__mbarrier_complete_tx);
+        _LIBCUDACXX_DEBUG_ASSERT(__can_use_complete_tx == (nullptr != __bar_handle), "Pass non-null bar_handle if and only if can_use_complete_tx.");
+        if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (_Align >= 16) {
+            if (__can_use_complete_tx && __isShared(__bar_handle)) {
+                __cp_async_bulk_shared_global(__group, __dest_char, __src_char, __size, __bar_handle);
+                return __completion_mechanism::__mbarrier_complete_tx;
+            }
+        }
+        // Fallthrough to SM 80..
+    ));
+#endif // __cccl_ptx_isa >= 800
+
+    NV_IF_TARGET(NV_PROVIDES_SM_80, (
+        if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (_Align >= 4) {
+            const bool __can_use_async_group = __allowed_completions & uint32_t(__completion_mechanism::__async_group);
+            if (__can_use_async_group) {
+                __cp_async_shared_global_mechanism<_Align>(__group, __dest_char, __src_char, __size);
+                return __completion_mechanism::__async_group;
+            }
+        }
+        // Fallthrough..
+    ));
+
+    __cp_async_fallback_mechanism<_Align>(__group, __dest_char, __src_char, __size);
+    return __completion_mechanism::__sync;
+}
+
+// __dispatch_memcpy_async is the internal entry point for dispatching to the correct memcpy_async implementation.
+template<_CUDA_VSTD::size_t _Align, typename _Group>
+_LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+__completion_mechanism __dispatch_memcpy_async(_Group const & __group, char * __dest_char, char const * __src_char, size_t __size, _CUDA_VSTD::uint32_t __allowed_completions, uint64_t* __bar_handle) {
+    NV_IF_ELSE_TARGET(NV_IS_DEVICE, (
+        // Dispatch based on direction of the copy: global to shared, shared to
+        // global, etc.
+
+        // CUDA compilers <= 12.2 may not propagate assumptions about the state space
+        // of pointers correctly. Therefore, we
+        // 1) put the code for each copy direction in a separate function, and
+        // 2) make sure none of the code paths can reach each other by "falling through".
+        //
+        // See nvbug 4074679 and also PR #478.
+        if (__isGlobal(__src_char) && __isShared(__dest_char)) {
+            return __dispatch_memcpy_async_global_to_shared<_Align>(__group, __dest_char, __src_char, __size, __allowed_completions, __bar_handle);
+        } else {
+            return __dispatch_memcpy_async_any_to_any<_Align>(__group, __dest_char, __src_char, __size, __allowed_completions, __bar_handle);
+        }
+    ), (
+        // Host code path:
+        if (__group.thread_rank() == 0) {
+            memcpy(__dest_char, __src_char, __size);
+        }
+        return __completion_mechanism::__sync;
+    ));
+}
+
+template<_CUDA_VSTD::size_t _Align, typename _Group>
+_LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+__completion_mechanism __dispatch_memcpy_async(_Group const & __group, char * __dest_char, char const * __src_char, _CUDA_VSTD::size_t __size, _CUDA_VSTD::uint32_t __allowed_completions) {
+    _LIBCUDACXX_DEBUG_ASSERT(! (__allowed_completions & uint32_t(__completion_mechanism::__mbarrier_complete_tx)), "Cannot allow mbarrier_complete_tx completion mechanism when not passing a barrier. ");
+    return __dispatch_memcpy_async<_Align>(__group, __dest_char, __src_char, __size, __allowed_completions, nullptr);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct __single_thread_group {
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void sync() const {}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr _CUDA_VSTD::size_t size() const { return 1; };
+    _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr _CUDA_VSTD::size_t thread_rank() const { return 0; };
+};
+
+template<typename _Group, class _Tp, typename _Size, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_INLINE_VISIBILITY
+async_contract_fulfillment __memcpy_async_barrier(_Group const & __group, _Tp * __destination, _Tp const * __source, _Size __size, barrier<_Sco, _CompF> & __barrier) {
+    static_assert(_CUDA_VSTD::is_trivially_copyable<_Tp>::value, "memcpy_async requires a trivially copyable type");
+
+    // 1. Determine which completion mechanisms can be used with the current
+    // barrier. A local shared memory barrier, i.e., block-scope barrier in local
+    // shared memory, supports the mbarrier_complete_tx mechanism in addition to
+    // the async group mechanism.
+    _CUDA_VSTD::uint32_t __allowed_completions = __is_local_smem_barrier(__barrier)
+        ? ( _CUDA_VSTD::uint32_t(__completion_mechanism::__async_group) | _CUDA_VSTD::uint32_t(__completion_mechanism::__mbarrier_complete_tx))
+        : _CUDA_VSTD::uint32_t(__completion_mechanism::__async_group);
+
+    // Alignment: Use the maximum of the alignment of _Tp and that of a possible cuda::aligned_size_t.
+    constexpr _CUDA_VSTD::size_t __size_align = __get_size_align<_Size>::align;
+    constexpr _CUDA_VSTD::size_t __align = (alignof(_Tp) < __size_align) ? __size_align : alignof(_Tp);
+    // Cast to char pointers. We don't need the type for alignment anymore and
+    // erasing the types reduces the number of instantiations of down-stream
+    // functions.
+    char * __dest_char = reinterpret_cast<char*>(__destination);
+    char const * __src_char = reinterpret_cast<char const *>(__source);
+
+    // 2. Issue actual copy instructions.
+    auto __bh = __try_get_barrier_handle(__barrier);
+    auto __cm =  __dispatch_memcpy_async<__align>(__group, __dest_char, __src_char, __size, __allowed_completions, __bh);
+
+    // 3. Synchronize barrier with copy instructions.
+    return __memcpy_completion_impl::__defer(__cm, __group, __size, __barrier);
+}
+
+template<typename _Group, class _Tp, _CUDA_VSTD::size_t _Alignment, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_INLINE_VISIBILITY
+async_contract_fulfillment memcpy_async(_Group const & __group, _Tp * __destination, _Tp const * __source, aligned_size_t<_Alignment> __size, barrier<_Sco, _CompF> & __barrier) {
+    return __memcpy_async_barrier(__group, __destination, __source, __size, __barrier);
+}
+
+template<class _Tp, typename _Size, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_INLINE_VISIBILITY
+async_contract_fulfillment memcpy_async(_Tp * __destination, _Tp const * __source, _Size __size, barrier<_Sco, _CompF> & __barrier) {
+    return __memcpy_async_barrier(__single_thread_group{}, __destination, __source, __size, __barrier);
+}
+
+template<typename _Group, class _Tp, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_INLINE_VISIBILITY
+async_contract_fulfillment memcpy_async(_Group const & __group, _Tp * __destination, _Tp const * __source, _CUDA_VSTD::size_t __size, barrier<_Sco, _CompF> & __barrier) {
+
+    return __memcpy_async_barrier(__group, __destination, __source, __size, __barrier);
+}
+
+template<typename _Group, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_INLINE_VISIBILITY
+async_contract_fulfillment memcpy_async(_Group const & __group, void * __destination, void const * __source, _CUDA_VSTD::size_t __size, barrier<_Sco, _CompF> & __barrier) {
+    return __memcpy_async_barrier(__group, reinterpret_cast<char *>(__destination), reinterpret_cast<char const *>(__source), __size, __barrier);
+}
+
+template<typename _Group, _CUDA_VSTD::size_t _Alignment, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_INLINE_VISIBILITY
+async_contract_fulfillment memcpy_async(_Group const & __group, void * __destination, void const * __source, aligned_size_t<_Alignment> __size, barrier<_Sco, _CompF> & __barrier) {
+    return __memcpy_async_barrier(__group, reinterpret_cast<char *>(__destination), reinterpret_cast<char const *>(__source), __size, __barrier);
+}
+
+template<typename _Size, thread_scope _Sco, typename _CompF>
+_LIBCUDACXX_INLINE_VISIBILITY
+async_contract_fulfillment memcpy_async(void * __destination, void const * __source, _Size __size, barrier<_Sco, _CompF> & __barrier) {
+    return __memcpy_async_barrier(__single_thread_group{}, reinterpret_cast<char *>(__destination), reinterpret_cast<char const *>(__source), __size, __barrier);
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _CCCL_CUDA_COMPILER
+
+#endif // _LIBCUDACXX___CUDA_BARRIER_H

cuda_toolkit/include/__cuda/chrono.h

@@ -0,0 +1,65 @@
+// -*- 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___CUDA_CHRONO_H
+#define _LIBCUDACXX___CUDA_CHRONO_H
+
+#ifndef __cuda_std__
+#error "<__cuda/chrono> should only be included in from <cuda/std/chrono>"
+#endif // __cuda_std__
+
+#include <nv/target>
+
+#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
+
+namespace chrono {
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+system_clock::time_point system_clock::now() noexcept
+{
+NV_DISPATCH_TARGET(
+NV_IS_DEVICE, (
+    uint64_t __time;
+    asm volatile("mov.u64 %0, %%globaltimer;":"=l"(__time)::);
+    return time_point(duration_cast<duration>(nanoseconds(__time)));
+),
+NV_IS_HOST, (
+    return time_point(duration_cast<duration>(nanoseconds(
+            ::std::chrono::duration_cast<::std::chrono::nanoseconds>(
+                ::std::chrono::system_clock::now().time_since_epoch()
+            ).count()
+           )));
+));
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+time_t system_clock::to_time_t(const system_clock::time_point& __t) noexcept
+{
+    return time_t(duration_cast<seconds>(__t.time_since_epoch()).count());
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+system_clock::time_point system_clock::from_time_t(time_t __t) noexcept
+{
+    return time_point(seconds(__t));;
+}
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CUDA_CHRONO_H

cuda_toolkit/include/__cuda/climits_prelude.h

@@ -0,0 +1,95 @@
+// -*- 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___CUDA_CLIMITS_PRELUDE_H
+#define _LIBCUDACXX___CUDA_CLIMITS_PRELUDE_H
+
+#ifndef __cuda_std__
+#error "<__cuda/climits_prelude> should only be included in from <cuda/std/climits>"
+#endif // __cuda_std__
+
+#ifndef _LIBCUDACXX_COMPILER_NVRTC
+    #include <climits>
+    #include <limits.h>
+    #include <cstdint>
+#else // ^^^ !_LIBCUDACXX_COMPILER_NVRTC ^^^ / vvv _LIBCUDACXX_COMPILER_NVRTC vvv
+    #define CHAR_BIT 8
+
+    #define SCHAR_MIN (-128)
+    #define SCHAR_MAX 127
+    #define UCHAR_MAX 255
+    #define __CHAR_UNSIGNED__ ('\xff' > 0) // CURSED
+    #if __CHAR_UNSIGNED__
+        #define CHAR_MIN 0
+        #define CHAR_MAX UCHAR_MAX
+    #else
+        #define CHAR_MIN SCHAR_MIN
+        #define CHAR_MAX SCHAR_MAX
+    #endif
+    #define SHRT_MIN (-SHRT_MAX - 1)
+    #define SHRT_MAX 0x7fff
+    #define USHRT_MAX 0xffff
+    #define INT_MIN (-INT_MAX - 1)
+    #define INT_MAX 0x7fffffff
+    #define UINT_MAX 0xffffffff
+    #define LONG_MIN (-LONG_MAX - 1)
+    #ifdef __LP64__
+        #define LONG_MAX LLONG_MAX
+        #define ULONG_MAX ULLONG_MAX
+    #else
+        #define LONG_MAX INT_MAX
+        #define ULONG_MAX UINT_MAX
+    #endif
+    #define LLONG_MIN (-LLONG_MAX - 1)
+    #define LLONG_MAX 0x7fffffffffffffffLL
+    #define ULLONG_MAX 0xffffffffffffffffUL
+
+    #define __FLT_RADIX__ 2
+    #define __FLT_MANT_DIG__ 24
+    #define __FLT_DIG__ 6
+    #define __FLT_MIN__ 1.17549435082228750796873653722224568e-38F
+    #define __FLT_MAX__ 3.40282346638528859811704183484516925e+38F
+    #define __FLT_EPSILON__ 1.19209289550781250000000000000000000e-7F
+    #define __FLT_MIN_EXP__ (-125)
+    #define __FLT_MIN_10_EXP__ (-37)
+    #define __FLT_MAX_EXP__ 128
+    #define __FLT_MAX_10_EXP__ 38
+    #define __FLT_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F
+    #define __DBL_MANT_DIG__ 53
+    #define __DBL_DIG__ 15
+    #define __DBL_MIN__ 2.22507385850720138309023271733240406e-308
+    #define __DBL_MAX__ 1.79769313486231570814527423731704357e+308
+    #define __DBL_EPSILON__ 2.22044604925031308084726333618164062e-16
+    #define __DBL_MIN_EXP__ (-1021)
+    #define __DBL_MIN_10_EXP__ (-307)
+    #define __DBL_MAX_EXP__ 1024
+    #define __DBL_MAX_10_EXP__ 308
+    #define __DBL_DENORM_MIN__ 4.94065645841246544176568792868221372e-324
+
+    template<typename _To, typename _From>
+    static _LIBCUDACXX_DEVICE _LIBCUDACXX_FORCE_INLINE
+    _To __cowchild_cast(_From __from)
+    {
+        static_assert(sizeof(_From) == sizeof(_To), "");
+        union __cast { _From __from; _To __to; };
+        __cast __c;
+        __c.__from = __from;
+        return __c.__to;
+    }
+
+    #define __builtin_huge_valf() __cowchild_cast<float>(0x7f800000)
+    #define __builtin_nanf(__dummy) __cowchild_cast<float>(0x7fc00000)
+    #define __builtin_nansf(__dummy) __cowchild_cast<float>(0x7fa00000)
+    #define __builtin_huge_val() __cowchild_cast<double>(0x7ff0000000000000)
+    #define __builtin_nan(__dummy) __cowchild_cast<double>(0x7ff8000000000000)
+    #define __builtin_nans(__dummy) __cowchild_cast<double>(0x7ff4000000000000)
+#endif // _LIBCUDACXX_COMPILER_NVRTC
+
+#endif // _LIBCUDACXX___CUDA_CLIMITS_PRELUDE_H

cuda_toolkit/include/__cuda/cstddef_prelude.h

@@ -0,0 +1,31 @@
+// -*- 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___CUDA_CSTDDEF_PRELUDE_H
+#define _LIBCUDACXX___CUDA_CSTDDEF_PRELUDE_H
+
+#ifndef __cuda_std__
+#error "<__cuda/cstddef_prelude> should only be included in from <cuda/std/cstddef>"
+#endif // __cuda_std__
+
+#ifndef _LIBCUDACXX_COMPILER_NVRTC
+#include <cstddef>
+#include <stddef.h>
+#else
+#define offsetof(type, member) (_CUDA_VSTD::size_t)((char*)&(((type *)0)->member) - (char*)0)
+#endif // _LIBCUDACXX_COMPILER_NVRTC
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+typedef decltype(nullptr) nullptr_t;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CUDA_CSTDDEF_PRELUDE_H

cuda_toolkit/include/__cuda/cstdint_prelude.h

@@ -0,0 +1,84 @@
+// -*- 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___CUDA_CSTDINT_PRELUDE_H
+#define _LIBCUDACXX___CUDA_CSTDINT_PRELUDE_H
+
+#ifndef __cuda_std__
+#error "<__cuda/cstdint_prelude> should only be included in from <cuda/std/cstdint>"
+#endif // __cuda_std__
+
+#ifndef _LIBCUDACXX_COMPILER_NVRTC
+    #include <cstdint>
+#else // ^^^ !_LIBCUDACXX_COMPILER_NVRTC ^^^ / vvv _LIBCUDACXX_COMPILER_NVRTC vvv
+    typedef signed char int8_t;
+    typedef unsigned char uint8_t;
+    typedef signed short int16_t;
+    typedef unsigned short uint16_t;
+    typedef signed int int32_t;
+    typedef unsigned int uint32_t;
+    typedef signed long long int64_t;
+    typedef unsigned long long uint64_t;
+
+#define _LIBCUDACXX_ADDITIONAL_INTS(N) \
+    typedef int##N##_t int_fast##N##_t; \
+    typedef uint##N##_t uint_fast##N##_t; \
+    typedef int##N##_t int_least##N##_t; \
+    typedef uint##N##_t uint_least##N##_t
+
+    _LIBCUDACXX_ADDITIONAL_INTS(8);
+    _LIBCUDACXX_ADDITIONAL_INTS(16);
+    _LIBCUDACXX_ADDITIONAL_INTS(32);
+    _LIBCUDACXX_ADDITIONAL_INTS(64);
+#undef _LIBCUDACXX_ADDITIONAL_INTS
+
+    typedef int64_t intptr_t;
+    typedef uint64_t uintptr_t;
+    typedef int64_t intmax_t;
+    typedef uint64_t uintmax_t;
+
+    #define INT8_MIN SCHAR_MIN
+    #define INT16_MIN SHRT_MIN
+    #define INT32_MIN INT_MIN
+    #define INT64_MIN LLONG_MIN
+    #define INT8_MAX SCHAR_MAX
+    #define INT16_MAX SHRT_MAX
+    #define INT32_MAX INT_MAX
+    #define INT64_MAX LLONG_MAX
+    #define UINT8_MAX UCHAR_MAX
+    #define UINT16_MAX USHRT_MAX
+    #define UINT32_MAX UINT_MAX
+    #define UINT64_MAX ULLONG_MAX
+    #define INT_FAST8_MIN SCHAR_MIN
+    #define INT_FAST16_MIN SHRT_MIN
+    #define INT_FAST32_MIN INT_MIN
+    #define INT_FAST64_MIN LLONG_MIN
+    #define INT_FAST8_MAX SCHAR_MAX
+    #define INT_FAST16_MAX SHRT_MAX
+    #define INT_FAST32_MAX INT_MAX
+    #define INT_FAST64_MAX LLONG_MAX
+    #define UINT_FAST8_MAX UCHAR_MAX
+    #define UINT_FAST16_MAX USHRT_MAX
+    #define UINT_FAST32_MAX UINT_MAX
+    #define UINT_FAST64_MAX ULLONG_MAX
+
+    #define INT8_C(X) ((int_least8_t)(X))
+    #define INT16_C(X) ((int_least16_t)(X))
+    #define INT32_C(X) ((int_least32_t)(X))
+    #define INT64_C(X) ((int_least64_t)(X))
+    #define UINT8_C(X) ((uint_least8_t)(X))
+    #define UINT16_C(X) ((uint_least16_t)(X))
+    #define UINT32_C(X) ((uint_least32_t)(X))
+    #define UINT64_C(X) ((uint_least64_t)(X))
+    #define INTMAX_C(X) ((intmax_t)(X))
+    #define UINTMAX_C(X) ((uintmax_t)(X))
+#endif // _LIBCUDACXX_COMPILER_NVRTC
+
+#endif // _LIBCUDACXX___CUDA_CSTDINT_PRELUDE_H

cuda_toolkit/include/__cuda/latch.h

@@ -0,0 +1,31 @@
+// -*- 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___CUDA_LATCH_H
+#define _LIBCUDACXX___CUDA_LATCH_H
+
+#ifndef __cuda_std__
+#error "<__cuda/latch> should only be included in from <cuda/std/latch>"
+#endif // __cuda_std__
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+template<thread_scope _Sco>
+class latch : public _CUDA_VSTD::__latch_base<_Sco> {
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    latch(_CUDA_VSTD::ptrdiff_t __count)
+        : _CUDA_VSTD::__latch_base<_Sco>(__count) {
+    }
+};
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _LIBCUDACXX___CUDA_LATCH_H

cuda_toolkit/include/__cuda/ptx.h

@@ -0,0 +1,1373 @@
+// -*- 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___CUDA_PTX_H
+#define  _LIBCUDACXX___CUDA_PTX_H
+
+#ifndef __cuda_std__
+#error "<__cuda/ptx.h> should only be included in from <cuda/std/barrier>"
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <nv/target> // __CUDA_MINIMUM_ARCH__ and friends
+
+#include "../__cuda/ptx/ptx_dot_variants.h"
+#include "../__cuda/ptx/ptx_helper_functions.h"
+#include "../__cuda/ptx/parallel_synchronization_and_communication_instructions_mbarrier.h"
+#include "../cstdint" // uint32_t
+/*
+ * The cuda::ptx namespace intends to provide PTX wrappers for new hardware
+ * features and new PTX instructions so that they can be experimented with
+ * before higher-level C++ APIs are designed and developed.
+ *
+ * The wrappers have the following responsibilities:
+ *
+ * - They must prevent any PTX assembler errors, that is:
+ *   - They are defined only for versions of the CUDA Toolkit in which nvcc/ptxas
+ *     actually recognizes the instruction.
+ *   - Sizes and types of parameters are correct.
+ * - They must convert state spaces correctly.
+ * - They adhere to the libcu++ coding standards of using:
+ *   - Reserved identifiers for all parameters, variables. E.g. `__meow` or `_Woof`
+ *   - _CUDA_VSTD:: namespace for types
+ *
+ * The wrappers should not do the following:
+ *
+ * - Use any non-native types. For example, an mbarrier instruction wrapper
+ *   takes the barrier address as a uint64_t pointer.
+ *
+ * This header is intended for:
+ *
+ * - internal consumption by higher-level APIs such as cuda::barrier,
+ * - outside developers who want to experiment with the latest features of the
+ *   hardware.
+ *
+ * Stability:
+ *
+ * - These headers are intended to present a stable API (not ABI) within one
+ *   major version of the CTK. This means that:
+ *   - All functions are marked inline
+ *   - The type of a function parameter can be changed to be more generic if
+ *     that means that code that called the original version can still be
+ *     compiled.
+ *
+ * - Good exposure of the PTX should be high priority. If, at a new major
+ *   version, we face a difficult choice between breaking backward-compatibility
+ *   and an improvement of the PTX exposure, we will tend to the latter option
+ *   more easily than in other parts of libcu++.
+ */
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA_PTX
+
+/*
+ *  Instructions
+ *
+ *  The organization of the instructions below follows that of the PTX ISA documentation:
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#instructions
+ *
+ *  To improve code organization, some sections are separated into their own
+ *  header. For instance, the mbarrier instructions are found in:
+ *  __cuda/ptx/parallel_synchronization_and_communication_instructions_mbarrier.h
+ *
+ */
+
+/*
+ *  9.7.1. Integer Arithmetic Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions
+ *
+ */
+
+// 9.7.1.7. Integer Arithmetic Instructions: sad
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-sad
+
+// 9.7.1.8. Integer Arithmetic Instructions: div
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-div
+
+// 9.7.1.9. Integer Arithmetic Instructions: rem
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-rem
+
+// 9.7.1.10. Integer Arithmetic Instructions: abs
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-abs
+
+// 9.7.1.11. Integer Arithmetic Instructions: neg
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-neg
+
+// 9.7.1.12. Integer Arithmetic Instructions: min
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-min
+
+// 9.7.1.13. Integer Arithmetic Instructions: max
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-max
+
+// 9.7.1.14. Integer Arithmetic Instructions: popc
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-popc
+
+// 9.7.1.15. Integer Arithmetic Instructions: clz
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-clz
+
+// 9.7.1.16. Integer Arithmetic Instructions: bfind
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-bfind
+
+// 9.7.1.17. Integer Arithmetic Instructions: fns
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-fns
+
+// 9.7.1.18. Integer Arithmetic Instructions: brev
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-brev
+
+// 9.7.1.19. Integer Arithmetic Instructions: bfe
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-bfe
+
+// 9.7.1.20. Integer Arithmetic Instructions: bfi
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-bfi
+
+// 9.7.1.21. Integer Arithmetic Instructions: szext
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-szext
+
+// 9.7.1.22. Integer Arithmetic Instructions: bmsk
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-bmsk
+
+// 9.7.1.23. Integer Arithmetic Instructions: dp4a
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-dp4a
+
+// 9.7.1.24. Integer Arithmetic Instructions: dp2a
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#integer-arithmetic-instructions-dp2a
+
+
+/*
+ *  9.7.2. Extended-Precision Integer Arithmetic Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#extended-precision-integer-arithmetic-instructions
+ *
+ */
+
+// 9.7.2.1. Extended-Precision Arithmetic Instructions: add.cc
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#extended-precision-arithmetic-instructions-add-cc
+
+// 9.7.2.2. Extended-Precision Arithmetic Instructions: addc
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#extended-precision-arithmetic-instructions-addc
+
+// 9.7.2.3. Extended-Precision Arithmetic Instructions: sub.cc
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#extended-precision-arithmetic-instructions-sub-cc
+
+// 9.7.2.4. Extended-Precision Arithmetic Instructions: subc
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#extended-precision-arithmetic-instructions-subc
+
+// 9.7.2.5. Extended-Precision Arithmetic Instructions: mad.cc
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#extended-precision-arithmetic-instructions-mad-cc
+
+// 9.7.2.6. Extended-Precision Arithmetic Instructions: madc
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#extended-precision-arithmetic-instructions-madc
+
+
+/*
+ *  9.7.3. Floating-Point Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions
+ *
+ */
+
+// 9.7.3.1. Floating Point Instructions: testp
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-testp
+
+// 9.7.3.2. Floating Point Instructions: copysign
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-copysign
+
+// 9.7.3.3. Floating Point Instructions: add
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-add
+
+// 9.7.3.4. Floating Point Instructions: sub
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-sub
+
+// 9.7.3.5. Floating Point Instructions: mul
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-mul
+
+// 9.7.3.6. Floating Point Instructions: fma
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-fma
+
+// 9.7.3.7. Floating Point Instructions: mad
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-mad
+
+// 9.7.3.8. Floating Point Instructions: div
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-div
+
+// 9.7.3.9. Floating Point Instructions: abs
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-abs
+
+// 9.7.3.10. Floating Point Instructions: neg
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-neg
+
+// 9.7.3.11. Floating Point Instructions: min
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-min
+
+// 9.7.3.12. Floating Point Instructions: max
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-max
+
+// 9.7.3.13. Floating Point Instructions: rcp
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-rcp
+
+// 9.7.3.14. Floating Point Instructions: rcp.approx.ftz.f64
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-rcp-approx-ftz-f64
+
+// 9.7.3.15. Floating Point Instructions: sqrt
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-sqrt
+
+// 9.7.3.16. Floating Point Instructions: rsqrt
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-rsqrt
+
+// 9.7.3.17. Floating Point Instructions: rsqrt.approx.ftz.f64
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-rsqrt-approx-ftz-f64
+
+// 9.7.3.18. Floating Point Instructions: sin
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-sin
+
+// 9.7.3.19. Floating Point Instructions: cos
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-cos
+
+// 9.7.3.20. Floating Point Instructions: lg2
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-lg2
+
+// 9.7.3.21. Floating Point Instructions: ex2
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-ex2
+
+// 9.7.3.22. Floating Point Instructions: tanh
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-tanh
+
+
+/*
+ *  9.7.4. Half Precision Floating-Point Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions
+ *
+ */
+
+// 9.7.4.1. Half Precision Floating Point Instructions: add
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions-add
+
+// 9.7.4.2. Half Precision Floating Point Instructions: sub
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions-sub
+
+// 9.7.4.3. Half Precision Floating Point Instructions: mul
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions-mul
+
+// 9.7.4.4. Half Precision Floating Point Instructions: fma
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions-fma
+
+// 9.7.4.5. Half Precision Floating Point Instructions: neg
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions-neg
+
+// 9.7.4.6. Half Precision Floating Point Instructions: abs
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions-abs
+
+// 9.7.4.7. Half Precision Floating Point Instructions: min
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions-min
+
+// 9.7.4.8. Half Precision Floating Point Instructions: max
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions-max
+
+// 9.7.4.9. Half Precision Floating Point Instructions: tanh
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions-tanh
+
+// 9.7.4.10. Half Precision Floating Point Instructions: ex2
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-floating-point-instructions-ex2
+
+
+/*
+ *  9.7.5. Comparison and Selection Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#comparison-and-selection-instructions
+ *
+ */
+
+// 9.7.5.1. Comparison and Selection Instructions: set
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#comparison-and-selection-instructions-set
+
+// 9.7.5.2. Comparison and Selection Instructions: setp
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#comparison-and-selection-instructions-setp
+
+// 9.7.5.3. Comparison and Selection Instructions: selp
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#comparison-and-selection-instructions-selp
+
+// 9.7.5.4. Comparison and Selection Instructions: slct
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#comparison-and-selection-instructions-slct
+
+
+/*
+ *  9.7.6. Half Precision Comparison Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-comparison-instructions
+ *
+ */
+
+// 9.7.6.1. Half Precision Comparison Instructions: set
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-comparison-instructions-set
+
+// 9.7.6.2. Half Precision Comparison Instructions: setp
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#half-precision-comparison-instructions-setp
+
+
+/*
+ *  9.7.7. Logic and Shift Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#logic-and-shift-instructions
+ *
+ */
+
+// 9.7.7.1. Logic and Shift Instructions: and
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#logic-and-shift-instructions-and
+
+// 9.7.7.2. Logic and Shift Instructions: or
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#logic-and-shift-instructions-or
+
+// 9.7.7.3. Logic and Shift Instructions: xor
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#logic-and-shift-instructions-xor
+
+// 9.7.7.4. Logic and Shift Instructions: not
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#logic-and-shift-instructions-not
+
+// 9.7.7.5. Logic and Shift Instructions: cnot
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#logic-and-shift-instructions-cnot
+
+// 9.7.7.6. Logic and Shift Instructions: lop3
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#logic-and-shift-instructions-lop3
+
+// 9.7.7.7. Logic and Shift Instructions: shf
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#logic-and-shift-instructions-shf
+
+// 9.7.7.8. Logic and Shift Instructions: shl
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#logic-and-shift-instructions-shl
+
+// 9.7.7.9. Logic and Shift Instructions: shr
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#logic-and-shift-instructions-shr
+
+
+/*
+ *  9.7.8. Data Movement and Conversion Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions
+ *
+ */
+
+// 9.7.8.3. Data Movement and Conversion Instructions: mov
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-mov
+
+// 9.7.8.4. Data Movement and Conversion Instructions: mov
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-mov-2
+
+// 9.7.8.5. Data Movement and Conversion Instructions: shfl (deprecated)
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-shfl-deprecated
+
+// 9.7.8.6. Data Movement and Conversion Instructions: shfl.sync
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-shfl-sync
+
+// 9.7.8.7. Data Movement and Conversion Instructions: prmt
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-prmt
+
+// 9.7.8.8. Data Movement and Conversion Instructions: ld
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-ld
+
+// 9.7.8.9. Data Movement and Conversion Instructions: ld.global.nc
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-ld-global-nc
+
+// 9.7.8.10. Data Movement and Conversion Instructions: ldu
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-ldu
+
+// 9.7.8.11. Data Movement and Conversion Instructions: st
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-st
+
+// 9.7.8.12. Data Movement and Conversion Instructions: st.async
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-st-async
+
+/*
+// st.async.weak.shared::cluster.mbarrier::complete_tx::bytes{.type} [addr], value, [remote_bar];    // 1.  PTX ISA 81, SM_90
+// .type      = { .b32, .b64 }
+template <typename Type>
+__device__ static inline void st_async(
+  Type* addr,
+  const Type& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_st_async_is_not_supported_before_SM_90__();
+template <typename _Type>
+_LIBCUDACXX_DEVICE static inline void st_async(
+  _Type* __addr,
+  const _Type& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  static_assert(sizeof(_Type) == 4 || sizeof(_Type) == 8, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (sizeof(_Type) == 4) {
+      asm (
+        "st.async.weak.shared::cluster.mbarrier::complete_tx::bytes.b32 [%0], %1, [%2];    // 1. "
+        :
+        : "r"(__as_ptr_remote_dsmem(__addr)),
+          "r"(__as_b32(__value)),
+          "r"(__as_ptr_remote_dsmem(__remote_bar))
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (sizeof(_Type) == 8) {
+      asm (
+        "st.async.weak.shared::cluster.mbarrier::complete_tx::bytes.b64 [%0], %1, [%2];    // 1. "
+        :
+        : "r"(__as_ptr_remote_dsmem(__addr)),
+          "l"(__as_b64(__value)),
+          "r"(__as_ptr_remote_dsmem(__remote_bar))
+        : "memory"
+      );
+    }
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_st_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// st.async.weak.shared::cluster.mbarrier::complete_tx::bytes.v2{.type} [addr], value, [remote_bar]; // 2.  PTX ISA 81, SM_90
+// .type      = { .b32, .b64 }
+template <typename Type>
+__device__ static inline void st_async(
+  Type* addr,
+  const Type (&value)[2],
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_st_async_is_not_supported_before_SM_90__();
+template <typename _Type>
+_LIBCUDACXX_DEVICE static inline void st_async(
+  _Type* __addr,
+  const _Type (&__value)[2],
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  static_assert(sizeof(_Type) == 4 || sizeof(_Type) == 8, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (sizeof(_Type) == 4) {
+      asm (
+        "st.async.weak.shared::cluster.mbarrier::complete_tx::bytes.v2.b32 [%0], {%1, %2}, [%3]; // 2. "
+        :
+        : "r"(__as_ptr_remote_dsmem(__addr)),
+          "r"(__as_b32(__value[0])),
+          "r"(__as_b32(__value[1])),
+          "r"(__as_ptr_remote_dsmem(__remote_bar))
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (sizeof(_Type) == 8) {
+      asm (
+        "st.async.weak.shared::cluster.mbarrier::complete_tx::bytes.v2.b64 [%0], {%1, %2}, [%3]; // 2. "
+        :
+        : "r"(__as_ptr_remote_dsmem(__addr)),
+          "l"(__as_b64(__value[0])),
+          "l"(__as_b64(__value[1])),
+          "r"(__as_ptr_remote_dsmem(__remote_bar))
+        : "memory"
+      );
+    }
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_st_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// st.async.weak.shared::cluster.mbarrier::complete_tx::bytes.v4.b32 [addr], value, [remote_bar];    // 3.  PTX ISA 81, SM_90
+template <typename B32>
+__device__ static inline void st_async(
+  B32* addr,
+  const B32 (&value)[4],
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_st_async_is_not_supported_before_SM_90__();
+template <typename _B32>
+_LIBCUDACXX_DEVICE static inline void st_async(
+  _B32* __addr,
+  const _B32 (&__value)[4],
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  static_assert(sizeof(_B32) == 4, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "st.async.weak.shared::cluster.mbarrier::complete_tx::bytes.v4.b32 [%0], {%1, %2, %3, %4}, [%5];    // 3. "
+      :
+      : "r"(__as_ptr_remote_dsmem(__addr)),
+        "r"(__as_b32(__value[0])),
+        "r"(__as_b32(__value[1])),
+        "r"(__as_b32(__value[2])),
+        "r"(__as_b32(__value[3])),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_st_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+
+// 9.7.8.13. Data Movement and Conversion Instructions: multimem.ld_reduce, multimem.st, multimem.red
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-multimem-ld-reduce-multimem-st-multimem-red
+
+// 9.7.8.14. Data Movement and Conversion Instructions: prefetch, prefetchu
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-prefetch-prefetchu
+
+// 9.7.8.15. Data Movement and Conversion Instructions: applypriority
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-applypriority
+
+// 9.7.8.16. Data Movement and Conversion Instructions: discard
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-discard
+
+// 9.7.8.17. Data Movement and Conversion Instructions: createpolicy
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-createpolicy
+
+// 9.7.8.18. Data Movement and Conversion Instructions: isspacep
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-isspacep
+
+// 9.7.8.19. Data Movement and Conversion Instructions: cvta
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cvta
+
+// 9.7.8.20. Data Movement and Conversion Instructions: cvt
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cvt
+
+// 9.7.8.21. Data Movement and Conversion Instructions: cvt.pack
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cvt-pack
+
+// 9.7.8.22. Data Movement and Conversion Instructions: mapa
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-mapa
+
+// 9.7.8.23. Data Movement and Conversion Instructions: getctarank
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-getctarank
+
+
+/*
+ *  9.7.8.24. Data Movement and Conversion Instructions: Asynchronous copy
+ *   https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-asynchronous-copy
+ *
+ */
+
+// 9.7.8.24.3. Data Movement and Conversion Instructions: cp.async
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async
+
+// 9.7.8.24.4. Data Movement and Conversion Instructions: cp.async.commit_group
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-commit-group
+
+// 9.7.8.24.5. Data Movement and Conversion Instructions: cp.async.wait_group / cp.async.wait_all
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-wait-group-cp-async-wait-all
+
+// 9.7.8.24.6. Data Movement and Conversion Instructions: cp.async.bulk
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-bulk
+
+// 9.7.8.24.7. Data Movement and Conversion Instructions: cp.reduce.async.bulk
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-reduce-async-bulk
+
+// 9.7.8.24.8. Data Movement and Conversion Instructions: cp.async.bulk.prefetch
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-bulk-prefetch
+
+// 9.7.8.24.9. Data Movement and Conversion Instructions: cp.async.bulk.tensor
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-bulk-tensor
+
+// 9.7.8.24.10. Data Movement and Conversion Instructions: cp.reduce.async.bulk.tensor
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-reduce-async-bulk-tensor
+
+// 9.7.8.24.11. Data Movement and Conversion Instructions: cp.async.bulk.prefetch.tensor
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-bulk-prefetch-tensor
+
+// 9.7.8.24.12. Data Movement and Conversion Instructions: cp.async.bulk.commit_group
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-bulk-commit-group
+
+// 9.7.8.24.13. Data Movement and Conversion Instructions: cp.async.bulk.wait_group
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-bulk-wait-group
+
+// 9.7.8.25. Data Movement and Conversion Instructions: tensormap.replace
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-tensormap-replace
+
+
+/*
+ *  9.7.9. Texture Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#texture-instructions
+ *
+ */
+
+// 9.7.9.3. Texture Instructions: tex
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#texture-instructions-tex
+
+// 9.7.9.4. Texture Instructions: tld4
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#texture-instructions-tld4
+
+// 9.7.9.5. Texture Instructions: txq
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#texture-instructions-txq
+
+// 9.7.9.6. Texture Instructions: istypep
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#texture-instructions-istypep
+
+
+/*
+ *  9.7.10. Surface Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#surface-instructions
+ *
+ */
+
+// 9.7.10.1. Surface Instructions: suld
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#surface-instructions-suld
+
+// 9.7.10.2. Surface Instructions: sust
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#surface-instructions-sust
+
+// 9.7.10.3. Surface Instructions: sured
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#surface-instructions-sured
+
+// 9.7.10.4. Surface Instructions: suq
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#surface-instructions-suq
+
+
+/*
+ *  9.7.11. Control Flow Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#control-flow-instructions
+ *
+ */
+
+// 9.7.11.1. Control Flow Instructions: {}
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#control-flow-instructions-curly-braces
+
+// 9.7.11.2. Control Flow Instructions: @
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#control-flow-instructions-at
+
+// 9.7.11.3. Control Flow Instructions: bra
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#control-flow-instructions-bra
+
+// 9.7.11.4. Control Flow Instructions: brx.idx
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#control-flow-instructions-brx-idx
+
+// 9.7.11.5. Control Flow Instructions: call
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#control-flow-instructions-call
+
+// 9.7.11.6. Control Flow Instructions: ret
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#control-flow-instructions-ret
+
+// 9.7.11.7. Control Flow Instructions: exit
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#control-flow-instructions-exit
+
+
+/*
+ *  9.7.12. Parallel Synchronization and Communication Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions
+ *
+ */
+
+// 9.7.12.1. Parallel Synchronization and Communication Instructions: bar, barrier
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-bar-barrier
+
+// 9.7.12.2. Parallel Synchronization and Communication Instructions: bar.warp.sync
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-bar-warp-sync
+
+// 9.7.12.3. Parallel Synchronization and Communication Instructions: barrier.cluster
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-barrier-cluster
+
+// 9.7.12.4. Parallel Synchronization and Communication Instructions: membar/fence
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-membar-fence
+
+// 9.7.12.5. Parallel Synchronization and Communication Instructions: atom
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-atom
+
+// 9.7.12.6. Parallel Synchronization and Communication Instructions: red
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-red
+
+// 9.7.12.7. Parallel Synchronization and Communication Instructions: red.async
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-red-async
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .u32 }
+// .op        = { .inc }
+template <typename=void>
+__device__ static inline void red_async(
+  cuda::ptx::op_inc_t,
+  uint32_t* dest,
+  const uint32_t& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_inc_t,
+  _CUDA_VSTD::uint32_t* __dest,
+  const _CUDA_VSTD::uint32_t& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_u32 (due to parameter type constraint)
+  // __op == op_inc (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.inc.u32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__value),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .u32 }
+// .op        = { .dec }
+template <typename=void>
+__device__ static inline void red_async(
+  cuda::ptx::op_dec_t,
+  uint32_t* dest,
+  const uint32_t& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_dec_t,
+  _CUDA_VSTD::uint32_t* __dest,
+  const _CUDA_VSTD::uint32_t& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_u32 (due to parameter type constraint)
+  // __op == op_dec (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.dec.u32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__value),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .u32 }
+// .op        = { .min }
+template <typename=void>
+__device__ static inline void red_async(
+  cuda::ptx::op_min_t,
+  uint32_t* dest,
+  const uint32_t& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_min_t,
+  _CUDA_VSTD::uint32_t* __dest,
+  const _CUDA_VSTD::uint32_t& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_u32 (due to parameter type constraint)
+  // __op == op_min (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.min.u32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__value),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .u32 }
+// .op        = { .max }
+template <typename=void>
+__device__ static inline void red_async(
+  cuda::ptx::op_max_t,
+  uint32_t* dest,
+  const uint32_t& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_max_t,
+  _CUDA_VSTD::uint32_t* __dest,
+  const _CUDA_VSTD::uint32_t& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_u32 (due to parameter type constraint)
+  // __op == op_max (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.max.u32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__value),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .u32 }
+// .op        = { .add }
+template <typename=void>
+__device__ static inline void red_async(
+  cuda::ptx::op_add_t,
+  uint32_t* dest,
+  const uint32_t& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_add_t,
+  _CUDA_VSTD::uint32_t* __dest,
+  const _CUDA_VSTD::uint32_t& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_u32 (due to parameter type constraint)
+  // __op == op_add (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.add.u32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__value),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .s32 }
+// .op        = { .min }
+template <typename=void>
+__device__ static inline void red_async(
+  cuda::ptx::op_min_t,
+  int32_t* dest,
+  const int32_t& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_min_t,
+  _CUDA_VSTD::int32_t* __dest,
+  const _CUDA_VSTD::int32_t& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_s32 (due to parameter type constraint)
+  // __op == op_min (due to parameter type constraint)
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.min.s32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__value),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .s32 }
+// .op        = { .max }
+template <typename=void>
+__device__ static inline void red_async(
+  cuda::ptx::op_max_t,
+  int32_t* dest,
+  const int32_t& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_max_t,
+  _CUDA_VSTD::int32_t* __dest,
+  const _CUDA_VSTD::int32_t& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_s32 (due to parameter type constraint)
+  // __op == op_max (due to parameter type constraint)
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.max.s32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__value),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .s32 }
+// .op        = { .add }
+template <typename=void>
+__device__ static inline void red_async(
+  cuda::ptx::op_add_t,
+  int32_t* dest,
+  const int32_t& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_add_t,
+  _CUDA_VSTD::int32_t* __dest,
+  const _CUDA_VSTD::int32_t& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_s32 (due to parameter type constraint)
+  // __op == op_add (due to parameter type constraint)
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.add.s32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__value),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .b32 }
+// .op        = { .and }
+template <typename B32>
+__device__ static inline void red_async(
+  cuda::ptx::op_and_op_t,
+  B32* dest,
+  const B32& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename _B32>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_and_op_t,
+  _B32* __dest,
+  const _B32& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_b32 (due to parameter type constraint)
+  // __op == op_and_op (due to parameter type constraint)
+  static_assert(sizeof(_B32) == 4, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.and.b32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__as_b32(__value)),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .b32 }
+// .op        = { .or }
+template <typename B32>
+__device__ static inline void red_async(
+  cuda::ptx::op_or_op_t,
+  B32* dest,
+  const B32& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename _B32>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_or_op_t,
+  _B32* __dest,
+  const _B32& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_b32 (due to parameter type constraint)
+  // __op == op_or_op (due to parameter type constraint)
+  static_assert(sizeof(_B32) == 4, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.or.b32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__as_b32(__value)),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .b32 }
+// .op        = { .xor }
+template <typename B32>
+__device__ static inline void red_async(
+  cuda::ptx::op_xor_op_t,
+  B32* dest,
+  const B32& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename _B32>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_xor_op_t,
+  _B32* __dest,
+  const _B32& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_b32 (due to parameter type constraint)
+  // __op == op_xor_op (due to parameter type constraint)
+  static_assert(sizeof(_B32) == 4, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.xor.b32  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "r"(__as_b32(__value)),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}{.type}  [dest], value, [remote_bar];  // PTX ISA 81, SM_90
+// .type      = { .u64 }
+// .op        = { .add }
+template <typename=void>
+__device__ static inline void red_async(
+  cuda::ptx::op_add_t,
+  uint64_t* dest,
+  const uint64_t& value,
+  uint64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_add_t,
+  _CUDA_VSTD::uint64_t* __dest,
+  const _CUDA_VSTD::uint64_t& __value,
+  _CUDA_VSTD::uint64_t* __remote_bar)
+{
+  // __type == type_u64 (due to parameter type constraint)
+  // __op == op_add (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.add.u64  [%0], %1, [%2]; "
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "l"(__value),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+/*
+// red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes{.op}.u64  [dest], value, [remote_bar]; // .u64 intentional PTX ISA 81, SM_90
+// .op        = { .add }
+template <typename=void>
+__device__ static inline void red_async(
+  cuda::ptx::op_add_t,
+  int64_t* dest,
+  const int64_t& value,
+  int64_t* remote_bar);
+*/
+#if __cccl_ptx_isa >= 810
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void red_async(
+  op_add_t,
+  _CUDA_VSTD::int64_t* __dest,
+  const _CUDA_VSTD::int64_t& __value,
+  _CUDA_VSTD::int64_t* __remote_bar)
+{
+  // __op == op_add (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "red.async.relaxed.cluster.shared::cluster.mbarrier::complete_tx::bytes.add.u64  [%0], %1, [%2]; // .u64 intentional"
+      :
+      : "r"(__as_ptr_remote_dsmem(__dest)),
+        "l"(__value),
+        "r"(__as_ptr_remote_dsmem(__remote_bar))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_red_async_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 810
+
+
+// 9.7.12.8. Parallel Synchronization and Communication Instructions: vote (deprecated)
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-vote-deprecated
+
+// 9.7.12.9. Parallel Synchronization and Communication Instructions: vote.sync
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-vote-sync
+
+// 9.7.12.10. Parallel Synchronization and Communication Instructions: match.sync
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-match-sync
+
+// 9.7.12.11. Parallel Synchronization and Communication Instructions: activemask
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-activemask
+
+// 9.7.12.12. Parallel Synchronization and Communication Instructions: redux.sync
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-redux-sync
+
+// 9.7.12.13. Parallel Synchronization and Communication Instructions: griddepcontrol
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-griddepcontrol
+
+// 9.7.12.14. Parallel Synchronization and Communication Instructions: elect.sync
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-elect-sync
+
+/*
+ *  9.7.12.15. Parallel Synchronization and Communication Instructions: mbarrier
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier
+ *
+ *  Contained in: __cuda/ptx/parallel_synchronization_and_communication_instructions_mbarrier.h
+ */
+
+// 9.7.12.15.18. Parallel Synchronization and Communication Instructions: tensormap.cp_fenceproxy
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-tensormap-cp-fenceproxy
+
+
+/*
+ *  9.7.13. Warp Level Matrix Multiply-Accumulate Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#warp-level-matrix-multiply-accumulate-instructions
+ *
+ */
+
+// 9.7.13.3.3. Warp-level Matrix Load Instruction: wmma.load
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#warp-level-matrix-load-instruction-wmma-load
+
+// 9.7.13.3.4. Warp-level Matrix Store Instruction: wmma.store
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#warp-level-matrix-store-instruction-wmma-store
+
+// 9.7.13.3.5. Warp-level Matrix Multiply-and-Accumulate Instruction: wmma.mma
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#warp-level-matrix-multiply-and-accumulate-instruction-wmma-mma
+
+// 9.7.13.4.14. Multiply-and-Accumulate Instruction: mma
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#multiply-and-accumulate-instruction-mma
+
+// 9.7.13.4.15. Warp-level matrix load instruction: ldmatrix
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#warp-level-matrix-load-instruction-ldmatrix
+
+// 9.7.13.4.16. Warp-level matrix store instruction: stmatrix
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#warp-level-matrix-store-instruction-stmatrix
+
+// 9.7.13.4.17. Warp-level matrix transpose instruction: movmatrix
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#warp-level-matrix-transpose-instruction-movmatrix
+
+// 9.7.13.5.3. Multiply-and-Accumulate Instruction: mma.sp
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#multiply-and-accumulate-instruction-mma-sp
+
+
+/*
+ *  9.7.14. Asynchronous Warpgroup Level Matrix Multiply-Accumulate Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#asynchronous-warpgroup-level-matrix-multiply-accumulate-instructions
+ *
+ */
+
+// 9.7.14.5.2. Asynchronous Multiply-and-Accumulate Instruction: wgmma.mma_async
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#asynchronous-multiply-and-accumulate-instruction-wgmma-mma-async
+
+// 9.7.14.6.4. Asynchronous Multiply-and-Accumulate Instruction: wgmma.mma_async.sp
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#asynchronous-multiply-and-accumulate-instruction-wgmma-mma-async-sp
+
+// 9.7.14.7.1. Asynchronous Multiply-and-Accumulate Instruction: wgmma.fence
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#asynchronous-multiply-and-accumulate-instruction-wgmma-fence
+
+// 9.7.14.7.2. Asynchronous Multiply-and-Accumulate Instruction: wgmma.commit_group
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#asynchronous-multiply-and-accumulate-instruction-wgmma-commit-group
+
+// 9.7.14.7.3. Asynchronous Multiply-and-Accumulate Instruction: wgmma.wait_group
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#asynchronous-multiply-and-accumulate-instruction-wgmma-wait-group
+
+
+/*
+ *  9.7.15. Stack Manipulation Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#stack-manipulation-instructions
+ *
+ */
+
+// 9.7.15.1. Stack Manipulation Instructions: stacksave
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#stack-manipulation-instructions-stacksave
+
+// 9.7.15.2. Stack Manipulation Instructions: stackrestore
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#stack-manipulation-instructions-stackrestore
+
+// 9.7.15.3. Stack Manipulation Instructions: alloca
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#stack-manipulation-instructions-alloca
+
+
+/*
+ *  9.7.16. Video Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#video-instructions
+ *
+ */
+
+// 9.7.16.1.1. Scalar Video Instructions: vadd, vsub, vabsdiff, vmin, vmax
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#scalar-video-instructions-vadd-vsub-vabsdiff-vmin-vmax
+
+// 9.7.16.1.2. Scalar Video Instructions: vshl, vshr
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#scalar-video-instructions-vshl-vshr
+
+// 9.7.16.1.3. Scalar Video Instructions: vmad
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#scalar-video-instructions-vmad
+
+// 9.7.16.1.4. Scalar Video Instructions: vset
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#scalar-video-instructions-vset
+
+
+/*
+ *  9.7.16.2. SIMD Video Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#simd-video-instructions
+ *
+ */
+
+// 9.7.16.2.1. SIMD Video Instructions: vadd2, vsub2, vavrg2, vabsdiff2, vmin2, vmax2
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#simd-video-instructions-vadd2-vsub2-vavrg2-vabsdiff2-vmin2-vmax2
+
+// 9.7.16.2.2. SIMD Video Instructions: vset2
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#simd-video-instructions-vset2
+
+// 9.7.16.2.3. SIMD Video Instructions: vadd4, vsub4, vavrg4, vabsdiff4, vmin4, vmax4
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#simd-video-instructions-vadd4-vsub4-vavrg4-vabsdiff4-vmin4-vmax4
+
+// 9.7.16.2.4. SIMD Video Instructions: vset4
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#simd-video-instructions-vset4
+
+
+/*
+ *  9.7.17. Miscellaneous Instructions
+ *  https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#miscellaneous-instructions
+ *
+ */
+
+// 9.7.17.1. Miscellaneous Instructions: brkpt
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#miscellaneous-instructions-brkpt
+
+// 9.7.17.2. Miscellaneous Instructions: nanosleep
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#miscellaneous-instructions-nanosleep
+
+// 9.7.17.3. Miscellaneous Instructions: pmevent
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#miscellaneous-instructions-pmevent
+
+// 9.7.17.4. Miscellaneous Instructions: trap
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#miscellaneous-instructions-trap
+
+// 9.7.17.5. Miscellaneous Instructions: setmaxnreg
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#miscellaneous-instructions-setmaxnreg
+
+_LIBCUDACXX_END_NAMESPACE_CUDA_PTX
+
+#endif // _LIBCUDACXX___CUDA_PTX_H

cuda_toolkit/include/__cuda/ptx/parallel_synchronization_and_communication_instructions_mbarrier.h

@@ -0,0 +1,1070 @@
+// -*- 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 _CUDA_PTX_PARALLEL_SYNCHRONIZATION_AND_COMMUNICATION_INSTRUCTIONS_MBARRIER_H_
+#define _CUDA_PTX_PARALLEL_SYNCHRONIZATION_AND_COMMUNICATION_INSTRUCTIONS_MBARRIER_H_
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include "ptx_dot_variants.h"
+#include "ptx_helper_functions.h"
+#include "../../cstdint"
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA_PTX
+
+/*
+ *  9.7.12.15. Parallel Synchronization and Communication Instructions: mbarrier
+ *   https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier
+ *
+ */
+
+// 9.7.12.15.9. Parallel Synchronization and Communication Instructions: mbarrier.init
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier-init
+
+// 9.7.12.15.10. Parallel Synchronization and Communication Instructions: mbarrier.inval
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier-inval
+
+// 9.7.12.15.11. Parallel Synchronization and Communication Instructions: mbarrier.expect_tx
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier-expect-tx
+
+// 9.7.12.15.12. Parallel Synchronization and Communication Instructions: mbarrier.complete_tx
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier-complete-tx
+
+// 9.7.12.15.13. Parallel Synchronization and Communication Instructions: mbarrier.arrive
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier-arrive
+
+/*
+PTX ISA docs:
+
+// mbarrier.arrive:
+mbarrier.arrive{.shared}.b64 state, [addr];                                         // 1. PTX ISA 70, SM_80
+mbarrier.arrive{.shared{::cta}}.b64 state, [addr]{, count};                         // 2. PTX ISA 78, SM_90 (due to count)
+
+mbarrier.arrive{.sem}{.scope}{.shared{::cta}}.b64           state, [addr]{, count}; // 3. PTX ISA 80, SM_90 (some variants are SM_80, but are covered by 1)
+mbarrier.arrive{.sem}{.scope}{.shared::cluster}.b64         _, [addr] {,count}      // 4. PTX ISA 80, SM_90
+
+.sem   = { .release }
+.scope = { .cta, .cluster }
+
+
+// mbarrier.arrive.noComplete:
+mbarrier.arrive.noComplete{.shared}.b64 state, [addr], count;                       // 5. PTX ISA 70, SM_80
+mbarrier.arrive.noComplete{.shared{::cta}}.b64 state, [addr], count;                // 6. PTX ISA 78, Not exposed. Just a spelling change (shared -> shared::cta)
+mbarrier.arrive.noComplete{.sem}{.cta}{.shared{::cta}}.b64  state, [addr], count;   // 7. PTX ISA 80, Not exposed. Adds .release, and .cta scope.
+
+
+// mbarrier.arrive.expect_tx:
+mbarrier.arrive.expect_tx{.sem}{.scope}{.shared{::cta}}.b64 state, [addr], tx_count; // 8. PTX ISA 80, SM_90
+mbarrier.arrive.expect_tx{.sem}{.scope}{.shared::cluster}.b64   _, [addr], tx_count; // 9. PTX ISA 80, SM_90
+
+.sem   = { .release }
+.scope = { .cta, .cluster }
+
+
+Corresponding Exposure:
+
+// mbarrier_arrive:
+mbarrier.arrive.shared.b64                                  state,  [addr];           // 1. PTX ISA 70, SM_80, !memory
+// count is non-optional, otherwise 3 would not be distinguishable from 1
+mbarrier.arrive.shared::cta.b64                             state,  [addr], count;    // 2. PTX ISA 78, SM_90, !memory
+mbarrier.arrive{.sem}{.scope}{.space}.b64                   state,  [addr];           // 3a. PTX ISA 80, SM_90, !memory
+.space = { .shared::cta}
+.sem   = { .release }
+.scope = { .cta, .cluster }
+
+mbarrier.arrive{.sem}{.scope}{.space}.b64                   state,  [addr], count;    // 3b. PTX ISA 80, SM_90, !memory
+.space = { .shared::cta}
+.sem   = { .release }
+.scope = { .cta, .cluster }
+
+// NOTE: .scope=.cta is dropped on purpose
+mbarrier.arrive{.sem}{.scope}{.space}.b64                   _, [addr];                // 4a. PTX ISA 80, SM_90, !memory
+.space = { .shared::cluster}
+.sem   = { .release }
+.scope = { .cluster }
+
+// NOTE: .scope=.cta is dropped on purpose
+mbarrier.arrive{.sem}{.scope}{.space}.b64                   _, [addr], count;         // 4b. PTX ISA 80, SM_90, !memory
+.space = { .shared::cluster}
+.sem   = { .release }
+.scope = { .cluster }
+
+
+// mbarrier_arrive_no_complete:
+mbarrier.arrive.noComplete.shared.b64                       state,  [addr], count;    // 5. PTX ISA 70, SM_80, !memory
+
+
+mbarrier.arrive.expect_tx{.sem}{.scope}{.space}.b64        state, [addr], tx_count;   // 8. PTX ISA 80, SM_90, !memory
+.space = { .shared::cta }
+.sem   = { .release }
+.scope = { .cta, .cluster }
+
+// NOTE: .scope=.cta is dropped on purpose
+mbarrier.arrive.expect_tx{.sem}{.scope}{.space}.b64        _, [addr], tx_count;       // 9. PTX ISA 80, SM_90, !memory
+.space = { .shared::cluster }
+.sem   = { .release }
+.scope = { .cluster }
+
+*/
+
+/*
+// mbarrier.arrive.shared.b64                                  state,  [addr];           // 1.  PTX ISA 70, SM_80
+template <typename=void>
+__device__ static inline uint64_t mbarrier_arrive(
+  uint64_t* addr);
+*/
+#if __cccl_ptx_isa >= 700
+extern "C" _LIBCUDACXX_DEVICE _CUDA_VSTD::uint64_t ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_80__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline _CUDA_VSTD::uint64_t mbarrier_arrive(
+  _CUDA_VSTD::uint64_t* __addr)
+{
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_80,(
+    _CUDA_VSTD::uint64_t __state;
+    asm (
+      "mbarrier.arrive.shared.b64                                  %0,  [%1];           // 1. "
+      : "=l"(__state)
+      : "r"(__as_ptr_smem(__addr))
+      : "memory"
+    );
+    return __state;
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_80__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 700
+
+/*
+// mbarrier.arrive.shared::cta.b64                             state,  [addr], count;    // 2.  PTX ISA 78, SM_90
+template <typename=void>
+__device__ static inline uint64_t mbarrier_arrive(
+  uint64_t* addr,
+  const uint32_t& count);
+*/
+#if __cccl_ptx_isa >= 780
+extern "C" _LIBCUDACXX_DEVICE _CUDA_VSTD::uint64_t ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline _CUDA_VSTD::uint64_t mbarrier_arrive(
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __count)
+{
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint64_t __state;
+    asm (
+      "mbarrier.arrive.shared::cta.b64                             %0,  [%1], %2;    // 2. "
+      : "=l"(__state)
+      : "r"(__as_ptr_smem(__addr)),
+        "r"(__count)
+      : "memory"
+    );
+    return __state;
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 780
+
+/*
+// mbarrier.arrive{.sem}{.scope}{.space}.b64                   state,  [addr];           // 3a.  PTX ISA 80, SM_90
+// .sem       = { .release }
+// .scope     = { .cta, .cluster }
+// .space     = { .shared::cta }
+template <cuda::ptx::dot_scope Scope>
+__device__ static inline uint64_t mbarrier_arrive(
+  cuda::ptx::sem_release_t,
+  cuda::ptx::scope_t<Scope> scope,
+  cuda::ptx::space_shared_t,
+  uint64_t* addr);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE _CUDA_VSTD::uint64_t ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_90__();
+template <dot_scope _Scope>
+_LIBCUDACXX_DEVICE static inline _CUDA_VSTD::uint64_t mbarrier_arrive(
+  sem_release_t,
+  scope_t<_Scope> __scope,
+  space_shared_t,
+  _CUDA_VSTD::uint64_t* __addr)
+{
+  // __sem == sem_release (due to parameter type constraint)
+  static_assert(__scope == scope_cta || __scope == scope_cluster, "");
+  // __space == space_shared (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint64_t __state;
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cta) {
+      asm (
+        "mbarrier.arrive.release.cta.shared.b64                   %0,  [%1];           // 3a. "
+        : "=l"(__state)
+        : "r"(__as_ptr_smem(__addr))
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cluster) {
+      asm (
+        "mbarrier.arrive.release.cluster.shared.b64                   %0,  [%1];           // 3a. "
+        : "=l"(__state)
+        : "r"(__as_ptr_smem(__addr))
+        : "memory"
+      );
+    }
+    return __state;
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+/*
+// mbarrier.arrive{.sem}{.scope}{.space}.b64                   state,  [addr], count;    // 3b.  PTX ISA 80, SM_90
+// .sem       = { .release }
+// .scope     = { .cta, .cluster }
+// .space     = { .shared::cta }
+template <cuda::ptx::dot_scope Scope>
+__device__ static inline uint64_t mbarrier_arrive(
+  cuda::ptx::sem_release_t,
+  cuda::ptx::scope_t<Scope> scope,
+  cuda::ptx::space_shared_t,
+  uint64_t* addr,
+  const uint32_t& count);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE _CUDA_VSTD::uint64_t ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_90__();
+template <dot_scope _Scope>
+_LIBCUDACXX_DEVICE static inline _CUDA_VSTD::uint64_t mbarrier_arrive(
+  sem_release_t,
+  scope_t<_Scope> __scope,
+  space_shared_t,
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __count)
+{
+  // __sem == sem_release (due to parameter type constraint)
+  static_assert(__scope == scope_cta || __scope == scope_cluster, "");
+  // __space == space_shared (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint64_t __state;
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cta) {
+      asm (
+        "mbarrier.arrive.release.cta.shared.b64                   %0,  [%1], %2;    // 3b. "
+        : "=l"(__state)
+        : "r"(__as_ptr_smem(__addr)),
+          "r"(__count)
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cluster) {
+      asm (
+        "mbarrier.arrive.release.cluster.shared.b64                   %0,  [%1], %2;    // 3b. "
+        : "=l"(__state)
+        : "r"(__as_ptr_smem(__addr)),
+          "r"(__count)
+        : "memory"
+      );
+    }
+    return __state;
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+/*
+// mbarrier.arrive{.sem}{.scope}{.space}.b64                   _, [addr];                // 4a.  PTX ISA 80, SM_90
+// .sem       = { .release }
+// .scope     = { .cluster }
+// .space     = { .shared::cluster }
+template <typename=void>
+__device__ static inline void mbarrier_arrive(
+  cuda::ptx::sem_release_t,
+  cuda::ptx::scope_cluster_t,
+  cuda::ptx::space_cluster_t,
+  uint64_t* addr);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void mbarrier_arrive(
+  sem_release_t,
+  scope_cluster_t,
+  space_cluster_t,
+  _CUDA_VSTD::uint64_t* __addr)
+{
+  // __sem == sem_release (due to parameter type constraint)
+  // __scope == scope_cluster (due to parameter type constraint)
+  // __space == space_cluster (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "mbarrier.arrive.release.cluster.shared::cluster.b64                   _, [%0];                // 4a. "
+      :
+      : "r"(__as_ptr_smem(__addr))
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+/*
+// mbarrier.arrive{.sem}{.scope}{.space}.b64                   _, [addr], count;         // 4b.  PTX ISA 80, SM_90
+// .sem       = { .release }
+// .scope     = { .cluster }
+// .space     = { .shared::cluster }
+template <typename=void>
+__device__ static inline void mbarrier_arrive(
+  cuda::ptx::sem_release_t,
+  cuda::ptx::scope_cluster_t,
+  cuda::ptx::space_cluster_t,
+  uint64_t* addr,
+  const uint32_t& count);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void mbarrier_arrive(
+  sem_release_t,
+  scope_cluster_t,
+  space_cluster_t,
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __count)
+{
+  // __sem == sem_release (due to parameter type constraint)
+  // __scope == scope_cluster (due to parameter type constraint)
+  // __space == space_cluster (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "mbarrier.arrive.release.cluster.shared::cluster.b64                   _, [%0], %1;         // 4b. "
+      :
+      : "r"(__as_ptr_smem(__addr)),
+        "r"(__count)
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_mbarrier_arrive_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+/*
+// mbarrier.arrive.noComplete.shared.b64                       state,  [addr], count;    // 5.  PTX ISA 70, SM_80
+template <typename=void>
+__device__ static inline uint64_t mbarrier_arrive_no_complete(
+  uint64_t* addr,
+  const uint32_t& count);
+*/
+#if __cccl_ptx_isa >= 700
+extern "C" _LIBCUDACXX_DEVICE _CUDA_VSTD::uint64_t ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_no_complete_is_not_supported_before_SM_80__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline _CUDA_VSTD::uint64_t mbarrier_arrive_no_complete(
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __count)
+{
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_80,(
+    _CUDA_VSTD::uint64_t __state;
+    asm (
+      "mbarrier.arrive.noComplete.shared.b64                       %0,  [%1], %2;    // 5. "
+      : "=l"(__state)
+      : "r"(__as_ptr_smem(__addr)),
+        "r"(__count)
+      : "memory"
+    );
+    return __state;
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_no_complete_is_not_supported_before_SM_80__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 700
+
+/*
+// mbarrier.arrive.expect_tx{.sem}{.scope}{.space}.b64 state, [addr], tx_count; // 8.  PTX ISA 80, SM_90
+// .sem       = { .release }
+// .scope     = { .cta, .cluster }
+// .space     = { .shared::cta }
+template <cuda::ptx::dot_scope Scope>
+__device__ static inline uint64_t mbarrier_arrive_expect_tx(
+  cuda::ptx::sem_release_t,
+  cuda::ptx::scope_t<Scope> scope,
+  cuda::ptx::space_shared_t,
+  uint64_t* addr,
+  const uint32_t& tx_count);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE _CUDA_VSTD::uint64_t ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_expect_tx_is_not_supported_before_SM_90__();
+template <dot_scope _Scope>
+_LIBCUDACXX_DEVICE static inline _CUDA_VSTD::uint64_t mbarrier_arrive_expect_tx(
+  sem_release_t,
+  scope_t<_Scope> __scope,
+  space_shared_t,
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __tx_count)
+{
+  // __sem == sem_release (due to parameter type constraint)
+  static_assert(__scope == scope_cta || __scope == scope_cluster, "");
+  // __space == space_shared (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint64_t __state;
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cta) {
+      asm (
+        "mbarrier.arrive.expect_tx.release.cta.shared.b64 %0, [%1], %2; // 8. "
+        : "=l"(__state)
+        : "r"(__as_ptr_smem(__addr)),
+          "r"(__tx_count)
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cluster) {
+      asm (
+        "mbarrier.arrive.expect_tx.release.cluster.shared.b64 %0, [%1], %2; // 8. "
+        : "=l"(__state)
+        : "r"(__as_ptr_smem(__addr)),
+          "r"(__tx_count)
+        : "memory"
+      );
+    }
+    return __state;
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return ___cuda_vstd_uint64_t__cuda_ptx_mbarrier_arrive_expect_tx_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+/*
+// mbarrier.arrive.expect_tx{.sem}{.scope}{.space}.b64   _, [addr], tx_count; // 9.  PTX ISA 80, SM_90
+// .sem       = { .release }
+// .scope     = { .cluster }
+// .space     = { .shared::cluster }
+template <typename=void>
+__device__ static inline void mbarrier_arrive_expect_tx(
+  cuda::ptx::sem_release_t,
+  cuda::ptx::scope_cluster_t,
+  cuda::ptx::space_cluster_t,
+  uint64_t* addr,
+  const uint32_t& tx_count);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE void __void__cuda_ptx_mbarrier_arrive_expect_tx_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline void mbarrier_arrive_expect_tx(
+  sem_release_t,
+  scope_cluster_t,
+  space_cluster_t,
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __tx_count)
+{
+  // __sem == sem_release (due to parameter type constraint)
+  // __scope == scope_cluster (due to parameter type constraint)
+  // __space == space_cluster (due to parameter type constraint)
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    asm (
+      "mbarrier.arrive.expect_tx.release.cluster.shared::cluster.b64   _, [%0], %1; // 9. "
+      :
+      : "r"(__as_ptr_smem(__addr)),
+        "r"(__tx_count)
+      : "memory"
+    );
+
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __void__cuda_ptx_mbarrier_arrive_expect_tx_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+
+
+
+// 9.7.12.15.14. Parallel Synchronization and Communication Instructions: mbarrier.arrive_drop
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier-arrive-drop
+
+// 9.7.12.15.15. Parallel Synchronization and Communication Instructions: cp.async.mbarrier.arrive
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-cp-async-mbarrier-arrive
+
+// 9.7.12.15.16. Parallel Synchronization and Communication Instructions: mbarrier.test_wait/mbarrier.try_wait
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier-test-wait-mbarrier-try-wait
+
+/*
+// mbarrier.test_wait.shared.b64 waitComplete, [addr], state;                                                  // 1.  PTX ISA 70, SM_80
+template <typename=void>
+__device__ static inline bool mbarrier_test_wait(
+  uint64_t* addr,
+  const uint64_t& state);
+*/
+#if __cccl_ptx_isa >= 700
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_test_wait_is_not_supported_before_SM_80__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_test_wait(
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint64_t& __state)
+{
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_80,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    asm (
+      "{\n\t .reg .pred P_OUT; \n\t"
+      "mbarrier.test_wait.shared.b64 P_OUT, [%1], %2;                                                  // 1. \n\t"
+      "selp.b32 %0, 1, 0, P_OUT; \n"
+      "}"
+      : "=r"(__waitComplete)
+      : "r"(__as_ptr_smem(__addr)),
+        "l"(__state)
+      : "memory"
+    );
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_test_wait_is_not_supported_before_SM_80__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 700
+
+/*
+// mbarrier.test_wait{.sem}{.scope}.shared::cta.b64        waitComplete, [addr], state;                        // 2.   PTX ISA 80, SM_90
+// .sem       = { .acquire }
+// .scope     = { .cta, .cluster }
+template <cuda::ptx::dot_scope Scope>
+__device__ static inline bool mbarrier_test_wait(
+  cuda::ptx::sem_acquire_t,
+  cuda::ptx::scope_t<Scope> scope,
+  uint64_t* addr,
+  const uint64_t& state);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_test_wait_is_not_supported_before_SM_90__();
+template <dot_scope _Scope>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_test_wait(
+  sem_acquire_t,
+  scope_t<_Scope> __scope,
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint64_t& __state)
+{
+  // __sem == sem_acquire (due to parameter type constraint)
+  static_assert(__scope == scope_cta || __scope == scope_cluster, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cta) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.test_wait.acquire.cta.shared::cta.b64        P_OUT, [%1], %2;                        // 2.  \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "l"(__state)
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cluster) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.test_wait.acquire.cluster.shared::cta.b64        P_OUT, [%1], %2;                        // 2.  \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "l"(__state)
+        : "memory"
+      );
+    }
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_test_wait_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+/*
+// mbarrier.test_wait.parity.shared.b64 waitComplete, [addr], phaseParity;                                     // 3.  PTX ISA 71, SM_80
+template <typename=void>
+__device__ static inline bool mbarrier_test_wait_parity(
+  uint64_t* addr,
+  const uint32_t& phaseParity);
+*/
+#if __cccl_ptx_isa >= 710
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_test_wait_parity_is_not_supported_before_SM_80__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_test_wait_parity(
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __phaseParity)
+{
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_80,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    asm (
+      "{\n\t .reg .pred P_OUT; \n\t"
+      "mbarrier.test_wait.parity.shared.b64 P_OUT, [%1], %2;                                     // 3. \n\t"
+      "selp.b32 %0, 1, 0, P_OUT; \n"
+      "}"
+      : "=r"(__waitComplete)
+      : "r"(__as_ptr_smem(__addr)),
+        "r"(__phaseParity)
+      : "memory"
+    );
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_test_wait_parity_is_not_supported_before_SM_80__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 710
+
+/*
+// mbarrier.test_wait.parity{.sem}{.scope}.shared::cta.b64 waitComplete, [addr], phaseParity;                  // 4.  PTX ISA 80, SM_90
+// .sem       = { .acquire }
+// .scope     = { .cta, .cluster }
+template <cuda::ptx::dot_scope Scope>
+__device__ static inline bool mbarrier_test_wait_parity(
+  cuda::ptx::sem_acquire_t,
+  cuda::ptx::scope_t<Scope> scope,
+  uint64_t* addr,
+  const uint32_t& phaseParity);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_test_wait_parity_is_not_supported_before_SM_90__();
+template <dot_scope _Scope>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_test_wait_parity(
+  sem_acquire_t,
+  scope_t<_Scope> __scope,
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __phaseParity)
+{
+  // __sem == sem_acquire (due to parameter type constraint)
+  static_assert(__scope == scope_cta || __scope == scope_cluster, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cta) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.test_wait.parity.acquire.cta.shared::cta.b64 P_OUT, [%1], %2;                  // 4. \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "r"(__phaseParity)
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cluster) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.test_wait.parity.acquire.cluster.shared::cta.b64 P_OUT, [%1], %2;                  // 4. \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "r"(__phaseParity)
+        : "memory"
+      );
+    }
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_test_wait_parity_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+/*
+// mbarrier.try_wait.shared::cta.b64         waitComplete, [addr], state;                                      // 5a.  PTX ISA 78, SM_90
+template <typename=void>
+__device__ static inline bool mbarrier_try_wait(
+  uint64_t* addr,
+  const uint64_t& state);
+*/
+#if __cccl_ptx_isa >= 780
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_try_wait_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_try_wait(
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint64_t& __state)
+{
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    asm (
+      "{\n\t .reg .pred P_OUT; \n\t"
+      "mbarrier.try_wait.shared::cta.b64         P_OUT, [%1], %2;                                      // 5a. \n\t"
+      "selp.b32 %0, 1, 0, P_OUT; \n"
+      "}"
+      : "=r"(__waitComplete)
+      : "r"(__as_ptr_smem(__addr)),
+        "l"(__state)
+      : "memory"
+    );
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_try_wait_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 780
+
+/*
+// mbarrier.try_wait.shared::cta.b64         waitComplete, [addr], state, suspendTimeHint;                    // 5b.  PTX ISA 78, SM_90
+template <typename=void>
+__device__ static inline bool mbarrier_try_wait(
+  uint64_t* addr,
+  const uint64_t& state,
+  const uint32_t& suspendTimeHint);
+*/
+#if __cccl_ptx_isa >= 780
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_try_wait_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_try_wait(
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint64_t& __state,
+  const _CUDA_VSTD::uint32_t& __suspendTimeHint)
+{
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    asm (
+      "{\n\t .reg .pred P_OUT; \n\t"
+      "mbarrier.try_wait.shared::cta.b64         P_OUT, [%1], %2, %3;                    // 5b. \n\t"
+      "selp.b32 %0, 1, 0, P_OUT; \n"
+      "}"
+      : "=r"(__waitComplete)
+      : "r"(__as_ptr_smem(__addr)),
+        "l"(__state),
+        "r"(__suspendTimeHint)
+      : "memory"
+    );
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_try_wait_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 780
+
+/*
+// mbarrier.try_wait{.sem}{.scope}.shared::cta.b64         waitComplete, [addr], state;                        // 6a.  PTX ISA 80, SM_90
+// .sem       = { .acquire }
+// .scope     = { .cta, .cluster }
+template <cuda::ptx::dot_scope Scope>
+__device__ static inline bool mbarrier_try_wait(
+  cuda::ptx::sem_acquire_t,
+  cuda::ptx::scope_t<Scope> scope,
+  uint64_t* addr,
+  const uint64_t& state);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_try_wait_is_not_supported_before_SM_90__();
+template <dot_scope _Scope>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_try_wait(
+  sem_acquire_t,
+  scope_t<_Scope> __scope,
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint64_t& __state)
+{
+  // __sem == sem_acquire (due to parameter type constraint)
+  static_assert(__scope == scope_cta || __scope == scope_cluster, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cta) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.try_wait.acquire.cta.shared::cta.b64         P_OUT, [%1], %2;                        // 6a. \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "l"(__state)
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cluster) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.try_wait.acquire.cluster.shared::cta.b64         P_OUT, [%1], %2;                        // 6a. \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "l"(__state)
+        : "memory"
+      );
+    }
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_try_wait_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+/*
+// mbarrier.try_wait{.sem}{.scope}.shared::cta.b64         waitComplete, [addr], state , suspendTimeHint;      // 6b.  PTX ISA 80, SM_90
+// .sem       = { .acquire }
+// .scope     = { .cta, .cluster }
+template <cuda::ptx::dot_scope Scope>
+__device__ static inline bool mbarrier_try_wait(
+  cuda::ptx::sem_acquire_t,
+  cuda::ptx::scope_t<Scope> scope,
+  uint64_t* addr,
+  const uint64_t& state,
+  const uint32_t& suspendTimeHint);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_try_wait_is_not_supported_before_SM_90__();
+template <dot_scope _Scope>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_try_wait(
+  sem_acquire_t,
+  scope_t<_Scope> __scope,
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint64_t& __state,
+  const _CUDA_VSTD::uint32_t& __suspendTimeHint)
+{
+  // __sem == sem_acquire (due to parameter type constraint)
+  static_assert(__scope == scope_cta || __scope == scope_cluster, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cta) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.try_wait.acquire.cta.shared::cta.b64         P_OUT, [%1], %2 , %3;      // 6b. \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "l"(__state),
+          "r"(__suspendTimeHint)
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cluster) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.try_wait.acquire.cluster.shared::cta.b64         P_OUT, [%1], %2 , %3;      // 6b. \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "l"(__state),
+          "r"(__suspendTimeHint)
+        : "memory"
+      );
+    }
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_try_wait_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+/*
+// mbarrier.try_wait.parity.shared::cta.b64  waitComplete, [addr], phaseParity;                                // 7a.  PTX ISA 78, SM_90
+template <typename=void>
+__device__ static inline bool mbarrier_try_wait_parity(
+  uint64_t* addr,
+  const uint32_t& phaseParity);
+*/
+#if __cccl_ptx_isa >= 780
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_try_wait_parity_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_try_wait_parity(
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __phaseParity)
+{
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    asm (
+      "{\n\t .reg .pred P_OUT; \n\t"
+      "mbarrier.try_wait.parity.shared::cta.b64  P_OUT, [%1], %2;                                // 7a. \n\t"
+      "selp.b32 %0, 1, 0, P_OUT; \n"
+      "}"
+      : "=r"(__waitComplete)
+      : "r"(__as_ptr_smem(__addr)),
+        "r"(__phaseParity)
+      : "memory"
+    );
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_try_wait_parity_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 780
+
+/*
+// mbarrier.try_wait.parity.shared::cta.b64  waitComplete, [addr], phaseParity, suspendTimeHint;               // 7b.  PTX ISA 78, SM_90
+template <typename=void>
+__device__ static inline bool mbarrier_try_wait_parity(
+  uint64_t* addr,
+  const uint32_t& phaseParity,
+  const uint32_t& suspendTimeHint);
+*/
+#if __cccl_ptx_isa >= 780
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_try_wait_parity_is_not_supported_before_SM_90__();
+template <typename=void>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_try_wait_parity(
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __phaseParity,
+  const _CUDA_VSTD::uint32_t& __suspendTimeHint)
+{
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    asm (
+      "{\n\t .reg .pred P_OUT; \n\t"
+      "mbarrier.try_wait.parity.shared::cta.b64  P_OUT, [%1], %2, %3;               // 7b. \n\t"
+      "selp.b32 %0, 1, 0, P_OUT; \n"
+      "}"
+      : "=r"(__waitComplete)
+      : "r"(__as_ptr_smem(__addr)),
+        "r"(__phaseParity),
+        "r"(__suspendTimeHint)
+      : "memory"
+    );
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_try_wait_parity_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 780
+
+/*
+// mbarrier.try_wait.parity{.sem}{.scope}.shared::cta.b64  waitComplete, [addr], phaseParity;                  // 8a.  PTX ISA 80, SM_90
+// .sem       = { .acquire }
+// .scope     = { .cta, .cluster }
+template <cuda::ptx::dot_scope Scope>
+__device__ static inline bool mbarrier_try_wait_parity(
+  cuda::ptx::sem_acquire_t,
+  cuda::ptx::scope_t<Scope> scope,
+  uint64_t* addr,
+  const uint32_t& phaseParity);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_try_wait_parity_is_not_supported_before_SM_90__();
+template <dot_scope _Scope>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_try_wait_parity(
+  sem_acquire_t,
+  scope_t<_Scope> __scope,
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __phaseParity)
+{
+  // __sem == sem_acquire (due to parameter type constraint)
+  static_assert(__scope == scope_cta || __scope == scope_cluster, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cta) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.try_wait.parity.acquire.cta.shared::cta.b64  P_OUT, [%1], %2;                  // 8a. \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "r"(__phaseParity)
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cluster) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.try_wait.parity.acquire.cluster.shared::cta.b64  P_OUT, [%1], %2;                  // 8a. \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "r"(__phaseParity)
+        : "memory"
+      );
+    }
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_try_wait_parity_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+/*
+// mbarrier.try_wait.parity{.sem}{.scope}.shared::cta.b64  waitComplete, [addr], phaseParity, suspendTimeHint; // 8b.  PTX ISA 80, SM_90
+// .sem       = { .acquire }
+// .scope     = { .cta, .cluster }
+template <cuda::ptx::dot_scope Scope>
+__device__ static inline bool mbarrier_try_wait_parity(
+  cuda::ptx::sem_acquire_t,
+  cuda::ptx::scope_t<Scope> scope,
+  uint64_t* addr,
+  const uint32_t& phaseParity,
+  const uint32_t& suspendTimeHint);
+*/
+#if __cccl_ptx_isa >= 800
+extern "C" _LIBCUDACXX_DEVICE bool __bool__cuda_ptx_mbarrier_try_wait_parity_is_not_supported_before_SM_90__();
+template <dot_scope _Scope>
+_LIBCUDACXX_DEVICE static inline bool mbarrier_try_wait_parity(
+  sem_acquire_t,
+  scope_t<_Scope> __scope,
+  _CUDA_VSTD::uint64_t* __addr,
+  const _CUDA_VSTD::uint32_t& __phaseParity,
+  const _CUDA_VSTD::uint32_t& __suspendTimeHint)
+{
+  // __sem == sem_acquire (due to parameter type constraint)
+  static_assert(__scope == scope_cta || __scope == scope_cluster, "");
+
+  NV_IF_ELSE_TARGET(NV_PROVIDES_SM_90,(
+    _CUDA_VSTD::uint32_t __waitComplete;
+    if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cta) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.try_wait.parity.acquire.cta.shared::cta.b64  P_OUT, [%1], %2, %3; // 8b. \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "r"(__phaseParity),
+          "r"(__suspendTimeHint)
+        : "memory"
+      );
+    } else if _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 (__scope == scope_cluster) {
+      asm (
+        "{\n\t .reg .pred P_OUT; \n\t"
+        "mbarrier.try_wait.parity.acquire.cluster.shared::cta.b64  P_OUT, [%1], %2, %3; // 8b. \n\t"
+        "selp.b32 %0, 1, 0, P_OUT; \n"
+        "}"
+        : "=r"(__waitComplete)
+        : "r"(__as_ptr_smem(__addr)),
+          "r"(__phaseParity),
+          "r"(__suspendTimeHint)
+        : "memory"
+      );
+    }
+    return static_cast<bool>(__waitComplete); // Deliberate downcast.
+  ),(
+    // Unsupported architectures will have a linker error with a semi-decent error message
+    return __bool__cuda_ptx_mbarrier_try_wait_parity_is_not_supported_before_SM_90__();
+  ));
+}
+#endif // __cccl_ptx_isa >= 800
+
+
+// 9.7.12.15.17. Parallel Synchronization and Communication Instructions: mbarrier.pending_count
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier-pending-count
+
+_LIBCUDACXX_END_NAMESPACE_CUDA_PTX
+
+#endif // _CUDA_PTX_PARALLEL_SYNCHRONIZATION_AND_COMMUNICATION_INSTRUCTIONS_MBARRIER_H_

cuda_toolkit/include/__cuda/ptx/ptx_dot_variants.h

@@ -0,0 +1,176 @@
+// -*- 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 _CUDA_PTX_DOT_VARIANTS_H_
+#define _CUDA_PTX_DOT_VARIANTS_H_
+
+#include "../../__type_traits/integral_constant.h" // std::integral_constant
+
+#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
+
+/*
+ * Public integral constant types and values for ".variant"s:
+ *
+ * - .sem:     acquire, release, ..
+ * - .space:   global, shared, constant, ..
+ * - .scope:   cta, cluster, gpu, ..
+ * - .op:      add, min, cas, ..
+ *
+ * For each .variant, the code below defines:
+ * - An enum `dot_variant` with each possible value
+ * - A type template `variant_t<dot_variant>`
+ * - Types `variant_A_t`, ..., `variant_Z_t`
+ * - Constexpr values `variant_A` of type `variant_A_t`
+ *
+ * These types enable specifying fine-grained overloads of a PTX binding. If a
+ * binding can handle multiple variants, then it is defined as:
+ *
+ * template <dot_variant var>
+ * [...] void ptx_binding(variant_t<var> __v) { ... }
+ *
+ * If it only handles a single variant, then it is defined as:
+ *
+ * [...] void ptx_binding(variant_A __v) { ... }
+ *
+ * If two variants have different behaviors or return types (see .space
+ * overloads of mbarrier.arrive.expect_tx for an example), then these can be
+ * provided as separate overloads of the same function:
+ *
+ * [...] void ptx_binding(variant_A __v) { ... }
+ * [...] int ptx_binding(variant_B __v) { ... }
+ *
+ */
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA_PTX
+
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#operation-types
+enum class dot_sem
+{
+  acq_rel,
+  acquire,
+  relaxed,
+  release,
+  sc,
+  weak
+};
+
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#state-spaces
+enum class dot_space
+{
+  global,
+  cluster, // The PTX spelling is shared::cluster
+  shared,  // The PTX spelling is shared::cta
+
+  // The following state spaces are unlikely to be used in cuda::ptx in the near
+  // future, so they are not exposed:
+
+  // reg,
+  // sreg,
+  // const_mem, // Using const_mem as `const` is reserved in C++.
+  // local,
+  // param,
+  // tex // deprecated
+};
+
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#scope
+enum class dot_scope
+{
+  cta,
+  cluster,
+  gpu,
+  sys
+};
+
+enum class dot_op
+{
+  add,
+  dec,
+  inc,
+  max,
+  min,
+  and_op, // Using and_op, as `and, or, xor` are reserved in C++.
+  or_op,
+  xor_op,
+  cas,
+  exch
+};
+
+template <dot_sem __sem>
+using sem_t         = _CUDA_VSTD::integral_constant<dot_sem, __sem>;
+using sem_acq_rel_t = sem_t<dot_sem::acq_rel>;
+using sem_acquire_t = sem_t<dot_sem::acquire>;
+using sem_relaxed_t = sem_t<dot_sem::relaxed>;
+using sem_release_t = sem_t<dot_sem::release>;
+using sem_sc_t      = sem_t<dot_sem::sc>;
+using sem_weak_t    = sem_t<dot_sem::weak>;
+
+static constexpr sem_acq_rel_t sem_acq_rel{};
+static constexpr sem_acquire_t sem_acquire{};
+static constexpr sem_relaxed_t sem_relaxed{};
+static constexpr sem_release_t sem_release{};
+static constexpr sem_sc_t sem_sc{};
+static constexpr sem_weak_t sem_weak{};
+
+template <dot_space __spc>
+using space_t         = _CUDA_VSTD::integral_constant<dot_space, __spc>;
+using space_global_t  = space_t<dot_space::global>;
+using space_shared_t  = space_t<dot_space::shared>;
+using space_cluster_t = space_t<dot_space::cluster>;
+
+static constexpr space_global_t space_global{};
+static constexpr space_shared_t space_shared{};
+static constexpr space_cluster_t space_cluster{};
+
+template <dot_scope __scope>
+using scope_t         = _CUDA_VSTD::integral_constant<dot_scope, __scope>;
+using scope_cluster_t = scope_t<dot_scope::cluster>;
+using scope_cta_t     = scope_t<dot_scope::cta>;
+using scope_gpu_t     = scope_t<dot_scope::gpu>;
+using scope_sys_t     = scope_t<dot_scope::sys>;
+
+static constexpr scope_cluster_t scope_cluster{};
+static constexpr scope_cta_t scope_cta{};
+static constexpr scope_gpu_t scope_gpu{};
+static constexpr scope_sys_t scope_sys{};
+
+template <dot_op __op>
+using op_t        = _CUDA_VSTD::integral_constant<dot_op, __op>;
+using op_add_t    = op_t<dot_op::add>;
+using op_dec_t    = op_t<dot_op::dec>;
+using op_inc_t    = op_t<dot_op::inc>;
+using op_max_t    = op_t<dot_op::max>;
+using op_min_t    = op_t<dot_op::min>;
+using op_and_op_t = op_t<dot_op::and_op>;
+using op_or_op_t  = op_t<dot_op::or_op>;
+using op_xor_op_t = op_t<dot_op::xor_op>;
+using op_cas_t    = op_t<dot_op::cas>;
+using op_exch_t   = op_t<dot_op::exch>;
+
+static constexpr op_add_t op_add{};
+static constexpr op_dec_t op_dec{};
+static constexpr op_inc_t op_inc{};
+static constexpr op_max_t op_max{};
+static constexpr op_min_t op_min{};
+static constexpr op_and_op_t op_and_op{};
+static constexpr op_or_op_t op_or_op{};
+static constexpr op_xor_op_t op_xor_op{};
+static constexpr op_cas_t op_cas{};
+static constexpr op_exch_t op_exch{};
+
+_LIBCUDACXX_END_NAMESPACE_CUDA_PTX
+
+#endif // _CUDA_PTX_DOT_VARIANTS_H_

cuda_toolkit/include/__cuda/ptx/ptx_helper_functions.h

@@ -0,0 +1,68 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_PTX_HELPER_FUNCTIONS_H_
+#define _CUDA_PTX_HELPER_FUNCTIONS_H_
+
+#include "../../cstdint"        // uint32_t
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA_PTX
+
+inline _LIBCUDACXX_DEVICE _CUDA_VSTD::uint32_t __as_ptr_smem(const void* __ptr)
+{
+  // Consider adding debug asserts here.
+  return static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(__ptr));
+}
+
+inline _LIBCUDACXX_DEVICE _CUDA_VSTD::uint32_t __as_ptr_remote_dsmem(const void* __ptr)
+{
+  // No difference in implementation to __as_ptr_smem.
+  // Consider adding debug asserts here.
+  return static_cast<_CUDA_VSTD::uint32_t>(__cvta_generic_to_shared(__ptr));
+}
+
+inline _LIBCUDACXX_DEVICE _CUDA_VSTD::uint64_t __as_ptr_gmem(const void* __ptr)
+{
+  // Consider adding debug asserts here.
+  return static_cast<_CUDA_VSTD::uint64_t>(__cvta_generic_to_global(__ptr));
+}
+
+template <typename _Tp>
+inline _LIBCUDACXX_DEVICE _CUDA_VSTD::uint32_t __as_b32(_Tp __val)
+{
+#if _LIBCUDACXX_STD_VER >= 17 && !defined(_LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR)
+  static_assert(sizeof(_Tp) == 4, "");
+#endif // _LIBCUDACXX_STD_VER >= 17  && !_LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR
+  // Consider using std::bitcast
+  return *reinterpret_cast<_CUDA_VSTD::uint32_t*>(&__val);
+}
+
+template <typename _Tp>
+inline _LIBCUDACXX_DEVICE _CUDA_VSTD::uint64_t __as_b64(_Tp __val)
+{
+#if _LIBCUDACXX_STD_VER >= 17 && !defined(_LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR)
+  static_assert(sizeof(_Tp) == 8, "");
+#endif // _LIBCUDACXX_STD_VER >= 17 && !_LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR
+  // Consider using std::bitcast
+  return *reinterpret_cast<_CUDA_VSTD::uint64_t*>(&__val);
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA_PTX
+
+#endif // _CUDA_PTX_HELPER_FUNCTIONS_H_

cuda_toolkit/include/__cuda/semaphore.h

@@ -0,0 +1,46 @@
+// -*- 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___CUDA_SEMAPHORE_H
+#define _LIBCUDACXX___CUDA_SEMAPHORE_H
+
+#ifndef __cuda_std__
+#error "<__cuda/semaphore> should only be included in from <cuda/std/semaphore>"
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+template<thread_scope _Sco, ptrdiff_t __least_max_value = INT_MAX>
+class counting_semaphore : public _CUDA_VSTD::__semaphore_base<__least_max_value, _Sco>
+{
+    static_assert(__least_max_value <= _CUDA_VSTD::__semaphore_base<__least_max_value, _Sco>::max(), "");
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    counting_semaphore(ptrdiff_t __count = 0) : _CUDA_VSTD::__semaphore_base<__least_max_value, _Sco>(__count) { }
+    ~counting_semaphore() = default;
+
+    counting_semaphore(const counting_semaphore&) = delete;
+    counting_semaphore& operator=(const counting_semaphore&) = delete;
+};
+
+template<thread_scope _Sco>
+using binary_semaphore = counting_semaphore<_Sco, 1>;
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#endif // _LIBCUDACXX___CUDA_SEMAPHORE_H

cuda_toolkit/include/__expected/bad_expected_access.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) 2022 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCUDACXX___EXPECTED_BAD_EXPECTED_ACCESS_H
+#define _LIBCUDACXX___EXPECTED_BAD_EXPECTED_ACCESS_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#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 "../__utility/move.h"
+#include "../exception"
+
+#if _LIBCUDACXX_STD_VER  > 11
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Err>
+class bad_expected_access;
+
+template <>
+class bad_expected_access<void> : public exception {
+protected:
+  bad_expected_access() noexcept                             = default;
+  bad_expected_access(const bad_expected_access&)            = default;
+  bad_expected_access(bad_expected_access&&)                 = default;
+  bad_expected_access& operator=(const bad_expected_access&) = default;
+  bad_expected_access& operator=(bad_expected_access&&)      = default;
+  ~bad_expected_access() noexcept override                   = default;
+
+public:
+  // The way this has been designed (by using a class template below) means that we'll already
+  // have a profusion of these vtables in TUs, and the dynamic linker will already have a bunch
+  // of work to do. So it is not worth hiding the <void> specialization in the dylib, given that
+  // it adds deployment target restrictions.
+  _LIBCUDACXX_INLINE_VISIBILITY
+  const char* what() const noexcept override { return "bad access to std::expected"; }
+};
+
+template <class _Err>
+class bad_expected_access : public bad_expected_access<void> {
+public:
+  _LIBCUDACXX_INLINE_VISIBILITY
+  explicit bad_expected_access(_Err __e) : __unex_(_CUDA_VSTD::move(__e)) {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  _Err& error() & noexcept { return __unex_; }
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  const _Err& error() const& noexcept { return __unex_; }
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  _Err&& error() && noexcept { return _CUDA_VSTD::move(__unex_); }
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  const _Err&& error() const&& noexcept { return _CUDA_VSTD::move(__unex_); }
+
+private:
+  _Err __unex_;
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+#endif // _LIBCUDACXX___EXPECTED_BAD_EXPECTED_ACCESS_H

cuda_toolkit/include/__expected/expected.h

@@ -0,0 +1,1790 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCUDACXX___EXPECTED_EXPECTED_H
+#define _LIBCUDACXX___EXPECTED_EXPECTED_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__assert"
+#include "../__concepts/invocable.h"
+#ifndef _LIBCUDACXX_NO_EXCEPTIONS
+#include "../__expected/bad_expected_access.h"
+#endif // _LIBCUDACXX_NO_EXCEPTIONS
+#include "../__expected/expected_base.h"
+#include "../__expected/unexpect.h"
+#include "../__expected/unexpected.h"
+#include "../__memory/addressof.h"
+#include "../__memory/construct_at.h"
+#include "../__type_traits/conjunction.h"
+#include "../__type_traits/disjunction.h"
+#include "../__type_traits/is_assignable.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_copy_assignable.h"
+#include "../__type_traits/is_copy_constructible.h"
+#include "../__type_traits/is_default_constructible.h"
+#include "../__type_traits/is_function.h"
+#include "../__type_traits/is_move_assignable.h"
+#include "../__type_traits/is_move_constructible.h"
+#include "../__type_traits/is_nothrow_constructible.h"
+#include "../__type_traits/is_nothrow_copy_assignable.h"
+#include "../__type_traits/is_nothrow_copy_constructible.h"
+#include "../__type_traits/is_nothrow_default_constructible.h"
+#include "../__type_traits/is_nothrow_move_assignable.h"
+#include "../__type_traits/is_nothrow_move_constructible.h"
+#include "../__type_traits/is_reference.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/is_swappable.h"
+#include "../__type_traits/is_trivially_copy_constructible.h"
+#include "../__type_traits/is_trivially_destructible.h"
+#include "../__type_traits/is_trivially_move_constructible.h"
+#include "../__type_traits/is_void.h"
+#include "../__type_traits/lazy.h"
+#include "../__type_traits/negation.h"
+#include "../__type_traits/remove_cv.h"
+#include "../__type_traits/remove_cvref.h"
+#include "../__utility/exception_guard.h"
+#include "../__utility/forward.h"
+#include "../__utility/in_place.h"
+#include "../__utility/move.h"
+#include "../__utility/swap.h"
+
+#include "../cstdlib"
+#include "../initializer_list"
+
+#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 _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Err>
+class expected;
+
+namespace __expected {
+
+  template <class _Err, class _Arg>
+  _LIBCUDACXX_INLINE_VISIBILITY
+  void __throw_bad_expected_access(_Arg&& __arg) {
+#ifndef _LIBCUDACXX_NO_EXCEPTIONS
+    throw _CUDA_STD::bad_expected_access<_Err>(_CUDA_VSTD::forward<_Arg>(__arg));
+#else
+    (void)__arg;
+    _LIBCUDACXX_UNREACHABLE();
+#endif // _LIBCUDACXX_NO_EXCEPTIONS
+  }
+
+  template <class _Tp, class _Err>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __valid_expected =
+    !_LIBCUDACXX_TRAIT(is_reference, _Tp) &&
+    !_LIBCUDACXX_TRAIT(is_function, _Tp) &&
+    !_LIBCUDACXX_TRAIT(is_same, __remove_cv_t<_Tp>, in_place_t) &&
+    !_LIBCUDACXX_TRAIT(is_same, __remove_cv_t<_Tp>, unexpect_t) &&
+    !__unexpected::__is_unexpected<__remove_cv_t<_Tp>> &&
+    __unexpected::__valid_unexpected<_Err>;
+
+  template <class _Tp>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __is_expected = false;
+
+  template <class _Tp, class _Err>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __is_expected<expected<_Tp, _Err>> = true;
+
+  template <class _Tp>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __is_expected_nonvoid = __is_expected<_Tp>;
+
+  template <class _Err>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __is_expected_nonvoid<expected<void, _Err>> = false;
+
+  template<class _Tp, class _Err>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __can_swap =
+       _LIBCUDACXX_TRAIT(is_swappable, _Tp)
+    && _LIBCUDACXX_TRAIT(is_swappable, _Err)
+    && _LIBCUDACXX_TRAIT(is_move_constructible, _Tp)
+    && _LIBCUDACXX_TRAIT(is_move_constructible, _Err)
+    && (_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp)
+    || _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err));
+
+  template<class _Err>
+  _LIBCUDACXX_INLINE_VAR constexpr bool __can_swap<void, _Err> =
+       _LIBCUDACXX_TRAIT(is_swappable, _Err)
+    && _LIBCUDACXX_TRAIT(is_move_constructible, _Err);
+} // namespace __expected
+
+template <class _Tp, class _Err>
+class expected : private __expected_move_assign<_Tp, _Err>
+               , private __expected_sfinae_ctor_base_t<_Tp, _Err>
+               , private __expected_sfinae_assign_base_t<_Tp, _Err>
+{
+  using __base = __expected_move_assign<_Tp, _Err>;
+
+  static_assert(__expected::__valid_expected<_Tp, _Err>,
+      "[expected.object.general] A program that instantiates the definition of template expected<T, E> for a "
+      "reference type, a function type, or for possibly cv-qualified types in_place_t, unexpect_t, or a "
+      "specialization of unexpected for the T parameter is ill-formed. A program that instantiates the "
+      "definition of the template expected<T, E> with a type for the E parameter that is not a valid "
+      "template argument for unexpected is ill-formed.");
+
+  template <class, class>
+  friend class expected;
+
+public:
+  using value_type      = _Tp;
+  using error_type      = _Err;
+  using unexpected_type = unexpected<_Err>;
+
+  template <class _Up>
+  using rebind = expected<_Up, error_type>;
+
+  // [expected.object.ctor], constructors
+  _LIBCUDACXX_TEMPLATE(class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_default_constructible, _Tp2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  expected() noexcept(_LIBCUDACXX_TRAIT(is_nothrow_default_constructible, _Tp2))
+    : __base(true)
+  {}
+
+  constexpr expected(const expected&) = default;
+  constexpr expected(expected&&) = default;
+  constexpr expected& operator=(const expected&) = default;
+  constexpr expected& operator=(expected&&) = default;
+
+private:
+  template <class _Up, class _OtherErr, class _UfQual, class _OtherErrQual>
+  using __can_convert =
+      _And< is_constructible<_Tp, _UfQual>,
+            is_constructible<_Err, _OtherErrQual>,
+            _Not<is_constructible<_Tp, expected<_Up, _OtherErr>&>>,
+            _Not<is_constructible<_Tp, expected<_Up, _OtherErr>>>,
+            _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>&>>,
+            _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>>>,
+            _Not<is_convertible<expected<_Up, _OtherErr>&, _Tp>>,
+            _Not<is_convertible<expected<_Up, _OtherErr>&&, _Tp>>,
+            _Not<is_convertible<const expected<_Up, _OtherErr>&, _Tp>>,
+            _Not<is_convertible<const expected<_Up, _OtherErr>&&, _Tp>>,
+            _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>,
+            _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>,
+            _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>,
+            _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>> >;
+
+
+public:
+  _LIBCUDACXX_TEMPLATE(class _Up, class _OtherErr)
+    _LIBCUDACXX_REQUIRES( __can_convert<_Up, _OtherErr, const _Up&, const _OtherErr&>::value _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, const _Up&, _Tp) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, const _OtherErr&, _Err)
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  expected(const expected<_Up, _OtherErr>& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, const _Up&) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, const _OtherErr&)) // strengthened
+    : __base(__other.__has_val_)
+  {
+    if (__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__val_, __other.__union_.__val_);
+    } else {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, __other.__union_.__unex_);
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class _OtherErr)
+    _LIBCUDACXX_REQUIRES( __can_convert<_Up, _OtherErr, const _Up&, const _OtherErr&>::value _LIBCUDACXX_AND
+              (!_LIBCUDACXX_TRAIT(is_convertible, const _Up&, _Tp) || !_LIBCUDACXX_TRAIT(is_convertible, const _OtherErr&, _Err))
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  explicit expected(const expected<_Up, _OtherErr>& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, const _Up&) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, const _OtherErr&)) // strengthened
+    : __base(__other.__has_val_)
+  {
+    if (__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__val_, __other.__union_.__val_);
+    } else {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, __other.__union_.__unex_);
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class _OtherErr)
+    _LIBCUDACXX_REQUIRES( __can_convert<_Up, _OtherErr, _Up, _OtherErr>::value _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, _Up, _Tp) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, _OtherErr, _Err)
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  expected(expected<_Up, _OtherErr>&& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Up) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _OtherErr)) // strengthened
+    : __base(__other.__has_val_)
+  {
+    if (__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__val_, _CUDA_VSTD::move(__other.__union_.__val_));
+    } else {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, _CUDA_VSTD::move(__other.__union_.__unex_));
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class _OtherErr)
+    _LIBCUDACXX_REQUIRES( __can_convert<_Up, _OtherErr, _Up, _OtherErr>::value _LIBCUDACXX_AND
+              (!_LIBCUDACXX_TRAIT(is_convertible, _Up, _Tp) || !_LIBCUDACXX_TRAIT(is_convertible, _OtherErr, _Err))
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  explicit expected(expected<_Up, _OtherErr>&& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Up) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _OtherErr)) // strengthened
+    : __base(__other.__has_val_)
+  {
+    if (__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__val_, _CUDA_VSTD::move(__other.__union_.__val_));
+    } else {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, _CUDA_VSTD::move(__other.__union_.__unex_));
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Up = _Tp)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_same, __remove_cvref_t<_Up>, in_place_t)) _LIBCUDACXX_AND
+              (!_LIBCUDACXX_TRAIT(is_same, expected, __remove_cvref_t<_Up>)) _LIBCUDACXX_AND
+              (!__unexpected::__is_unexpected<__remove_cvref_t<_Up>>) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_constructible, _Tp, _Up) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, _Up, _Tp)
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  expected(_Up&& __u) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Up)) // strengthened
+    : __base(in_place, _CUDA_VSTD::forward<_Up>(__u))
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class _Up = _Tp)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_same, __remove_cvref_t<_Up>, in_place_t)) _LIBCUDACXX_AND
+              (!_LIBCUDACXX_TRAIT(is_same, expected, __remove_cvref_t<_Up>)) _LIBCUDACXX_AND
+              (!__unexpected::__is_unexpected<__remove_cvref_t<_Up>>) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_constructible, _Tp, _Up) _LIBCUDACXX_AND
+              (!_LIBCUDACXX_TRAIT(is_convertible, _Up, _Tp))
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(_Up&& __u) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Up)) // strengthened
+    : __base(in_place, _CUDA_VSTD::forward<_Up>(__u))
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, const _OtherErr&) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, const _OtherErr&, _Err)
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  expected(const unexpected<_OtherErr>& __unex) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, const _OtherErr&)) // strengthened
+    : __base(unexpect, __unex.error())
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, const _OtherErr&) _LIBCUDACXX_AND
+              (!_LIBCUDACXX_TRAIT(is_convertible, const _OtherErr&, _Err))
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(const unexpected<_OtherErr>& __unex) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, const _OtherErr&)) // strengthened
+    : __base(unexpect, __unex.error())
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, _OtherErr) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, _OtherErr, _Err)
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  expected(unexpected<_OtherErr>&& __unex) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _OtherErr)) // strengthened
+    : __base(unexpect, _CUDA_VSTD::move(__unex.error()))
+  {}
+
+
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, _OtherErr) _LIBCUDACXX_AND
+              (!_LIBCUDACXX_TRAIT(is_convertible, _OtherErr, _Err))
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(unexpected<_OtherErr>&& __unex) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _OtherErr)) // strengthened
+    : __base(unexpect, _CUDA_VSTD::move(__unex.error()))
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Tp, _Args...))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(in_place_t, _Args&&... __args) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...)) // strengthened
+    : __base(in_place, _CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Tp, initializer_list<_Up>&, _Args...))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, initializer_list<_Up>&, _Args...)) // strengthened
+    : __base(in_place, __il, _CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, _Args...))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(unexpect_t, _Args&&... __args) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...))  // strengthened
+    : __base(unexpect, _CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, initializer_list<_Up>&, _Args...))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, initializer_list<_Up>&, _Args...)) // strengthened
+    : __base(unexpect, __il, _CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+
+private:
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  expected(__expected_construct_from_invoke_tag, in_place_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, invoke_result_t<_Fun, _Args...>))
+    : __base(__expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  expected(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+    : __base(__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+
+public:
+  // [expected.object.assign], assignment
+  _LIBCUDACXX_TEMPLATE(class _Up = _Tp)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_same, expected, __remove_cvref_t<_Up>)) _LIBCUDACXX_AND
+              (!__unexpected::__is_unexpected<__remove_cvref_t<_Up>>) _LIBCUDACXX_AND
+               _LIBCUDACXX_TRAIT(is_constructible, _Tp, _Up) _LIBCUDACXX_AND
+               _LIBCUDACXX_TRAIT(is_assignable, _Tp&, _Up) _LIBCUDACXX_AND
+              (_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Up) ||
+               _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp) ||
+               _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err))
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  expected& operator=(_Up&& __v) {
+    if (this->__has_val_) {
+      this->__union_.__val_ = _CUDA_VSTD::forward<_Up>(__v);
+    } else {
+      this->__reinit_expected(this->__union_.__val_, this->__union_.__unex_, _CUDA_VSTD::forward<_Up>(__v));
+      this->__has_val_ = true;
+    }
+    return *this;
+  }
+
+private:
+  template <class _OtherErrQual>
+  static constexpr bool __can_assign_from_unexpected =
+      _And< is_constructible<_Err, _OtherErrQual>,
+            is_assignable<_Err&, _OtherErrQual>,
+            _Lazy<_Or,
+                  is_nothrow_constructible<_Err, _OtherErrQual>,
+                  is_nothrow_move_constructible<_Tp>,
+                  is_nothrow_move_constructible<_Err>> >::value;
+
+public:
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( __can_assign_from_unexpected<const _OtherErr&>)
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  expected& operator=(const unexpected<_OtherErr>& __un) {
+    if (this->__has_val_) {
+      this->__reinit_expected(this->__union_.__unex_, this->__union_.__val_, __un.error());
+      this->__has_val_ = false;
+    } else {
+      this->__union_.__unex_ = __un.error();
+    }
+    return *this;
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( __can_assign_from_unexpected<_OtherErr>)
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  expected& operator=(unexpected<_OtherErr>&& __un) {
+    if (this->__has_val_) {
+      this->__reinit_expected(this->__union_.__unex_, this->__union_.__val_, _CUDA_VSTD::move(__un.error()));
+      this->__has_val_ = false;
+    } else {
+      this->__union_.__unex_ = _CUDA_VSTD::move(__un.error());
+    }
+    return *this;
+  }
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  _Tp& emplace(_Args&&... __args) noexcept {
+    if (this->__has_val_) {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(this->__union_.__val_));
+    } else {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(this->__union_.__unex_));
+      this->__has_val_ = true;
+    }
+    return *_LIBCUDACXX_CONSTRUCT_AT(this->__union_.__val_, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, initializer_list<_Up>&, _Args...))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) noexcept {
+    if (this->__has_val_) {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(this->__union_.__val_));
+    } else {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(this->__union_.__unex_));
+      this->__has_val_ = true;
+    }
+    return *_LIBCUDACXX_CONSTRUCT_AT(this->__union_.__val_, __il, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+
+
+public:
+  // [expected.object.swap], swap
+  _LIBCUDACXX_TEMPLATE(class _Tp2 = _Tp, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( __expected::__can_swap<_Tp2, _Err2>)
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  void swap(expected<_Tp2, _Err>& __rhs)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp2) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_swappable, _Tp2) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_swappable, _Err))
+  {
+    if (this->__has_val_) {
+      if (__rhs.__has_val_) {
+        using _CUDA_VSTD::swap;
+        swap(this->__union_.__val_, __rhs.__union_.__val_);
+      } else {
+        this->__swap_val_unex_impl(*this, __rhs);
+      }
+    } else {
+      if (__rhs.__has_val_) {
+        this->__swap_val_unex_impl(__rhs, *this);
+      } else {
+        using _CUDA_VSTD::swap;
+        swap(this->__union_.__unex_, __rhs.__union_.__unex_);
+      }
+    }
+  }
+
+  template<class _Tp2 = _Tp, class _Err2 = _Err>
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  auto swap(expected& __x, expected& __y) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp2) &&
+                                                   _LIBCUDACXX_TRAIT(is_nothrow_swappable, _Tp2) &&
+                                                   _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err2) &&
+                                                   _LIBCUDACXX_TRAIT(is_nothrow_swappable, _Err2))
+    _LIBCUDACXX_TRAILING_REQUIRES(void)(__expected::__can_swap<_Tp2, _Err2>)
+  {
+    return __x.swap(__y); // some compiler warn about non void function without return
+  }
+
+  // [expected.object.obs], observers
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr const _Tp* operator->() const noexcept {
+    _LIBCUDACXX_ASSERT(this->__has_val_, "expected::operator-> requires the expected to contain a value");
+    return _CUDA_VSTD::addressof(this->__union_.__val_);
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr _Tp* operator->() noexcept {
+    _LIBCUDACXX_ASSERT(this->__has_val_, "expected::operator-> requires the expected to contain a value");
+    return _CUDA_VSTD::addressof(this->__union_.__val_);
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr const _Tp& operator*() const& noexcept {
+    _LIBCUDACXX_ASSERT(this->__has_val_, "expected::operator* requires the expected to contain a value");
+    return this->__union_.__val_;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr _Tp& operator*() & noexcept {
+    _LIBCUDACXX_ASSERT(this->__has_val_, "expected::operator* requires the expected to contain a value");
+    return this->__union_.__val_;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr const _Tp&& operator*() const&& noexcept {
+    _LIBCUDACXX_ASSERT(this->__has_val_, "expected::operator* requires the expected to contain a value");
+    return _CUDA_VSTD::move(this->__union_.__val_);
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr _Tp&& operator*() && noexcept {
+    _LIBCUDACXX_ASSERT(this->__has_val_, "expected::operator* requires the expected to contain a value");
+    return _CUDA_VSTD::move(this->__union_.__val_);
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr explicit operator bool() const noexcept { return this->__has_val_; }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr bool has_value() const noexcept { return this->__has_val_; }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr const _Tp& value() const& {
+    if (!this->__has_val_) {
+      __expected::__throw_bad_expected_access<_Err>(this->__union_.__unex_);
+    }
+    return this->__union_.__val_;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  _Tp& value() & {
+    if (!this->__has_val_) {
+      __expected::__throw_bad_expected_access<_Err>(this->__union_.__unex_);
+    }
+    return this->__union_.__val_;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  const _Tp&& value() const&& {
+    if (!this->__has_val_) {
+      __expected::__throw_bad_expected_access<_Err>(_CUDA_VSTD::move(this->__union_.__unex_));
+    }
+    return _CUDA_VSTD::move(this->__union_.__val_);
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  _Tp&& value() && {
+    if (!this->__has_val_) {
+      __expected::__throw_bad_expected_access<_Err>(_CUDA_VSTD::move(this->__union_.__unex_));
+    }
+    return _CUDA_VSTD::move(this->__union_.__val_);
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  const _Err& error() const& noexcept {
+    _LIBCUDACXX_ASSERT(!this->__has_val_, "expected::error requires the expected to contain an error");
+    return this->__union_.__unex_;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  _Err& error() & noexcept {
+    _LIBCUDACXX_ASSERT(!this->__has_val_, "expected::error requires the expected to contain an error");
+    return this->__union_.__unex_;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  const _Err&& error() const&& noexcept {
+    _LIBCUDACXX_ASSERT(!this->__has_val_, "expected::error requires the expected to contain an error");
+    return _CUDA_VSTD::move(this->__union_.__unex_);
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  _Err&& error() && noexcept {
+    _LIBCUDACXX_ASSERT(!this->__has_val_, "expected::error requires the expected to contain an error");
+    return _CUDA_VSTD::move(this->__union_.__unex_);
+  }
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  _Tp value_or(_Up&& __v) const& {
+    static_assert(_LIBCUDACXX_TRAIT(is_copy_constructible, _Tp), "value_type has to be copy constructible");
+    static_assert(_LIBCUDACXX_TRAIT(is_convertible, _Up, _Tp), "argument has to be convertible to value_type");
+    return this->__has_val_ ? this->__union_.__val_ : static_cast<_Tp>(_CUDA_VSTD::forward<_Up>(__v));
+  }
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  _Tp value_or(_Up&& __v) && {
+    static_assert(_LIBCUDACXX_TRAIT(is_move_constructible, _Tp), "value_type has to be move constructible");
+    static_assert(_LIBCUDACXX_TRAIT(is_convertible, _Up, _Tp), "argument has to be convertible to value_type");
+    return this->__has_val_ ? _CUDA_VSTD::move(this->__union_.__val_) : static_cast<_Tp>(_CUDA_VSTD::forward<_Up>(__v));
+  }
+
+  // [expected.object.monadic]
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, _Err2&))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto and_then(_Fun&& __fun) & {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, _Tp&>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of f(value()) must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::error_type, _Err),
+      "The error type of the result of f(value()) must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__val_);
+    } else {
+      return _Res{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_copy_constructible, _Err2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto and_then(_Fun&& __fun) const& {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, const _Tp&>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of f(value()) must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::error_type, _Err),
+      "The error type of the result of f(value()) must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__val_);
+    } else {
+      return _Res{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_move_constructible, _Err2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto and_then(_Fun&& __fun) && {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, _Tp>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of f(value()) must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::error_type, _Err),
+      "The error type of the result of f(value()) must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::move(this->__union_.__val_));
+    } else {
+      return _Res{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, const _Err2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto and_then(_Fun&& __fun) const&& {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, const _Tp>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of f(value()) must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::error_type, _Err),
+      "The error type of the result of f(value()) must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::move(this->__union_.__val_));
+    } else {
+      return _Res{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Tp2, _Tp2&))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto or_else(_Fun&& __fun) & {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, _Err&>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of std::expected::or_else must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::value_type, _Tp),
+      "The value type of the result of std::expected::or_else must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _Res{in_place, this->__union_.__val_};
+    } else {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__unex_);
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_copy_constructible, _Tp2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto or_else(_Fun&& __fun) const& {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, const _Err&>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of std::expected::or_else must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::value_type, _Tp),
+      "The value type of the result of std::expected::or_else must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _Res{in_place, this->__union_.__val_};
+    } else {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__unex_);
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_move_constructible, _Tp2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto or_else(_Fun&& __fun) && {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, _Err>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of std::expected::or_else must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::value_type, _Tp),
+      "The value type of the result of std::expected::or_else must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _Res{in_place, _CUDA_VSTD::move(this->__union_.__val_)};
+    } else {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::move(this->__union_.__unex_));
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Tp2, const _Tp2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto or_else(_Fun&& __fun) const&& {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, const _Err>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of std::expected::or_else must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::value_type, _Tp),
+      "The value type of the result of std::expected::or_else must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _Res{in_place, _CUDA_VSTD::move(this->__union_.__val_)};
+    } else {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::move(this->__union_.__unex_));
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, _Err2&) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun, _Tp2&>>, void))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) & {
+    static_assert(invocable<_Fun, _Tp&>,
+      "std::expected::transform requires that F must be invocable with T.");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, _Tp&>>;
+
+    if (this->__has_val_) {
+      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__val_);
+      return expected<void, _Err>{};
+    } else {
+      return expected<_Res, _Err>{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, _Err2&) _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun, _Tp2&>>, void)))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) & {
+    static_assert(invocable<_Fun, _Tp&>,
+      "std::expected::transform requires that F must be invocable with T.");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, _Tp&>>;
+
+    static_assert(__invoke_constructible<_Fun, _Tp&>,
+      "std::expected::transform requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Res, _Err>,
+      "std::expected::transform requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Res, _Err>{
+              __expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__val_};
+    } else {
+      return expected<_Res, _Err>{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_copy_constructible, _Err2) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun, const _Tp2&>>, void))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) const& {
+    static_assert(invocable<_Fun, const _Tp&>,
+      "std::expected::transform requires that F must be invocable with T.");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, const _Tp&>>;
+
+    if (this->__has_val_) {
+      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__val_);
+      return expected<_Res, _Err>{};
+    } else {
+      return expected<_Res, _Err>{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_copy_constructible, _Err2) _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun, const _Tp2&>>, void)))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) const& {
+    static_assert(invocable<_Fun, const _Tp&>,
+      "std::expected::transform requires that F must be invocable with T");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, const _Tp&>>;
+
+    static_assert(__invoke_constructible<_Fun, const _Tp&>,
+      "std::expected::transform requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Res, _Err>,
+      "std::expected::transform requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Res, _Err>{
+              __expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__val_};
+    } else {
+      return expected<_Res, _Err>{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_move_constructible, _Err2) _LIBCUDACXX_AND
+             _LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun, _Tp2>>, void))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) && {
+    static_assert(invocable<_Fun, _Tp>,
+      "std::expected::transform requires that F must be invocable with T.");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, _Tp>>;
+
+    if (this->__has_val_) {
+      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::move(this->__union_.__val_));
+      return expected<_Res, _Err>{};
+    } else {
+      return expected<_Res, _Err>{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_move_constructible, _Err2) _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun, _Tp2>>, void)))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) && {
+    static_assert(invocable<_Fun, _Tp>,
+      "std::expected::transform requires that F must be invocable with T");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, _Tp>>;
+
+    static_assert(__invoke_constructible<_Fun, _Tp>,
+      "std::expected::transform requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Res, _Err>,
+      "std::expected::transform requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Res, _Err>{
+              __expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::move(this->__union_.__val_)};
+    } else {
+      return expected<_Res, _Err>{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, const _Err2) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun, const _Tp2>>, void))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) const&& {
+    static_assert(invocable<_Fun, const _Tp>,
+      "std::expected::transform requires that F must be invocable with T.");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, const _Tp>>;
+
+    if (this->__has_val_) {
+      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::move(this->__union_.__val_));
+      return expected<_Res, _Err>{};
+    } else {
+      return expected<_Res, _Err>{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, const _Err2) _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun, const _Tp2>>, void)))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) const&& {
+    static_assert(invocable<_Fun, const _Tp>,
+      "std::expected::transform requires that F must be invocable with T");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, const _Tp>>;
+
+    static_assert(__invoke_constructible<_Fun, const _Tp>,
+      "std::expected::transform requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Res, _Err>,
+      "std::expected::transform requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Res, _Err>{
+              __expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::move(this->__union_.__val_)};
+    } else {
+      return expected<_Res, _Err>{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Tp2, _Tp2&))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform_error(_Fun&& __fun) & {
+    static_assert(invocable<_Fun, _Err&>,
+      "std::expected::transform_error requires that F must be invocable with E");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, _Err&>>;
+
+    static_assert(__invoke_constructible<_Fun, _Err&>,
+      "std::expected::transform_error requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Tp, _Res>,
+      "std::expected::transform_error requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Tp, _Res>{in_place, this->__union_.__val_};
+    } else {
+      return expected<_Tp, _Res>{
+          __expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_copy_constructible, _Tp2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform_error(_Fun&& __fun) const& {
+    static_assert(invocable<_Fun, const _Err&>,
+      "std::expected::transform_error requires that F must be invocable with E");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, const _Err&>>;
+
+    static_assert(__invoke_constructible<_Fun, const _Err&>,
+      "std::expected::transform_error requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Tp, _Res>,
+      "std::expected::transform_error requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Tp, _Res>{in_place, this->__union_.__val_};
+    } else {
+      return expected<_Tp, _Res>{
+          __expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_move_constructible, _Tp2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform_error(_Fun&& __fun) && {
+    static_assert(invocable<_Fun, _Err>,
+      "std::expected::transform_error requires that F must be invocable with E");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, _Err>>;
+
+    static_assert(__invoke_constructible<_Fun, _Err>,
+      "std::expected::transform_error requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Tp, _Res>,
+      "std::expected::transform_error requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Tp, _Res>{in_place, _CUDA_VSTD::move(this->__union_.__val_)};
+    } else {
+      return expected<_Tp, _Res>{__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun),
+          _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Tp2, const _Tp2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform_error(_Fun&& __fun) const&& {
+    static_assert(invocable<_Fun, const _Err>,
+      "std::expected::transform_error requires that F must be invocable with E");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, const _Err>>;
+
+    static_assert(__invoke_constructible<_Fun, const _Err>,
+      "std::expected::transform_error requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Tp, _Res>,
+      "std::expected::transform_error requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Tp, _Res>{in_place, _CUDA_VSTD::move(this->__union_.__val_)};
+    } else {
+      return expected<_Tp, _Res>{__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun),
+          _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  // [expected.object.eq], equality operators
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator==(const expected& __x, const expected& __y) {
+    if (__x.__has_val_ != __y.has_value()) {
+      return false;
+    } else {
+      if (__x.__has_val_) {
+        return __x.__union_.__val_ == __y.value();
+      } else {
+        return __x.__union_.__unex_ == __y.error();
+      }
+    }
+  }
+
+#if _LIBCUDACXX_STD_VER < 20
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator!=(const expected& __x, const expected& __y) {
+    return !(__x == __y);
+  }
+#endif // _LIBCUDACXX_STD_VER < 20
+
+  _LIBCUDACXX_TEMPLATE(class _T2, class _E2)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_void, _T2)))
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator==(const expected& __x, const expected<_T2, _E2>& __y) {
+    if (__x.__has_val_ != __y.has_value()) {
+      return false;
+    } else {
+      if (__x.__has_val_) {
+        return __x.__union_.__val_ == __y.value();
+      } else {
+        return __x.__union_.__unex_ == __y.error();
+      }
+    }
+  }
+
+#if _LIBCUDACXX_STD_VER < 20
+  _LIBCUDACXX_TEMPLATE(class _T2, class _E2)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_void, _T2)))
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator!=(const expected& __x, const expected<_T2, _E2>& __y) {
+    return !(__x == __y);
+  }
+#endif // _LIBCUDACXX_STD_VER < 20
+
+  _LIBCUDACXX_TEMPLATE(class _T2)
+    _LIBCUDACXX_REQUIRES( (!__expected::__is_expected_nonvoid<_T2>))
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator==(const expected& __x, const _T2& __v) {
+    return __x.__has_val_ && static_cast<bool>(__x.__union_.__val_ == __v);
+  }
+#if _LIBCUDACXX_STD_VER < 20
+  _LIBCUDACXX_TEMPLATE(class _T2)
+    _LIBCUDACXX_REQUIRES( (!__expected::__is_expected_nonvoid<_T2>))
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator==(const _T2& __v, const expected& __x) {
+    return __x.__has_val_ && static_cast<bool>(__x.__union_.__val_ == __v);
+  }
+  _LIBCUDACXX_TEMPLATE(class _T2)
+    _LIBCUDACXX_REQUIRES( (!__expected::__is_expected_nonvoid<_T2>))
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator!=(const expected& __x, const _T2& __v) {
+    return !__x.__has_val_ || static_cast<bool>(__x.__union_.__val_ != __v);
+  }
+  _LIBCUDACXX_TEMPLATE(class _T2)
+    _LIBCUDACXX_REQUIRES( (!__expected::__is_expected_nonvoid<_T2>))
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator!=(const _T2& __v, const expected& __x) {
+    return !__x.__has_val_ || static_cast<bool>(__x.__union_.__val_ != __v);
+  }
+#endif // _LIBCUDACXX_STD_VER < 20
+
+  template <class _E2>
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator==(const expected& __x, const unexpected<_E2>& __e) {
+    return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __e.error());
+  }
+#if _LIBCUDACXX_STD_VER < 20
+  template <class _E2>
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator==(const unexpected<_E2>& __e, const expected& __x) {
+    return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __e.error());
+  }
+  template <class _E2>
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator!=(const expected& __x, const unexpected<_E2>& __e) {
+    return __x.__has_val_ || static_cast<bool>(__x.__union_.__unex_ != __e.error());
+  }
+  template <class _E2>
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator!=(const unexpected<_E2>& __e, const expected& __x) {
+    return __x.__has_val_ || static_cast<bool>(__x.__union_.__unex_ != __e.error());
+  }
+#endif // _LIBCUDACXX_STD_VER < 20
+};
+
+
+template <class _Err>
+class expected<void, _Err> : private __expected_move_assign<void, _Err>
+                           , private __expected_void_sfinae_ctor_base_t<_Err>
+                           , private __expected_void_sfinae_assign_base_t<_Err>
+{
+  using __base = __expected_move_assign<void, _Err>;
+  static_assert(__unexpected::__valid_unexpected<_Err>,
+                "[expected.void.general] A program that instantiates expected<T, E> with a E that is not a "
+                "valid argument for unexpected<E> is ill-formed");
+
+  template <class, class>
+  friend class expected;
+
+  template <class _Up, class _OtherErr, class _OtherErrQual>
+  using __can_convert =
+      _And< is_void<_Up>,
+            is_constructible<_Err, _OtherErrQual>,
+            _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>,
+            _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>,
+            _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>,
+            _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>>>;
+
+public:
+  using value_type      = void;
+  using error_type      = _Err;
+  using unexpected_type = unexpected<_Err>;
+
+  template <class _Up>
+  using rebind = expected<_Up, error_type>;
+
+  // [expected.void.ctor], constructors
+  constexpr expected() = default;
+  constexpr expected(const expected&) = default;
+  constexpr expected(expected&&) = default;
+  constexpr expected& operator=(const expected&) = default;
+  constexpr expected& operator=(expected&&) = default;
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class _OtherErr)
+    _LIBCUDACXX_REQUIRES( __can_convert<_Up, _OtherErr, const _OtherErr&>::value _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, const _OtherErr&, _Err)
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  expected(const expected<_Up, _OtherErr>& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, const _OtherErr&)) // strengthened
+    : __base(__other.__has_val_)
+  {
+    if (!__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, __other.__union_.__unex_);
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class _OtherErr)
+    _LIBCUDACXX_REQUIRES( __can_convert<_Up, _OtherErr, const _OtherErr&>::value _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_convertible, const _OtherErr&, _Err))
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  explicit expected(const expected<_Up, _OtherErr>& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, const _OtherErr&)) // strengthened
+    : __base(__other.__has_val_)
+  {
+    if (!__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, __other.__union_.__unex_);
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class _OtherErr)
+    _LIBCUDACXX_REQUIRES( __can_convert<_Up, _OtherErr, _OtherErr>::value _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, _OtherErr, _Err)
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  expected(expected<_Up, _OtherErr>&& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _OtherErr)) // strengthened
+    : __base(__other.__has_val_)
+  {
+    if (!__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, _CUDA_VSTD::move(__other.__union_.__unex_));
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class _OtherErr)
+    _LIBCUDACXX_REQUIRES( __can_convert<_Up, _OtherErr, _OtherErr>::value _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_convertible, _OtherErr, _Err))
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  explicit expected(expected<_Up, _OtherErr>&& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _OtherErr)) // strengthened
+    : __base(__other.__has_val_)
+  {
+    if (!__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, _CUDA_VSTD::move(__other.__union_.__unex_));
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, const _OtherErr&) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, const _OtherErr&, _Err)
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  expected(const unexpected<_OtherErr>& __unex)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, const _OtherErr&)) // strengthened
+    : __base(unexpect, __unex.error())
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, const _OtherErr&) _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_convertible, const _OtherErr&, _Err))
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(const unexpected<_OtherErr>& __unex)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, const _OtherErr&)) // strengthened
+    : __base(unexpect, __unex.error())
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, _OtherErr) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_convertible, _OtherErr, _Err))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  expected(unexpected<_OtherErr>&& __unex)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _OtherErr)) // strengthened
+    : __base(unexpect, _CUDA_VSTD::move(__unex.error()))
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, _OtherErr) _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_convertible, _OtherErr, _Err))
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(unexpected<_OtherErr>&& __unex)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _OtherErr)) // strengthened
+    : __base(unexpect, _CUDA_VSTD::move(__unex.error()))
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(in_place_t) noexcept : __base(true) {}
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, _Args...))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(unexpect_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...)) // strengthened
+    : __base(unexpect, _CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, initializer_list<_Up>&, _Args...))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  explicit expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, initializer_list<_Up>, _Args...)) // strengthened
+    : __base(unexpect, __il, _CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+
+private:
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  expected(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+    : __base(__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+
+public:
+
+  // [expected.void.dtor], destructor
+  // [expected.void.assign], assignment
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, const _OtherErr&) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_assignable, _Err&, const _OtherErr&)
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  expected& operator=(const unexpected<_OtherErr>& __un)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_assignable, _Err&, const _OtherErr&) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, const _OtherErr&)) // strengthened
+  {
+    if (this->__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, __un.error());
+      this->__has_val_ = false;
+    } else {
+      this->__union_.__unex_ = __un.error();
+    }
+    return *this;
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _OtherErr)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, _OtherErr) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_assignable, _Err&, _OtherErr)
+    )
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  expected& operator=(unexpected<_OtherErr>&& __un)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_assignable, _Err&, _OtherErr) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _OtherErr))
+  {
+    if (this->__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, _CUDA_VSTD::move(__un.error()));
+      this->__has_val_ = false;
+    } else {
+      this->__union_.__unex_ = _CUDA_VSTD::move(__un.error());
+    }
+    return *this;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  void emplace() noexcept
+  {
+    if (!this->__has_val_) {
+      this->__union_.__unex_.~_Err();
+      this->__has_val_ = true;
+    }
+  }
+
+  // [expected.void.swap], swap
+  _LIBCUDACXX_TEMPLATE(class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( __expected::__can_swap<void, _Err2>)
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  void swap(expected<void, _Err2>& __rhs) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err2) &&
+                                                   _LIBCUDACXX_TRAIT(is_nothrow_swappable, _Err2))
+  {
+    if (this->__has_val_) {
+      if (!__rhs.__has_val_) {
+        this->__swap_val_unex_impl(*this, __rhs);
+      }
+    } else {
+      if (__rhs.__has_val_) {
+        this->__swap_val_unex_impl(__rhs, *this);
+      } else {
+        using _CUDA_VSTD::swap;
+        swap(this->__union_.__unex_, __rhs.__union_.__unex_);
+      }
+    }
+  }
+
+  template<class _Err2 = _Err>
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  auto swap(expected& __x, expected& __y) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err2) &&
+                                                   _LIBCUDACXX_TRAIT(is_nothrow_swappable, _Err2))
+    _LIBCUDACXX_TRAILING_REQUIRES(void)(__expected::__can_swap<void, _Err2>)
+  {
+    return __x.swap(__y); // some compiler warn about non void function without return
+  }
+
+  // [expected.void.obs], observers
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr explicit operator bool() const noexcept { return this->__has_val_; }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr bool has_value() const noexcept { return this->__has_val_; }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr void operator*() const noexcept {
+    _LIBCUDACXX_ASSERT(this->__has_val_, "expected::operator* requires the expected to contain a value");
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr void value() const& {
+    if (!this->__has_val_) {
+      __expected::__throw_bad_expected_access<_Err>(this->__union_.__unex_);
+    }
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr void value() && {
+    if (!this->__has_val_) {
+      __expected::__throw_bad_expected_access<_Err>(_CUDA_VSTD::move(this->__union_.__unex_));
+    }
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr const _Err& error() const& noexcept {
+    _LIBCUDACXX_ASSERT(!this->__has_val_, "expected::error requires the expected to contain an error");
+    return this->__union_.__unex_;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr _Err& error() & noexcept {
+    _LIBCUDACXX_ASSERT(!this->__has_val_, "expected::error requires the expected to contain an error");
+    return this->__union_.__unex_;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr const _Err&& error() const&& noexcept {
+    _LIBCUDACXX_ASSERT(!this->__has_val_, "expected::error requires the expected to contain an error");
+    return _CUDA_VSTD::move(this->__union_.__unex_);
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr _Err&& error() && noexcept {
+    _LIBCUDACXX_ASSERT(!this->__has_val_, "expected::error requires the expected to contain an error");
+    return _CUDA_VSTD::move(this->__union_.__unex_);
+  }
+
+  // [expected.void.monadic]
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, _Err2&))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto and_then(_Fun&& __fun) & {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of f(value()) must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::error_type, _Err),
+      "The error type of the result of f(value()) must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun));
+    } else {
+      return _Res{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_copy_constructible, _Err2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto and_then(_Fun&& __fun) const& {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of f(value()) must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::error_type, _Err),
+      "The error type of the result of f(value()) must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun));
+    } else {
+      return _Res{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_move_constructible, _Err2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto and_then(_Fun&& __fun) && {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of f(value()) must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::error_type, _Err),
+      "The error type of the result of f(value()) must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun));
+    } else {
+      return _Res{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, const _Err2))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto and_then(_Fun&& __fun) const&& {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of f(value()) must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::error_type, _Err),
+      "The error type of the result of f(value()) must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun));
+    } else {
+      return _Res{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  template<class _Fun>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto or_else(_Fun&& __fun) & {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, _Err&>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of std::expected::or_else must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::value_type, void),
+      "The value type of the result of std::expected::or_else must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _Res{};
+    } else {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__unex_);
+    }
+  }
+
+  template<class _Fun>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto or_else(_Fun&& __fun) const& {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, const _Err&>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of std::expected::or_else must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::value_type, void),
+      "The value type of the result of std::expected::or_else must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _Res{};
+    } else {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__unex_);
+    }
+  }
+
+  template<class _Fun>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto or_else(_Fun&& __fun) && {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, _Err>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of std::expected::or_else must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::value_type, void),
+      "The value type of the result of std::expected::or_else must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _Res{};
+    } else {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::move(this->__union_.__unex_));
+    }
+  }
+
+  template<class _Fun>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto or_else(_Fun&& __fun) const&& {
+    using _Res = __remove_cvref_t<invoke_result_t<_Fun, const _Err>>;
+
+    static_assert(__expected::__is_expected<_Res>,
+      "Result of std::expected::or_else must be a specialization of std::expected");
+    static_assert(_LIBCUDACXX_TRAIT(is_same, typename _Res::value_type, void),
+      "The value type of the result of std::expected::or_else must be the same as that of std::expected");
+
+    if (this->__has_val_) {
+      return _Res{};
+    } else {
+      return _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::move(this->__union_.__unex_));
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, _Err2&) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun>>, void))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) & {
+    static_assert(invocable<_Fun>,
+      "std::expected::transform requires that F must be invocable with T.");
+    if (this->__has_val_) {
+      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun));
+      return expected<void, _Err>{};
+    } else {
+      return expected<void, _Err>{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, _Err2&) _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun>>, void)))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) & {
+    static_assert(invocable<_Fun>,
+      "std::expected::transform requires that F must be invocable with T.");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun>>;
+
+    static_assert(__invoke_constructible<_Fun>,
+      "std::expected::transform requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Res, _Err>,
+      "std::expected::transform requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Res, _Err>{
+              __expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun)};
+    } else {
+      return expected<_Res, _Err>{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_copy_constructible, _Err2) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun>>, void))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) const& {
+    static_assert(invocable<_Fun>,
+      "std::expected::transform requires that F must be invocable with T.");
+    if (this->__has_val_) {
+      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun));
+      return expected<void, _Err>{};
+    } else {
+      return expected<void, _Err>{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_copy_constructible, _Err2) _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun>>, void)))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) const& {
+    static_assert(invocable<_Fun>,
+      "std::expected::transform requires that F must be invocable with T");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun>>;
+
+    static_assert(__invoke_constructible<_Fun>,
+      "std::expected::transform requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Res, _Err>,
+      "std::expected::transform requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Res, _Err>{
+              __expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun)};
+    } else {
+      return expected<_Res, _Err>{unexpect, this->__union_.__unex_};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_move_constructible, _Err2) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun>>, void))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) && {
+    static_assert(invocable<_Fun>,
+      "std::expected::transform requires that F must be invocable with T.");
+    if (this->__has_val_) {
+      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun));
+      return expected<void, _Err>{};
+    } else {
+      return expected<void, _Err>{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_move_constructible, _Err2) _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun>>, void)))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) && {
+    static_assert(invocable<_Fun>,
+      "std::expected::transform requires that F must be invocable with T");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun>>;
+
+    static_assert(__invoke_constructible<_Fun>,
+      "std::expected::transform requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Res, _Err>,
+      "std::expected::transform requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Res, _Err>{
+              __expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun)};
+    } else {
+      return expected<_Res, _Err>{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, const _Err2) _LIBCUDACXX_AND
+              _LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun>>, void))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) const&& {
+    static_assert(invocable<_Fun>,
+      "std::expected::transform requires that F must be invocable with T.");
+    if (this->__has_val_) {
+      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun));
+      return expected<void, _Err>{};
+    } else {
+        return expected<void, _Err>{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Fun, class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err2, const _Err2) _LIBCUDACXX_AND
+            (!_LIBCUDACXX_TRAIT(is_same, __remove_cv_t<invoke_result_t<_Fun>>, void)))
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform(_Fun&& __fun) const&& {
+    static_assert(invocable<_Fun>,
+      "std::expected::transform requires that F must be invocable with T");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun>>;
+
+    static_assert(__invoke_constructible<_Fun>,
+      "std::expected::transform requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<_Res, _Err>,
+      "std::expected::transform requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<_Res, _Err>{
+              __expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun)};
+    } else {
+        return expected<_Res, _Err>{unexpect, _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  template<class _Fun>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform_error(_Fun&& __fun) & {
+    static_assert(invocable<_Fun, _Err&>,
+      "std::expected::transform_error requires that F must be invocable with E");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, _Err&>>;
+
+    static_assert(__invoke_constructible<_Fun, _Err&>,
+      "std::expected::transform_error requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<void, _Res>,
+      "std::expected::transform_error requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<void, _Res>{};
+    } else {
+      return expected<void, _Res>{
+          __expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__unex_};
+    }
+  }
+
+  template<class _Fun>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform_error(_Fun&& __fun) const& {
+    static_assert(invocable<_Fun, const _Err&>,
+      "std::expected::transform_error requires that F must be invocable with E");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, const _Err&>>;
+
+    static_assert(__invoke_constructible<_Fun, const _Err&>,
+      "std::expected::transform_error requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<void, _Res>,
+      "std::expected::transform_error requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<void, _Res>{};
+    } else {
+      return expected<void, _Res>{
+          __expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), this->__union_.__unex_};
+    }
+  }
+
+  template<class _Fun>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform_error(_Fun&& __fun) && {
+    static_assert(invocable<_Fun, _Err>,
+      "std::expected::transform_error requires that F must be invocable with E");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, _Err>>;
+
+    static_assert(__invoke_constructible<_Fun, _Err>,
+      "std::expected::transform_error requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<void, _Res>,
+      "std::expected::transform_error requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<void, _Res>{};
+    } else {
+      return expected<void, _Res>{__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun),
+          _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  template<class _Fun>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  auto transform_error(_Fun&& __fun) const&& {
+    static_assert(invocable<_Fun, const _Err>,
+      "std::expected::transform_error requires that F must be invocable with E");
+    using _Res = __remove_cv_t<invoke_result_t<_Fun, const _Err>>;
+
+    static_assert(__invoke_constructible<_Fun, const _Err>,
+      "std::expected::transform_error requires that the return type of F is constructible with the result of invoking F");
+    static_assert(__expected::__valid_expected<void, _Res>,
+      "std::expected::transform_error requires that the return type of F must be a valid argument for std::expected");
+
+    if (this->__has_val_) {
+      return expected<void, _Res>{};
+    } else {
+      return expected<void, _Res>{__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun),
+          _CUDA_VSTD::move(this->__union_.__unex_)};
+    }
+  }
+
+  // [expected.void.eq], equality operators
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator==(const expected& __x, const expected& __y) noexcept {
+    if (__x.__has_val_ != __y.has_value()) {
+      return false;
+    } else {
+      return __x.__has_val_ || static_cast<bool>(__x.__union_.__unex_ == __y.error());
+    }
+  }
+#if _LIBCUDACXX_STD_VER < 20
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator!=(const expected& __x, const expected& __y) noexcept {
+    return !(__x == __y);
+  }
+#endif
+
+  template <class _E2>
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator==(const expected& __x, const expected<void, _E2>& __y) noexcept {
+    if (__x.__has_val_ != __y.has_value()) {
+      return false;
+    } else {
+      return __x.__has_val_ || static_cast<bool>(__x.__union_.__unex_ == __y.error());
+    }
+  }
+#if _LIBCUDACXX_STD_VER < 20
+  template <class _E2>
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator!=(const expected& __x, const expected<void, _E2>& __y) noexcept {
+    return !(__x == __y);
+  }
+#endif
+
+  template <class _E2>
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator==(const expected& __x, const unexpected<_E2>& __y) noexcept {
+    return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __y.error());
+  }
+#if _LIBCUDACXX_STD_VER < 20
+  template <class _E2>
+  friend _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  bool operator==(const unexpected<_E2>& __y, const expected& __x) noexcept {
+    return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __y.error());
+  }
+  template <class _E2>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  friend constexpr bool operator!=(const expected& __x, const unexpected<_E2>& __y) noexcept {
+    return __x.__has_val_ || static_cast<bool>(__x.__union_.__unex_ != __y.error());
+  }
+  template <class _E2>
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  friend constexpr bool operator!=(const unexpected<_E2>& __y, const expected& __x) noexcept {
+    return __x.__has_val_ || static_cast<bool>(__x.__union_.__unex_ != __y.error());
+  }
+#endif
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+#endif // _LIBCUDACXX___EXPECTED_EXPECTED_H

cuda_toolkit/include/__expected/expected_base.h

@@ -0,0 +1,1048 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCUDACXX___EXPECTED_EXPECTED_BASE_H
+#define _LIBCUDACXX___EXPECTED_EXPECTED_BASE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__assert"
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/invocable.h"
+#include "../__expected/unexpect.h"
+#include "../__memory/addressof.h"
+#include "../__memory/construct_at.h"
+#include "../__tuple_dir/sfinae_helpers.h"
+#include "../__type_traits/is_assignable.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_copy_assignable.h"
+#include "../__type_traits/is_copy_constructible.h"
+#include "../__type_traits/is_default_constructible.h"
+#include "../__type_traits/is_move_assignable.h"
+#include "../__type_traits/is_move_constructible.h"
+#include "../__type_traits/is_nothrow_constructible.h"
+#include "../__type_traits/is_nothrow_copy_assignable.h"
+#include "../__type_traits/is_nothrow_copy_constructible.h"
+#include "../__type_traits/is_nothrow_default_constructible.h"
+#include "../__type_traits/is_nothrow_move_assignable.h"
+#include "../__type_traits/is_nothrow_move_constructible.h"
+#include "../__type_traits/is_trivially_copy_assignable.h"
+#include "../__type_traits/is_trivially_copy_constructible.h"
+#include "../__type_traits/is_trivially_destructible.h"
+#include "../__type_traits/is_trivially_move_assignable.h"
+#include "../__type_traits/is_trivially_move_constructible.h"
+#include "../__type_traits/is_void.h"
+#include "../__utility/exception_guard.h"
+#include "../__utility/forward.h"
+#include "../__utility/in_place.h"
+#include "../__utility/move.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// MSVC complains about [[no_unique_address]] prior to C++20 as a vendor extension
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#pragma warning(push)
+#pragma warning(disable : 4848)
+#endif // _LIBCUDACXX_COMPILER_MSVC
+
+struct __expected_construct_from_invoke_tag {
+  explicit __expected_construct_from_invoke_tag() = default;
+};
+
+template <class _Tp, class _Err,
+          bool = _LIBCUDACXX_TRAIT(is_trivially_destructible, _Tp)
+              && _LIBCUDACXX_TRAIT(is_trivially_destructible, _Err)>
+union __expected_union_t {
+  struct __empty_t {};
+
+  _LIBCUDACXX_TEMPLATE(class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_default_constructible, _Tp2))
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t() noexcept(_LIBCUDACXX_TRAIT(is_nothrow_default_constructible, _Tp2)) : __val_() {}
+
+  _LIBCUDACXX_TEMPLATE(class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_default_constructible, _Tp2)))
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t() noexcept : __empty_() {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t(in_place_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+    : __val_(_CUDA_VSTD::forward<_Args>(__args)...) {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t(unexpect_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...))
+    : __unex_(_CUDA_VSTD::forward<_Args>(__args)...) {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t(__expected_construct_from_invoke_tag, in_place_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, invoke_result_t<_Fun, _Args...>))
+    : __val_(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)) {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+    : __unex_(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)) {}
+
+  // the __expected_destruct's destructor handles this
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  ~__expected_union_t() {}
+
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS __empty_t __empty_;
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS _Tp __val_;
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS _Err __unex_;
+};
+
+template <class _Tp, class _Err>
+union __expected_union_t<_Tp, _Err, true> {
+  struct __empty_t {};
+
+  _LIBCUDACXX_TEMPLATE(class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_default_constructible, _Tp2))
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t() noexcept(_LIBCUDACXX_TRAIT(is_nothrow_default_constructible, _Tp2)) : __val_() {}
+
+  _LIBCUDACXX_TEMPLATE(class _Tp2 = _Tp)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_default_constructible, _Tp2)))
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t() noexcept : __empty_() {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t(in_place_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+    : __val_(_CUDA_VSTD::forward<_Args>(__args)...) {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t(unexpect_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...))
+    : __unex_(_CUDA_VSTD::forward<_Args>(__args)...) {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t(__expected_construct_from_invoke_tag, in_place_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, invoke_result_t<_Fun, _Args...>))
+    : __val_(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)) {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_union_t(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+    : __unex_(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)) {}
+
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS __empty_t __empty_;
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS _Tp __val_;
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS _Err __unex_;
+};
+
+template <class _Tp, class _Err,
+          bool = _LIBCUDACXX_TRAIT(is_trivially_destructible, _Tp),
+          bool = _LIBCUDACXX_TRAIT(is_trivially_destructible, _Err)>
+struct __expected_destruct;
+
+template <class _Tp, class _Err>
+struct __expected_destruct<_Tp, _Err, false, false> {
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS __expected_union_t<_Tp, _Err> __union_{};
+  bool __has_val_{true};
+
+  constexpr __expected_destruct() noexcept = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(const bool __has_val) noexcept : __has_val_(__has_val) {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(in_place_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+    : __union_(in_place, _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(true)
+  {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(unexpect_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...))
+    : __union_(unexpect, _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(__expected_construct_from_invoke_tag, in_place_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, invoke_result_t<_Fun, _Args...>))
+    : __union_(__expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(true)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+    : __union_(__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  ~__expected_destruct() {
+    if (__has_val_) {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__union_.__val_));
+    } else {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__union_.__unex_));
+    }
+  }
+};
+
+template <class _Tp, class _Err>
+struct __expected_destruct<_Tp, _Err, true, false> {
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS __expected_union_t<_Tp, _Err> __union_{};
+  bool __has_val_{true};
+
+  constexpr __expected_destruct() noexcept = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(const bool __has_val) noexcept : __has_val_(__has_val) {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(in_place_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+    : __union_(in_place, _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(true)
+  {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(unexpect_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+    : __union_(unexpect, _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(__expected_construct_from_invoke_tag, in_place_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, invoke_result_t<_Fun, _Args...>))
+    : __union_(__expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(true)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+    : __union_(__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  ~__expected_destruct() {
+    if (!__has_val_) {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__union_.__unex_));
+    }
+  }
+};
+
+template <class _Tp, class _Err>
+struct __expected_destruct<_Tp, _Err, false, true> {
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS __expected_union_t<_Tp, _Err> __union_{};
+  bool __has_val_{true};
+
+  constexpr __expected_destruct() noexcept = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(const bool __has_val) noexcept : __has_val_(__has_val) {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(in_place_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+    : __union_(in_place, _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(true)
+  {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(unexpect_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+    : __union_(unexpect, _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(__expected_construct_from_invoke_tag, in_place_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, invoke_result_t<_Fun, _Args...>))
+    : __union_(__expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(true)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+    : __union_(__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  ~__expected_destruct() {
+    if (__has_val_) {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__union_.__val_));
+    }
+  }
+};
+
+template <class _Tp, class _Err>
+struct __expected_destruct<_Tp, _Err, true, true> {
+  // This leads to an ICE with nvcc, see nvbug4103076
+  /* _LIBCUDACXX_NO_UNIQUE_ADDRESS */ __expected_union_t<_Tp, _Err> __union_{};
+  bool __has_val_{true};
+
+  constexpr __expected_destruct() noexcept = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(const bool __has_val) noexcept : __has_val_(__has_val) {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(in_place_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+    : __union_(in_place, _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(true)
+  {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(unexpect_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, _Args...))
+    : __union_(unexpect, _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(__expected_construct_from_invoke_tag, in_place_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Tp, invoke_result_t<_Fun, _Args...>))
+    : __union_(__expected_construct_from_invoke_tag{}, in_place, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(true)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+    : __union_(__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+};
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#pragma warning(pop)
+#endif // _LIBCUDACXX_COMPILER_MSVC
+
+template <class _Tp, class _Err>
+struct __expected_storage : __expected_destruct<_Tp, _Err>
+{
+  using __base = __expected_destruct<_Tp, _Err>;
+
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  constexpr __expected_storage() noexcept = default;
+
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_storage(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+  _LIBCUDACXX_TEMPLATE(class _T1, class _T2, class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_nothrow_constructible, _T1, _Args...))
+  static _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  void __reinit_expected(_T1& __newval, _T2& __oldval, _Args&&... __args) noexcept {
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__oldval));
+    _LIBCUDACXX_CONSTRUCT_AT(__newval, _CUDA_VSTD::forward<_Args>(__args)...);
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _T1, class _T2, class... _Args)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_nothrow_constructible, _T1, _Args...)) _LIBCUDACXX_AND
+                _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _T1)
+    )
+  static _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  void __reinit_expected(_T1& __newval, _T2& __oldval, _Args&&... __args) {
+    _T1 __tmp(_CUDA_VSTD::forward<_Args>(__args)...);
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__oldval));
+    _LIBCUDACXX_CONSTRUCT_AT(__newval, _CUDA_VSTD::move(__tmp));
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _T1, class _T2, class... _Args)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_nothrow_constructible, _T1, _Args...)) _LIBCUDACXX_AND
+              (!_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _T1))
+    )
+  static _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  void __reinit_expected(_T1& __newval, _T2& __oldval, _Args&&... __args) {
+    static_assert(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _T2),
+        "To provide strong exception guarantee, T2 has to satisfy `is_nothrow_move_constructible_v` so that it can "
+        "be reverted to the previous state in case an exception is thrown during the assignment.");
+    _T2 __tmp(_CUDA_VSTD::move(__oldval));
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__oldval));
+    auto __trans =
+        _CUDA_VSTD::__make_exception_guard([&] { _LIBCUDACXX_CONSTRUCT_AT(__oldval, _CUDA_VSTD::move(__tmp)); });
+    _LIBCUDACXX_CONSTRUCT_AT(__newval, _CUDA_VSTD::forward<_Args>(__args)...);
+    __trans.__complete();
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err2))
+  static _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  void __swap_val_unex_impl(__expected_storage<_Tp, _Err2>& __with_val, __expected_storage& __with_err) {
+    _Err __tmp(_CUDA_VSTD::move(__with_err.__union_.__unex_));
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__with_err.__union_.__unex_));
+    auto __trans = _CUDA_VSTD::__make_exception_guard([&] {
+      _LIBCUDACXX_CONSTRUCT_AT(__with_err.__union_.__unex_, _CUDA_VSTD::move(__tmp));
+    });
+    _LIBCUDACXX_CONSTRUCT_AT(__with_err.__union_.__val_, _CUDA_VSTD::move(__with_val.__union_.__val_));
+    __trans.__complete();
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__with_val.__union_.__val_));
+    _LIBCUDACXX_CONSTRUCT_AT(__with_val.__union_.__unex_, _CUDA_VSTD::move(__tmp));
+    __with_val.__has_val_ = false;
+    __with_err.__has_val_ = true;
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err2)))
+  static _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  void __swap_val_unex_impl(__expected_storage<_Tp, _Err2>& __with_val, __expected_storage& __with_err) {
+    static_assert(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp),
+                  "To provide strong exception guarantee, Tp has to satisfy `is_nothrow_move_constructible_v` so "
+                  "that it can be reverted to the previous state in case an exception is thrown during swap.");
+    _Tp __tmp(_CUDA_VSTD::move(__with_val.__union_.__val_));
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__with_val.__union_.__val_));
+    auto __trans = _CUDA_VSTD::__make_exception_guard([&] {
+      _LIBCUDACXX_CONSTRUCT_AT(__with_val.__union_.__val_, _CUDA_VSTD::move(__tmp));
+    });
+    _LIBCUDACXX_CONSTRUCT_AT(__with_val.__union_.__unex_, _CUDA_VSTD::move(__with_err.__union_.__unex_));
+    __trans.__complete();
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__with_err.__union_.__unex_));
+    _LIBCUDACXX_CONSTRUCT_AT(__with_err.__union_.__val_, _CUDA_VSTD::move(__tmp));
+    __with_val.__has_val_ = false;
+    __with_err.__has_val_ = true;
+  }
+};
+
+template <class _Tp, class _Err, bool =
+          (_LIBCUDACXX_TRAIT(is_trivially_copy_constructible, _Tp) || _LIBCUDACXX_TRAIT(is_same, _Tp, void)) &&
+           _LIBCUDACXX_TRAIT(is_trivially_copy_constructible, _Err)>
+struct __expected_copy : __expected_storage<_Tp, _Err>
+{
+  using __base = __expected_storage<_Tp, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  constexpr __expected_copy() noexcept = default;
+
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_copy(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+};
+
+template <class _Tp, class _Err>
+struct __expected_copy<_Tp, _Err, false> : __expected_storage<_Tp, _Err>
+{
+  using __base = __expected_storage<_Tp, _Err>;
+
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_copy(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+  constexpr __expected_copy() noexcept = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  __expected_copy(const __expected_copy& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_copy_constructible, _Tp)
+          && _LIBCUDACXX_TRAIT(is_nothrow_copy_constructible, _Err))
+    : __base(__other.__has_val_)
+  {
+    if (__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__val_, __other.__union_.__val_);
+    } else {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, __other.__union_.__unex_);
+    }
+  }
+
+  __expected_copy(__expected_copy&&) = default;
+  __expected_copy& operator=(const __expected_copy&) = default;
+  __expected_copy& operator=(__expected_copy&&) = default;
+};
+
+template <class _Tp, class _Err, bool =
+          (_LIBCUDACXX_TRAIT(is_trivially_move_constructible, _Tp) || _LIBCUDACXX_TRAIT(is_same, _Tp, void)) &&
+           _LIBCUDACXX_TRAIT(is_trivially_move_constructible, _Err)>
+struct __expected_move : __expected_copy<_Tp, _Err>
+{
+  using __base = __expected_copy<_Tp, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  constexpr __expected_move() noexcept = default;
+
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_move(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+};
+
+template <class _Tp, class _Err>
+struct __expected_move<_Tp, _Err, false> : __expected_copy<_Tp, _Err>
+{
+  using __base = __expected_copy<_Tp, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_move(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+  __expected_move() = default;
+  __expected_move(const __expected_move&) = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  __expected_move(__expected_move&& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp)
+          && _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err))
+    : __base(__other.__has_val_)
+  {
+    if (__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__val_, _CUDA_VSTD::move(__other.__union_.__val_));
+    } else {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, _CUDA_VSTD::move(__other.__union_.__unex_));
+    }
+  }
+
+  __expected_move& operator=(const __expected_move&) = default;
+  __expected_move& operator=(__expected_move&&) = default;
+};
+
+template <class _Tp, class _Err, bool =
+          (_LIBCUDACXX_TRAIT(is_trivially_destructible, _Tp)  || _LIBCUDACXX_TRAIT(is_same, _Tp, void)) &&
+           _LIBCUDACXX_TRAIT(is_trivially_destructible, _Err) &&
+          (_LIBCUDACXX_TRAIT(is_trivially_copy_constructible, _Tp)  || _LIBCUDACXX_TRAIT(is_same, _Tp, void))&&
+           _LIBCUDACXX_TRAIT(is_trivially_copy_constructible, _Err) &&
+          (_LIBCUDACXX_TRAIT(is_trivially_copy_assignable, _Tp)  || _LIBCUDACXX_TRAIT(is_same, _Tp, void))&&
+           _LIBCUDACXX_TRAIT(is_trivially_copy_assignable, _Err)>
+struct __expected_copy_assign : __expected_move<_Tp, _Err>
+{
+  using __base = __expected_move<_Tp, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  constexpr __expected_copy_assign() noexcept = default;
+
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_copy_assign(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+};
+
+template <class _Tp, class _Err>
+struct __expected_copy_assign<_Tp, _Err, false> : __expected_move<_Tp, _Err>
+{
+  using __base = __expected_move<_Tp, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_copy_assign(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+  __expected_copy_assign() = default;
+  __expected_copy_assign(const __expected_copy_assign&) = default;
+  __expected_copy_assign(__expected_copy_assign&&) = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  __expected_copy_assign& operator=(const __expected_copy_assign& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_copy_assignable, _Tp) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_copy_constructible, _Tp) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_copy_assignable, _Err) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_copy_constructible, _Err)) // strengthened
+  {
+    if (this->__has_val_ && __other.__has_val_) {
+      this->__union_.__val_ = __other.__union_.__val_;
+    } else if (this->__has_val_ && !__other.__has_val_) {
+      this->__reinit_expected(this->__union_.__unex_, this->__union_.__val_, __other.__union_.__unex_);
+      this->__has_val_ = false;
+    } else if (!this->__has_val_ && __other.__has_val_) {
+      this->__reinit_expected(this->__union_.__val_, this->__union_.__unex_, __other.__union_.__val_);
+      this->__has_val_ = true;
+    } else { // !this->__has_val_ && !__other.__has_val_
+      this->__union_.__unex_ = __other.__union_.__unex_;
+    }
+    return *this;
+  }
+
+  __expected_copy_assign& operator=(__expected_copy_assign&&) = default;
+};
+
+template <class _Tp, class _Err, bool =
+          (_LIBCUDACXX_TRAIT(is_trivially_destructible, _Tp) || _LIBCUDACXX_TRAIT(is_same, _Tp, void)) &&
+          _LIBCUDACXX_TRAIT(is_trivially_destructible, _Err) &&
+          (_LIBCUDACXX_TRAIT(is_trivially_move_constructible, _Tp) || _LIBCUDACXX_TRAIT(is_same, _Tp, void)) &&
+          _LIBCUDACXX_TRAIT(is_trivially_move_constructible, _Err) &&
+          (_LIBCUDACXX_TRAIT(is_trivially_move_assignable, _Tp) || _LIBCUDACXX_TRAIT(is_same, _Tp, void)) &&
+          _LIBCUDACXX_TRAIT(is_trivially_move_assignable, _Err)>
+struct __expected_move_assign : __expected_copy_assign<_Tp, _Err>
+{
+  using __base = __expected_copy_assign<_Tp, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  constexpr __expected_move_assign() noexcept = default;
+
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_move_assign(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+};
+
+template <class _Tp, class _Err>
+struct __expected_move_assign<_Tp, _Err, false> : __expected_copy_assign<_Tp, _Err>
+{
+  using __base = __expected_copy_assign<_Tp, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_move_assign(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+  __expected_move_assign() = default;
+  __expected_move_assign(const __expected_move_assign&) = default;
+  __expected_move_assign(__expected_move_assign&&) = default;
+  __expected_move_assign& operator=(const __expected_move_assign&) = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  __expected_move_assign& operator=(__expected_move_assign&& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_assignable, _Tp) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_move_assignable, _Err) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err)) // strengthened
+  {
+    if (this->__has_val_ && __other.__has_val_) {
+      this->__union_.__val_ = _CUDA_VSTD::move(__other.__union_.__val_);
+    } else if (this->__has_val_ && !__other.__has_val_) {
+      this->__reinit_expected(this->__union_.__unex_, this->__union_.__val_, _CUDA_VSTD::move(__other.__union_.__unex_));
+      this->__has_val_ = false;
+    } else if (!this->__has_val_ && __other.__has_val_) {
+      this->__reinit_expected(this->__union_.__val_, this->__union_.__unex_, _CUDA_VSTD::move(__other.__union_.__val_));
+      this->__has_val_ = true;
+    } else { // !this->__has_val_ && !__other.__has_val_
+      this->__union_.__unex_ = _CUDA_VSTD::move(__other.__union_.__unex_);
+    }
+    return *this;
+  }
+};
+
+template <class _Tp, class _Err>
+using __expected_sfinae_ctor_base_t = __sfinae_ctor_base<
+  _LIBCUDACXX_TRAIT(is_copy_constructible, _Tp) && _LIBCUDACXX_TRAIT(is_copy_constructible, _Err),
+  _LIBCUDACXX_TRAIT(is_move_constructible, _Tp) && _LIBCUDACXX_TRAIT(is_move_constructible, _Err)
+>;
+
+template <class _Tp, class _Err>
+using __expected_sfinae_assign_base_t = __sfinae_assign_base<
+  _LIBCUDACXX_TRAIT(is_copy_constructible, _Tp) && _LIBCUDACXX_TRAIT(is_copy_constructible, _Err) &&
+  _LIBCUDACXX_TRAIT(is_copy_assignable, _Tp)    && _LIBCUDACXX_TRAIT(is_copy_assignable, _Err) &&
+  (_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp) || _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err)),
+  _LIBCUDACXX_TRAIT(is_move_constructible, _Tp) && _LIBCUDACXX_TRAIT(is_move_constructible, _Err) &&
+  _LIBCUDACXX_TRAIT(is_move_assignable, _Tp)    && _LIBCUDACXX_TRAIT(is_move_assignable, _Err) &&
+ (_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp) || _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err))
+>;
+
+// expected<void, E> base classtemplate <class _Tp, class _Err>
+// MSVC complains about [[no_unique_address]] prior to C++20 as a vendor extension
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#pragma warning(push)
+#pragma warning(disable : 4848)
+#endif // _LIBCUDACXX_COMPILER_MSVC
+
+template <class _Err>
+struct __expected_destruct<void, _Err, false, false> {
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS union __expected_union_t {
+    struct __empty_t {};
+
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    __expected_union_t() noexcept : __empty_() {}
+
+    template<class... _Args>
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    __expected_union_t(unexpect_t, _Args&&... __args)
+      noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...))
+      : __unex_(_CUDA_VSTD::forward<_Args>(__args)...) {}
+
+    template<class _Fun, class... _Args>
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    __expected_union_t(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+      noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+      : __unex_(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)) {}
+
+    // the __expected_destruct's destructor handles this
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    ~__expected_union_t() {}
+
+    _LIBCUDACXX_NO_UNIQUE_ADDRESS __empty_t __empty_;
+    _LIBCUDACXX_NO_UNIQUE_ADDRESS _Err __unex_;
+  } __union_{};
+  bool __has_val_{true};
+
+  constexpr __expected_destruct() noexcept = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(const bool __has_val) noexcept : __has_val_(__has_val) {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(unexpect_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...))
+    : __union_(unexpect, _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+    : __union_(__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  ~__expected_destruct() {
+    if (!__has_val_) {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__union_.__unex_));
+    }
+  }
+};
+
+template <class _Err>
+struct __expected_destruct<void, _Err, false, true> {
+  // Using `_LIBCUDACXX_NO_UNIQUE_ADDRESS` here crashes nvcc
+  /* _LIBCUDACXX_NO_UNIQUE_ADDRESS */ union __expected_union_t {
+    struct __empty_t {};
+
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    __expected_union_t() noexcept : __empty_() {}
+
+    template<class... _Args>
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    __expected_union_t(unexpect_t, _Args&&... __args)
+      noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...))
+      : __unex_(_CUDA_VSTD::forward<_Args>(__args)...) {}
+
+    template<class _Fun, class... _Args>
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    __expected_union_t(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+      noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+      : __unex_(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)) {}
+
+    _LIBCUDACXX_NO_UNIQUE_ADDRESS __empty_t __empty_;
+    _LIBCUDACXX_NO_UNIQUE_ADDRESS _Err __unex_;
+  } __union_{};
+  bool __has_val_{true};
+
+  constexpr __expected_destruct() noexcept = default;
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(in_place_t)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...))
+    : __union_()
+    , __has_val_(true)
+  {}
+
+  template<class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(unexpect_t, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...))
+    : __union_(unexpect, _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  template<class _Fun, class... _Args>
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(__expected_construct_from_invoke_tag, unexpect_t, _Fun&& __fun, _Args&&... __args)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, invoke_result_t<_Fun, _Args...>))
+    : __union_(__expected_construct_from_invoke_tag{}, unexpect, _CUDA_VSTD::forward<_Fun>(__fun), _CUDA_VSTD::forward<_Args>(__args)...)
+    , __has_val_(false)
+  {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_destruct(const bool __has_val) noexcept : __has_val_(__has_val) {}
+};
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#pragma warning(pop)
+#endif // _LIBCUDACXX_COMPILER_MSVC
+
+template <class _Err>
+struct __expected_storage<void, _Err> : __expected_destruct<void, _Err>
+{
+  using __base = __expected_destruct<void, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  constexpr __expected_storage() noexcept = default;
+
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_storage(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+  static _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  void __swap_val_unex_impl(__expected_storage& __with_val, __expected_storage& __with_err)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err)) {
+    _LIBCUDACXX_CONSTRUCT_AT(__with_val.__union_.__unex_, _CUDA_VSTD::move(__with_err.__union_.__unex_));
+    _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(__with_err.__union_.__unex_));
+    __with_val.__has_val_ = false;
+    __with_err.__has_val_ = true;
+  }
+};
+
+template <class _Err>
+struct __expected_copy<void, _Err, false> : __expected_storage<void, _Err>
+{
+  using __base = __expected_storage<void, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_copy(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+  constexpr __expected_copy() = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  __expected_copy(const __expected_copy& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_copy_constructible, _Err))
+    : __base(__other.__has_val_)
+  {
+    if (!__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, __other.__union_.__unex_);
+    }
+  }
+
+  __expected_copy(__expected_copy&&) = default;
+  __expected_copy& operator=(const __expected_copy&) = default;
+  __expected_copy& operator=(__expected_copy&&) = default;
+};
+
+template <class _Err>
+struct __expected_move<void, _Err, false> : __expected_copy<void, _Err>
+{
+  using __base = __expected_copy<void, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_move(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+  __expected_move() = default;
+  __expected_move(const __expected_move&) = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  __expected_move(__expected_move&& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err))
+    : __base(__other.__has_val_)
+  {
+    if (!__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, _CUDA_VSTD::move(__other.__union_.__unex_));
+    }
+  }
+
+  __expected_move& operator=(const __expected_move&) = default;
+  __expected_move& operator=(__expected_move&&) = default;
+};
+
+template <class _Err>
+struct __expected_copy_assign<void, _Err, false> : __expected_move<void, _Err>
+{
+  using __base = __expected_move<void, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_copy_assign(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+  __expected_copy_assign() = default;
+  __expected_copy_assign(const __expected_copy_assign&) = default;
+  __expected_copy_assign(__expected_copy_assign&&) = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  __expected_copy_assign& operator=(const __expected_copy_assign& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_copy_assignable, _Err) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_copy_constructible, _Err)) // strengthened
+  {
+    if (this->__has_val_ && __other.__has_val_) {
+      // nothing to do
+    } else if (this->__has_val_ && !__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, __other.__union_.__unex_);
+      this->__has_val_ = false;
+    } else if (!this->__has_val_ && __other.__has_val_) {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(this->__union_.__unex_));
+      this->__has_val_ = true;
+    } else { // !this->__has_val_ && !__other.__has_val_
+      this->__union_.__unex_ = __other.__union_.__unex_;
+    }
+    return *this;
+  }
+
+  __expected_copy_assign& operator=(__expected_copy_assign&&) = default;
+};
+
+template <class _Err>
+struct __expected_move_assign<void, _Err, false> : __expected_copy_assign<void, _Err>
+{
+  using __base = __expected_copy_assign<void, _Err>;
+// nvbug3961621
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ || (defined(_LIBCUDACXX_CUDACC_BELOW_11_3) && defined(_LIBCUDACXX_COMPILER_CLANG))
+  template<class... _Args, __enable_if_t<_LIBCUDACXX_TRAIT(is_constructible, __base, _Args...), int> = 0>
+   _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  __expected_move_assign(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+    : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+  {}
+#else // ^^^ _LIBCUDACXX_COMPILER_NVRTC || nvcc < 11.3 ^^^ / vvv !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3 vvv
+  using __base::__base;
+#endif // !_LIBCUDACXX_COMPILER_NVRTC || nvcc >= 11.3
+
+  __expected_move_assign() = default;
+  __expected_move_assign(const __expected_move_assign&) = default;
+  __expected_move_assign(__expected_move_assign&&) = default;
+  __expected_move_assign& operator=(const __expected_move_assign&) = default;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  __expected_move_assign& operator=(__expected_move_assign&& __other)
+    noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_assignable, _Err) &&
+             _LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Err)) // strengthened
+  {
+    if (this->__has_val_ && __other.__has_val_) {
+      // nothing to do
+    } else if (this->__has_val_ && !__other.__has_val_) {
+      _LIBCUDACXX_CONSTRUCT_AT(this->__union_.__unex_, _CUDA_VSTD::move(__other.__union_.__unex_));
+      this->__has_val_ = false;
+    } else if (!this->__has_val_ && __other.__has_val_) {
+      _CUDA_VSTD::__destroy_at(_CUDA_VSTD::addressof(this->__union_.__unex_));
+      this->__has_val_ = true;
+    } else { // !this->__has_val_ && !__other.__has_val_
+      this->__union_.__unex_ = _CUDA_VSTD::move(__other.__union_.__unex_);
+    }
+    return *this;
+  }
+};
+
+template <class _Err>
+using __expected_void_sfinae_ctor_base_t = __sfinae_ctor_base<
+  _LIBCUDACXX_TRAIT(is_copy_constructible, _Err),
+  _LIBCUDACXX_TRAIT(is_move_constructible, _Err)
+>;
+
+template <class _Err>
+using __expected_void_sfinae_assign_base_t = __sfinae_assign_base<
+  _LIBCUDACXX_TRAIT(is_copy_constructible, _Err) &&
+  _LIBCUDACXX_TRAIT(is_copy_assignable, _Err),
+  _LIBCUDACXX_TRAIT(is_move_constructible, _Err) &&
+  _LIBCUDACXX_TRAIT(is_move_assignable, _Err)
+>;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+#endif // _LIBCUDACXX___EXPECTED_EXPECTED_BASE_H

cuda_toolkit/include/__expected/unexpect.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) 2022 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCUDACXX___EXPECTED_UNEXPECT_H
+#define _LIBCUDACXX___EXPECTED_UNEXPECT_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#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 _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct unexpect_t {
+  explicit unexpect_t() = default;
+};
+
+_LIBCUDACXX_CPO_ACCESSIBILITY unexpect_t unexpect{};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+#endif // _LIBCUDACXX___EXPECTED_UNEXPECT_H

cuda_toolkit/include/__expected/unexpected.h

@@ -0,0 +1,170 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___EXPECTED_UNEXPECTED_H
+#define _LIBCUDACXX___EXPECTED_UNEXPECTED_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_array.h"
+#include "../__type_traits/is_const.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_nothrow_constructible.h"
+#include "../__type_traits/is_object.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/is_swappable.h"
+#include "../__type_traits/is_volatile.h"
+#include "../__type_traits/remove_cvref.h"
+#include "../__utility/forward.h"
+#include "../__utility/in_place.h"
+#include "../__utility/move.h"
+
+#include "../initializer_list"
+
+#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
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template <class _Err>
+class unexpected;
+
+namespace __unexpected {
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool __is_unexpected = false;
+
+template <class _Err>
+_LIBCUDACXX_INLINE_VAR constexpr bool __is_unexpected<unexpected<_Err>> = true;
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool __valid_unexpected = _LIBCUDACXX_TRAIT(is_object, _Tp) &&
+                                                          !_LIBCUDACXX_TRAIT(is_array, _Tp) &&
+                                                          !__is_unexpected<_Tp> &&
+                                                          !_LIBCUDACXX_TRAIT(is_const, _Tp) &&
+                                                          !_LIBCUDACXX_TRAIT(is_volatile, _Tp);
+} // namespace __unexpected
+
+// [expected.un.general]
+template <class _Err>
+class unexpected {
+  static_assert(__unexpected::__valid_unexpected<_Err>,
+                "[expected.un.general] states a program that instantiates std::unexpected for a non-object type, an "
+                "array type, a specialization of unexpected, or a cv-qualified type is ill-formed.");
+
+  template <class, class>
+  friend class expected;
+
+public:
+  // [expected.un.ctor]
+  _LIBCUDACXX_HIDE_FROM_ABI unexpected(const unexpected&) = default;
+  _LIBCUDACXX_HIDE_FROM_ABI unexpected(unexpected&&)      = default;
+
+  _LIBCUDACXX_TEMPLATE(class _Error = _Err)
+    _LIBCUDACXX_REQUIRES( (!_LIBCUDACXX_TRAIT(is_same, remove_cvref_t<_Error>, unexpected) &&
+               !_LIBCUDACXX_TRAIT(is_same, remove_cvref_t<_Error>, in_place_t) &&
+               _LIBCUDACXX_TRAIT(is_constructible, _Err, _Error)))
+  _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr explicit unexpected(_Error&& __error) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Error))
+    : __unex_(_CUDA_VSTD::forward<_Error>(__error)) {}
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, _Args...))
+  _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr explicit unexpected(in_place_t, _Args&&... __args) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, _Args...))
+    : __unex_(_CUDA_VSTD::forward<_Args>(__args)...) {}
+
+  _LIBCUDACXX_TEMPLATE(class _Up, class... _Args)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_constructible, _Err, initializer_list<_Up>&, _Args...))
+  _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr explicit unexpected(in_place_t, initializer_list<_Up> __il, _Args&&... __args) noexcept(
+    _LIBCUDACXX_TRAIT(is_nothrow_constructible, _Err, initializer_list<_Up>&, _Args...))
+    : __unex_(__il, _CUDA_VSTD::forward<_Args>(__args)...) {}
+
+  constexpr unexpected& operator=(const unexpected&) = default;
+  constexpr unexpected& operator=(unexpected&&)      = default;
+
+  // [expected.un.obs]
+  _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr const _Err& error() const& noexcept {
+    return __unex_;
+  }
+
+  _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr _Err& error() & noexcept {
+    return __unex_;
+  }
+
+  _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr const _Err&& error() const&& noexcept {
+    return _CUDA_VSTD::move(__unex_);
+  }
+
+  _LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr _Err&& error() && noexcept {
+    return _CUDA_VSTD::move(__unex_);
+  }
+
+  // [expected.un.swap]
+  _LIBCUDACXX_INLINE_VISIBILITY
+  constexpr void swap(unexpected& __other) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_swappable, _Err)) {
+    static_assert(_LIBCUDACXX_TRAIT(is_swappable, _Err), "E must be swappable");
+    using _CUDA_VSTD::swap;
+    swap(__unex_, __other.__unex_);
+  }
+
+  _LIBCUDACXX_TEMPLATE(class _Err2 = _Err)
+    _LIBCUDACXX_REQUIRES( _LIBCUDACXX_TRAIT(is_swappable, _Err2))
+  friend _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  void swap(unexpected& __lhs, unexpected& __rhs) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_swappable, _Err2))
+  {
+    __lhs.swap(__rhs);
+    return;
+  }
+
+  // [expected.un.eq]
+  template <class _UErr>
+  friend _LIBCUDACXX_INLINE_VISIBILITY constexpr
+  _LIBCUDACXX_NODISCARD_EXT bool operator==(const unexpected& __lhs, const unexpected<_UErr>& __rhs) noexcept(
+    noexcept(static_cast<bool>(__lhs.error() == __rhs.error()))) {
+    return __lhs.error() == __rhs.error();
+  }
+#if _LIBCUDACXX_STD_VER < 20
+  template <class _UErr>
+  _LIBCUDACXX_INLINE_VISIBILITY
+  _LIBCUDACXX_NODISCARD_EXT friend constexpr bool operator!=(const unexpected& __lhs, const unexpected<_UErr>& __rhs) noexcept(
+    noexcept(static_cast<bool>(__lhs.error() != __rhs.error()))) {
+    return __lhs.error() != __rhs.error();
+  }
+#endif
+
+private:
+  _Err __unex_;
+};
+
+#if _LIBCUDACXX_STD_VER > 14 && !defined(_LIBCUDACXX_HAS_NO_DEDUCTION_GUIDES)
+template <class _Err>
+unexpected(_Err) -> unexpected<_Err>;
+#endif // _LIBCUDACXX_STD_VER > 14 && !defined(_LIBCUDACXX_HAS_NO_DEDUCTION_GUIDES)
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___EXPECTED_UNEXPECTED_H

cuda_toolkit/include/__functional/binary_function.h

@@ -0,0 +1,59 @@
+// -*- 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___FUNCTIONAL_BINARY_FUNCTION_H
+#define _LIBCUDACXX___FUNCTIONAL_BINARY_FUNCTION_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#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
+
+#if _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
+
+template <class _Arg1, class _Arg2, class _Result>
+struct _LIBCUDACXX_TEMPLATE_VIS _LIBCUDACXX_DEPRECATED_IN_CXX11 binary_function
+{
+    typedef _Arg1   first_argument_type;
+    typedef _Arg2   second_argument_type;
+    typedef _Result result_type;
+};
+
+#endif // _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
+
+template <class _Arg1, class _Arg2, class _Result> struct __binary_function_keep_layout_base {
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+  using first_argument_type _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Arg1;
+  using second_argument_type _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Arg2;
+  using result_type _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Result;
+#endif
+};
+
+#if _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
+_CCCL_DIAG_SUPPRESS_DEPRECATED_PUSH
+template <class _Arg1, class _Arg2, class _Result>
+using __binary_function = binary_function<_Arg1, _Arg2, _Result>;
+_CCCL_DIAG_SUPPRESS_DEPRECATED_POP
+#else
+template <class _Arg1, class _Arg2, class _Result>
+using __binary_function = __binary_function_keep_layout_base<_Arg1, _Arg2, _Result>;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_BINARY_FUNCTION_H

cuda_toolkit/include/__functional/binary_negate.h

@@ -0,0 +1,59 @@
+// -*- 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___FUNCTIONAL_BINARY_NEGATE_H
+#define _LIBCUDACXX___FUNCTIONAL_BINARY_NEGATE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/binary_function.h"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_NEGATORS)
+
+template <class _Predicate>
+class _LIBCUDACXX_TEMPLATE_VIS _LIBCUDACXX_DEPRECATED_IN_CXX17 binary_negate
+    : public __binary_function<typename _Predicate::first_argument_type,
+                               typename _Predicate::second_argument_type,
+                               bool>
+{
+    _Predicate __pred_;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY explicit _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    binary_negate(const _Predicate& __pred) : __pred_(__pred) {}
+
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const typename _Predicate::first_argument_type& __x,
+                    const typename _Predicate::second_argument_type& __y) const
+        {return !__pred_(__x, __y);}
+};
+
+template <class _Predicate>
+_LIBCUDACXX_DEPRECATED_IN_CXX17 inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+binary_negate<_Predicate>
+not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
+
+#endif // _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_NEGATORS)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_BINARY_NEGATE_H

cuda_toolkit/include/__functional/bind.h

@@ -0,0 +1,417 @@
+// -*- 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___FUNCTIONAL_BIND_H
+#define _LIBCUDACXX___FUNCTIONAL_BIND_H
+
+// `cuda::std::bind` is not currently supported.
+
+#ifndef __cuda_std__
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/invoke.h"
+#include "../__functional/reference_wrapper.h"
+#include "../__functional/weak_result_type.h"
+#include "../__fwd/get.h"
+#include "../__tuple_dir/tuple_element.h"
+#include "../__tuple_dir/tuple_indices.h"
+#include "../__tuple_dir/tuple_size.h"
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/decay.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/is_void.h"
+#include "../__type_traits/remove_cvref.h"
+#include "../__type_traits/remove_reference.h"
+#include "../__utility/forward.h"
+
+#include "../cstddef"
+#include "../tuple"
+
+#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 is_bind_expression : _If<
+    _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
+    false_type,
+    is_bind_expression<__remove_cvref_t<_Tp> >
+> {};
+
+#if _LIBCUDACXX_STD_VER > 14
+template <class _Tp>
+inline constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value;
+#endif
+
+template<class _Tp>
+struct is_placeholder : _If<
+    _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
+    integral_constant<int, 0>,
+    is_placeholder<__remove_cvref_t<_Tp> >
+> {};
+
+#if _LIBCUDACXX_STD_VER > 14
+template <class _Tp>
+inline constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value;
+#endif
+
+namespace placeholders
+{
+
+template <int _Np> struct __ph {};
+
+#if defined(_LIBCUDACXX_BUILDING_LIBRARY)
+_LIBCUDACXX_FUNC_VIS extern const __ph<1>   _1;
+_LIBCUDACXX_FUNC_VIS extern const __ph<2>   _2;
+_LIBCUDACXX_FUNC_VIS extern const __ph<3>   _3;
+_LIBCUDACXX_FUNC_VIS extern const __ph<4>   _4;
+_LIBCUDACXX_FUNC_VIS extern const __ph<5>   _5;
+_LIBCUDACXX_FUNC_VIS extern const __ph<6>   _6;
+_LIBCUDACXX_FUNC_VIS extern const __ph<7>   _7;
+_LIBCUDACXX_FUNC_VIS extern const __ph<8>   _8;
+_LIBCUDACXX_FUNC_VIS extern const __ph<9>   _9;
+_LIBCUDACXX_FUNC_VIS extern const __ph<10> _10;
+#else
+/* _LIBCUDACXX_INLINE_VAR */ constexpr __ph<1>   _1{};
+/* _LIBCUDACXX_INLINE_VAR */ constexpr __ph<2>   _2{};
+/* _LIBCUDACXX_INLINE_VAR */ constexpr __ph<3>   _3{};
+/* _LIBCUDACXX_INLINE_VAR */ constexpr __ph<4>   _4{};
+/* _LIBCUDACXX_INLINE_VAR */ constexpr __ph<5>   _5{};
+/* _LIBCUDACXX_INLINE_VAR */ constexpr __ph<6>   _6{};
+/* _LIBCUDACXX_INLINE_VAR */ constexpr __ph<7>   _7{};
+/* _LIBCUDACXX_INLINE_VAR */ constexpr __ph<8>   _8{};
+/* _LIBCUDACXX_INLINE_VAR */ constexpr __ph<9>   _9{};
+/* _LIBCUDACXX_INLINE_VAR */ constexpr __ph<10> _10{};
+#endif // defined(_LIBCUDACXX_BUILDING_LIBRARY)
+
+} // namespace placeholders
+
+template<int _Np>
+struct is_placeholder<placeholders::__ph<_Np> >
+    : public integral_constant<int, _Np> {};
+
+
+template <class _Tp, class _Uj>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+_Tp&
+__mu(reference_wrapper<_Tp> __t, _Uj&)
+{
+    return __t.get();
+}
+
+template <class _Ti, class ..._Uj, size_t ..._Indx>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+typename __invoke_of<_Ti&, _Uj...>::type
+__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
+{
+    return __ti(_CUDA_VSTD::forward<_Uj>(_CUDA_VSTD::get<_Indx>(__uj))...);
+}
+
+template <class _Ti, class ..._Uj>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__enable_if_t
+<
+    is_bind_expression<_Ti>::value,
+    __invoke_of<_Ti&, _Uj...>
+>
+__mu(_Ti& __ti, tuple<_Uj...>& __uj)
+{
+    typedef __make_tuple_indices_t<sizeof...(_Uj)> __indices;
+    return _CUDA_VSTD::__mu_expand(__ti, __uj, __indices());
+}
+
+template <bool IsPh, class _Ti, class _Uj>
+struct __mu_return2 {};
+
+template <class _Ti, class _Uj>
+struct __mu_return2<true, _Ti, _Uj>
+{
+  typedef __tuple_element_t<is_placeholder<_Ti>::value - 1, _Uj> type;
+};
+
+template <class _Ti, class _Uj>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__enable_if_t
+<
+    0 < is_placeholder<_Ti>::value,
+    typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
+>
+__mu(_Ti&, _Uj& __uj)
+{
+  const size_t _Indx = is_placeholder<_Ti>::value - 1;
+  return _CUDA_VSTD::forward<__tuple_element_t<_Indx, _Uj>>(_CUDA_VSTD::get<_Indx>(__uj));
+}
+
+template <class _Ti, class _Uj>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__enable_if_t
+<
+    !is_bind_expression<_Ti>::value &&
+    is_placeholder<_Ti>::value == 0 &&
+    !__is_reference_wrapper<_Ti>::value,
+    _Ti&
+>
+__mu(_Ti& __ti, _Uj&)
+{
+    return __ti;
+}
+
+template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
+          class _TupleUj>
+struct __mu_return_impl;
+
+template <bool _Invokable, class _Ti, class ..._Uj>
+struct __mu_return_invokable  // false
+{
+    typedef __nat type;
+};
+
+template <class _Ti, class ..._Uj>
+struct __mu_return_invokable<true, _Ti, _Uj...>
+{
+    typedef typename __invoke_of<_Ti&, _Uj...>::type type;
+};
+
+template <class _Ti, class ..._Uj>
+struct __mu_return_impl<_Ti, false, true, false, tuple<_Uj...> >
+    : public __mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...>
+{
+};
+
+template <class _Ti, class _TupleUj>
+struct __mu_return_impl<_Ti, false, false, true, _TupleUj>
+{
+  typedef __tuple_element_t<is_placeholder<_Ti>::value - 1, _TupleUj>&& type;
+};
+
+template <class _Ti, class _TupleUj>
+struct __mu_return_impl<_Ti, true, false, false, _TupleUj>
+{
+    typedef typename _Ti::type& type;
+};
+
+template <class _Ti, class _TupleUj>
+struct __mu_return_impl<_Ti, false, false, false, _TupleUj>
+{
+    typedef _Ti& type;
+};
+
+template <class _Ti, class _TupleUj>
+struct __mu_return
+    : public __mu_return_impl<_Ti,
+                              __is_reference_wrapper<_Ti>::value,
+                              is_bind_expression<_Ti>::value,
+                              0 < is_placeholder<_Ti>::value &&
+                              is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
+                              _TupleUj>
+{
+};
+
+template <class _Fp, class _BoundArgs, class _TupleUj>
+struct __is_valid_bind_return
+{
+    static const bool value = false;
+};
+
+template <class _Fp, class ..._BoundArgs, class _TupleUj>
+struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
+{
+    static const bool value = __invokable<_Fp,
+                    typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
+};
+
+template <class _Fp, class ..._BoundArgs, class _TupleUj>
+struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
+{
+    static const bool value = __invokable<_Fp,
+                    typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
+};
+
+template <class _Fp, class _BoundArgs, class _TupleUj,
+          bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
+struct __bind_return;
+
+template <class _Fp, class ..._BoundArgs, class _TupleUj>
+struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>
+{
+    typedef typename __invoke_of
+    <
+        _Fp&,
+        typename __mu_return
+        <
+            _BoundArgs,
+            _TupleUj
+        >::type...
+    >::type type;
+};
+
+template <class _Fp, class ..._BoundArgs, class _TupleUj>
+struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>
+{
+    typedef typename __invoke_of
+    <
+        _Fp&,
+        typename __mu_return
+        <
+            const _BoundArgs,
+            _TupleUj
+        >::type...
+    >::type type;
+};
+
+template <class _Fp, class _BoundArgs, class _TupleUj>
+using __bind_return_t = typename __bind_return<_Fp, _BoundArgs, _TupleUj>::type;
+
+template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bind_return_t<_Fp, _BoundArgs, _Args>
+__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
+                _Args&& __args)
+{
+    return _CUDA_VSTD::__invoke(__f, _CUDA_VSTD::__mu(_CUDA_VSTD::get<_Indx>(__bound_args), __args)...);
+}
+
+template<class _Fp, class ..._BoundArgs>
+class __bind : public __weak_result_type<__decay_t<_Fp>>
+{
+protected:
+    typedef __decay_t<_Fp> _Fd;
+    typedef tuple<__decay_t<_BoundArgs>...> _Td;
+private:
+    _Fd __f_;
+    _Td __bound_args_;
+
+    typedef __make_tuple_indices_t<sizeof...(_BoundArgs)> __indices;
+public:
+    template <class _Gp, class ..._BA,
+              class = __enable_if_t
+                               <
+                                  is_constructible<_Fd, _Gp>::value &&
+                                  !is_same<__libcpp_remove_reference_t<_Gp>,
+                                           __bind>::value
+                               >>
+      _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+      explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
+        : __f_(_CUDA_VSTD::forward<_Gp>(__f)),
+          __bound_args_(_CUDA_VSTD::forward<_BA>(__bound_args)...) {}
+
+    template <class ..._Args>
+        _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+        __bind_return_t<_Fd, _Td, tuple<_Args&&...>>
+        operator()(_Args&& ...__args)
+        {
+            return _CUDA_VSTD::__apply_functor(__f_, __bound_args_, __indices(),
+                                  tuple<_Args&&...>(_CUDA_VSTD::forward<_Args>(__args)...));
+        }
+
+    template <class ..._Args>
+        _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+        __bind_return_t<const _Fd, const _Td, tuple<_Args&&...>>
+        operator()(_Args&& ...__args) const
+        {
+            return _CUDA_VSTD::__apply_functor(__f_, __bound_args_, __indices(),
+                                   tuple<_Args&&...>(_CUDA_VSTD::forward<_Args>(__args)...));
+        }
+};
+
+template<class _Fp, class ..._BoundArgs>
+struct is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};
+
+template<class _Rp, class _Fp, class ..._BoundArgs>
+class __bind_r
+    : public __bind<_Fp, _BoundArgs...>
+{
+    typedef __bind<_Fp, _BoundArgs...> base;
+    typedef typename base::_Fd _Fd;
+    typedef typename base::_Td _Td;
+public:
+    typedef _Rp result_type;
+
+
+    template <class _Gp, class ..._BA,
+              class = __enable_if_t
+                               <
+                                  is_constructible<_Fd, _Gp>::value &&
+                                  !is_same<__libcpp_remove_reference_t<_Gp>,
+                                           __bind_r>::value
+                               >>
+      _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+      explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
+        : base(_CUDA_VSTD::forward<_Gp>(__f),
+               _CUDA_VSTD::forward<_BA>(__bound_args)...) {}
+
+    template <class ..._Args>
+        _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+        __enable_if_t
+        <
+            is_convertible<__bind_return_t<_Fd, _Td, tuple<_Args&&...>>,
+                           result_type>::value || is_void<_Rp>::value,
+            result_type
+        >
+        operator()(_Args&& ...__args)
+        {
+            typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+            return _Invoker::__call(static_cast<base&>(*this), _CUDA_VSTD::forward<_Args>(__args)...);
+        }
+
+    template <class ..._Args>
+        _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+        __enable_if_t
+        <
+            is_convertible<__bind_return_t<const _Fd, const _Td, tuple<_Args&&...>>,
+                           result_type>::value || is_void<_Rp>::value,
+            result_type
+        >
+        operator()(_Args&& ...__args) const
+        {
+            typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+            return _Invoker::__call(static_cast<base const&>(*this), _CUDA_VSTD::forward<_Args>(__args)...);
+        }
+};
+
+template<class _Rp, class _Fp, class ..._BoundArgs>
+struct is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
+
+template<class _Fp, class ..._BoundArgs>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+__bind<_Fp, _BoundArgs...>
+bind(_Fp&& __f, _BoundArgs&&... __bound_args)
+{
+    typedef __bind<_Fp, _BoundArgs...> type;
+    return type(_CUDA_VSTD::forward<_Fp>(__f), _CUDA_VSTD::forward<_BoundArgs>(__bound_args)...);
+}
+
+template<class _Rp, class _Fp, class ..._BoundArgs>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+__bind_r<_Rp, _Fp, _BoundArgs...>
+bind(_Fp&& __f, _BoundArgs&&... __bound_args)
+{
+    typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
+    return type(_CUDA_VSTD::forward<_Fp>(__f), _CUDA_VSTD::forward<_BoundArgs>(__bound_args)...);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // __cuda_std__
+
+#endif // _LIBCUDACXX___FUNCTIONAL_BIND_H

cuda_toolkit/include/__functional/bind_back.h

@@ -0,0 +1,79 @@
+// -*- 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___FUNCTIONAL_BIND_BACK_H
+#define _LIBCUDACXX___FUNCTIONAL_BIND_BACK_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/invoke.h"
+#include "../__functional/perfect_forward.h"
+#include "../__fwd/get.h"
+#include "../__tuple_dir/tuple_size.h"
+#include "../__type_traits/decay.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_move_constructible.h"
+#include "../__utility/forward.h"
+#include "../__utility/integer_sequence.h"
+
+#include "../tuple"
+
+#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
+
+#if _LIBCUDACXX_STD_VER > 14
+
+template <size_t _NBound, class = make_index_sequence<_NBound>>
+struct __bind_back_op;
+
+template <size_t _NBound, size_t ..._Ip>
+struct __bind_back_op<_NBound, index_sequence<_Ip...>> {
+    template <class _Fn, class _BoundArgs, class... _Args>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr auto operator()(_Fn&& __f, _BoundArgs&& __bound_args, _Args&&... __args) const
+        noexcept(noexcept(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)..., _CUDA_VSTD::get<_Ip>(_CUDA_VSTD::forward<_BoundArgs>(__bound_args))...)))
+        -> decltype(      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)..., _CUDA_VSTD::get<_Ip>(_CUDA_VSTD::forward<_BoundArgs>(__bound_args))...))
+        { return          _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)..., _CUDA_VSTD::get<_Ip>(_CUDA_VSTD::forward<_BoundArgs>(__bound_args))...); }
+};
+
+template <class _Fn, class _BoundArgs>
+struct __bind_back_t : __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs> {
+    using __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs>::__perfect_forward;
+};
+
+template <class _Fn, class ..._Args, class = enable_if_t<
+    _And<
+        is_constructible<decay_t<_Fn>, _Fn>,
+        is_move_constructible<decay_t<_Fn>>,
+        is_constructible<decay_t<_Args>, _Args>...,
+        is_move_constructible<decay_t<_Args>>...
+    >::value
+>>
+_LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+constexpr auto __bind_back(_Fn&& __f, _Args&&... __args)
+    noexcept(noexcept(__bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Args>(__args)...))))
+    -> decltype(      __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Args>(__args)...)))
+    { return          __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Args>(__args)...)); }
+
+#endif // _LIBCUDACXX_STD_VER > 14
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_BIND_BACK_H