0%

DFlash BugFix

DFlash & 投机解码滑窗注意力

论文原文:DFlash: Block Diffusion for Flash Speculative Decoding

背景

Speculative Decoding 使用一个较小的 draft model 先猜测未来的多个 token,再让 target model 在一次前向中并行验证。设每轮 draft 的 token 数为 $\gamma$,平均接受长度为 $\tau$,则平均每个已接受 token 的延迟可写为:

$$
L=\frac{T_{\text{draft}}+T_{\text{verify}}}{\tau}.
$$

因此,加速的关键是同时降低 draft 开销 $T_{\text{draft}}$,并提高平均接受长度 $\tau$。然而,以 EAGLE-3 为代表的方法仍采用自回归 draft,生成 $\gamma$ 个候选 token 需要进行 $\gamma$ 次串行前向:
$$
T_{\text{draft}}=\gamma\cdot t_{\text{step}}.
$$

随着 draft 长度增加,其成本线性增长,而且前面 token 的预测错误还会影响后续预测。为了控制延迟,draft model 往往只能使用很浅的网络,这又限制了候选质量和平均接受长度,使实际加速通常停留在 $2\sim3\times$。

Diffusion LLM 可以同时预测一个 block 中的多个 masked token,将 draft 成本变为一次并行前向:

$$
T_{\text{draft}}=t_{\text{parallel}}.
$$

Diffusion 投机推理的基本思路是:给定已经确认的 token,在其后放置一组 mask token,diffusion drafter 利用非因果注意力并行预测这些位置,得到一个候选 token block;随后,自回归 target model 只需一次前向就能计算该 block 中各位置的真实条件概率,并从左到右验证候选。Diffusion model 只负责低成本地提出候选,生成结果的正确性仍由 target model 保证。

例如,已确认的 token 为 The capital of France is,需要 draft 预测后续 4 个 token。一个草稿过程可能是:

  1. 初始状态为 [MASK] [MASK] [MASK] [MASK]。第一轮并行预测全部位置,但只固定置信度最高的 Paris,得到 Paris [MASK] [MASK] [MASK];
  2. 第二轮利用 Paris 和原始上下文重新预测其余位置,固定 , 和 a,得到 Paris , a [MASK];
  3. 第三轮预测最后一个位置,得到完整候选 Paris , a city。

完整候选随后交给 target model 并行验证。假设 target model 依次认可 Paris , a,但第四个位置预测的是 major 而不是 city,那么本轮只接受前三个候选 token。

但直接使用 diffusion model 也有两个问题:小模型没有足够能力独立推理,候选 token 的接受率低;大 diffusion model 虽然质量更高,却会带来较大的显存和延迟开销,并且通常需要多步去噪,抵消了并行生成的收益。

DFlash认为,target model(即原始模型,叫target model是因为其是草稿模型拟合的目标)的中间隐藏状态不仅包含历史语义,也隐式包含对未来多个 token 的预测信息。与其让一个很小的 diffusion model 从 token 开始从头上下文,不如利用 target model 的隐藏状态提供上下文信息,并由 block diffusion 在一次前向中并行产生候选,最后由 target model 验证。

DFlash原理

整体推理流程

DFlash 的一轮推理可以概括为:

  1. target model 完成 prefill,或对上一轮候选进行验证,同时输出 token 和若干层的隐藏状态;
  2. 将 target model 的跨层隐藏状态融合,并注入 draft model 每一层的 KV cache;
  3. 以 target model 刚刚生成或确认的 token 作为 anchor,在其后放置一组 mask token;
  4. draft model 对 block 内的 mask token 使用双向注意力,通过一次前向并行预测整个候选 block;
  5. target model 一次性验证候选 block,接受其中满足验证规则的最长前缀,并额外产生一个 bonus token;
  6. 以新的已确认 token 为 anchor,重复上述过程。

这里 diffusion 只负责生成候选,最终接受哪些 token 仍由 target model 决定。因此 DFlash 改变的是生成速度,而不是 target model 的输出分布;在 greedy decoding 和带采样的场景中都可以沿用标准 Speculative Decoding 的验证与校正过程。

Target feature fusion

target model 在 prefill 或 verification 时,会从由浅到深均匀选取若干 Transformer 层的隐藏状态。对于位置 $t$,将这些状态拼接后通过一个轻量投影层,得到紧凑的上下文特征:

$$
c_t=W_f\left[h_t^{(l_1)};h_t^{(l_2)};\ldots;h_t^{(l_m)}\right].
$$

