One-Sided Expert-Parallel All-to-All for Mixture-of-Experts Inference over NVLink

Bo Li, Chulian Zhang, Or Biri, Anthony Chang, Anton Korzh, Noam Duvdevani, XingFei Xi, Daniel Stokes, Zhenhuan Chen 等 13 人 · arXiv 2611.13188 · 发表 2026-11-11
17 分钟阅读时长 6445字 4.35综合分 第 3 名11-12 Infra 日报
目录 · 7 节1两卡 top-2 的例子:同一个 token 要去哪里2发送方自己挑槽位,一个 token 对一张卡只写一次3grouped GEMM 按槽位编号原地读4剩下的固定开销是两次同步5Sentinel:让数据本身当到齐信号6每 rank 1 个 token,往返从 47.9 降到 17.4 微秒7能用它的前提是整个 EP 组在一个 NVLink 域里
相关 4新颖 4实用 5证据 4时效 5

NVIDIA 这篇 NVLinkOneSided 的判断是:推理时 MoE 的 all-to-all 在小 batch 下慢在固定开销,不在搬数据;在一个 NVLink 域里,让每张卡凭自己的路由结果直接把 token 写进对方显存里按来源卡分好的槽位,省掉元数据交换和按专家重排;小 batch 时再让数据本身充当「到齐」信号、省掉栅栏,就能把这部分开销砍掉大半。

先说场景。现在部署 MoE 大模型,常见做法是 attention 按数据并行(DP)跑、MoE 层按专家并行(EP)跑:每张 GPU(论文叫 rank)在 attention 里只处理自己那批请求,在 MoE 层里只持有一部分专家。于是每个 MoE 层都要做两次 all-to-all。第一次叫 dispatch,把每个 token 送到持有它所选专家的那张卡;第二次叫 combine,把专家算完的结果送回 token 原来的卡,加权求和。送多少、送给谁,全看路由器这一步怎么选,所以这是一个大小不固定的 all-to-all。

难点在于推理每张卡手里的 token 很少。解码要满足每个输出 token 的时延目标,每 rank 的 batch 只能有几百个 token。论文举的例子是 DeepInfer 解码 DeepSeek-V4.1-Flash:每 rank 64 个请求,每个请求带 3 个草稿 token,一步一共 256 个 token。token 少到每 rank 只有几个时,要发的字节按 NVLink 理论带宽算不到 1 微秒,可实测的 dispatch 加 combine 往返要几十微秒。多出来的时间花在不随 token 数增长的固定开销上,最典型的是不同 GPU 上生产者和消费者之间的同步。

现有做法在这里多绕了一步。NCCL 和 DeepEP(DeepSeek 开源的 EP 通信库)的发送方先把数据写进一块中间缓冲区,接收方再把它拷贝或重排成下一个 kernel 要的布局。DeepEP V2.5 配 DeepGEMM 时更进一步:DeepGEMM 要求同一个专家的 token 连续存放(论文叫 expert-major 布局),所以收到的 token 要按「选中了本卡的几个专家」再复制几份。小 batch 时,这一遍额外拷贝加的是时延;大 batch 时,它吃的是显存带宽。下面用一个两卡的例子看它具体多做了什么。

两卡 top-2 的例子:同一个 token 要去哪里

论文全文都用同一个例子,我也沿用它(示意,只有 2 张卡、4 个专家):R0 持有专家 E0、E1,R1 持有 E2、E3;每个 token 选 2 个专家。R0 上有 T0–T3 四个 token,R1 上有 T4–T6 三个。

