扩散模型从零讲起(三):dLLM 推理系统——dInfer、Fast-dLLM 与真实硬件上的服务设计

12759 字
64 分钟
扩散模型从零讲起(三):dLLM 推理系统——dInfer、Fast-dLLM 与真实硬件上的服务设计

写在前面:从数学走到系统

前两篇已经把这套生成机制完整走过一遍。第一篇从加噪与去噪的高斯链讲到 DDPM 的闭式后验、DDIM 的确定性轨迹、score matching、Flow Matching,以及 DiT 用 adaLN-Zero 注入全局条件;第二篇把同一个过程搬到离散状态空间,推导了 CTMC 框架下的离散 ELBO、吸收态掩码扩散的后验两项式、按 1/t1/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 推理为什么和自回归推理不同

先回忆:自回归推理的代价结构

设上下文长度 LL、词表大小 VV、隐藏维度 dd、层数 NN。自回归模型逐 token 生成,第 tt 步只需计算新 token 的 query,并对长度为 tt 的 KV 缓存做注意力。由于因果掩码,前缀 token 的 key/value 一旦算好就不再变化,所以每步的计算量是 O(t⋅d)O(t \cdot d) 级别的线性量,而”权重矩阵乘”这一部分(FFN 与投影)每步是 O(d2)O(d^2) 的固定量。

这套结构带来三个性质:

  1. 缓存是精确的。因果掩码保证已生成 token 的表示不会被后续 token 改写,KV 缓存可以直接长期复用。
  2. 计算随时间线性增长。序列越长,单步注意力越重,所以自回归推理的 decode 阶段是典型的”访存受限”——每算一个 token 要读一遍全部 KV,算术强度很低。
  3. 跨请求可以共享前向计算,这就是连续批处理(continuous batching)的基础。vLLM、Orca 这类系统在迭代边界上做准入与驱逐,让不同请求共享每次 forward 的 GPU 时间。

dLLM 的代价结构:三个性质全部被改写

掩码扩散的生成是”整块同时去噪”,第二篇已经把流程讲清楚了。落到推理系统上,三个性质分别变成:

第一,缓存变成近似。掩码扩散使用双向注意力,一个位置上的 token 被确定后,仍然会影响同一块内其他掩码位置的表示,甚至影响相邻块的表示;更重要的是,每个去噪步骤都会对全序列重算一遍前向。Fast-dLLM 的论文直接点出这一点:双向注意力的性质使”完全等价的 KV 缓存”不可能存在,只能用近似。dInfer 的表述更直接——解码单个 token 会改写全序列中所有 token 的表示,使得朴素复用不可行。

第二,每步的计算量几乎与上下文等长,与生成了多少 token 无关。自回归的第 tt 步只算一个 token;dLLM 的第 tt 个去噪步骤要对整个块(甚至整个序列)做前向。这意味着 dLLM 的算力浪费是”显式”的:如果块内还有一半位置是掩码,那一半的算力用于为尚未确定的 token 产生概率分布,而不是直接产出 token。

第三,并行度来自”步”而不是”请求”。后文会看到 Virginia Tech 的测量:dLLM 服务中真正的共享单位是每个去噪步骤的一次前向,批处理的主要收益是摊薄这一步的调度开销,而不是像自回归那样提高 GPU 的矩阵乘利用率。

统一记账:dLLM 的成本由什么决定

一个请求的端到端时间可以拆成三部分:前向计算、步骤数、调度开销:

Treq=S⋅Lb⋅bTPF⏟前向次数×单次前向耗时+Tdispatch⏟每步调度开销+T其余T_{\text{req}} = \underbrace{S \cdot \frac{L}{b} \cdot \frac{b}{\text{TPF}}}_{前向次数 \times 单次前向耗时} + \underbrace{T_{\text{dispatch}}}_{\text{每步调度开销}} + T_{\text{其余}}

其中 SS 是总去噪步数、bb 是块长、TPF\text{TPF}(tokens per forward)是单次前向平均确定并提交的 token 数、LL 是生成长度。这个式子几乎把本篇所有优化归了类:

  • 增大 TPF\text{TPF}:并行解码策略、迭代平滑、轨迹蒸馏(算法层);
  • 减少每步的计算量:KV 缓存复用、稀疏化与驱逐(缓存层);
  • 减少 TdispatchT_{\text{dispatch}} 与提升单位时间内的前向次数:批处理、CUDA Graphs、循环展开(系统层)。

