← 全部报告

Qwen 与 Sol 的失败原因复核及改进方法

2026-11-18 整理版,11-20 补入第 8 节。对象是 b9(v2 harness)的正式运行:A100 上 Sol 14 个;MI210 上 Sol 14 个、Qwen 14 个(另有 2 次被重排的尝试);DCU 上 Sol 14 个、Qwen 14 个;以及 v3 harness 下 Qwen 的 28 次重跑(b10,第 8 节)。

这一版的改动:

这份报告独立于 11-15 的《b9 模型对比与性能迁移失败分析》。结论都重新读过交付代码、agent 自己写的 NOTES/DECISIONS、完整会话和计分文件;那份报告里标"待验证"的几条归因,这次用实验做了验证。两份报告的关系见附录 A。

1. 结论

  1. Sol 保持率低于 1,最大的一类原因是一行提交代码,已经实验证实。 目标平台的 SYCL 运行时,每次普通提交都要多付一笔固定开销。

  2. 这个写法 Sol 自己会,只是每次运行都要重新发现。 MI210 和 DCU 各 14 次运行里,它各有 3 次独立发现并采用了这个写法,其余 11 次没有;同一个算子在一个平台上发现了,换个平台又没发现。DCU 的 fattn 也是这样:mask 搬进共享内存、提前取 K/V 这两招,Sol 在 MI210 上自己用了,在 DCU 上没用。这是"经验要带条件保存并跨运行复用"(M4)目前最直接的证据。

  3. Sol 是提前收工,不是时间不够。 42 次 Sol 运行全部是它自己宣布完成的。MI210 上 router 用了 49 分钟、qknorm 用了 35 分钟就停了,停的依据是"比自己的初版快了多少"。任务里没有任何性能参照,它不知道自己还低于源代码的水平。

  4. Sol 的低分里,有一部分是丢了源代码的机制,或者选错了机制。

  5. Qwen 的崩溃是过程问题叠加知识缺口,两个平台是同一种模式。 有三个环节:

    结果是,MI210 上 bnb、mmq、fattn、dsv3 交付的都是最早那个朴素版本,和 Sol 差 8~315 倍;DCU 上 14 个只有 8 个通过,能算保持率的 6 个在 0.002~0.45。

  6. 一行写法可以决定一次运行能不能交出解。 DCU 上 Qwen 的 router:AdaptiveCpp 把 kernel 在主机端和设备端各编译一遍,它的写法让两遍捕获变量的顺序不同,设备端拿到错位的指针。它把由此产生的崩溃当成编译器和硬件的 bug,追了 100 分钟。取它第 17 分钟的版本:原样运行,33 个形状全部崩溃;只加一行固定捕获顺序,33 个形状加交替检查全部通过。

  7. 有几类失败不该算在模型头上,已在 v3 harness 里修掉。

    用旧版本重新计分证实,MI210 的 gdn 和 DCU 的 bnb 此前都有过能通过全部检查的版本,是在截止那一刻把交付文件改坏的。v3 下的重跑结果见第 9 条。

  8. "通过计分"不等于正确。 Qwen 在 MI210 上交付的 topk_fp32 对负数的排序是反的,只因为测试数据的边界恒为正才通过。v3 的换内容检查已经加入全负、大量并列的数据;用它重评,b9 两个平台上 Qwen 的 topk_fp32 都不通过,Sol 的 top-k 全部通过(8.2)。

  9. v3 harness 下重跑 Qwen(b10):测量问题去掉了,失败形态没变(第 8 节)。 MI210 14/14 通过,比 b9 快(两次都通过的算子上总时间约为 b9 的一半);DCU 仍是 8/14,失败项换了一批,通过的反而更慢。截止时间不再算错,但 DCU 失败的 6 个里有 4 个从头到尾没有正确版本。两个新发现:

2. 证据和口径

3. 两个模型怎么干活

3.1 过程统计

时间从控制器启动算起。

Sol(MI210) Qwen(MI210) Sol(DCU) Qwen(DCU)
第一个全部通过列出形状的版本 1~3.5 分钟(topk 两项因为分批测试,记录上更晚) 10~112 分钟;kimi、topk_bf16、gdn(重排后)始终没有 2~35 分钟,14 个里 9 个在 5 分钟内 18~98 分钟;6 个始终没有
矩阵单元 bnb、equi、fattn、lightning 的第 1 分钟初稿就有 没有一个初稿含矩阵核;需要它的 6 次里走通 1 次 需要它的 8 个算子全部用上,第 1.4~5.4 分钟就搜到或用上 8 个一次都没用上
结束方式 14/14 自己宣布完成,用时 35~118 分钟 6/14 被截止时间打断 14/14 自己宣布完成,用时 37~105 分钟 10/14 被截止时间打断
上下文交接次数 合计 2 次 合计 62 次(每次运行 2~6 次) 合计 2 次 合计 30 次
交付版本 ÷ 自己测到过的最好版本 1.00~1.04 多数 1.00;topk_fp32 是 7.1,qknorm 1.16 没统计 没统计
独立计分全部通过 14/14 11/14 14/14 8/14

Sol 的做法是先在一两分钟内交出一个完整可测的版本,然后在它上面一项项换机制、调参数,每一步都留着能退回的版本。它从初版到终版的提升是 2~14 倍(bnb 11 倍、gdn 14 倍、fattn 8 倍、router 2.8 倍)。

Qwen 有两种开局。先写基线再优化的几次(lightning、qknorm、equi_f64、topk_moe),后续也能提升 2~28 倍,结果相对好。先去探测矩阵核的几次(bnb、mmq、fattn、gdn),预算在有基线之前就花掉了一大半。

DCU 上这个差别更明显。Sol 先写最直接的版本,编译报什么错就查什么。Qwen 先研究平台(带宽、FMA 峰值、汇编指令、运行时内部),再写一个一开始就带优化的"基线"。Qwen 在 DCU 上自己结束的 4 次全部通过;被打断的 10 次里有 4 次通过,是因为打断时工作区里恰好是能通过的版本。

3.2 逐算子结果

MI210。 "时间倍数"是两者都通过的配置上,Qwen 时间之和 ÷ Sol 时间之和。

算子 保持率 Qwen / Sol 时间倍数 Qwen 的主要问题
bnb_gemm4 0.01 / 2.57 315× 4.1、4.2、4.3;非矩阵核的快版本有 bug,归咎编译器
mmq 0.02 / 2.16 127× 4.1、4.2、4.3
fattn_mma 0.01 / 1.26 172× 4.2、4.3;设计里没有任何跨 lane 协作
topk_bf16 失败 / — 704× 4.8
topk_fp32 — / — 25× 4.7、4.8
kimi_attn_res 失败 / — 15× 4.8
lightning_indexer 0.66 / 5.93 9.1× 用上了矩阵核,但只覆盖一条路径,数据复用弱
dsv3_a_gemm 0.12 / 1.01 8.4× 4.2(布局)、4.6
router_gemm 0.11 / 0.82 7.2× 自己的 5 个 bug 修到 69 分钟;每个 expert 把激活重读一遍;没用 FP32 矩阵核
topk_moe 0.43 / 1.95 4.5× LDS 归并树(多次屏障)对 Sol 的寄存器内选择;没用省开销的提交
equi_f64 0.25 / 1.01 4.1× 4.5
equi_f32 1.04 / 2.82 2.7× 任务表述歧义,读成禁用全部 MFMA
qknorm_rope 0.73 / 0.94 1.3× 接近;没用省开销的提交
gdn 失败 / 2.23 — 第一次:保住了分块算法、没用上矩阵核,0.17;重排后:4.6