论文 Figure 1:两卡 top-2 路由例子。R0 持有 E0、E1 和 T0–T3,R1 持有 E2、E3 和 T4–T6;每个 token 旁边是它选的两个专家和对应的目标 rank;R1 的 token 数 T=3,各 rank 中最多的 token 数是 4
论文 Figure 1:两卡 top-2 路由例子。R0 持有 E0、E1 和 T0–T3,R1 持有 E2、E3 和 T4–T6;每个 token 旁边是它选的两个专家和对应的目标 rank;R1 的 token 数 T=3,各 rank 中最多的 token 数是 4
token(所在卡)选中的专家要去的卡
T0(R0)E0、E2R0、R1
T1(R0)E0、E1只有 R0
T2(R0)E1、E3R0、R1
T3(R0)E2、E3只有 R1
T4(R1)E1、E2R0、R1
T5(R1)E2、E3只有 R1
T6(R1)E0、E3R0、R1

T1 是最能说明问题的一行。它选的两个专家都在 R0 上。按 expert-major 的做法,R0 要给 E0 存一份 T1、给 E1 再存一份 T1,同样的隐藏状态在显存里出现两次。另外,R0 和 R1 都会往同一张卡写数据。如果所有来源卡共用一个槽位池,要么对远端计数器做原子操作,要么先交换各卡的 token 计数算出偏移。论文给通用设计列的开销是另外两项:生产者与消费者之间的同步,以及中间缓冲区的那一遍额外拷贝。

发送方自己挑槽位,一个 token 对一张卡只写一次

NVLinkOneSided 的出发点是对称内存:在同一个 NVLink 域里,每张卡用 CUDA 的虚拟内存管理把其他卡的显存映射进自己的地址空间,kernel 用普通的 load、store 就能读写别的卡的显存。NVIDIA 的 HGX(GPU 服务器主板)B300 上的 8 张卡、GB200 NVL72(NVIDIA 的 72 卡整机架)里的 72 张卡,都各自是一个这样的域。

有了直接写的能力,每张卡只凭自己的路由结果就知道每个 token 要去哪些卡,可以直接把 token 推进目标卡的显存,并在本地记下「写到了哪张卡的第几个槽」。token 计数、专家 id 这类元数据不必先发出去。用 Fence 协议时,token 直接写进 grouped GEMM 读取的 dispatch 工作区;用 Sentinel 协议时,token 先落进一组 landing 槽,后面再细说。

难题是好几张卡会同时往同一张目标卡写,槽位不能撞。上面说过,共用一个槽位池要么做远端原子操作,要么先交换计数,又回到了元数据交换。论文的办法是 rank-major 布局:目标卡的 dispatch 工作区按来源卡分区,每个区只有对应的那张来源卡会写,它在本地对「发往这张目标卡的计数器」做原子加一,拿下一个槽。每个区留 T̂ 个槽,T̂ 是这一步各卡中最大的 token 数;DP attention 的推理引擎每步本来就同步 batch 大小,所以每张卡都知道 T̂。

一个 token 对同一张目标卡只占一个槽,它的 k 个专家 id 和路由权重都放在槽里。回到例子(示意,按 Fence 协议的填法),R0 的 dispatch 工作区填完是这样的:

R0 的 dispatch 工作区(T̂ = 4,两个区共 8 个槽)
来自 R0 的区:槽0 T0 [E0,E2]  槽1 T1 [E0,E1]  槽2 T2 [E1,E3]  槽3 空
来自 R1 的区:槽4 T4 [E1,E2]  槽5 T6 [E0,E3]  槽6 空          槽7 空

T1 只占了槽 1 一个位置。这一点在专家多时省得更明显:一个 token 最多发 min(k, P) 次,而不是 k 次。以 k=16、8 张卡为例,无论路由怎么选,一个 token 最多发 8 次,字节最多是逐专家发送的一半。

工作区也因此变小。DeepSeek-V4.1-Flash 在 8 张卡上、每 rank 最多 4096 个 token 时,这套布局的 dispatch 工作区 160 MiB(MXFP8),combine 工作区 320 MiB(BF16)。DeepEP V2.5 配 DeepGEMM 需要 242 MiB 通信缓冲区,外加按专家排列的 GEMM 输入,光隐藏状态就占 1020 MiB。这说明省掉那一份按专家复制的输入,显存账差的是好几倍;两种协议都不按专家复制,而这些缓冲区都随 EP 规模线性增长。Sentinel 另外还要一组 landing 槽,并多一次从 landing 槽到 dispatch 工作区同一槽位的拷贝,上面的 160 MiB 只算了 dispatch 工作区。

grouped GEMM 按槽位编号原地读

token 留在槽里不挪,专家怎么拿到自己的 token?论文在 MoE 计算前加了一个小的索引 kernel,把槽里的专家 id 翻成「每个专家要读哪些槽」的列表。接着上面的例子,R0 上的索引结果是(示意):

E0 → 槽 [0, 1, 5]   (T0、T1、T6)
E1 → 槽 [1, 2, 4]   (T1、T2、T4)
空槽 3、6、7 的专家 id 无效,跳过

槽 1 同时出现在两个列表里,但 T1 的数据只存了一份。FC1(专家的 up/gate 投影)用 gather 指令按这些编号直接从 dispatch 工作区取数据,不读空槽;FC2(第二个 grouped GEMM)做 down 投影。最后的 finalize 把同一个 token 在本卡各专家上的输出按路由权重加起来,写回 combine 工作区里同一个槽号。T1 在 E0、E1 上的两份输出,就在 R0 本地加成一份,放进槽 1。

论文 Figure 3:R0 上的 MoE 层。索引 kernel 把收到的专家 id 变成每个专家的槽位列表,空槽 3、6、7 的 id 无效;FC1 按列表取 token,FC2 再乘自己的权重,finalize 把每个 token 的输出加到 combine 工作区它所在的槽
论文 Figure 3:R0 上的 MoE 层。索引 kernel 把收到的专家 id 变成每个专家的槽位列表,空槽 3、6、7 的 id 无效;FC1 按列表取 token,FC2 再乘自己的权重,finalize 把每个 token 的输出加到 combine 工作区它所在的槽

结果回到了和 dispatch 一样的 rank-major 位置,combine 也不需要元数据:来源卡按 dispatch 时记下的「目标卡、槽号」,从各目标卡的 combine 工作区把部分结果取回来相加。

剩下的固定开销是两次同步

数据路径简化之后,还剩一件事绕不过去。远端 store 发出去就不管了,可能乱序到达,GPU 内存又是弱序的。所以有两处必须同步:dispatch 结束时,目标卡要确认所有来源卡都写完了才能开始算;combine 开始时,来源卡要确认所有目标卡都算完、写完了才能读。

第一种协议叫 Fence。每个线程块处理一个 token,最后完成的那个块代表整张卡做收尾:把各目标卡的槽位计数写过去,先执行一次系统级 release 栅栏,再给每张对端卡发布一个完成标志,然后等所有对端的标志都到。之后再由一个小 kernel 把计数之后的槽标成无效(专家 id 写 −1)。这条链是串行的:原子计数、栅栏、写标志、等标志,一样都省不掉。

Sentinel:让数据本身当到齐信号

Sentinel 想去掉的正是这条串行链。它利用了 NVLink 的一个保证:写到对端显存里的每个对齐 32 位字,要么整个可见,要么完全不可见,不会只到一半。于是来源卡不直接写 dispatch 工作区,而是把 token 推进目标卡的 landing 槽。landing 槽的每个 32 位字预先填一个哨兵值,也就是数据不会取到的位模式。BF16 数据用 0xFFFFFFFF(两个 BF16 NaN),生产者真遇到这个值时,改写成两个 0x7FFF NaN。目标卡轮询一个 landing 槽,所有字都不等于哨兵,这个槽就完整到了,不需要栅栏。目标卡随后把它拷进 dispatch 工作区的同一槽位,MoE 计算照 Fence 一样从这里读,再把 landing 槽重置成哨兵。NCCL 的 LL 协议是在数据里插标志字,Sentinel 不插,数据本身就是标志。

这里有一个更简单的做法行不通:只轮询「有 token 的槽」。目标卡事先并不知道哪些槽会来数据,它分不清一个槽是还在路上,还是根本不会来。还是看例子里的 R1(示意):

R1 收到的槽位,Sentinel 协议(token i 固定落在槽 i;没有 token 的槽保留哨兵)
来自 R0 的区:槽0 T0 [E0,E2]  槽1 哨兵 [−1,−1]  槽2 T2 [E1,E3]  槽3 T3 [E2,E3]
来自 R1 的区:槽0 T4 [E1,E2]  槽1 T5 [E2,E3]    槽2 T6 [E0,E3]  槽3 哨兵 [−1,−1]

T1 不去 R1,所以来自 R0 的槽 1 永远收不到数据。为了让 R1 不在这个槽上死等,Sentinel 定了两条规则:来源卡的第 i 个 token 固定落在自己分区的第 i 号槽;每张来源卡给每张目标卡的全部 T̂ 个槽都写专家 id,没有 token 的地方写 −1。R1 看到槽 1 的专家 id 是 −1,就知道这里不会有数据。来自 R1 的槽 3 同理,它超出了 R1 本步 3 个 token 的范围。combine 也改成推送:目标卡算完就把部分结果写到来源卡,不等其他卡。

论文 Figure 4:R1 在 dispatch 结束时的工作区。(a) Fence 把每个来源卡的 token 填进分区前缀并发送计数 C=3,之后的槽专家 id 为 −1;(b) Sentinel 让第 i 个 token 落在第 i 号槽,没有 token 的槽保留哨兵(斜线)并带 −1。下方对比 dispatch 关键路径:Fence 要写计数、栅栏、同步标志,Sentinel 推送 token 的同时轮询槽位,省下的部分标为 saved
论文 Figure 4:R1 在 dispatch 结束时的工作区。(a) Fence 把每个来源卡的 token 填进分区前缀并发送计数 C=3,之后的槽专家 id 为 −1;(b) Sentinel 让第 i 个 token 落在第 i 号槽,没有 token 的槽保留哨兵(斜线)并带 −1。下方对比 dispatch 关键路径:Fence 要写计数、栅栏、同步标志,Sentinel 推送 token 的同时轮询槽位,省下的部分标为 saved

这套协议的代价会随 batch 增长,因为每张卡每步都要写、轮询、重置 P·T̂ 个专家 id 槽,每个收到的字都要检查、拷进 dispatch 工作区,再把 landing 槽重置成哨兵。batch 一大,这些逐槽工作就抵消了省下的那条串行链。

每 rank 1 个 token,往返从 47.9 降到 17.4 微秒

实验在 8 张 B300 上做,测的是 DeepSeek-V4.1-Flash(384 个专家选 6 个)和 Kimi-K3(896 个专家选 16 个)的路由专家层,每 rank 1 到 4096 个 token,路由是理想均匀的。最能说明问题的是每 rank 1 个 token 的情形,因为这时几乎全是固定开销:此时,DeepSeek-V4.1-Flash 的 dispatch 加 combine 往返,Sentinel 17.4 μs,Fence 27.6 μs,DeepEP 47.9 μs。所有 batch 下 NVLinkOneSided 都比 DeepEP 快:128 token 以内快 1.75–3.00 倍,256 起快 1.17–1.63 倍。

这说明收益主要来自固定开销:token 越少,加速比越大。两种协议的交叉点在每 rank 256 个 token。论文用 kernel 内打点追踪看了关键路径:1 个 token 时,两种协议等对端的时间差不多,Sentinel 省的是等待前后的工作,它的 dispatch 跳过了 Fence 的串行链和额外 kernel,耗时只有一半。Sentinel 缩短的是等待周围的工作,不是等待本身。