浅层特征保留更多局部和词法信息,深层特征包含更强的语义与任务信息;融合多个层比只使用最终 logits 能向 drafter 提供更丰富的未来 token 线索。

通过 KV injection 注入 target 信息

DFlash 将融合特征投影为每一个 draft layer 的 key 和 value:

$$
K_i^{\text{target}}=cW_{K,i},\qquad
V_i^{\text{target}}=cW_{V,i},
$$

并直接写入该层的 KV cache。这样每一层都能访问完整、稳定的 target context,而不是依赖条件信息在层间传播。已经计算出的 target KV 可以在后续 draft 轮次中复用,因此这种强条件注入不会引入同等规模的重复计算;同时,draft model 可以通过增加少量层数提升候选质量和平均接受长度。

单步 block diffusion drafting

draft block 的第一个位置是 target model 给出的干净 anchor token,其余位置为 mask token:

1
2
3
context:      The capital of France
draft input: is [MASK] [MASK] [MASK] [MASK]
draft output: is Paris , a city

与自回归 attention mask 不同,block 内采用双向注意力,使所有 mask 位置能够同时关注 target context、anchor 以及其他 mask 位置。draft model 随后在一次前向中输出所有位置的 logits,并复用 target model 的 LM head 得到候选 token。

DFlash不追求让 diffusion model 独立生成最终文本,只要求它以较低成本提供接受率足够高的候选,即使某些候选不正确,target model 的验证也会拒绝它们,因此使用单步去噪,而不是为了接近 target model 的独立生成质量付出多步去噪的开销。

并行 drafting 还改变了 draft model 的speculative tokens与延迟之间的关系。对于适中的 block size,候选位置数增加不会像自回归方法一样增加相同数量的串行前向,因此可以使用更深、更有表达力的 drafter。论文中使用的典型配置是 5 层 draft Transformer 和大小为 16 的 block,并共享 target model 的 embedding 与 LM head。

整体来看,DFlash 的核心思路是:使用 target hidden features作为预测依据,将之投影为diffusion 模型的 KV,从而利用block diffusion 降低 draft 延迟,target verification 保证无损输出。

vLLM Ascend中的draft model滑窗注意力

相关PR:[Feature] Add kv sliding window for Eagle3 and DFlash

为什么draft model需要滑窗注意力

DFlash的target model与draft model对长上下文的处理能力并不对称。target model负责理解完整输入,并在完整上下文上进行最终验证;draft model只有少量Transformer层,训练上下文通常也显著短于线上可能出现的上下文。DFlash论文中的基础drafter在4K上下文上训练,而该PR测试的输入最长达到128K。若推理时让draft model直接关注全部target hidden features,drafter会进入训练分布之外的长度范围:大量较早的KV会稀释与下一个token最相关的局部信息,位置外推和有限的模型容量也会进一步降低候选质量。

对于位置$t$,完整注意力和大小为$W$的滑窗注意力分别为:

$$
\begin{aligned}
o_t^{\text{full}}&=\operatorname{Attn}(q_t,K_{0:t},V_{0:t}),\
o_t^{\text{window}}&=\operatorname{Attn}
\left(q_t,K_{\max(0,t-W):t},V_{\max(0,t-W):t}\right).
\end{aligned}
$$

限制draft model只读取最近的KV有两个收益:

  1. 改善draft质量:让drafter看到的上下文长度更接近训练分布,并突出对未来几个token最重要的局部依赖,从而提高接受长度;
  2. 减少draft attention开销:输入继续增长时,drafter参与attention计算的KV数量被限制在$O(W)$,而不是随完整上下文增长到$O(L)$。

这里的滑窗只作用于draft model。target model仍使用完整上下文验证候选,因此即使窗口遗漏了某个远距离依赖,也只会使候选被拒绝,不会改变target model最终生成的结果。也就是说,滑窗可能改变加速比,但不会破坏Speculative Decoding的无损性。

相关组件在vLLM中的位置

该PR基于vLLM V1 speculative decoding框架,在vLLM Ascend的设备适配层实现。主要组件的位置如下:

