7 份 profile 从 GitHub Release 下载,解压后一个 logdir 下每份一个 run,用开源 XProf 打开(和正文 2.1「本机怎么开」同一套命令)。
本课用到的 7 份 profile 公开在 GitHub Release topic07-hy3-profiles-v1(混元3 在 64 颗 TPU v7x 上的训练,每份是一台主机抓的 3 步,一份解压后 1.2–1.45 GB;除了主机名换成 gke-node-N,其余原样)。下面四步从下载到打开,命令可以直接复制:
# 1. 下载(7 个附件共 0.86 GB;只看一两份就只下那几个)
mkdir -p ~/hy3-prof && cd ~/hy3-prof
B=https://github.com/yangwhale/gpu-tpu-pedia/releases/download/topic07-hy3-profiles-v1
for r in fp8old fp8new fp8nat r3anat fp8tk bf16old bf16new; do curl -fLO $B/hy3-$r.tar.zst; done
curl -fLO $B/SHA256SUMS && sha256sum -c SHA256SUMS
# 只下了几份就加 --ignore-missing;macOS 用 shasum -a 256 -c SHA256SUMS
# 2. 解压(共 9.2 GB):每个 tar 里已经是 <run>/plugins/profile/<时间戳>/<主机>.xplane.pb
# 没有 zstd 命令先装:apt install zstd / brew install zstd
for f in hy3-*.tar.zst; do zstd -dc "$f" | tar -xf -; done
# 3. 装开源 XProf,指向这个目录
# ==2.23.1 是本课截图用的版本,去掉就装最新版
pip install xprof==2.23.1
xprof --logdir ~/hy3-prof --port 6311
# 也可以用 TensorBoard:pip install tensorboard tensorboard-plugin-profile
# 再 tensorboard --logdir ~/hy3-prof --port 6311,进 PROFILE 页
# 4. 浏览器开 http://127.0.0.1:6311/
# 左栏 Sessions 下拉选 run(如 fp8old/2026_08_15_03_57_28),Tools 选工具<logdir>/<run>/plugins/profile/<时间戳>/<主机>.xplane.pb,logdir 下每个子目录是一个 run。解压完 ~/hy3-prof 下就是 7 个 run 目录;自己抓的 profile 照这个结构摆进来也能一起看。| run | 是什么 | 中位步(ms) | 解压后的文件 |
|---|---|---|---|
fp8old | FP8 原配方(tokamax,注入 tile 512/2048/1536) | 11,758.2 | fp8old/plugins/profile/2026_08_15_03_57_28/gke-node-1.xplane.pb |
fp8new | FP8 改后(native + 12 个新 tile 值):快了 50% 的那一份 | 7,842.1 | fp8new/plugins/profile/2026_08_15_04_11_46/gke-node-1.xplane.pb |
fp8nat | fp8new 的复跑 | 7,846.1 | fp8nat/plugins/profile/2026_08_15_16_59_57/gke-node-4.xplane.pb |
r3anat | fp8new 的再一次复跑 | 7,840.1 | r3anat/plugins/profile/2026_08_16_01_29_28/gke-node-5.xplane.pb |
fp8tk | 原配方但没注入 tile(默认 128×128×128):375 s 那一份 | 375,160.0 | fp8tk/plugins/profile/2026_08_15_17_48_55/gke-node-4.xplane.pb |
bf16old | BF16,改之前(tokamax,注入 tile) | 21,747.2 | bf16old/plugins/profile/2026_08_15_09_13_02/gke-node-2.xplane.pb |
bf16new | BF16,做同一个改动之后(native + 同 12 个 tile 值) | 20,693.8 | bf16new/plugins/profile/2026_08_15_09_28_25/gke-node-3.xplane.pb |
view_start/view_end(毫秒,距 profile 起点),后面的「↗ 打开」直接开到那一屏;工具页的「↗ 打开」开到那份 run 的那一页。链接按本机 XProf 端口 6311 写,端口不同就把链接里的 6311 改掉。/device:TPU:0 和它的 SparseCore 0/1 → Expand All。Details 里 Start、Wall Duration 的单位是 ns。view_start/view_end,打开就是整份会话;要开到一层,用题里窗口后面的「↗ 打开」(它直接开 trace_viewer_index.html)。jit_train_step(正文 4.3 录屏停 3–4)。jit_add 这类小模块,要在 Hlo Modules 下拉里换成 jit_train_step;换完以后 Module Name 那一行可能还写着原来的名字,以下面的数为准。= 切到「包含」才能用 gmm 这样的片段筛。utilization_viewer)在 2.23.1 上打开任何 profile 都弹 404,error 写着 No Data。这是这一版的 bug:它把这个工具路由到一个没注册的处理器,XProf 日志里是 No ProfileProcessor registered for tool: utilization_viewer;2.23.2 已修。原料是在的:以 fp8old 为例,/device:TPU:0–3 平面上各有一行 counters_0,每行 94,039 个硬件计数器事件。要看这一页就装 2.23.2 或更新的版本(本课截图都是 2.23.1)。做完这一级,你能读出任何一份 profile 的步时,框出一步、认出一层里的通信。对应正文第二节。
打开 fp8tk 的 Overview(工具 overview_page)↗ 打开,读平均步时。它是原配方 fp8old↗ 打开 同一格的几倍?
fp8tk 375,326.7 ms,fp8old 11,793.8 ms,约 31.8 倍。
怎么看出来:两份 Overview 左栏的 Average Step Time。这一格按主机上的 Steps 切步、3 步平均,比 Trace Viewer 里单击 jit_train_step 读的中位步(375,160.0/11,758.2,31.9 倍)分别大 0.04% 和 0.3%,口径不同,结论一样。为什么慢这么多,练习 6。
打开 fp8nat 的 Trace Viewer(不带窗口,整份会话)↗ 打开,在 XLA Modules 行上单击 3 块 jit_train_step,各读 Wall Duration。取居中的那一步,和 fp8new 的 7,842.1 ms 差多少?
三步 7,846.7/7,846.1/7,845.4 ms;居中的是第二块(8,239.931 ms 起),7,846.1 ms,比 fp8new 多 4.0 ms(0.05%)。漏算那份结果能复现,不是一次偶然。
怎么看出来:抓了 3 步就有 3 块;读 XLA Modules 而不读 Steps(正文 2.3 认行表)。按 f 可以让选中的一步铺满一屏。
打开 bf16new 反向 40 号层:view_start=34056.155&view_end=34251.406 ↗ 打开。小核 SparseCore 0 的 Sparse Core Ops 上,收 192 个专家的 all-gather 有几条、多宽?专家梯度的 reduce-scatter 呢?单击读形状。
all-gather.550/552/554:4.86/4.95/4.87 ms,输出 bf16[1,192,4096,1536] ×2 和 [1,192,1536,4096];reduce-scatter.198/200/202:9.08/8.74/8.33 ms,输出 bf16[192,32,1536] ×2 和 bf16[32,294912]。和原配方 bf16old 同一层几乎一样宽:通信一条不少(正文图 5.1B)。
怎么看出来:reduce-scatter.202 的形状不带 192,可 294,912 = 192 × 1,536:它是第三份专家矩阵的梯度换了排布(HLO 里顺着它的输入往上追,是一颗 tgmm 的输出)。另外 all-gather.550 在这一窗里出现两次(层头、层尾各一条),两次各算一条还是层尾那条属于下一层,本课没追。
做完这一级,你能说出一块 done 在等哪条小核上的通信、藏了多少,在两张总账页上判断「真快」还是「漏算」,并把少掉的时间和没干的活对上账。对应正文第二、三、五节。
打开 fp8old:view_start=31223.000&view_end=31227.000 ↗ 打开(反向 40 号层里)。主核 XLA Ops 上找名字带 all-gather.548、call-done 的那块,读宽度;往下找小核上右沿和它对齐的那条。这次通信一共多长、藏住了多少?
done 31,225.002–31,226.183 ms,宽 1.181 ms;对着 SparseCore 0 的 all-gather.547(31,223.777–31,226.183,2.406 ms,f8e4m3fn[1,192,4096,1536]),右沿差 0.1 µs。藏住 2.406 − 1.181 = 1.225 ms,露出 1.181 ms。
怎么看出来:done 的宽度就是主核白等的那段;小核上的号比主核上的小 1(547 对 548)。先单击小核那条再单击 done,反过来点 Details 变高会把小核行挤出屏幕。正文 2.5、图 2.6。
打开 bf16new 的 HLO Op Profile(工具 op_profile)↗ 打开,Group by 选 Category,读整体 FLOPS 利用率和 custom-call 那一行的 FLOPS。再和 fp8new↗ 打开 同一格比:哪一份可能是漏算?
bf16new:整体 22.55%,custom-call 49.62%(bf16old 是 21.44%、45.57%)。fp8new 的 custom-call 是 117.45%,超过这页自己用的峰值:漏算的是 fp8new。
怎么看出来:BF16 这一格涨了 4 个点,和时间少掉的比例对得上;FP8 那一格时间少了一半多、利用率反而翻倍。只凭「超过 100%」还不够下结论(正文 3.2 折叠块),要展开到单颗 kernel 看它的 FLOP rate 有没有超过硬件峰值。
打开 fp8tk 的 HLO Op Stats(工具 hlo_stats)↗ 打开。第一名是谁、每次多久(读 Avg. time (us))?按名字过滤 gmm_megablox.16,每次多久,是 fp8old 同名 kernel 的几倍?
第一名 tgmm_megablox.10,每次 418,120.7 µs;gmm_megablox.16 每次 373,915.2 µs,fp8old 同名 3,432.0 µs,慢 108.9 倍(Model 7,719 GFLOP/s)。前十名全是专家矩阵乘。
怎么看出来:次数两份都是 1,872(78 圈 × 3 步 × 8 个 TensorCore):活一样多,每颗慢了一百多倍。原因是这份没注入 tile,退回默认 128×128×128(正文 3.5)。Model GFLOP/s 这一列默认不显示,在表格上方的 Visible Columns 下拉里勾上才看得到。
打开 fp8old 的 HLO Op Stats↗ 打开,HLO op name 框切到「包含」、输 gmm。把筛出来那些行的 Total self time (us) 加起来(这一列默认不显示:在 Visible Columns 下拉里勾上;custom-call 没有子操作,它和默认显示的 Total time (us) 一样),除以 24(8 个 TensorCore × 3 步):每步每核专家矩阵乘花多少 ms?fp8new↗ 打开 同样做一遍。再按「只算了 3/192」估:改后该省多少、实际省了多少、差几成?和正文 3.4 表里的 3,668.8/98.3 ms 为什么差一点?三十多行手加太累,可以把下面这段存成 opstats_sum.py,从同一张表的数据接口求和(页面上的表就是从这个接口取的数;XProf 不在 6311 就改脚本里的端口):
import gzip, json, sys, urllib.parse, urllib.request
run, key = sys.argv[1], sys.argv[2] # run 写成 fp8old/2026_08_15_03_57_28 这样;key 是名字片段
host = sys.argv[3] if len(sys.argv) > 3 else "gke-node-1"
q = urllib.parse.urlencode(dict(run=run, tag="hlo_stats", host=host))
b = urllib.request.urlopen("http://127.0.0.1:6311/data/plugin/profile/data?" + q).read()
try: b = gzip.decompress(b)
except OSError: pass
d = json.loads(b); ids = [c["id"] for c in d["cols"]]
rows = [dict(zip(ids, [c.get("v") if c else None for c in r["c"]])) for r in d["rows"]]
m = [r for r in rows if key in r["hlo_op_name"]]
occ = sum(r["occurrences"] for r in m); us = sum(r["total_self_time"] for r in m)
print(len(m), "行", int(occ), "次", round(us / 1000, 1), "ms;÷24 =", round(us / 24000, 1), "ms")
python3 opstats_sum.py fp8old/2026_08_15_03_57_28 gmm
python3 opstats_sum.py fp8new/2026_08_15_04_11_46 gmm
fp8old:33 行,#Occurrences 合计 22,968(= 957 × 24,除以 24 没错),Total self time 合计 87,860.6 ms,每步每核 3,660.9 ms。fp8new:37 行,其中 33 行是专家矩阵乘 kernel(同样 22,968 次,每步每核 99.1 ms),另 4 行是名字里碰巧带 gmm 的 broadcast(jit_gmm_.688 这类),合计每步约 0.09 ms,带上是 99.2 ms。该省 3,660.9 × 189/192 = 3,603.7 ms,实际少 3,561.7 ms,是估计的 98.8%,差约 1%:两头对上了。
怎么看出来:两份的次数一样(每步每核 957 个),时间少了 97%:kernel 照样一次次发出去,每次只干了 3/192 的活(正文 3.4、第四节)。和 3.4 那张表差 0.2%(原配方)和 0.9%(改后),是口径不同:Op Stats 是 8 个 TensorCore、3 步的平均,3.4 用的是 TPU:0 的中位步;两种口径各自算出来的「实际 ÷ 估计」都是 99% 上下。「包含」只按名字片段匹配,名字里碰巧带 gmm 的别的算子也会进来:改后那 4 行的 category 是 broadcast,Framework op name 是 jit(gmm),形状 s32[192]、s32[639],每次不到 1 µs。对账前先扫一眼 category 列,不是 custom-call 的剔掉;fp8old 那 33 行全是 custom-call。
做完这一级,你能在 Details 的 HLO 原文、Graph Viewer 和导出的 HLO 文本里读出一条指令吃什么、程序里一共有几条、循环写死转几圈,并在 Memory Profile 上找到对应的数。对应正文第四节和 2.3、3.6。
打开 bf16new 前向 40 号层:view_start=23992.641&view_end=24062.505 ↗ 打开。单击第一颗 gmm.24,读 Details 里 Start Stack Trace 下的 HLO 原文:专家权重那个操作数是什么形状?输入 token 那个操作数呢?
权重 bf16[192,4096,1536]:192 个专家都在;输入 bf16[393216,4096],393,216 = 每个 device 12 条 × 4,096 token × 每个 token 8 个专家。
怎么看出来:看 operand_layout_constraints 那一段最省事,每个操作数的形状按顺序列一遍(正文图 4.1 ⑨)。和第四节录屏停 12 的 fp8new gmm.27(f8e4m3fn[3,4096,1536])对比,就是第五节的结论。
打开 fp8old 的 Memory Profile(工具 memory_profile)↗ 打开,读这份 profile 窗口里的显存峰值和总容量。
峰值 93.28 GiB,容量 94.74 GiB,只剩 1.5 GiB 左右。换成 Memory ID 1 是 93.23 GiB,时刻 23,606.7 ms。
怎么看出来:读页面顶上 Memory Profile Summary 里的 Memory Capacity 和 Profile-window Peak Memory Usage(下面一行 Free Memory 1.46 GiB),几乎用满。别读成它上面那行 Lifetime Peak Heap Usage(43.89 GiB):那只算 heap,不含 stack。默认显示的是 Memory ID 0,它的峰值落在窗口开头 1.4 ms,那时训练步还没开始;正文 3.6 教的是换到 1 再读,峰值时刻落在训练步里,两个数只差 0.05 GiB。是哪些 buffer 占了大头,去 Memory Viewer 按 buffer 看(正文 3.6;BF16 那份见练习 23、24)。
打开 fp8old 的 Graph Viewer(工具 graph_viewer)↗ 打开,在页面下方的 quick-start 列表里点 gmm_megablox.16,以它为中心画图。指向它的边带序号:哪条边送来 s32[193]?7 号边从哪个节点来、什么形状、再往上是谁?换 fp8new,点 gmm.27,1 号边和 7 号操作数呢(图上找不到那条边,就看节点框里写的 operand 行)?
fp8old:1 号边 copy-done.141,s32[193];7 号边 bitcast.3183,f8e4m3fn[192,4096,1536],上游是 all-gather.574 的 call-done。fp8new:1 号边 copy-done.122,s32[193];7 号没有边,gmm.27 的节点框里写着 operand 7 = tuple-element 1 of fusion.1642,f8e4m3fn[3,4096,1536]。
怎么看出来:fp8old 往上那个带标题的大框是子计算 all-gather.573;fp8new 的 fusion.1642 是本 device 的 3 个专家量化后的结果。边上的序号就是操作数的位置,和 Details 里 HLO 原文的操作数顺序一致(练习 8 的读法)。操作数是从元组里取一项(tuple-element)时不画边,直接写在节点框的 operand 行里:fp8old 那张图上的 4 号、fp8new 那张图上的 0、4、6、7、8 号都是这样。s32[193] 是 192 组 token 的分组偏移,两边一样:token 照样按 192 组送进来,改后手里只有 3 个专家的权重(正文 4.3、图 4.2)。图太小就滚轮放大,或点 Save SVG 存下来放大;从 Details 的链接点进来时下拉框停在别的模块上,先手动选 jit_train_step。
Graph Viewer 一次只画一条指令周围那一小片。数整份程序要 HLO 文本:在 Graph Viewer 或 Memory Viewer 里打开过这份 run 之后,profile 目录里会多出每个模块一份 *.hlo_proto.pb,下面第一段存成 hlo2txt.py,它把训练步那份转成文本。分别导出 fp8old、fp8new,按形状数:输出是 f8e4m3fn[1,192,…] 或 [192,1,…] 的 all-gather 各几条?输出是 bf16[3,…] 的 reduce-scatter 呢?
# hlo2txt.py:把 profile 目录里训练步的 HloProto 转成 HLO 文本(只用 jax,CPU 版就行)
import glob, sys
from jax._src.lib import xla_client as xc # 内部模块路径,本机 jax 0.11.0 实测
d, out = sys.argv[1], sys.argv[2]
b = open(glob.glob(d + "/jit_train_step*.hlo_proto.pb")[0], "rb").read()
n, i, s = 0, 1, 0 # 第 1 个字段是 hlo_module:先读出它的长度
while True:
c = b[i]; i += 1; n |= (c & 0x7F) << s; s += 7
if c < 0x80: break
open(out, "w").write(xc.XlaComputation(b[i:i + n]).as_hlo_text())
pip install jax
python3 hlo2txt.py ~/hy3-prof/fp8old/plugins/profile/2026_08_15_03_57_28 fp8old.hlo.txt
grep -cE '= f8e4m3fn\[(1,192|192,1),\S* all-gather\(' fp8old.hlo.txt
grep -cE '= bf16\[3,\S* reduce-scatter\(' fp8old.hlo.txt
fp8old:all-gather 12 条、reduce-scatter 6 条;fp8new:0 条、0 条。导出的文本 fp8old 9,599,857 字节、fp8new 8,403,650 字节,就是正文 4.1 降噪前那两个数。
怎么看出来:两条 grep 就是正文 4.2 那张表的口径:收 192 个专家 FP8 权重的 all-gather 有四种形状([1,192,4096,1536]×6、[1,192,1536,4096]×3、[192,1,4096,1536]×2、[192,1,1536,4096]×1),散回本 device 的 3 个专家梯度的 reduce-scatter 两种。页面只列跑过的指令;「改后一条都没有」这种答案,要数整份程序才拿得到。脚本用的是 jax 的内部模块,换了 jax 版本可能要改导入那一行。
正文 2.3 说前向、反向两个大循环各转 78 圈,是在 trace 上数出来的(while.457 底下同一块出现 78 次;Op Stats 里 gmm_megablox.16 的 #Occurrences 1,872 = 78 × 3 步 × 8 核)。在练习 11 导出的 fp8old.hlo.txt 里把它核一遍:while 指令的 condition= 指向一个小计算,里面是「计数器 < 某个常数」;while(…) 括号里是初始值元组,元组的第一个元素就是计数器的初值。从这一条开始:
grep -E '^\s*while\.457 = ' fp8old.hlo.txt | grep -oE 'while\([^)]+\)|condition=[^,]+'顺着打印出来的两个名字往下找。前向 while.457 的常数和初值各是多少?反向 while.453 呢?为什么一个从 1 数、一个从 0 数?
while.457:condition(wide.region_53.67_spmd.clone.clone.clone.clone)里是 constant(79)、direction=LT;初值元组 tuple.1968 的第一个元素 copy.2308 = copy(constant(1));body 的 ROOT 元组第一个元素是 add.7090 = 计数器 + constant(1)。i 从 1 数到 78,78 圈。while.453:constant(78)、初值 constant(0),也是 78 圈。
怎么看出来:四条 grep 一条接一条,后面每条里的名字都是前面打印出来的(第四条里的 constant.4132.clone 要先 grep 一次 copy.2308 才看得到,这里合成了一条):
grep -E '^\s*while\.457 = ' fp8old.hlo.txt | grep -oE 'while\([^)]+\)|condition=[^,]+'
grep -A4 '^wide.region_53.67_spmd.clone.clone.clone.clone {' fp8old.hlo.txt | grep -oE 'constant\([0-9]+\)|direction=\w+'
grep -E '^\s*tuple\.1968 = ' fp8old.hlo.txt | grep -oE '\) tuple\([^,]+'
grep -E '^\s*(copy\.2308|constant\.4132\.clone) = ' fp8old.hlo.txt | grep -oE '\S+ = \S+ (copy|constant)\([^)]*\)'层权重叠成首维 79(HLO 里 u32[79]、bf16[79,…] 这类形状到处都是):前向把 0 号层剥到循环前,循环取 1–78 号层,所以计数器从 1 数到 79 之前;反向倒着取 78–1 号层、0 号层在循环后,计数器从 0 数到 78 之前(正文 2.2 折叠块)。前向那个条件计算的参数名里带 loop_peel(剥出一圈),说的就是这件事。读法:trace 上数出来的次数,到 HLO 里要能找到写死的常数;两边对不上,就是数的口径错了。
正文只讲了一条 done、一层的合计、两份程序的条数和代码里的两行。下面七题换一条通信、换到一层里的每一颗 kernel、换一份 profile 的 HLO、回到代码,由易到难排;答案只在本页。做完这一组,你能用 Ctrl 多选对一层的账,按字节先估一条通信该多久再和实测比,判断一块 done 在等谁,并从 trace 上的一块追到公开代码里的那一行。
打开 bf16old 反向 40 号层:view_start=35630.027&view_end=35825.278 ↗ 打开。主核 XLA Ops 上单击第一颗专家矩阵乘(名字带 gmm),按住 Ctrl(Mac 是 Command)依次单击另外 8 颗,读面板顶上的「… items selected.」和 Totals 行的 Wall Duration;bf16new 同一层 view_start=34056.155&view_end=34251.406 ↗ 打开 再来一遍。这一层的专家矩阵乘一共少了多少?Totals 下面那行 Selection extent 又是什么?最后一颗对一颗比(单击读 Wall Duration),少掉的时间集中在哪几颗?
「9 items selected.」,Totals 79,113,086 → 66,893,085 ns(79.113 → 66.893 ms),这一层少 12.220 ms。Selection extent 98,189,886/86,068,731 ns 是第一颗起点到最后一颗终点的跨度,不是合计。快得最多的三颗:gmm_megablox_transpose_rhs.9 → gmm.22 9.961 → 6.305(−3.656);gmm_megablox_transpose_rhs.10 → gmm.23 10.414 → 7.000(−3.414);tgmm_megablox.10 → tgmm.8 10.053 → 6.834(−3.219),三颗合计少 10.289 ms,占 84%;gmm_megablox.12→gmm.19、tgmm_megablox.8→tgmm.6、tgmm_megablox.9→tgmm.7 几乎不动(±0.05 ms 以内)。
怎么看出来:两份的 9 颗按出现顺序一一对应,输出形状逐颗相同(单击核一下即可),所以能一颗对一颗比。少一行就是有一下没点中(页面转圈时单击不生效)。前向同一层也一样:3 颗合计少 1.070 ms,几乎全在第三颗 gmm_megablox.16 → gmm.26(快了 0.988 ms),前两颗只差几十微秒。一层少约 13.3 ms(反向 12.220 + 前向 1.070),× 78 圈 ≈ 1,037 ms,和一步少的 1,053.4 ms 对得上大头(剥到循环外那一层和 MTP 层没算)。为什么偏偏是这几颗快,本课没追。
回到 fp8old 反向 40 号层,练习 4 那个窗口往右:view_start=31254.000&view_end=31302.000 ↗ 打开。主核上单击 tgmm_megablox.10,读输出形状;它算完的下一刻,小核上开始的那条 reduce-scatter 叫什么、多长、输出什么形状?主核上它的 done(号大 1)在哪、多宽?
tgmm_megablox.10 输出 bf16[192,4096,1536](4.522 ms);31,260.076 小核上 reduce-scatter.12 开始,10.447 ms,输出 bf16[3,4096,1536];主核 reduce-scatter.13…call-done 在 31,290.841,宽 0,全藏住。
怎么看出来:192 个专家的梯度进去、本 device 的 3 个出来:这就是正文 2.4 说的「散回去」。小核上三条 reduce-scatter(12、14、16)一条接一条,合计约 29.8 ms,主核一直在算别的,三个 done(13、15、17,后两个在 31,298.349、31,300.427)都是 0 宽:这类通信在原配方里本来就不花主核时间,没了它们,主核也省不下多少(正文 3.3 图 3.5)。
还是练习 14 那条 reduce-scatter.12。在练习 11 导出的 HLO 里看它的输入和参与的设备:
grep -B1 'ROOT reduce-scatter.12 = ' fp8old.hlo.txt | cut -c1-330上一行是它所在子计算的 parameter(0)。先估:输入有多少字节?按正文 2.5 量出的 all-gather 速度(547 收齐 1.21 GB 用了 2.406 ms,约 0.50 TB/s)要搬多久?再和练习 14 读到的时长比:reduce-scatter 的有效速度是多少,是 all-gather 的几成?同一窗里另外两条(14、16)呢?
输入 bf16[192,4096,1536]:192 × 4,096 × 1,536 × 2 字节 = 2,415,919,104 字节 ≈ 2.42 GB,是 547 收齐后(FP8,1.21 GB)的两倍。按 0.50 TB/s 估要 4.8 ms;实测 10.447 ms,是估计的 2.2 倍。有效速度 2.42 GB ÷ 10.447 ms ≈ 0.23 TB/s,约 all-gather 的 46%。14、16 两条 10.246/9.134 ms,0.24/0.26 TB/s,同一个量级。replica_groups 是 {'fsdp'},mesh 里 'fsdp'=64(另有 'data'=2):64 颗芯片是 128 个 device(一芯片 2 个),分成两组各 64 个,每组内散一次,每个 device 留 192 ÷ 64 = 3 个专家,和输出 bf16[3,4096,1536] 对得上。
怎么看出来:两边用同一把尺子:整块(192 个专家那一侧)的字节 ÷ 时长。环形的 all-gather 和 reduce-scatter,每个 device 要收发的都约是整块的 63/64,按字节算两者该一样快 [推断:没核这一版用的是不是环形算法];reduce-scatter 实测慢一倍多,原因本课没追 [推断:每收一块要和本地那块相加再发出去,多了读写和加法]。先估再看的用处是定量:一层三条散梯度约 29.8 ms、一步 2,354.7 ms(正文 3.3),全靠和主核的计算重叠才不花时间(练习 14);估出来的数和实测差一倍以上时,先回去核字节和形状,再怀疑带宽。
还在 fp8old 反向 40 号层:view_start=31218.000&view_end=31234.000 ↗ 打开。主核上找 all-gather.546 的 call-start 和 call-done,小核 SparseCore 0 上找号小 1 的 all-gather.545。它几时发令、开搬前在小核上等了多久、搬了多久?done 有多宽?和练习 4 那条 548 比,哪一条在主核上露得多?为什么?
start 31,219.550 ms(比 548 晚 0.04 ms 发令);545 在 547 搬完之后,31,226.187 才开搬,开搬前等了 6.64 ms,搬 2.207 ms,31,228.394 搬完;done 在 31,232.781,宽 0:搬完 4.39 ms 之后主核才走到这里,全藏住。548 露了 1.181 ms,546 一点没露。
怎么看出来:等多久不要紧,要紧的是主核什么时候要用。548 的用户是紧跟在后面的 gmm_megablox.14;546 搬的是另一份专家矩阵 [1,192,1536,4096],它的用户 gmm_megablox_transpose_rhs.10 排在 gmm_megablox.14、.13 两颗之后,晚了 6 ms 多才要。HLO 里 gmm_megablox_transpose_rhs.10 的最后一个操作数 = bitcast(all-gather.546…call-done)(找 HLO 见正文 4.1)。
回到 bf16new 反向 40 号层:view_start=34056.155&view_end=34251.406 ↗ 打开。先找练习 3 那 3 条收 192 个专家的 all-gather 在主核上的 done(号大 1:all-gather.551/.553/.555),各多宽?再找这一窗主核 XLA Ops 上最宽的那块 done,单击读名字和宽度,往下找右沿和它对齐的小核那条:它在干什么、输出什么形状?
3 个 done 都是 0 宽。最宽的是 gather_offload_async_done.3,34,129.891–34,132.862 ms,2.971 ms;对着小核 Sparse Core Ops 行上的 gather_offload_custom_fusion.70.cloned.1.call-done(它下面 TEC 0–15 那些行上是本体 gather_offload_custom_fusion.69),输出 bf16[393216,4096]:按专家搬 token,不是集合通信。
怎么看出来:这条 gather 两颗小核上都有,都从 34,129.579 ms 开始,SparseCore 0 跑 3.277 ms、SparseCore 1 跑 3.283 ms,done 的右沿对齐的是 SparseCore 1 那条。393,216 = 每个 device 12 条 × 4,096 token × 每个 token 8 个专家,和练习 8 里 gmm 输入的行数一样;Details 里这块 done 的 tf_op 末段是 sort_activations/gather。这一层宽过 50 µs 的 done 一共 10 块、合计 5.86 ms。读法:最宽的 done 不一定是通信,先读名字再下结论;两颗小核跑同一条时,done 等的是后结束的那颗。
用练习 11 的脚本导出 fp8tk 的 HLO(目录换成 ~/hy3-prof/fp8tk/plugins/profile/2026_08_15_17_48_55),跑同样两条 grep。再用 grep -oE ' (all-gather|reduce-scatter|all-reduce)\(' fp8tk.hlo.txt | sort | uniq -c 数三类集合通信的总条数,和 fp8old 比。375 s 是通信多出来的吗?
fp8tk:12 条、6 条,和 fp8old 一样;三类合计 all-gather 92、reduce-scatter 6、all-reduce 36,和 fp8old 一条不差(fp8new 是 82/0/36)。通信一条没多,375 s 慢在 kernel 本身(练习 6)。
怎么看出来:fp8tk 和 fp8old 是同一份配方,只差 tile 有没有注入(正文 3.5),程序结构一样,集合通信逐条相同。读法:两份一快一慢,先比程序结构(指令条数)变没变,再比单颗 kernel。
打开 fp8new 前向 40 号层:view_start=9384.136&view_end=9419.813 ↗ 打开。主核 XLA Ops 上第三颗专家矩阵乘 gmm.28 后面紧跟着一块 broadcast_select_fusion…:两块各读 Wall Duration 和输出形状,后一块 Details 里 tf_op 的末段是什么?再打开公开 MaxText 的 backend.py(yangwhale/maxtext 的 hunyuan3 分支 @1afaa0fb,正文 4.5 用的同一版),在 gmm() 里找 num_current_groups 那两行和函数末尾那个 if,再跳到它调用的函数。这一块在做什么?为什么只有改后才有?它比 kernel 本身慢 30 多倍,按字节估一下它该要多久。最后对上正文 3.4、4.6 里 loop fusion 多出来的 276 ms。
gmm.28:0.035 ms,输出 bf16[229376,4096];broadcast_select_fusion.99 紧接着开始,1.202 ms(34 倍),输出同样是 bf16[229376,4096],tf_op 末段 shard_map/jit(gmm)/jit(_where)/select_n。代码:L346 num_current_groups = rhs.shape[0](改后权重只有 3 组)、L347 num_total_groups = group_sizes.shape[0](192 组);L555 if existing_out is None and num_current_groups < num_total_groups: 成立,L556 调 _zero_uninitialized_memory。这个函数(L268–281)按 out.shape[0] 建一个 229,376 长的掩码,只有本 device 那 3 组(从 start_group 起 num_nonzero_groups 组)的行为真(L280),最后 L281 return jnp.where(valid_mask[:, None], out, 0) 把其余行写成 0。估:输出 229,376 × 4,096 × 2 字节 = 1.88 GB,读一遍写一遍 3.76 GB,按每核 HBM 3,433 GiB/s 要 1.02 ms;实测平均 1.204 ms,约用到 85% 的带宽。每步前向 79 次、95.1 ms,反向 select_add_fusion 79 次、225.6 ms,就是 4.6 表里那两类。
怎么看出来:原配方的权重收齐了 192 组,num_current_groups < num_total_groups 是 192 < 192,不成立,这一步根本不跑;改后权重只剩 3 组,kernel 只算这 3 组的行(所以只要 0.035 ms),剩下 189/192 的行靠这一步整块刷成 0 [推断:刷 0 一读一写、卡在 HBM 带宽上]。jnp.where 是逐元素操作,编译成 loop fusion,所以多出来的时间记在 loop fusion 这一类里(正文 3.4 表里 −275.9 ms);反向那份和原来就有的梯度相加融在了一起(原配方那次相加每步 135.5 ms,记在 non-fusion elementwise),所以两类新 fusion 合计约 321 ms 里,去掉换了类别的那 135.5 ms,约 185 ms 才是补 0 本身;loop fusion 这一类只多 276 ms,是因为别的 loop fusion 合计少了约 45 ms(正文 4.6)。读法:trace 上碰到一块不认识的融合,先读 tf_op 末段,它通常就是代码里那一行调的函数;文件和行号要按 profile 对应的那一版代码找(正文 4.5 折叠块)。
正文的 Roofline、显存各只读了一两份 profile。下面五题换到 BF16 和改后那份,由易到难排;答案只在本页。做完这一组,你能在 Roofline 上判断一个点画不画得出来、整步速率该不该信,并在 Memory Profile、Memory Viewer 上说清一个改动省没省显存、峰值那一刻是谁占着。
打开 bf16new 的 Roofline(工具 roofline_model)↗ 打开,Section2 的 Operation 框输 gmm.19;再在 bf16old↗ 打开 里输 gmm_megablox_transpose_rhs.10。各读 Model FLOP Rate、FLOP Rate / Peak 和 Source Info。点画得出来吗?
bf16new gmm.19:513,223 GFLOP/s、49.9%,Source Info 是 MaxText kernels/megablox/backend.py:548;bf16old:475,232 GFLOP/s、46.2%(layers/moe.py:1523)。两颗点都在屋顶下面,画得出来。
怎么看出来:gmm.19 和 fp8new 的 gmm.27 是同一行代码(backend.py:548,改后那条分支),gmm.27 在 FP8 上报 5,674.9%、点冲出纵轴画不出来(正文 3.2 折叠块),gmm.19 在 BF16 上报 49.9%:同一条代码路径,BF16 那份 kernel 拿到的是 192 个专家(练习 8),所以真在干活。截图分享时记得遮掉 Program ID 那一列。
打开 bf16old↗ 打开、bf16new↗ 打开 的 Roofline,第 1 节(Section1)表里 Step 为 Average 的那一行,读 Total Time per core (us)、Normalized FLOP Rate (GFLOP/s) 和 FLOP Rate / Peak。时间、速率各变了百分之几?两数一乘,每步每核记了多少 GFLOP?再拿 fp8old、fp8new 同一行乘一遍。
bf16old 21,767,912 µs、474,422.33 GFLOP/s、46.1%;bf16new 20,713,041 µs、498,583.66 GFLOP/s、48.5%:时间少 4.85%、速率高 5.09%,乘出来两份都是每步每核约 10,327,184 GFLOP,一样多。FP8:fp8old 5,261,170、fp8new 5,267,374 GFLOP,也几乎一样,可时间少了 33.4%、速率高了 50.3%。
怎么看出来:Total Time per core 就是 Overview 的平均步时(21,767.9/20,713.0 ms)。记账的运算量两份一样,因为 XProf 按程序声明的运算量记账:BF16 那份活没少(练习 8 里 kernel 拿到 192 个专家)、时间真少了,速率涨 5% 合情合理;FP8 那份同样多的账面运算量配上短得多的时间,速率涨了五成,活其实少干了(正文 3.2、练习 5)。所以 Average 行的速率只在同一份程序之间比,先确认乘出来的分子没变。
在 Memory Viewer(工具 memory_viewer)↗ 打开 里把 bf16old、bf16new↗ 打开、fp8new↗ 打开 都换到 jit_train_step,读顶上几行:Peak memory allocation、total argument size、stack simulated HLO temporary variables。原配方 fp8old 是 91,766.56 MiB、入口参数 44,533.22 MiB、临时变量 47,230.39 MiB。同一个改动,两种精度下显存各变了多少?
BF16:88,401.89 → 88,399.85 MiB(−2.04),入口参数都是 22,271.03,临时变量 66,127.62 → 66,125.64。FP8:fp8new 91,597.20 MiB,比 fp8old 少 169.36,入口参数一样,临时变量 47,061.12。两种精度下这个改动都几乎不动显存(FP8 少 0.2%)。
怎么看出来:FP8 改后少了 12 条收 192 个专家权重的 all-gather、6 条散梯度的 reduce-scatter,峰值却只少 169 MiB:峰值只看最高那一刻。原配方峰值那一刻活着 5 块 bf16 的 [192,…] 梯度,其中 3 块是反向循环里这一层 tgmm 刚算完、还没散回去的(另 2 块是 MTP 层专家梯度的 all-reduce,在循环外);改后循环里那 3 块没了,可峰值让给了输出头的 logits(正文 3.6),所以只少这么一点。收来的 FP8 专家权重本来就不在两份峰值那一刻最大的几块里(悬停前二十根就能看到:参数、优化器状态、输出头和这几块梯度)。读法:省没省显存,比 Peak memory allocation 和临时变量两行。换完模块后 Module Name 那一行可能还写着默认模块的名字,以下面的数为准。
打开 bf16new 的 Memory Profile(工具 memory_profile)↗ 打开。默认 Memory ID 是 0:读 Profile-window Peak Memory Usage 和它下面的 Timestamp、Stack Reservation、Heap Allocation、Free Memory。把 Memory ID 换成 1 再读一遍。然后在 HLO Modules 表上方的「HLO's at time (ms)」框里填 1 号的峰值时刻,表里剩下哪个模块?最后和 fp8new 的 0 号比 Stack、Heap。
0 号:93.60 GiB,时刻 2.0 ms,Stack 71.42、Heap 22.18、Free 1.13 GiB;1 号:93.52 GiB,时刻 41,419.7 ms,Stack 71.42、Heap 22.10、Free 1.21 GiB。填 41419.7 后表里剩 8 行,都是第二个 jit_train_step(TPU:0–7,21,109.4–41,803.3 ms)。fp8new 0 号:Stack 47.72、Heap 43.89、Free 3.12 GiB。
怎么看出来:Memory ID 是这台主机上的第几个设备(下拉里 0–7)。0 号的峰值落在窗口开头 2.0 ms,HLO Modules 表里第一个模块 395 ms 才开始跑;那一刻它比 1 号多出约 82 MiB heap。两个设备 Stack 一样、只差这点 heap,结论不受影响,但填 HLO's at time 要用落在步里的那个时刻。整条时间线几乎是平的,Stack 从头到尾都是 71.42 GiB。BF16 的 Heap 只有 fp8new 的一半、Stack 多 23.7 GiB:前者和 Memory Viewer 里入口参数只有一半对得上(正文 3.6)[推断:Heap 主要是常驻的参数和优化器状态,两者只差 0.4 GiB 左右],后者和临时变量多(练习 22)同方向。
打开 bf16new 的 Memory Viewer(工具 memory_viewer)↗ 打开,Hlo Modules 下拉换成 jit_train_step,读顶上的 Peak memory allocation。滚到 by Buffer Size,从左往右悬停第 0–4 根和第 11 根(从 0 数),读左栏的名字、Size、Shape、Framework Op。最大的三块是什么、加起来占峰值几成?第 3、4 根和第 11 根又是什么?
峰值 88,399.85 MiB(含碎片 93,519.35)。第 0–2 根各 11,328 MiB,形状都是 bf16[12,4096,120832](multiply_convert_fusion.1、fusion.1218{1}、select_reduce_fusion.3{1},Framework Op 末段分别是 convert_element_type、dot_general、reduce_sum),三块 33,984 MiB,占峰值 38.4%。第 3、4 根是 gather_offload_custom_fusion.79/.81,各 3,072 MiB,bf16[393216,4096],Framework Op 末段 sort_activations/gather;第 11–13 根各 2,304 MiB,是 all-gather.604/.605(bf16[192,4096,1536])和 copy.1717…(bf16[192,1536,4096]);同样宽的条每次开页面先后会变,第 11 根悬停出来是其中哪一块都对。
怎么看出来:120,832 是词表大小(配置 vocab_size),12 是每个 device 12 条:12 × 4,096 × 120,832 × 2 字节 = 11,328 MiB,是输出头的 logits 一类 [推断:按形状和 Framework Op 认]。393,216 行就是练习 17 那条按专家搬 token 的输出。all-gather.604 这一组是收齐 192 个专家的 BF16 权重:192 × 4,096 × 1,536 × 2 字节 = 2,304 MiB,峰值那一刻它还活着,BF16 这份程序确实收了 192 个专家(练习 3、8)。第 5–10 根是参数和 Adam 的 nu,形状 f32[192,79,32,1536] 一类:192 个专家都在、切的是 4,096 那一维。