有同卡原生对照、Qwen 也有结果的 10 个算子里,Qwen 只有 qknorm 快于原生实现。Sol 在 11 个有原生对照的算子上,按时间之和都快于原生(个别形状除外,见 5.3)。

DCU。 DCU 的工具链和 MI210 不同:SYCL 实现是 AdaptiveCpp(HIP 后端),编译器是海光 DTK 26.04 自带的 LLVM 17 分支,目标是 gfx936。 "第一个全通过的版本"指 agent 自己的测试记录里,第一个让全部列出形状都通过的可执行文件出现的时间。

算子 独立计分 保持率 Qwen / Sol 时间 ÷ Sol 第一个全通过的版本(分钟) 结束方式
fattn_mma 13/13 0.002 / 0.36 199× 50 被截止打断
topk_moe 14/14 0.03 / 0.77 26× 76 被截止打断
gdn 8/8 0.22 / 2.09 9.5× 98 被截止打断
dsv3_a_gemm 32/32 0.22 / 0.79 3.6× 52 自己结束(103 分钟)
qknorm_rope 18/18 0.32 / 1.28 4.1× 88 被截止打断
equi_f64 6/6 0.45 / 1.04 2.3× 21 自己结束(108 分钟)
topk_fp32 8/8 无源端参考 1.9× 18 自己结束(89 分钟)
kimi_attn_res 7/7 无源端参考 1.4× 76 自己结束(83 分钟)
bnb_gemm4 0/18,结果全 0 — / 1.14 — 没做过完整测试;第 58 分钟起的版本其实全对(4.7) 被截止打断
topk_bf16 5/15 无源端参考 通过的 5 个上是 16× 从未 被截止打断
equi_f32 2/18 — / 4.25 — 从未 被截止打断
mmq 1/20 — / 0.70 — 从未 被截止打断
lightning_indexer 0/11 — / 3.29 — 从未 被截止打断
router_gemm 编译失败 — / 0.82 — 从未;第 17 分钟的版本只差一行(4.4) 被截止打断

8/14 通过,可算保持率的 6 个没有一个到 1。占卡 26.4 小时,按固定费率折算 49.5 美元;Sol 是 17.4 小时、35.3 美元。

同一个模型在同一个算子上,换个平台结果并不稳定。equi_f32、lightning、mmq、router、bnb 在 MI210 上通过、在 DCU 上失败;kimi 相反;gdn 在 MI210 上正式的那次是编译失败,在 DCU 上通过。都通过的几项里,qknorm 从 0.73 降到 0.32,topk_moe 从 0.43 降到 0.03,fattn 从 0.01 降到 0.002;dsv3(0.12 → 0.22)和 equi_f64(0.25 → 0.45)有所提高;topk_fp32 相对 Sol 的倍数从 25× 变成 1.9×,MI210 上那个负数排序的错误在 DCU 的解里没有出现。

4. Qwen 的问题出在哪

每节先讲 MI210,再讲 DCU。

4.1 第一个正确版本来得太晚,或始终没有

算子 第一个全通过版本(分钟) 交付的是不是它
mmq 112 是(朴素标量)
fattn 102 是(最大形状一次调用 2.3 秒)
router 83 之后提升了 3 倍
dsv3 74 是(标量)
bnb 57 是(36 行,逐元素点积)
topk_fp32 53 是(中间有过快 7 倍的版本,见 4.7)

mmq 的例子最能说明问题。它前 66 分钟连朴素版本都没有:约 45 分钟花在"破解 Q4_K 的排布"上,而这个谜是它自己的主机端校验程序造出来的(一个下标写错,只写了 256 个值里的 64 个;一个 FP16 舍入函数指数差 1)。排布其实就是标准的。Sol 在同一个算子上 3 分钟就有了遵守量化合同的完整版本。

DCU 上更严重:6 个算子到截止都没有一个正确版本;通过的 8 个里,kimi、topk_moe、qknorm、gdn 的第一个正确版本在第 76~98 分钟。时间去向主要是两种。

topk_moe 是另一种情况。它第 76 分钟通过,此后每次调用都固定在 0.28~0.30 ms,从 1 行到 512 行都一样(Sol 是 9~15 µs)。剩下 44 分钟,它先后怀疑 expf、冷缓存、时钟频率,都没有找到原因。我也没有定位。

4.2 矩阵单元:缺的是一个写法或一个名字

MI210:设备端保护。

这套工具链里调用矩阵核的可用写法是:

using v4h = _Float16 __attribute__((ext_vector_type(4)));
#ifdef __SYCL_DEVICE_ONLY__
  acc = __builtin_amdgcn_mfma_f32_16x16x16f16(a, b, acc, 0, 0, 0);
#endif

SYCL 的单源编译会把 kernel 代码在主机端也编译一遍,不加设备端保护,主机那一遍就报 mai-insts 相关的错。Sol 的初稿从第 1 分钟起就这样写。Qwen 在 6 次需要矩阵核的运行里只走通 1 次:

运行 遇到主机端报错后怎么做 结果
lightning 先有基线;用 #error 探针查清"设备编译也是主机三元组加 __SYCL_DEVICE_ONLY__" 24.5 分钟 builtin 跑通,交付用上了矩阵核
bnb 一开始就选内联汇编,调寄存器约束 42.8 分钟得出"这块芯片的 AGPR 数据通路坏了,浮点 MFMA 确定不可用"
mmq 读成"需要打开目标特性",转去内联汇编;84.5 分钟意识到报错来自主机端,却把保护加在汇编路径上 111.6 分钟的交接写着"MFMA 路径确定走不通"
fattn 读成"SYCL 后端不会自动打开 mai-insts",转内联汇编,结果全是 NaN 放弃矩阵核
gdn(重排后) "这个分支里 builtin 没有实现代码生成",22.6 分钟又发现能用,随后被别的错误结论打断 没用上
dsv3 找到了 builtin,但解码片段布局花了约 45 分钟 75 分钟 MFMA 版本正确,但访存是串行的,不比标量快,没交付

gdn 第一次尝试在第 100 分钟发现 joint_matrix 接口在 gfx90a 上可用,随即因输出超限被调度重排。重排后的运行没有任何记忆,又从头探测了一遍。

