[INFRA] Import NVIDIA/CCCL upstream as optimization reference library

CCCL (CUDA C++ Core Libraries) provides:
- CUB: device/block/warp-level GPU primitives (reduce, scan, sort, topk)
- Thrust: high-level parallel algorithms (transform_reduce, sort, scan)
- libcudacxx: CUDA C++ standard library (atomics, barriers, memory)
- cudax: experimental features (memory resources, allocators)
- Tuning policies: per-SM hardware-specific algorithm parameters

Competition optimization vectors mapped to CCCL:
- Output TPS (83% weight): warp_reduce, block_reduce, device_topk
- Input TPS (14% weight): device_scan, block_load, prefetch
- Cache TPS (3% weight): prefix caching strategy patterns
- Memory (0.9 util): pooled/cached/buddy allocators

Source: https://github.com/NVIDIA/cccl (shallow clone, HEAD only)
License: Apache-2.0

cccl_upstream/cudax/test/multi_gpu/nccl/CMakeLists.txt

@@ -0,0 +1,15 @@
+#===----------------------------------------------------------------------===##
+#
+# Part of CUDA Experimental in CUDA C++ Core Libraries,
+# 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) 2026 NVIDIA CORPORATION & AFFILIATES.
+#
+#===----------------------------------------------------------------------===##
+
+file(GLOB test_srcs LIST_DIRECTORIES FALSE CONFIGURE_DEPENDS *.cu *.cpp)
+
+foreach (src IN LISTS test_srcs)
+  cudax_add_multi_gpu_test("nccl" test_target "${src}")
+endforeach()

cccl_upstream/cudax/test/multi_gpu/nccl/abi_compatible.cu

