Add files using upload-large-folder tool

cuda_toolkit/include/cuda/std/array

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the CUDA Toolkit, 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_STD_ARRAY
+#define _CUDA_STD_ARRAY
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/array"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_ARRAY

cuda_toolkit/include/cuda/std/atomic

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_ATOMIC
+#define _CUDA_STD_ATOMIC
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/atomic"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_ATOMIC

cuda_toolkit/include/cuda/std/barrier

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_BARRIER
+#define _CUDA_STD_BARRIER
+
+#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ < 700
+#  error "CUDA synchronization primitives are only supported for sm_70 and up."
+#endif
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/barrier"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_BARRIER

cuda_toolkit/include/cuda/std/bit

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_BIT
+#define _CUDA_STD_BIT
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/bit"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_BIT

cuda_toolkit/include/cuda/std/cassert

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_CASSERT
+#define _CUDA_STD_CASSERT
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/cassert"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_CASSERT

cuda_toolkit/include/cuda/std/ccomplex

@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the CUDA Toolkit, 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_STD_CCOMPLEX
+#define _CUDA_STD_CCOMPLEX
+
+#include "complex"
+
+#endif // _CUDA_STD_CCOMPLEX

cuda_toolkit/include/cuda/std/cfloat

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_CFLOAT
+#define _CUDA_STD_CFLOAT
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/cfloat"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_CFLOAT

cuda_toolkit/include/cuda/std/chrono

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_CHRONO
+#define _CUDA_STD_CHRONO
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/chrono"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_CHRONO

cuda_toolkit/include/cuda/std/climits

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_CLIMITS
+#define _CUDA_STD_CLIMITS
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/climits"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_CLIMITS

cuda_toolkit/include/cuda/std/cmath

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the CUDA Toolkit, 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_STD_CMATH
+#define _CUDA_STD_CMATH
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/cmath"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_CMATH

cuda_toolkit/include/cuda/std/complex

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the CUDA Toolkit, 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_STD_COMPLEX
+#define _CUDA_STD_COMPLEX
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/complex"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_COMPLEX

cuda_toolkit/include/cuda/std/concepts

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the CUDA Toolkit, 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_STD_CONCEPTS
+#define _CUDA_STD_CONCEPTS
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/concepts"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_CONCEPTS

cuda_toolkit/include/cuda/std/cstddef

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_CSTDDEF
+#define _CUDA_STD_CSTDDEF
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/cstddef"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_CSTDDEF

cuda_toolkit/include/cuda/std/cstdint

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_CSTDINT
+#define _CUDA_STD_CSTDINT
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/cstdint"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_CSTDINT

cuda_toolkit/include/cuda/std/ctime

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_CTIME
+#define _CUDA_STD_CTIME
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/libcxx/include/ctime"
+
+#include "detail/__pragma_pop"
+
+#endif // _CUDA_STD_CTIME

cuda_toolkit/include/cuda/std/detail/__access_property