同一条 mai-insts 报错,在两个平台上含义相反。MI210 上是"主机端那一遍不认识这条 builtin",加设备端保护就行。DCU 上,标准的 __builtin_amdgcn_mfma_* 在设备端编译也报这个错,因为那里真的没有这条指令,要用海光自己的 __builtin_amdgcn_mmac_*。所以这件事不能靠记一句"报这个错就加保护"解决,要靠能区分主机编译和设备编译的探针。

DCU:海光的矩阵 builtin。

Sol 的处理以 bnb 为例。第 1.4 分钟的初稿用标准 builtin,编译报错;第 1.8 分钟在 DTK 的头文件目录和 LLVM 的 intrinsic 定义里搜 mmac|mfma;第 2.0 分钟看到 mmac 一族的定义;第 2.2 分钟替换进代码并运行;第 3 分钟读厂商自带的 du_mma.hpp 确认操作数排布。需要矩阵单元的 8 个算子(bnb、dsv3、equi_f32、equi_f64、fattn、gdn、lightning、mmq)它每次都把这个过程重新走了一遍,第一次搜到或用上都在第 1.4~5.4 分钟。

Qwen 在这 8 个算子上一次都没用上:

运行 它做了什么 它的结论
lightning 第 1.7 分钟的探针里,编译器的报错是:未声明的标识符 __builtin_amdgcn_mfma_f32_16x16x16bf16,是否想写 __builtin_amdgcn_mmac_f32_16x16x16bf16。它没有跟这条提示,转去试汇编助记符 第 4.9 分钟:"汇编器里没有 MFMA,只能靠向量 FMA"
bnb 汇编助记符被拒;第 13.8 分钟在厂商 BLAS 的 kernel 名里看到 MMAC,猜到是矩阵指令,转去反汇编库文件 第 22.9 分钟:"厂商自己的 GEMM 是纯标量的,这个 ISA 没有张量核"
dsv3 约 40 分钟试汇编助记符和目标特性开关 第 50.3 分钟:"全部被特性开关挡住,固定的构建脚本打不开,确定不可用"
equi_f32 汇编助记符被拒 第 5.9 分钟:"gfx936 没有矩阵核";之后到第 92 分钟都在研究手写汇编的打包 FMA 和 LDS 指令
gdn 试汇编助记符 第 6.8 分钟:"只有 K=4 的老式变体,最多快 2 倍,不值得"
equi_f64 第 4 分钟在 HIP 头文件里搜 MFMA 没搜到,搁下;第 60 分钟又提了一次,凭推测认为"多半没有" 交付标量 FMA,0.45(Sol 用 FP64 的矩阵 builtin,1.04)
fattn、mmq 没有探测 —

两者的差别在找法。Qwen 找的是汇编助记符(v_mfma_*),Sol 找的是编译器 builtin 和厂商头文件。同一套工具链里,汇编器拒绝这些助记符,builtin 却能用。"绕开 builtin、直接写内联汇编"也是 Qwen 在 MI210 上撞墙的那条路。

4.3 自己的错被读成平台的 bug,交接把它固化

MI210。

运行 探测或校验程序的问题 由此得出的错误结论
mmq 回传只拷了四分之一的字节,其余是初始哨兵值 "MFMA 结果全错"
mmq 4.1 节的两个校验 bug "Q4_K 的列被置换过"
bnb 探针里矩阵行下标越界;把整数直接当 BF16 位模式 "所有浮点 MFMA 读到的都是 0"
dsv3 探针用了全 1 的 A,分辨不出布局 交接里带着一份错的片段布局
fattn local_accessor 没按这套工具链要求的方式(在命令组的 handler 里)构造 "这个工具链不能用 LDS",67 分钟后才被自己推翻
fattn 位模式检查得到"2.0 → 0x0000" "half 不是 IEEE 格式"(之后没有再验证;它在 gdn 运行里承认过同类检查公式写错)
router 同一个 wave 里经 LDS 做跨 lane 归约 "编译器把读提到写前面了,是误编译"

最后一条值得多说一句(这是我的解释,没有重放验证)。按 SYCL 的语义,每个 work-item 是独立的线程;自己写 l[lane]、再读 l[lane^1],在编译器看来是两个不相干的地址,把读提前是合法的。CUDA 源码里用的是 warp shuffle,不经过内存。Sol 在同样的位置用的是 DPP 或 ds_bpermute builtin,或者 LDS 加屏障。Qwen 没找到可用的跨 lane 原语,于是 fattn 设计成"每个 lane 各算各的",router 用原始指令编码手写等待,这两种设计本身就慢。bnb 和 kimi 的记录里也各有几条归咎"误编译"的结论,我没有逐条核实。

每次上下文交接,结论会被写进摘要,证据不会。"MFMA 确定不可用""没有 LDS"这类话在下一段里就成了前提,没有人再去查。Qwen 平均每次运行交接 4 次以上。

DCU。 这个模式在 DCU 上更重。下表的"实际原因"是我读快照代码确认的,或者是它自己后来推翻前一个结论时写下的。router 的情况单独放在 4.4。

运行 实际原因 它当时的归因 耗时
qknorm BF16 和 float 互转的辅助类型写成了 struct(两个独立字段),应为 union。从第 17 分钟的第一版一直带到第 82 分钟 "运行时在传递 kernel 参数时把指针改写了,属于闭源运行时,修不了";改用 memcpy 后通过,交付文件的注释是"这个版本的 acpp 会误编译 struct/union 位转换,已证实" 第 17~87 分钟
topk_bf16 自己的检查程序期望值算错(第 96 分钟发现);收集并列元素时少加了基址(第 115 分钟发现) "LDS 上的原子操作是坏的""ds_swizzle 是坏的""DTK 的编译器会打乱连续的 shuffle" 第 18~120 分钟
lightning(第 62 分钟之后) 对 void* 做指针运算,步长成了字节(第 78 分钟自己发现);每个线程只算一个头,却要对全部头求和(第 114 分钟自己发现) "真正的编译器 bug:对表达式的写法敏感""第二条 128 位加载流会被误编译" 第 62~120 分钟
fattn 工作组数写成了工作项数(第 41 分钟发现,原话是"根本不是编译器 bug");之后开发的 v2 到截止也没调通 "编译器跨屏障缓存了局部内存的读" 第 11~41 分钟

这张表和 4.4 合起来是一个模式:自己代码里的一个错,被读成平台的 bug;为了绕开这个并不存在的 bug,设计越改越复杂;交接又把"平台有 bug"写成前提。我的理解是,DCU 的资料少,模型更容易相信"这里的工具链有问题",所以这个模式比 MI210 上更重。我核实过的几条"编译器、运行时或硬件有 bug"的结论(router、qknorm、lightning 的前半段、fattn、topk_bf16 的一部分)都不成立;没有逐条核实的还有一些,不能排除这套工具链确有个别问题。

4.4 两遍编译和捕获顺序:DCU router 的 100 分钟(已重放证实)

