56fd68e7dd
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
102 lines
2.7 KiB
Plaintext
102 lines
2.7 KiB
Plaintext
//===----------------------------------------------------------------------===//
|
|
//
|
|
// 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) 2023 NVIDIA CORPORATION & AFFILIATES.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef __COMMON_HOST_DEVICE_H__
|
|
#define __COMMON_HOST_DEVICE_H__
|
|
|
|
#include "utility.cuh"
|
|
|
|
template <typename Dims, typename Lambda>
|
|
void __global__ lambda_launcher(const Dims dims, const Lambda lambda)
|
|
{
|
|
lambda(dims);
|
|
}
|
|
|
|
template <typename Comparator, unsigned int FilterArch>
|
|
bool arch_filter(const cudaDeviceProp& props)
|
|
{
|
|
int act_arch = props.major * 10 + props.minor;
|
|
if (Comparator()(act_arch, FilterArch))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool skip_host_exec(bool (* /* filter */)(const cudaDeviceProp&))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static bool skip_device_exec(bool (*filter)(const cudaDeviceProp&))
|
|
{
|
|
cudaDeviceProp props;
|
|
REQUIRE_CUDART(cudaGetDeviceProperties(&props, 0));
|
|
return filter(props);
|
|
}
|
|
|
|
template <typename Dims, typename Lambda, typename... Filters>
|
|
void test_host_dev(const Dims& dims, const Lambda& lambda, const Filters&... filters)
|
|
{
|
|
SECTION("Host execution")
|
|
{
|
|
if ((... && !skip_host_exec(filters)))
|
|
{
|
|
// host testing
|
|
lambda(dims);
|
|
}
|
|
}
|
|
|
|
SECTION("Device execution")
|
|
{
|
|
// Asymmetrical but cleaner
|
|
if ((... || skip_device_exec(filters)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
cudaLaunchConfig_t config = {};
|
|
config.gridDim = {0};
|
|
cudaLaunchAttribute attrs[1];
|
|
config.attrs = &attrs[0];
|
|
|
|
config.blockDim = dims.extents(cuda::gpu_thread, cuda::block);
|
|
config.gridDim = dims.extents(cuda::block, cuda::grid);
|
|
|
|
if constexpr (Dims::has_level(cluster))
|
|
{
|
|
dim3 cluster_dims = dims.extents(cuda::block, cuda::cluster);
|
|
config.attrs[config.numAttrs].id = cudaLaunchAttributeClusterDimension;
|
|
config.attrs[config.numAttrs].val.clusterDim = {cluster_dims.x, cluster_dims.y, cluster_dims.z};
|
|
config.numAttrs = 1;
|
|
}
|
|
else
|
|
{
|
|
config.numAttrs = 0;
|
|
}
|
|
|
|
// device testing
|
|
REQUIRE_CUDART(cudaLaunchKernelEx(&config, lambda_launcher<Dims, Lambda>, dims, lambda));
|
|
REQUIRE_CUDART(cudaDeviceSynchronize());
|
|
}
|
|
}
|
|
|
|
template <typename Fn, typename Tuple>
|
|
void apply_each(const Fn& fn, const Tuple& tuple)
|
|
{
|
|
cuda::std::apply(
|
|
[&](const auto&... elems) {
|
|
(fn(elems), ...);
|
|
},
|
|
tuple);
|
|
}
|
|
|
|
#endif // __COMMON_HOST_DEVICE_H__
|