@@ -0,0 +1,327 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ *
+ * NVIDIA SOFTWARE LICENSE
+ *
+ * This license is a legal agreement between you and NVIDIA Corporation ("NVIDIA") and governs your use of the NVIDIA/CUDA C++ Library software and materials provided hereunder (“SOFTWARE”).
+ *
+ * This license can be accepted only by an adult of legal age of majority in the country in which the SOFTWARE is used. If you are under the legal age of majority, you must ask your parent or legal guardian to consent to this license. By taking delivery of the SOFTWARE, you affirm that you have reached the legal age of majority, you accept the terms of this license, and you take legal and financial responsibility for the actions of your permitted users.
+ *
+ * You agree to use the SOFTWARE only for purposes that are permitted by (a) this license, and (b) any applicable law, regulation or generally accepted practices or guidelines in the relevant jurisdictions.
+ *
+ * 1. LICENSE. Subject to the terms of this license, NVIDIA grants you a non-exclusive limited license to: (a) install and use the SOFTWARE, and (b) distribute the SOFTWARE subject to the distribution requirements described in this license. NVIDIA reserves all rights, title and interest in and to the SOFTWARE not expressly granted to you under this license.
+ *
+ * 2. DISTRIBUTION REQUIREMENTS. These are the distribution requirements for you to exercise the distribution grant:
+ * a.      The terms under which you distribute the SOFTWARE must be consistent with the terms of this license, including (without limitation) terms relating to the license grant and license restrictions and protection of NVIDIA’s intellectual property rights.
+ * b.      You agree to notify NVIDIA in writing of any known or suspected distribution or use of the SOFTWARE not in compliance with the requirements of this license, and to enforce the terms of your agreements with respect to distributed SOFTWARE.
+ *
+ * 3. LIMITATIONS. Your license to use the SOFTWARE is restricted as follows:
+ * a.      The SOFTWARE is licensed for you to develop applications only for use in systems with NVIDIA GPUs.
+ * b.      You may not reverse engineer, decompile or disassemble, or remove copyright or other proprietary notices from any portion of the SOFTWARE or copies of the SOFTWARE.
+ * c.      You may not modify or create derivative works of any portion of the SOFTWARE.
+ * d.      You may not bypass, disable, or circumvent any technical measure, encryption, security, digital rights management or authentication mechanism in the SOFTWARE.
+ * e.      You may not use the SOFTWARE in any manner that would cause it to become subject to an open source software license. As examples, licenses that require as a condition of use, modification, and/or distribution that the SOFTWARE be (i) disclosed or distributed in source code form; (ii) licensed for the purpose of making derivative works; or (iii) redistributable at no charge.
+ * f.      Unless you have an agreement with NVIDIA for this purpose, you may not use the SOFTWARE with any system or application where the use or failure of the system or application can reasonably be expected to threaten or result in personal injury, death, or catastrophic loss. Examples include use in avionics, navigation, military, medical, life support or other life critical applications. NVIDIA does not design, test or manufacture the SOFTWARE for these critical uses and NVIDIA shall not be liable to you or any third party, in whole or in part, for any claims or damages arising from such uses.
+ * g.      You agree to defend, indemnify and hold harmless NVIDIA and its affiliates, and their respective employees, contractors, agents, officers and directors, from and against any and all claims, damages, obligations, losses, liabilities, costs or debt, fines, restitutions and expenses (including but not limited to attorney’s fees and costs incident to establishing the right of indemnification) arising out of or related to use of the SOFTWARE outside of the scope of this Agreement, or not in compliance with its terms.
+ *
+ * 4. PRE-RELEASE. SOFTWARE versions identified as alpha, beta, preview, early access or otherwise as pre-release may not be fully functional, may contain errors or design flaws, and may have reduced or different security, privacy, availability, and reliability standards relative to commercial versions of NVIDIA software and materials. You may use a pre-release SOFTWARE version at your own risk, understanding that these versions are not intended for use in production or business-critical systems.
+ *
+ * 5. OWNERSHIP. The SOFTWARE and the related intellectual property rights therein are and will remain the sole and exclusive property of NVIDIA or its licensors. The SOFTWARE is copyrighted and protected by the laws of the United States and other countries, and international treaty provisions. NVIDIA may make changes to the SOFTWARE, at any time without notice, but is not obligated to support or update the SOFTWARE.
+ *
+ * 6. COMPONENTS UNDER OTHER LICENSES. The SOFTWARE may include NVIDIA or third-party components with separate legal notices or terms as may be described in proprietary notices accompanying the SOFTWARE. If and to the extent there is a conflict between the terms in this license and the license terms associated with a component, the license terms associated with the components control only to the extent necessary to resolve the conflict.
+ *
+ * 7. FEEDBACK. You may, but don’t have to, provide to NVIDIA any Feedback. “Feedback” means any suggestions, bug fixes, enhancements, modifications, feature requests or other feedback regarding the SOFTWARE. For any Feedback that you voluntarily provide, you hereby grant NVIDIA and its affiliates a perpetual, non-exclusive, worldwide, irrevocable license to use, reproduce, modify, license, sublicense (through multiple tiers of sublicensees), and distribute (through multiple tiers of distributors) the Feedback without the payment of any royalties or fees to you. NVIDIA will use Feedback at its choice.
+ *
+ * 8. NO WARRANTIES. THE SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED WARRANTY OF ANY KIND INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, OR FITNESS FOR A PARTICULAR PURPOSE. NVIDIA DOES NOT WARRANT THAT THE SOFTWARE WILL MEET YOUR REQUIREMENTS OR THAT THE OPERATION THEREOF WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ALL ERRORS WILL BE CORRECTED.
+ *
+ * 9. LIMITATIONS OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, PROJECT DELAYS, LOSS OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION WITH THIS LICENSE OR THE USE OR PERFORMANCE OF THE SOFTWARE, WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF LIABILITY, EVEN IF NVIDIA HAS PREVIOUSLY BEEN ADVISED OF, OR COULD REASONABLY HAVE FORESEEN, THE POSSIBILITY OF SUCH DAMAGES. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS LICENSE EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS LIMIT.
+ *
+ * 10. TERMINATION. Your rights under this license will terminate automatically without notice from NVIDIA if you fail to comply with any term and condition of this license or if you commence or participate in any legal proceeding against NVIDIA with respect to the SOFTWARE. NVIDIA may terminate this license with advance written notice to you if NVIDIA decides to no longer provide the SOFTWARE in a country or, in NVIDIA’s sole discretion, the continued use of it is no longer commercially viable. Upon any termination of this license, you agree to promptly discontinue use of the SOFTWARE and destroy all copies in your possession or control. Your prior distributions in accordance with this license are not affected by the termination of this license. All provisions of this license will survive termination, except for the license granted to you.
+ *
+ * 11. APPLICABLE LAW. This license will be governed in all respects by the laws of the United States and of the State of Delaware as those laws are applied to contracts entered into and performed entirely within Delaware by Delaware residents, without regard to the conflicts of laws principles. The United Nations Convention on Contracts for the International Sale of Goods is specifically disclaimed. You agree to all terms of this Agreement in the English language. The state or federal courts residing in Santa Clara County, California shall have exclusive jurisdiction over any dispute or claim arising out of this license. Notwithstanding this, you agree that NVIDIA shall still be allowed to apply for injunctive remedies or an equivalent type of urgent legal relief in any jurisdiction.
+ *
+ * 12. NO ASSIGNMENT. This license and your rights and obligations thereunder may not be assigned by you by any means or operation of law without NVIDIA’s permission. Any attempted assignment not approved by NVIDIA in writing shall be void and of no effect.
+ *
+ * 13. EXPORT. The SOFTWARE is subject to United States export laws and regulations. You agree that you will not ship, transfer or export the SOFTWARE into any country, or use the SOFTWARE in any manner, prohibited by the United States Bureau of Industry and Security or economic sanctions regulations administered by the U.S. Department of Treasury’s Office of Foreign Assets Control (OFAC), or any applicable export laws, restrictions or regulations. These laws include restrictions on destinations, end users and end use. By accepting this license, you confirm that you are not a resident or citizen of any country currently embargoed by the U.S. and that you are not otherwise prohibited from receiving the SOFTWARE.
+ *
+ * 14. GOVERNMENT USE. The SOFTWARE has been developed entirely at private expense and is “commercial items” consisting of “commercial computer software” and “commercial computer software documentation” provided with RESTRICTED RIGHTS. Use, duplication or disclosure by the U.S. Government or a U.S. Government subcontractor is subject to the restrictions in this license pursuant to DFARS 227.7202-3(a) or as set forth in subparagraphs (b)(1) and (2) of the Commercial Computer Software - Restricted Rights clause at FAR 52.227-19, as applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas Expressway, Santa Clara, CA 95051.
+ *
+ * 15. ENTIRE AGREEMENT. This license is the final, complete and exclusive agreement between the parties relating to the subject matter of this license and supersedes all prior or contemporaneous understandings and agreements relating to this subject matter, whether oral or written. If any court of competent jurisdiction determines that any provision of this license is illegal, invalid or unenforceable, the remaining provisions will remain in full force and effect. This license may only be modified in a writing signed by an authorized representative of each party.
+ *
+ * (v. August 20, 2021)
+ */
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+namespace __detail_ap {
+
+  _LIBCUDACXX_HOST_DEVICE
+  constexpr uint32_t __ap_floor_log2(uint32_t __x) {
+    return (__x == 1 | __x == 0) ? 0 : 1 + __ap_floor_log2(__x >> 1);
+  }
+
+  _LIBCUDACXX_HOST_DEVICE
+  constexpr uint32_t __ap_ceil_log2(uint32_t __x) {
+    return (__x == 1 | __x == 0) ? 0 : __ap_floor_log2(__x - 1) + 1;
+  }
+
+  _LIBCUDACXX_HOST_DEVICE
+  constexpr uint32_t __ap_min(uint32_t __a, uint32_t __b) noexcept {
+    return (__a < __b) ? __a : __b;
+  }
+
+  _LIBCUDACXX_HOST_DEVICE
+  constexpr uint32_t __ap_max(uint32_t __a, uint32_t __b) noexcept {
+    return (__a > __b) ? __a : __b;
+  }
+
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414
+// Specifically search for 8.4 and 9.3 and above to guarantee uint64_t enum.
+#if defined(_LIBCUDACXX_COMPILER_GCC) && ( \
+    ((_GNUC_VER < 804)) || \
+    ((_GNUC_VER < 903))    \
+  )
+# define _LIBCUDACXX_AP_ENUM_TYPE_ANNOTATION
+#else
+# define _LIBCUDACXX_AP_ENUM_TYPE_ANNOTATION : uint64_t
+#endif
+
+  namespace __sm_80 {
+    namespace __off {
+      enum __l2_cop_off_t _LIBCUDACXX_AP_ENUM_TYPE_ANNOTATION {
+        _L2_EVICT_NORMAL = 0,
+        _L2_EVICT_FIRST = 1,
+      };
+    } // namespace __off
+
+    namespace __on {
+      enum __l2_cop_on_t _LIBCUDACXX_AP_ENUM_TYPE_ANNOTATION {
+        _L2_EVICT_NORMAL = 0,
+        _L2_EVICT_FIRST = 1,
+        _L2_EVICT_LAST = 2,
+        _L2_EVICT_NORMAL_DEMOTE = 3,
+      };
+    } // namespace __on
+
+    enum __l2_descriptor_mode_t _LIBCUDACXX_AP_ENUM_TYPE_ANNOTATION {
+      _DESC_IMPLICIT = 0,
+      _DESC_INTERLEAVED = 2,
+      _DESC_BLOCK_TYPE = 3,
+    };
+
+    enum __l2_eviction_max_way_t _LIBCUDACXX_AP_ENUM_TYPE_ANNOTATION {
+      _CUDA_AMPERE_MAX_L2_WAYS = std::uint32_t{16},
+    };
+
+    enum __block_size_t _LIBCUDACXX_AP_ENUM_TYPE_ANNOTATION {
+      _BLOCKSIZE_4K   = 0,
+      _BLOCKSIZE_8K   = 1,
+      _BLOCKSIZE_16K  = 2,
+      _BLOCKSIZE_32K  = 3,
+      _BLOCKSIZE_64K  = 4,
+      _BLOCKSIZE_128K = 5,
+      _BLOCKSIZE_256K = 6,
+      _BLOCKSIZE_512K = 7,
+      _BLOCKSIZE_1M   = 8,
+      _BLOCKSIZE_2M   = 9,
+      _BLOCKSIZE_4M   = 10,
+      _BLOCKSIZE_8M   = 11,
+      _BLOCKSIZE_16M  = 12,
+      _BLOCKSIZE_32M  = 13,
+    };
+
+    struct __block_desc_t {
+      uint64_t __ap_reserved : 37;
+      uint64_t __block_count: 7;
+      uint64_t __block_start: 7;
+      uint64_t __ap_reserved2 : 1;
+      __block_size_t __block_size : 4;
+      __off::__l2_cop_off_t __l2_cop_off : 1;
+      __on::__l2_cop_on_t __l2_cop_on : 2;
+      __l2_descriptor_mode_t __l2_descriptor_mode : 2;
+      uint64_t __l1_inv_dont_allocate : 1;
+      uint64_t __l2_sector_promote_256B : 1;
+      uint64_t __ap_reserved3 : 1;
+
+      _LIBCUDACXX_HOST_DEVICE
+      constexpr std::uint64_t __get_descriptor_cexpr() const noexcept {
+        return
+          std::uint64_t(__ap_reserved)            << 0  |
+          std::uint64_t(__block_count)            << 37 |
+          std::uint64_t(__block_start)            << 44 |
+          std::uint64_t(__ap_reserved2)           << 51 |
+          std::uint64_t(__block_size)             << 52 |
+          std::uint64_t(__l2_cop_off)             << 56 |
+          std::uint64_t(__l2_cop_on)              << 57 |
+          std::uint64_t(__l2_descriptor_mode)     << 59 |
+          std::uint64_t(__l1_inv_dont_allocate)   << 61 |
+          std::uint64_t(__l2_sector_promote_256B) << 62 |
+          std::uint64_t(__ap_reserved3)           << 63;
+      }
+
+      inline
+      _LIBCUDACXX_HOST_DEVICE
+      std::uint64_t __get_descriptor_non_cexpr() const noexcept { return *reinterpret_cast<const std::uint64_t*>(this); }
+
+      _LIBCUDACXX_HOST_DEVICE
+      constexpr std::uint64_t __get_descriptor() const noexcept {
+#if defined(_LIBCUDACXX_IS_CONSTANT_EVALUATED)
+        return cuda::std::is_constant_evaluated() ?
+                    __get_descriptor_cexpr() :
+                    __get_descriptor_non_cexpr();
+#else
+        return __get_descriptor_cexpr();
+#endif
+      }
+    };
+    static_assert(sizeof(__block_desc_t) == 8, "__block_desc_t should be 8 bytes");
+    static_assert(sizeof(__block_desc_t) == sizeof(std::uint64_t), "");
+    static_assert(
+      __block_desc_t{(uint64_t)1, (uint64_t)1, (uint64_t)1, (uint64_t)1, __block_size_t::_BLOCKSIZE_8K, __off::_L2_EVICT_FIRST, __on::_L2_EVICT_FIRST, __l2_descriptor_mode_t::_DESC_INTERLEAVED, (uint64_t)1, (uint64_t)1, (uint64_t)1}.__get_descriptor()
+         == 0xF318102000000001, "");
+
+    /* Factory like struct to build a __block_desc_t due to constexpr C++11
+     */
+    struct __block_descriptor_builder { //variable declaration order matters == usage order
+      std::uint32_t __offset;
+      __block_size_t __block_size;
+      std::uint32_t __block_start, __end_hit;
+      std::uint32_t __block_count;
+      __off::__l2_cop_off_t __l2_cop_off;
+      __on::__l2_cop_on_t __l2_cop_on;
+      __l2_descriptor_mode_t __l2_descriptor_mode;
+      bool __l1_inv_dont_allocate, __l2_sector_promote_256B;
+
+      _LIBCUDACXX_HOST_DEVICE static constexpr std::uint32_t __calc_offset(std::size_t __total_bytes) {
+          return __ap_max(std::uint32_t{12}, static_cast<std::uint32_t>(__ap_ceil_log2(static_cast<uint32_t>(__total_bytes))) - std::uint32_t{7});
+      }
+
+      _LIBCUDACXX_HOST_DEVICE static constexpr std::uint32_t __calc_block_start(std::uintptr_t __ptr, std::size_t __total_bytes) {
+          return static_cast<uint32_t>(__ptr >> __calc_offset(static_cast<uint32_t>(__total_bytes)));
+      }
+
+      _LIBCUDACXX_HOST_DEVICE static constexpr std::uint32_t __calc_end_hit(std::uintptr_t __ptr, std::size_t __hit_bytes, std::size_t __total_bytes) {
+          return static_cast<uint32_t>((__ptr + __hit_bytes + (std::uintptr_t{1} << (__calc_offset(static_cast<uint32_t>(__total_bytes)))) - 1) >> __calc_offset(static_cast<uint32_t>(__total_bytes)));
+      }
+
+      _LIBCUDACXX_HOST_DEVICE constexpr __block_descriptor_builder(std::uintptr_t __ptr, std::size_t __hit_bytes, std::size_t __total_bytes, __on::__l2_cop_on_t __hit_prop, __off::__l2_cop_off_t __miss_prop)
+        : __offset(__calc_offset(__total_bytes))
+        , __block_size(static_cast<__block_size_t>(__calc_offset(__total_bytes) - std::uint32_t{12}))
+        , __block_start(__calc_block_start(__ptr, __total_bytes))
+        , __end_hit(__calc_end_hit(__ptr, __hit_bytes, __total_bytes))
+        , __block_count(__calc_end_hit(__ptr, __hit_bytes, __total_bytes) - __calc_block_start(__ptr, __total_bytes))
+        , __l2_cop_off(__miss_prop)
+        , __l2_cop_on(__hit_prop)
+        , __l2_descriptor_mode(_DESC_BLOCK_TYPE)
+        , __l1_inv_dont_allocate(false)
+        , __l2_sector_promote_256B(false)
+        {}
+
+      _LIBCUDACXX_HOST_DEVICE
+      constexpr __block_desc_t __get_block() const noexcept {
+        return __block_desc_t { 0, __ap_min(std::uint32_t{0x7f}, __block_count), (__block_start & std::uint32_t{0x7f}), 0, __block_size, __l2_cop_off, __l2_cop_on, _DESC_BLOCK_TYPE, false, false, 0 };
+      }
+    };
+    static_assert(sizeof(std::uintptr_t) > 4, "std::uintptr_t needs at least 5 bytes for this code to work");
+
+    struct __interleave_descriptor_t {
+      uint64_t __ap_reserved : 52;
+      uint64_t __fraction : 4;
+      __off::__l2_cop_off_t __l2_cop_off : 1;
+      __on::__l2_cop_on_t __l2_cop_on : 2;
+      __l2_descriptor_mode_t __l2_descriptor_mode : 2;
+      uint64_t __l1_inv_dont_allocate : 1;
+      uint64_t __l2_sector_promote_256B : 1;
+      uint64_t __ap_reserved2 : 1;
+
+      _LIBCUDACXX_HOST_DEVICE
+      constexpr __interleave_descriptor_t(
+                    __on::__l2_cop_on_t __hit_prop,
+                    std::uint32_t __hit_ratio,
+                    __off::__l2_cop_off_t __miss_prop) noexcept
+                        : __fraction(__hit_ratio),
+                          __l2_cop_off(__miss_prop),
+                          __l2_cop_on(__hit_prop),
+                          __l2_descriptor_mode(_DESC_INTERLEAVED),
+                          __l1_inv_dont_allocate(0x0),
+                          __l2_sector_promote_256B(0x0),
+                          __ap_reserved(0x0),
+                          __ap_reserved2(0x0) {}
+
+      _LIBCUDACXX_HOST_DEVICE
+      constexpr std::uint64_t __get_descriptor_cexpr() const {
+        return
+          std::uint64_t(__ap_reserved)            << 0  |
+          std::uint64_t(__fraction)               << 52 |
+          std::uint64_t(__l2_cop_off)             << 56 |
+          std::uint64_t(__l2_cop_on)              << 57 |
+          std::uint64_t(__l2_descriptor_mode)     << 59 |
+          std::uint64_t(__l1_inv_dont_allocate)   << 61 |
+          std::uint64_t(__l2_sector_promote_256B) << 62 |
+          std::uint64_t(__ap_reserved2)           << 63;
+      }
+
+      inline
+      _LIBCUDACXX_HOST_DEVICE
+      std::uint64_t __get_descriptor_non_cexpr() const noexcept { return *reinterpret_cast<const std::uint64_t*>(this); }
+
+
+      _LIBCUDACXX_HOST_DEVICE
+      constexpr std::uint64_t __get_descriptor() const noexcept {
+#if defined(_LIBCUDACXX_IS_CONSTANT_EVALUATED)
+        return cuda::std::is_constant_evaluated() ?
+                    __get_descriptor_cexpr() :
+                    __get_descriptor_non_cexpr();
+#else
+        return __get_descriptor_cexpr();
+#endif
+      }
+    };
+    static_assert(sizeof(__interleave_descriptor_t) == 8, "__interleave_descriptor_t should be 8 bytes");
+    static_assert(sizeof(__interleave_descriptor_t) == sizeof(std::uint64_t), "");
+
+    _LIBCUDACXX_HOST_DEVICE
+    static constexpr std::uint64_t __interleave_normal() noexcept {
+      return 0x10F0000000000000;
+    }
+
+    _LIBCUDACXX_HOST_DEVICE
+    static constexpr std::uint64_t __interleave_streaming() noexcept {
+      return 0x12F0000000000000;
+    }
+
+    _LIBCUDACXX_HOST_DEVICE
+    static constexpr std::uint64_t __interleave_persisting() noexcept {
+      return 0x14F0000000000000;
+    }
+
+    _LIBCUDACXX_HOST_DEVICE
+    static constexpr std::uint64_t __interleave_normal_demote() noexcept {
+      return 0x16F0000000000000;
+    }
+
+  } // namespace __sm_80
+
+  _LIBCUDACXX_HOST_DEVICE
+  constexpr std::uint64_t __interleave(cudaAccessProperty __hit_prop, float __hit_ratio, cudaAccessProperty __miss_prop = cudaAccessPropertyNormal) {
+      return __sm_80::__interleave_descriptor_t(
+          ((__hit_prop == cudaAccessPropertyNormal) ? __sm_80::__on::__l2_cop_on_t::_L2_EVICT_NORMAL_DEMOTE : static_cast<__sm_80::__on::__l2_cop_on_t>(__hit_prop)),
+          __ap_min((static_cast<std::uint32_t>(__hit_ratio) * __sm_80::__l2_eviction_max_way_t::_CUDA_AMPERE_MAX_L2_WAYS), static_cast<std::uint32_t>(__sm_80::__l2_eviction_max_way_t::_CUDA_AMPERE_MAX_L2_WAYS - 1)),
+          static_cast<__sm_80::__off::__l2_cop_off_t>(__miss_prop)
+          ).__get_descriptor();
+  }
+
+  _LIBCUDACXX_HOST_DEVICE
+  constexpr std::uint64_t __block(void* __ptr, std::size_t __hit_bytes, std::size_t __total_bytes, cudaAccessProperty __hit_prop, cudaAccessProperty __miss_prop = cudaAccessPropertyNormal) {
+      return (__total_bytes <= (size_t{0xFFFFFFFF}) & __total_bytes != 0 & __hit_bytes <= __total_bytes) ? __sm_80::__block_descriptor_builder(
+          reinterpret_cast<std::uintptr_t>(__ptr),
+          __hit_bytes,
+          __total_bytes,
+          (__hit_prop == cudaAccessPropertyNormal) ? __sm_80::__on::_L2_EVICT_NORMAL_DEMOTE : static_cast<__sm_80::__on::__l2_cop_on_t>(__hit_prop),
+          static_cast<__sm_80::__off::__l2_cop_off_t>(__miss_prop)
+          ).__get_block().__get_descriptor()
+        : __sm_80::__interleave_normal();
+  }
+} // namespace __detail_ap
+
+_LIBCUDACXX_END_NAMESPACE_CUDA

cuda_toolkit/include/cuda/std/detail/__annotated_ptr