AdaptiveCpp 的 HIP 流程把同一个 kernel lambda 编译两遍。主机端那一遍生成闭包对象,把捕获的变量按顺序放进去;设备端那一遍按自己看到的布局去读。隐式捕获([=])的顺序,在 clang 里由变量在 lambda 体中第一次出现的位置决定(C++ 标准没有规定),所以两遍看到的 lambda 体必须以同样的顺序用到同一组变量。这段机制是我的解释;下面的重放验证的是它的推论:只固定捕获顺序,崩溃就消失。

Qwen 的 router kernel 是这样写的:

q.parallel_for(range, [=](sycl::nd_item<1> item) {
#if ACPP_LIBKERNEL_IS_DEVICE_PASS_HIP
    ... 先用到 w(权重),再用到 a(激活),最后 out      // 设备端
#else
    ... 先用到 a,再用到 w,最后 out                    // 主机端备用实现
#endif
});

设备端于是把 a 的地址当成 w 来读。w 有几兆字节,a 只有几百 KB,读越界,VMFault。

时间线:第 13.6 分钟写出 kernel,第 21.1 分钟第一次运行就崩溃。之后它的归因依次是:向量类型的加载有问题 → hipSYCL 的代码生成 bug(第 41 分钟)→ 64 位加载被合并后目的寄存器和地址寄存器重名(第 56 分钟)→ 立即数偏移破坏了地址高位(第 81 分钟)→ "这块海光硬件对加载地址的采样偏晚"(第 115 分钟)。它为此改用手写内联汇编做加载和等待。到截止时没有一个形状跑通过,交付文件的头部注释把这些"硬件隐患"当作本次确立的事实写了进去。

重放。 从快照里取第 17.9 分钟的 solution.cpp 和 kernel.h(就是第 21.1 分钟崩溃的那一版,头文件并进单个文件),在 DCU 上用官方计分器:

版本 结果 时间之和 保持率 时间 ÷ Sol
第 17.9 分钟的版本,原样 33 个形状全部崩溃 — — —
同一版本,只在 lambda 开头加一行 33/33 通过,交替检查 12/12 3.16 ms 0.15 5.7×
交付版(官方) 编译失败 — — —
交付版,头文件并入 仍然编译失败 — — —

加的那一行是 if (false) { (void)w; (void)a; (void)out; },作用只是让两遍编译都按同一个顺序捕获这三个指针。

也就是说,Qwen 在第 14 分钟就写出了一个正确的 router kernel。按这个版本,它在第 20 分钟就能有一个保持率 0.15 的通过版本,比它在 MI210 上用 97 分钟交付的 0.11 还高,后面还剩 100 分钟。

交付版"编译失败"的直接原因是另外两件事:kernel 被拆到了 kernel.h,而计分只取 solution.cpp;把头文件并进去以后,文件末尾一行没改到的备用调用触发了它自己写的静态断言。

同一个坑,lightning 那次是 Qwen 自己找出来的(那次是主机端 lambda 体为空,什么都没捕获)。从加上设备端保护后第一次崩溃(第 18 分钟)到找到原因(第 62 分钟)用了 44 分钟,找到后用的正是上面这一行的写法。但在找到之前,它已经把崩溃依次归因于 __shared__、local_accessor 和跨函数传指针,第 52 分钟的交接结论是"这套运行时的局部内存不可靠",设计因此改成完全不用 LDS。找到真正的原因后,这些结论没有回头重验,交付文件的注释里仍然写着"局部内存和 __device__ 辅助函数在这套工具链里都不可靠"。Sol 在 DCU 上的 14 个解有 13 个在用 local_accessor。

Sol 的写法天然避开了这个坑:设备专用的 builtin 包在很小的叶子函数里,主机端分支直接返回输入;kernel lambda 本身在两遍编译里完全一样。equi_f32 那次,它第 1.4 分钟的初稿就是这个结构。

4.5 凭记忆的硬件事实,不验证

equi_f64:Qwen 在第 1.5 分钟写下"MI210 的 MFMA 不支持 FP64,MI300 才有",此后一次探测都没做。实际上 gfx90a 有 mfma_f64_16x16x4f64。Sol 用它做到 11.4 TFLOPS;Qwen 用标量 FMA 写了一个很规整的 CUDA 式分块 GEMM(LDS 双缓冲、防 bank 冲突的重排都有),停在 2.65 TFLOPS,保持率 0.25。源代码的 FP64 张量核就这样被整个抹掉了。

4.6 截止时间被重新起算(harness 的问题,v3 已修)

启动提示是"The deadline is 120 minutes from now"。上下文交接后,这句话原样留在历史开头,模型把"now"理解成交接后的当下。

运行 真实截止(UTC) 运行后期认为的截止
MI210 bnb 20:33 21:29
MI210 mmq 09:39 10:35,后来是 11:31
MI210 gdn(重排后) 18:10 19:48
MI210 dsv3 03:59 05:00,后来是 05:36
DCU bnb 16:01 16:40(到 16:00 还写着"离截止还有 40 分钟")
DCU gdn、qknorm 18:02、18:01 18:43、18:47
DCU fattn、kimi 20:03、20:03 20:55~21:00、20:47
DCU topk_moe 16:02 17:42(第 100 分钟交接后)
DCU equi_f32 21:47 23:34(第 107 分钟交接后)
DCU topk_bf16 23:29 第 115 分钟认为"还有约 2 小时"

后果很直接。MI210 的 gdn 在真实截止前约 2 分钟,以为还剩 100 分钟,把刚验证的新 kernel 拼进交付文件,编译报错,没来得及恢复。DCU 的 bnb 以为还有 40 分钟,正在交付文件上调试一个结果全 0 的新版本时被打断,而它第 58 分钟起的版本是全对的(4.7)。MI210 的 fattn 那次是 Qwen 自己查进程树看到 timeout 7200 才纠正过来。

DCU 的 equi_f32 把这个机制记录得最清楚。第 107 分钟的交接摘要里写着正确的截止时间和"只剩 5~8 分钟"。接手的那一段读到提示里的"from now"之后的推理是:截止是从现在起 120 分钟,摘要里的时间是上一段的旧信息,所以还有约 2 小时。topk_bf16 是另一种错法:环境信息里写的时区是 Asia/Shanghai,而机器上 date 给的是 UTC,它在截止前 2 分钟把摘要里正确的"23:27"当成了北京时间。

DCU 上 14 次 Qwen 运行有 10 次被截止时间打断,8 次在后期用的是错的截止时间。不过结果被它直接决定的只有 bnb;其余 5 个失败项在截止前本来就没有正确版本。Sol 几乎不交接,所以没受影响。

这一条必须在比较模型能力之前修掉。v3 harness 已经改为在提示里给带时区的绝对截止时刻,并提供 ./time_left.sh(7.5)。

4.7 交付的不是已验证的版本

有三次运行交付的不是自己最好的已验证版本。每次运行在 agent 看不到的地方都有工作目录快照,取出旧版本用官方计分器重新计分,可以验证这一点。

MI210 的 topk_fp32:第 73 分钟有一个 5/5 通过、合计 8.69 ms 的版本。之后它在原文件上继续改,连续 4 个版本全错,第 90 分钟决定"恢复已知可用的备份",而备份是重写之前存的旧版。最后交付 62.1 ms,比自己的最好版本慢 7.1 倍。Qwen 与 Sol 在这个算子上 25 倍的差距里,有 7 倍来自这一步。

DCU 的 bnb:第 46 分钟朴素版本正确;第 58 分钟 v2 正确(它自己抽测过 5 个列出形状);第 102 分钟 v3 正确、快了 2.5 倍;第 112 分钟写出更快的 v4,结果全 0。它当时以为离截止还有 46 分钟(真实只剩 8 分钟),直接在交付文件上插探针调试,被打断。从快照取旧版本,用官方计分器重新计分:

版本 通过 时间之和 保持率 时间 ÷ Sol
DCU bnb 交付版(v4) 0/18 — — —
DCU bnb 第 82.7 分钟快照(v2) 18/18,交替检查通过 63.0 ms 0.07 17.1×
DCU bnb 第 101.6 分钟快照(v3) 18/18,交替检查通过 27.3 ms 0.15 7.4×
MI210 topk_fp32 交付版 8/8 98.0 ms — 25.3×
MI210 topk_fp32 第 72 分钟快照 8/8,交替检查通过 13.6 ms — 3.5×
MI210 gdn(重排后)交付版 编译失败 — — —
MI210 gdn 第 81 分钟快照 8/8,交替检查通过 7.9 ms 0.22 10.1×
MI210 gdn 第 115 分钟快照 8/8,交替检查通过 6.7 ms 0.26 8.5×

只要控制器保证"交付的是最后一个通过全部检查的版本",Qwen 的通过数在 MI210 上从 11/14 变成 12/14,在 DCU 上从 8/14 变成 9/14,MI210 的 topk_fp32 快 7 倍。这只是保住已有的东西,不算优化能力。

DCU 的 fattn 有一点做对了:它把通过的 v0 留作交付文件,新版本在别处开发。v2 到截止也没调通,交付的仍是 v0,所以这次运行是通过的(虽然只有 0.002)。

"交付最后一个已验证的版本"由谁来保证,11-17 已经定下来:不放进基线 harness,作为我们系统控制器的能力,单独做有/无对照(7.5)。

4.8 正确性

v3 的 top-k 换内容检查已经改用全负、大量并列的数据。用它重测 b9 的交付代码:Sol 的解全部通过;Qwen 在 MI210 上的 topk_fp32 因为上面的符号错误没通过;它在 DCU 上的 topk_fp32 也没通过,原因是另一个隐藏错误:边界桶最多收 2048 个元素,并列值一多就被截断。

5. Sol 保持率低于 1:问题出在哪

5.1 提前收工,参照的是自己

Sol 的收尾消息都是同一个样式:"全部检查通过;比初版快 2.68 倍(几何平均);最大形状达到多少 TFLOPS。"保持率低于 1 的几次,离预算用完都还很远:

运行 用时(分钟,预算 120) 保持率
MI210 qknorm 35 0.94
MI210 router 49 0.82
DCU topk_moe 59 0.77
DCU dsv3 76 0.79
DCU router 88 0.82

它没有办法知道自己低于源水平:任务只说"尽量快",没有源代码在源卡上的时间,也没有任何下界。

5.2 提交方式:已证实,而且是 Sol 自己会的东西

Sol 在 MI210 的 dsv3 运行里量过:"一个什么都不做的 kernel,普通提交 7.7~8.5 µs,无事件提交 3.1~4.6 µs。"在 topk_moe 里:"9.3~16.5 µs 降到 3.8~7.8 µs,采用。"在 A100 的 topk_moe 里它也试了,记录是"基本无差别"。也就是说这是一个随后端翻转的决策:DPC++ 的 HIP 适配层上很值,CUDA 适配层上无所谓。DCU 的 AdaptiveCpp 有对应的"粗粒度事件"属性,Sol 在 qknorm 里量到 N=1 从 10.2 µs 降到 4.7~5.8 µs。

它在哪些运行里用了:

平台 用了 没用
MI210 dsv3、kimi、topk_moe 其余 11 个,包括 router、qknorm
DCU qknorm、kimi、topk_moe 其余 11 个,包括 router、dsv3
A100 topk_moe(无差别) —

qknorm 在 DCU 上用了、在 MI210 上没用;dsv3 正相反。找到它的几次,都是先量了空 kernel,或者注意到"多提交一次 kernel 就慢一截";router 的 47 KB 决策记录全是分块和展开参数的搜索,从没量过单次提交的开销。

实验:只换提交调用。 把交付代码里的 q.submit / q.parallel_for 机械地换成无事件形式(router 改 2 处,qknorm 改 2 处),别的不动。MI210,官方计分器:

算子(Sol 交付代码) 保持率:官方 → 原版复测 → 换提交后 列出形状 留出形状 低于 1 的配置
router_gemm 0.82 → 0.82 → 1.47 0.84 → 1.51 0.80 → 1.42 26/33 → 1/33
qknorm_rope 0.94 → 0.94 → 1.54 1.00 → 1.53 0.77 → 1.56 12/18 → 0/18
lightning_indexer 5.93 → 5.95 → 6.07 6.02 → 6.12 5.35 → 5.71 4/11 → 0/11
gdn 2.23 → 2.24 → 2.58 2.41 → 2.76 1.79 → 2.13 0/8 → 0/8
bnb_gemm4 2.57 → 2.57 → 2.70 2.49 → 2.62 2.67 → 2.81 0/18 → 0/18
mmq 2.16 → 2.20 → 2.25 2.45 → 2.54 1.59 → 1.67 5/20 → 4/20
fattn_mma 1.26 → 1.27 → 1.29 1.29 → 1.31 0.81 → 0.87 9/13 → 8/13
equi_f32 2.82 → 2.82 → 2.84 — — 4/18 → 2/18
equi_f64 1.01 → 1.02 → 1.04 — — 3/6 → 3/6

所有检查仍然通过。router 的每个配置都少了约 8 µs(M=1:14.2 → 5.6 µs;最大的一组:25.2 → 16.9 µs)。实验覆盖的 11 个算子(上表 9 个,加两个没有保持率的 top-k)里没有一个变慢。

把同一个改动用到 Qwen 的交付代码上:qknorm 0.86 → 1.08(官方计分时是 0.73),topk_moe 0.47 → 0.64,其余几个被 kernel 本身的慢盖住,基本不变。也就是说,一条从别的运行里得来的决策,能让便宜模型的一个结果越过 1。

DCU 上做了同样的对照(把 Sol 交付代码里的提交加上粗粒度事件属性,Slurm 上用官方计分器交替各 2 轮):