后面的章节按”算法 → 缓存 → 调度”的顺序展开,中间穿插 dInfer 这套框架的四个组件,最后用真实硬件测量收束。

第一层:算法——块并行的步数与置信度调度

并行解码的根本矛盾

第二篇推导过掩码扩散的后验:对一个仍被掩码的位置 ii,在从 tt 跳到 ss 时,它以 s/ts/t 的概率继续保持掩码、以 (t−s)/t(t-s)/t 的概率恢复为原 token。反向采样时,模型对每个掩码位置独立给出一个词表分布,如果一次性提交多个位置,等价于假设这些位置的条件独立:

p(xis,xjs∣xt)≈p(xis∣xt) p(xjs∣xt)p(x_i^s, x_j^s \mid x_t) \approx p(x_i^s \mid x_t)\, p(x_j^s \mid x_t)

Fast-dLLM 用一个例子说明这个假设有多脆弱:英文扑克牌型中由两个单词组成的名称,可能是 “high card”、“two pair”、“full house”、“straight flush”;两个位置高度相关,但独立采样会产生 “high house” 这种不存在的组合。公式上,真正的联合分布应当是

p(xis,xjs∣xt)=p(xis∣xt) p(xjs∣xt,xis)p(x_i^s, x_j^s \mid x_t) = p(x_i^s \mid x_t)\, p(x_j^s \mid x_t, x_i^s)

而并行解码丢掉了后一项的依赖。提交的位置越多、位置之间越相邻,丢掉的信息越多,输出的连贯性越差。LLaDA 的原始实现也报告过类似的观察:一次只生成一个 token 时质量最好,同时解码多个就开始退化。

于是算法层的核心问题变成:在不让质量垮掉的前提下,一次前向最多能提交多少个 token,以及提交哪几个。这直接决定了上一节公式里的 TPF\text{TPF},而 TPF\text{TPF} 又线性地决定端到端时间。

置信度阈值:让模型自己决定提交几个

LLaDA 官方实现的做法是每步固定取 top-kk 个最自信的位置。Fast-dLLM 指出这个策略的问题:kk 是人为固定的,简单块与困难块被同等对待;而且在分布平坦(模型不确定)的块上,强行取满 kk 个等于硬凑。

它改成阈值策略:对块内所有仍为掩码的位置计算 ci=max⁡vpθ(xi=v∣xt)c_i = \max_v p_\theta(x_i = v \mid x_t),把所有 ci≥τc_i \ge \tau 的位置一次性提交,另外无论如何都提交置信度最高的那一个(避免死锁)。τ\tau 通常取 0.9 左右。这一改动让每步提交的 token 数从”固定 kk“变成”由当前块的置信度分布决定”:容易的块一步提交十几个,困难的块一步只提交一两个。

Fast-dLLM 还给了另一种变体:把置信度降序排列为 c(1)≥c(2)≥⋯c_{(1)} \ge c_{(2)} \ge \cdots,找最大的 nn 使得 (n+1)(1−c(n))<f(n+1)(1-c_{(n)}) < f,提交前 nn 个。这个判据的直觉是:多提交一个 token 带来的风险大致与它的不确定度 1−c1-c 成正比,只有当累计风险仍低于预算 ff 时才继续。

在 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(log⁡n)O(\log n),也就是一个长度为 nn 的掩码区间可以用大约 log⁡n\log n 轮完成,而不是逐位置一轮。

这个策略不需要训练、不需要额外参数,但它的收益依赖实现细节:递归切分与”每区间至少一个”的约束必须在不引入控制流的前提下实现,否则会与后面要讲的循环展开、CUDA Graphs 冲突。dInfer 明确要求解码算法用无控制流的方式实现、把张量到 Python 的数据传输消除掉,正是为了兼容这些系统级优化。

置信度积分:Credit Decoding

标准的 predict–sample–re-mask 循环有一处隐蔽的浪费:很多最终正确的 token 在生成早期就已经稳定,但置信度一直低于阈值,于是被反复重新掩码、反复重新预测,每一轮都要再算一遍。dInfer 把这个现象量化成了一个可累积的量。

对每个位置 ii 和词表中的每个 token vv,维护信用值 Cti,vC_t^{i,v},每步更新:

Cti,v={β Ct−1i,v+(pθi(v∣xt))γ,v=v∗β Ct−1i,v,否则C_t^{i,v} = \begin{cases} \beta\, C_{t-1}^{i,v} + \left(p_\theta^i(v \mid x_t)\right)^\gamma, & v = v^* \\ \beta\, C_{t-1}^{i,v}, & \text{否则} \end{cases}

其中 v∗=arg⁡max⁡vpθi(v∣xt)v^* = \arg\max_v p_\theta^i(v \mid x_t) 是当前位置的 top-1 候选,β∈(0,1)\beta \in (0,1) 是折扣因子,防止历史错误无限累积,γ∈(0,1)\gamma \in (0,1) 是凹变换。凹变换这一点很关键:如果直接用线性置信度累加,高置信度的错误预测会占据优势;而凹凸变换让”持续出现、但单次置信度不高”的候选也能积累起足够信用,恰好对应那些稳定但犹豫的正确 token。

提交决策前,信用值以对数先验的形式并入 logits:

f~θi(xt)v=fθi(xt)v+αlog⁡(1+Cti,v),α>0\tilde{f}_\theta^i(x_t)_v = f_\theta^i(x_t)_v + \alpha \log\left(1 + C_t^{i,v}\right), \quad \alpha > 0

再对 f~\tilde{f} 做 softmax 得到增强分布 p~θ\tilde{p}_\theta,用阈值或 top-kk 决定提交。直觉是:多轮迭代中持续被看好的 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]p_t[i] = \mathrm{softmax}(z_t[i]), \qquad \Delta e_t[i] = p_t[i] \, W_{\text{emb}}, \qquad e_{t+1}[i] = e_{\text{mask}} + \alpha_t \, \Delta e_t[i]

其中 zt[i]z_t[i] 是第 tt 步位置 ii 的 logits,WembW_{\text{emb}} 是输入嵌入矩阵,emaske_{\text{mask}} 是标准掩码嵌入,混合权重

αt=min⁡(αinit+αgrowth⋅t,  αpreset)\alpha_t = \min\left(\alpha_{\text{init}} + \alpha_{\text{growth}} \cdot t,\; \alpha_{\text{preset}}\right)

从较小的初始值(约 0.1)随步数增长到预设上限(约 0.2–0.4),前期保守、后期放开。只对仍为掩码的位置做这件事,避免改变已确定位置的输入分布。因为 dInfer 使用的模型输入嵌入与输出投影不共享权重,期望嵌入必须用输入嵌入矩阵计算。

效果是每步的有效信息量变大:原本只有 argmax token 进入下一步,现在整条分布以期望嵌入的形式进入。dInfer 报告这一步让单个去噪迭代平均多提交 30–40% 的 token,并改善最终质量。与 Credit Decoding 类似,它不引入新参数、不需要训练。

训练侧的补充:轨迹压缩

以上都是推理时的技巧。dInfer 还有一个模型侧的改动值得单独说明,因为它改变了”步数”这个变量的上限。

Trajectory Compression 分两阶段。第一阶段用预训练 dLLM 在领域数据(如 20 万道数学题)上采样大量生成轨迹 τ=(sN,sN−1,…,s0)\tau = (s_N, s_{N-1}, \ldots, s_0),用外部验证器筛出最终答案正确的轨迹集合 Tgold\mathcal{T}_{\text{gold}}。第二阶段在这个集合上微调,但目标不是标准的单步转移 pθ(st−1∣st)p_\theta(s_{t-1} \mid s_t),而是从较早状态 sis_i 直接预测较晚状态 sjs_j(i>ji > j)的多步转移,只对”在 sis_i 中仍是掩码、在 sjs_j 中已被揭示”的位置 Δi→j=Mi∖Mj\Delta_{i \to j} = M_i \setminus M_j 计算负对数似然:

Lcompress(θ)=−Eτ∈Tgold, i,j∼U(τ)[∑k∈Δi→jlog⁡pθ(xk=sj[k]∣si)]\mathcal{L}_{\text{compress}}(\theta) = -\mathbb{E}_{\tau \in \mathcal{T}_{\text{gold}},\, i,j \sim U(\tau)} \left[ \sum_{k \in \Delta_{i \to j}} \log p_\theta(x_k = s_j[k] \mid s_i) \right]

这等于教模型”一次跳过多步”,把原本需要多轮迭代才能确定的 token 压缩到一轮。dInfer 报告该方法在数学推理上把 TPF 提升 99.8%,在其他领域(含代码生成)平均提升 45.3%。得到的模型叫 LLaDA-MoE-TD。

这里需要克制地看待:轨迹压缩属于后训练,依赖领域内可验证的数据与一个能判断答案对错的验证器,通用开放域任务上没有这么干净的信号。它也把”模型能力”和”解码策略”耦合在了一起——一旦模型被训练成”大步跳”,再换回普通解码策略,收益不一定保留。

算法层的收益边界

把这一层的手段放在一起看,它们都在做同一件事:在不增加每步计算量的前提下提高 TPF。阈值解码、分治提交、信用积分、迭代平滑都是训练无关的;轨迹压缩则把 TPF 的上限写进了权重。

它们也有共同的代价:TPF 越高,条件独立假设被违反得越彻底,质量风险越大。所有方法的实际参数(阈值 τ\tau、风险预算 ff、α\alpha、γ\gamma)都是在”多提交”和”别写错”之间调出来的,没有一个可以脱离具体模型与任务直接套用。

第二层:KV 缓存——缓存什么、以什么粒度失效

为什么”精确缓存”在双向注意力下不存在

自回归的 KV 缓存成立,靠的是一条因果不变性:位置 ii 的 key/value 只由 x≤ix_{\le i} 决定,后续 token 不会改写它。掩码扩散没有这条性质。第 tt 步的输入里,块内还有一批位置是 [MASK];第 t+1t+1 步提交了其中几个,这些位置从掩码嵌入变成真实 token 嵌入,它们的 key/value 立刻改变;而双向注意力让它们又反过来影响同一块内其他位置的表示。于是严格意义上的”缓存一次、长期复用”不成立。

但”不精确”不等于”不能用”。Fast-dLLM 的出发点是测量:相邻去噪步骤之间,块外位置的 KV 激活到底变了多少。它算的是余弦相似度热图,结论是在块内解码期间,前缀位置的 key/value 相似度始终接近 1;DualCache 进一步显示,后缀(尚未解码的掩码块)位置的 KV 变化同样很小。

Fast-dLLM 测量的 KV 激活余弦相似度热图:块内解码期间前缀 KV 变化接近零

上图是 Fast-dLLM 论文中的前缀 KV 激活余弦相似度热图,横轴是推理步、纵轴是 token 位置,颜色越亮表示与相邻步的相似度越高。对角线附近(同一步内)以及块外区域都接近 1,说明在块内迭代期间复用块外缓存是可接受的近似;真正变化剧烈的是当前正在解码的块本身。这张图是整条”近似缓存”路线的经验依据——不是假设 KV 不变,而是测出它变得足够慢。

Fast-dLLM 的块级缓存与 DualCache

Fast-dLLM 把生成组织成块:提示词之后按固定块长 BB 逐块解码,块内反复迭代直到该块没有掩码。缓存策略随之分成两层:

  1. 前缀缓存:进入一个块之前,提示词与所有已完成块的 KV 已经算好并缓存,块内每一轮迭代直接复用,不再重算这部分。
  2. 块后全量刷新:一个块解码完成后,对全部 token(不只是新生成的)重算一次 KV,保证跨块的全局一致性。这次刷新可以与解码的最后一步合并,所以相对无缓存版本没有额外的计算开销。

DualCache 在这个基础上多缓存一块:后缀,也就是当前块之后那些仍然全为掩码的位置。因为块内迭代时这些位置始终是掩码,它们的 KV 表示也相对稳定;把它们缓存下来,注意力计算就只需要覆盖”当前块 + 缓存的前缀 + 缓存的后缀”,而不是整条序列。

Fast-dLLM 的块级前缀缓存与 DualCache:前缀与后缀 KV 分别缓存,块结束后统一刷新

上图对比了两种方案:左侧是仅缓存前缀,右侧是 DualCache 同时缓存前缀与后缀。图中 [MASK] 块只保留当前解码块需要计算的部分,其余位置的 KV 来自缓存,块边界处执行一次缓存刷新。DualCache 的意义在长上下文时最明显:序列越长,可复用的比例越高,Fast-dLLM 报告 8-shot 长前缀下 DualCache 的加速从 9.4× 继续上升。

Fast-dLLM 给出的完整流程可以直接写成伪代码:

输入: 提示词 p0, 答案长度 L, 块数 K, 块长 B, 每块最多迭代 T 步, 阈值 τ
x ← [p0; MASK × (L - |p0|)]
初始化 KV 缓存(可融合进第一次前向)
for k = 1..K:
s ← |p0| + (k-1)·B ; e ← |p0| + k·B
for t = 1..T:
用缓存执行前向:DualCache 时只算 x[s:e],否则算 x[s:]
对块内掩码位置计算置信度 c_i = max_v p(x_i = v)
提交所有 c_i ≥ τ 的位置,并至少提交 argmax 的一个位置
若块内已无掩码,跳出
更新缓存:DualCache 刷新前缀与后缀,否则只刷新前缀
return 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)。

Sparse-dLLM 观察到的 dLLM 注意力图:局部对角带与稳定的竖直关键 token 带

上图是论文中单层、单步的注意力热图示例。亮色集中在两条结构上:对角线附近的局部带,以及若干条贯穿所有 query 的竖直带。这两类结构在层间、步间都保持稳定,正是”可以只保留关键 KV”的依据。图中没有出现自回归模型典型的首列亮带,这也说明不能把 AR 的 KV 驱逐策略(例如强制保留前几个 token)直接搬过来。

基于这个观察,Sparse-dLLM 的做法是:

  • 范围:同时处理前缀与后缀,也就是当前块之前和之后的全部块外 token,而不只是前缀。这是 dLLM 与 AR 的又一个区别:AR 只能看到已生成的 token,dLLM 能看到完整序列,所以驱逐要”双向”。
  • 打分:用当前块的 query QbQ_b 与候选 key KfK_f 计算注意力分数 A=QbKf⊤/dkA = Q_b K_f^\top / \sqrt{d_k},再做核大小为 ss 的 max-pooling,取 top-kk 保留,其中 k=(L−b)×rk = (L-b)\times r,rr 是保留率(默认 0.5)。max-pooling 的作用是防止只保留局部细节导致的表示不完整。
  • 延迟一步更新:缓存不在块的第一步写入,而是延迟一步。原因是作者测得块内第 0 步到第 1 步之间 KV 的 L2 变化最剧烈,第 0 步的 KV 尚未稳定;延迟一步再写,缓存质量明显更好。
  • 块边界全清:跨块时缓存被完全清空并重建,避免误差跨块传播。
Sparse-dLLM 整体流程:块外 KV 先缓存、延迟一步后按注意力分数驱逐低权重条目

上图是 Sparse-dLLM 的整体流程:块外 KV 先进入缓存,延迟一步后用注意力分数筛选,低权重的前缀与后缀条目被驱逐,只保留关键子集参与后续注意力;块切换时缓存整体刷新。与 Fast-dLLM 的”全留”相比,这里多了一个保留率 rr,缓存大小从”随序列线性增长”变成”随 rLrL 增长”。

收益方面,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)。

缓存的显存账

缓存策略最终要落到显存上。一个 NN 层、KV 头维度 dkvd_{kv}、精度 2 字节的模型,长度为 LL 的序列的 KV 缓存大小是

Mkv=2⋅N⋅L⋅dkv⋅bytesM_{\text{kv}} = 2 \cdot N \cdot L \cdot d_{kv} \cdot \text{bytes}

以 32 层、dkv=4096d_{kv}=4096、fp16 的 8B 级模型为例,每个 token 的 KV 是 2×32×4096×2=512 KB2 \times 32 \times 4096 \times 2 = 512\text{ KB};4096 token 就是 2 GB。这还只是一个请求。Sparse-dLLM 的保留率 0.5 直接把这个数字砍半,而它的意义不只是省显存:注意力计算量也随之下降,因为被驱逐的条目不再参与 QK⊤QK^\top。

需要强调的是,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+29k178 + 29k(k=0,1,…,10k = 0,1,\ldots,10)。去噪步数与端到端延迟的相关性高到 r=0.9997r = 0.9997、R2=0.9994R^2 = 0.9994——也就是说,一旦知道一个请求会走多少步,延迟几乎完全确定。

问题在于,生成开始之前没有任何信号能预测它会落在哪一档。作者测试了四个廉价的早期信号:首步的置信度比例、平均置信度、token 熵、提示词长度。四者的 R2R^2 分别是 0.011、0.004、0.023、0.087,最好的也只有 0.150,远低于他们设定的 0.5 可用门槛。原因不是特征选得不好,而是结构性的:第一步去噪时,每个请求的第一个块都是 32 个位置全掩码,模型看到的只是”这是一个数学题”这种先验,还没有任何关于这道题难度的证据。难度取决于去噪路径,而路径在生成前不可见。

这个发现对调度的影响是根本性的:dLLM 的调度不是一个”估计服务时间”的问题,而是一个”面对未知服务时间”的问题。能做的是围绕最坏情况留余量、在生成过程中动态调整,而不是试图在准入时算准。

负载的方差有多大

如果所有请求都走同一档,不可预测也无所谓。实际上方差很大。在 512 token 生成预算下,GSM8K 请求的延迟变异系数 CV=0.272CV = 0.272,最大与最小延迟之比 2.64×。这个数字还和生成长度强相关:128 token 预算时 CVCV 只有 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 代码补全的 CVCV 是 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=2B=2 时 2.4×,B=4B=4 时 5.1×,B=8B=8 时 8.1×,几乎等于 BB 本身。

这也是 dLLM 与自回归批处理的本质区别。vLLM 的连续批处理之所以有效,是因为它让不同请求共享每次 forward 的矩阵乘,提高 GPU 利用率;dLLM 的批处理首先摊薄的是每步固定调度开销,而矩阵乘的共享是附带的。论文对此的表述很直接:masked diffusion 的并行在”步骤”这一级,而不在”请求”这一级。

由此推出的设计是 slot-based:固定若干 GPU 槽位,所有活跃槽位每步一起前进一次共享前向,请求完成后立刻从队列补位。它同时具备共享前向与请求的动态进出,是同步批处理更现实的比较对象。论文把这一设计列为后续工作,没有给出实测——这也是理解其结论边界时必须注意的一点:16.0× 的分母是”每请求派发”,而不是一个已经实现好的 slot-based 服务系统。

批超时:一个可以直接用的排队规则

固定填充(fixed-fill)的同步批处理要决定等多久:等太久,请求空等;发太早,一次前向只服务半个 batch,容量被浪费。论文在 Poisson 到达下把这个权衡解成了一个批超时规则。

设 batch 大小 BB、到达率 λ\lambda、一个 batch 的平均服务时间 SS、超时 TT。系统稳定的条件是”一个超时窗口内平均收到的请求数”要跟得上”服务一个 batch 所需时间内到达的请求数”:

E[batch size(T,λ)]=λS\mathbb{E}[\text{batch size}(T,\lambda)] = \lambda S

不满足这个等式,队列会无界增长。直观上,TT 太小会让 batch 长期填不满,有效容量下降;TT 太大则增加每个请求的填充等待(均值约 (B−1)/(2λ)(B-1)/(2\lambda))。

用实测的 8 个 batch 服务时间(B=8B=8、均值 S=8.74S=8.74 s、CV=0.266CV=0.266)做 20000 次蒙特卡洛,得到的结论是:平均延迟随负载呈 U 形,最低点出现在利用率 ρ≈0.70\rho \approx 0.70;此时 P50 约 14.6 s、P90 22.2 s、P99 29.2 s,超过 25 s 的 SLA 违约率约 5%。ρ=0.95\rho=0.95 时违约率跳到 55%。对应的最小安全超时从 ρ=0.3\rho=0.3 时的 5.1 s 升到 ρ=0.7\rho=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 的四模块架构:模型、扩散迭代管理器、解码策略与 KV 缓存管理器,外加运行时优化

上图是 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 的伪代码更明确地区分了”谁负责什么”:

创建 KV 缓存
while 迭代管理器还有下一块:
[start, end] ← 选出下一块(blockwise 顺序)
undecided ← 块内仍为掩码的位置
while undecided 非空:
if 缓存管理器判断该更新:
更新缓存(按 prefix / dual / vicinity 策略)
logits ← 模型前向(x, 缓存, [start, end])
(x, undecided) ← 解码器提交(logits, x, undecided, [start, end])
return 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.522.8263.61
dInfer(无缓存)54.334.29407.36
Fast-dLLM(DualCache)52.152.46110.98
dInfer(邻域刷新)53.963.87680.71
dInfer(LLaDA-MoE-TD)52.725.67847.22
Qwen2.5-3B + vLLM54.441277.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.22235 \times 9.43\text{ ms} \approx 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.0096CV = 0.0096;而不同请求之间的延迟 CV=0.345CV = 0.345。两个数字相差约 36×,GSM8K 上也是同一个比例(请求内 0.0073,请求间 0.260)。

这个结果的含义是:块长不影响一个请求有多难,只影响系统以多大的粒度推进它。所以块长应当作为服务参数(调度粒度、缓存刷新频率、显存碎片)来选,而不是当作”调小一点就能让难请求变快”的旋钮。这与很多实现里把块长当成质量参数来调的做法不同:块长会影响并行解码的质量,因为块越大,块内一次提交的 token 越多;但它不会改变请求本身需要的去噪步数。

批大小会不会伤质量

服务的加速只有在不掉准确率时才有意义。论文对同步批处理给出了一个结构性论证,依赖三个假设:

  1. 补齐(padding)不改变每个请求的注意力掩码与位置编码;
  2. 每个请求从自己独立的 RNG 流采样 token;
  3. 批处理的注意力与采样 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 的块解码每步有 bb 个 query 同时读同一份 KV,b=32b=32 或 6464 时算术强度提高一到两个数量级。这带来一个反直觉的结论: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+29k178 + 29k 步),准入时不可预测(最好的早期信号 R2R^2 只有 0.150),所以调度必须面向未知服务时间设计。批处理的主要收益是摊薄每步的 CPU 派发,而不是提高 GPU 利用率;16.0× 的数字来自”同步批处理 vs 每请求派发”这个特定对比。批超时可以用实测服务时间分布加批量排队模型来定,ρ≈0.70\rho \approx 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 如何把采样轨迹拉直、以及这些结构如何决定图像与视频生成的服务成本。下一篇回到连续侧,拆解潜空间扩散与条件生成架构。

参考资料

  1. dInfer: An Efficient Inference Framework for Diffusion Language Models
  2. Fast-dLLM: Training-free Acceleration of Diffusion LLM by Enabling KV Cache and Parallel Decoding
  3. Sparse-dLLM: Accelerating Diffusion LLMs with Dynamic Cache Eviction
  4. Serving Masked Diffusion LLMs: Characterization and Design Principles from Real Hardware
  5. Large Language Diffusion Models (LLaDA)
  6. LLaDA-MoE: A Sparse MoE Diffusion Language Model
  7. Dream 7B: Diffusion Large Language Models
  8. Fast-dLLM v2: Efficient Block-Diffusion LLM
  9. dLLM-Cache: Accelerating Diffusion Large Language Models with Adaptive Caching
  10. dKV-Cache: The Cache for Diffusion Language Models

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

扩散模型从零讲起(三):dLLM 推理系统——dInfer、Fast-dLLM 与真实硬件上的服务设计
https://pinghaoyang.com.cn/articles/insights/posts/dllm-inference-systems/
作者
平昊阳
发布于
2026-11-18
许可协议
CC BY-NC-SA 4.0

评论区

访客信息
--°天气加载中

正在获取所在地区…

💨 风力--
💧 湿度--

正在读取天气

Profile Image of the Author
平昊阳
乘长风,破巨浪, 展鸿图于未央!
公告
欢迎来到我的个人博客!欢迎关注交流吖!
更多相关公告,见
「社交-留言」。
音乐
封面

音乐

暂未播放

0:000:00
暂无歌词
站点统计
文章
572
分类
29
标签
659
总字数
8,320,312
运行时长
0 天
最后活动
0 天前

文章目录