@@ -0,0 +1,231 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ *
+ * NVIDIA SOFTWARE LICENSE
+ *
+ * This license is a legal agreement between you and NVIDIA Corporation ("NVIDIA") and governs your use of the NVIDIA/CUDA C++ Library software and materials provided hereunder (“SOFTWARE”).
+ *
+ * This license can be accepted only by an adult of legal age of majority in the country in which the SOFTWARE is used. If you are under the legal age of majority, you must ask your parent or legal guardian to consent to this license. By taking delivery of the SOFTWARE, you affirm that you have reached the legal age of majority, you accept the terms of this license, and you take legal and financial responsibility for the actions of your permitted users.
+ *
+ * You agree to use the SOFTWARE only for purposes that are permitted by (a) this license, and (b) any applicable law, regulation or generally accepted practices or guidelines in the relevant jurisdictions.
+ *
+ * 1. LICENSE. Subject to the terms of this license, NVIDIA grants you a non-exclusive limited license to: (a) install and use the SOFTWARE, and (b) distribute the SOFTWARE subject to the distribution requirements described in this license. NVIDIA reserves all rights, title and interest in and to the SOFTWARE not expressly granted to you under this license.
+ *
+ * 2. DISTRIBUTION REQUIREMENTS. These are the distribution requirements for you to exercise the distribution grant:
+ * a.      The terms under which you distribute the SOFTWARE must be consistent with the terms of this license, including (without limitation) terms relating to the license grant and license restrictions and protection of NVIDIA’s intellectual property rights.
+ * b.      You agree to notify NVIDIA in writing of any known or suspected distribution or use of the SOFTWARE not in compliance with the requirements of this license, and to enforce the terms of your agreements with respect to distributed SOFTWARE.
+ *
+ * 3. LIMITATIONS. Your license to use the SOFTWARE is restricted as follows:
+ * a.      The SOFTWARE is licensed for you to develop applications only for use in systems with NVIDIA GPUs.
+ * b.      You may not reverse engineer, decompile or disassemble, or remove copyright or other proprietary notices from any portion of the SOFTWARE or copies of the SOFTWARE.
+ * c.      You may not modify or create derivative works of any portion of the SOFTWARE.
+ * d.      You may not bypass, disable, or circumvent any technical measure, encryption, security, digital rights management or authentication mechanism in the SOFTWARE.
+ * e.      You may not use the SOFTWARE in any manner that would cause it to become subject to an open source software license. As examples, licenses that require as a condition of use, modification, and/or distribution that the SOFTWARE be (i) disclosed or distributed in source code form; (ii) licensed for the purpose of making derivative works; or (iii) redistributable at no charge.
+ * f.      Unless you have an agreement with NVIDIA for this purpose, you may not use the SOFTWARE with any system or application where the use or failure of the system or application can reasonably be expected to threaten or result in personal injury, death, or catastrophic loss. Examples include use in avionics, navigation, military, medical, life support or other life critical applications. NVIDIA does not design, test or manufacture the SOFTWARE for these critical uses and NVIDIA shall not be liable to you or any third party, in whole or in part, for any claims or damages arising from such uses.
+ * g.      You agree to defend, indemnify and hold harmless NVIDIA and its affiliates, and their respective employees, contractors, agents, officers and directors, from and against any and all claims, damages, obligations, losses, liabilities, costs or debt, fines, restitutions and expenses (including but not limited to attorney’s fees and costs incident to establishing the right of indemnification) arising out of or related to use of the SOFTWARE outside of the scope of this Agreement, or not in compliance with its terms.
+ *
+ * 4. PRE-RELEASE. SOFTWARE versions identified as alpha, beta, preview, early access or otherwise as pre-release may not be fully functional, may contain errors or design flaws, and may have reduced or different security, privacy, availability, and reliability standards relative to commercial versions of NVIDIA software and materials. You may use a pre-release SOFTWARE version at your own risk, understanding that these versions are not intended for use in production or business-critical systems.
+ *
+ * 5. OWNERSHIP. The SOFTWARE and the related intellectual property rights therein are and will remain the sole and exclusive property of NVIDIA or its licensors. The SOFTWARE is copyrighted and protected by the laws of the United States and other countries, and international treaty provisions. NVIDIA may make changes to the SOFTWARE, at any time without notice, but is not obligated to support or update the SOFTWARE.
+ *
+ * 6. COMPONENTS UNDER OTHER LICENSES. The SOFTWARE may include NVIDIA or third-party components with separate legal notices or terms as may be described in proprietary notices accompanying the SOFTWARE. If and to the extent there is a conflict between the terms in this license and the license terms associated with a component, the license terms associated with the components control only to the extent necessary to resolve the conflict.
+ *
+ * 7. FEEDBACK. You may, but don’t have to, provide to NVIDIA any Feedback. “Feedback” means any suggestions, bug fixes, enhancements, modifications, feature requests or other feedback regarding the SOFTWARE. For any Feedback that you voluntarily provide, you hereby grant NVIDIA and its affiliates a perpetual, non-exclusive, worldwide, irrevocable license to use, reproduce, modify, license, sublicense (through multiple tiers of sublicensees), and distribute (through multiple tiers of distributors) the Feedback without the payment of any royalties or fees to you. NVIDIA will use Feedback at its choice.
+ *
+ * 8. NO WARRANTIES. THE SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED WARRANTY OF ANY KIND INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, OR FITNESS FOR A PARTICULAR PURPOSE. NVIDIA DOES NOT WARRANT THAT THE SOFTWARE WILL MEET YOUR REQUIREMENTS OR THAT THE OPERATION THEREOF WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ALL ERRORS WILL BE CORRECTED.
+ *
+ * 9. LIMITATIONS OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, PROJECT DELAYS, LOSS OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION WITH THIS LICENSE OR THE USE OR PERFORMANCE OF THE SOFTWARE, WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF LIABILITY, EVEN IF NVIDIA HAS PREVIOUSLY BEEN ADVISED OF, OR COULD REASONABLY HAVE FORESEEN, THE POSSIBILITY OF SUCH DAMAGES. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS LICENSE EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS LIMIT.
+ *
+ * 10. TERMINATION. Your rights under this license will terminate automatically without notice from NVIDIA if you fail to comply with any term and condition of this license or if you commence or participate in any legal proceeding against NVIDIA with respect to the SOFTWARE. NVIDIA may terminate this license with advance written notice to you if NVIDIA decides to no longer provide the SOFTWARE in a country or, in NVIDIA’s sole discretion, the continued use of it is no longer commercially viable. Upon any termination of this license, you agree to promptly discontinue use of the SOFTWARE and destroy all copies in your possession or control. Your prior distributions in accordance with this license are not affected by the termination of this license. All provisions of this license will survive termination, except for the license granted to you.
+ *
+ * 11. APPLICABLE LAW. This license will be governed in all respects by the laws of the United States and of the State of Delaware as those laws are applied to contracts entered into and performed entirely within Delaware by Delaware residents, without regard to the conflicts of laws principles. The United Nations Convention on Contracts for the International Sale of Goods is specifically disclaimed. You agree to all terms of this Agreement in the English language. The state or federal courts residing in Santa Clara County, California shall have exclusive jurisdiction over any dispute or claim arising out of this license. Notwithstanding this, you agree that NVIDIA shall still be allowed to apply for injunctive remedies or an equivalent type of urgent legal relief in any jurisdiction.
+ *
+ * 12. NO ASSIGNMENT. This license and your rights and obligations thereunder may not be assigned by you by any means or operation of law without NVIDIA’s permission. Any attempted assignment not approved by NVIDIA in writing shall be void and of no effect.
+ *
+ * 13. EXPORT. The SOFTWARE is subject to United States export laws and regulations. You agree that you will not ship, transfer or export the SOFTWARE into any country, or use the SOFTWARE in any manner, prohibited by the United States Bureau of Industry and Security or economic sanctions regulations administered by the U.S. Department of Treasury’s Office of Foreign Assets Control (OFAC), or any applicable export laws, restrictions or regulations. These laws include restrictions on destinations, end users and end use. By accepting this license, you confirm that you are not a resident or citizen of any country currently embargoed by the U.S. and that you are not otherwise prohibited from receiving the SOFTWARE.
+ *
+ * 14. GOVERNMENT USE. The SOFTWARE has been developed entirely at private expense and is “commercial items” consisting of “commercial computer software” and “commercial computer software documentation” provided with RESTRICTED RIGHTS. Use, duplication or disclosure by the U.S. Government or a U.S. Government subcontractor is subject to the restrictions in this license pursuant to DFARS 227.7202-3(a) or as set forth in subparagraphs (b)(1) and (2) of the Commercial Computer Software - Restricted Rights clause at FAR 52.227-19, as applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas Expressway, Santa Clara, CA 95051.
+ *
+ * 15. ENTIRE AGREEMENT. This license is the final, complete and exclusive agreement between the parties relating to the subject matter of this license and supersedes all prior or contemporaneous understandings and agreements relating to this subject matter, whether oral or written. If any court of competent jurisdiction determines that any provision of this license is illegal, invalid or unenforceable, the remaining provisions will remain in full force and effect. This license may only be modified in a writing signed by an authorized representative of each party.
+ *
+ * (v. August 20, 2021)
+ */
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+namespace __detail_ap {
+
+  template <typename _Property>
+  _LIBCUDACXX_DEVICE
+  void* __associate_address_space(void* __ptr, _Property __prop) {
+    if (std::is_same<_Property, access_property::shared>::value == true) {
+      bool __b = __isShared(__ptr);
+      _LIBCUDACXX_ASSERT(__b, "");
+#if !defined(_LIBCUDACXX_CUDACC_BELOW_11_2)
+      __builtin_assume(__b);
+#else // ^^^ !_LIBCUDACXX_CUDACC_BELOW_11_2 ^^^ / vvv _LIBCUDACXX_CUDACC_BELOW_11_2 vvv
+      (void)__b;
+#endif // _LIBCUDACXX_CUDACC_BELOW_11_2
+    } else if (std::is_same<_Property, access_property::global>::value == true ||
+               std::is_same<_Property, access_property::normal>::value == true ||
+               std::is_same<_Property, access_property::persisting>::value == true ||
+               std::is_same<_Property, access_property::streaming>::value == true ||
+               std::is_same<_Property, access_property>::value) {
+      bool __b = __isGlobal(__ptr);
+      _LIBCUDACXX_ASSERT(__b, "");
+#if !defined(_LIBCUDACXX_CUDACC_BELOW_11_2)
+      __builtin_assume(__b);
+#else // ^^^ !_LIBCUDACXX_CUDACC_BELOW_11_2 ^^^ / vvv _LIBCUDACXX_CUDACC_BELOW_11_2 vvv
+      (void)__b;
+#endif // _LIBCUDACXX_CUDACC_BELOW_11_2
+    }
+
+    return __ptr;
+  }
+
+  template <typename __Prop>
+  _LIBCUDACXX_DEVICE
+  void* __associate_descriptor(void* __ptr, __Prop __prop) {
+    return __associate_descriptor(__ptr, static_cast<std::uint64_t>(access_property(__prop)));
+  }
+
+  template <>
+  inline _LIBCUDACXX_DEVICE
+  void* __associate_descriptor(void* __ptr, std::uint64_t __prop) {
+    NV_IF_ELSE_TARGET(NV_PROVIDES_SM_80,(
+      return __nv_associate_access_property(__ptr, __prop);
+    ),(
+      return __ptr;
+    ))
+  }
+
+  template<>
+  inline _LIBCUDACXX_DEVICE
+  void* __associate_descriptor(void* __ptr, access_property::shared) {
+    return __ptr;
+  }
+
+  template<typename _Type, typename _Property>
+  _LIBCUDACXX_HOST_DEVICE
+  _Type* __associate(_Type* __ptr, _Property __prop) {
+    NV_IF_ELSE_TARGET(NV_IS_DEVICE,(
+      return static_cast<_Type*>(__associate_descriptor(
+        __associate_address_space(const_cast<void*>(static_cast<const void*>(__ptr)), __prop),
+        __prop));
+    ),(
+      return __ptr;
+    ))
+  }
+
+
+  template<typename _Property>
+  class __annotated_ptr_base {
+    using __error = typename _Property::__unknown_access_property_type;
+  };
+
+  template<>
+  class __annotated_ptr_base<access_property::shared> {
+    protected:
+      static constexpr std::uint64_t __prop = 0;
+
+      constexpr __annotated_ptr_base() noexcept = default;
+      constexpr __annotated_ptr_base(__annotated_ptr_base const&) = default;
+      _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 __annotated_ptr_base& operator=(const __annotated_ptr_base&) = default;
+      _LIBCUDACXX_HOST_DEVICE constexpr __annotated_ptr_base(access_property::shared) noexcept {}
+      inline _LIBCUDACXX_DEVICE void* __apply_prop(void* __p) const {
+        return __associate(__p, access_property::shared{});
+      }
+      _LIBCUDACXX_HOST_DEVICE constexpr access_property::shared __get_property() const noexcept {
+	return access_property::shared{};
+      }
+  };
+
+  template<>
+  class __annotated_ptr_base<access_property::global> {
+    protected:
+      static constexpr std::uint64_t __prop = __sm_80::__interleave_normal();
+
+      constexpr __annotated_ptr_base() noexcept = default;
+      constexpr __annotated_ptr_base(__annotated_ptr_base const&) = default;
+      _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 __annotated_ptr_base& operator=(const __annotated_ptr_base&) = default;
+      _LIBCUDACXX_HOST_DEVICE constexpr __annotated_ptr_base(access_property::global) noexcept {}
+      inline _LIBCUDACXX_DEVICE void* __apply_prop(void* __p) const {
+        return __associate(__p, access_property::global{});
+      }
+      _LIBCUDACXX_HOST_DEVICE constexpr access_property::global __get_property() const noexcept {
+	return access_property::global{};
+      }
+  };
+
+  template<>
+  class __annotated_ptr_base<access_property::normal> {
+    protected:
+      static constexpr std::uint64_t __prop = __sm_80::__interleave_normal_demote();
+
+      constexpr __annotated_ptr_base() noexcept = default;
+      constexpr __annotated_ptr_base(__annotated_ptr_base const&) = default;
+      _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 __annotated_ptr_base& operator=(const __annotated_ptr_base&) = default;
+      _LIBCUDACXX_HOST_DEVICE constexpr __annotated_ptr_base(access_property::normal) noexcept {}
+      inline _LIBCUDACXX_DEVICE void* __apply_prop(void* __p) const {
+        return __associate(__p, access_property::normal{});
+      }
+      _LIBCUDACXX_HOST_DEVICE constexpr access_property::normal __get_property() const noexcept {
+	return access_property::normal{};
+      }
+  };
+
+  template<>
+  class __annotated_ptr_base<access_property::persisting> {
+    protected:
+      static constexpr std::uint64_t __prop = __sm_80::__interleave_persisting();
+
+      constexpr __annotated_ptr_base() noexcept = default;
+      constexpr __annotated_ptr_base(__annotated_ptr_base const&) = default;
+      _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 __annotated_ptr_base& operator=(const __annotated_ptr_base&) = default;
+      _LIBCUDACXX_HOST_DEVICE constexpr __annotated_ptr_base(access_property::persisting) noexcept {}
+      inline _LIBCUDACXX_DEVICE void* __apply_prop(void* __p) const {
+        return __associate(__p, access_property::persisting{});
+      }
+      _LIBCUDACXX_HOST_DEVICE constexpr access_property::persisting __get_property() const noexcept {
+	return access_property::persisting{};
+      }
+  };
+
+  template<>
+  class __annotated_ptr_base<access_property::streaming> {
+    protected:
+      static constexpr std::uint64_t __prop = __sm_80::__interleave_streaming();
+
+      constexpr __annotated_ptr_base() noexcept = default;
+      constexpr __annotated_ptr_base(__annotated_ptr_base const&) = default;
+      _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 __annotated_ptr_base& operator=(const __annotated_ptr_base&) = default;
+      _LIBCUDACXX_HOST_DEVICE constexpr __annotated_ptr_base(access_property::streaming) noexcept {}
+      inline _LIBCUDACXX_DEVICE void* __apply_prop(void* __p) const {
+        return __associate(__p, access_property::streaming{});
+      }
+      _LIBCUDACXX_HOST_DEVICE constexpr access_property::streaming __get_property() const noexcept {
+	return access_property::streaming{};
+      }
+  };
+
+  template<>
+  class __annotated_ptr_base<access_property> {
+    protected:
+      std::uint64_t __prop;
+
+      _LIBCUDACXX_HOST_DEVICE constexpr __annotated_ptr_base() noexcept : __prop(access_property()) {}
+      _LIBCUDACXX_HOST_DEVICE constexpr __annotated_ptr_base(std::uint64_t __property) noexcept : __prop(__property) {}
+      _LIBCUDACXX_HOST_DEVICE constexpr __annotated_ptr_base(access_property __property) noexcept
+        : __annotated_ptr_base(static_cast<std::uint64_t>(__property)) {}
+      constexpr __annotated_ptr_base(__annotated_ptr_base const&) = default;
+      _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 __annotated_ptr_base& operator=(const __annotated_ptr_base&) = default;
+      inline _LIBCUDACXX_DEVICE void* __apply_prop(void* __p) const {
+        return __associate(__p, __prop);
+      }
+      _LIBCUDACXX_HOST_DEVICE access_property __get_property() const noexcept {
+	return reinterpret_cast<access_property&>(const_cast<std::uint64_t&>(__prop));
+      }
+  };
+} // namespace __detail_ap
+
+_LIBCUDACXX_END_NAMESPACE_CUDA

