在上一篇 [CUDA 编程初探] 中,我们用向量加法走通了 CUDA 程序的基本流程:分配显存、搬运数据、启动 Kernel、校验结果和测量时间。程序能够正确运行之后,下一个问题自然是:它为什么还不够快?
CUDA 优化很少是“换一个更复杂的写法就会更快”。一个 Kernel 可能在等待全局内存,也可能因为同一 Warp 内的线程走了不同分支而浪费执行槽;可能是寄存器和共享内存限制了可驻留的 Warp,也可能是大量线程争用同一个原子变量。只有先找出限制因素,优化才有方向。
本文基于 AIInfraGuide 的 CUDA 性能优化基础概览、Warp 与执行模型、内存访问优化、Occupancy 与资源分配、同步与原子操作 五篇文章重新整理。正文不追求记住一串固定数字,而是建立一条可以反复使用的思考路径:
保证正确 → 建立基线 → 找到瓶颈 → 只改一个变量 → 重新验证结果与性能。
文中的性能数字如果没有明确说明,均用于解释原理,不代表本文作者的实测结果。GPU 架构、CUDA 版本、编译器和输入规模都会改变实际表现。
1. 性能优化首先是一套实验方法
优化前,先把“快”定义清楚。至少需要区分下面几种时间:
| 指标 | 包含的工作 | 适合回答的问题 |
|---|---|---|
| Kernel 时间 | GPU 上某个 Kernel 的执行区间 | Kernel 本身是否变快? |
| GPU 流水线时间 | H2D、多个 Kernel、D2H 等指定阶段 | 整段 GPU 工作是否变快? |
| 端到端时间 | CPU 准备、分配、传输、GPU 计算、同步和后处理 | 应用实际是否受益? |
只比较 Kernel 时间,可能忽略 PCIe 传输;只看端到端时间,又可能掩盖 Kernel 内部的变化。两种数据都可以记录,但计时边界必须一致。
一个可靠的实验至少要做到:
- 使用相同输入,先比较 CPU 或可信库的参考结果。
- 检查 NaN、Inf,并根据算法选择合理的绝对误差和相对误差。
- 使用 Release 优化编译,记录 GPU、驱动、Toolkit、编译参数和数据规模。
- 预热后重复测量,报告中位数或稳定的统计结果。
- 一次只改变一个主要因素,例如 Block 大小或数据布局。
- 优化后重新做正确性检查,因为数据竞争有时只在特定调度下暴露。
工具的分工也很清楚:Nsight Systems 用时间线回答“CPU、传输和 Kernel 在什么时候运行”,Nsight Compute 深入一个 Kernel,回答“它为什么花这么久”。分析前可以先编译带设备行号的优化版本:
1 | nvcc -O3 -lineinfo kernel.cu -o kernel |
-G 会生成设备调试代码并显著影响优化,因此不应拿调试构建做正式性能比较。
2. Warp:理解 GPU 实际怎样执行线程
2.1 Thread 是编程视角,Warp 是执行视角
我们编写的是单个线程的标量代码,但当前 NVIDIA GPU 会把一个 Block 中线性线程编号连续的线程组成 Warp,每个 Warp 包含 32 个 lane。
对于一维 Block:
1 | int laneId = threadIdx.x & 31; // threadIdx.x % 32 |
对于多维 Block,Warp 的划分依据是线程的线性编号,x 维变化最快:
1 | int linearTid = threadIdx.x |
warpSize 在 CUDA 设备代码中表示 Warp 宽度;为理解当前 NVIDIA CUDA GPU,可以认为它是 32。一个 256 线程的 Block 因而包含 8 个 Warp。Block 大小不是 32 的倍数时,最后一个 Warp 仍占用调度资源,只是部分 lane 没有对应线程。
SM 上会驻留多个 Warp。一个 Warp 因内存依赖或指令依赖暂时不能继续时,Warp Scheduler 可以发射另一个已就绪 Warp 的指令,以此隐藏延迟。这种切换不需要像 CPU 操作系统线程那样保存和恢复上下文,因为驻留 Warp 的状态已经保存在 SM 资源中。
这里的关键不是“线程越多越好”,而是调度器在多数周期里能否找到有资格且已就绪的 Warp。
2.2 SIMT 与分支分歧
SIMT(Single Instruction, Multiple Threads)让我们用独立线程来表达程序,同时让一个 Warp 的活跃 lane 执行共同的指令。当同一个 Warp 中的线程需要走不同控制流路径时,硬件会用活跃掩码执行这些路径,某条路径之外的 lane 暂时不参与。这就是 Warp Divergence。
1 | int gid = blockIdx.x * blockDim.x + threadIdx.x; |
分歧发生在同一个 Warp 内。如果 Warp 0 全部执行 A、Warp 1 全部执行 B,这两个 Warp 可以独立调度,不构成同一个 Warp 内的分歧:
1 | int warpId = threadIdx.x / warpSize; |
不能简单断言一个 if/else 一定慢 2 倍,或者最坏一定慢 32 倍。真实代价取决于各路径的指令数量、内存访问、编译器是否使用 predication、分支数据分布,以及路径能否很快重新汇合。优化前应查看分支与活跃线程相关指标,而不是只凭源码中的 if 做判断。
也不要为了消除分支,盲目让所有线程执行更重的工作。下面两个版本哪个更快,需要测量:
1 | // 版本 A:存在分支,但每个线程只执行需要的路径 |
可行的优化包括:让相似数据相邻、按 Warp 粒度分配任务、把很短的分支交给编译器谓词化,或者重构算法减少路径差异。数据重排本身也有成本,只有复用次数足够时才可能划算。
2.3 Volta 之后仍然不能忘记 Warp 同步
Volta 及更新架构支持 Independent Thread Scheduling。它提高了调度灵活性,但没有让分歧免费,也没有保证分歧后的 lane 会自动保持过去那种隐式锁步关系。
如果 Warp 内线程通过共享内存通信,需要使用合适的同步:
1 | shared[linearTid] = value; |
mask 描述参加同步的 lane。参与掩码必须与实际执行这条原语的线程一致;把 0xffffffff 到处当作固定模板,在尾部 Warp 或分歧区域中可能是错误的。
2.4 Warp Shuffle:直接交换寄存器值
Shuffle 原语允许 Warp 内参与线程交换寄存器值,常见形式有:
1 | __shfl_sync(mask, value, sourceLane); |
它避免了“写共享内存—同步—再读取”的完整过程,通常能减少共享内存和屏障使用。不过它依然是一条有成本的指令,也只适用于参与 Warp 线程之间的数据交换,不能把它描述成真正的零延迟通信。
完整 Warp 的求和可以写成:
1 | __device__ float warpReduceSum(float value) { |
这段函数的前提是完整 Warp 中所有 lane 都执行它。若只处理数组尾部的部分线程,更稳妥的方式是让整个 Warp 都执行 Shuffle,无有效数据的 lane 把 value 设为加法单位元 0:
1 | int gid = blockIdx.x * blockDim.x + threadIdx.x; |
另一种情况是只有部分 lane 存在并参与。此时需要在分支之前用 __ballot_sync 建立正确的参与集合,并确保原语的源 lane 在该集合中。__activemask() 只返回执行到当前位置时当前活跃的 lane,不能随意用它替代算法所需的参与集合。
2.5 Vote 原语适合 Warp 内集体决策
1 | unsigned participants = __activemask(); |
__any_sync 和 __all_sync 返回集体判断,__ballot_sync 则把各 lane 的布尔结果编码到位图中。它们可以用于筛选、压缩、选择 leader 和 Warp 聚合原子操作。
3. 内存访问:先减少无效流量,再谈更复杂的计算
3.1 用 Roofline 建立上限意识
算术强度定义为完成算法所需的计算量与数据流量之比:
给定峰值计算吞吐
向量加法每个元素做一次加法,按算法流量读两个 float、写一个 float,算术强度约为 1 / 12 = 0.083 FLOP/Byte,通常属于带宽受限任务。此时把一次加法换成更短的表达式不会产生明显收益;更值得检查的是实际传输了多少数据、访问是否合并,以及中间结果能否复用。
Roofline 是上界模型,不是对每个 Kernel 的自动分类器。小 Kernel 可能受启动延迟限制,不规则 Kernel 可能受访存延迟而非饱和带宽限制,原子争用和依赖链也可能成为真正瓶颈。
3.2 合并访问关注同一条指令中一个 Warp 的地址
连续线程访问连续的 float,是最常见的高效模式:
1 | int gid = blockIdx.x * blockDim.x + threadIdx.x; |
一个 Warp 的 32 个线程共访问 128 字节。现代 NVIDIA GPU 会以一定粒度把 Warp 的请求合并;分析常见架构时,经常以 32 字节 sector 观察实际请求数量。对齐的连续 128 字节范围通常覆盖 4 个 sector,而不是一句笼统的“只发生一次 128 字节事务”。具体缓存与事务行为应以目标架构的文档和 profiler 为准。
跨步访问会触及更多 sector:
1 | output[gid] = input[gid * stride]; |
stride 越大,同一 Warp 请求的地址越分散,搬来的数据中真正有用的比例通常越低。Grid-stride Loop 并不破坏合并访问,因为同一轮循环里相邻线程仍访问相邻元素:
1 | for (int i = gid; i < N; i += blockDim.x * gridDim.x) { |
3.3 AoS 与 SoA 要按访问方式选择
假设粒子包含位置和速度:
1 | struct Particle { |
如果所有线程只读取 x,AoS(结构体数组)会让相邻线程的 x 之间隔着其他字段;SoA(数组结构体)可以让 x[i] 连续:
1 | struct ParticlesSoA { |
但“SoA 永远优于 AoS”也过于绝对。如果每个线程总会读取一个小结构体的全部字段,经过对齐或使用 AoSoA 后,AoS 可能同样合适。数据布局应服务于实际访问方式,还要考虑 CPU 侧使用、内存占用和转换成本。
3.4 用共享内存改变全局访存方向
矩阵转置是经典案例。输入按行存储时,朴素实现可以合并读取,却会跨行写出:
1 | out[col * height + row] = in[row * width + col]; |
共享内存 Tile 可以先合并读取一块数据,在片上交换行列,再以合并方式写出:
1 | constexpr int TILE = 32; |
这里 tile[32][33] 多出的一列改变了列访问时的 Bank 映射,避免常见的 32 路 Bank Conflict。共享内存通常有多个 Bank;当同一 Warp 的线程访问同一个 Bank 中不同地址时,请求可能串行化。多个线程读取完全相同的地址则可以广播,不属于这种冲突。
Bank 数量、Bank 宽度和某些特殊访问行为具有架构差异。Padding 是解决这个转置访问模式的有效方法,并不是所有共享内存数组都应该机械地加一列。
3.5 向量化加载主要减少指令,不会凭空增加带宽
当地址满足对齐要求、数据连续且每个线程确实需要多个元素时,可以使用 float2、float4 等向量类型:
1 | __global__ void copyFloat4(float* dst, const float* src, int count4) { |
float4 要求地址满足 16 字节对齐。cudaMalloc 返回的基地址足够对齐,但 data + 1 之类的偏移可能破坏对齐。数组长度不是 4 的倍数时,还需要单独处理尾部。
向量化可能把多条窄加载指令合成更少的宽加载指令,减少指令和地址计算压力。它没有减少算法总字节数,也不会保证 DRAM 带宽自动提高;有时编译器已经生成合适指令,有时更宽的每线程数据还会增加寄存器压力。因此仍要检查生成代码和实际耗时。
4. Occupancy:它衡量驻留能力,不直接衡量速度
4.1 定义与作用
Occupancy 的常见定义是:
这里的“活跃”通常表示 Warp 已驻留在 SM 上,而不是说它当前周期一定正在执行。理论 Occupancy 根据启动配置和静态资源需求计算;Achieved Occupancy 则是运行时观测值。两者都不能直接替代 GPU 利用率、吞吐量或耗时。
Occupancy 的主要价值是为延迟隐藏提供候选 Warp。当一个 Warp 等待全局内存时,调度器可以从其他已就绪 Warp 中选择工作。如果驻留 Warp 太少,调度器更容易找不到可发射指令的 Warp。
但是更多驻留 Warp 只是增加机会。若所有 Warp 都在等待同一种长延迟操作,或者 Kernel 已经达到带宽上限,提高 Occupancy 未必继续加速。
4.2 哪些资源限制驻留 Block?
一个 Block 必须作为整体驻留到某个 SM。能同时驻留多少个 Block,要同时满足多种约束:
- 每个 SM 的最大线程数与最大 Warp 数;
- 每个 SM 的最大驻留 Block 数;
- 每线程寄存器数乘以 Block 线程数,并考虑分配粒度;
- 每个 Block 的静态及动态共享内存,并考虑分配粒度;
- 架构和 Kernel 自身的启动限制。
可以把可驻留 Block 数写成概念公式:
随后:
手算有助于理解,但寄存器和共享内存分配存在架构相关的粒度与限制。最终应使用 CUDA Occupancy API、编译器资源报告和 profiler,而不是把某一代 GPU 的固定表格套到所有设备。
4.3 查看 Kernel 的资源使用
编译时可以让 ptxas 报告寄存器与共享内存:
1 | nvcc -O3 -lineinfo -Xptxas=-v kernel.cu -o kernel |
运行时可查询指定 Block 大小下,每个 SM 最多驻留多少个 Block:
1 | int activeBlocks = 0; |
cudaOccupancyMaxPotentialBlockSize 也可以给出以 Occupancy 为目标的候选 Block 大小,但它不是通用的“最快 Block 大小预测器”。它不了解算法的数据复用、访存布局、指令级并行度和实际工作量。
4.4 为什么 Occupancy 不是越高越好?
寄存器和共享内存不仅是限制条件,也是提高单个 Warp 效率的资源:
- 更多寄存器可以保存更多累加器,增加指令级并行度,减少中间值访存;
- 更大的共享内存 Tile 可以增加数据复用,减少全局内存流量;
- 较大的每线程工作量可以摊薄索引和循环开销。
如果为了追求 100% Occupancy 而强制减少寄存器,编译器可能把值 spill 到 Local Memory。Local Memory 是线程私有地址空间,但通常由设备内存承载并经过缓存,延迟远高于寄存器。此时 Occupancy 上升,性能反而下降。
-maxrregcount 和 __launch_bounds__ 可以影响编译器的资源决策,但应作为实验参数使用:
1 | __global__ void __launch_bounds__(256, 2) |
这里的第二个参数表达希望每个 SM 至少容纳的 Block 数,编译器会据此权衡寄存器使用。它不是运行时保证,也不能替代性能测量。
4.5 一套更实用的 Block 大小实验
对于简单一维 Kernel,可以从 {128, 256, 512} 开始扫描:
- 每个配置使用相同输入和 Grid 覆盖策略。
- 记录 Kernel 时间、理论/实际 Occupancy、寄存器、共享内存和 spill。
- 查看内存吞吐、Eligible Warps 与主要 Stall 原因。
- 保留实际最快且结果正确的配置。
小 Block 可能受到每 SM 最大 Block 数限制,大 Block 可能因寄存器或共享内存导致同驻留 Block 减少。最优点取决于 Kernel 和 GPU,没有跨设备永久有效的固定答案。
5. 同步:屏障、内存顺序与原子性是三件事
并行程序中的错误常来自把三个概念混在一起:
| 概念 | 解决的问题 | 典型工具 |
|---|---|---|
| 屏障(Barrier) | 参与线程是否都到达某个阶段? | __syncthreads()、__syncwarp() |
| 内存顺序与可见性 | 某次写入何时能被指定范围观察? | 屏障的内存语义、Fence、现代原子内存序 |
| 原子性 | 多线程读改写同一地址是否丢失更新? | atomicAdd、atomicCAS 等 |
Fence 不会让其他线程停下来等待,原子操作也不自动成为整个 Block 的屏障。选择原语前,应先说清楚需要的是哪一种保证。
5.1 __syncthreads() 是 Block 屏障
当 Block 内线程先合作写共享内存,再读取其他线程写的值时,需要块内同步:
1 | __shared__ float tile[256]; |
__syncthreads() 等待 Block 中所有线程到达屏障,并为相关内存访问建立块内顺序保证。它不能同步另一个 Block。
屏障可以位于条件代码中,但只有在 Block 中所有线程对该条件作出一致判断,并动态执行同一个屏障时才安全。下面的写法会导致未定义行为,因为只有部分线程到达:
1 | if (threadIdx.x < 128) { |
同样,包含屏障的循环必须保证参与 Block 的所有线程执行相同次数。稳妥的尾块处理方式,是让无有效输入的线程写入单位元并继续参与同步,而不是提前 return。
5.2 Warp 级同步必须使用正确掩码
__syncwarp(mask) 只同步掩码中的 lane,并为这些线程的相关内存访问提供顺序保证。所有在掩码中命名的、未退出的线程都必须执行与该掩码相应的同步。
如果一个 Warp 内只有满足条件的线程参加后续协作,可以先由共同执行位置生成掩码:
1 | unsigned full = __activemask(); |
具体算法还要保证 Shuffle 的源 lane 存在于 group,并且所有被命名的 lane 都按要求执行原语。掩码既是参与集合,也是正确性契约。
5.3 跨 Block 同步优先使用 Kernel 边界
普通 Kernel 内的 __syncthreads() 不能跨 Block。最容易验证的全局阶段划分,是拆成两个 Kernel:
1 | stage1<<<grid, block>>>(input, partial); |
同一 Stream 中,第二个 Kernel 在第一个 Kernel 完成后执行,因此 Kernel 边界自然形成全局阶段边界。
Cooperative Groups 可以在满足设备能力、合作启动方式和驻留条件时提供 Grid 级同步。它要求整个协作 Grid 能同时驻留,启动规模受到限制。普通方式启动含 grid.sync() 的 Kernel 并不安全。
5.4 Memory Fence 只处理顺序,不负责等待
传统 CUDA Fence 有不同作用域:
1 | __threadfence_block(); // Block 作用域 |
它们约束调用线程的内存操作顺序与相应范围的可见性,但不会让其他线程等待到这里。要实现“写数据,然后发布完成标志”,还需要配合原子标志或其他同步协议;接收方也必须使用匹配的观察方式。
跨 Block 通信尤其容易写错,还可能出现前向进展问题。若没有强烈的单 Kernel 融合需求,分成多个 Kernel 往往更清楚。现代 CUDA 还提供带作用域与内存序的原子 API,复杂生产代码应优先依据目标 CUDA 版本的官方内存模型设计,而不是只靠经验拼接 volatile、Fence 和计数器。
6. 原子操作:正确并不代表可扩展
6.1 为什么普通 += 会丢失更新?
counter += 1 通常包含读取、加法、写回三个步骤。如果两个线程同时读取旧值 5,再各自写回 6,最终只增加一次。
1 | atomicAdd(&counter, 1); |
原子操作把目标地址上的读改写作为不可分割操作,从而防止丢失更新。它保证的是该地址上的操作原子性,不保证多个不同地址组成的更大事务也是原子的。
支持的操作与数据类型随计算能力和 CUDA 版本变化。例如 double 的原生 atomicAdd 有架构要求,使用前应检查目标设备,而不是依赖一张脱离版本的固定列表。
6.2 性能取决于地址争用程度
若线程原子更新彼此不同的地址,可以保持较高并行度;如果成千上万线程竞争一个地址,操作就会在该地址上串行化。
因此,优化原子的核心通常不是“把原子换成另一个函数”,而是减少到同一地址的原子次数:
1 | 每线程私有累加 |
6.3 分层规约
下面的结构让每个线程先在 Grid-stride Loop 中累加多个元素,再进行 Warp 与 Block 级合并,最后每个 Block 只做一次全局 atomicAdd:
1 | __device__ float warpReduceFull(float value) { |
这个教学版本假设 blockDim.x 是 32 的倍数且不超过 1024,并让整个 Warp 执行 Shuffle。若要支持任意 Block 大小,需要为最后一个不完整 Warp 构造正确掩码。调用前还必须把 output 初始化为 0:
1 | CUDA_CHECK(cudaMemset(d_output, 0, sizeof(float))); |
浮点原子加法的完成顺序不固定,因此不同运行或配置可能得到略有差异的最低位结果。正确性判断应考虑浮点归约的非结合性。
若全局原子仍是瓶颈,可以让每个 Block 写一个部分和,再用第二个 Kernel 完成规约。多阶段 Kernel 往往更容易获得确定的结构,也避免所有 Block 争用一个地址。
6.4 直方图适合私有化
朴素直方图让每个输入直接更新全局 bin:
1 | atomicAdd(&globalHistogram[value], 1); |
数据分布偏斜时,热门 bin 会产生严重争用。常见改法是每个 Block 在共享内存中维护局部直方图,处理完一批输入后再合并到全局结果。这样把大量全局争用变成片上争用和少量全局更新。
但局部直方图也不是免费方案:bin 数过大时,共享内存用量会降低 Occupancy;初始化与合并也有成本;共享内存原子仍可能争用。更进一步可以为每个 Warp 或线程维护私有副本,但寄存器和共享内存开销会增加。这正是原子优化与 Occupancy 互相影响的地方。
6.5 CAS 循环适合实现缺失的原子语义
Compare-and-Swap 根据旧值是否匹配来条件更新,可用来构造某些硬件未直接提供的原子操作:
1 | do { |
高竞争下,CAS 失败后会反复重试,代价可能很高。还要正确处理数据位表示、NaN 和 ABA 等问题。能用现成原子 API、库算法或分层聚合解决时,通常更容易验证。
7. 四类优化其实相互制约
这些主题不能孤立看待:
1 | flowchart TD |
例如,扩大矩阵乘法 Tile 可以提高数据复用,却增加共享内存与寄存器,Occupancy 可能下降;把每线程的四次加载改成 float4 可能减少指令,却增加寄存器活跃区间;把全局原子改成 Block 局部直方图减少了争用,却可能占用大量共享内存。
因此,优化目标是让整条关键路径更短,而不是让某个单独指标看起来更漂亮。
8. 把方法用回前一篇的练习代码
8.1 向量加法与 SAXPY
这两类 Kernel 算术强度低,可以按下面顺序实验:
- 确认相邻线程访问相邻元素,计算有效带宽。
- 扫描 128、256、512 三种 Block 大小。
- 用 Grid-stride Loop 控制 Grid 数量,并确保并行度足够。
- 在地址对齐、尾部处理正确的前提下测试
float4。 - 检查向量化是否真的减少指令,以及寄存器与耗时是否变化。
若数据每次都从 CPU 搬到 GPU,再搬回来,端到端性能还会受传输限制。此时 Kernel 微优化的收益可能被淹没,应考虑数据驻留与多算子融合。
8.2 点积
前一篇的 dot_product.cu 使用纯共享内存树形规约。可以构造三个版本进行对比:
- 版本 A:当前每轮
__syncthreads()的共享内存规约; - 版本 B:每个 Warp 用 Shuffle 规约,只把 Warp 结果写入共享内存;
- 版本 C:每线程先用 Grid-stride Loop 或向量化加载累加多个元素,再执行版本 B 的 Block 规约。
每个版本都要记录寄存器、共享内存、理论/实际 Occupancy、Kernel 时间和数值误差。规约顺序改变后,浮点结果最后几位发生变化并不意外。
当前点积代码把 65,536 个 Block 部分和拷回 CPU 再求和。若要完整比较 GPU 方案,还应增加第二阶段 GPU 规约,并分别测量 Kernel 阶段与完整流程。
8.3 异步分块程序
前一篇已经说明:同一个 Stream 中的 H2D、Kernel、D2H 仍按依赖顺序执行。多 Stream 分块后,可以用 Nsight Systems 验证复制引擎与计算是否真的重叠。
这时应同时检查:
- 每块数据是否足够大,能够摊薄启动和提交开销;
- 主机缓冲区是否使用锁页内存;
- 不同 Stream 是否使用互不冲突的数据区间;
- 最终等待是否放在所有任务提交之后;
- 多 Stream 是否因 Kernel 资源占用或带宽竞争而没有获得收益。
9. 一张可执行的优化检查表
面对一个慢 Kernel,可以沿着下面的顺序检查:
| 阶段 | 要问的问题 | 常见行动 |
|---|---|---|
| 正确性 | 是否有越界、数据竞争、错误掩码或错误屏障? | Compute Sanitizer、参考结果、异常值检查 |
| 系统时间线 | 时间花在 CPU、传输还是 Kernel? | Nsight Systems、明确计时边界 |
| 瓶颈类型 | 启动、内存、计算、依赖、同步还是原子争用? | Nsight Compute、Roofline、Stall 分析 |
| Warp | 是否有低效分支或部分 Warp? | 重排任务、调整 Block、正确使用 Warp 原语 |
| 全局内存 | 相邻线程是否访问相邻地址?是否搬了无用数据? | 改布局、合并访问、减少中间流量 |
| 共享内存 | 是否真正复用数据?是否有 Bank Conflict? | Padding、调整 Tile、减少屏障 |
| Occupancy | 哪种资源限制驻留?提高它是否能改善延迟隐藏? | 扫描 Block、检查寄存器/smem/spill |
| 原子操作 | 是否大量线程竞争相同地址? | 私有化、Warp/Block 聚合、多阶段归约 |
| 验证 | 优化是否真的改善目标指标? | 重复基准、复查结果、保留实验记录 |
真正有价值的性能结论应能够回答三件事:原版本受什么限制;修改改变了哪项硬件行为;测量结果是否与这个解释一致。
10. 小结
Warp 解释了线程如何以 32 个 lane 为一组执行,也解释了分支、Shuffle 和 Vote 原语的行为。内存优化要求从 Warp 的地址集合出发,减少 sector 流量、Bank Conflict 和重复搬运。Occupancy 描述 SM 能驻留多少 Warp,主要用于理解延迟隐藏,但不等于性能。同步、Fence 和原子操作分别解决阶段协调、内存顺序与读改写冲突,不能互相替代。
当这些知识连在一起时,CUDA 优化就不再是一组零散技巧,而是一套基于证据的过程:观察执行行为,找出限制因素,在资源、复用和并行度之间做权衡,然后用正确性与性能数据验证结论。
参考资料
本文依据以下五篇 AIInfraGuide 文章组织学习主线,并补充了适用条件与实验方法:
涉及架构差异、掩码语义、内存模型与 API 支持范围时,应以目标 CUDA 版本的官方文档为准: