HIP 事件开销调研报告

2026-11-18 · Aqua-Xpiler b9 失败分析的延伸调研(启动开销专题)

为什么一次事件记录
在 AMD 和海光上要 5~11 µs,
在 NVIDIA 上几乎为零

SYCL/HIP 事件开销的成因调研:MI210、海光 BW1000(DCU)与 H100 的逐项拆分和对照

记录一次事件让每次迭代多出的时间(逐项见表 20)

MI210ROCm 7.0
+5.0~5.5µs
空 kernel,GPU 端每次多出
读数据的 kernel
+9.1~11.6 µs
写数据的 kernel
+5.8~8.0 µs
主机端单次调用
1.6 µs
海光 DCUDTK 26.04
+5.4µs
空 kernel,GPU 端每次多出
读数据的 kernel
+3.0~5.2 µs
写数据的 kernel
+5.0~5.8 µs
主机端单次调用
5.7 µs
H100CUDA 12.8
+0.04µs
空 kernel,GPU 端每次多出
读数据的 kernel
未测
写数据的 kernel
约 0 µs
主机端单次调用
未测

原始数据、测量程序和本报告的生成脚本:research/data/h100_dcu_20261110/analysis_v2/claude/launch_overhead/why_amd/

摘要

把 CUDA 程序翻译成 SYCL 后,在 AMD MI210 和海光 DCU 上,小算子每次调用会多出 5~11 µs,在 NVIDIA 上几乎没有。上一阶段已经查明:多出来的钱来自 SYCL 运行时在每次提交后都记录一个后端事件(HIP 的 hipEventRecord)。本次调研回答下一个问题:同样是记录事件,为什么 AMD 和海光贵、NVIDIA 便宜,其中有没有不必要的部分。

做法分三步:读 ROCm 7.0 的 HIP 运行时源码并抓取真实提交的 AQL 包,弄清 hipEventRecord 往 GPU 队列里放了什么;绕过 HIP、直接往 HSA 队列里手写同样的包,每次只加一样东西,逐项计时;在 H100 上做功能对应的操作作对照。三种卡都用 GPU 自己的时钟核对,海光 DCU 上把前两步完整重做了一遍。

结论。HIP 的一次事件记录,在队列里是一个会让队列停下来的屏障包,带系统范围的 acquire 和 release 两道栅栏,外加一个放在主机内存里的完成信号。MI210 上:屏障包 0.65 µs,主机内存里的信号 2.4~2.6 µs,系统 acquire 在空 kernel 上 1.5~1.9 µs,下一个 kernel 要访存时合计 4.9~6.8 µs;系统 release 要把 L2 里的脏数据写回显存,每 MiB 约 0.7 µs,但 L2 只留得住约 4~5 MiB 脏数据,所以最多约 3.1 µs。读数据的小 kernel 每次因此多 9~11.6 µs。海光 DCU 上 GPU 端每次多 5.4 µs(屏障包更慢,没有 acquire 后续罚时),主机端 DTK 的 hipEventRecord 另要 5.7 µs CPU 时间,因为它给每个事件都用能触发中断的信号,并挂一个主机回调。NVIDIA 的普通事件不让流停下来,也不需要写回 L2,GPU 端只多 0.04 µs。

不必要的部分主要有六处:记录事件时做 acquire;文档里写着的 hipEventReleaseToDevice 没有实现;每个事件都按"主机要直接读数据"做系统 release;只给 GPU 用的信号也放主机内存;DTK 给每个事件挂中断和回调;HIP 已有的"把事件挂在 kernel 包上"的路径,SYCL 运行时没有用。按"最少必要"算,AMD 上一个事件约 1~3 µs(取决于信号放在哪、要不要单独的屏障包)。

A100 上的另一笔开销。A100 上 SYCL 不管返不返回事件都比原生慢 0.5~0.9 µs。这不是事件的问题,而是 SYCL 运行时自己每次提交要跑约 0.7 µs 的 CPU 代码(返回事件约 1.1 µs);A100 上提交本来就卡在 CPU 上,所以一比一显现。MI210 上同样有这笔钱,只是被 GPU 时间盖住了(6.2 节)。

一、背景:问题从哪里来#

1.1现象#

b9 实验里,Sol 在 MI210 上交付的 router、qknorm 两个算子保持率低于 1(0.82、0.94)。只把 SYCL 的提交写法换成不返回事件的 nd_launch,其余代码不动,保持率就变成 1.47、1.54。CUDA 和 HIP 程序本身没有这笔开销,于是要问:是不是 SYCL 多做了本不需要做的事?

1.2上一阶段已经查清的部分#

上一阶段的调研(launch_overhead/README.md)查清了这笔开销从哪来。SYCL 规范要求 queue::submit 和 queue::parallel_for 每次返回一个 sycl::event。运行时不知道调用方会不会用这个事件,只好每次都在后端真的记录一个:

原生 CUDA/HIP 程序只在需要时才记录事件,翻译过来的程序却每个 kernel 都记一次。表 1 是空 kernel 上的实测。

表 1 每次调用的时间(µs,空 kernel,连续提交,7 轮取最好;上一阶段的测量)
写法MI210(DPC++ HIP)DCU(AdaptiveCpp)A100(DPC++ CUDA)
原生启动1.32~1.441.92~1.982.52
原生启动 + 每次记录一个事件6.08~6.497.24~7.632.90
SYCL 普通提交(q.parallel_for)6.14~6.487.86~8.103.81
SYCL 不返回事件(DPC++ nd_launch)1.43~1.58—3.03
AdaptiveCpp 即时提交 + 粗粒度事件—3.03~3.17—

第 2 行是诊断用的对照:原生程序平时不会每次启动都记录事件。翻译出的程序实际付出的代价,要看第 3 行比第 1 行多多少。

这张表要分两件事看:

影响面不小。b9 里 Sol 的 221 个配置中,MI210 和 DCU 各有约 38% 每次调用不到 20 µs,在这些配置上 5~8 µs 的额外开销占四分之一以上。在 DCU 上,整个程序打开 AdaptiveCpp 的即时提交并加粗粒度事件,其余代码不动,官方计分器给出 router 0.82 → 1.07、dsv3 0.79 → 0.98、topk_moe 0.77 → 1.37、qknorm 1.28 → 1.58。

1.3这次要回答的问题#

  1. hipEventRecord 在 GPU 上具体做了什么?每一部分各花多少时间?
  2. 为什么同样的操作在 NVIDIA 上便宜?
  3. 哪些部分是必要的,哪些不必要或不合理?在工具链层面能怎么改,各能省多少?
  4. 海光 DCU(DTK)和 AMD 原版 ROCm 是否一样?
  5. A100 上事件本身便宜,SYCL 为什么仍比原生慢?

注意,我们关心的不是"靠哪个参数能关掉这个事件",而是"为什么在 AMD 和海光上贵"。关掉事件的办法上一阶段已经有了(第十一节会再总结);这次要找的是事件本身贵的原因,以及其中不合理的设计。

二、预备知识:队列、屏障、信号和栅栏#

这一节为不熟悉 GPU 运行时内部的读者准备。已经熟悉 AQL 和内存栅栏的读者可以跳到第三节。

2.1GPU 怎么接收命令:队列、包、门铃#

在 AMD 的 GPU 软件栈(HSA 架构)里,主机程序和 GPU 之间通过"用户态队列"交流。队列是一块环形缓冲区,每格放一个 64 字节的 AQL 包(Architected Queuing Language)。主机写好一个包,再往门铃(doorbell)写一个数,通知 GPU 上的命令处理器(Command Processor,下文简称 CP)来取。CP 按顺序处理包,主要有两类:

HIP 的 hipLaunchKernel、hipEventRecord 等调用,最终都翻译成往这个队列里写包。NVIDIA 也有类似的"命令缓冲区 + 门铃",但格式不公开。

2.2屏障位#

每个包的 header 里有一个屏障位(barrier bit)。设了这一位的包,要等前面所有的包都执行完才开始。HIP 的 kernel 包都设了这一位,所以同一个队列里的 kernel 严格先后执行;屏障包也一定设这一位。因此,在两个 kernel 之间插一个屏障包,第二个 kernel 要等"第一个 kernel 结束 → CP 处理屏障包 → 屏障包完成"之后才能开始。屏障包上的每一点工作,都直接加在相邻两个 kernel 的间隔上。

2.3完成信号#

包可以带一个完成信号(completion signal):放在内存里的一个 64 位整数。包执行完,CP 把它减 1。主机(例如 hipEventSynchronize)或者别的包(屏障包)可以等它变化。信号放在哪里很重要:

信号还可以"带中断":值变化时 GPU 给 CPU 发一个中断,叫醒睡眠中的等待线程。中断本身也有开销。

2.4内存栅栏:acquire 和 release,设备范围和系统范围#

GPU 有多级缓存。一个 kernel 写的数据可能还停在缓存里,别人不一定马上看得到。栅栏(fence)规定的是"什么时候、对谁可见":

范围(scope)有两种:设备范围(agent scope)只对同一块 GPU 上的其他工作有效;系统范围(system scope)对主机 CPU 和其他 GPU 也有效。AQL 包的 header 里,acquire 和 release 各有一个字段,可以分别选"无 / 设备 / 系统"。acquire 在包开始前做,release 在包完成后、改完成信号之前做。

2.5AMD 和 NVIDIA 的 L2 有什么不同#

按 LLVM 文档对 GFX90A(MI210 的架构)内存模型的描述,本卡显存的数据可以以"脏"的形式留在 L2 里(MTYPE RW)。同一块卡上的所有计算单元共用一个 L2,所以设备范围的 release 不需要写回;但要让别的设备(包括经 PCIe 访问的主机)看到,必须先用 buffer_wbl2 把 L2 里的脏行写回显存。所以系统范围 release 的代价,和"kernel 写了多少、还有多少留在 L2 里"成正比。系统范围的 acquire 在着色器层面用 buffer_invl2,按文档只需要作废 MTYPE NC 的行(非本地内存),本地显存的行"由于探测机制,永远不会过期"。

NVIDIA 的 L2 是显存的一致性点:主机和其他设备经 PCIe 访问显存也经过 L2,所以系统栅栏不需要写回 L2。这一点是根据第六节的实测(栅栏代价不随脏数据变化)加上公开资料推断的,没有找到 NVIDIA 官方文档的明确表述。

AMD MI210 / 海光 DCU计算单元(CU / SM)+ L1L2(整卡共享)脏数据显存(HBM)主机 CPUPCIe主机或别的设备经 PCIe 读这块显存时,看不到还留在 L2 里的脏数据。系统范围 release必须先把脏行写回显存(buffer_wbl2),代价随脏数据量增长。NVIDIA H100计算单元(CU / SM)+ L1L2(整卡共享)显存(HBM)主机 CPUPCIe经 PCIe 访问显存也经过 L2,L2 就是显存的一致点,系统栅栏不用写回 L2。(由"栅栏代价不随脏数据变化"的实测和公开资料推断,未见官方文档明确说明)
图 1 AMD 和 NVIDIA 的 L2 与主机访问路径(示意)。AMD 一侧依据 LLVM 的 GFX90A 内存模型;NVIDIA 一侧是推断。海光 DCU(gfx936)和 MI210 是同一类架构,第七节的实测也表现出同样的"系统 release 随脏数据增长"。

2.6记录一个事件,最少需要做什么#

事件的语义是:标记队列里的一个位置,以后可以查询或等待"这个位置之前的工作是否都完成了"。要实现它,最少需要:

  1. 前面的工作完成后,改一个等待方能看到的值(完成信号)。
  2. 如果等待方要直接读前面 kernel 写的数据(例如主机等完事件后直接读显存),这些数据要对等待方可见,需要一次范围合适的 release。只有主机或其他设备要直接读时,才需要系统范围;同一块 GPU 上的依赖只要设备范围,而 kernel 包结束时本来就带设备范围 release。

记录事件的一方不需要 acquire:acquire 是"读别人的数据之前"做的,应该由等待方在等到之后做。另外,同一个 in-order 队列里的后续 kernel 已经被屏障位排好了顺序,连事件都不需要。

三、调研方法#

3.1思路#

  1. 看清 HIP 放了什么。读 ROCm 7.0 CLR(HIP 运行时)的源码,并用 AMD_LOG_LEVEL=4 抓下真实提交的每个 AQL 包的 header,两者对照。
  2. 逐项拆分。绕过 HIP,用 HSA 接口直接往队列里写同样的包。从"只有 kernel"开始,每次只加一样东西:屏障包、完成信号、信号放在哪、acquire、release、栅栏的范围,测每一项让每次迭代多出多少时间。再回到 HIP 层面,用真实的 HIP 调用核对。
  3. 对照。在 NVIDIA H100 上做功能对应的操作(不计时事件、计时事件、带系统栅栏往主机内存写一个值),看它便宜在哪里。在海光 DCU 上把 1、2 两步重做一遍。

3.2测量程序#

表 2 本次写的测量程序(都在 why_amd/ 下)
程序作用
kernels.clHSA 探针用的 kernel:空 kernel、写 n 字节(wr)、读 n 字节(rd)、按页跨步读(rds)、按 GPU 时钟空转(spin)、在 GPU 上记时间戳(stamp)。OpenCL C,不链接设备库,同一份源码可编 gfx90a(MI210)和 gfx936(DCU)。
hsa_probe.cpp手工构造 AQL 包:kernel 包、BARRIER_AND、BarrierValue,acquire/release 范围任意组合。完成信号可以用 ROCr 建的,也可以自己在指定内存池(主机细粒度、显存粗粒度、显存细粒度)里构造。kernel 参数放显存。模式:主表与时间线、信号位置、写入量、读 kernel、冷热数据、插空 kernel、GPU 忙时提交。
hip_probe.cppHIP 层:启动加各种标志的 hipEventRecord、每次新建/销毁事件、hipExtLaunchKernelGGL 挂停止事件;输出每次调用时间、GPU 时间线、GPU 忙时的单次调用耗时、AQL 日志。
cuda_probe.cuNVIDIA 对照:不计时/计时事件、新建-记录-销毁、cuStreamWriteValue32 带系统栅栏写显存或主机内存、不同写入量、GPU 时间线。
../a100_why/ 下的 native_prof.cu、sycl_prof.cpp、prof.h、gen_count_shim.pyA100 上的提交循环:原生 CUDA 的几种启动方式和 SYCL 的两种提交;进程内采样(GPU50 上用不了 perf);LD_PRELOAD 计数库,统计 UR 的 CUDA 适配层每次提交调用了哪些驱动函数(6.2 节)。
counters_probe.cpprocprof 硬件计数器(L2 命中、地址翻译)。计数器采集本身会在每个 kernel 前后清缓存,测不出差别,结果没有用上。

3.3几种测法#

3.4平台#

表 3 平台和软件版本
MI210海光 DCUH100
型号AMD Instinct MI210(gfx90a)BW1000 64G(gfx936)H100 80GB HBM3
L28 MiB8 MiB50 MiB
软件ROCm 7.0.0(CLR rocm-7.0.0 标签)DTK 26.04;HIP 是 libgalaxyhip(AMD HIP 6.3 的分支),HSA 运行时用计算节点上的 /opt/hyhal驱动 580.178.04,CUDA 12.8 编译
机器GPU62 card3,宿主机直接运行齐物集群 bw1000 分区,Slurm 作业齐物集群 gxn74;GPU70 card4(驱动 570)复测
频率1700 MHz(全程)1500 MHz(全程)—

另外:A100 在 GPU50 card1(主机 CPU 为 AMD EPYC 7763,CUDA 12.0),表 1 是上一阶段的数字,6.2 节是这次在同一张卡、同一个容器里重测的。SYCL 实现:MI210 上是 DPC++(2026-10-14 的 intel/llvm),A100 上是 b9 A100 容器里的 DPC++(clang 21 开发版,libsycl.so.8),DCU 上是 AdaptiveCpp 24.10。MI210 本该在 b9 的容器里跑,但 GPU62 的 /data1 已满,Docker 起不了容器,所以用宿主机上同一版本的 ROCm 7.0.0 运行时,并用 ROCR_VISIBLE_DEVICES 固定在空闲的 card3 上。

四、HIP 往队列里放了什么#

4.1源码#

看的是 clr 仓库的 rocm-7.0.0 标签:

4.2AQL 包日志#

表 4 各种操作放进队列的包(MI210,AMD_LOG_LEVEL=4;out/mi210_hip_aqllog.txt、out/mi210_sycl_aqllog.txt)
操作放进队列的包
kernel<<<>>> / hipLaunchKernelDispatch 0xb02:屏障位,acquire=设备,release=设备,无信号
hipEventRecord(DisableTiming、计时、ReleaseToDevice、ReleaseToSystem、每次新建事件,全部一样)Dispatch 之后加 BarrierValue 0x1500:屏障位,acquire=系统,release=系统,带信号
hipEventRecord(DisableSystemFence)BarrierValue 0x100:无栅栏,带信号
hipDeviceSynchronizeBARRIER_AND 0x1503:系统/系统,带信号
DPC++ q.parallel_for每个 Dispatch 后一个 BarrierValue 0x1500
DPC++ nd_launch只有 Dispatch
hipExtLaunchKernelGGL(..., stopEvent)没有单独的标记包,事件挂在 kernel 包的完成信号上;第一个 kernel 包是 0x1502(系统/系统),后面连续的都被降成 0xb02(设备/设备)

图 2 把这几种情况画在一起。和 2.6 节的"最少需要"相比,HIP 的事件多了三样东西:一个让队列停下来的独立屏障包、一道 acquire、以及不分场合的系统范围 release;而且信号放在主机内存里。

队列里的先后顺序(示意,不按比例)普通启动CUDA、HIP,DPC++ nd_launchKKKKKKKKK启动 + hipEventRecordSYCL 默认的每次提交K屏障包系统 acquire系统 release写信号(经 PCIe)K罚时屏障包要等前一个 kernel 做完;后面的 kernel 又要等屏障包做完。虚线框:MI210 上下一个访存的 kernel 还要再慢约 3~5 µs(acquire 的后续罚时)。扩展启动挂停止事件hipExtLaunchKernelGGL(…, stopEvent)KKKKKKK信号挂在 kernel 包上(橙色小块),不另插屏障包。NVIDIA cudaEventRecord不计时(DisableTiming)KKKKKKKKK事件(粉色菱形)只在前面做完时记一笔,后面的 kernel 不等它(由实测推断)。
图 2 几种提交方式放进队列的东西(示意,长度不按比例)。颜色和图 3 一致:灰色是 kernel,蓝色是 CP 处理屏障包本身,绿色是系统 acquire,黄色是系统 release,橙色是经 PCIe 改主机内存里的完成信号。NVIDIA 一行是根据实测推断的行为,不是公开文档。

4.3HIP 内部已有的"挂在 kernel 包上"的路径和懒栅栏#

表 4 最后一行是 HIP 自己已有的路径:hip_module.cpp 里的 BindCommand 把停止事件直接挂在 kernel 包的完成信号上,不另插屏障包。连续的系统范围包被降级,是 dispatchGenericAqlPacket 的规则:前一个包已经是系统 release 时,下一个降成设备范围,同时记一笔 fence_dirty_,等 hipStreamSynchronize、hipStreamQuery 或队列 finish 时再补一个系统范围的屏障包。也就是说,HIP 内部已经有"需要时再付系统栅栏"的懒做法,只是没有用在普通的 hipEventRecord 上。DPC++ 和 AdaptiveCpp 都没有用这条路径,用的是"启动,再单独记录事件"。

这里有一个没有验证的疑点:hipEventSynchronize 只等事件的信号,不看 fence_dirty_。连续用 hipExtLaunchKernelGGL 绑定停止事件时,后面的 kernel 只有设备范围 release;主机等到这个事件后直接读显存(不经过拷贝)时,按内存模型可能看不到 L2 里的数据。见第十三节。

4.4海光 DTK 的 HIP#

DTK 的 HIP 库是 libgalaxyhip,从 AMD HIP 6.3 分出,运行时 dlopen 计算节点上的 /opt/hyhal/lib/libhsa-runtime64.so。它用自己的日志开关(HIP_LOG_LEVEL、HIP_LOG_OUTPUT_PATH),日志是 NanoLog 二进制格式,要用 DTK 自带的 .hyhal/NanoLog/bin/hiplogdump sort 解码;默认级别下不打印逐包 header。解码后的日志(out/dtk_hiplog/)显示:

在 DCU 上用手工构造的同样的包计时,结果和 HIP 实测一致(第七节)。

五、MI210 逐项拆分#

5.1空 kernel:每一项各花多少#

表 5 从"只有 kernel"开始,每次加一样东西。两列分别是逐包敲门铃和只敲一次门铃(纯 GPU 时间),增量按后一列算。

表 5 MI210,每次迭代的时间(µs,空 kernel;out/mi210_hsa_.txt、out/mi210_hsa__batch.txt)
每次迭代放进队列的东西逐包敲门铃只敲一次门铃增量
kernel1.321.33
+ 屏障包(不带栅栏、不带信号)1.971.98+0.65
+ 完成信号(主机内存)4.414.56+2.58
同上,信号带中断5.125.16+0.60
屏障包 + 信号 + 设备范围 acquire4.664.78+0.22
屏障包 + 信号 + 设备范围 release4.414.560.00
屏障包 + 信号 + 系统范围 release4.754.96+0.40
屏障包 + 信号 + 系统范围 acquire6.296.09+1.53
屏障包 + 信号 + 两道系统栅栏(= HIP 的事件,BarrierValue 包)6.836.31+4.98
同上,用 BARRIER_AND 包6.616.29+4.96
BarrierValue + 信号,不带栅栏(= DisableSystemFence)4.354.48+3.15
信号直接挂在 kernel 包上(不加屏障包)3.833.94+2.61
kernel 包自己带系统 release1.531.54+0.21
kernel 包自己带系统 acquire2.192.23+0.90
两个 kernel2.642.66+1.33

增量的对照:第 2 行相对第 1 行,第 3、4 行相对上一行,第 5~8 行相对第 3 行(屏障包 + 信号、不带栅栏),其余相对第 1 行。逐包敲门铃时,主机每次迭代写包加敲门铃只花 0.3~0.8 µs,所以两列都是 GPU 处理命令的时间。

逐项看:

开不开队列的时间戳采样,各行相差不超过 0.15 µs。HIP 的每个队列都开着采样,所以 hipEventDisableTiming 设不设,放进队列的包和花的时间都一样。

kernel 本身屏障包完成信号(主机内存)系统 acquire系统 releaseNVIDIA 事件(整体)02468每次迭代的 GPU 时间(µs)MI210kernel + hipEventRecord1.330.652.581.536.31 µs海光 DCUkernel + hipEventRecord1.711.432.570.810.627.14 µsH100kernel + cudaEventRecord(不计时)1.982.02 µs(事件 +0.04)H100kernel + cudaEventRecord(计时)1.983.014.99 µs(事件 +3.01)
图 3 一次事件记录在 GPU 上的时间构成(空 kernel)。MI210 和 DCU 是只敲一次门铃时每次迭代的 GPU 时间,按"kernel → 加屏障包 → 加主机内存信号 → 加系统 acquire → 再加系统 release"逐项累加,最后一段的右端就是 HIP 事件的实测总时间;H100 是 GPU 时间线上相邻 kernel 的间隔。数值见表 5、表 12、表 15。

5.2完成信号放在哪里#

ROCr 建的信号,包括声明了"只有 GPU 用"的(HSA_AMD_SIGNAL_AMD_GPU_ONLY),都放在主机内存里,和自己建在主机内存里的信号一样慢。把同样的信号块放到显存(粗粒度),挂在 kernel 包上只多 0.9 µs(主机内存 2.5 µs);屏障包 + 信号多 1.6 µs(主机内存 3.1 µs)。

表 6 信号位置的影响(µs;out/mi210_hsa_sig.txt、out/dcu_hsa_sig.txt,逐包敲门铃)
每次迭代(µs)MI210海光 DCU
只有 kernel1.331.69
信号挂在 kernel 包上
ROCr 建的"只给 GPU 用"的信号(实际在主机内存)3.954.17
自建信号,主机细粒度内存3.844.13
自建信号,显存粗粒度2.252.74
自建信号,显存细粒度—3.12
屏障包(不带栅栏)+ 信号
ROCr 的信号(主机内存)4.555.62
自建信号,显存粗粒度2.924.16
屏障包 + 两道系统栅栏 + 信号(= HIP 的事件)
ROCr 的信号(主机内存)6.716.94
自建信号,显存粗粒度5.605.64

"自建信号"是测量手段:在指定内存池里按 amd_signal_t 的布局自己构造信号块,不是 ROCr 支持的用法。放在粗粒度显存里的信号,主机经 PCIe 直接读可能看不到最新值,只适合只由 GPU 等待的事件。

5.3系统 release 和 L2 里的脏数据#

让 kernel 先写一段数据,再看系统 release 比不加栅栏多多少(设备范围 release 和不加栅栏实测完全一样)。写入量从 1 MiB 到 64 MiB,每 1 MiB 一个点。同时用读 kernel 比较"反复读同一块"和"轮流读不同的块",看 L2 能留住多少数据。