cuda_toolkit/include/cuda/std/detail/__config

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_std__
+#define __cuda_std__
+
+#include <cuda/std/detail/libcxx/include/__cccl/version.h>
+
+#define _LIBCUDACXX_CUDA_API_VERSION CCCL_VERSION
+#define _LIBCUDACXX_CUDA_API_VERSION_MAJOR CCCL_MAJOR_VERSION
+#define _LIBCUDACXX_CUDA_API_VERSION_MINOR CCCL_MINOR_VERSION
+#define _LIBCUDACXX_CUDA_API_VERSION_PATCH CCCL_PATCH_VERSION
+
+#ifndef _LIBCUDACXX_CUDA_ABI_VERSION_LATEST
+#  define _LIBCUDACXX_CUDA_ABI_VERSION_LATEST 4
+#endif
+
+#ifdef _LIBCUDACXX_CUDA_ABI_VERSION
+#  if _LIBCUDACXX_CUDA_ABI_VERSION != 2 && _LIBCUDACXX_CUDA_ABI_VERSION != 3 && _LIBCUDACXX_CUDA_ABI_VERSION != 4
+#    error Unsupported libcu++ ABI version requested. Please define _LIBCUDACXX_CUDA_ABI_VERSION to either 2 or 3.
+#  endif
+#else
+#  define _LIBCUDACXX_CUDA_ABI_VERSION _LIBCUDACXX_CUDA_ABI_VERSION_LATEST
+#endif
+
+#ifdef _LIBCUDACXX_PIPELINE_ASSUMED_ABI_VERSION
+#  if _LIBCUDACXX_PIPELINE_ASSUMED_ABI_VERSION != _LIBCUDACXX_CUDA_ABI_VERSION
+#    error cuda_pipeline.h has assumed a different libcu++ ABI version than provided by this library. To fix this, please include a libcu++ header before including cuda_pipeline.h, or upgrade to a version of the toolkit this version of libcu++ shipped in.
+#  endif
+#endif
+
+#include "libcxx/include/__config"
+
+#endif //__cuda_std__

cuda_toolkit/include/cuda/std/detail/__pragma_pop

@@ -0,0 +1,12 @@
+//===----------------------------------------------------------------------===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include "libcxx/include/__pragma_pop"
+

cuda_toolkit/include/cuda/std/detail/__pragma_push

@@ -0,0 +1,13 @@
+//===----------------------------------------------------------------------===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include "libcxx/include/__pragma_push"
+#include "libcxx/include/__undef_macros"
+

cuda_toolkit/include/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/include/__assert

@@ -0,0 +1,70 @@
+// -*- 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___ASSERT
+#define _LIBCUDACXX___ASSERT
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "__verbose_abort"
+
+#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
+
+// This is for backwards compatibility with code that might have been enabling
+// assertions through the Debug mode previously.
+// TODO: In LLVM 16, make it an error to define _LIBCUDACXX_DEBUG
+#if defined(_LIBCUDACXX_DEBUG)
+# ifndef _LIBCUDACXX_ENABLE_ASSERTIONS
+#   define _LIBCUDACXX_ENABLE_ASSERTIONS 1
+# endif
+#endif
+
+// Automatically enable assertions when the debug mode is enabled.
+#if defined(_LIBCUDACXX_ENABLE_DEBUG_MODE)
+# ifndef _LIBCUDACXX_ENABLE_ASSERTIONS
+#   define _LIBCUDACXX_ENABLE_ASSERTIONS 1
+# endif
+#endif
+
+#ifndef _LIBCUDACXX_ENABLE_ASSERTIONS
+# define _LIBCUDACXX_ENABLE_ASSERTIONS _LIBCUDACXX_ENABLE_ASSERTIONS_DEFAULT
+#endif
+
+#if _LIBCUDACXX_ENABLE_ASSERTIONS != 0 && _LIBCUDACXX_ENABLE_ASSERTIONS != 1
+# error "_LIBCUDACXX_ENABLE_ASSERTIONS must be set to 0 or 1"
+#endif
+
+#if _LIBCUDACXX_ENABLE_ASSERTIONS
+# define _LIBCUDACXX_ASSERT(expression, message)                                \
+    (_CCCL_DIAG_PUSH                                                            \
+    _CCCL_DIAG_SUPPRESS_CLANG("-Wassume")                                       \
+    __builtin_expect(static_cast<bool>(expression), 1) ?                        \
+      (void)0 :                                                                 \
+      ::_CUDA_VSTD::__libcpp_verbose_abort("%s:%d: assertion %s failed: %s", __FILE__, __LINE__, #expression, message)
+    _CCCL_DIAG_POP)
+#elif 0 // !defined(_LIBCUDACXX_ASSERTIONS_DISABLE_ASSUME) && __has_builtin(__builtin_assume)
+# define _LIBCUDACXX_ASSERT(expression, message)                                \
+    (_CCCL_DIAG_PUSH                                                            \
+    _CCCL_DIAG_SUPPRESS_CLANG("-Wassume")                                       \
+    __builtin_assume(static_cast<bool>(expression))                             \
+    _CCCL_DIAG_POP)
+#else
+# define _LIBCUDACXX_ASSERT(expression, message) ((void)0)
+#endif
+
+#endif // _LIBCUDACXX___ASSERT

cuda_toolkit/include/cuda/std/detail/libcxx/include/__availability

@@ -0,0 +1,306 @@
+// -*- 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___AVAILABILITY
+#define _LIBCUDACXX___AVAILABILITY
+
+#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
+
+// Libc++ is shipped by various vendors. In particular, it is used as a system
+// library on macOS, iOS and other Apple platforms. In order for users to be
+// able to compile a binary that is intended to be deployed to an older version
+// of a platform, Clang provides availability attributes [1]. These attributes
+// can be placed on declarations and are used to describe the life cycle of a
+// symbol in the library.
+//
+// The main goal is to ensure a compile-time error if a symbol that hasn't been
+// introduced in a previously released library is used in a program that targets
+// that previously released library. Normally, this would be a load-time error
+// when one tries to launch the program against the older library.
+//
+// For example, the filesystem library was introduced in the dylib in macOS 10.15.
+// If a user compiles on a macOS 10.15 host but targets macOS 10.13 with their
+// program, the compiler would normally not complain (because the required
+// declarations are in the headers), but the dynamic loader would fail to find
+// the symbols when actually trying to launch the program on macOS 10.13. To
+// turn this into a compile-time issue instead, declarations are annotated with
+// when they were introduced, and the compiler can produce a diagnostic if the
+// program references something that isn't available on the deployment target.
+//
+// This mechanism is general in nature, and any vendor can add their markup to
+// the library (see below). Whenever a new feature is added that requires support
+// in the shared library, a macro should be added below to mark this feature
+// as unavailable. When vendors decide to ship the feature as part of their
+// shared library, they can update the markup appropriately.
+//
+// Furthermore, many features in the standard library have corresponding
+// feature-test macros. When a feature is made unavailable on some deployment
+// target, a macro should be defined to signal that it is unavailable. That
+// macro can then be picked up when feature-test macros are generated (see
+// generate_feature_test_macro_components.py) to make sure that feature-test
+// macros don't announce a feature as being implemented if it has been marked
+// as unavailable.
+//
+// Note that this mechanism is disabled by default in the "upstream" libc++.
+// Availability annotations are only meaningful when shipping libc++ inside
+// a platform (i.e. as a system library), and so vendors that want them should
+// turn those annotations on at CMake configuration time.
+//
+// [1]: https://clang.llvm.org/docs/AttributeReference.html#availability
+
+
+// For backwards compatibility, allow users to define _LIBCUDACXX_DISABLE_AVAILABILITY
+// for a while.
+#if defined(_LIBCUDACXX_DISABLE_AVAILABILITY)
+#   if !defined(_LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
+#       define _LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
+#   endif
+#endif
+
+// Availability markup is disabled when building the library, or when the compiler
+// doesn't support the proper attributes.
+#if defined(_LIBCUDACXX_BUILDING_LIBRARY) ||                                        \
+    defined(_LIBCXXABI_BUILDING_LIBRARY) ||                                     \
+    !__has_feature(attribute_availability_with_strict) ||                       \
+    !__has_feature(attribute_availability_in_templates) ||                      \
+    !__has_extension(pragma_clang_attribute_external_declaration)
+#   if !defined(_LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
+#       define _LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
+#   endif
+#endif
+
+#if defined(_LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
+
+    // This controls the availability of std::shared_mutex and std::shared_timed_mutex,
+    // which were added to the dylib later.
+#   define _LIBCUDACXX_AVAILABILITY_SHARED_MUTEX
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex
+
+    // These macros control the availability of std::bad_optional_access and
+    // other exception types. These were put in the shared library to prevent
+    // code bloat from every user program defining the vtable for these exception
+    // types.
+    //
+    // Note that when exceptions are disabled, the methods that normally throw
+    // these exceptions can be used even on older deployment targets, but those
+    // methods will abort instead of throwing.
+#   define _LIBCUDACXX_AVAILABILITY_BAD_OPTIONAL_ACCESS
+#   define _LIBCUDACXX_AVAILABILITY_BAD_VARIANT_ACCESS
+#   define _LIBCUDACXX_AVAILABILITY_BAD_ANY_CAST
+
+    // This controls the availability of std::uncaught_exceptions().
+#   define _LIBCUDACXX_AVAILABILITY_UNCAUGHT_EXCEPTIONS
+
+    // This controls the availability of the sized version of ::operator delete,
+    // ::operator delete[], and their align_val_t variants, which were all added
+    // in C++17, and hence not present in early dylibs.
+#   define _LIBCUDACXX_AVAILABILITY_SIZED_NEW_DELETE
+
+    // This controls the availability of the std::future_error exception.
+    //
+    // Note that when exceptions are disabled, the methods that normally throw
+    // std::future_error can be used even on older deployment targets, but those
+    // methods will abort instead of throwing.
+#   define _LIBCUDACXX_AVAILABILITY_FUTURE_ERROR
+
+    // This controls the availability of std::type_info's vtable.
+    // I can't imagine how using std::type_info can work at all if
+    // this isn't supported.
+#   define _LIBCUDACXX_AVAILABILITY_TYPEINFO_VTABLE
+
+    // This controls the availability of std::locale::category members
+    // (e.g. std::locale::collate), which are defined in the dylib.
+#   define _LIBCUDACXX_AVAILABILITY_LOCALE_CATEGORY
+
+    // This controls the availability of atomic operations on std::shared_ptr
+    // (e.g. `std::atomic_store(std::shared_ptr)`), which require a shared
+    // lock table located in the dylib.
+#   define _LIBCUDACXX_AVAILABILITY_ATOMIC_SHARED_PTR
+
+    // These macros control the availability of all parts of <filesystem> that
+    // depend on something in the dylib.
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM_PUSH
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM_POP
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem
+
+    // This controls the availability of floating-point std::to_chars functions.
+    // These overloads were added later than the integer overloads.
+#   define _LIBCUDACXX_AVAILABILITY_TO_CHARS_FLOATING_POINT
+
+    // This controls the availability of the C++20 synchronization library,
+    // which requires shared library support for various operations
+    // (see libcxx/src/atomic.cpp). This includes <barier>, <latch>,
+    // <semaphore>, and notification functions on std::atomic.
+#   define _LIBCUDACXX_AVAILABILITY_SYNC
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_latch
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore
+
+    // This controls the availability of the C++20 format library.
+    // The library is in development and not ABI stable yet. P2216 is
+    // retroactively accepted in C++20. This paper contains ABI breaking
+    // changes.
+#   define _LIBCUDACXX_AVAILABILITY_FORMAT
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_format
+
+    // This controls whether the default verbose termination function is
+    // provided by the library.
+    //
+    // Note that when users provide their own custom function, it doesn't
+    // matter whether the dylib provides a default function, and the
+    // availability markup can actually give a false positive diagnostic
+    // (it will think that no function is provided, when in reality the
+    // user has provided their own).
+    //
+    // Users can pass -D_LIBCUDACXX_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED
+    // to the compiler to tell the library not to define its own verbose abort.
+    // Note that defining this macro but failing to define a custom function
+    // will lead to a load-time error on back-deployment targets, so it should
+    // be avoided.
+// #   define _LIBCUDACXX_HAS_NO_VERBOSE_ABORT_IN_LIBRARY
+
+#elif defined(__APPLE__)
+
+#   define _LIBCUDACXX_AVAILABILITY_SHARED_MUTEX                                    \
+        __attribute__((availability(macos,strict,introduced=10.12)))            \
+        __attribute__((availability(ios,strict,introduced=10.0)))               \
+        __attribute__((availability(tvos,strict,introduced=10.0)))              \
+        __attribute__((availability(watchos,strict,introduced=3.0)))
+#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \
+        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \
+        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) ||         \
+        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000)
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex
+#   endif
+
+        // Note: bad_optional_access & friends were not introduced in the matching
+        // macOS and iOS versions, so the version mismatch between macOS and others
+        // is intended.
+#   define _LIBCUDACXX_AVAILABILITY_BAD_OPTIONAL_ACCESS                             \
+        __attribute__((availability(macos,strict,introduced=10.13)))            \
+        __attribute__((availability(ios,strict,introduced=12.0)))               \
+        __attribute__((availability(tvos,strict,introduced=12.0)))              \
+        __attribute__((availability(watchos,strict,introduced=5.0)))
+#   define _LIBCUDACXX_AVAILABILITY_BAD_VARIANT_ACCESS                              \
+        _LIBCUDACXX_AVAILABILITY_BAD_OPTIONAL_ACCESS
+#   define _LIBCUDACXX_AVAILABILITY_BAD_ANY_CAST                                    \
+        _LIBCUDACXX_AVAILABILITY_BAD_OPTIONAL_ACCESS
+
+#   define _LIBCUDACXX_AVAILABILITY_UNCAUGHT_EXCEPTIONS                             \
+        __attribute__((availability(macos,strict,introduced=10.12)))            \
+        __attribute__((availability(ios,strict,introduced=10.0)))               \
+        __attribute__((availability(tvos,strict,introduced=10.0)))              \
+        __attribute__((availability(watchos,strict,introduced=3.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_SIZED_NEW_DELETE                                \
+        __attribute__((availability(macos,strict,introduced=10.12)))            \
+        __attribute__((availability(ios,strict,introduced=10.0)))               \
+        __attribute__((availability(tvos,strict,introduced=10.0)))              \
+        __attribute__((availability(watchos,strict,introduced=3.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_FUTURE_ERROR                                    \
+        __attribute__((availability(ios,strict,introduced=6.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_TYPEINFO_VTABLE                                 \
+        __attribute__((availability(macos,strict,introduced=10.9)))             \
+        __attribute__((availability(ios,strict,introduced=7.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_LOCALE_CATEGORY                                 \
+        __attribute__((availability(macos,strict,introduced=10.9)))             \
+        __attribute__((availability(ios,strict,introduced=7.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_ATOMIC_SHARED_PTR                               \
+        __attribute__((availability(macos,strict,introduced=10.9)))             \
+        __attribute__((availability(ios,strict,introduced=7.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM                                      \
+        __attribute__((availability(macos,strict,introduced=10.15)))            \
+        __attribute__((availability(ios,strict,introduced=13.0)))               \
+        __attribute__((availability(tvos,strict,introduced=13.0)))              \
+        __attribute__((availability(watchos,strict,introduced=6.0)))
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM_PUSH                                 \
+        _Pragma("clang attribute push(__attribute__((availability(macos,strict,introduced=10.15))), apply_to=any(function,record))") \
+        _Pragma("clang attribute push(__attribute__((availability(ios,strict,introduced=13.0))), apply_to=any(function,record))")    \
+        _Pragma("clang attribute push(__attribute__((availability(tvos,strict,introduced=13.0))), apply_to=any(function,record))")   \
+        _Pragma("clang attribute push(__attribute__((availability(watchos,strict,introduced=6.0))), apply_to=any(function,record))")
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM_POP                                  \
+        _Pragma("clang attribute pop")                                          \
+        _Pragma("clang attribute pop")                                          \
+        _Pragma("clang attribute pop")                                          \
+        _Pragma("clang attribute pop")
+#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101500) ||    \
+        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 130000) || \
+        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 130000) ||         \
+        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 60000)
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem
+#   endif
+
+#   define _LIBCUDACXX_AVAILABILITY_TO_CHARS_FLOATING_POINT                         \
+        __attribute__((unavailable))
+
+#   define _LIBCUDACXX_AVAILABILITY_SYNC                                            \
+        __attribute__((availability(macos,strict,introduced=11.0)))             \
+        __attribute__((availability(ios,strict,introduced=14.0)))               \
+        __attribute__((availability(tvos,strict,introduced=14.0)))              \
+        __attribute__((availability(watchos,strict,introduced=7.0)))
+#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 110000) ||    \
+        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 140000) || \
+        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 140000) ||         \
+        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 70000)
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_latch
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore
+#   endif
+
+#   define _LIBCUDACXX_AVAILABILITY_FORMAT                                          \
+        __attribute__((unavailable))
+#   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_format
+
+#   define _LIBCUDACXX_HAS_NO_VERBOSE_ABORT_IN_LIBRARY
+
+#else
+
+// ...New vendors can add availability markup here...
+
+#   error "It looks like you're trying to enable vendor availability markup, but you haven't defined the corresponding macros yet!"
+
+#endif
+
+// Define availability attributes that depend on _LIBCUDACXX_NO_EXCEPTIONS.
+// Those are defined in terms of the availability attributes above, and
+// should not be vendor-specific.
+#if defined(_LIBCUDACXX_NO_EXCEPTIONS)
+#   define _LIBCUDACXX_AVAILABILITY_FUTURE
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_ANY_CAST
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
+#else
+#   define _LIBCUDACXX_AVAILABILITY_FUTURE                    _LIBCUDACXX_AVAILABILITY_FUTURE_ERROR
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_ANY_CAST        _LIBCUDACXX_AVAILABILITY_BAD_ANY_CAST
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS _LIBCUDACXX_AVAILABILITY_BAD_OPTIONAL_ACCESS
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_VARIANT_ACCESS  _LIBCUDACXX_AVAILABILITY_BAD_VARIANT_ACCESS
+#endif
+
+#endif // _LIBCUDACXX___AVAILABILITY

cuda_toolkit/include/cuda/std/detail/libcxx/include/__bit_reference

@@ -0,0 +1,1293 @@
+// -*- 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___BIT_REFERENCE
+#define _LIBCUDACXX___BIT_REFERENCE
+
+#include <__config>
+#include <bit>
+#include <algorithm>
+
+#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_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Cp, bool _IsConst, typename _Cp::__storage_type = 0> class __bit_iterator;
+template <class _Cp> class __bit_const_reference;
+
+template <class _Tp>
+struct __has_storage_type
+{
+    static const bool value = false;
+};
+
+template <class _Cp, bool = __has_storage_type<_Cp>::value>
+class __bit_reference
+{
+    typedef typename _Cp::__storage_type    __storage_type;
+    typedef typename _Cp::__storage_pointer __storage_pointer;
+
+    __storage_pointer __seg_;
+    __storage_type    __mask_;
+
+    friend typename _Cp::__self;
+
+    friend class __bit_const_reference<_Cp>;
+    friend class __bit_iterator<_Cp, false>;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_reference(const __bit_reference&) = default;
+
+    _LIBCUDACXX_INLINE_VISIBILITY operator bool() const noexcept
+        {return static_cast<bool>(*__seg_ & __mask_);}
+    _LIBCUDACXX_INLINE_VISIBILITY bool operator ~() const noexcept
+        {return !static_cast<bool>(*this);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_reference& operator=(bool __x) noexcept
+    {
+        if (__x)
+            *__seg_ |= __mask_;
+        else
+            *__seg_ &= ~__mask_;
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_reference& operator=(const __bit_reference& __x) noexcept
+        {return operator=(static_cast<bool>(__x));}
+
+    _LIBCUDACXX_INLINE_VISIBILITY void flip() noexcept {*__seg_ ^= __mask_;}
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator<_Cp, false> operator&() const noexcept
+        {return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
+private:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_reference(__storage_pointer __s, __storage_type __m) noexcept
+        : __seg_(__s), __mask_(__m) {}
+};
+
+template <class _Cp>
+class __bit_reference<_Cp, false>
+{
+};
+
+template <class _Cp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) noexcept
+{
+    bool __t = __x;
+    __x = __y;
+    __y = __t;
+}
+
+template <class _Cp, class _Dp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) noexcept
+{
+    bool __t = __x;
+    __x = __y;
+    __y = __t;
+}
+
+template <class _Cp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(__bit_reference<_Cp> __x, bool& __y) noexcept
+{
+    bool __t = __x;
+    __x = __y;
+    __y = __t;
+}
+
+template <class _Cp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(bool& __x, __bit_reference<_Cp> __y) noexcept
+{
+    bool __t = __x;
+    __x = __y;
+    __y = __t;
+}
+
+template <class _Cp>
+class __bit_const_reference
+{
+    typedef typename _Cp::__storage_type          __storage_type;
+    typedef typename _Cp::__const_storage_pointer __storage_pointer;
+
+    __storage_pointer        __seg_;
+    __storage_type __mask_;
+
+    friend typename _Cp::__self;
+    friend class __bit_iterator<_Cp, true>;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_const_reference(const __bit_const_reference&) = default;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_const_reference(const __bit_reference<_Cp>& __x) noexcept
+        : __seg_(__x.__seg_), __mask_(__x.__mask_) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr operator bool() const noexcept
+        {return static_cast<bool>(*__seg_ & __mask_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator<_Cp, true> operator&() const noexcept
+        {return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
+private:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr
+    __bit_const_reference(__storage_pointer __s, __storage_type __m) noexcept
+        : __seg_(__s), __mask_(__m) {}
+
+    __bit_const_reference& operator=(const __bit_const_reference&) = delete;
+};
+
+// find
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, _IsConst>
+__find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _It;
+    typedef typename _It::__storage_type __storage_type;
+    static const int __bits_per_word = _It::__bits_per_word;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        __storage_type __b = *__first.__seg_ & __m;
+        if (__b)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));
+        if (__n == __dn)
+            return __first + __n;
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
+        if (*__first.__seg_)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(*__first.__seg_)));
+    // do last partial word
+    if (__n > 0)
+    {
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        __storage_type __b = *__first.__seg_ & __m;
+        if (__b)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));
+    }
+    return _It(__first.__seg_, static_cast<unsigned>(__n));
+}
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, _IsConst>
+__find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _It;
+    typedef typename _It::__storage_type __storage_type;
+    const int __bits_per_word = _It::__bits_per_word;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        __storage_type __b = ~*__first.__seg_ & __m;
+        if (__b)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));
+        if (__n == __dn)
+            return __first + __n;
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
+    {
+        __storage_type __b = ~*__first.__seg_;
+        if (__b)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));
+    }
+    // do last partial word
+    if (__n > 0)
+    {
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        __storage_type __b = ~*__first.__seg_ & __m;
+        if (__b)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));
+    }
+    return _It(__first.__seg_, static_cast<unsigned>(__n));
+}
+
+template <class _Cp, bool _IsConst, class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<_Cp, _IsConst>
+find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
+{
+    if (static_cast<bool>(__value_))
+        return __find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
+    return __find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
+}
+
+// count
+
+template <class _Cp, bool _IsConst>
+typename __bit_iterator<_Cp, _IsConst>::difference_type
+__count_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _It;
+    typedef typename _It::__storage_type __storage_type;
+    typedef typename _It::difference_type difference_type;
+    const int __bits_per_word = _It::__bits_per_word;
+    difference_type __r = 0;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        __r = _CUDA_VSTD::__libcpp_popcount(*__first.__seg_ & __m);
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
+        __r += _CUDA_VSTD::__libcpp_popcount(*__first.__seg_);
+    // do last partial word
+    if (__n > 0)
+    {
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        __r += _CUDA_VSTD::__libcpp_popcount(*__first.__seg_ & __m);
+    }
+    return __r;
+}
+
+template <class _Cp, bool _IsConst>
+typename __bit_iterator<_Cp, _IsConst>::difference_type
+__count_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _It;
+    typedef typename _It::__storage_type __storage_type;
+    typedef typename _It::difference_type difference_type;
+    const int __bits_per_word = _It::__bits_per_word;
+    difference_type __r = 0;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        __r = _CUDA_VSTD::__libcpp_popcount(~*__first.__seg_ & __m);
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
+        __r += _CUDA_VSTD::__libcpp_popcount(~*__first.__seg_);
+    // do last partial word
+    if (__n > 0)
+    {
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        __r += _CUDA_VSTD::__libcpp_popcount(~*__first.__seg_ & __m);
+    }
+    return __r;
+}
+
+template <class _Cp, bool _IsConst, class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+typename __bit_iterator<_Cp, _IsConst>::difference_type
+count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
+{
+    if (static_cast<bool>(__value_))
+        return __count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
+    return __count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
+}
+
+// fill_n
+
+template <class _Cp>
+void
+__fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, false> _It;
+    typedef typename _It::__storage_type __storage_type;
+    const int __bits_per_word = _It::__bits_per_word;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        *__first.__seg_ &= ~__m;
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    __storage_type __nw = __n / __bits_per_word;
+    _CUDA_VSTD::memset(_CUDA_VSTD::__to_raw_pointer(__first.__seg_), 0, __nw * sizeof(__storage_type));
+    __n -= __nw * __bits_per_word;
+    // do last partial word
+    if (__n > 0)
+    {
+        __first.__seg_ += __nw;
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        *__first.__seg_ &= ~__m;
+    }
+}
+
+template <class _Cp>
+void
+__fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, false> _It;
+    typedef typename _It::__storage_type __storage_type;
+    const int __bits_per_word = _It::__bits_per_word;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        *__first.__seg_ |= __m;
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    __storage_type __nw = __n / __bits_per_word;
+    _CUDA_VSTD::memset(_CUDA_VSTD::__to_raw_pointer(__first.__seg_), -1, __nw * sizeof(__storage_type));
+    __n -= __nw * __bits_per_word;
+    // do last partial word
+    if (__n > 0)
+    {
+        __first.__seg_ += __nw;
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        *__first.__seg_ |= __m;
+    }
+}
+
+template <class _Cp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value_)
+{
+    if (__n > 0)
+    {
+        if (__value_)
+            __fill_n_true(__first, __n);
+        else
+            __fill_n_false(__first, __n);
+    }
+}
+
+// fill
+
+template <class _Cp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value_)
+{
+    _CUDA_VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value_);
+}
+
+// copy
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, false>
+__copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
+                                                     __bit_iterator<_Cp, false> __result)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _In;
+    typedef  typename _In::difference_type difference_type;
+    typedef typename _In::__storage_type __storage_type;
+    const int __bits_per_word = _In::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first.__ctz_ != 0)
+        {
+            unsigned __clz = __bits_per_word - __first.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
+            __storage_type __b = *__first.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b;
+            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
+            ++__first.__seg_;
+            // __first.__ctz_ = 0;
+        }
+        // __first.__ctz_ == 0;
+        // do middle words
+        __storage_type __nw = __n / __bits_per_word;
+        _CUDA_VSTD::memmove(_CUDA_VSTD::__to_raw_pointer(__result.__seg_),
+                       _CUDA_VSTD::__to_raw_pointer(__first.__seg_),
+                       __nw * sizeof(__storage_type));
+        __n -= __nw * __bits_per_word;
+        __result.__seg_ += __nw;
+        // do last word
+        if (__n > 0)
+        {
+            __first.__seg_ += __nw;
+            __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            __storage_type __b = *__first.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b;
+            __result.__ctz_ = static_cast<unsigned>(__n);
+        }
+    }
+    return __result;
+}
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, false>
+__copy_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
+                                                       __bit_iterator<_Cp, false> __result)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _In;
+    typedef  typename _In::difference_type difference_type;
+    typedef typename _In::__storage_type __storage_type;
+    static const int __bits_per_word = _In::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first.__ctz_ != 0)
+        {
+            unsigned __clz_f = __bits_per_word - __first.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz_f), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+            __storage_type __b = *__first.__seg_ & __m;
+            unsigned __clz_r = __bits_per_word - __result.__ctz_;
+            __storage_type __ddn = _CUDA_VSTD::min<__storage_type>(__dn, __clz_r);
+            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
+            *__result.__seg_ &= ~__m;
+            if (__result.__ctz_ > __first.__ctz_)
+                *__result.__seg_ |= __b << (__result.__ctz_ - __first.__ctz_);
+            else
+                *__result.__seg_ |= __b >> (__first.__ctz_ - __result.__ctz_);
+            __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_)  % __bits_per_word);
+            __dn -= __ddn;
+            if (__dn > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __dn);
+                *__result.__seg_ &= ~__m;
+                *__result.__seg_ |= __b >> (__first.__ctz_ + __ddn);
+                __result.__ctz_ = static_cast<unsigned>(__dn);
+            }
+            ++__first.__seg_;
+            // __first.__ctz_ = 0;
+        }
+        // __first.__ctz_ == 0;
+        // do middle words
+        unsigned __clz_r = __bits_per_word - __result.__ctz_;
+        __storage_type __m = ~__storage_type(0) << __result.__ctz_;
+        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_)
+        {
+            __storage_type __b = *__first.__seg_;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b << __result.__ctz_;
+            ++__result.__seg_;
+            *__result.__seg_ &= __m;
+            *__result.__seg_ |= __b >> __clz_r;
+        }
+        // do last word
+        if (__n > 0)
+        {
+            __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            __storage_type __b = *__first.__seg_ & __m;
+            __storage_type __dn = _CUDA_VSTD::min(__n, static_cast<difference_type>(__clz_r));
+            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b << __result.__ctz_;
+            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
+            __n -= __dn;
+            if (__n > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __n);
+                *__result.__seg_ &= ~__m;
+                *__result.__seg_ |= __b >> __dn;
+                __result.__ctz_ = static_cast<unsigned>(__n);
+            }
+        }
+    }
+    return __result;
+}
+
+template <class _Cp, bool _IsConst>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<_Cp, false>
+copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
+{
+    if (__first.__ctz_ == __result.__ctz_)
+        return __copy_aligned(__first, __last, __result);
+    return __copy_unaligned(__first, __last, __result);
+}
+
+// copy_backward
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, false>
+__copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
+                                                     __bit_iterator<_Cp, false> __result)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _In;
+    typedef  typename _In::difference_type difference_type;
+    typedef typename _In::__storage_type __storage_type;
+    const int __bits_per_word = _In::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__last.__ctz_ != 0)
+        {
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
+            __n -= __dn;
+            unsigned __clz = __bits_per_word - __last.__ctz_;
+            __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz);
+            __storage_type __b = *__last.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b;
+            __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) +
+                                                       __result.__ctz_)  % __bits_per_word);
+            // __last.__ctz_ = 0
+         }
+        // __last.__ctz_ == 0 || __n == 0
+        // __result.__ctz_ == 0 || __n == 0
+        // do middle words
+        __storage_type __nw = __n / __bits_per_word;
+        __result.__seg_ -= __nw;
+        __last.__seg_ -= __nw;
+        _CUDA_VSTD::memmove(_CUDA_VSTD::__to_raw_pointer(__result.__seg_),
+                       _CUDA_VSTD::__to_raw_pointer(__last.__seg_),
+                       __nw * sizeof(__storage_type));
+        __n -= __nw * __bits_per_word;
+        // do last word
+        if (__n > 0)
+        {
+            __storage_type __m = ~__storage_type(0) << (__bits_per_word - __n);
+            __storage_type __b = *--__last.__seg_ & __m;
+            *--__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b;
+            __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
+        }
+    }
+    return __result;
+}
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, false>
+__copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
+                                                       __bit_iterator<_Cp, false> __result)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _In;
+    typedef  typename _In::difference_type difference_type;
+    typedef typename _In::__storage_type __storage_type;
+    const int __bits_per_word = _In::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__last.__ctz_ != 0)
+        {
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
+            __n -= __dn;
+            unsigned __clz_l = __bits_per_word - __last.__ctz_;
+            __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_l);
+            __storage_type __b = *__last.__seg_ & __m;
+            unsigned __clz_r = __bits_per_word - __result.__ctz_;
+            __storage_type __ddn = _CUDA_VSTD::min(__dn, static_cast<difference_type>(__result.__ctz_));
+            if (__ddn > 0)
+            {
+                __m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r);
+                *__result.__seg_ &= ~__m;
+                if (__result.__ctz_ > __last.__ctz_)
+                    *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);
+                else
+                    *__result.__seg_ |= __b >> (__last.__ctz_ - __result.__ctz_);
+                __result.__ctz_ = static_cast<unsigned>(((-__ddn & (__bits_per_word - 1)) +
+                                                         __result.__ctz_)  % __bits_per_word);
+                __dn -= __ddn;
+            }
+            if (__dn > 0)
+            {
+                // __result.__ctz_ == 0
+                --__result.__seg_;
+                __result.__ctz_ = static_cast<unsigned>(-__dn & (__bits_per_word - 1));
+                __m = ~__storage_type(0) << __result.__ctz_;
+                *__result.__seg_ &= ~__m;
+                __last.__ctz_ -= __dn + __ddn;
+                *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);
+            }
+            // __last.__ctz_ = 0
+         }
+        // __last.__ctz_ == 0 || __n == 0
+        // __result.__ctz_ != 0 || __n == 0
+        // do middle words
+        unsigned __clz_r = __bits_per_word - __result.__ctz_;
+        __storage_type __m = ~__storage_type(0) >> __clz_r;
+        for (; __n >= __bits_per_word; __n -= __bits_per_word)
+        {
+            __storage_type __b = *--__last.__seg_;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b >> __clz_r;
+            *--__result.__seg_ &= __m;
+            *__result.__seg_ |= __b << __result.__ctz_;
+        }
+        // do last word
+        if (__n > 0)
+        {
+            __m = ~__storage_type(0) << (__bits_per_word - __n);
+            __storage_type __b = *--__last.__seg_ & __m;
+            __clz_r = __bits_per_word - __result.__ctz_;
+            __storage_type __dn = _CUDA_VSTD::min(__n, static_cast<difference_type>(__result.__ctz_));
+            __m = (~__storage_type(0) << (__result.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_r);
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b >> (__bits_per_word - __result.__ctz_);
+            __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) +
+                                                     __result.__ctz_)  % __bits_per_word);
+            __n -= __dn;
+            if (__n > 0)
+            {
+                // __result.__ctz_ == 0
+                --__result.__seg_;
+                __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
+                __m = ~__storage_type(0) << __result.__ctz_;
+                *__result.__seg_ &= ~__m;
+                *__result.__seg_ |= __b << (__result.__ctz_ - (__bits_per_word - __n - __dn));
+            }
+        }
+    }
+    return __result;
+}
+
+template <class _Cp, bool _IsConst>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<_Cp, false>
+copy_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
+{
+    if (__last.__ctz_ == __result.__ctz_)
+        return __copy_backward_aligned(__first, __last, __result);
+    return __copy_backward_unaligned(__first, __last, __result);
+}
+
+// move
+
+template <class _Cp, bool _IsConst>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<_Cp, false>
+move(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
+{
+    return _CUDA_VSTD::copy(__first, __last, __result);
+}
+
+// move_backward
+
+template <class _Cp, bool _IsConst>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<_Cp, false>
+move_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
+{
+    return _CUDA_VSTD::copy_backward(__first, __last, __result);
+}
+
+// swap_ranges
+
+template <class __C1, class __C2>
+__bit_iterator<__C2, false>
+__swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
+                      __bit_iterator<__C2, false> __result)
+{
+    typedef __bit_iterator<__C1, false> _I1;
+    typedef  typename _I1::difference_type difference_type;
+    typedef typename _I1::__storage_type __storage_type;
+    const int __bits_per_word = _I1::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first.__ctz_ != 0)
+        {
+            unsigned __clz = __bits_per_word - __first.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
+            __storage_type __b1 = *__first.__seg_ & __m;
+            *__first.__seg_ &= ~__m;
+            __storage_type __b2 = *__result.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b1;
+            *__first.__seg_  |= __b2;
+            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
+            ++__first.__seg_;
+            // __first.__ctz_ = 0;
+        }
+        // __first.__ctz_ == 0;
+        // do middle words
+        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_, ++__result.__seg_)
+            swap(*__first.__seg_, *__result.__seg_);
+        // do last word
+        if (__n > 0)
+        {
+            __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            __storage_type __b1 = *__first.__seg_ & __m;
+            *__first.__seg_ &= ~__m;
+            __storage_type __b2 = *__result.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b1;
+            *__first.__seg_  |= __b2;
+            __result.__ctz_ = static_cast<unsigned>(__n);
+        }
+    }
+    return __result;
+}
+
+template <class __C1, class __C2>
+__bit_iterator<__C2, false>
+__swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
+                        __bit_iterator<__C2, false> __result)
+{
+    typedef __bit_iterator<__C1, false> _I1;
+    typedef  typename _I1::difference_type difference_type;
+    typedef typename _I1::__storage_type __storage_type;
+    const int __bits_per_word = _I1::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first.__ctz_ != 0)
+        {
+            unsigned __clz_f = __bits_per_word - __first.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz_f), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+            __storage_type __b1 = *__first.__seg_ & __m;
+            *__first.__seg_ &= ~__m;
+            unsigned __clz_r = __bits_per_word - __result.__ctz_;
+            __storage_type __ddn = _CUDA_VSTD::min<__storage_type>(__dn, __clz_r);
+            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
+            __storage_type __b2 = *__result.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            if (__result.__ctz_ > __first.__ctz_)
+            {
+                unsigned __s = __result.__ctz_ - __first.__ctz_;
+                *__result.__seg_ |= __b1 << __s;
+                *__first.__seg_  |= __b2 >> __s;
+            }
+            else
+            {
+                unsigned __s = __first.__ctz_ - __result.__ctz_;
+                *__result.__seg_ |= __b1 >> __s;
+                *__first.__seg_  |= __b2 << __s;
+            }
+            __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_)  % __bits_per_word);
+            __dn -= __ddn;
+            if (__dn > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __dn);
+                __b2 = *__result.__seg_ & __m;
+                *__result.__seg_ &= ~__m;
+                unsigned __s = __first.__ctz_ + __ddn;
+                *__result.__seg_ |= __b1 >> __s;
+                *__first.__seg_  |= __b2 << __s;
+                __result.__ctz_ = static_cast<unsigned>(__dn);
+            }
+            ++__first.__seg_;
+            // __first.__ctz_ = 0;
+        }
+        // __first.__ctz_ == 0;
+        // do middle words
+        __storage_type __m = ~__storage_type(0) << __result.__ctz_;
+        unsigned __clz_r = __bits_per_word - __result.__ctz_;
+        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_)
+        {
+            __storage_type __b1 = *__first.__seg_;
+            __storage_type __b2 = *__result.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b1 << __result.__ctz_;
+            *__first.__seg_  = __b2 >> __result.__ctz_;
+            ++__result.__seg_;
+            __b2 = *__result.__seg_ & ~__m;
+            *__result.__seg_ &= __m;
+            *__result.__seg_ |= __b1 >> __clz_r;
+            *__first.__seg_  |= __b2 << __clz_r;
+        }
+        // do last word
+        if (__n > 0)
+        {
+            __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            __storage_type __b1 = *__first.__seg_ & __m;
+            *__first.__seg_ &= ~__m;
+            __storage_type __dn = _CUDA_VSTD::min<__storage_type>(__n, __clz_r);
+            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
+            __storage_type __b2 = *__result.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b1 << __result.__ctz_;
+            *__first.__seg_  |= __b2 >> __result.__ctz_;
+            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
+            __n -= __dn;
+            if (__n > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __n);
+                __b2 = *__result.__seg_ & __m;
+                *__result.__seg_ &= ~__m;
+                *__result.__seg_ |= __b1 >> __dn;
+                *__first.__seg_  |= __b2 << __dn;
+                __result.__ctz_ = static_cast<unsigned>(__n);
+            }
+        }
+    }
+    return __result;
+}
+
+template <class __C1, class __C2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<__C2, false>
+swap_ranges(__bit_iterator<__C1, false> __first1, __bit_iterator<__C1, false> __last1,
+            __bit_iterator<__C2, false> __first2)
+{
+    if (__first1.__ctz_ == __first2.__ctz_)
+        return __swap_ranges_aligned(__first1, __last1, __first2);
+    return __swap_ranges_unaligned(__first1, __last1, __first2);
+}
+
+// rotate
+
+template <class _Cp>
+struct __bit_array
+{
+    typedef typename _Cp::difference_type difference_type;
+    typedef typename _Cp::__storage_type  __storage_type;
+    typedef typename _Cp::__storage_pointer __storage_pointer;
+    typedef typename _Cp::iterator        iterator;
+    static const unsigned __bits_per_word = _Cp::__bits_per_word;
+    static const unsigned _Np = 4;
+
+    difference_type __size_;
+    __storage_type __word_[_Np];
+
+    _LIBCUDACXX_INLINE_VISIBILITY static difference_type capacity()
+        {return static_cast<difference_type>(_Np * __bits_per_word);}
+    _LIBCUDACXX_INLINE_VISIBILITY explicit __bit_array(difference_type __s) : __size_(__s) {}
+    _LIBCUDACXX_INLINE_VISIBILITY iterator begin()
+    {
+        return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]), 0);
+    }
+    _LIBCUDACXX_INLINE_VISIBILITY iterator end()
+    {
+        return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]) + __size_ / __bits_per_word,
+                                                  static_cast<unsigned>(__size_ % __bits_per_word));
+    }
+};
+
+template <class _Cp>
+__bit_iterator<_Cp, false>
+rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle, __bit_iterator<_Cp, false> __last)
+{
+    typedef __bit_iterator<_Cp, false> _I1;
+    typedef  typename _I1::difference_type difference_type;
+    difference_type __d1 = __middle - __first;
+    difference_type __d2 = __last - __middle;
+    _I1 __r = __first + __d2;
+    while (__d1 != 0 && __d2 != 0)
+    {
+        if (__d1 <= __d2)
+        {
+            if (__d1 <= __bit_array<_Cp>::capacity())
+            {
+                __bit_array<_Cp> __b(__d1);
+                _CUDA_VSTD::copy(__first, __middle, __b.begin());
+                _CUDA_VSTD::copy(__b.begin(), __b.end(), _CUDA_VSTD::copy(__middle, __last, __first));
+                break;
+            }
+            else
+            {
+                __bit_iterator<_Cp, false> __mp = _CUDA_VSTD::swap_ranges(__first, __middle, __middle);
+                __first = __middle;
+                __middle = __mp;
+                __d2 -= __d1;
+            }
+        }
+        else
+        {
+            if (__d2 <= __bit_array<_Cp>::capacity())
+            {
+                __bit_array<_Cp> __b(__d2);
+                _CUDA_VSTD::copy(__middle, __last, __b.begin());
+                _CUDA_VSTD::copy_backward(__b.begin(), __b.end(), _CUDA_VSTD::copy_backward(__first, __middle, __last));
+                break;
+            }
+            else
+            {
+                __bit_iterator<_Cp, false> __mp = __first + __d2;
+                _CUDA_VSTD::swap_ranges(__first, __mp, __middle);
+                __first = __mp;
+                __d1 -= __d2;
+            }
+        }
+    }
+    return __r;
+}
+
+// equal
+
+template <class _Cp, bool _IC1, bool _IC2>
+bool
+__equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
+                  __bit_iterator<_Cp, _IC2> __first2)
+{
+    typedef __bit_iterator<_Cp, _IC1> _It;
+    typedef  typename _It::difference_type difference_type;
+    typedef typename _It::__storage_type __storage_type;
+    static const int __bits_per_word = _It::__bits_per_word;
+    difference_type __n = __last1 - __first1;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first1.__ctz_ != 0)
+        {
+            unsigned __clz_f = __bits_per_word - __first1.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz_f), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+            __storage_type __b = *__first1.__seg_ & __m;
+            unsigned __clz_r = __bits_per_word - __first2.__ctz_;
+            __storage_type __ddn = _CUDA_VSTD::min<__storage_type>(__dn, __clz_r);
+            __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
+            if (__first2.__ctz_ > __first1.__ctz_)
+            {
+                if ((*__first2.__seg_ & __m) != (__b << (__first2.__ctz_ - __first1.__ctz_)))
+                    return false;
+            }
+            else
+            {
+                if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ - __first2.__ctz_)))
+                    return false;
+            }
+            __first2.__seg_ += (__ddn + __first2.__ctz_) / __bits_per_word;
+            __first2.__ctz_ = static_cast<unsigned>((__ddn + __first2.__ctz_)  % __bits_per_word);
+            __dn -= __ddn;
+            if (__dn > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __dn);
+                if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ + __ddn)))
+                    return false;
+                __first2.__ctz_ = static_cast<unsigned>(__dn);
+            }
+            ++__first1.__seg_;
+            // __first1.__ctz_ = 0;
+        }
+        // __first1.__ctz_ == 0;
+        // do middle words
+        unsigned __clz_r = __bits_per_word - __first2.__ctz_;
+        __storage_type __m = ~__storage_type(0) << __first2.__ctz_;
+        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_)
+        {
+            __storage_type __b = *__first1.__seg_;
+            if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
+                return false;
+            ++__first2.__seg_;
+            if ((*__first2.__seg_ & ~__m) != (__b >> __clz_r))
+                return false;
+        }
+        // do last word
+        if (__n > 0)
+        {
+            __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            __storage_type __b = *__first1.__seg_ & __m;
+            __storage_type __dn = _CUDA_VSTD::min(__n, static_cast<difference_type>(__clz_r));
+            __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
+            if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
+                return false;
+            __first2.__seg_ += (__dn + __first2.__ctz_) / __bits_per_word;
+            __first2.__ctz_ = static_cast<unsigned>((__dn + __first2.__ctz_)  % __bits_per_word);
+            __n -= __dn;
+            if (__n > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __n);
+                if ((*__first2.__seg_ & __m) != (__b >> __dn))
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+
+template <class _Cp, bool _IC1, bool _IC2>
+bool
+__equal_aligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
+                __bit_iterator<_Cp, _IC2> __first2)
+{
+    typedef __bit_iterator<_Cp, _IC1> _It;
+    typedef  typename _It::difference_type difference_type;
+    typedef typename _It::__storage_type __storage_type;
+    static const int __bits_per_word = _It::__bits_per_word;
+    difference_type __n = __last1 - __first1;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first1.__ctz_ != 0)
+        {
+            unsigned __clz = __bits_per_word - __first1.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
+            if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
+                return false;
+            ++__first2.__seg_;
+            ++__first1.__seg_;
+            // __first1.__ctz_ = 0;
+            // __first2.__ctz_ = 0;
+        }
+        // __first1.__ctz_ == 0;
+        // __first2.__ctz_ == 0;
+        // do middle words
+        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_, ++__first2.__seg_)
+            if (*__first2.__seg_ != *__first1.__seg_)
+                return false;
+        // do last word
+        if (__n > 0)
+        {
+            __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
+                return false;
+        }
+    }
+    return true;
+}
+
+template <class _Cp, bool _IC1, bool _IC2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2)
+{
+    if (__first1.__ctz_ == __first2.__ctz_)
+        return __equal_aligned(__first1, __last1, __first2);
+    return __equal_unaligned(__first1, __last1, __first2);
+}
+
+template <class _Cp, bool _IsConst,
+          typename _Cp::__storage_type>
+class __bit_iterator
+{
+public:
+    typedef typename _Cp::difference_type                                                          difference_type;
+    typedef bool                                                                                  value_type;
+    typedef __bit_iterator                                                                        pointer;
+    typedef typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >::type reference;
+    typedef random_access_iterator_tag                                                            iterator_category;
+
+private:
+    typedef typename _Cp::__storage_type                                           __storage_type;
+    typedef typename conditional<_IsConst, typename _Cp::__const_storage_pointer,
+                                           typename _Cp::__storage_pointer>::type  __storage_pointer;
+    static const unsigned __bits_per_word = _Cp::__bits_per_word;
+
+    __storage_pointer __seg_;
+    unsigned          __ctz_;
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator() noexcept
+#if _LIBCUDACXX_STD_VER > 11
+    : __seg_(nullptr), __ctz_(0)
+#endif
+    {}
+    // avoid re-declaring a copy constructor for the non-const version.
+    using __type_for_copy_to_const =
+      _If<_IsConst, __bit_iterator<_Cp, false>, struct __private_nat>;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_iterator(const __type_for_copy_to_const& __it) noexcept
+        : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY reference operator*() const noexcept
+        {return reference(__seg_, __storage_type(1) << __ctz_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator++()
+    {
+        if (__ctz_ != __bits_per_word-1)
+            ++__ctz_;
+        else
+        {
+            __ctz_ = 0;
+            ++__seg_;
+        }
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator++(int)
+    {
+        __bit_iterator __tmp = *this;
+        ++(*this);
+        return __tmp;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator--()
+    {
+        if (__ctz_ != 0)
+            --__ctz_;
+        else
+        {
+            __ctz_ = __bits_per_word - 1;
+            --__seg_;
+        }
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator--(int)
+    {
+        __bit_iterator __tmp = *this;
+        --(*this);
+        return __tmp;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator+=(difference_type __n)
+    {
+        if (__n >= 0)
+            __seg_ += (__n + __ctz_) / __bits_per_word;
+        else
+            __seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1)
+                    / static_cast<difference_type>(__bits_per_word);
+        __n &= (__bits_per_word - 1);
+        __ctz_ = static_cast<unsigned>((__n + __ctz_)  % __bits_per_word);
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator-=(difference_type __n)
+    {
+        return *this += -__n;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator+(difference_type __n) const
+    {
+        __bit_iterator __t(*this);
+        __t += __n;
+        return __t;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator-(difference_type __n) const
+    {
+        __bit_iterator __t(*this);
+        __t -= __n;
+        return __t;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    friend __bit_iterator operator+(difference_type __n, const __bit_iterator& __it) {return __it + __n;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    friend difference_type operator-(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return (__x.__seg_ - __y.__seg_) * __bits_per_word + __x.__ctz_ - __y.__ctz_;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY reference operator[](difference_type __n) const {return *(*this + __n);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator==(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator!=(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return !(__x == __y);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator<(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return __x.__seg_ < __y.__seg_ || (__x.__seg_ == __y.__seg_ && __x.__ctz_ < __y.__ctz_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator>(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return __y < __x;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator<=(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return !(__y < __x);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator>=(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return !(__x < __y);}
+
+private:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_iterator(__storage_pointer __s, unsigned __ctz) noexcept
+        : __seg_(__s), __ctz_(__ctz) {}
+
+    friend typename _Cp::__self;
+
+    friend class __bit_reference<_Cp>;
+    friend class __bit_const_reference<_Cp>;
+    friend class __bit_iterator<_Cp, true>;
+    template <class _Dp> friend struct __bit_array;
+    template <class _Dp> friend void __fill_n_false(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
+    template <class _Dp> friend void __fill_n_true(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_aligned(__bit_iterator<_Dp, _IC> __first,
+                                                                                  __bit_iterator<_Dp, _IC> __last,
+                                                                                  __bit_iterator<_Dp, false> __result);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_unaligned(__bit_iterator<_Dp, _IC> __first,
+                                                                                    __bit_iterator<_Dp, _IC> __last,
+                                                                                    __bit_iterator<_Dp, false> __result);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> copy(__bit_iterator<_Dp, _IC> __first,
+                                                                        __bit_iterator<_Dp, _IC> __last,
+                                                                        __bit_iterator<_Dp, false> __result);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_backward_aligned(__bit_iterator<_Dp, _IC> __first,
+                                                                                           __bit_iterator<_Dp, _IC> __last,
+                                                                                           __bit_iterator<_Dp, false> __result);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_backward_unaligned(__bit_iterator<_Dp, _IC> __first,
+                                                                                             __bit_iterator<_Dp, _IC> __last,
+                                                                                             __bit_iterator<_Dp, false> __result);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> copy_backward(__bit_iterator<_Dp, _IC> __first,
+                                                                                 __bit_iterator<_Dp, _IC> __last,
+                                                                                 __bit_iterator<_Dp, false> __result);
+    template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>,
+                                                                                           __bit_iterator<__C1, false>,
+                                                                                           __bit_iterator<__C2, false>);
+    template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>,
+                                                                                             __bit_iterator<__C1, false>,
+                                                                                             __bit_iterator<__C2, false>);
+    template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>,
+                                                                                 __bit_iterator<__C1, false>,
+                                                                                 __bit_iterator<__C2, false>);
+    template <class _Dp> friend __bit_iterator<_Dp, false> rotate(__bit_iterator<_Dp, false>,
+                                                                __bit_iterator<_Dp, false>,
+                                                                __bit_iterator<_Dp, false>);
+    template <class _Dp, bool _IC1, bool _IC2> friend bool __equal_aligned(__bit_iterator<_Dp, _IC1>,
+                                                    __bit_iterator<_Dp, _IC1>,
+                                                    __bit_iterator<_Dp, _IC2>);
+    template <class _Dp, bool _IC1, bool _IC2> friend bool __equal_unaligned(__bit_iterator<_Dp, _IC1>,
+                                                      __bit_iterator<_Dp, _IC1>,
+                                                      __bit_iterator<_Dp, _IC2>);
+    template <class _Dp, bool _IC1, bool _IC2> friend bool equal(__bit_iterator<_Dp, _IC1>,
+                                                                __bit_iterator<_Dp, _IC1>,
+                                                                __bit_iterator<_Dp, _IC2>);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, _IC> __find_bool_true(__bit_iterator<_Dp, _IC>,
+                                                                          typename _Dp::size_type);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, _IC> __find_bool_false(__bit_iterator<_Dp, _IC>,
+                                                                           typename _Dp::size_type);
+    template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
+                   __count_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
+    template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
+                   __count_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_LIBCUDACXX_POP_MACROS
+
+#endif  // _LIBCUDACXX___BIT_REFERENCE

cuda_toolkit/include/cuda/std/detail/libcxx/include/__bsd_locale_defaults.h

@@ -0,0 +1,40 @@
+// -*- C++ -*-
+//===---------------------- __bsd_locale_defaults.h -----------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+// The BSDs have lots of *_l functions.  We don't want to define those symbols
+// on other platforms though, for fear of conflicts with user code.  So here,
+// we will define the mapping from an internal macro to the real BSD symbol.
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_BSD_LOCALE_DEFAULTS_H
+#define _LIBCUDACXX_BSD_LOCALE_DEFAULTS_H
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#define __libcpp_mb_cur_max_l(loc)                          MB_CUR_MAX_L(loc)
+#define __libcpp_btowc_l(ch, loc)                           btowc_l(ch, loc)
+#define __libcpp_wctob_l(wch, loc)                          wctob_l(wch, loc)
+#define __libcpp_wcsnrtombs_l(dst, src, nwc, len, ps, loc)  wcsnrtombs_l(dst, src, nwc, len, ps, loc)
+#define __libcpp_wcrtomb_l(src, wc, ps, loc)                wcrtomb_l(src, wc, ps, loc)
+#define __libcpp_mbsnrtowcs_l(dst, src, nms, len, ps, loc)  mbsnrtowcs_l(dst, src, nms, len, ps, loc)
+#define __libcpp_mbrtowc_l(pwc, s, n, ps, l)                mbrtowc_l(pwc, s, n, ps, l)
+#define __libcpp_mbtowc_l(pwc, pmb, max, l)                 mbtowc_l(pwc, pmb, max, l)
+#define __libcpp_mbrlen_l(s, n, ps, l)                      mbrlen_l(s, n, ps, l)
+#define __libcpp_localeconv_l(l)                            localeconv_l(l)
+#define __libcpp_mbsrtowcs_l(dest, src, len, ps, l)         mbsrtowcs_l(dest, src, len, ps, l)
+#define __libcpp_snprintf_l(...)                            snprintf_l(__VA_ARGS__)
+#define __libcpp_asprintf_l(...)                            asprintf_l(__VA_ARGS__)
+#define __libcpp_sscanf_l(...)                              sscanf_l(__VA_ARGS__)
+
+#endif // _LIBCUDACXX_BSD_LOCALE_DEFAULTS_H

cuda_toolkit/include/cuda/std/detail/libcxx/include/__bsd_locale_fallbacks.h

@@ -0,0 +1,143 @@
+// -*- C++ -*-
+//===---------------------- __bsd_locale_fallbacks.h ----------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+// The BSDs have lots of *_l functions.  This file provides reimplementations
+// of those functions for non-BSD platforms.
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_BSD_LOCALE_FALLBACKS_DEFAULTS_H
+#define _LIBCUDACXX_BSD_LOCALE_FALLBACKS_DEFAULTS_H
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <memory>
+
+#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
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+decltype(MB_CUR_MAX) __libcpp_mb_cur_max_l(locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return MB_CUR_MAX;
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+wint_t __libcpp_btowc_l(int __c, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return btowc(__c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+int __libcpp_wctob_l(wint_t __c, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return wctob(__c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_wcsnrtombs_l(char *__dest, const wchar_t **__src, size_t __nwc,
+                         size_t __len, mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return wcsnrtombs(__dest, __src, __nwc, __len, __ps);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return wcrtomb(__s, __wc, __ps);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms,
+                      size_t __len, mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return mbsnrtowcs(__dest, __src, __nms, __len, __ps);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
+                   mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return mbrtowc(__pwc, __s, __n, __ps);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+int __libcpp_mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return mbtowc(__pwc, __pmb, __max);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return mbrlen(__s, __n, __ps);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+lconv *__libcpp_localeconv_l(locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return localeconv();
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len,
+                     mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return mbsrtowcs(__dest, __src, __len, __ps);
+}
+
+inline
+int __libcpp_snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...) {
+    va_list __va;
+    va_start(__va, __format);
+    __libcpp_locale_guard __current(__l);
+    int __res = vsnprintf(__s, __n, __format, __va);
+    va_end(__va);
+    return __res;
+}
+
+inline
+int __libcpp_asprintf_l(char **__s, locale_t __l, const char *__format, ...) {
+    va_list __va;
+    va_start(__va, __format);
+    __libcpp_locale_guard __current(__l);
+    int __res = vasprintf(__s, __format, __va);
+    va_end(__va);
+    return __res;
+}
+
+inline
+int __libcpp_sscanf_l(const char *__s, locale_t __l, const char *__format, ...) {
+    va_list __va;
+    va_start(__va, __format);
+    __libcpp_locale_guard __current(__l);
+    int __res = vsscanf(__s, __format, __va);
+    va_end(__va);
+    return __res;
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX_BSD_LOCALE_FALLBACKS_DEFAULTS_H

cuda_toolkit/include/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/include/__cccl_config

@@ -0,0 +1,194 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_CONFIG
+#define __CCCL_CONFIG
+
+// Determine the host compiler
+#if defined(__INTEL_LLVM_COMPILER)
+#  define _CCCL_COMPILER_ICC_LLVM
+#elif defined(__INTEL_COMPILER)
+#  define _CCCL_COMPILER_ICC
+#elif defined(__NVCOMPILER)
+#  define _CCCL_COMPILER_NVHPC
+#elif defined(__clang__)
+#  define _CCCL_COMPILER_CLANG
+#elif defined(__GNUC__)
+#  define _CCCL_COMPILER_GCC
+#elif defined(_MSC_VER)
+#  define _CCCL_COMPILER_MSVC
+#elif defined(__IBMCPP__)
+#  define _CCCL_COMPILER_IBM
+#elif defined(__CUDACC_RTC__)
+#  define _CCCL_COMPILER_NVRTC
+#endif
+
+// Convenient shortcut to determine which version of MSVC we are dealing with
+#if defined(_CCCL_COMPILER_MSVC)
+#  if _MSC_VER < 1917
+#    define _CCCL_COMPILER_MSVC_2017
+#  elif _MSC_VER < 1930
+#    define _CCCL_COMPILER_MSVC_2019
+#  else // _MSC_VER < 1940
+#    define _CCCL_COMPILER_MSVC_2022
+#  endif // _MSC_VER < 1940
+#endif // _CCCL_COMPILER_MSVC
+
+// Determine the cuda compiler
+#if defined(__NVCC__)
+#  define _CCCL_CUDA_COMPILER_NVCC
+#elif defined(_NVHPC_CUDA)
+#  define _CCCL_CUDA_COMPILER_NVHPC
+#elif defined(__CUDA__) && defined(_CCCL_COMPILER_CLANG)
+#  define _CCCL_CUDA_COMPILER_CLANG
+#endif
+
+// Shorthand to check whether there is a cuda compiler available
+#if defined(_CCCL_CUDA_COMPILER_NVCC) || defined(_CCCL_CUDA_COMPILER_NVHPC) || defined(_CCCL_CUDA_COMPILER_CLANG) \
+  || defined(_CCCL_COMPILER_NVRTC)
+#  define _CCCL_CUDA_COMPILER
+#endif // cuda compiler available
+
+// Enforce that cccl headers are treated as system headers
+#if defined(_CCCL_COMPILER_GCC) || defined(_CCCL_COMPILER_NVHPC) || defined(_CCCL_COMPILER_ICC) \
+  || defined(_CCCL_COMPILER_ICC_LLVM)
+#  define _CCCL_FORCE_SYSTEM_HEADER_GCC
+#elif defined(_CCCL_COMPILER_CLANG)
+#  define _CCCL_FORCE_SYSTEM_HEADER_CLANG
+#elif defined(_CCCL_COMPILER_MSVC)
+#  define _CCCL_FORCE_SYSTEM_HEADER_MSVC
+#endif // other compilers
+
+// Potentially enable that cccl headers are treated as system headers
+#if !defined(_CCCL_NO_SYSTEM_HEADER)                                                     \
+  && !(defined(_CCCL_COMPILER_MSVC) && defined(_LIBCUDACXX_DISABLE_PRAGMA_MSVC_WARNING)) \
+  && !defined(_CCCL_COMPILER_NVRTC) && !defined(_LIBCUDACXX_DISABLE_PRAGMA_GCC_SYSTEM_HEADER)
+#  if defined(_CCCL_COMPILER_GCC) || defined(_CCCL_COMPILER_NVHPC) || defined(_CCCL_COMPILER_ICC) \
+    || defined(_CCCL_COMPILER_ICC_LLVM)
+#    define _CCCL_IMPLICIT_SYSTEM_HEADER_GCC
+#  elif defined(_CCCL_COMPILER_CLANG)
+#    define _CCCL_IMPLICIT_SYSTEM_HEADER_CLANG
+#  elif defined(_CCCL_COMPILER_MSVC)
+#    define _CCCL_IMPLICIT_SYSTEM_HEADER_MSVC
+#  endif // other compilers
+#endif // Use system header
+
+// Potentially silence all warnings from this header
+#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
+
+// Enable us to selectively silence host compiler warnings
+#define _CCCL_TOSTRING2(_STR) #_STR
+#define _CCCL_TOSTRING(_STR)  _CCCL_TOSTRING2(_STR)
+#ifdef _CCCL_COMPILER_CLANG
+#  define _CCCL_DIAG_PUSH                _Pragma("clang diagnostic push")
+#  define _CCCL_DIAG_POP                 _Pragma("clang diagnostic pop")
+#  define _CCCL_DIAG_SUPPRESS_CLANG(str) _Pragma(_CCCL_TOSTRING(clang diagnostic ignored str))
+#  define _CCCL_DIAG_SUPPRESS_GCC(str)
+#  define _CCCL_DIAG_SUPPRESS_NVHPC(str)
+#  define _CCCL_DIAG_SUPPRESS_MSVC(str)
+#elif defined(_CCCL_COMPILER_GCC)
+#  define _CCCL_DIAG_PUSH _Pragma("GCC diagnostic push")
+#  define _CCCL_DIAG_POP  _Pragma("GCC diagnostic pop")
+#  define _CCCL_DIAG_SUPPRESS_CLANG(str)
+#  define _CCCL_DIAG_SUPPRESS_GCC(str) _Pragma(_CCCL_TOSTRING(GCC diagnostic ignored str))
+#  define _CCCL_DIAG_SUPPRESS_NVHPC(str)
+#  define _CCCL_DIAG_SUPPRESS_MSVC(str)
+#elif defined(_CCCL_COMPILER_NVHPC)
+#  define _CCCL_DIAG_PUSH _Pragma("diagnostic push")
+#  define _CCCL_DIAG_POP  _Pragma("diagnostic pop")
+#  define _CCCL_DIAG_SUPPRESS_CLANG(str)
+#  define _CCCL_DIAG_SUPPRESS_GCC(str)
+#  define _CCCL_DIAG_SUPPRESS_NVHPC(str) _Pragma(_CCCL_TOSTRING(diag_suppress str))
+#  define _CCCL_DIAG_SUPPRESS_MSVC(str)
+#elif defined(_CCCL_COMPILER_MSVC)
+#  define _CCCL_DIAG_PUSH __pragma(warning(push))
+#  define _CCCL_DIAG_POP  __pragma(warning(pop))
+#  define _CCCL_DIAG_SUPPRESS_CLANG(str)
+#  define _CCCL_DIAG_SUPPRESS_GCC(str)
+#  define _CCCL_DIAG_SUPPRESS_NVHPC(str)
+#  define _CCCL_DIAG_SUPPRESS_MSVC(str) __pragma(warning(disable : str))
+#else
+#  define _CCCL_DIAG_PUSH
+#  define _CCCL_DIAG_POP
+#  define _CCCL_DIAG_SUPPRESS_CLANG(str)
+#  define _CCCL_DIAG_SUPPRESS_GCC(str)
+#  define _CCCL_DIAG_SUPPRESS_NVHPC(str)
+#  define _CCCL_DIAG_SUPPRESS_MSVC(str)
+#endif
+
+// Convenient shortcuts to silence common warnings
+#if defined(_CCCL_COMPILER_CLANG)
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_PUSH \
+    _CCCL_DIAG_PUSH                           \
+    _CCCL_DIAG_SUPPRESS_CLANG("-Wdeprecated") \
+    _CCCL_DIAG_SUPPRESS_CLANG("-Wdeprecated-declarations")
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_POP _CCCL_DIAG_POP
+#elif defined(_CCCL_COMPILER_GCC)
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_PUSH \
+    _CCCL_DIAG_PUSH                           \
+    _CCCL_DIAG_SUPPRESS_GCC("-Wdeprecated")   \
+    _CCCL_DIAG_SUPPRESS_GCC("-Wdeprecated-declarations")
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_POP _CCCL_DIAG_POP
+#elif defined(_CCCL_COMPILER_MSVC)
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_PUSH \
+    _CCCL_DIAG_PUSH                           \
+    _CCCL_DIAG_SUPPRESS_MSVC(4996)
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_POP _CCCL_DIAG_POP
+#else // !_CCCL_COMPILER_CLANG && !_CCCL_COMPILER_GCC
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_PUSH
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_POP
+#endif // !_CCCL_COMPILER_CLANG && !_CCCL_COMPILER_GCC
+
+// Enable us to selectively silence cuda compiler warnings
+#if defined(__CUDACC__)
+#  if !defined(_CCCL_CUDA_COMPILER_CLANG)
+#    define _CCCL_NV_DIAG_SUPPRESS(_WARNING)
+#    define _CCCL_NV_DIAG_DEFAULT(_WARNING)
+#  elif defined(__NVCC_DIAG_PRAGMA_SUPPORT__)
+#    if defined(_CCCL_COMPILER_MSVC)
+#      define _CCCL_NV_DIAG_SUPPRESS(_WARNING) __pragma(_CCCL_TOSTRING(nv_diag_suppress _WARNING))
+#      define _CCCL_NV_DIAG_DEFAULT(_WARNING)  __pragma(_CCCL_TOSTRING(nv_diag_default _WARNING))
+#    else // ^^^ _CCCL_COMPILER_MSVC ^^^ / vvv !_CCCL_COMPILER_MSVC vvv
+#      define _CCCL_NV_DIAG_SUPPRESS(_WARNING) \
+        _Pragma(_CCCL_TOSTRING(nv_diagnostic push)) _Pragma(_CCCL_TOSTRING(nv_diag_suppress _WARNING))
+#      define _CCCL_NV_DIAG_DEFAULT(_WARNING) _Pragma(_CCCL_TOSTRING(nv_diagnostic pop))
+#    endif // !_CCCL_COMPILER_MSVC
+#  elif defined(_CCCL_COMPILER_NVHPC)
+#    define _CCCL_NV_DIAG_SUPPRESS(_WARNING) \
+      _Pragma(_CCCL_TOSTRING(diagnostic push)) _Pragma(_CCCL_TOSTRING(diag_suppress _WARNING))
+#    define _CCCL_NV_DIAG_DEFAULT(_WARNING) _Pragma(_CCCL_TOSTRING(diagnostic pop))
+#  else // ^^^ __NVCC_DIAG_PRAGMA_SUPPORT__ ^^^ / vvv !__NVCC_DIAG_PRAGMA_SUPPORT__ vvv
+#    if defined(_CCCL_COMPILER_MSVC_2017) // MSVC 2017 has issues with restoring the warning
+#      define _CCCL_NV_DIAG_SUPPRESS(_WARNING) __pragma(_CCCL_TOSTRING(diag_suppress _WARNING))
+#      define _CCCL_NV_DIAG_DEFAULT(_WARNING)
+#    elif defined(_CCCL_COMPILER_MSVC)
+#      define _CCCL_NV_DIAG_SUPPRESS(_WARNING) __pragma(_CCCL_TOSTRING(diag_suppress _WARNING))
+#      define _CCCL_NV_DIAG_DEFAULT(_WARNING)  __pragma(_CCCL_TOSTRING(diag_default _WARNING))
+#    else // ^^^ _CCCL_COMPILER_MSVC ^^^ / vvv !_CCCL_COMPILER_MSVC vvv
+#      define _CCCL_NV_DIAG_SUPPRESS(_WARNING) _Pragma(_CCCL_TOSTRING(diag_suppress _WARNING))
+#      define _CCCL_NV_DIAG_DEFAULT(_WARNING)  _Pragma(_CCCL_TOSTRING(diag_default _WARNING))
+#    endif // !_CCCL_COMPILER_MSVC
+#  endif // !__NVCC_DIAG_PRAGMA_SUPPORT__
+#else // ^^^ __CUDACC__ ^^^ / vvv !__CUDACC__ vvv
+#  define _CCCL_NV_DIAG_SUPPRESS(_WARNING)
+#  define _CCCL_NV_DIAG_DEFAULT(_WARNING)
+#endif // other compilers
+
+#include "__cccl/ptx_isa.h"
+#include "__cccl/version.h"
+#include "__cccl/visibility.h"
+
+#endif // __CCCL_CONFIG

cuda_toolkit/include/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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/cuda/std/detail/libcxx/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