@@ -0,0 +1,129 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// 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) 2026 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/underlying_type.h>
+
+#include <cuda/experimental/__nccl/abi_compatible.h>
+
+#include <c2h/catch2_test_helper.h>
+
+namespace
+{
+namespace abi_detail = ::cuda::experimental::__nccl::__abi_detail;
+
+// NOLINTBEGIN(bugprone-reserved-identifier)
+enum Foo_enum
+{
+};
+
+#if _CCCL_OS(WINDOWS)
+using FooEnum = int;
+#else
+using FooEnum = unsigned int;
+#endif
+
+struct Foo_st;
+using FooStruct = Foo_st*;
+
+// An enum whose underlying type is fixed, so that mismatch tests are deterministic
+// regardless of how the implementation picks the underlying type of an unfixed enum.
+enum class CharEnum : char
+{
+};
+
+enum class IntEnum : int
+{
+};
+
+struct Bar_st;
+// NOLINTEND(bugprone-reserved-identifier)
+} // namespace
+
+C2H_TEST("nccl __abi_compatible type comparisons", "[multi_gpu][nccl]")
+{
+  // --- Identical / scalar types -------------------------------------------------
+  STATIC_REQUIRE(abi_detail::__abi_compatible<int, int>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int, float>());
+
+  // remove_cv only strips the top level, so a top-level cv difference is still compatible.
+  STATIC_REQUIRE(abi_detail::__abi_compatible<const int, int>());
+  STATIC_REQUIRE(abi_detail::__abi_compatible<volatile int, int>());
+  STATIC_REQUIRE(abi_detail::__abi_compatible<const volatile int, int>());
+
+  // Different-width / signedness integers are distinct types and must not be compatible.
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int, long>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int, short>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int, unsigned int>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<char, signed char>());
+
+  // --- Pointers -----------------------------------------------------------------
+  STATIC_REQUIRE(abi_detail::__abi_compatible<const char**, const char* const*>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<const char*, const int*>());
+
+  // Deep cv-qualifications on the pointee are stripped at each level of recursion.
+  STATIC_REQUIRE(abi_detail::__abi_compatible<int*, const int*>());
+  STATIC_REQUIRE(abi_detail::__abi_compatible<int**, const int* const*>());
+
+  // Multi-level pointers must agree in depth.
+  STATIC_REQUIRE(abi_detail::__abi_compatible<int**, int**>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int**, int*>());
+
+  // A pointer is never compatible with a non-pointer (the `&&` in the pointer branch).
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int*, int>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int, int*>());
+
+  // void* is not compatible with a typed pointer: the pointees differ.
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<void*, int*>());
+  STATIC_REQUIRE(abi_detail::__abi_compatible<void*, void*>());
+
+  // Opaque struct pointers: identical handle types and matching opaque pointees.
+  STATIC_REQUIRE(abi_detail::__abi_compatible<Foo_st*, FooStruct>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<Foo_st*, Bar_st*>());
+
+  // --- Enums --------------------------------------------------------------------
+  STATIC_REQUIRE(::cuda::std::is_same_v<FooEnum, ::cuda::std::underlying_type_t<Foo_enum>>);
+
+  // enum vs its underlying type (either side), and enum-vs-enum through the pointee.
+  STATIC_REQUIRE(abi_detail::__abi_compatible<FooEnum, Foo_enum>());
+  STATIC_REQUIRE(abi_detail::__abi_compatible<Foo_enum, FooEnum>());
+  STATIC_REQUIRE(abi_detail::__abi_compatible<FooEnum*, Foo_enum*>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<FooEnum*, Foo_enum>());
+
+  // Both sides enums: compatible iff their underlying types match exactly.
+  STATIC_REQUIRE(abi_detail::__abi_compatible<CharEnum, CharEnum>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<CharEnum, IntEnum>());
+
+  // An enum is compatible with its exact underlying type but not a mismatched one.
+  STATIC_REQUIRE(abi_detail::__abi_compatible<CharEnum, char>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<CharEnum, int>());
+  STATIC_REQUIRE(abi_detail::__abi_compatible<IntEnum, int>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<IntEnum, char>());
+
+  // --- Function pointers --------------------------------------------------------
+  STATIC_REQUIRE(abi_detail::__abi_compatible<int (*)(Foo_st*), int (*)(FooStruct)>());
+
+  // Return type, arity, and argument types must all match.
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int (*)(int), float (*)(int)>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int (*)(int), int (*)(int, int)>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int (*)(int), int (*)(long)>());
+
+  // void return and no-argument functions.
+  STATIC_REQUIRE(abi_detail::__abi_compatible<void (*)(), void (*)()>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<void (*)(), int (*)()>());
+
+  // Per-argument ABI compatibility recurses (enum / opaque-pointer arguments).
+  STATIC_REQUIRE(abi_detail::__abi_compatible<void (*)(FooEnum), void (*)(Foo_enum)>());
+  STATIC_REQUIRE(abi_detail::__abi_compatible<int (*)(Foo_st*, FooEnum), int (*)(FooStruct, Foo_enum)>());
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<void (*)(CharEnum), void (*)(IntEnum)>());
+
+  // A function type is not compatible with a non-function type.
+  STATIC_REQUIRE(!abi_detail::__abi_compatible<int (*)(int), int*>());
+}

cccl_upstream/cudax/test/multi_gpu/nccl/concepts.cu