算子(Sol 交付代码,DCU) 保持率:官方 → 原版复测 → 换提交后 低于 1 的配置
router_gemm 0.82 → 0.82 → 0.93 31/33 → 25/33
dsv3_a_gemm 0.79 → 0.78 → 0.90 32/32 → 29/32
lightning_indexer 3.29 → 3.29 → 3.32 4/11 → 3/11

方向一致,但每次调用只省了 1.3~2.5 µs(router 的 M=1:9.9 → 7.9 µs),没有到 1。

剩下的差距也不是 AdaptiveCpp 的固定下限。它默认用后台线程批量提交,每次操作仍要记录一个 HIP 事件。整个程序开即时提交(ACPP_ALLOW_INSTANT_SUBMISSION=1,必须所有编译单元一致)再加粗粒度事件后:router 0.82 → 1.07,dsv3 0.79 → 0.98,topk_moe 0.77 → 1.37,qknorm 1.28 → 1.58(细节在 analysis_v2/claude/launch_overhead/README.md)。只在 solution.cpp 里定义这个宏反而更慢(router 0.47),而 harness 的构建脚本是固定的,所以 agent 在现有规则下用不了它。

5.3 机制选择:attention 的 decode 和 mmq 的小批量

MI210 上每个 token 的 decode 形状(tok=1)和原生实现的对比:

形状 Sol(µs) llama.cpp HIP 版(µs) Sol 保持率 换提交后的保持率
kv=2048,1 条序列 45.7 22.0 0.56 0.88
kv=4096,1 条序列 59.1 43.4 0.62 0.88
kv=1024,8 条序列 87.2 63.4 0.60 0.76
kv=3072,4 条序列 112.2 86.9 0.50 0.56
kv=65536,1 条序列 453.6 370.6 0.49 0.50

提交开销解释了短的那几组(一次调用要提交 2~3 个 kernel),长的几组不是它。llama.cpp 在 AMD 上走的是不用矩阵核的路径。decode 时每个 KV 头只有 6 个查询,矩阵指令的 16 行只用上 6 行,整个运算其实受访存带宽限制。Sol 的决策记录里试过寄存器驻留 Q、两阶段 decode、不同的切分数,都还是 MFMA 方案;纯 SIMT 的流式方案一次也没试。

mmq 的情况相同:J ≤ 64 时,MI210 上原生实现比 Sol 快 1.1~1.8 倍;A100 同卡上 Sol 的保持率是 0.74~0.88,也就是比源 CUDA 慢。源代码在这个算子上用的本来就是每线程的整数点积,Sol 换成了矩阵核路径,大 J 赢了 2~2.8 倍,小 J 输了。

这两处还有一个共同点:总数看不出来。MI210 的 fattn 总保持率 1.26,但 7 个 decode 配置在 0.49~0.65;最大的那组 prefill 占了全部时间之和的 74%。

A100 同卡上(保持率就是源时间 ÷ Sol 时间)共有 35 个配置低于 1,性质都是"改了之后在这个形状上不如原来"。

5.4 DCU 的 fattn 和 mmq:慢在非矩阵部分和一个厂商库的坑

DCU 上 Sol 的 fattn 是 0.36、mmq 是 0.70。这里的"厂商库"指 DTK 26.04 的 hipBLAS,底层是为 gfx936 编译的 rocBLAS/Tensile kernel。它在 FP16 方阵上有 370 TFLOPS;但在 attention 的实际形状上,hipBLAS 算 QK 要 3.97 ms、PV 要 19.0 ms,合计比 Sol 整个 attention(18.3 ms)还慢,所以不能拿方阵的峰值当参照。补测的结论如下,细节在 analysis_v2/claude/dcu_mma/README.md 和 dcu_fused/README.md。

所以这两个低分都不是"新硬件的矩阵单元不会用":fattn 是丢了源代码的两处机制(mask 共享内存块、融合不写 P),而且融合在 DCU 上做得到,是 Sol 自己的融合版没写好才退到拆分;mmq 是一次失败的测量被扩大成了"厂商库不可用"。

DCU 的 topk_moe(0.77)已经用了粗粒度事件,小形状仍要 9~10 µs,而同一张卡上 HIP 空 kernel 的启动只要 2 µs。缺的是即时提交:整个程序开即时提交后它是 1.37(5.2)。这个解法要动构建选项,agent 在固定的构建脚本下够不着。

5.5 指标边缘上的几项

dsv3 和 equi 的源代码跑在 H100 上。dsv3 的源在 H100 上已经贴着收紧上界(8 MB 的权重读一遍,6.9 µs),目标侧做到上界的 75%~90% 就会显示成 0.75~0.9。equi 小批量换提交后只从 4/18 变成 2/18、3/6 不变。这些我不硬归因。

5.6 汇总

平台 × 算子 低于 1 的配置 归因 证据强度
MI210 router(0.82) 26/33 提交方式 实验证实:换后 1.47
MI210 qknorm(0.94) 12/18 提交方式 实验证实:换后 1.54
MI210 lightning 小批量 4/11 提交方式 实验证实:换后 0/11
MI210 fattn decode 9/13 机制选择为主,提交方式为辅 同卡原生实现更快;换提交后 8/13
MI210、A100 mmq 小 J 5/20、6/20 机制选择 同卡原生实现和源 CUDA 都更快
A100 fattn 留出形状 8/13 中间 token 数的分块填充、decode 同卡比源慢;未做拆分实验
DCU router(0.82)、dsv3(0.79) 31/33、32/32 提交方式(事件记录 + 默认批量提交) 实验:只加粗粒度事件 0.93、0.90;整程序即时提交 + 粗粒度事件 1.07、0.98
DCU fattn(0.36)、mmq(0.70) 13/13、16/20 fattn:mask 逐元素读、P 写出和读回(丢了源代码的共享内存 mask 块和融合结构);mmq:厂商库 FP32 输出慢 33 倍,Sol 因此弃用 对照实验和计数器;融合版补三处后 11.6 ms,交付的拆分版 18.3 ms(5.4)
DCU topk_moe(0.77) 13/14 提交方式(同上;Sol 已用粗粒度事件,缺的是即时提交) 实验:整程序即时提交 1.37
dsv3(A100、MI210)、equi 小批量 若干 指标边缘 不归因

6. 失败原因总表