组件 代码位置 在框架中的职责
NPUModelRunner worker/model_runner_v1.py Ascend执行入口,继承vLLM的GPUModelRunner,组织target forward、drafter调用、采样与验证
AscendDflashProposer spec_decode/dflash_proposer.py DFlash算法适配层,将target hidden states写入draft KV,并构造anchor与mask query
AscendSpecDecodeBaseProposer spec_decode/llm_base_proposer.py Eagle3、DFlash等LLM drafter共享的执行层,准备attention metadata并运行draft model;本PR的接入点位于这里
SlidingWindowAdapter spec_decode/utils.py 本PR新增的metadata适配器,将完整Paged KV视图转换为draft attention的窗口视图
AscendCommonAttentionMetadata attention/utils.py model runner与各attention backend之间共享的批次级元数据,保存block_table_tensor、seq_lens和slot_mapping等信息
AscendAttentionMetadataBuilder attention/attention_v1.py 将公共metadata转换成逐层AscendMetadata,最终把block table和序列长度交给FIA attention backend

组件之间的调用关系如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
SchedulerOutput
|
v
NPUModelRunner
|-- target model forward / verification(完整上下文)
|
`-- AscendDflashProposer.set_inputs_first_pass
| 构造 anchor + mask query,准备 target hidden states
v
AscendSpecDecodeBaseProposer._propose
|
|-- SlidingWindowAdapter.apply
| 改写 block_table_tensor 与 seq_lens
|
|-- AscendAttentionMetadataBuilder.build
| 生成逐层 AscendMetadata
|
`-- DFlash model -> Ascend Attention Backend -> FIA
只读取窗口内的 draft KV

一个重要的设计点是:SlidingWindowAdapter位于proposer和attention metadata builder之间。FIA仍执行普通Paged Attention,只是它收到的block table和有效序列长度已经被裁剪,因此只能寻址到窗口内的KV page。

配置与初始化

PR提供的启用方式是通过vLLM的额外配置传入窗口大小:

1
2
--additional-config '{"draft_window_size": 2048}' \
--speculative-config '{"method":"dflash","model":"<draft-model>","num_speculative_tokens":7}'

NPUModelRunner初始化时会根据speculative method选择AscendDflashProposer。DFlash proposer继承自AscendEagleProposer,而后者又使用AscendSpecDecodeBaseProposer提供的公共执行逻辑。因此,PR #10023只需在base proposer中读取draft_window_size并创建一个SlidingWindowAdapter,就可以同时覆盖DFlash和Eagle3。PR #12103又将adapter的创建时机从proposer构造阶段移到了load_model(),原因是此时才能从已加载的draft attention backend取得正确的kernel block size。

初始化adapter时还需要设置future_offset:

1
future_offset = 0 if method == "dflash" else num_speculative_tokens

这是因为两种proposer调用adapter时,seq_lens的含义不同:

  • Eagle3此时的seq_lens只包含已有context,之后还会逐步产生$K$个draft token,所以窗口终点需要额外加上$K$,即future_offset=K;
  • DFlash的set_inputs_first_pass已经把一个bonus/anchor token和$K$个mask query加入seq_lens,即$L_{\text{apply}}=L_{\text{context}}+1+K$,所以不能再次加$K$,使用future_offset=0。

future_offset会被保存在adapter的_future_offset成员中,并在后续每次调用SlidingWindowAdapter.apply()时参与窗口起点计算:

1
2
start = floor_to_block_boundary(seq_lens + future_offset - window_size)
windowed_seq_lens = seq_lens - start

它的作用是提前为尚未计入当前seq_lens的draft位置预留窗口右侧空间。以Eagle3为例,如果当前context长度已经接近$W$,但计算起点时没有加入未来的$K$个draft token,那么第0步得到的窗口已经占满;后续每生成一个draft token,有效attention范围都会继续增长,最终变成$W+K$。加入future_offset=K后,窗口起点会相应右移,使第$K$步结束时“保留的context + 新增draft token”仍落在同一个大小为$W$的窗口中。

未配置draft_window_size时不会创建adapter,也不会执行任何block table复制,原有路径保持不变。PR #12103之后,公开配置入口仍然是additional_config.draft_window_size。

SlidingWindowAdapter如何生成窗口视图

vLLM使用Paged KV Cache。每个request的block_table_tensor保存“逻辑KV block到物理KV block”的映射;attention kernel通过block table找到需要读取的KV page,而seq_lens告诉kernel这些page中有多少token有效。

设adapter执行时某个request的序列长度为$L$,窗口大小为$W$,KV block大小为$B$,future_offset为$F$。PR先计算窗口的起点:

$$
S=\left\lfloor
\frac{\max(0,L+F-W)}{B}
\right\rfloor B.
$$

