Step-5 的 MoE 路由:选出 8 个专家,再找到它们在哪张卡上

Step-5 的 MoE 路由:选出 8 个专家,再找到它们在哪张卡上

一个 token 到达 MoE 层,先要决定交给哪些专家,再把全局专家编号换成本卡能用的编号。这两步紧挨着,耗时的原因却不同。第一步要连续做 8 次选择,后一次依赖前一次的结果。第二步只是查表,小批量下,准备索引花的时间就已经超过查表本身。

选专家时,可以把“谁的分数高、同分时谁的编号小”编码为一次整数比较。到了分发阶段,编号已经是 int32,查本卡专家表也可以直接用它。

把平局规则编进比较键

在原稿测试的配置里,每个 token 有 352 个候选专家。先算出每个专家的 sigmoid(logit) + bias,选分数最高的 8 个,同分时选编号较小的。旧 kernel 每轮同时求最大值和下标,屏蔽赢家,再选下一位。16 行的小实验里,8 轮只求最大值用 2.78 µs,换成同时跟踪下标就到了 4.99 µs。两组都保留轮次之间的依赖,因而确实测到了 8 轮工作。

分数和下标可以装进同一个整数。先把 FP32 分数的位模式转换为保持数值顺序的无符号整数,再左移 9 位,低位填入 511 - 专家编号。9 位能容纳这组候选。假设 7 号和 12 号专家同分,它们的高位相同,低位分别是 504 和 499,一次整数最大值归约就会选中 7 号。取回低 9 位也就找回了专家编号。

16 行时的完整 top-8 4 个 warp 1 个 warp
同时归约分数与索引 6.11 µs 8.46 µs
归约打包整数 5.13 µs 4.65 µs

单独减线程会让旧实现变慢。换成一个整数参加比较之后,一个 warp 就能完成这部分工作,还省下了跨 warp 交换中间结果。用实际 prefill 大小的 8192 行测,完整 kernel 从 82.85 µs 降到 36.72 µs。

有个细节决定了输出能否对齐。bias 只参与选人,选中后的权重仍取原始 logit 的 sigmoid。用加过 bias 的分数再减去 bias,可能丢掉小概率值。因此实现按赢家编号重新读取原始 logit,按选出顺序累加 8 个概率,再归一化并乘 3。测试还单独覆盖了平局、正负零、NaN 和 padding。比如一行同时有 NaN 且属于 padding,最终 ID 应为 -1。路由实现 · 设备端对照测试

查本卡专家编号,只需要一次读取

全局编号出来后,分发器执行类似 table[topk_ids] 的操作。查看 decode trace 才能看到,这一行先把 int32 索引复制成 int64,再按索引查表。批量为 4、每个 token 选 8 个专家时,总共只查 32 项,却启动了两次 kernel。

新的查表 kernel 直接读取 int32 编号,查完立即写出本地编号。这里必须保留负索引语义:输入的 -1 会索引表的最后一项,该项也是 -1,表示跳过。本 rank 不负责的专家同样应映射为 -1。调用点检查类型和连续布局,符合条件才进入这条路径。查表实现 · 查表测试

这两次改动来自不同实验。只换 top-8,在 TP16/EP16 的 INT8 服务上,102400 token 的 prefill 从 17.985 秒降到 17.926 秒,省约 0.33%。查表改动则是在另一份 decode trace 中测的,相关 kernel 的全报告均值每次合计从 9.85 µs 降到 1.63 µs。一轮观察到 88 次查表,累计少约 0.72 ms 设备时间。

把比较键拆开看

一个线程块负责一个 token。Triton 展开 512 个候选位置,前 352 个对应专家,余下的位置屏蔽。最容易写错的是分数的高位:bias 可能把分数推成负数,直接把 FP32 比特当无符号整数比较,会把带符号位的负数排到正数前面。原始提交先把分数映射成一个随数值递增的整数:

1
2
3
4
scores = scores + 0.0
bits = scores.to(tl.int32, bitcast=True).to(tl.int64) & 0xFFFFFFFF
ordered = tl.where(bits >= 0x80000000, bits ^ 0xFFFFFFFF, bits | 0x80000000)
key = (ordered << 9) | (511 - expert).to(tl.int64)

