CUDA 协作组:thread_block 与 grid.sync() 的层级同步机制
更新时间:2026-09-29。前置阅读:CUDA 线程层级:grid 与 block、warp shuffle 原语。CUDA 9 之前,kernel 里的同步只有两个极端:
__syncthreads()管一个 block,跨越 block 就只能等 kernel 结束、靠下一次 launch 接力。Cooperative Groups(协作组)把「哪些线程算一个同步集合」抽象成一个可传递的对象,从 warp 分片到整个 grid,再到多 GPU 的 multi-grid,一条sync()调用按组的层级逐级展开。它解决的正是迭代式算法里反复出现的痛点——像 Jacobi 迭代、共轭梯度法这种「每一轮都要全网格归约后再进下一轮」的模式,过去要切几十个 kernel,现在一个 kernel 里循环加grid.sync()就能跑。
本文要回答的问题
- CUDA 协作组到底有哪些层级,每一层对应什么硬件边界?
grid.sync()为什么必须用cudaLaunchCooperativeKernel启动,普通<<<>>>启动会发生什么?- 协作 launch 对 grid 大小有什么硬性限制,occupancy 如何决定上限?
multi_grid_group能做什么,为什么它在多数环境下不可用?- 用协作组重写迭代式算法时,哪些坑最常见?
一、同步层级的金字塔:从线程片到多 GPU
协作组的设计思想是把「同步集合」做成一等公民。cooperative_groups 命名空间里,组的类型按覆盖范围从小到大排成一座金字塔,每一层的 sync() 只能在自己那一层生效,越界调用要么编译不过,要么运行时行为未定义。
这张图里每一层都有明确的硬件含义。thread_block_tile 对应 warp(或 warp 的子集),同步在 SM 内部靠锁步与 __syncwarp 完成,成本最低;thread_block 对应 SM 上的一个 block,靠 bar.sync 屏障寄存器;grid_group 的边界是整个 GPU——所有 block 必须同时驻留在所有 SM 上,才能在内存里做全局计数器式的 arrive-and-wait;multi_grid_group 理论上跨 GPU,需要 NVLink 与驱动、运行时三重配合。
关键判据就一句话:组的层级不能超出线程实际驻留的范围。普通 kernel 的 block 由调度器分批上架,后面的 block 要等前面的 block 退出才能上 SM,此时 grid.sync() 会让先到的 block 空等永远到不了的同伴——死锁。这就是下一节协作式 launch 存在的理由。
二、grid.sync() 的前提:协作式 launch 与全驻留约束
要在 kernel 里用 grid_group,启动方式必须换成运行时 API:
#include <cooperative_groups.h>
namespace cg = cooperative_groups;
__global__ void jacobi(float* x, const float* b, int n, int iters) {
cg::grid_group grid = cg::this_grid();
int i = blockIdx.x * blockDim.x + threadIdx.x;
for (int k = 0; k < iters; ++k) {
float v = iterate_once(x, b, i, n);
grid.sync(); // 全网格屏障:所有 block 到齐才放行
if (i < n) x[i] = v;
grid.sync();
}
}
// host 侧
void* args[] = { &dx, &db, &n, &iters };
cudaLaunchCooperativeKernel((void*)jacobi, gridDim, blockDim, args);用普通 <<<>>> 启动调了 grid.sync() 的 kernel,行为是未定义的——在老驱动上常常表现为挂死,在新驱动上可能静默通过但同步语义不成立,两者都足以毁掉一次深夜调试。协作式 launch 的本质是运行时替你把了一道关:它会校验这个 grid 能否一次性全部驻留到所有 SM 上,驻留不了就直接返回 cudaErrorCooperativeLaunchTooLarge,而不是让你死锁。
「全部驻留」换算成 occupancy 语言就是:gridDim.x <= 每 SM 可驻留 block 数 × SM 总数。每 SM 可驻留数由寄存器用量、shared memory 用量、block 线程数共同决定,查询方法是用 occupancy API:
int numBlocksPerSm = 0;
cudaOccupancyMaxActiveBlocksPerMultiprocessor(
&numBlocksPerSm, (void*)jacobi, blockDim.x, sharedBytes);
int maxBlocks = numBlocksPerSm * deviceProp.multiProcessorCount;得到的 maxBlocks 就是该 kernel 在当前架构下的协作 launch 上限。工程上的稳妥做法是 grid 取这个上限、用 grid-stride loop 处理任意规模数据,而不是按数据量直接开 grid——后者数据一涨就越界报错。另外注意两个细节:协作 launch 要求计算能力 6.0(Pascal)及以上;开了 grid.sync() 的 kernel 里,所有线程必须走同一条路径抵达 sync,发散分支里调用同步同样是未定义行为,这与 __syncthreads() 的纪律一脉相承。
还有一个容易忽略的收益值得一提:多 kernel 方案里每一轮迭代之间,数据要先写回全局内存、等 kernel 边界隐式同步、下一个 kernel 再读回来,launch 本身在主机侧还有微秒级开销;协作 kernel 把迭代圈留在设备内部,中间结果可以停在 L2 甚至 shared memory 里,省掉的是「launch 开销 + 往返全局内存」的双重成本。实测在几十到几百轮的小步迭代场景下,协作版相对多 kernel 版常见 1.3 到 2 倍的端到端加速,当然前提是每轮计算量足够小、同步占比足够高——这恰恰是协作组的主场。
三、各层级 API 速查与选型
不同组对象拿到的能力并不相同,选型时先看你要同步的范围,再看组上有没有现成的集合操作可用。
| 组类型 | 构造方式 | 同步原语 | 附带集合操作 | 硬件前提 |
|---|---|---|---|---|
thread_block_tile<N> | cg::tiled_partition<N>(block) | tile.sync() | shfl/any/all/ballot/reduce(11.0+) | warp 锁步 |
thread_block | cg::this_thread_block() | block.sync() | 无内建,自己组合 | block 驻留 SM |
grid_group | cg::this_grid() | grid.sync() | 无 | 协作 launch,全驻留 |
multi_grid_group | cg::this_multi_grid() | mg.sync() | 无 | 多设备协作 launch + 平台支持 |
一张表能看出的趋势是:层级越高,能力越「裸」。tile 一级因为对应 warp,硬件顺手,shuffle、投票、乃至 CUDA 11 引入的 cg::reduce 都是一条指令的事;到 grid 一级就只剩一个屏障,归约要自己用 atomic 或两遍 sync 拼。所以工程原则是能用低层组就不用高层组:warp 内能收尾的归约别拖到 block,block 内能做完的别拖到 grid——每升一层,同步成本从几个周期涨到数百乃至上千周期。
上图是「每迭代一次全网格归约」的标准骨架:先在 block 内用 shared memory 把 256 个部分和压成一个,由一个线程做全局 atomicAdd,然后 grid.sync() 保证所有 block 的贡献都落地,再统一读回。理解这个骨架,也就理解了为什么 grid 级同步贵——屏障状态要穿过 L2 和全局内存,原子操作还要排队串行化。迭代次数很多、每轮计算量很小时,同步开销会反客为主,这时要么减少每轮的同步次数(把两次 sync 合并成一次),要么干脆回退到多 kernel 方案做对比实测。
四、multi-grid:看得见吃不着的顶层
multi_grid_group 的愿景是把 grid 级屏障推广到多块 GPU:一次 cudaLaunchCooperativeKernelMultiDevice 在所有参与卡上同时启动协作 kernel,各卡的 grid 共同构成一个 multi-grid,mg.sync() 跨卡生效。听起来是单机多卡迭代算法的理想解,现实却骨感得多:
- 平台限制:需要计算能力 6.0+ 且所有参与 GPU 通过 NVLink/对等访问互联,还要
cudaDeviceEnablePeerAccess逐对打通;不少云实例的拓扑根本不满足。 - 驻留限制翻倍:每张卡的 grid 都要满足各自的全驻留约束,最弱的一张卡决定全局上限。
- 维护态度保守:Hopper 之后 NVIDIA 把跨 block 协作的重心转向了 thread block cluster(
cluster.sync(),计算能力 9.0+),multi-grid 在新架构文档里存在感持续走低,许多新驱动组合下它只退化为单设备占位。
务实的结论是:单卡内迭代用 grid.sync(),跨卡协作优先看 cluster 加 distributed shared memory,或直接落到 NCCL/多 kernel 流水线;multi-grid 只在「老平台、卡间 NVLink 齐全、算法强迭代耦合」的窄场景里值得一试,上线前必须用 cudaDeviceGetAttribute(cudaDevAttrCooperativeMultiDeviceLaunch) 确认支持。
五、常见坑清单
把协作组用顺,最后绕不开这几个反复出现的坑:第一,混用启动方式——kernel 里写了 grid.sync() 却忘了改成 cudaLaunchCooperativeKernel,调试时务必先检查 launch 路径;第二,grid 开得超过 occupancy 上限,返回码没检查,kernel 根本没跑起来;第三,在发散分支里调用组的 sync(),部分线程永远到不了屏障;第四,把 thread_block 当 grid_group 用——this_thread_block().sync() 只是 __syncthreads() 的换皮,跨 block 没有任何效果;第五,忽略编译开关,旧代码用 cg::this_grid() 时需要 -rdc=true(可重定位设备代码)的场景在现代 CUDA 里虽已放宽,但静态链接老工程时仍可能撞上链接错误,升级到 CUDA 11+ 工具链通常一并解决。
这一篇在知识体系里的位置
本篇是 GPU 编程线里「同步机制」专题的一环:线程层级的地基在 CUDA 线程层级:grid 与 block,warp 内的数据交换见 warp shuffle 原语,块内信箱机制见 shared memory bank 冲突,跨 kernel 的异步编排则在 CUDA stream 与异步拷贝。理解了协作组的分层语义,就补齐了从 lane 到整卡的同步全景。
总结
CUDA 协作组把同步集合抽象成 thread_block_tile、thread_block、grid_group、multi_grid_group 四层金字塔,层级越低越快、越高越裸;grid.sync() 必须经 cudaLaunchCooperativeKernel 启动且 grid 全驻留,上限由 occupancy 决定;multi-grid 受平台与驱动限制如今基本被 thread block cluster 取代——选型原则永远是能用低层组就不用高层组。