整层的比较还要引入两个基线。DeepEP+DeepGEMM 是 DeepEP 通信配 DeepGEMM 计算的非融合版本;MegaMoE 是 DeepGEMM 里把 NVLink 传输和计算塞进同一个常驻 kernel、让两者重叠的融合版本。下面是 DeepSeek-V4.1-Flash 整层时延(μs,摘自论文 Table 4):

每 rank token 数FenceSentinelDeepEP+DeepGEMMMegaMoE
146.036.774.749.8
1679.670.5122.090.3
128188.5183.3235.9188.7
256208.1206.5251.2194.1
40961185.21198.61290.2766.1

比 DeepEP+DeepGEMM,NVLinkOneSided 每个 batch 都快,最多 2.4 倍,差距主要在 dispatch 和 combine 两段。比 MegaMoE,它在 128 token 以内快最多 30%;从 256 起 MegaMoE 领先,4096 时领先最多 35%。这说明分开的 kernel 在解码区间仍有竞争力,但大 batch 时,把通信藏在 grouped GEMM 后面更划算。注意这三个倍数的对照对象不同:1.2–3.0 倍是通信往返对 DeepEP,2.4 倍是整层对 DeepEP+DeepGEMM,30% 是整层对 MegaMoE。

两组补充实验也落在同一个机制上。路由不均衡(Zipf 分布)、每 rank 1024 个 token 时,最忙的卡算的 token-专家对最多是均衡时的 1.9 倍。但一个 token 对一张卡只发一次,这张卡收到的字节跟着 token 数走,不跟着 token-专家对走。所以 Zipf 指数 1.25 时,最忙卡的 dispatch 和 combine 只要 160 和 135 μs,DeepEP+DeepGEMM 要 267 和 400 μs,因为后者要按专家复制 token。

扩到 GB200 NVL72 的 64 张卡时,1 个 token 的往返 Sentinel 保持在 16.6–17.8 μs,Fence 从 43.0 升到 47.6 μs。这说明 Sentinel 没有逐对端的握手,卡数变多它几乎不涨。

能用它的前提是整个 EP 组在一个 NVLink 域里

这套设计离不开两件事:对端显存能直接 load/store,每个 32 位字整体到达。RDMA 两样都不提供,一次 RDMA 写里数据的落地顺序是未定义的。所以 EP 组必须装进一个 NVLink 域,比如 8 卡 HGX 或 72 卡的 NVL72 机架。另外,dispatch 工作区给每张来源卡留一个区,显存随 EP 规模增长。评测用的是理想均匀路由加 Zipf 模拟,给的是算子和单层时延,不是端到端服务吞吐。

回到开头那个两卡例子:T1 在 R0 上只占一个槽,R1 不需要先听到「R0 要发几个」,只要看到槽 1 的专家 id 是 −1 就知道不用等。每 rank 只有一两个 token 的解码步里,省下的就是这些等元数据、等栅栏、按专家重排的微秒。目前它已集成进 FlashInfer 和 vLLM;作者也提到,下一步打算把这套单边设计放进融合 kernel,去追 MegaMoE 在大 batch 下的通信计算重叠。

读完这篇,你觉得

点一下即可,无需登录;再点一次撤回。只统计匿名次数,不记录你是谁。