窗口必须从block边界开始,因此这里向下取整,而不是精确地从$L+F-W$开始。以$L=200$、$F=3$、$W=64$、$B=16$为例,精确窗口起点原本是$200+3-64=139$,向下对齐到block边界后得到$S=128$:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
                              窗口右端 R = L + F
|
v
精确窗口起点 s_exact = max(0, R - W) = max(0, L + F - W)
|
| 向下对齐到 KV block 边界
v
S = floor(s_exact / B) * B
/ \
v v
起始block j_start = S / B 当前窗口长度 L_window = L - S
|
v
需要的block数 n_blocks = ceil(L_window / B)
1
2
3
4
5
6
token position
0 127 128 138 139 199 200 202
|----------- 丢弃 -----------| |-- 对齐补入 --| |--- 已有context ---| | future |
^ S=128 ^ 精确起点=139 ^ L=200 ^ L+F=203
|<--------- 实际覆盖 75 token ---------------->|
|<---- 目标窗口 W=64 ------->|

future_offset=3表示右侧的[200, 203)尚未包含在当前$L$中,但计算窗口起点时必须把它算进去。向下对齐又向窗口左侧多保留了[128, 139)这11个token,所以实际覆盖75个token,而不是严格的64个。

随后计算相对窗口长度、起始逻辑block和需要复制的block数:

$$
L_{\text{window}}=L-S,\qquad
j_{\text{start}}=\frac{S}{B},\qquad
n_{\text{blocks}}=\left\lceil\frac{L_{\text{window}}}{B}\right\rceil.
$$

这里的$L_{\text{window}}$只表示当前已经计入$L$的部分。在上述例子中:

$$
L_{\text{window}}=200-128=72,\qquad
j_{\text{start}}=128/16=8,\qquad
n_{\text{blocks}}=\lceil72/16\rceil=5.
$$

从block视角看,窗口横跨逻辑block 8到12:

1
2
3
4
5
6
7
8
逻辑block          8              9              10             11             12
token范围 [128,143] [144,159] [160,175] [176,191] [192,207]
|--11个对齐--| |
|<----------- 64 token目标窗口 ------------------------>|
|<---- 当前L_window=72 token(128..199)---->|--future--|--空余--|

需要复制的block: [ B8 ][ B9 ][ B10 ][ B11 ][ B12 ]
\________________________ ceil(72 / 16) = 5 _____________________/

虽然$W/B=4$,但精确窗口起点139落在block 8内部,窗口终点又落在block 12内部,因此实际需要5个block。这就是代码不能只分配$\lceil W/B\rceil$列,而要额外预留一列的原因。

例如,DFlash调用adapter时$L=200$、$W=64$、$B=16$、$F=0$:

$$
S=\left\lfloor\frac{200-64}{16}\right\rfloor16=128,
\qquad L_{\text{window}}=200-128=72.
$$

因此完整block table从第8个逻辑block开始被裁剪,draft attention实际读取最近72个token对应的5个page:

1
2
3
4
5
完整逻辑 block:   0   1   2   3   4   5   6   7 | 8   9   10  11  12 | ...
完整 block table: P0 P1 P2 P3 P4 P5 P6 P7 | P8 P9 P10 P11 P12 | ...
\_________________/
draft读取视图: [ P8 P9 P10 P11 P12 ]
seq_len = 72

其中P0到P12表示物理KV block id,它们不要求连续。adapter只是复制这些id形成新的索引视图,不会搬运物理KV数据。

同步修改所有序列长度

裁剪block table后,序列长度也必须从完整长度$L$改为窗口内的相对长度$L_{\text{window}}$。否则FIA在把裁剪后block table的第一列当作起点之后,却仍按完整长度读取,造成block table越界或读取错误page。

AscendCommonAttentionMetadata同时保存NPU和CPU上的多份长度:

  • seq_lens:NPU tensor;DFlash的parallel_drafting路径直接使用它;
  • seq_lens_cpu:部分host侧metadata逻辑使用的长度;
  • _seq_lens_cpu:Ascend attention builder优先读取的vLLM基类字段;
  • seq_lens_cpu_upper_bound:图执行和长度上界相关使用的镜像。

SlidingWindowAdapter.apply会同步替换这些字段。
CPU侧的这些字段执行同样的计算,而不是从NPU读取,省去了一次evice-to-host拷贝。

读取使用窗口block table,写KV必须使用完整block table