# 原因 出现在 影响 性质
1 目标平台的写法不知道或没走通(矩阵核调用、跨 lane 归约、LDS 与屏障) Qwen:MI210 的 bnb、mmq、fattn、gdn、dsv3、router;DCU 上需要矩阵单元的 8 个算子全部 保持率 0.002~0.45,或失败 模型知识 + 探测方法
2 探测和校验程序自身有错,或自己代码里的错被归到平台头上;错误结论被扩大成"平台不支持""编译器有 bug",再经交接固化 Qwen:MI210 的 7 次运行;DCU 的 router、qknorm、lightning、topk_bf16、fattn 把 1 变成不可恢复;DCU 上每次耗掉 30~100 分钟 过程
3 凭记忆的硬件事实不验证 Qwen equi_f64(MI210) 0.25 模型知识
4 基线来得太晚,或始终没有 Qwen:MI210 的 6 次运行;DCU 的 5 个失败项从未有过正确版本,4 个通过项(kimi、topk_moe、qknorm、gdn)的第一个正确版本在第 76~98 分钟 交付朴素版,或失败 过程
5 截止时间重新起算;在交付文件上直接做实验 Qwen:MI210 gdn、DCU bnb 编译失败、结果全 0 harness + 过程
6 交付的不是最好的已验证版本 Qwen topk_fp32(MI210) 7.1× 过程
7 比较、同步这类不变量写错;依赖测试数据分布 Qwen topk_bf16、kimi、topk_fp32 失败,或隐藏错误 模型 + 计分数据
8 任务表述歧义 Qwen equi_f32 2.7× harness
9 目标运行时的固定开销没被发现 Sol:MI210 和 DCU 各 11 次;Qwen 全部 router 0.82、qknorm 0.94 经验没有跨运行复用
10 没有性能参照,提前收工 Sol 全部 低于 1 而不自知 任务设置
11 机制只在一个家族里搜,源机制没有作为对照保留 Sol:fattn decode、mmq 小 J 区域 0.5~0.9 搜索策略
12 丢掉源代码的访存机制;一次失败的厂商库测量被扩大成"库不可用" Sol:DCU fattn、mmq 0.36、0.70 源机制没有登记;平台知识稀缺;MI210 上用过的做法没带到 DCU
13 kernel 在主机端和设备端各编译一遍,两遍捕获的变量或顺序不一致,设备端拿到错位的指针 Qwen:DCU router(没找到,重放证实)、DCU lightning(44 分钟后自己找到) router 交不出解 平台知识 + 探测方法

7. 我们的改进方法

下面按论文提纲的 M1~M4 组织。每一条都对应上面的原因编号,并写明现在有什么证据、还要做什么实验。

7.1 M2:可实现性检查要产出"已验证原语",而不是一张表

对应原因 1、2、3、12、13。

这条的定位是"便宜模型上的效果"。Sol 不需要它:MI210 上初稿就写对了,DCU 上两分钟就查到了。Qwen 在 MI210 上 6 次只走通 1 次,在 DCU 上 8 次一次没走通。router 的重放说明这类知识的分量:一行写法决定了一次运行是第 20 分钟就有一个 0.15 的正确版本,还是 120 分钟交不出解。

7.2 M4:带条件的决策记忆

对应原因 9。这次的实验给了 F5 里一直缺的那个数的第一个实测点。

7.3 M3:取证要有目标,有对照,先量固定开销

对应原因 10、11、9。

7.4 M1:算法结构和目标机制分开记、分开恢复

对应原因 1、4。gdn 给了一个干净的三段对照:

算法结构(分块递推) 目标机制(矩阵核) 保持率
Sol 保住 用上 2.23
Qwen 第一次尝试 保住 没用上 0.17
Qwen 重排后 交付前的可用版本是逐 token 递推 没用上 交付编译失败;快照里的可用版本 0.22~0.26

所以"源代码有哪些优化"至少要分两层登记:算法层(分块、融合解码、在线 softmax、split-KV)和机制层(矩阵指令、异步拷贝、warp shuffle)。每层各有恢复状态。正确性通过不能掩盖"某一层还没恢复"。Qwen 的 equi_f64 是另一个例子:分块、双缓冲、防冲突的重排都移植了,唯独丢了张量核。DCU 的 fattn 是机制层的另一个例子:源代码把 mask 整块搬进共享内存,翻译时丢了;拆分版和融合版都在这上面多花了 4~5 ms(5.4)。

7.5 harness 和控制器要先修的几件事

这些不算论文贡献,但不修的话模型之间没法公平比较。前四条已在 v3 harness 里实现(research/data/h100_dcu_20261110/agent/HARNESS_V3.md,b10 起用)。

  1. 绝对截止时间(v3 已做)。 提示里给带时区的绝对时刻,不写"从现在起"。工作目录里有截止时间文件 /work/.deadline 和查询剩余时间的 ./time_left.sh。DCU 上 codex 和它执行的命令都用登录节点的时区,和环境信息一致。对应原因 5。
  2. 自测和官方计分用同一种方式取文件(v3 已做)。 ./run_tests.sh 把要测的文件单独拷进一个干净目录再构建,和计分一样只认 solution.cpp。DCU 上 Qwen 的 router 把 kernel 拆到了 kernel.h,在工作区里能编译,计分时直接编译失败(4.4 末尾)。
  3. 计分数据加对抗性分布(v3 已做)。 top-k 的换内容检查用全负、带大量并列值的行。对应原因 7。
  4. 修正 equi_f32 的精度说明(v3 已做)。 允许操作数是 FP32 或 TF32、在 FP32 里累加的矩阵指令,不允许把操作数转成 FP16/BF16。对应原因 8。
  5. 候选版本和已验证版本分开,只晋升不回退(不放进基线)。 agent 在候选文件上做实验,通过全部检查且不比当前版本慢,才替换交付文件。对应原因 6。11-17 决定:基线 harness 不替模型管理版本,计分仍然只看最终的 solution.cpp。原因 5 里由截止时间引起的那部分已由第 1 条修掉,剩下的是模型自己的版本管理;这条作为我们系统控制器的能力,单独做有/无对照。

7.6 建议的验证实验

优先级 实验 改动 看什么 成本
1 v3 harness 下重跑 Qwen 的全部 28 次(已完成,见第 8 节) 7.5 的第 1~4 条 失败率;截止判断还会不会错;和 b9 的结果比 28 次 × 2 小时卡时
2 Qwen 加原语卡重跑:MI210 的 bnb、mmq、fattn、equi_f64,DCU 的 router、lightning、bnb、dsv3 7.1 的第一批原语(DCU 上是矩阵 builtin 和两遍编译这两条) 第一个正确版本和第一个矩阵核候选出现的时间;最终保持率 8 次 × 2 小时
3 Sol 加每形状目标重跑 router、qknorm、fattn、mmq;Qwen 也应加(8.4) 7.3 第一条,目标同时作停止条件 是否自己去量固定开销;decode 和小 J 是否改善;用时 4 次 × 2 小时
4 Sol 加"源机制保底"重跑 mmq、fattn(A100、MI210、DCU) 7.3 第二条 同卡低于 1 的配置数 4 次 × 2 小时
5 记忆迁移扩到更多决策 把各运行 DECISIONS 里"采用"的条目抽成带条件的记忆,留一个算子做测试 命中率、负迁移率 离线为主

第 2 项直接回答"系统能把便宜模型拉回来多少",第 3、4 项回答"系统能不能在强模型上再拿到收益"。