相关论文RELATED

  1. Infra · 2026-11-02Nemotron 3.5 Super and Lightning: Open, Efficient Mixture-of-Experts Hybrid Mamba-Transformer Models for Agentic AI开源模型做 agent,能力和推理成本常常只能顾一头。NVIDIA 的 Nemotron 3.5 Super 把两头一起优化:它是 Mamba 和 Transformer 混合的 MoE 模型,每个 token 只激活约十分之一的参数,在 SWE-bench Pro 上拿到 51.78%,超过了激活参数多好几倍的上一代 Ultra。对做推理部署的人更有用的是它的部署设计:模型自带多 token 预测头来做投机解码,后训练里再专门练这个头,平均每步被接受的 token 数比原来的头多出 21.8%(按概率采样草稿时),贪心解码时多出 10.1%。NVFP4 量化后,在交互式 agent 负载上吞吐是 BF16 的 2.43 倍。基座、后训练和量化后的权重连同训练数据一起开放。
  2. Infra · 2026-11-02Rimuru: Unified Memory Management for Modern LLM Serving via Elastic Expert Offloading把 MoE 模型的专家权重和 KV cache 放进同一池显存,按负载随时调整两边各占多少,显存有限的机器就能接住更多并发请求。Rimuru 就是这样的推理系统:请求多时把用得少的专家移出显存,给 KV cache 腾出页,请求少时再把专家搬回来。为此它改写了 MoE 计算核,直接读取不连续存放的专家权重。现有的专家卸载系统在启动时就把显存切成固定的两块,请求一多 KV cache 就不够用。在显存刚好放得下全部权重的 5090 机器上,Rimuru 主动移出一部分专家来接更多请求,吞吐是权重全放显存的 vLLM 和 SGLang 的 1.1 到 2.88 倍。
  3. Infra · 2026-11-13Multi-Future Drafting: Mixture Block Drafters for Tree-Verified Speculative Decoding投机解码里,一次前向就起草一整块 token 的草稿模型很快,但它给每个位置单独一个分布。后文有两种同样合理的措辞时,按各位置概率连乘排出的草稿树会把两种说法拼成目标模型根本不会说的句子。作者证明,这类树想同时放下两种说法,就必须给它们的拼接也分预算,草稿模型训得再好也绕不开,因为连乘本身表达不了位置之间的关联。实测 64 个节点的树里约三成节点是这种拼接。MFD 在草稿模型输入端加 K 个可学习的模式向量,同一次前向里并行起草 K 条各自连贯的续写,再合成一棵树交给目标模型验证,输出分布不变。在四个 Qwen 目标模型上,它比同样训练的单模式树快 5% 到 8%。
  4. Infra · 2026-11-12ForeSpark: Joint Draft and Verification Budget Scheduling for Parallel Speculative Decoding并行草稿模型一次前向就能写出一整块草稿 token。现在的做法是先写满一整块,再挑最有希望的几个去验证。作者发现高负载下这很浪费:写草稿占到每步时间的 40%,而写出来的大部分根本没被验证就丢掉了。难点在于并行草稿模型必须在写之前就定好长度,没法像逐个生成的草稿模型那样写到没把握时停下。ForeSpark 在写草稿前,先用目标模型当前的上下文特征估计每个请求写不同长度时能被接受多少,再把整个 batch 里所有请求的草稿长度和验证名额一起排序分配。在 vLLM 上,同样的单请求生成速度下,吞吐比目前最强的 DSpark 最多高 1.77 倍,输出分布不变。草稿写多长,要在写之前按请求定下来。
  5. Infra · 2026-10-26KVStream: Adaptive Parallel Storage Management for KV Caching in Large-Scale LLM Serving长上下文推理会反复用到同一段前缀,比如系统提示、整份文档、代码仓库和多轮会话历史。这些前缀的 KV cache 早已放不进 GPU 显存和主机内存,只能落到硬盘上,下次命中再读回来,读盘就卡在了每一步推理的关键路径上。现有系统只读节点本地的 NVMe,集群早已挂载的并行文件系统却几乎闲着。这篇论文做了 KVStream:每块 KV 在本地盘和共享存储各写一份,读的时候两边同时读,谁先读完谁接着领下一批。接进 LMCache 实测,离线吞吐最高是 LMCache 的 1.49 倍,突发流量下平均 TTFT 最多快 6.1 倍。

讨论

欢迎补充实验细节、复现经验或不同看法。需 GitHub 登录。

正在加载讨论…