block_table_tensor在vLLM中有两个不同用途:

  1. attention根据它读取历史KV;
  2. slot_mapping根据它计算新token应该写入哪个物理KV slot。

滑窗裁剪后,新block table的第0列已经对应原完整block table的第$j_{\text{start}}$列,适合从窗口起点读取KV,但由于在写KV时,该PR使用的是token的绝对位置计算写地址,因此,需要保留历史KV,并使用完整的block table计算写入地址。在实现上,SlidingWindowAdapter.apply会保存原始的full_block_table;attn_update_stack_num_spec_norm计算slot_mapping时仍使用完整表。

1
2
3
4
5
6
7
8
                         同一份物理 draft KV cache
/ \
attention读取路径 / \ 新token写入路径
window block table full block table
只暴露最近W附近的page 按绝对position定位page
| |
v v
FIA计算窗口attention slot_mapping写入完整KV cache

例如,block size为4,完整映射为:

1
2
3
4
5
token位置:       0~3    4~7    8~11
逻辑block: 0 1 2
物理block: P7 P3 P9

full_block_table = [P7, P3, P9]

若窗口从token 4开始,则滑窗block table变成[P3, P9]。写入绝对位置$p=10$时,现有代码计算逻辑block为10 // 4 = 2:full_block_table[2]能正确找到P9,但滑窗block table的索引2已经越界。只有改用相对索引(10 - 4) // 4 = 1,才能通过滑窗block table找到P9。

因此,该PR实现的是完整保存、窗口读取,并没有释放窗口之外的draft KV:

  • draft KV cache仍保存完整序列,显存容量不会因窗口而按比例下降;
  • draft attention只读取最近的page,计算量和访存量下降;

若要真正释放旧KV,还需要增加窗口基址或循环缓存,并同步修改slot_mapping与KV allocator;该PR没有实现这些机制。

图模式与单元测试

ACL Graph会复用capture阶段记录的attention算子。capture时,输入block_table_tensor的列数和存储buffer已经确定;如果运行时根据实际窗口生成不同列数的block table,例如从[16, 5]变成[16, 6],捕获的FIA调用就无法直接复用。SlidingWindowAdapter因此预先分配[max_num_reqs, max_window_blocks]大小的_block_table_clone,运行时只更新内容并取前num_reqs行,列数和底层buffer保持不变,未使用的列填零。

Hybrid Attention的block size初始化修复

相关PR:vllm-project/vllm-ascend#12103

修复了什么bug

PR #10023最初在AscendSpecDecodeBaseProposer.__init__()中创建SlidingWindowAdapter时,传入的block size是不正确的self.runner.block_size。问题可以直接概括为:

SlidingWindowAdapter应该使用block_size=128,旧代码却传入了block_size=2048。

为什么同时会出现128和2048两个值?需要分清“分配内存”和“运行attention算子”两件事:

  • KVCache Block的背景:vLLM启动时会预先申请一块KV cache内存,再把它切成许多固定大小的物理block。每个物理block有一个ID;运行时,KV cache manager只是把空闲block ID分给request,不是每次临时申请新内存。
  • block_size的意义:runner.block_size是每个attention物理block里有多少个token的K/V存储位置。runner.block_size=2048就表示一个attention物理block可以存token 0~2047这2048个位置的K/V。
  • Qwen3.6混合注意力带来的问题:Qwen3.6既有full attention层,又有GDN层。full attention层要保存每个token的K/V,GDN层要保存一个递归状态tensor。vLLM为了用统一的block ID管理这两种cache,会让两者的一个物理block占用相同的字节数。如果某层的GDN状态tensor比默认attention KV block更大,vLLM会增大runner.block_size,以让两种物理block的内存字节数对齐。随着block_size增大,Full Attention的内存字节数会随之增大,而GDN状态的大小保持不变。
  • kernel_block_size是FIA使用的block size,即进行注意力计算时,底层算子的block_size。如果draft attention backend返回128,那么交给FIA的每个block ID都对应连续128个token的K/V。

vLLM Ascend在构造BlockTable时已经处理了这个差异:它会把一个2048-token的物理block拆成$2048/128=16$个kernel block。假设某个request的token 0~2047存在物理block 3中,那么交给FIA的block table不是只有一列[3],而是展开成16个逻辑block ID:$3\times16=48$,即[48, 49, ..., 63]。对应的BlockTable拆分代码

在BlockTable.__init__()中,会保留物理block size,再把对外使用的block_size改成kernel block size:

1
2
3
4
5
6
self.physical_block_size = block_size
self.block_size = selected_kernel_size
self.logical_block_size = selected_kernel_size
self.blocks_per_phys_block = (
self.physical_block_size // self.logical_block_size
)

物理block ID被展开时,代码直接生成对应的一段逻辑block ID:

1
2
3
4
base_logical = phys_block * self.blocks_per_phys_block
logical_blocks.extend(
range(base_logical, base_logical + self.blocks_per_phys_block)
)

因此,physical_block_size=2048、logical_block_size=128时,blocks_per_phys_block=16;物理block 3就会生成逻辑block 48~63。

1
2
3
4
5
6
7
8
9
10
11
KV cache内存池(启动时已经分好):
物理block 0 [2048个token槽位]
物理block 1 [2048个token槽位]
...
物理block 3 [2048个token槽位] <- 分给这个request,存它的token 0~2047

交给FIA的block table:
列号 0 1 2 14 15
block ID 48 49 50 ... 62 63
token位置 0~127 128~255 256~383 ... 1792~1919 1920~2047
`----------- 每个block ID对应一个128-token KV block -----------'

SlidingWindowAdapter裁剪的是下面这张已展开成16列的表,所以它必须使用128计算列号,不能使用2048。

继续用一个具体例子说明旧代码怎么算错。假设Eagle3当前有$L=2000$个token,$F=3$、$W=512$,draft FIA的block size为128,而runner.block_size为2048:

正确:$B=128$ 错误:$B=2048$
精确起点$L+F-W$ 1491 1491
向下对齐后的$S$ 1408 0
起始block索引$S/B$ 11 0
窗口内有效长度$L-S$ 592 2000
adapter认为需要的block数 5 1

上表对应SlidingWindowAdapter中的这几行。起点、起始block索引和block数都直接依赖b = self.block_size:

1
2
3
4
5
6
7
8
9
b = self.block_size
self.start_tokens_in_window_rounding = ((
common_attn_metadata.seq_lens + k_future - w
).clamp(min=0) // b) * b
self._windowed_seq_lens = (
common_attn_metadata.seq_lens - self.start_tokens_in_window_rounding
)
start_block_indices = self.start_tokens_in_window_rounding // b
needed_blocks_per_req = (self._windowed_seq_lens + b - 1) // b

滑窗计算的完整实现

正确情况下,adapter从第11列开始取出5列,即block ID 59~63,覆盖序列尾部。旧代码使用2048计算,会得到“从第0列开始,只需1列”,于是只留下block ID 48。但FIA认为block ID 48只包含token 0~127,而传入的有效序列长度却是2000。block table说“我只给了128个token的KV”,seq_lens却说“请读2000个token”,两个输入不匹配。问题不在滑窗公式本身,而在于公式使用了错误的$B$。

代码如何修改

AscendSpecDecodeBaseProposer是vLLM Ascend中DFlash和Eagle3共用的draft执行层,位于NPUModelRunner与draft model/attention backend之间。PR将初始化拆成两步:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
AscendSpecDecodeBaseProposer.__init__
`-- 只声明draft_window_size和sliding_window,初值均为None

AscendSpecDecodeBaseProposer.load_model
|-- 加载draft model
|-- 找到draft attention layers
|-- 从第一个attention layer取backend
|-- backend.get_supported_kernel_block_sizes()[0]
| `-- 得到kernel_block_size
|-- 读取additional_config.draft_window_size
`-- 用kernel_block_size创建SlidingWindowAdapter

AscendSpecDecodeBaseProposer._propose
`-- sliding_window.apply(common_attn_metadata)
`-- 使用FIA的block_size裁剪block table和seq_lens

模型加载后,PR从实际的draft attention layer上找到backend,再读取它支持的block size:

1
2
3
4
5
self.kernel_block_size = (
draft_attn_layers_dict[self.attn_layer_names[0]]
.get_attn_backend()
.get_supported_kernel_block_sizes()[0]
)

最关键的修改:

1
2
3
4
5
6
 self.sliding_window = SlidingWindowAdapter(
self.draft_window_size,
- self.runner.block_size,
+ self.kernel_block_size,
...
)

之所以移到load_model(),是因为构造proposer时draft attention layer还没有加载,还不知道最后会使用哪个attention backend,也就不知道FIA的block_size是多少。模型加载后再创建adapter,就可以直接使用backend返回的block_size,而不是拿KV cache管理器的物理block size代替。