[CCCL] 瘦身 + 补全: 移除 cudax/python/libcudacxx-tests 冗余文件, 新增 c2h 测试助手 + cmake 构建系统 + 8 个 CUDA thrust examples
变更摘要:
- 删除: cudax/ (783 files, 7.2M) — 实验性组件，竞赛不需要
- 删除: python/ (226 files, 2.0M) — Python 绑定，竞赛不需要
- 删除: libcudacxx/{test,benchmarks,codegen,cmake,share} (4432 files, 31M)
保留: libcudacxx/include/ (1463 headers, cuda::std 编译依赖)
- 新增: c2h/ (27 files) — CUB Catch2 测试辅助头文件，编译 243 个测试必需
- 新增: cmake/ (29 files) — CCCL 原生 CMake 构建系统
- 新增: thrust/examples/cuda/ (7 files) + cpp_integration/ (1 file)
async_reduce, custom_temporary_allocation, explicit_cuda_stream,
global_device_vector, range_view, unwrap_pointer, wrap_pointer, device
结果: cccl_upstream 从 74M→35M (瘦身 53%), 核心内容 100% 保留:
27/27 tuning headers, 78 benchmarks, 243 tests,
60 thrust examples, 18 CUB examples, 全部编译头文件
This commit is contained in:
muh-bot
@@ -1,15 +0,0 @@
|
||||
#===----------------------------------------------------------------------===##
|
||||
#
|
||||
# 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()
|
||||
@@ -1,129 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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*>());
|
||||
}
|
||||
@@ -1,100 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>);
|
||||
}
|
||||
Reference in New Issue
Block a user