@@ -0,0 +1,100 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// 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) 2026 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cuda/functional> // cuda::maximum, cuda::minimum
+#include <cuda/std/cstdint>
+#include <cuda/std/functional> // cuda::std::plus, cuda::std::multiplies
+
+#include <cuda/experimental/__nccl/nccl_api.h>
+
+#include <c2h/catch2_test_helper.h>
+
+namespace
+{
+// A trivially-copyable aggregate with no corresponding NCCL data type.
+struct trivial_aggregate
+{
+  int a;
+  double b;
+};
+
+// A non-trivially-copyable type (user-provided copy ctor).
+struct non_trivial
+{
+  non_trivial(const non_trivial&) {} // NOLINT(modernize-use-equals-default)
+  int a;
+};
+} // namespace
+
+C2H_TEST("nccl type and reduction-op traits", "[multi_gpu][nccl]")
+{
+  namespace nccl = ::cuda::experimental::__nccl;
+
+  // --- __has_nccl_type_of -------------------------------------------------------
+  //
+  // True only for the fixed set of types __nccl_type_of() recognizes.
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<::cuda::std::int8_t>);
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<::cuda::std::uint8_t>);
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<::cuda::std::int32_t>);
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<::cuda::std::uint32_t>);
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<::cuda::std::int64_t>);
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<::cuda::std::uint64_t>);
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<float>);
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<double>);
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<bool>);
+
+  // cv-qualifications are stripped via remove_cvref_t before the lookup.
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<const float>);
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<volatile int>);
+  STATIC_REQUIRE(nccl::__has_nccl_type_of<float&>);
+
+  // Unsupported types have no NCCL data type.
+  STATIC_REQUIRE(!nccl::__has_nccl_type_of<long double>);
+  STATIC_REQUIRE(!nccl::__has_nccl_type_of<void>);
+  STATIC_REQUIRE(!nccl::__has_nccl_type_of<int*>);
+  STATIC_REQUIRE(!nccl::__has_nccl_type_of<trivial_aggregate>);
+
+  // --- __nccl_type_of_v ---------------------------------------------------------
+  STATIC_REQUIRE(nccl::__nccl_type_of_v<bool> == nccl::__ncclChar);
+  STATIC_REQUIRE(nccl::__nccl_type_of_v<::cuda::std::int8_t> == nccl::__ncclInt8);
+  STATIC_REQUIRE(nccl::__nccl_type_of_v<::cuda::std::uint8_t> == nccl::__ncclUint8);
+  STATIC_REQUIRE(nccl::__nccl_type_of_v<::cuda::std::int32_t> == nccl::__ncclInt32);
+  STATIC_REQUIRE(nccl::__nccl_type_of_v<::cuda::std::uint32_t> == nccl::__ncclUint32);
+  STATIC_REQUIRE(nccl::__nccl_type_of_v<::cuda::std::int64_t> == nccl::__ncclInt64);
+  STATIC_REQUIRE(nccl::__nccl_type_of_v<::cuda::std::uint64_t> == nccl::__ncclUint64);
+  STATIC_REQUIRE(nccl::__nccl_type_of_v<float> == nccl::__ncclFloat);
+  STATIC_REQUIRE(nccl::__nccl_type_of_v<double> == nccl::__ncclDouble);
+
+  // cv-ref qualifiers are removed before mapping.
+  STATIC_REQUIRE(nccl::__nccl_type_of_v<const double&> == nccl::__ncclDouble);
+
+  // --- __nccl_redop_of_v --------------------------------------------------------
+  STATIC_REQUIRE(nccl::__nccl_redop_of_v<::cuda::std::plus<>> == nccl::__ncclSum);
+  STATIC_REQUIRE(nccl::__nccl_redop_of_v<::cuda::std::multiplies<>> == nccl::__ncclProd);
+  STATIC_REQUIRE(nccl::__nccl_redop_of_v<::cuda::maximum<>> == nccl::__ncclMax);
+  STATIC_REQUIRE(nccl::__nccl_redop_of_v<::cuda::minimum<>> == nccl::__ncclMin);
+  STATIC_REQUIRE(nccl::__nccl_redop_of_v<const ::cuda::std::plus<int>&> == nccl::__ncclSum);
+
+  // --- __has_nccl_redop ---------------------------------------------------------
+  STATIC_REQUIRE(nccl::__has_nccl_redop_of<::cuda::std::plus<>>);
+  STATIC_REQUIRE(nccl::__has_nccl_redop_of<::cuda::std::multiplies<>>);
+  STATIC_REQUIRE(nccl::__has_nccl_redop_of<::cuda::maximum<>>);
+  STATIC_REQUIRE(nccl::__has_nccl_redop_of<::cuda::minimum<>>);
+
+  // Typed specializations are recognized too.
+  STATIC_REQUIRE(nccl::__has_nccl_redop_of<::cuda::std::plus<int>>);
+
+  // cv-ref qualifiers are stripped before the lookup.
+  STATIC_REQUIRE(nccl::__has_nccl_redop_of<const ::cuda::std::plus<>&>);
+
+  // Unsupported functors and non-functor types are rejected.
+  STATIC_REQUIRE(!nccl::__has_nccl_redop_of<::cuda::std::minus<>>);
+  STATIC_REQUIRE(!nccl::__has_nccl_redop_of<int>);
+}