正在获取所在地区…
正在读取天气
音乐
暂未播放
扩散模型从零讲起(三):dLLM 推理系统——dInfer、Fast-dLLM 与真实硬件上的服务设计
写在前面:从数学走到系统
前两篇已经把这套生成机制完整走过一遍。第一篇从加噪与去噪的高斯链讲到 DDPM 的闭式后验、DDIM 的确定性轨迹、score matching、Flow Matching,以及 DiT 用 adaLN-Zero 注入全局条件;第二篇把同一个过程搬到离散状态空间,推导了 CTMC 框架下的离散 ELBO、吸收态掩码扩散的后验两项式、按 1/t 加权的交叉熵训练目标、随机采样与重掩码、块并行解码,以及掩码扩散下 KV 缓存为什么不能照搬自回归。
那些讨论都停在”机制对不对”。本篇换一个问题:这套机制在真实硬件上跑的时候,推理系统该怎么设计。这个问题在第二篇结尾已经点过名——缓存、调度、块内轮数、块长的在线选择——但当时只给了定性的判断。现在要把它落到具体的系统、具体的数值和具体的瓶颈上。
本篇依赖四篇一手材料:
- dInfer(蚂蚁集团等,2025 年 10 月发布,arXiv 2510.08666v3),第一个把 dLLM 推理拆成”模型 / 扩散迭代管理器 / 解码策略 / KV 缓存管理器”四模块的完整框架;
- Fast-dLLM(香港大学、NVIDIA、MIT,2025 年 5 月发布,arXiv 2505.22618v3),提出块级近似 KV 缓存与置信度阈值并行解码,是后续几乎所有工作对照的基线;
- Sparse-dLLM(复旦大学等,2025 年 8 月发布,arXiv 2508.02558v2),在 KV 缓存上再做动态驱逐,把缓存问题从”能不能用”推进到”存多少”;
- Serving Masked Diffusion LLMs: Characterization and Design Principles from Real Hardware(Virginia Tech,2026 年 8 月,arXiv 2608.23807v1),第一篇系统测量 dLLM 在并发服务负载下行为的论文。
四篇材料指向同一个结论:dLLM 推理的瓶颈分布与自回归推理很不一样,从算法到内核再到运行时,每一层的优化目标都被”迭代去噪”这件事改写了。
dLLM 推理为什么和自回归推理不同
先回忆:自回归推理的代价结构
设上下文长度 L、词表大小 V、隐藏维度 d、层数 N。自回归模型逐 token 生成,第 t 步只需计算新 token 的 query,并对长度为 t 的 KV 缓存做注意力。由于因果掩码,前缀 token 的 key/value 一旦算好就不再变化,所以每步的计算量是 O(t⋅d) 级别的线性量,而”权重矩阵乘”这一部分(FFN 与投影)每步是 O(d2) 的固定量。
这套结构带来三个性质:
- 缓存是精确的。因果掩码保证已生成 token 的表示不会被后续 token 改写,KV 缓存可以直接长期复用。
- 计算随时间线性增长。序列越长,单步注意力越重,所以自回归推理的 decode 阶段是典型的”访存受限”——每算一个 token 要读一遍全部 KV,算术强度很低。
- 跨请求可以共享前向计算,这就是连续批处理(continuous batching)的基础。vLLM、Orca 这类系统在迭代边界上做准入与驱逐,让不同请求共享每次 forward 的 GPU 时间。
dLLM 的代价结构:三个性质全部被改写
掩码扩散的生成是”整块同时去噪”,第二篇已经把流程讲清楚了。落到推理系统上,三个性质分别变成:
第一,缓存变成近似。掩码扩散使用双向注意力,一个位置上的 token 被确定后,仍然会影响同一块内其他掩码位置的表示,甚至影响相邻块的表示;更重要的是,每个去噪步骤都会对全序列重算一遍前向。Fast-dLLM 的论文直接点出这一点:双向注意力的性质使”完全等价的 KV 缓存”不可能存在,只能用近似。dInfer 的表述更直接——解码单个 token 会改写全序列中所有 token 的表示,使得朴素复用不可行。
第二,每步的计算量几乎与上下文等长,与生成了多少 token 无关。自回归的第 t 步只算一个 token;dLLM 的第 t 个去噪步骤要对整个块(甚至整个序列)做前向。这意味着 dLLM 的算力浪费是”显式”的:如果块内还有一半位置是掩码,那一半的算力用于为尚未确定的 token 产生概率分布,而不是直接产出 token。
第三,并行度来自”步”而不是”请求”。后文会看到 Virginia Tech 的测量:dLLM 服务中真正的共享单位是每个去噪步骤的一次前向,批处理的主要收益是摊薄这一步的调度开销,而不是像自回归那样提高 GPU 的矩阵乘利用率。
统一记账:dLLM 的成本由什么决定
一个请求的端到端时间可以拆成三部分:前向计算、步骤数、调度开销:
Treq=前向次数×单次前向耗时S⋅bL⋅TPFb+每步调度开销Tdispatch+T其余其中 S 是总去噪步数、b 是块长、TPF(tokens per forward)是单次前向平均确定并提交的 token 数、L 是生成长度。这个式子几乎把本篇所有优化归了类:
- 增大 TPF:并行解码策略、迭代平滑、轨迹蒸馏(算法层);
- 减少每步的计算量:KV 缓存复用、稀疏化与驱逐(缓存层);
- 减少 Tdispatch 与提升单位时间内的前向次数:批处理、CUDA Graphs、循环展开(系统层)。
后面的章节按”算法 → 缓存 → 调度”的顺序展开,中间穿插 dInfer 这套框架的四个组件,最后用真实硬件测量收束。
第一层:算法——块并行的步数与置信度调度
并行解码的根本矛盾
第二篇推导过掩码扩散的后验:对一个仍被掩码的位置 i,在从 t 跳到 s 时,它以 s/t 的概率继续保持掩码、以 (t−s)/t 的概率恢复为原 token。反向采样时,模型对每个掩码位置独立给出一个词表分布,如果一次性提交多个位置,等价于假设这些位置的条件独立:
p(xis,xjs∣xt)≈p(xis∣xt)p(xjs∣xt)Fast-dLLM 用一个例子说明这个假设有多脆弱:英文扑克牌型中由两个单词组成的名称,可能是 “high card”、“two pair”、“full house”、“straight flush”;两个位置高度相关,但独立采样会产生 “high house” 这种不存在的组合。公式上,真正的联合分布应当是
p(xis,xjs∣xt)=p(xis∣xt)p(xjs∣xt,xis)而并行解码丢掉了后一项的依赖。提交的位置越多、位置之间越相邻,丢掉的信息越多,输出的连贯性越差。LLaDA 的原始实现也报告过类似的观察:一次只生成一个 token 时质量最好,同时解码多个就开始退化。
于是算法层的核心问题变成:在不让质量垮掉的前提下,一次前向最多能提交多少个 token,以及提交哪几个。这直接决定了上一节公式里的 TPF,而 TPF 又线性地决定端到端时间。
置信度阈值:让模型自己决定提交几个
LLaDA 官方实现的做法是每步固定取 top-k 个最自信的位置。Fast-dLLM 指出这个策略的问题:k 是人为固定的,简单块与困难块被同等对待;而且在分布平坦(模型不确定)的块上,强行取满 k 个等于硬凑。
它改成阈值策略:对块内所有仍为掩码的位置计算 ci=maxvpθ(xi=v∣xt),把所有 ci≥τ 的位置一次性提交,另外无论如何都提交置信度最高的那一个(避免死锁)。τ 通常取 0.9 左右。这一改动让每步提交的 token 数从”固定 k“变成”由当前块的置信度分布决定”:容易的块一步提交十几个,困难的块一步只提交一两个。
Fast-dLLM 还给了另一种变体:把置信度降序排列为 c(1)≥c(2)≥⋯,找最大的 n 使得 (n+1)(1−c(n))<f,提交前 n 个。这个判据的直觉是:多提交一个 token 带来的风险大致与它的不确定度 1−c 成正比,只有当累计风险仍低于预算 f 时才继续。
在 LLaDA-Instruct 的 5-shot GSM8K 上,Fast-dLLM 报告缓存与并行解码的组合把吞吐从 6.7 tok/s 提到 54.4 tok/s(8.1×);把生成长度拉到 1024、使用 8-shot 长前缀后,端到端加速可达 27.6×。这两个数字的口径完全不同:前者是短生成、单请求,后者是长前缀加长生成,缓存命中率更高。这也解释了为什么 dLLM 论文里的加速比经常不可比——基线、批大小、生成长度都没有统一。
分治式提交:Hierarchical Decoding
dInfer 对”提交哪几个”给了另一种答案。它观察到掩码位置的空间分布本身影响预测稳定性:相邻的掩码位置之间存在强局部依赖,同时提交它们最容易违反条件独立假设;反之,把提交位置在空间上拉开,局部依赖就弱了。
Hierarchical Decoding 的做法是递归二分:把一个掩码区间不断对半切分,在每个子区间内至少提交一个置信度足够的位置,优先选择靠近区间中心的位置。这样做有两个效果。其一,同一步提交的位置彼此间隔较大,局部依赖被打破;其二,每次提交中心位置后,两侧未确定的区间继续二分,理想情况下递归深度是 O(logn),也就是一个长度为 n 的掩码区间可以用大约 logn 轮完成,而不是逐位置一轮。
这个策略不需要训练、不需要额外参数,但它的收益依赖实现细节:递归切分与”每区间至少一个”的约束必须在不引入控制流的前提下实现,否则会与后面要讲的循环展开、CUDA Graphs 冲突。dInfer 明确要求解码算法用无控制流的方式实现、把张量到 Python 的数据传输消除掉,正是为了兼容这些系统级优化。
置信度积分:Credit Decoding
标准的 predict–sample–re-mask 循环有一处隐蔽的浪费:很多最终正确的 token 在生成早期就已经稳定,但置信度一直低于阈值,于是被反复重新掩码、反复重新预测,每一轮都要再算一遍。dInfer 把这个现象量化成了一个可累积的量。
对每个位置 i 和词表中的每个 token v,维护信用值 Cti,v,每步更新:
Cti,v={βCt−1i,v+(pθi(v∣xt))γ,βCt−1i,v,v=v∗否则其中 v∗=argmaxvpθi(v∣xt) 是当前位置的 top-1 候选,β∈(0,1) 是折扣因子,防止历史错误无限累积,γ∈(0,1) 是凹变换。凹变换这一点很关键:如果直接用线性置信度累加,高置信度的错误预测会占据优势;而凹凸变换让”持续出现、但单次置信度不高”的候选也能积累起足够信用,恰好对应那些稳定但犹豫的正确 token。
提交决策前,信用值以对数先验的形式并入 logits:
f~θi(xt)v=fθi(xt)v+αlog(1+Cti,v),α>0再对 f~ 做 softmax 得到增强分布 p~θ,用阈值或 top-k 决定提交。直觉是:多轮迭代中持续被看好的 token 获得额外置信度,偶尔冒尖但随后回落的 token 被压制。由于它只替换分布、不改变采样策略,Credit Decoding 可以与阈值解码、KV 缓存、编译器优化叠乘。
dInfer 默认只在当前解码块内维护信用值,不跨块累积。理由也很明确:跨块的历史置信度会受到尚未确定的未来上下文干扰,块内累积更稳,也更容易在不同模型规模与上下文长度上扩展。
迭代平滑:把被丢弃的 logits 用起来
标准解码每步只提交少数位置,其余位置的 logits 直接丢掉。dInfer 的 IterSmooth 认为这是信息浪费:那些 logits 虽然不足以支撑一次提交,但它们的分布形状包含了”模型此刻倾向于什么”的信号。
做法是把掩码位置的 logits 分布转成期望嵌入,再注入该位置的掩码嵌入:
pt[i]=softmax(zt[i]),Δet[i]=pt[i]Wemb,et+1[i]=emask+αtΔet[i]其中 zt[i] 是第 t 步位置 i 的 logits,Wemb 是输入嵌入矩阵,emask 是标准掩码嵌入,混合权重
αt=min(αinit+αgrowth⋅t,αpreset)从较小的初始值(约 0.1)随步数增长到预设上限(约 0.2–0.4),前期保守、后期放开。只对仍为掩码的位置做这件事,避免改变已确定位置的输入分布。因为 dInfer 使用的模型输入嵌入与输出投影不共享权重,期望嵌入必须用输入嵌入矩阵计算。
效果是每步的有效信息量变大:原本只有 argmax token 进入下一步,现在整条分布以期望嵌入的形式进入。dInfer 报告这一步让单个去噪迭代平均多提交 30–40% 的 token,并改善最终质量。与 Credit Decoding 类似,它不引入新参数、不需要训练。
训练侧的补充:轨迹压缩
以上都是推理时的技巧。dInfer 还有一个模型侧的改动值得单独说明,因为它改变了”步数”这个变量的上限。
Trajectory Compression 分两阶段。第一阶段用预训练 dLLM 在领域数据(如 20 万道数学题)上采样大量生成轨迹 τ=(sN,sN−1,…,s0),用外部验证器筛出最终答案正确的轨迹集合 Tgold。第二阶段在这个集合上微调,但目标不是标准的单步转移 pθ(st−1∣st),而是从较早状态 si 直接预测较晚状态 sj(i>j)的多步转移,只对”在 si 中仍是掩码、在 sj 中已被揭示”的位置 Δi→j=Mi∖Mj 计算负对数似然:
Lcompress(θ)=−Eτ∈Tgold,i,j∼U(τ)k∈Δi→j∑logpθ(xk=sj[k]∣si)这等于教模型”一次跳过多步”,把原本需要多轮迭代才能确定的 token 压缩到一轮。dInfer 报告该方法在数学推理上把 TPF 提升 99.8%,在其他领域(含代码生成)平均提升 45.3%。得到的模型叫 LLaDA-MoE-TD。
这里需要克制地看待:轨迹压缩属于后训练,依赖领域内可验证的数据与一个能判断答案对错的验证器,通用开放域任务上没有这么干净的信号。它也把”模型能力”和”解码策略”耦合在了一起——一旦模型被训练成”大步跳”,再换回普通解码策略,收益不一定保留。
算法层的收益边界
把这一层的手段放在一起看,它们都在做同一件事:在不增加每步计算量的前提下提高 TPF。阈值解码、分治提交、信用积分、迭代平滑都是训练无关的;轨迹压缩则把 TPF 的上限写进了权重。
它们也有共同的代价:TPF 越高,条件独立假设被违反得越彻底,质量风险越大。所有方法的实际参数(阈值 τ、风险预算 f、α、γ)都是在”多提交”和”别写错”之间调出来的,没有一个可以脱离具体模型与任务直接套用。
第二层:KV 缓存——缓存什么、以什么粒度失效
为什么”精确缓存”在双向注意力下不存在
自回归的 KV 缓存成立,靠的是一条因果不变性:位置 i 的 key/value 只由 x≤i 决定,后续 token 不会改写它。掩码扩散没有这条性质。第 t 步的输入里,块内还有一批位置是 [MASK];第 t+1 步提交了其中几个,这些位置从掩码嵌入变成真实 token 嵌入,它们的 key/value 立刻改变;而双向注意力让它们又反过来影响同一块内其他位置的表示。于是严格意义上的”缓存一次、长期复用”不成立。
但”不精确”不等于”不能用”。Fast-dLLM 的出发点是测量:相邻去噪步骤之间,块外位置的 KV 激活到底变了多少。它算的是余弦相似度热图,结论是在块内解码期间,前缀位置的 key/value 相似度始终接近 1;DualCache 进一步显示,后缀(尚未解码的掩码块)位置的 KV 变化同样很小。

上图是 Fast-dLLM 论文中的前缀 KV 激活余弦相似度热图,横轴是推理步、纵轴是 token 位置,颜色越亮表示与相邻步的相似度越高。对角线附近(同一步内)以及块外区域都接近 1,说明在块内迭代期间复用块外缓存是可接受的近似;真正变化剧烈的是当前正在解码的块本身。这张图是整条”近似缓存”路线的经验依据——不是假设 KV 不变,而是测出它变得足够慢。
Fast-dLLM 的块级缓存与 DualCache
Fast-dLLM 把生成组织成块:提示词之后按固定块长 B 逐块解码,块内反复迭代直到该块没有掩码。缓存策略随之分成两层:
- 前缀缓存:进入一个块之前,提示词与所有已完成块的 KV 已经算好并缓存,块内每一轮迭代直接复用,不再重算这部分。
- 块后全量刷新:一个块解码完成后,对全部 token(不只是新生成的)重算一次 KV,保证跨块的全局一致性。这次刷新可以与解码的最后一步合并,所以相对无缓存版本没有额外的计算开销。
DualCache 在这个基础上多缓存一块:后缀,也就是当前块之后那些仍然全为掩码的位置。因为块内迭代时这些位置始终是掩码,它们的 KV 表示也相对稳定;把它们缓存下来,注意力计算就只需要覆盖”当前块 + 缓存的前缀 + 缓存的后缀”,而不是整条序列。

上图对比了两种方案:左侧是仅缓存前缀,右侧是 DualCache 同时缓存前缀与后缀。图中 [MASK] 块只保留当前解码块需要计算的部分,其余位置的 KV 来自缓存,块边界处执行一次缓存刷新。DualCache 的意义在长上下文时最明显:序列越长,可复用的比例越高,Fast-dLLM 报告 8-shot 长前缀下 DualCache 的加速从 9.4× 继续上升。
Fast-dLLM 给出的完整流程可以直接写成伪代码:
1输入: 提示词 p0, 答案长度 L, 块数 K, 块长 B, 每块最多迭代 T 步, 阈值 τ2x ← [p0; MASK × (L - |p0|)]3初始化 KV 缓存(可融合进第一次前向)4for k = 1..K:5 s ← |p0| + (k-1)·B ; e ← |p0| + k·B6 for t = 1..T:7 用缓存执行前向:DualCache 时只算 x[s:e],否则算 x[s:]8 对块内掩码位置计算置信度 c_i = max_v p(x_i = v)9 提交所有 c_i ≥ τ 的位置,并至少提交 argmax 的一个位置10 若块内已无掩码,跳出11 更新缓存:DualCache 刷新前缀与后缀,否则只刷新前缀12return x这段伪代码里有一个容易被忽略的细节:缓存的刷新时机与解码的最后一步是同一件事。如果实现成”先解码、再单独跑一次前向刷新缓存”,就会多出一次全序列前向;正确做法是在最后一步提交的同时把新的 KV 写回缓存。
dInfer 的邻域刷新:不刷新全部,只刷新附近
Fast-dLLM 的块后刷新是”全量”的,dInfer 认为这仍然偏贵。它提出 vicinity KV-cache refresh:利用语义局部性,只更新与当前解码块相邻的一小段窗口内的 token;每个去噪步骤里,对掩码 token 及其紧邻位置重算 K/V,等整块解码完成后再做一次全量刷新以恢复全局一致。
这个折中解决的是 Fast-dLLM 路线的一个结构性问题:块内缓存一旦写入就当作静态,忽略了新提交 token 对周围表示的改写;而全量刷新又太贵。邻域刷新把”改写的影响范围有限”这一经验假设显式化——只重算会被直接影响的那一圈。dInfer 报告在启用缓存时,它的平均准确率是 53.96,而 Fast-dLLM 是 52.15(六个基准平均),同时 TPS 从 110.98 提到 680.71。这组对比很重要:缓存不是免费的,Fast-dLLM 的近似让准确率掉了约 1.4 个点,dInfer 用邻域刷新把这块损失补回来,同时速度还高一个量级。
Sparse-dLLM:把缓存从”存不存”推进到”存多少”
Fast-dLLM 与 dInfer 都在回答”缓存能不能复用”,Sparse-dLLM 问的是下一个问题:复用的时候,有必要把整条 KV 都留着吗。
它先做了一次注意力模式分析,结论有两条。第一,dLLM 的注意力在层间与步间都高度稀疏,存在稳定的”关键 token”(pivotal token):少数 key 持续吸引几乎所有 query 的注意力,其余位置权重很低。第二,与自回归模型不同,dLLM 没有明显的首 token 注意力汇聚(attention sink)——自回归里常见”所有 query 都关注第一个 token”的现象,在双向注意力的 dLLM 里并不突出,取而代之的是局部对角带(关注邻近位置)与竖直亮带(所有 query 关注少数关键 key)。

上图是论文中单层、单步的注意力热图示例。亮色集中在两条结构上:对角线附近的局部带,以及若干条贯穿所有 query 的竖直带。这两类结构在层间、步间都保持稳定,正是”可以只保留关键 KV”的依据。图中没有出现自回归模型典型的首列亮带,这也说明不能把 AR 的 KV 驱逐策略(例如强制保留前几个 token)直接搬过来。
基于这个观察,Sparse-dLLM 的做法是:
- 范围:同时处理前缀与后缀,也就是当前块之前和之后的全部块外 token,而不只是前缀。这是 dLLM 与 AR 的又一个区别:AR 只能看到已生成的 token,dLLM 能看到完整序列,所以驱逐要”双向”。
- 打分:用当前块的 query Qb 与候选 key Kf 计算注意力分数 A=QbKf⊤/dk,再做核大小为 s 的 max-pooling,取 top-k 保留,其中 k=(L−b)×r,r 是保留率(默认 0.5)。max-pooling 的作用是防止只保留局部细节导致的表示不完整。
- 延迟一步更新:缓存不在块的第一步写入,而是延迟一步。原因是作者测得块内第 0 步到第 1 步之间 KV 的 L2 变化最剧烈,第 0 步的 KV 尚未稳定;延迟一步再写,缓存质量明显更好。
- 块边界全清:跨块时缓存被完全清空并重建,避免误差跨块传播。

上图是 Sparse-dLLM 的整体流程:块外 KV 先进入缓存,延迟一步后用注意力分数筛选,低权重的前缀与后缀条目被驱逐,只保留关键子集参与后续注意力;块切换时缓存整体刷新。与 Fast-dLLM 的”全留”相比,这里多了一个保留率 r,缓存大小从”随序列线性增长”变成”随 rL 增长”。
收益方面,Sparse-dLLM 在 LLaDA-8B-Instruct 上把平均 TPS 从 1× 提到 3.4×(MMLU 3.4×、GSM8K 5.8×、GPQA 4.6×),在 Dream 系列上报告最高 10× 吞吐,同时峰值显存与不使用缓存时基本持平(约 15–16 GB),准确率平均 59.86,与基线的 59.24 相当甚至略高。测试平台是单张 RTX 4090(48 GB)。
缓存的显存账
缓存策略最终要落到显存上。一个 N 层、KV 头维度 dkv、精度 2 字节的模型,长度为 L 的序列的 KV 缓存大小是
Mkv=2⋅N⋅L⋅dkv⋅bytes以 32 层、dkv=4096、fp16 的 8B 级模型为例,每个 token 的 KV 是 2×32×4096×2=512 KB;4096 token 就是 2 GB。这还只是一个请求。Sparse-dLLM 的保留率 0.5 直接把这个数字砍半,而它的意义不只是省显存:注意力计算量也随之下降,因为被驱逐的条目不再参与 QK⊤。
需要强调的是,dLLM 的缓存占用与自回归有一个不同的增长结构:自回归的 KV 随输出长度增长,dLLM 的 KV 在生成开始时就接近满长(答案位置全是掩码,同样要占 KV),所以峰值显存在请求准入时就已经确定。这对服务系统的准入控制是好事——显存可以提前算准;但对长上下文是坏事——一开始就要为整段序列留出空间。
缓存层的三个经验结论
- 近似缓存是必需的,不是可选的。没有缓存时,dLLM 每个去噪步骤都要对全序列做前向,成本随上下文长度线性增长;有了缓存,块内迭代只算当前块,成本与块长相关。
- 缓存会改变输出分布,必须与解码策略一起评估。Fast-dLLM 的阈值解码在无缓存与有缓存下的最优阈值不同;dInfer 的邻域刷新、Sparse-dLLM 的延迟更新,本质上都是在修补”近似”带来的分布偏移。
- 缓存稀疏化与并行解码是乘性关系,不是替代关系。Sparse-dLLM 的实验里,稀疏缓存与块并行同时开启才能拿到 3–10×;单独开启任一一项,收益都受另一项的瓶颈限制。
第三层:调度——当请求成本在准入时不可知
一个反直觉的测量结果:难度是离散的
自回归服务的调度器默认一件事:请求的成本可以估。提示词长度已知,输出长度可以用历史分布或早期信号估计,于是准入、排队、抢占都能围绕一个连续的”预计耗时”来做。Virginia Tech 的测量直接推翻了这个前提在 dLLM 上的适用性。
他们用 LLaDA-8B-Instruct 加一个 D2F(Discrete Diffusion Forcing)LoRA 适配器,在单张 H200 上跑 GSM8K,统计每个请求需要的去噪步数。结果是:步数不是连续分布,而是落在 11 个固定的档位上,档位之间的间隔是 29 步,最低档约 178 步,可以写成 178+29k(k=0,1,…,10)。去噪步数与端到端延迟的相关性高到 r=0.9997、R2=0.9994——也就是说,一旦知道一个请求会走多少步,延迟几乎完全确定。
问题在于,生成开始之前没有任何信号能预测它会落在哪一档。作者测试了四个廉价的早期信号:首步的置信度比例、平均置信度、token 熵、提示词长度。四者的 R2 分别是 0.011、0.004、0.023、0.087,最好的也只有 0.150,远低于他们设定的 0.5 可用门槛。原因不是特征选得不好,而是结构性的:第一步去噪时,每个请求的第一个块都是 32 个位置全掩码,模型看到的只是”这是一个数学题”这种先验,还没有任何关于这道题难度的证据。难度取决于去噪路径,而路径在生成前不可见。
这个发现对调度的影响是根本性的:dLLM 的调度不是一个”估计服务时间”的问题,而是一个”面对未知服务时间”的问题。能做的是围绕最坏情况留余量、在生成过程中动态调整,而不是试图在准入时算准。
负载的方差有多大
如果所有请求都走同一档,不可预测也无所谓。实际上方差很大。在 512 token 生成预算下,GSM8K 请求的延迟变异系数 CV=0.272,最大与最小延迟之比 2.64×。这个数字还和生成长度强相关:128 token 预算时 CV 只有 0.067,256 时 0.080,512 时 0.283,1024 时 0.360。
低预算下的”低方差”是假象。128 token 预算下 100% 的请求被截断,准确率只有 6.0%;256 token 时仍有 83% 被截断,准确率 48.0%;到 512 token,截断率降到 3%,准确率 76.0%。也就是说,短预算的测量主要测的是”截断行为”——所有请求都在同一个位置被砍掉,当然看起来整齐。真正反映服务行为的,是接近任务自然完成长度(GSM8K 平均约 320 token)时的方差。
跨任务的结果一致:HumanEval 代码补全的 CV 是 0.343–0.346,最大最小比 3.99–4.09×,比 GSM8K 还高。两个完全不同的任务给出几乎相同的”块内稳定、跨请求波动”的比例(约 36×),说明这不是数学题的特例。
批处理到底在摊薄什么
dLLM 的同步批处理(synchronized batching)是:一个 batch 内所有请求补齐到相同形状,每个去噪步骤对整个 batch 跑一次共享前向;前向之后,各请求独立采样自己的 token。Virginia Tech 把它与”每请求独立派发”(per-request dispatch)对比,在 batch size 16 时得到 1.939 req/s,而单请求是 0.121 req/s,提升 16.0×,接近线性。
这个对比容易被误读成”批处理让 GPU 更忙”。真正的原因在后面的 profiler 数据里:每个去噪步骤都有一段固定的 CPU 侧控制流——跟踪块状态、构造注意力掩码、检查置信度阈值、在前向之间做同步。同步批处理每个步骤只为整个 batch 付一次这段开销;每请求派发则要为 batch 里的每个请求各付一次。实测的相对开销随 batch 增大而增大:B=2 时 2.4×,B=4 时 5.1×,B=8 时 8.1×,几乎等于 B 本身。
这也是 dLLM 与自回归批处理的本质区别。vLLM 的连续批处理之所以有效,是因为它让不同请求共享每次 forward 的矩阵乘,提高 GPU 利用率;dLLM 的批处理首先摊薄的是每步固定调度开销,而矩阵乘的共享是附带的。论文对此的表述很直接:masked diffusion 的并行在”步骤”这一级,而不在”请求”这一级。
由此推出的设计是 slot-based:固定若干 GPU 槽位,所有活跃槽位每步一起前进一次共享前向,请求完成后立刻从队列补位。它同时具备共享前向与请求的动态进出,是同步批处理更现实的比较对象。论文把这一设计列为后续工作,没有给出实测——这也是理解其结论边界时必须注意的一点:16.0× 的分母是”每请求派发”,而不是一个已经实现好的 slot-based 服务系统。
批超时:一个可以直接用的排队规则
固定填充(fixed-fill)的同步批处理要决定等多久:等太久,请求空等;发太早,一次前向只服务半个 batch,容量被浪费。论文在 Poisson 到达下把这个权衡解成了一个批超时规则。
设 batch 大小 B、到达率 λ、一个 batch 的平均服务时间 S、超时 T。系统稳定的条件是”一个超时窗口内平均收到的请求数”要跟得上”服务一个 batch 所需时间内到达的请求数”:
E[batch size(T,λ)]=λS不满足这个等式,队列会无界增长。直观上,T 太小会让 batch 长期填不满,有效容量下降;T 太大则增加每个请求的填充等待(均值约 (B−1)/(2λ))。
用实测的 8 个 batch 服务时间(B=8、均值 S=8.74 s、CV=0.266)做 20000 次蒙特卡洛,得到的结论是:平均延迟随负载呈 U 形,最低点出现在利用率 ρ≈0.70;此时 P50 约 14.6 s、P90 22.2 s、P99 29.2 s,超过 25 s 的 SLA 违约率约 5%。ρ=0.95 时违约率跳到 55%。对应的最小安全超时从 ρ=0.3 时的 5.1 s 升到 ρ=0.7 时的 7.2 s。
这组数字的价值不在于具体数值——它依赖模型、硬件、任务——而在于给出了一个可复用的方法:用实测的服务时间分布,而不是解析假设,去定批超时与目标利用率。dLLM 的服务时间分布是离散多峰的,用指数分布近似会严重低估尾延迟。
公平性与长请求
dLLM 的调度还有一个自回归没有的问题:一个请求一旦进入某个块,就必须把这块的迭代跑完才能让出 GPU。块内迭代的轮数由置信度动态决定,可能一步提交完,也可能反复十几轮。这意味着:
- 抢占粒度是块,不是 step。在块边界抢占的代价是要保存或重算该块的 KV;在块内抢占则会把一次前向拆成两次,失去批处理收益。
- 长请求会占住槽位。自回归可以用”每步只生成一个 token”的细粒度来保证公平,dLLM 的最小调度单位是一整个块,粗了一个量级。
- 难度不可预测让公平性更难做。调度器无法在准入时按预计时长排序,只能按已消耗的步数或块数做 aging。
一个自然的缓解手段是块长的在线选择:块短则抢占粒度细、公平性好,但块边界刷新缓存的次数多、开销大;块长则相反。第二篇提到的”块长是调度基本单位”,在这里落成了具体的权衡。
dInfer:把推理管线拆成四个可替换的组件
为什么需要框架级抽象
在 dInfer 之前,dLLM 的加速工作大多以”某个模型 + 某个脚本”的形式存在:Fast-dLLM 的缓存与阈值解码绑在 LLaDA/Dream 的参考实现上,Sparse-dLLM 的驱逐策略绑在自己的推理代码里。结果是不同论文的加速比无法横向比较——同一篇论文里 TPS 的分母可能是单请求、可能是无缓存、也可能是不同生成长度。dInfer 的第一个贡献其实是工程性的:把 dLLM 推理拆成四个可独立替换的组件,让算法组合可以被一致地测量。

上图是 dInfer 的架构图。四个模块各管一件事:Model 负责模型前向与并行切分(LLaDA-MoE、LLaDA-1.5 等);Iteration Manager 决定下一步解码哪个区域,提供 blockwise 与 IterSmooth 两种策略;Decoder 决定这一步提交哪些 token,提供 threshold、hierarchical、credit 三种策略;KV-Cache Manager 决定缓存何时失效、刷新哪一部分,提供 prefix、dual、vicinity refresh 三种策略。底部是运行时:数据并行、专家并行、张量并行,以及循环展开。图右侧的箭头表明,四个模块是按”选块 → 更新缓存 → 前向 → 提交”的顺序串起来的。
这种拆法的价值在于组合空间:4 个模块的选择相乘,可以覆盖从”无缓存 + 阈值解码”到”邻域刷新 + 分层 + 信用 + 平滑”的整条谱系,而且每个组合都能在同一套基准上比较。
编排流程
dInfer 的块级推理可以写成下面的循环,它比 Fast-dLLM 的伪代码更明确地区分了”谁负责什么”:
1创建 KV 缓存2while 迭代管理器还有下一块:3 [start, end] ← 选出下一块(blockwise 顺序)4 undecided ← 块内仍为掩码的位置5 while undecided 非空:6 if 缓存管理器判断该更新:7 更新缓存(按 prefix / dual / vicinity 策略)8 logits ← 模型前向(x, 缓存, [start, end])9 (x, undecided) ← 解码器提交(logits, x, undecided, [start, end])10return x与 Fast-dLLM 的流程相比,多出来的是”缓存管理器判断该更新”这个条件分支,以及解码器的可替换性。前者让邻域刷新成为可能,后者让分层解码、信用解码可以自由组合。
系统级优化:框架真正的提速来源
dInfer 报告的综合加速(相对 Fast-dLLM 约 10×、相对 vLLM 上的 Qwen2.5-3B 约 2–3×)并不只来自算法。它的实现细节里有一串系统优化,每一项的收益都被单独标注:
- 张量并行 + 专家并行:线性层用 TP 切分,MoE 专家用 EP 切分。这里有一个与自回归不同的观察:EP 在 dLLM 上 batch size 为 1 时也有效,因为一次前向要处理整块甚至整条序列,token 数足够多,专家负载天然被摊开;自回归的 EP 通常需要大 batch 才能填满专家。TP 与 EP 组合带来超过 100% 的效率提升。
- torch.compile + CUDA Graphs:融合 kernel 并把执行序列捕获成图,消除 PyTorch 的逐算子启动开销。在 TP/EP 开启时,这项优化带来超过 200% 的效率提升。
- 循环展开:dLLM 的迭代循环之间容易出现 CUDA stream 气泡——连续 kernel 启动之间的空闲间隙。循环展开让 Python 连续发起 kernel 而不被流同步阻塞,报告收益 5–10%。
- 提前终止:块内一旦出现 EOS,后续块全部填 EOS 并停止扩散循环。收益 15–40%,且随生成长度增加而增加。
- 无控制流的解码实现:解码算法不能用 Python 分支,张量到 Python 的数据传输要消除,否则循环展开与 CUDA Graphs 都会失效。
这几项加起来说明一件事:dLLM 的推理瓶颈有很大一部分不在数学上,而在”如何把 235 次前向高效地发出去”。这一点与下一节的 profiler 测量互相印证。
实测结果与口径
在 8× H800、batch size 1、生成长度 1024、块长 64 的设定下,dInfer 在六个基准上的平均结果如下(数据来自论文表 1 与表 2):
| 配置 | 平均准确率 | 平均 TPF | 平均 TPS |
|---|---|---|---|
| Fast-dLLM(无缓存) | 53.52 | 2.82 | 63.61 |
| dInfer(无缓存) | 54.33 | 4.29 | 407.36 |
| Fast-dLLM(DualCache) | 52.15 | 2.46 | 110.98 |
| dInfer(邻域刷新) | 53.96 | 3.87 | 680.71 |
| dInfer(LLaDA-MoE-TD) | 52.72 | 5.67 | 847.22 |
| Qwen2.5-3B + vLLM | 54.44 | 1 | 277.45 |
读这张表要看三件事。第一,dInfer 的无缓存版本已经比 Fast-dLLM 快 6.4×,说明算法与系统优化在缓存之外就有巨大空间。第二,开缓存后 dInfer 的准确率只掉 0.37 个点(54.33 → 53.96),而 Fast-dLLM 掉了 1.37 个点(53.52 → 52.15),邻域刷新确实补回了近似缓存的损失。第三,TD 模型的 TPF 5.67 明显高于非 TD 的 3.87,说明轨迹压缩把”每次前向提交更多 token”写进了模型权重,这是推理侧技巧无法替代的。
同时要看到口径的限制:batch size 1、单序列 TPS、8 张 H800。这不是一个服务系统的吞吐数字,而是单请求延迟的倒数。把它与 vLLM 的 Qwen2.5-3B 相比也有模型差异——LLaDA-MoE 的激活参数量与 Qwen2.5-3B 接近,但总参数量、注意力结构与训练数据都不同,2–3× 只能作为量级参考。
真实硬件上的特征:瓶颈不在 GPU
单请求时间里,GPU 只占四分之一
前面所有算法与缓存优化都隐含着”GPU 是瓶颈”的假设。Virginia Tech 的 profiler 测量把这个假设拆开了。在一个 512 token 生成预算、单请求、H200 的实验中,一次完整生成耗时 10.28 s;用 CUDA kernel trace 逐项求和,GPU kernel 执行时间只有 2.511 s,占 24.4%。剩下 75.6% 是 CPU 侧的派发开销:跟踪块状态、构造注意力掩码、检查阈值、在前向之间做同步。
单请求的 10.28 s 里,2.511 s 是 GPU kernel,7.77 s 是 CPU 派发;这两组数字正好对应 dInfer 架构图里”模型”与”另外三个模块”的分工——模型负责 kernel,其余三个模块的每次决策都在 CPU 上完成。
这个测量还给了两个可复核的细节。第一,这次生成一共发起 235 次前向,作者用 aten::embedding 的调用次数独立核对,235 对 235 完全一致;235 次前向、每次前向 64 层的注意力算子计数,反过来也验证了模型是 64 层。第二,这些前向发生在不同 KV 形状上,不能简单地乘一个常数。
CUDA Graphs 能救多少
既然瓶颈是派发,最直接的手段是把派发序列捕获成图。作者用 torch.cuda.CUDAGraph 捕获单次前向调用,CPU 派发时间从 19.4 ms 降到 10.0 ms,减少 48.6%,且输出 logits 与未捕获版本完全一致(最大绝对误差 0.0)。
把这个收益外推到全部 235 次前向:235×9.43 ms≈2.22 s,占 7.77 s 派发开销的 28.5%。剩下 71.5% 来自前向之外的 Python 控制流:掩码构造、阈值判断、块状态记账。也就是说,CUDA Graphs 只能解决”把 kernel 发出去”的成本,解决不了”每一轮都要在 Python 里做决策”的成本。
这与 dInfer 的工程选择正好对上:它的解码算法要求无控制流、张量不回到 Python,循环展开把连续 kernel 发出去;这些做法本质上都是在压缩那 71.5%。dInfer 报告的循环展开收益只有 5–10%,看起来不大,但那是叠加在已经做过 torch.compile 与 CUDA Graphs 的基础上——先做图捕获,再做控制流重构,收益是分层的,不能相加。
块内延迟几乎不变:块长是服务粒度,不是难度参数
另一个对系统设计有直接影响的测量是块长的作用。在 HumanEval 上,同一请求内把块长从 16 换到 32、64、128,延迟几乎不变,CV=0.0096;而不同请求之间的延迟 CV=0.345。两个数字相差约 36×,GSM8K 上也是同一个比例(请求内 0.0073,请求间 0.260)。
这个结果的含义是:块长不影响一个请求有多难,只影响系统以多大的粒度推进它。所以块长应当作为服务参数(调度粒度、缓存刷新频率、显存碎片)来选,而不是当作”调小一点就能让难请求变快”的旋钮。这与很多实现里把块长当成质量参数来调的做法不同:块长会影响并行解码的质量,因为块越大,块内一次提交的 token 越多;但它不会改变请求本身需要的去噪步数。
批大小会不会伤质量
服务的加速只有在不掉准确率时才有意义。论文对同步批处理给出了一个结构性论证,依赖三个假设:
- 补齐(padding)不改变每个请求的注意力掩码与位置编码;
- 每个请求从自己独立的 RNG 流采样 token;
- 批处理的注意力与采样 kernel 在数值上等价于单请求版本,而不只是统计上相似。
三条都成立时,批大小不影响输出质量。实测的支持来自单请求的稳定性:GSM8K、512 token 预算下两次独立实验分别是 74.0% 与 76.0%,差距来自温度采样下的运行间波动,而不是方法差异。论文也检查了 24 个错误样本,只有 2 个是撞到 512 token 上限,其余 22 个是正常生成但答错——截断不是主要错误来源。
需要留意的是第三条假设。它要求批处理 kernel 与单请求 kernel 在数值上逐位一致,而实际的高性能 attention kernel 往往按 batch 形状选择不同的 tile 与归约顺序,浮点加法不满足结合律,逐位一致并不自动成立。这不是说批处理一定伤质量,而是说”质量不变”是一个需要验证的工程结论,不是可以默认的前提。
对内核与硬件设计的三个含义
第一,dLLM 的 decode 不是访存受限,而是更像 GEMM。 自回归 decode 每步只有一个 query,要读完整条 KV,算术强度极低;dLLM 的块解码每步有 b 个 query 同时读同一份 KV,b=32 或 64 时算术强度提高一到两个数量级。这带来一个反直觉的结论:dLLM 在 GPU 上更容易吃满算力,反而更早撞到 CPU 派发与 kernel 启动的墙。这也解释了为什么 dInfer 要把大量精力放在 CUDA Graphs 和循环展开上,而不是 attention kernel 本身。
第二,掩码构造是真实的内核成本。 自回归的因果掩码是静态的,可以在 kernel 里用下标算出来;dLLM 每一步的掩码取决于哪些位置已被提交,形状随步变化,且要覆盖”当前块 + 前缀缓存 + 后缀缓存”三段。构造这个掩码、把它传给 attention kernel,本身就是每步的固定开销。Sparse-dLLM 的驱逐又在这个基础上加了一层索引重排(gather),索引的间接寻址会进一步降低访存效率。
第三,硬件层面的机会在”CPU-GPU 紧耦合”。 论文指出,既然瓶颈是派发,那么 GH200 这类 CPU 与 GPU 通过 NVLink 紧耦合的超级芯片、以及能把控制循环整体捕获的运行时,会比单纯提升 GPU 算力更有效。这个判断对 dLLM 尤其重要:它的每步控制逻辑比自回归复杂得多(块选择、阈值判断、缓存刷新决策),对主机侧延迟更敏感。
小结与下一篇
本篇把 dLLM 从”能生成”推到”能服务”,核心结论可以归成三层:
- 成本结构:一个请求的时间由”前向次数 × 单次前向耗时 + 每步调度开销”决定;前向次数由步数与 TPF 决定,单次前向耗时由缓存命中率决定,调度开销由批处理与图捕获决定。三层优化的对象完全不同,不能互相替代。
- 算法层:并行解码的根本矛盾是条件独立假设。阈值解码把”提交几个”交给置信度分布;分层解码把提交位置在空间上拉开;信用解码用历史一致性补贴早期稳定但不够自信的 token;迭代平滑把被丢弃的 logits 转成期望嵌入。四者都是训练无关的,轨迹压缩则把大步跳写进权重,TPF 提升更彻底但依赖可验证数据。
- 缓存层:双向注意力让精确缓存不可能,块级近似缓存(Fast-dLLM)是起点;DualCache 把后缀也缓存起来;邻域刷新(dInfer)只重算当前块附近,把缓存带来的准确率损失从 1.37 点压到 0.37 点;Sparse-dLLM 用注意力分数做双向驱逐,保留率 0.5 就把平均吞吐提到 3.4×、最高 10×,显存几乎不涨。
- 调度层:dLLM 的难度是 11 个离散档位(178+29k 步),准入时不可预测(最好的早期信号 R2 只有 0.150),所以调度必须面向未知服务时间设计。批处理的主要收益是摊薄每步的 CPU 派发,而不是提高 GPU 利用率;16.0× 的数字来自”同步批处理 vs 每请求派发”这个特定对比。批超时可以用实测服务时间分布加批量排队模型来定,ρ≈0.70 是延迟最优点。
- 真实硬件:单请求只有 24.4% 的时间在 GPU 上,75.6% 是 CPU 派发;CUDA Graphs 能砍掉其中约 28.5%,剩下的要靠重构控制流。块长是服务粒度而不是难度参数;批大小对质量的影响依赖三条假设,其中”kernel 数值等价”需要实测而不是默认。
- 框架:dInfer 的四模块拆分让算法组合可比较,也暴露了真正的提速来源——TP/EP、torch.compile、CUDA Graphs、循环展开、提前终止。在 8× H800、单请求、1024 生成长度下,它相对 Fast-dLLM 约 10×、相对 vLLM 上的同量级自回归模型 2–3×,但这些数字的口径必须连同批大小与生成长度一起读。
这一篇讲的是”离散扩散语言模型怎么服务”。连续扩散那一侧还有一条同样重要的工程线索没有展开:潜空间扩散如何把像素压缩到 VAE 的 latent、文本条件如何通过 cross-attention 与 MMDiT 的双流结构进入去噪网络、rectified flow 如何把采样轨迹拉直、以及这些结构如何决定图像与视频生成的服务成本。下一篇回到连续侧,拆解潜空间扩散与条件生成架构。
参考资料
- dInfer: An Efficient Inference Framework for Diffusion Language Models
- Fast-dLLM: Training-free Acceleration of Diffusion LLM by Enabling KV Cache and Parallel Decoding
- Sparse-dLLM: Accelerating Diffusion LLMs with Dynamic Cache Eviction
- Serving Masked Diffusion LLMs: Characterization and Design Principles from Real Hardware
- Large Language Diffusion Models (LLaDA)
- LLaDA-MoE: A Sparse MoE Diffusion Language Model
- Dream 7B: Diffusion Large Language Models
- Fast-dLLM v2: Efficient Block-Diffusion LLM
- dLLM-Cache: Accelerating Diffusion Large Language Models with Adaptive Caching
- dKV-Cache: The Cache for Diffusion Language Models
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!
评论区
分享你的想法,与大家交流讨论
正在获取所在地区…
正在读取天气
音乐
暂未播放