第一行把负零折成正零。对负数,把 32 位逐位取反,这样 −2 排在 −1 前面;对非负数,把最高位置 1,这样零和正数都排在负数之后。排序键的低 9 位只在高位相等时决定胜负。一次选择的要点只有三行,中间计算权重的代码在这里略去:

1
2
3
best = tl.max(key, axis=0)
index = (511 - (best & 511)).to(tl.int32)
key = tl.where(expert == index, -1, key)

例如 7 号胜出时,低 9 位是 504,511 - 504 取回 7。所有正常键都是非负整数,把这个位置改成 −1,下轮就会轮到其他专家。八轮仍然串行;省下的是每一轮归约中单独传递索引的成本。

取回编号后还要算权重。假设 7 号专家的概率为 0.25、bias 为 0.5,它凭 0.75 参加排名,最终归一化时用的仍是 0.25。实现重新读出赢家的 logit,按选择顺序逐项累加概率,最后执行 weights / (total + 1e-20) 再乘 3。把八项改成树形求和会改变 FP32 加法的次序,输出末位可能随之变化。对照测试为此保留了旧的设备端归约实现,可以同时比较选中的编号和权重。

用一张小表看懂分发器的负索引

假设只有 4 个全局专家,本卡负责 1 号和 3 号,本地编号依次是 0 和 1。映射表可以写成 [-1, 0, -1, 1, -1],末尾额外留一项。输入 [3, 0, -1] 应当得到 [1, -1, -1]:3 号交给本地 1 号,0 号属于其他卡,最后一项是原本就应跳过的 token/专家项。

1
2
3
4
idx = tl.where(idx < 0, idx + table_numel, idx)
in_range = (idx >= 0) & (idx < table_numel)
val = tl.load(table_ptr + idx, mask=mask & in_range, other=-1)
tl.store(out_ptr + offs, val, mask=mask)

对这张长度为 5 的表,输入 −1 会变成下标 4,恰好读到尾部的 −1。调用点只在支持的设备、连续布局和 int32 类型下走这条路径。这样才可以省掉索引类型转换,直接拿每个全局编号做一次读取。

后来为何又回到两次归约?

前面的 2.26 倍来自 ZW810E 上的 int64 打包版本。它缩短了比较过程,不过每挑出一个赢家,循环仍要去读对应的 logit 并计算 sigmoid。仔细看数据依赖,第 2 名是谁只取决于哪些专家还在候选集里;第 1 名的最终权重可以晚一点再算。

后来的单 warp 版本把循环分成“先选齐、再算权重”。每轮先取最高分,再从所有同分专家中选编号最小的,把编号留在八项向量里。循环结束后,才一次读出八个 logits:

1
2
3
4
best = tl.max(scores, axis=0)
index = tl.min(tl.where(scores == best, expert, 512), axis=0)
indices = tl.where(slot == k, index, indices)
scores = tl.where(expert == index, -float("inf"), scores)

这里 512 大于所有有效专家编号,所以第二次归约只会在赢家中挑最小 ID。最后仍按选择顺序累加八项概率。早先那组 5.17 µs 的实验只替换了归约,保留了循环内的重读;它没有测试这个组合。原稿记录的 V900P 耗时为 2.83 → 1.80 µs,ZW810E 上这两版的同口径对照尚缺。双归约版本的完整实现

对应提交

文中改动与代码入口 原始提交
把分数和专家 ID 打包进 int64,一轮整数最大值归约同时得到两者。文中的 82.85 → 36.72 µs 对应这个历史版本。 0eef32dd7e
后续版本每轮先求最高分,再在同分专家中取最小 ID,八轮结束后集中读取赢家 logits。 8131e7a3e4
分发阶段直接用 int32 查本卡专家表,保留负索引回绕。看 local_expert_lookup 和 dispatcher 中的调用点。 484bd782ce

Step-5 的 MoE 路由:选出 8 个专家,再找到它们在哪张卡上
https://dingfen.github.io/2026/11/22/2026-11-22-Step5-ppu04/
作者
Bill Ding
发布于
2026年11月22日
更新于
2026年11月22日
许可协议