8. v3 harness 下的 Qwen 重跑(b10)

7.6 第 1 项已经跑完:只重跑 Qwen,MI210 和 DCU 各 14 次,任务、预算、并发和 b9 相同,harness 换成 v3(7.5 第 1~4 条)。DCU 11-17 17:48~11-18 03:47;MI210 因 GPU62 磁盘满推迟到 11-18 09:54 开始,11-19 07:34 结束。结果表:research/data/h100_dcu_20261110/v3_results/full/v2_table.md(和 b9 的表分开);对比和过程统计脚本在 analysis_v2/claude/b10/。

8.1 结果

通过 保持率几何平均 卡时 API 费用
MI210 Qwen b9 11/14 0.13(10 个算子) 24.3 h $75.9
MI210 Qwen b10 14/14 0.22(11 个) 21.4 h $66.6
DCU Qwen b9 8/14 0.18(5 个) 26.4 h $49.5
DCU Qwen b10 8/14 0.09(7 个) 27.1 h $51.8
Sol b9(参照) 14/14、14/14 1.72(MI210)、1.17(DCU) 16.8 h、17.4 h 36.3、35.3

几何平均只按各自能算出保持率的算子计算,两批的算子集合不同,只能粗看。逐算子按"两次都通过的配置上的总时间比"比较:

每个算子只跑一次。DCU 上这种来回变动的幅度和 MI210 的整体提升差不多大,所以不能把 MI210 的提升直接归给 harness 修正;要下这个结论,至少要在 MI210 上每个算子再重复跑一两次。

8.2 harness 修正各自起了什么作用

  1. 截止时间:修好了。 每次运行调用 ./time_left.sh 6~23 次;被截断的运行在最后都清楚地说"还剩 1 分钟",b9 里那种把截止时间算晚的情况没有再出现。
  2. "改到最后一分钟、交出坏文件"仍然存在,但这次救不回来。 DCU 有 5 次被截断(gdn、equi_f64、mmq、topk_bf16、qknorm),前 4 个交出的是坏文件。这 4 个在整个过程里没有一次自测输出出现过全部通过(equi_f64 最好一次是 1/3),和 b9 DCU 一样:"交付最后一个已验证版本"对它们无效,瓶颈在更前面:一直没有正确版本。
  3. 对抗性 top-k 数据:抓出了 b9 漏掉的错。 用 v3 计分器重评 b9 的 top-k 解:
  4. 自测用干净目录构建: 没有再出现"自测能编译、计分编译失败"的情况(b9 DCU router)。DCU mmq 和 topk_bf16 的编译失败是截止时文件本身就编不过。

8.3 新发现一:DCU 矩阵指令找到了,但卡在数据布局上

b9 里 Qwen 在 DCU 上一次都没找到海光的矩阵 builtin。b10 里 fattn、gdn、equi_f32、lightning 分别在第 6、8、24、43 分钟找到了 __builtin_amdgcn_mmac_*,fattn 和 gdn 还读到了厂商头文件 du_mma.hpp。之后它们没有照头文件里 DUFragment 的写法用,而是自己写探针、用实验反推每个 lane 持有哪些元素:

对照:Sol 在 8 个需要矩阵指令的 DCU 算子上,都在 2~5 分钟内按头文件给的布局直接用上。

含义:b9 的结论是"缺一个名字",b10 说明名字不够,名字加布局加一个能跑的最小例子才够。7.1 的已验证原语必须包含调用形式、数据布局和一个通过的最小测试,只给"能不能用"的结论没有用。

8.4 新发现二:知道还剩一小时,照样提前收工

MI210 的 14 次都是 Qwen 自己结束的,DCU 有 9 次。其中多数是离截止只剩 1~12 分钟时收尾;真正提前很多的有 8 次,全在 MI210:

算子 结束时还剩 保持率 Sol(b9)
qknorm 72 分钟 0.60 0.94
topk_moe 59 0.46 1.95
equi_f32 57 1.25 2.82
dsv3 48 0.38 1.01
kimi 47 - -
equi_f64 32 0.38 1.01
topk_fp32 27 - -
gdn 20 0.35 2.23

读了这 8 次最后一段的思考,是三件事叠在一起:

  1. 没有性能目标,参照是自己的初版。 TASK.md 只写"尽可能快"。equi_f32 停下时的依据是"比最初的直接移植快 4.5 倍、比上一段会话最好的版本快 1.5 倍,便宜又有效的办法用完了";它自己算过只用到 FP32 峰值的 34%,仍然停了。这和 5.1 里 Sol 的停止依据相同,只是起点低得多。
  2. 上下文交接把开放的目标变成待办清单。 这 8 次都在最后一次交接后 3~20 分钟内结束,5 次明确说"交接列出的剩余工作已完成"。qknorm 接手后核对清单、写完 NOTES.md,问了一句"还有什么值得做的?"就结束了,当时还剩 72 分钟。"越快越好"在交接摘要里没有留下来。
  3. 错误结论经交接成为前提,把可走的路提前排除。 equi_f32 的前一段会话已确认 FP32 矩阵指令合法,用内联汇编写出来结果像逐元素相加,于是认定"SYCL 编译流程把 MFMA 变成了加法",写进交接。接手的会话又一次想到矩阵指令,读到这条后放弃。Sol 在同一个算子上用的是 __builtin_amdgcn_mfma_f32_16x16x4f32 和 32x32x2f32 两个 builtin,保持率 2.82。

b9 里 Qwen 常把截止时间算晚;这次它清楚知道还剩五六十分钟,照样停。所以提前收工不是时间感知的问题,而是它不知道离上限还有多远。

含义:

8.5 小结

9. 局限

附录 A:与 11-15 报告的关系

一致的部分:三个正确性缺陷的定位(topk_bf16 的截断键、kimi 的标记重合、gdn 的末尾拼接);Qwen 丢掉矩阵化和融合结构造成两个数量级的差距;equi_f32 的歧义;Sol 在 topk_moe、dsv3 里用过省开销的提交而 router、qknorm 没用;attention 的总数掩盖了 decode。

修正的部分:

新增的部分:六组实验(MI210 上 Sol 11 个算子和 Qwen 7 个算子的提交方式对照;DCU 上 Sol 3 个算子的对照;Qwen 旧版本重新计分,MI210 两个算子、DCU 一个算子;DCU 上 router 捕获顺序的重放);Sol 提前收工和它的停止依据;同一决策的独立重新发现率;用同卡原生实现作为"存在更快做法"的证据;topk_fp32 的版本回退和隐藏的排序错误;DCU 的 Sol 低分;DCU 上 Qwen 14 次运行的逐条分析(矩阵 builtin、两遍编译、截止时间);跨 lane 传值被误判为"误编译"的解释;DCU 上 fattn、mmq 的拆解和 fattn 的融合实验。

附录 B:主要更正

前几版里有几处说法后来被实验推翻,这一版的正文已经按新结论写:

附录 C:文件