MI210海光 DCU海光 DCU,固定 256 个工作组脏数据上限(a)kernel 写入之后,系统 release 比不加栅栏多出的时间(µs)01234567048121620242832(b)读同一块数据(在 L2 里)比轮流读不同的块快多少(µs)01234048121620242832L2 容量 8 MiBkernel 写入或读取的数据量(MiB)
图 4 系统 release 的代价随写入量的变化,以及 L2 能留住多少数据。(a)纵轴是"屏障包 + 信号 + 系统 release"比"屏障包 + 信号"多出的时间(逐包敲门铃)。两块卡都在 4~5 MiB 处到顶:MI210 到 4 MiB 为止每 MiB 约 0.7 µs,接近显存写带宽,4~5 MiB 时 3.1 µs,之后回落到 1.7~2.2 µs;DCU 在 4~6 MiB 停在 3.4~3.5 µs,然后又慢慢涨到 4.4 µs。(b)两块卡在 7~8 MiB 附近收益最大,12~13 MiB 以后基本没有,和 8 MiB 的 L2 容量一致。DCU 上每个工作项一个 float4 的读 kernel 卡在工作组派发上,数据在不在 L2 里都一样快(橙线贴着 0),所以另画了固定 256 个工作组的曲线。48、64 MiB 见表 7。
表 7 系统 release 比不加栅栏多出的时间,以及数据在 L2 里时读快多少(µs;out/*_hsa_wfine*.txt、out/*_hsa_rfine*.txt)
数据量MI210
release 多
DCU
release 多
DCU(固定工作组)
release 多
MI210
在 L2 里快
DCU(固定工作组)
在 L2 里快
1 MiB+0.98+1.68+1.700.730.02
2 MiB+1.92+2.30+2.321.330.70
3 MiB+2.44+2.86+3.011.391.22
4 MiB+3.12+3.36+3.621.981.39
5 MiB+3.13+3.40+3.912.251.56
6 MiB+2.55+3.49+3.342.801.70
7 MiB+2.11+3.74+3.083.381.80
8 MiB+1.92+3.94+3.262.521.80
10 MiB+1.73+4.29+3.871.060.79
12 MiB+1.95+4.43+4.320.330.20
16 MiB+1.57+4.54+4.750.070.07
24 MiB+2.20+4.49+5.440.110.08
32 MiB+2.01+4.55+6.070.050.12
64 MiB+1.69+4.46+6.510.050.12

这就是 L2 写回:LLVM 的 GFX90A 内存模型说,系统范围 release 要用 buffer_wbl2 写回 MTYPE RW(本地粗粒度显存)和 NC 的脏 L2 行;设备范围不需要,因为同一块卡的所有工作组共用一个 L2。这笔钱只有在主机或别的设备要直接读这块显存时才有必要付。SYCL in-order 队列里 kernel 之间的依赖都在同一块卡上,不需要它。

图 4 还说明了三件事:

5.4系统 acquire 的后续罚时#

空 kernel 上系统 acquire 自身多 1.9 µs。换成读数据的 kernel,代价大得多:

表 8 MI210,读数据的 kernel(µs;out/mi210_hsa_l2.txt、out/mi210_hsa_cold.txt)
MI210,读 kernel 每次迭代(µs)64 KiB1 MiB4 MiB16 MiB
只有 kernel(数据在 L2 里)1.311.442.4013.09
只有 kernel(数据不在 L2 里,轮流读 32 MiB 里的不同块)1.492.174.34—
+ 屏障包 + 信号(不带栅栏)4.685.006.0417.16
+ 屏障包 + 信号 + 设备范围 acquire4.945.246.3017.39
+ 屏障包 + 信号 + 系统范围 release5.055.356.4117.49
+ 屏障包 + 信号 + 系统范围 acquire9.5810.4712.7820.80
+ HIP 的事件(两道系统栅栏)10.4211.7113.4822.24
只有 kernel,kernel 包自己带系统 acquire5.816.368.7517.35
MI210海光 DCU系统 acquire 让这一次迭代多出的时间(µs)024681.9空 kernel4.964 KiB5.0256 KiB5.51 MiB6.02 MiB6.74 MiB6.88 MiB3.616 MiBDCU 各列都在 0.6~0.8 µs下一个 kernel 读的数据量
图 5 系统 acquire 让每次迭代多出的时间。"屏障包 + 信号 + 系统 acquire"减去"屏障包 + 信号"(逐包敲门铃)。MI210 上,读数据的 kernel 多 4.9~6.8 µs(16 MiB 时 3.6 µs),比空 kernel 的 1.9 µs 多出约 3~5 µs;DCU 上无论读多少都只多 0.6~0.8 µs。

访存 kernel 上多出来的这 3~5 µs"罚时"是什么?下面几组对照逐个排除:

表 9 热数据(在 L2 里)和冷数据(不在 L2 里)(µs;out/mi210_hsa_cold.txt、out/dcu_hsa_cold.txt)
数据量kernel(热)kernel(冷)加屏障包与信号(热)(冷)再加系统 acquire(热)(冷)acquire 多(冷)
MI210
64 KiB1.331.494.795.5910.1410.09+4.50
1 MiB1.452.175.075.9510.7710.78+4.83
4 MiB2.434.346.188.3813.1213.11+4.73
海光 DCU
64 KiB1.731.735.615.606.346.34+0.74
1 MiB2.222.235.605.606.346.34+0.74
4 MiB4.784.796.436.557.317.31+0.76
表 10 按页跨步读、在 acquire 后插空 kernel(µs;out/*_hsa_l2.txt、out/*_hsa_acq.txt)
系统 acquire 让每次迭代多出的时间(µs)MI210海光 DCU
按页跨步读,范围 4 MiB(只读 1/256 的数据)+5.27+0.70
按页跨步读,范围 16 MiB(只读 1/256 的数据)+5.57+0.70
按页跨步读,范围 64 MiB(只读 1/256 的数据)+6.29+1.45
读 1 MiB;acquire 和读 kernel 之间插 0 个空 kernel+5.70+0.73
读 1 MiB;acquire 和读 kernel 之间插 1 个空 kernel+5.83+1.04
读 1 MiB;acquire 和读 kernel 之间插 2 个空 kernel+6.16+1.06
读 1 MiB;acquire 和读 kernel 之间插 3 个空 kernel+5.85+1.08

推断(没法直接验证):CP 执行的系统范围 acquire 把整个 L2 作废了,下一个 kernel 的代码、参数、页表项都要从显存一级一级重新取,所以第一次访存要多付几 µs,和读多少数据无关。LLVM 的内存模型说,着色器层面的系统 acquire(buffer_invl2)只需要作废 MTYPE NC 的行,本地粗粒度显存的行不会过期;CP 实际做的比这多得多。用 rocprof 采计数器想验证,但计数器采集本身会在每个 kernel 前后清缓存,测不出差别。

AMD 自己的头文件对系统栅栏的描述是:会带来"缓存写回和失效的开销,以及这些操作对后续工作执行的影响"。实测正是如此,而且后一项(对后续工作的影响)在 MI210 上是最大的一块。

5.5HIP 层面的核对#

表 11 HIP 层面(每次调用和 GPU 时间线上的相邻 kernel 间隔,µs;out/mi210_hip.txt、out/dcu_hip.txt)
HIP 层面的写法MI210 每次调用MI210 GPU 间隔DCU 每次调用DCU GPU 间隔
只启动 kernel1.462.401.932.40
+ hipEventRecord(DisableTiming)6.118.007.637.68
+ hipEventRecord(计时)6.108.007.637.68
+ hipEventRecord(DisableSystemFence)4.415.926.186.24
+ hipEventRecord(ReleaseToDevice)6.108.007.627.68
+ hipEventRecord(ReleaseToSystem)6.118.007.627.68
每次新建、记录、销毁事件6.118.007.627.68
hipExtLaunchKernelGGL 挂停止事件3.873.844.784.80
同上,停止事件带 DisableSystemFence3.863.844.994.80

小结(MI210)。空 kernel 上,一次事件让 GPU 多花 5.0~5.5 µs:主机内存信号 2.4~2.6、系统 acquire 1.5~1.9、屏障包 0.65、系统 release 0.2~0.4。真实的读 kernel 上,acquire 合计多 4.9~6.8 µs,整个事件每次多 9~11.6 µs;写 kernel 上,release 的写回最多再多约 3 µs。

六、NVIDIA 对照#

这一节分两部分:6.1 节看 NVIDIA 的事件为什么便宜;6.2 节回答表 1 里的另一个现象,即 A100 上事件便宜,SYCL 为什么仍比原生慢。

6.1NVIDIA 的普通事件做了什么#

在集群的 H100 上做功能对应的操作(cuda_probe.cu,out/h100_cuda.txt)。

表 12 H100,每次迭代(µs)
H100(驱动 580)每次迭代主机计时(µs)GPU 上相邻 kernel 间隔(µs)
只启动 kernel1.631.98
+ cudaEventRecord(DisableTiming)1.692.02
+ cudaEventRecord(计时)4.764.99
+ cuStreamWriteValue32,带系统栅栏,写显存4.624.67
+ cuStreamWriteValue32,带系统栅栏,写主机内存5.455.60
每次新建、记录、销毁事件(DisableTiming)2.03—
两个 kernel3.24—
表 13 H100,写数据的 kernel 后面加事件或带栅栏的写值,多出的时间(µs)
kernel 写入量kernel 本身(µs)+ 不计时事件,多+ 带系统栅栏写主机内存,多
64 KiB1.83+0.01+3.55
1 MiB2.07+0.01+3.59
4 MiB2.720.00+3.70
16 MiB5.930.00+3.65
64 MiB22.81-0.01+3.93

GPU70 上的 H100(驱动 570):只启动 2.05 µs,加不计时事件 2.44 µs;上一阶段的 A100:2.52 → 2.90 µs。不计时事件只在主机端多 0.06~0.4 µs。CUDA 12 拒绝 CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER,所以没有"不带栅栏写值"这一项。

解读:

所以 NVIDIA 便宜,不是因为它的硬件做同样的事更快,而是因为它的普通事件根本不做那些事:不阻塞流、不做 acquire、不写回缓存。

6.2A100 上 SYCL 为什么仍比原生慢:运行时自己的 CPU 开销#

表 1 里,A100 上原生启动加一次事件记录只多 0.4 µs,SYCL 却不管返不返回事件都比原生慢:不返回事件多 0.5 µs,返回事件比"原生 + 记录"多 0.9 µs。为了查清这笔钱花在哪里,在 GPU50 的空闲 A100(card1)上,用和表 1 相同的容器和 DPC++,把几种原生启动方式和两种 SYCL 提交各连续跑 4 秒,用进程内采样(3.3 节)统计 CPU 时间落在哪个库里;再用一个 LD_PRELOAD 计数库,统计 UR 的 CUDA 适配层每次提交调用了哪些驱动函数(launch_overhead/a100_why/)。

CUDA 驱动(含驱动里的锁)程序自身(含静态链接的 CUDA 运行时)SYCL 运行时(libsycl)UR(加载层和 CUDA 适配层)C/C++ 库(malloc、free 等)01234每次调用的 CPU 时间(µs,A100 上全部是主机瓶颈)<<<>>>原生,CUDA 运行时,默认流2.422.51 µs<<<>>> + cudaEventRecord原生,每次记录一个复用的事件2.692.84 µscuLaunchKernel原生,驱动 API,自建流2.312.31 µsSYCL nd_launch不返回事件,比 <<<>>> 多 0.49 µs2.260.423.00 µsSYCL parallel_for返回事件,比 <<<>>> + 记录多 0.88 µs2.540.600.383.72 µs
图 6 A100 上每次提交的 CPU 时间花在哪里。每条的总长是每次调用的时间(7 轮取最好;所有写法都是主机瓶颈,每次调用的时间等于主机提交一次的时间),各段按采样落在各库里的比例分摊。"CUDA 驱动"包括驱动调用的 pthread_mutex_lock。数值见表 14。
表 14 A100,每次调用的 CPU 时间按库分摊(µs;a100_why/out/)
写法每次调用CUDA 驱动程序自身libsyclURC/C++ 库
<<<>>>,CUDA 运行时,默认流2.512.420.090.000.000.00
<<<>>>,自建非阻塞流2.392.300.090.000.000.00
cuLaunchKernel,驱动 API,自建流2.312.310.000.000.000.00
<<<>>> + cudaEventRecord(复用一个事件)2.842.690.130.000.000.02
cuLaunchKernel + cuEventRecord(复用一个事件)2.432.420.000.000.000.01
<<<>>> + 每次建、记录、销毁事件3.132.840.170.000.000.11
cuLaunchKernel + 每次建、记录、销毁事件2.712.620.000.000.000.09
SYCL nd_launch(不返回事件)3.002.260.040.420.070.20
SYCL q.parallel_for(返回事件)3.722.540.040.600.150.38

"程序自身"对原生写法主要是静态链接进程序的 CUDA 运行时(<<<>>> 走的那一层),对 SYCL 写法是头文件里内联进来的提交代码。"C/C++ 库"是 libc、libstdc++ 和动态链接器,主要是 malloc/free 和线程局部变量的访问。

所以表 1 里"MI210 上 SYCL 和原生差不多,A100 上差得多",是两件事叠在一起:SYCL 运行时每次提交的 CPU 代价(不返回事件约 0.7 µs,返回事件约 1.1 µs)在各平台都有,只在提交卡在 CPU 上的平台看得见;AMD 和海光上真正贵的是 SYCL 强加的那次事件记录,花在 GPU 端。两件事的修法也不同,见 11.2 节。

七、海光 DCU#

同样的探针在 DCU 上跑(run_dcu_hsa.sbatch、run_dcu_batch.sbatch、run_dcu_busy.sbatch、run_dcu_acpp_sig.sbatch)。DTK 的 HIP 运行时 dlopen 计算节点上的 /opt/hyhal/lib/libhsa-runtime64.so;DTK 目录里 .hyhal/lib 那一份在作业里看不到 GPU,lib/libhsa-runtime64.so 是断链(diag_dcu.sbatch)。HSA 探针要链接 /opt/hyhal/lib,而且 LD_LIBRARY_PATH 里不能有 $DTK/.hyhal/lib。

7.1GPU 端:每次 5.4 µs#

表 15 海光 DCU,每次迭代的时间(µs,空 kernel;out/dcu_hsa_.txt、out/dcu_hsa_batch.txt)
每次迭代放进队列的东西逐包敲门铃只敲一次门铃增量
kernel1.691.71
+ 屏障包(不带栅栏、不带信号)3.123.14+1.43
+ 完成信号(主机内存)5.625.71+2.57
同上,信号带中断6.216.30+0.59
屏障包 + 信号 + 设备范围 acquire5.635.710.00
屏障包 + 信号 + 设备范围 release5.625.710.00
屏障包 + 信号 + 系统范围 release6.206.30+0.59
屏障包 + 信号 + 系统范围 acquire6.356.52+0.81
屏障包 + 信号 + 两道系统栅栏(= HIP 的事件,BarrierValue 包)6.857.14+5.43
同上,用 BARRIER_AND 包6.947.14+5.43
BarrierValue + 信号,不带栅栏(= DisableSystemFence)5.425.53+3.82
信号直接挂在 kernel 包上(不加屏障包)4.174.27+2.56
kernel 包自己带系统 release2.282.30+0.59
kernel 包自己带系统 acquire2.442.44+0.73
两个 kernel3.383.42+1.71

增量的对照同表 5。

7.2栅栏:release 同样随脏数据增长,acquire 没有后续罚时#

7.3主机端:DTK 的中断信号和回调#

GPU 正忙着跑一个 2 ms 的 kernel 时,测各种调用在主机上多久返回:

MI210(ROCm 7.0)海光 DCU(DTK 26.04)0123456GPU 正忙时,单次调用在主机上花的时间(µs,中位数)直接写一个包并敲门铃(HSA)0.170.63kernel 启动1.751.30hipEventRecord1.625.67hipEventRecord(关掉中断信号)未测(ROCm 7.0 默认不用中断信号)1.96hipExtLaunchKernelGGL 挂停止事件2.672.32
图 7 GPU 忙时,单次调用在主机上花的时间。所有调用都没有在等 GPU(2 ms 的 kernel 还在跑就返回了),所以这是调用本身的 CPU 代价。DTK 的 hipEventRecord 要 5.7 µs,是 MI210 的 3.5 倍;关掉中断信号(设 ROC_SYSTEM_SCOPE_SIGNAL=0)后降到 2.0 µs。
表 16 GPU 忙时的单次调用(µs,中位数;out/*_hip_busy*.txt、out/*_hsa_busy.txt)
调用(GPU 正忙,中位数,µs)MI210DCUDCU,ROC_SYSTEM_SCOPE_SIGNAL=0
直接写一个 kernel 包并敲门铃(HSA)0.170.63—
直接写一个屏障包(两道系统栅栏 + 信号)并敲门铃0.160.60—
kernel 启动1.751.301.47
hipEventRecord(DisableTiming)1.625.671.96
hipEventRecord(DisableSystemFence)1.855.863.04
hipEventRecord(计时)2.215.715.27
hipEventQuery(记录之后)0.220.180.29
hipExtLaunchKernelGGL 挂停止事件2.672.323.56

结果是,DCU 上连续"启动 + 记录"时,主机端(约 7 µs:启动 1.3 + 记录 5.7)和 GPU 端(约 7 µs)差不多一样慢。上一阶段说"DCU 瓶颈在主机端"只说对了一半。

7.4只关中断信号,连续提交为什么快不了多少#

表 17 DCU:默认和 ROC_SYSTEM_SCOPE_SIGNAL=0 的对比(µs;out/dcu_acpp_sig.txt、out/dcu_hip*.txt)
DCU,每次调用(µs)默认ROC_SYSTEM_SCOPE_SIGNAL=0
原生 HIP:只启动1.762.00
原生 HIP:启动 + 记录事件7.447.04
原生 HIP:启动 + 记录(DisableSystemFence)5.735.68
原生 HIP:写 4 MiB 的 kernel + 记录9.759.75
AdaptiveCpp 普通提交(默认批量提交)7.737.25
AdaptiveCpp 即时提交(整个程序定义宏)7.687.02
AdaptiveCpp 即时提交 + 粗粒度事件(command group 属性)2.913.27
AdaptiveCpp 即时提交 + 粗粒度事件(队列属性)2.823.20
GPU 间隔:启动 + hipEventRecord7.687.04
GPU 间隔:hipExtLaunchKernelGGL 挂停止事件4.804.16

关掉中断信号,主机端省了 3.7 µs,但连续提交时被 GPU 端挡住:GPU 本身每次还要约 7 µs(kernel 加标记包)。所以原生启动加记录只从 7.44 变成 7.04 µs,AdaptiveCpp 普通提交 7.73 → 7.25 µs,即时提交 7.68 → 7.02 µs。要真正省下来,还是要去掉事件本身:即时提交加粗粒度事件每次 2.8~3.3 µs。

HIP 层面(表 11):DCU 上启动加 hipEventRecord 每次 7.6 µs,DisableSystemFence 6.2 µs,ReleaseToDevice、ReleaseToSystem 和默认一样;hipExtLaunchKernelGGL 挂停止事件,GPU 间隔 4.8 µs(关中断信号后 4.2 µs),比"启动再记录"的 7.7 µs 少约 3 µs。

小结(DCU)。GPU 端每次 5.4 µs:屏障包 1.43、主机内存信号 2.6、两道栅栏 1.4,没有 MI210 那种 acquire 后续罚时;release 的写回再多 1.7~4.5 µs(固定 256 个工作组写大数据时到 6.6 µs)。主机端 DTK 的 hipEventRecord 另要 5.7 µs,其中约 3.7 µs 来自中断信号和主机回调。和 MI210 共有的问题:ReleaseToDevice 没实现,信号放主机内存,HIP 现成的扩展启动路径没被使用。

八、真实访存 kernel 上的总开销#

前面的拆分大多用空 kernel。真实算子都要读写数据,事件的总开销会因此变化。图 8 把 HIP 事件让每次迭代多出的总时间,按 kernel 读或写的数据量画出来,H100 作对照。

MI210:hipEventRecord海光 DCU:hipEventRecordH100:cudaEventRecord(不计时)H100:cuStreamWriteValue32 带系统栅栏写主机内存读数据的 kernel03691264K256K1M4M16M写数据的 kernel03691264K256K1M4M16M64M比只跑 kernel 每次多出的时间(µs)kernel 读或写的数据量(对数刻度)
图 8 一次事件的总开销随 kernel 读写数据量的变化。AMD 两条线是"kernel + HIP 事件(手工构造的同样的包)"减去"只有 kernel";H100 两条线是"写 kernel + 不计时事件"和"写 kernel + 带系统栅栏写主机内存"减去"只有写 kernel"(只测了写 kernel)。逐包敲门铃,数值见表 18。
表 18 一次事件让每次迭代多出的时间(µs)
数据量MI210 读MI210 写DCU 读DCU 写H100 写 + 不计时事件H100 写 + 带栅栏写主机内存
64 KiB+9.11+5.79+5.22+5.42+0.01+3.55
256 KiB+9.37+5.92+5.21+5.61——
1 MiB+10.27+6.14+4.72+5.84+0.01+3.59
2 MiB+10.30+6.34+3.85+5.11——
4 MiB+11.08+7.98+3.10+4.970.00+3.70
8 MiB+11.62+6.42+3.12+5.64——
16 MiB+9.15+5.95+2.99+5.450.00+3.65
32 MiB—+6.26—+5.46——
64 MiB—+5.95—+5.71-0.01+3.93
表 19 信号和屏障包的代价随 kernel 长度的变化(µs;写 kernel,逐包敲门铃,out/*_hsa_sweep.txt)
写入量MI210 kernel信号挂在 kernel 包上,多屏障包 + 信号,多DCU kernel信号挂在 kernel 包上,多屏障包 + 信号,多
64 KiB1.32+2.47+3.411.73+2.44+3.89
1 MiB1.45+2.37+3.672.22+1.94+3.38
4 MiB2.82+1.08+3.704.780.00+1.66
16 MiB12.910.00+4.2015.220.00+1.61
64 MiB48.89+0.06+4.1956.26+0.01+1.63

表 19 有两点值得注意:

九、综合:为什么 AMD 和海光贵,NVIDIA 便宜#

表 20 三个平台上"记录一个事件"的对比
MI210(ROCm 7.0)海光 DCU(DTK 26.04)H100
事件在队列里是什么一个屏障包(BarrierValue),让队列停下来等它同左(DTK 的 HIP 是 AMD HIP 的分支)不让流停下来的完成报告(由实测推断)
栅栏系统 acquire + 系统 release同左普通事件不做
完成信号主机内存,GPU 经 PCIe 去改同左,而且带中断、挂主机回调—
L2系统 release 要写回脏行同左不需要写回
空 kernel,GPU 端多5.0~5.5 µs5.4 µs0.04 µs
访存 kernel,GPU 端多读 9.1~11.6 µs,写 5.8~8.0 µs读 3.0~5.2 µs,写 5.0~5.8 µs写 -0.01~0.01 µs(即 0)
主机端单次调用(GPU 忙)1.6 µs5.7 µs未测(连续调用时主机端只多 0.06 µs)
同类"重"操作的代价屏障包 + 主机内存信号 3.1 µs屏障包 + 主机内存信号 4.0 µs计时事件 3.0 µs,带栅栏写主机内存 3.6 µs

归结起来,AMD 和海光贵,是因为 HIP 把每一次 hipEventRecord 都按"最坏情况"来做:

  1. 按"要让队列停下来"来做。事件被做成一个设了屏障位的独立包,后面的 kernel 必须等它(以及它的信号写)完成。NVIDIA 的普通事件不阻塞流。
  2. 按"主机要立刻直接读所有数据"来做。每个事件都带系统范围 release,在 AMD 的缓存设计下意味着 L2 写回;还多带一道本不需要的系统 acquire,在 MI210 上让下一个访存的 kernel 多付约 3~5 µs。
  3. 按"主机要轮询这个信号"来做。信号放在主机内存里,GPU 每次都要经 PCIe 去改,并等改完;DTK 上还要触发中断、跑一个主机回调。

这三点在 HIP 的使用场景里不一定都错:原生 HIP 程序只在确实要和主机同步的地方记录事件,按最坏情况做也只付几次。问题在于 SYCL 运行时把它用在了"每个 kernel 一次"的场合,而这些事件绝大多数没有人等,或者只在同一块 GPU 上被等。同样的设计放在 NVIDIA 上不会暴露,因为 CUDA 的普通事件本来就便宜;所以在 NVIDIA 上开发和测试的 SYCL 代码,换到 AMD 和海光上才出现这笔开销。

十、哪些地方不必要或不合理#

按代价从大到小排:

  1. 每次记录都带系统范围 acquire。记录事件只是"发布前面的工作做完了",是 release;acquire 应该由等待的一方做(2.6 节)。在 MI210 上,它在空 kernel 上多 1.5~1.9 µs,下一个 kernel 要访存时合计多 4.9~6.8 µs,和读多少数据、数据原本在不在 L2 都基本无关,是最大的一块;DCU 上只多 0.6~0.8 µs。
  2. hipEventReleaseToDevice 写在文档里,却没有实现。头文件说它"记录事件时使用设备范围的 release",但 ROCm 7.0 的 Event::recordCommand 把它和 ReleaseToSystem 都归成默认值,在 MI210 和 DCU 上实测都和默认完全一样。结果用户只能二选一:要么两道系统栅栏全要,要么一道都不要(DisableSystemFence,主机可能看不到数据),没有"只要 release"或"只要设备范围"的选项。
  3. 每个事件都按"主机要直接读"来做 release。同一块 GPU 上的依赖(SYCL in-order 队列里每个 kernel 的事件、同卡两个流之间的等待)只要设备范围 release,实测代价为 0。系统范围 release 要把 L2 的脏数据写回显存,这是 AMD 的缓存设计决定的;但只有主机或别的设备真要直接读的时候,才需要付这笔钱(MI210 最多约 3 µs,DCU 最多约 4.5 µs)。
  4. 完成信号放在主机内存。ROCr 把所有信号都放在主机内存,连声明了"只有 GPU 用"的信号也一样。放显存每次省约 1.5 µs。代价是主机轮询会变慢,所以这是一个取舍;但对没人在主机上等的事件,这笔钱是白付的。
  5. DTK 默认给每个事件用中断信号和主机回调。GPU 端多 0.6 µs,主机端多约 3.7 µs。ROCm 7.0 在 MI210 上默认不这么做。
  6. HIP 自己有更便宜的现成路径,SYCL 运行时没用。hipExtLaunchKernelGGL(..., stopEvent) 把事件挂在 kernel 包上,不另插屏障包。GPU 上相邻 kernel 的间隔:MI210 3.84 µs("启动再记录"8.00 µs),DCU 4.2~4.8 µs(7.0~7.7 µs)。而且 kernel 一长,挂在 kernel 包上的信号几乎不花钱(第八节)。
  7. hipEventDisableTiming 在 AMD 上不起作用。带不带计时,放进队列的包完全一样,因为 HIP 的每个队列都开着时间戳采样。开不开采样实测没有差别,所以这一条不花钱,只是标志名不副实。
  8. SYCL 运行时每次提交的 CPU 代码偏重(不限于 AMD)。每次都构造并拆除 handler、command group 对象,在缓存里查 kernel,即使不返回事件也建一个内部 event_impl,A100 上约 0.7 µs CPU;返回事件再多 0.44 µs。它在提交卡在 CPU 上的平台(A100)上直接显现,在 MI210 上被 GPU 时间盖住(6.2 节)。

最少必要的代价#

按 2.6 节的"最少需要",一个事件在 AMD 上最少应该花多少?表 21 用同一硬件、同样的包,只换信号位置和是否单独插屏障包:

表 21 不同做法下,空 kernel 上一次事件让 GPU 多花的时间(µs)
做法(空 kernel,GPU 端每次多出的时间,µs)MI210海光 DCU
信号挂在 kernel 包上,信号放显存(粗粒度)0.921.05
单独一个屏障包,信号放显存(粗粒度)1.592.47
信号挂在 kernel 包上,信号放主机内存2.512.56
单独一个屏障包,信号放主机内存3.094.00
HIP 现在的事件(屏障包 + 两道系统栅栏 + 主机内存信号)4.985.43

前两行信号放在显存,只适合由 GPU 等待(或主机能接受较慢轮询)的事件;后两行信号在主机内存,主机可以直接轮询。都不带栅栏;需要主机直接读数据时,再加上随脏数据增长的系统 release(表 7)。

所以,按"最少必要"算,只由 GPU 等待的事件约 0.9~1.6 µs(DCU 1.0~2.5 µs),要让主机轮询的事件约 2.5~3.1 µs(DCU 2.6~4.0 µs)。HIP 现在实际要 5~11 µs,多出来的主要是 acquire 和不分场合的系统范围 release,DCU 上还有主机端的中断信号和回调。

十一、可以怎么改,对 SYCL 和转译器的意义#

11.1工具链层面的修法(都有对应的实测)#

表 22 各种修法下,一次事件让每次迭代多出的时间(µs)
改法改哪里MI210,读 4 MiB 的 kernelMI210,空 kernelDCU,空 kernel
现状(两道系统栅栏 + 主机内存信号)—11.15.0~5.55.4(主机端另 5.7)
SYCL 运行时改用 HIP 现成的 hipExtModuleLaunchKernel(..., stopEvent)DPC++ UR 的 HIP 适配层 / AdaptiveCpp 的 HIP 后端,不用改 HIP未测GPU 时间线上 1.4GPU 时间线上 1.8~2.4
事件只做 release(去掉 acquire)CLR submitMarker 的包头4.03.4~3.64.6
实现 ReleaseToDevice,SYCL 运行时的内部事件用它CLR Event::recordCommand;DPC++/AdaptiveCpp 建事件时传这个标志3.6~3.93.1~3.24.0
再把只给 GPU 用的信号放显存ROCr 的信号分配约 21.62.5
DTK:事件信号不带中断、不挂回调DTK 的 HIP 默认设置——GPU 端少 0.6,主机端少 3.7
SYCL 运行时不建事件(惰性事件、nd_launch、即时提交 + 粗粒度事件)DPC++ / AdaptiveCpp000

除"未测"和"约"之外都是实测:HSA 层用同一硬件、同样的包,只换包头和信号位置;HIP 层是真的调用。"约 2"是按空 kernel 上"信号放显存"省下的量推算的。范围的两端分别来自逐包敲门铃和只敲一次门铃两种测法。没有真的去改 CLR 重新编译;真正打补丁并在 SYCL 程序上验证,是下一步可以做的事(第十四节)。

11.2SYCL 运行时可以怎么做#

AdaptiveCpp 的粗粒度事件加即时提交、DPC++ 的 enqueue functions(nd_launch),都是在 SYCL 层绕开这一切。本次调研说明,即使在 HIP 层,按事件的用途选对栅栏,也能省掉大部分。

NVIDIA 上情况不同:nd_launch 去掉事件之后还剩约 0.5 µs,这是 SYCL 运行时每次提交的固定 CPU 代价(6.2 节)。它只能靠 command graph 这类批量提交摊掉(上一阶段测的 A100 上每个 kernel 0.98 µs,比原生还快),或者在运行时里给最常见的提交(in-order 队列、不要事件、没有 accessor)做一条更轻的路径。

11.3对我们转译器的规则#

表 23 转译规则(可以直接写进转译器或已验证原语)
后端规则条件
DPC++(HIP、CUDA、Level Zero)kernel<<<g,b,s,stream>>> 译成 syclex::nd_launch(q, nd_range, k);需要 local memory 时用 syclex::submit(q, cgf)队列是 in-order;源程序没有用这个 kernel 的完成事件
AdaptiveCpp构建时对整个程序加 -DACPP_ALLOW_INSTANT_SUBMISSION=1(不能只写在一个源文件里,否则反而变慢一倍),每个 submit 带粗粒度事件属性同上,且只用 USM;转译器要能控制整个程序的构建
源程序确实要等某个 kernel只在那一处要事件—
一次调用里有多个小 kernelDPC++ command graph 录一次、反复执行形状固定,参数不变

这件事和 paraTRANS 论文里发现的两个问题(相同 GPU 上多占 1 个寄存器导致占用率减半;DPC++ 在 MI100 上倾向高占用率导致 scratch 溢出)是同一类:移植后多出了源代码没有的代价,而且只在特定硬件上显现。不同的是,那两个出在编译器,这个出在运行时,而且一半在 SYCL 层(每次都建事件),一半在 HIP 层(事件本身做得太重)。

十二、和已有工作的关系#

以下是 2026-11-17 的粗查,没有逐篇细读。

本次调研和这些工作的不同之处在于:

  1. 把事件的代价拆到了包、信号位置、acquire、release 各自多少,并量化了 release 随脏数据增长、acquire 在 MI210 上的后续罚时;
  2. 发现 hipEventReleaseToDevice 没有实现,以及 HIP 已有的扩展启动路径没有被 SYCL 运行时使用;
  3. 海光 DCU(DTK)上的同类测量,包括主机端的中断信号和回调;
  4. 用 NVIDIA 做"功能对应"的对照,说明 NVIDIA 做同样重的事也不便宜,便宜的原因是普通事件不做这些事;
  5. 从 CUDA 自动转译(转译器或 LLM agent)的角度看这笔开销:翻译出的程序每个 kernel 都带一个源程序没有的同步对象。

十三、局限和待验证的问题#

十四、建议的下一步#

  1. 给 CLR 打补丁并端到端验证。改 submitMarker,让事件只做 release;在 Event::recordCommand 里实现 ReleaseToDevice。重新编译 HIP 运行时,在 MI210 上用 DPC++ 的 HIP 后端跑 Sol 的 router、qknorm 等小算子,看能省多少。
  2. 改 DPC++ 的 UR HIP 适配层,让 urEnqueueKernelLaunch 在要事件时改用 hipExtModuleLaunchKernel(..., stopEvent);同样在真实算子上测,并写程序验证 fence_dirty_ 的可见性疑点。
  3. DCU:在真实算子上测 ROC_SYSTEM_SCOPE_SIGNAL=0 加扩展启动的组合;把"每个事件都挂中断和回调"作为问题反馈给 DTK。
  4. 进一步定位 MI210 的 acquire 罚时:在下一个 kernel 内部用 s_memrealtime 打点,看时间花在取代码、取参数还是第一次访存上;有条件时在 MI300 上复测。
  5. SYCL 运行时的提交路径:在更新的 DPC++ 上复测 6.2 节的采样,看 handler、command group 和内部事件对象的开销有没有减少;DCU 上对 AdaptiveCpp 做同样的采样。
  6. 如果要单独成文:补 HeCBench 和 llama.cpp 这类真实程序的端到端数据,说明修法在完整应用上的收益。

附录 A 文件与复现#

目录 research/data/h100_dcu_20261110/analysis_v2/claude/launch_overhead/why_amd/:

表 24 文件
文件内容
README.md本次调研的文字结论(本报告的底稿)
kernels.cl、hsa_probe.cpp、hip_probe.cpp、cuda_probe.cu、counters_probe.cpp测量程序(表 2)
run_mi210_host.sh、run_mi210_more.shGPU62 宿主机上运行(run_mi210_more.sh <card> <modes>)
run_h100.sbatch、run_h100.sh集群 H100、GPU70 的 H100
diag_dcu.sbatch、run_dcu_hsa.sbatch、run_dcu_batch.sbatch、run_dcu_busy.sbatch、run_dcu_acpp_sig.sbatch、run_dcu_fine.sbatchDCU 作业(run_dcu.sbatch 是第一次、库路径错了的版本)
out/全部原始输出:mi210_*、dcu_*、h100_*、DTK 日志解码(dtk_hiplog/、dtk_sycllog/)、rocprof 计数器(pmc/)
../a100_why/A100 上 SYCL 提交开销的采样和驱动调用计数(6.2 节):程序、运行脚本 run_a100_why.sh、run_count.sh,原始输出 out/,说明 README.md
report/build_report.py、report/report_template.html、report/build_web.py本报告的生成脚本:图和表从 out/ 直接读取计算;build_report.py 用 Chrome 打印成 PDF,build_web.py 生成本网页

远端副本:GPU62 ~/claude-b9-analysis/launch_overhead/why_amd/,集群 ~/aqua/claude-b9-analysis/launch_overhead/why_amd/,GPU70 ~/claude-launch-overhead/why_amd/;A100 的采样在 GPU50 的 claude-b9-analysis/launch_overhead/a100_why/。

构建命令(摘自运行脚本):

# kernel(MI210 用 ROCm 的 clang,DCU 用 DTK 的 clang,-mcpu=gfx936)
clang -x cl -cl-std=CL2.0 -target amdgcn-amd-amdhsa -mcpu=gfx90a -nogpulib -O3 kernels.cl -o kernels_gfx90a.hsaco
# HSA 探针:MI210
clang++ -O2 -std=c++17 hsa_probe.cpp -I$R/include -L$R/lib -lhsa-runtime64 -Wl,-rpath,$R/lib -o hsa_probe_mi210
# HSA 探针:DCU(必须链接计算节点上的 /opt/hyhal,LD_LIBRARY_PATH 里不能有 $DTK/.hyhal/lib)
clang++ -O2 -std=c++17 hsa_probe.cpp -I$HI -L/opt/hyhal/lib -lhsa-runtime64 -Wl,-rpath,/opt/hyhal/lib -o hsa_probe_dcu
# HIP 探针(DCU 上要 -std=c++17)
hipcc -O3 --offload-arch=gfx90a hip_probe.cpp -o hip_probe_mi210
# NVIDIA
nvcc -O3 -arch=sm_90 cuda_probe.cu -lcuda -o cuda_probe_h100

运行:./hsa_probe_mi210 kernels_gfx90a.hsaco [模式],模式为空(主表与时间线)、sig、sweep、wfine、rfine、l2、cold、acq、busy;加 BATCH_DOORBELL=1 只敲一次门铃。wfine/rfine 用 FINE_LIST(KiB,逗号分隔)指定数据量,FINE_GS=1 换成固定 256 个工作组的循环 kernel。./hip_probe_mi210 [log|busy]。AQL 日志:AMD_LOG_LEVEL=4 AMD_LOG_MASK=0x8。DTK 日志:HIP_LOG_LEVEL、HIP_LOG_OUTPUT_PATH,再用 $DTK/.hyhal/NanoLog/bin/hiplogdump sort <文件> 解码。

重新生成本报告:python3 -I report/build_report.py <输出.pdf>(需要 macOS 上的 Google Chrome);--check 只打印推导出的数字。网页版:python3 -I report/build_web.py <输出.html>。

附录 B 术语表#

术语含义
HSA、ROCrAMD GPU 的底层运行时接口(Heterogeneous System Architecture)和它的实现 ROCr(libhsa-runtime64)
CLR、ROCclrHIP 运行时的实现(clr 仓库),HIP 调用在这里翻译成 AQL 包
DTK、hyhal、libgalaxyhip海光的软件栈;hyhal 是它的 HSA 层,libgalaxyhip 是它的 HIP 库(AMD HIP 6.3 的分支)
AQL 包写进 GPU 队列的 64 字节命令,kernel 派发包或屏障包
CP命令处理器,GPU 上按顺序处理队列里的包的部件
门铃(doorbell)主机写好包后通知 CP 来取的寄存器
屏障位包 header 里的一位:设了它,这个包要等前面的包都完成才开始
BARRIER_AND、BarrierValue两种屏障包:前者等若干信号都为 0,后者(AMD 扩展)等一个信号满足条件
完成信号包完成时 CP 修改的内存中的整数,供主机或其他包等待
acquire / release获取 / 发布:读别人数据前作废过期缓存;让自己的写入对别人可见
设备范围 / 系统范围栅栏的作用范围:同一块 GPU(agent)/ 包括主机和其他 GPU(system)
buffer_wbl2、buffer_invl2GFX90A 上写回 L2 脏行、作废 L2 行的指令
MTYPE RW / NCGFX90A 的内存类型:RW 用于本卡显存(L2 中可脏),NC 用于非本地内存
细粒度 / 粗粒度内存主机和 GPU 能否在 kernel 运行期间细粒度地看到彼此的写入;粗粒度只在同步点保证一致
URUnified Runtime,DPC++ 的后端适配层
in-order 队列按提交顺序执行的 SYCL 队列
粗粒度事件、即时提交AdaptiveCpp 的两个扩展:事件只和整个流同步(不建后端事件);提交时直接调用后端,不经后台线程
enqueue functions、nd_launchDPC++ 的扩展,提交 kernel 而不返回事件
s_memrealtime、%globaltimerAMD 和 NVIDIA GPU 上的恒定频率时钟,用来在 GPU 上打时间戳

附录 C 调研过程记录与更正#

C.1过程#

  1. 读 CLR 源码、抓 AQL 日志,确定 hipEventRecord = BarrierValue 包(系统/系统)+ 主机内存信号;发现 ReleaseToDevice 被忽略、DisableTiming 不改变包。
  2. 写 hsa_probe,在 MI210 上逐项拆分;发现空 kernel 上栅栏的钱主要在 acquire,release 只在写数据时明显。
  3. 为解释 acquire 在读 kernel 上的大代价,加冷热数据、按页跨步、插空 kernel 三组对照,排除"数据被清出 L2"和"后台操作"两种解释。
  4. H100 对照:普通事件几乎为 0;计时事件和带栅栏写值 3~4 µs,但不随脏数据增长。
  5. DCU:先修好库路径;HSA 层重做拆分;为区分主机端和 GPU 端,加"只敲一次门铃"和"GPU 忙时单次调用"两种测法;解码 DTK 日志,找到中断信号和回调;测 ROC_SYSTEM_SCOPE_SIGNAL=0 的效果。
  6. 写本报告时,从原始输出重新计算了所有图表数字,补上了"kernel 越长,挂在 kernel 包上的信号越不花钱"这一观察(第八节)。
  7. 读表 1 时发现 A100 上 SYCL 不管返不返回事件都比原生慢,补做了 A100 上的进程内采样和驱动调用计数(6.2 节)。
  8. 看图 4 时发现:MI210 的拐点只是 2 的幂采样点,DCU 的曲线看起来没有拐点。按 1 MiB(MI210 另有 0.5 MiB)加密重测,并加了固定工作组数的 kernel 和冷热读对照;又查了 Linux 驱动和 AMD 文档里有没有写回策略的说明(5.3 节)。

C.2走过的弯路#

C.3对之前说法的更正#

下面第 3~5 处是写本报告时从原始输出重新计算发现的,第 6~8 处是报告写好后补充的;涉及的 README 都已同步改正。

本页由 report/build_web.py 从同一份正文和 out/ 里的原始输出生成,图表数字与 PDF 版一致。把鼠标移到图上可以看每个点的数值;正文里提到的图和表,悬停可以预览,点击可以跳转。