0%

Qwen3.6 Dense的GDN前传与vLLM-Ascend实现

范围与代码版本

本文分析的是Qwen3.6-27B的文本主干。这里的Dense表示每层使用普通MLP,而不是Qwen3.6-35B-A3B中的MoE。Qwen3.6-27B的配置虽然仍注册为Qwen3_5ForConditionalGeneration、model_type=qwen3_5,但这是代码架构名;vLLM-Ascend也明确将Qwen3.5-27B和Qwen3.6-27B归为共享GDN/全注意力混合架构的一组模型。

本文以本地代码为准:

  • vllm-ascend:f4a08bddd0cc65a0bd8c3d377b158ae5ca7527db;
  • 该版本在.github/vllm-release-tag.commit中指定的配套vLLM版本:v0.23.0;
  • 模型配置:Qwen/Qwen3.6-27B的config.json。

Qwen3.6-27B文本主干的关键配置如下:

配置 数值
hidden size 5120
decoder层数 64
GDN层数 48
全注意力层数 16
层排列 3个GDN层 + 1个全注意力层,循环16次
GDN key head数 16
GDN value head数 48
key/value head dim 128/128
causal Conv1D kernel size 4
Dense MLP intermediate size 17408

需要先区分两个容易混用的范围:

  1. 完整的GDN decoder层:RMSNorm、残差连接、GDN mixer、RMSNorm、Dense MLP和残差连接;
  2. GDN mixer本身:输入投影、因果卷积、Gated Delta Rule、输出门控和输出投影。

下面先讲完整decoder层,再展开GDN mixer。

一次GDN decoder层前传

在vLLM中,Qwen3_5DecoderLayer根据layer_type选择GDN或全注意力。Qwen3.6的GDN层对应linear_attention:

1
2
3
4
5
6
7
if self.layer_type == "linear_attention":
self.linear_attn = QwenGatedDeltaNetAttention(
config=config,
vllm_config=vllm_config,
prefix=f"{prefix}.linear_attn",
gqa_interleaved_layout=False,
)

其中gqa_interleaved_layout=False很重要:Qwen3.6沿用Qwen3.5的非交错权重布局,逻辑上的$q,k,v,z$以及$b,a$在权重文件中分别保存,加载时再打包为in_proj_qkvz和in_proj_ba。

忽略可选的layer_scale和并行通信后,一个完整GDN decoder层可写成:

$$
\begin{aligned}
u &= \operatorname{RMSNorm}(x),\
x’ &= x + \operatorname{GDN}(u),\
v &= \operatorname{RMSNorm}(x’),\
y &= x’ + \operatorname{MLP}(v).
\end{aligned}
$$

vLLM为了把残差加法和RMSNorm融合,代码中不会每次都显式写出x + ...,而是用hidden_states和residual两个tensor跨层传递:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if residual is None:
residual = hidden_states
hidden_states = self.input_layernorm(hidden_states)
else:
hidden_states, residual = self.input_layernorm(hidden_states, residual)

self.linear_attn(
hidden_states=hidden_states,
output=self_attention_output,
)

hidden_states, residual = self.post_attention_layernorm(
self_attention_output, residual
)
hidden_states = self.mlp(hidden_states)
return hidden_states, residual

因此,函数返回时最后一次MLP残差可能尚未在Python层显式相加,它会在下一层的input_layernorm(hidden_states, residual)中完成融合的add+RMSNorm。数学含义仍然是标准的两段残差结构。

例如,为了只看清残差的传递,暂时忽略RMSNorm,并把tensor简化成标量。假设层输入为10,GDN输出为2,MLP输出为3:

1
2
3
层输入                 10
GDN残差相加后 10 + 2 = 12
MLP残差相加后 12 + 3 = 15

vLLM在本层返回的却可能是hidden_states=3, residual=12,下一层开头再由融合的add+RMSNorm先计算3 + 12 = 15。因此两个tensor并不是两条独立语义分支,只是为了延迟并融合残差加法。

Dense MLP是标准SwiGLU:

$$
\operatorname{MLP}(x)=W_{down}\left(\operatorname{SiLU}(W_{gate}x)\odot W_{up}x\right).
$$

vLLM对应Qwen3NextMLP(实际复用Qwen2MoeMLP),内部依次调用MergedColumnParallelLinear(gate_up_proj)、SiluAndMul和RowParallelLinear(down_proj)。在vLLM-Ascend中,SiluAndMul被替换为AscendSiluAndMul,非量化路径调用torch_npu.npu_swiglu。

GDN mixer做了什么

一次普通GDN前传可以概括为:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
hidden_states [N, 5120]
|
+-----------------------+
| |
v v
in_proj_qkvz in_proj_ba
q, k, v, z b, a
| |
v v
causal depthwise Conv1D g与beta计算
+ SiLU g=-exp(A_log)*softplus(a+dt_bias)
| beta=sigmoid(b)
v |
reshape q, k, v |
| |
v v
q、k做L2Norm ------> Gated Delta Rule <---- 旧ssm_state
|
+----> 写回新ssm_state
|
v
core_attn_out
|
RMSNorm(out) * SiLU(z)
|
out_proj
|
v
GDN输出 [N, 5120]

这里$N$是本轮所有请求打平后的实际token数。GDN不保存随上下文长度增长的K/V序列,而是为每个请求维护两个定长状态:

  • conv_state:保存因果卷积需要的最近若干个投影输入;
  • ssm_state:保存Gated Delta Rule的矩阵状态。

Qwen3.6仍包含16个全注意力层,因此整个模型仍然有会随上下文增长的KV cache;定长状态只描述48个GDN层。

例如,一条请求已经处理了100个token,现在解码第101个token。进入某个GDN层后,该层不会重新读取前100个token的$q/k/v$,而是:

1
2
3
4
5
6
第101个token的hidden_states
-> 投影出当前token的q、k、v、z、a、b
-> 用conv_state中的最近3个投影输入完成宽度为4的卷积
-> 用旧ssm_state和当前q、k、v、g、beta做一次状态更新
-> 写回新conv_state和新ssm_state
-> 输出当前token的GDN结果

这就是GDN decode可以用定长状态概括历史的具体含义。

输入投影与tensor形状

AscendGatedDeltaNetAttention.forward首先做两次投影:

1
2
3
4
5
6
7
mixed_qkvz, _ = self.in_proj_qkvz(hidden_states)
qkv_size = (self.key_dim * 2 + self.value_dim) // self.tp_size
z_size = self.value_dim // self.tp_size
mixed_qkv, z = mixed_qkvz.split([qkv_size, z_size], dim=-1)

ba, _ = self.in_proj_ba(hidden_states)
b, a = self._split_ba_for_tp(ba)

设tensor parallel大小为$p$,Qwen3.6-27B各tensor的本地形状如下:

tensor 作用 单个TP rank上的形状
输入$x$ decoder隐藏状态 $[N,5120]$
$q$ 查询向量 $[N,2048/p]$
$k$ 键向量 $[N,2048/p]$
$v$ 写入状态的目标值 $[N,6144/p]$
$z$ GDN输出门 $[N,48/p,128]$
$b$ delta更新强度的logit $[N,48/p]$
$a$ 衰减时间步的logit $[N,48/p]$
mixed_qkv 打包的$q,k,v$ $[N,10240/p]$
GDN核心输出 每个value head的输出 $[N,48/p,128]$

例如TP=2,本轮batch打平后共有3个token,即$N=3$。单个NPU上的$q/k$形状是[3, 1024];展平的$v/z$是[3, 3072],其中$z$随后变成[3, 24, 128];$b/a$是[3, 24];GDN核心输出也是[3, 24, 128]。两个TP rank各计算24个value head,最后由行并行的out_proj合并两边的结果。

Qwen3.6有16个key head和48个value head,因此每3个value head共享一组$q/k$。ssm_state仍按48个value head保存;对第$h$个value head,算子使用它所属组的$q/k$和自己的$v,g,\beta$。

未开启投机推理时,每个请求、每个GDN层的状态形状为:

$$
\text{conv_state}: [10240/p,3],\qquad
\text{ssm_state}: [48/p,128,128].
$$

其中3来自conv_kernel_size - 1。具体存储时,conv_state前两维会根据VLLM_SSM_CONV_STATE_LAYOUT采用DS或SD顺序;投机推理还会为卷积状态增加用于回滚的token槽位。

TP=2时额外发生了什么

这里先讨论最基本的TP=2路径:不考虑sequence parallel、FlashComm和matmul-allreduce融合。相对TP=1,需要区分两类变化:

  1. 分片:权重、head和GDN状态各放一半。这减少单卡计算和显存,但不是跨卡通信;
  2. 归约:两个rank分别得到输出的一部分贡献后,需要求和。这才是TP=2真正新增的运行时操作。

TP=2下每个rank持有的数据如下:

位置 全局逻辑形状 单个rank的形状 是否通信
decoder输入 $[N,5120]$ $[N,5120]$,两个rank各有一份 否
in_proj_qkvz输出 $[N,16384]$ $[N,8192]$ 否
其中mixed_qkv $[N,10240]$ $[N,5120]$ 否
其中$z$ $[N,48,128]$ $[N,24,128]$ 否
in_proj_ba输出 $[N,96]$ $[N,48]$,即24个$b$和24个$a$ 否
conv_state $[10240,3]$ $[5120,3]$ 否
ssm_state $[48,128,128]$ $[24,128,128]$ 否
GDN out_proj输入 $[N,6144]$ $[N,3072]$ 否
GDN out_proj输出 $[N,5120]$ 先产生$[N,5120]$局部贡献 一次TP AllReduce
MLP gate_up_proj输出 $[N,34816]$ $[N,17408]$ 否
SwiGLU输出 $[N,17408]$ $[N,8704]$ 否
MLP down_proj输出 $[N,5120]$ 先产生$[N,5120]$局部贡献 一次TP AllReduce

一次完整GDN decoder层的基本TP=2数据流如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
              replicated hidden_states [N, 5120]
|
+----------------+----------------+
| |
TP rank 0 TP rank 1
q/k各8个head,v/z各24个head q/k各8个head,v/z各24个head
本地conv + Gated Delta Rule 本地conv + Gated Delta Rule
| |
out_proj局部结果 y0 out_proj局部结果 y1
+---------------+-----------------+
|
HCCL AllReduce(sum): y0 + y1
|
replicated GDN输出 [N, 5120]
|
post-attention Norm/残差
|
+---------------+-----------------+
| |
本地gate/up各8704维 本地gate/up各8704维
SwiGLU -> down局部结果 m0 SwiGLU -> down局部结果 m1
+---------------+-----------------+
|
HCCL AllReduce(sum): m0 + m1
|
replicated decoder层输出

为什么列并行投影后不需要AllGather?in_proj_qkvz、in_proj_ba和MLP的gate_up_proj都设置为gather_output=False。每个rank只保留自己负责的head或中间维,后面的卷积、Gated Delta Rule、门控和SwiGLU也恰好能在这些本地分片上继续计算。只有out_proj和down_proj要把“按输入维切开的矩阵乘”恢复成完整hidden size,因此必须把两个局部结果相加:

$$
y=x_0W_0+x_1W_1=y_0+y_1.
$$

上游RowParallelLinear.forward中的对应逻辑是:

1
2
3
4
5
output_parallel = self.quant_method.apply(self, input_parallel, bias_)
if self.reduce_results and self.tp_size > 1:
output = tensor_model_parallel_all_reduce(output_parallel)
else:
output = output_parallel

因此在基本路径中,一个GDN decoder层一共新增两次TP AllReduce:一次在GDN out_proj之后,一次在Dense MLP的down_proj之后。因果卷积、$g/\beta$计算、L2Norm、prefill chunk GDN和decode recurrent GDN都只处理本rank的head与状态,不产生TP通信。

需要特别注意,ops/gdn.py中的get_pcp_group().all_gather(...)属于prefill context parallel(PCP),不是tensor parallel。仅仅设置--tensor-parallel-size 2不会触发这段PCP通信。

vLLM-Ascend可能使用的通信融合

上面的两次AllReduce描述的是数学上的基本路径。当前仓库还可能根据配置将“局部GEMM + AllReduce”合并为一个算子。MatmulAllreduceRowParallelOp在TP大于1时调用:

1
2
3
output = torch_npu.npu_mm_all_reduce_base(
input_parallel, self.layer.weight.t(), self.hcomm_info, bias=bias_
)

这并没有取消跨卡求和,只是让矩阵乘和HCCL归约在一个融合实现中执行,以减少独立算子调度并争取计算、通信重叠。

如果sequence parallel生效,通信形态会进一步变为:列并行投影前通过maybe_all_gather_and_maybe_unpad收集token,行并行投影后通过ReduceScatter重新按token切分;开启MMRS融合时,对应torch_npu.npu_mm_reduce_scatter_base。因此长prefill可能看到AllGather/ReduceScatter,而不是上述两个独立AllReduce。它们是sequence parallel带来的优化路径,不是TP=2本身必然增加的操作;短decode通常仍可按基本TP路径理解。

qwen_gdn_attention_core是图边界,不是最终硬件算子

完成投影后,Ascend前传调用:

1
2
3
4
5
6
7
8
9
core_attn_out = torch.zeros(
(num_tokens, self.num_v_heads // self.tp_size, self.head_v_dim),
dtype=hidden_states.dtype,
device=hidden_states.device,
)

torch.ops.vllm.qwen_gdn_attention_core(
mixed_qkv, b, a, core_attn_out, self.prefix, False
)

qwen_gdn_attention_core是vLLM通过direct_register_custom_op注册的高层custom op。它的作用是给torch.compile提供一个稳定边界,并通过ForwardContext找到当前GDN层,再调用被vLLM-Ascend替换过的_forward_core:

1
2
3
4
5
6
7
self = forward_context.no_compile_layers[layer_name]
self._forward_core(
mixed_qkv=qkv_or_qkvz,
b=b_or_ba,
a=a_or_z_out,
core_attn_out=core_attn_out,
)

所以不能把qwen_gdn_attention_core理解为一个完成所有计算的AscendC kernel。真正的卷积、门控和delta rule会继续下沉到多个Triton或AscendC算子。

GDN核心的数学操作

1. 因果depthwise Conv1D

先对打包后的$q,k,v$逐通道执行宽度为4的因果卷积,再做SiLU:

$$
\widetilde{x}{t,c}
=\operatorname{SiLU}\left(
\sum
{i=0}^{3}w_{c,i}x_{t-i,c}
\right),
\qquad x=[q;k;v].
$$

它只在时间维混合相邻token,不混合通道。随后将卷积结果重新拆成$q,k,v$。

在A2/A3/A5主路径中,对应算子都是:

1
torch.ops._C_ascend.npu_causal_conv1d_custom(...)

但参数不同:

  • prefill:run_mode=0,按query_start_loc处理变长序列,并把每条序列末尾写入conv_state;
  • decode:run_mode=1,读取旧conv_state,推入本轮token并更新状态;
  • speculative decode:同样使用更新模式,同时传入num_accepted_tokens,保证状态推进到已接受token对应的位置。

一个单通道的简化例子可以说明conv_state保存的是什么。假设卷积核宽度为4、权重全为1,并暂时忽略SiLU。prefill依次处理投影值[1, 2, 3, 4, 5]后,只需保存最后3个值:

1
conv_state = [3, 4, 5]

下一个decode token的投影值为6时,卷积输入就是[3, 4, 5, 6],卷积结果为18;随后状态更新成[4, 5, 6]。真实模型会对mixed_qkv全局10240个通道(单个TP rank为$10240/p$)分别做同样的depthwise卷积,并执行SiLU,但不需要重新读取更早的[1, 2]。

2. 计算衰减门$g$和更新门$\beta$

投影得到$a,b$后,每个value head计算:

$$
g_t=-\exp(A_{log})\cdot\operatorname{softplus}(a_t+dt_{bias}),
\qquad
\beta_t=\operatorname{sigmoid}(b_t).
$$

由于$g_t\le 0$,真正乘到旧状态上的遗忘系数$\exp(g_t)$位于$(0,1]$。DeviceOperator.fused_gdn_gating把softplus、指数、乘法和sigmoid合并:

1
2
3
g, beta = DeviceOperator.fused_gdn_gating(
self.A_log, a, b, self.dt_bias
)

硬件分支为:

  • A2/A3:torch.ops._C_ascend.npu_fused_gdn_gating,仓库内AscendC自定义算子;
  • A5:fused_gdn_gating_patch,Triton NPU kernel;
  • 310P:走gdn_310.py中的PyTorch组合实现。

例如取$A_{log}=0,a=0,dt_{bias}=0,b=0$,则:

$$
g=-\operatorname{softplus}(0)=-\ln 2,\qquad
\exp(g)=0.5,\qquad
\beta=\operatorname{sigmoid}(0)=0.5.
$$

这组数的含义很直接:旧状态先保留一半,然后当前token带来的预测误差再以0.5的强度写入。注意算子输出的$g$是log-space衰减值,真正衰减旧状态的是后续delta rule中的$\exp(g)$。

3. q/k L2Norm

Gated Delta Rule之前,对$q,k$的最后一维做L2归一化:

$$
\widehat q_t=\frac{q_t}{\sqrt{\lVert q_t\rVert_2^2+\epsilon}},
\qquad
\widehat k_t=\frac{k_t}{\sqrt{\lVert k_t\rVert_2^2+\epsilon}}.
$$

decode路径在调用recurrent算子前显式执行l2norm_fwd;prefill路径向chunk_gated_delta_rule传入use_qk_l2norm_in_kernel=True,由chunk封装执行相同操作。

例如$q=[3,4]$、$k=[0,2]$,归一化后分别变成$\widehat q=[0.6,0.8]$和$\widehat k=[0,1]$。归一化消除了向量长度的影响,使状态的读写方向主要由$q/k$的方向决定。

4. Gated Delta Rule状态更新

为方便和AscendC实现中的内存布局一致,令单个value head的状态$S_t\in\mathbb{R}^{d_v\times d_k}$。一次token更新为:

$$
\begin{aligned}
\bar S_t &= \exp(g_t)S_{t-1},\
\delta_t &= \beta_t\left(v_t-\bar S_t\widehat k_t\right),\
S_t &= \bar S_t+\delta_t\widehat k_t^\top,\
o_t &= S_t\left(\widehat q_t/\sqrt{d_k}\right).
\end{aligned}
$$

直观上,$S$先遗忘一部分旧信息,再读取当前key对应的旧预测$S\widehat k$;预测误差$v-S\widehat k$乘$\beta$后,以秩一更新写回状态。最后使用$q$从更新后的状态读出$o$。

用一维标量把这四步完整算一遍。设旧状态$S_{t-1}=4$,沿用上面的$\exp(g)=0.5$、$\beta=0.5$,再取$\widehat k=1$、$\widehat q=1$、$v=10$:

$$
\begin{aligned}
\bar S_t &= 0.5\times4=2,\
\delta_t &= 0.5\times(10-2\times1)=4,\
S_t &= 2+4\times1=6,\
o_t &= 6\times1=6.
\end{aligned}
$$

也就是说,状态原本对当前key的预测是2,而目标值是10;本轮只纠正一半误差,所以新状态变成6。真实模型把这个标量换成[128,128]矩阵,并同时处理多个head,数学含义不变。

AscendC recurrent kernel中的计算顺序与上式直接对应:旧状态乘衰减系数、计算v - state @ k、乘beta、做外积更新、再用$q$读取。

Prefill和decode为什么使用不同算子

两条路径实现的是同一组状态更新公式,差别在于并行方式。

Prefill:分块并行Gated Delta Rule

长prompt若逐token执行递推,NPU利用率很低。prefill把序列按64个token分块,将块内递推改写为矩阵运算,并在块间传递状态。vllm_ascend.ops.triton.fla.chunk.chunk_gated_delta_rule的主要步骤是:

1
2
3
4
5
6
g = chunk_local_cumsum(g, chunk_size=64, ...)
A = chunk_scaled_dot_kkt_fwd(k=k, beta=beta, g_cumsum=g, ...)
A = solve_tril(A=A, ...)
w, u = recompute_w_u_fwd(k=k, v=v, beta=beta, A=A, ...)
h, v_new, final_state = torch.ops._C_ascend.chunk_gated_delta_rule_fwd_h(...)
o = torch.ops._C_ascend.chunk_fwd_o(q, k, v_new, h, scale, ...)

各部分的角色如下:

步骤 函数/算子 实现 作用
块内累计衰减 chunk_local_cumsum Triton NPU 将log-space的$g$变成块内累计衰减
构造块内相互作用 chunk_scaled_dot_kkt_fwd Triton NPU 计算带$\beta$和衰减的key-key关系
解下三角系统 solve_tril Triton NPU 得到delta rule的WY表示
重算$w,u$ recompute_w_u_fwd Triton NPU 生成块状态更新所需中间量
跨块状态递推 _C_ascend.chunk_gated_delta_rule_fwd_h AscendC 根据初始状态生成各块状态,并输出最终ssm_state
计算token输出 _C_ascend.chunk_fwd_o AscendC 结合$q,k,v_{new}$和块状态得到$o$

AscendGDNAttentionMetadataBuilder会提前为每个batch构造cu_seqlens、64-token chunk索引、large-block索引以及最终chunk位置。它位于vLLM attention backend层,负责准备调度和状态寻址信息,不执行GDN数学计算。预建这些metadata也避免每个GDN层重复进行CPU计算或device-to-host同步。

例如一条prompt有130个token,真实的64-token分块为:

1
2
3
4
5
6
7
chunk 0: token   0 ...  63
chunk 1: token 64 ... 127
chunk 2: token 128 ... 129

初始ssm_state -> chunk 0末状态 -> chunk 1末状态 -> chunk 2末状态
| | |
块内64个输出 块内64个输出 块内2个输出

块与块之间仍然按时间顺序传递状态,但一个块内部的64次更新被改写成矩阵运算,因此比在Python层逐token调用64次recurrent kernel更适合NPU。

prefill结束后,last_recurrent_state会写回本请求对应的ssm_state槽位,供后续decode继续递推。

Decode:直接执行recurrent Gated Delta Rule

普通decode每个请求通常只有一个新token,此时分块会增加额外开销,直接递推更合适。vLLM-Ascend先做L2Norm,然后调用:

1
2
3
4
5
6
7
8
9
10
11
12
13
core_attn_out_non_spec = (
torch.ops._C_ascend.npu_recurrent_gated_delta_rule(
query=query_non_spec.squeeze(0),
key=key_non_spec.squeeze(0),
value=value_non_spec.squeeze(0),
g=g_non_spec.squeeze(0),
beta=beta_non_spec.squeeze(0),
state=ssm_state,
scale=key_non_spec.shape[-1] ** -0.5,
actual_seq_lengths=actual_seq_lengths,
ssm_state_indices=non_spec_state_indices_tensor,
)
).unsqueeze(0)

ssm_state_indices指出batch中每条请求应该读写哪个状态槽。算子直接原地更新ssm_state,因此decode不需要读取整段历史token,也不生成注意力矩阵。

例如当前batch包含请求A和B,它们的状态分别存放在缓存槽2和槽7,则metadata给出:

1
2
3
4
ssm_state_indices = [2, 7]

batch第0行(请求A) -> 读取并更新ssm_state[2]
batch第1行(请求B) -> 读取并更新ssm_state[7]

这样,即使请求在连续batch中的行号发生变化,recurrent算子仍能找到各自的历史状态。

投机解码一次可能处理多个候选token,仍使用npu_recurrent_gated_delta_rule,但会额外传入actual_seq_lengths、每个候选位置对应的ssm_state_indices以及num_accepted_tokens,从而只保留验证后真正接受位置的状态。

例如draft一次给请求A提出[甲, 乙, 丙]三个候选,而target只接受前两个。算子可以临时算出三个位置的输出,但num_accepted_tokens=2要求缓存最终落在处理完“乙”后的状态;“丙”对应的推进不能成为下一轮decode的起点,否则下一轮会携带一个实际上未被接受的token历史。

输出门控与输出投影

GDN核心输出$o$后,还要使用输入投影得到的$z$做门控:

$$
y_h=\operatorname{RMSNorm}(o_h)\odot\operatorname{SiLU}(z_h).
$$

代码中对应:

1
2
3
4
5
6
core_attn_out = core_attn_out.reshape(-1, core_attn_out.shape[-1])
z = z.reshape(-1, z.shape[-1])
core_attn_out = self.norm(core_attn_out, z)
core_attn_out = core_attn_out.reshape(z_shape_og)
core_attn_out = rearrange(core_attn_out, "... h d -> ... (h d)")
output[:num_tokens], _ = self.out_proj(core_attn_out)

self.norm在vLLM中是RMSNormGated(norm_before_gate=True);在Ascend平台被注册为AscendRMSNormGated,其out-of-tree实现使用layer_norm_fwd_npu Triton kernel。展平value heads后,out_proj通过RowParallelLinear将$6144/p$投影回5120。

在TP=2下,每个rank的out_proj输入是[N,3072],各自乘以输入维分片后的权重,得到两个[N,5120]局部结果;随后通过TP AllReduce求和,使两个rank都获得完整的[N,5120]输出。out_proj之前的RMSNormGated仍是纯本地操作,不需要同步另一张卡的24个value head。

vLLM组件与vLLM-Ascend实现的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
模型定义层(上游vLLM)
Qwen3_5ForConditionalGeneration
-> Qwen3_5Model
-> Qwen3_5DecoderLayer
-> QwenGatedDeltaNetAttention
|
| vLLM-Ascend运行时patch
v
插件模型适配层
patch/worker/patch_qwen3_5.py
-> 替换DecoderLayer.forward
-> 替换GDN.forward和GDN._forward_core
-> 指定AscendGDNAttentionBackend
|
+---------+----------+
| |
v v
attention backend层 算子编排层
gdn_attn_builder.py ops/gdn.py
构造batch/chunk/state 投影、prefill/decode分流、状态读写
metadata |
v
Triton / AscendC算子

各组件在框架中的职责如下:

位置 组件 在vLLM中的职责
vllm/model_executor/models/qwen3_5.py Qwen3_5DecoderLayer 模型结构层;决定当前层是GDN还是全注意力,并连接残差、Norm和MLP
vllm/model_executor/layers/mamba/gdn/qwen_gdn_linear_attn.py QwenGatedDeltaNetAttention 上游通用GDN layer;定义权重、tensor形状、custom-op边界和状态规格
vllm_ascend/patch/worker/patch_qwen3_5.py 运行时patch 将上游Qwen3.5兼容模型的forward/core/backend替换为Ascend实现;Qwen3.6也由此进入该路径
vllm_ascend/ops/gdn_attn_builder.py AscendGDNAttentionMetadataBuilder attention backend的metadata builder;划分prefill/decode/spec请求并生成状态索引、变长序列和chunk信息
vllm_ascend/ops/gdn.py AscendGatedDeltaNetAttention GDN算子编排;完成投影、conv/recurrent分支、状态读写、输出门控和投影
vllm_ascend/device/device_op.py DeviceOperator 根据A2/A3、A5或310P选择设备相关实现
vllm_ascend/ops/triton/fla/ chunk GDN相关Triton算子 prefill的块内并行计算、L2Norm和中间量构造
csrc/attention/recurrent_gated_delta_rule/ npu_recurrent_gated_delta_rule decode/投机decode的AscendC递推核
csrc/moe/causal_conv1d/ npu_causal_conv1d_custom prefill和decode共用的AscendC因果depthwise Conv1D核
csrc/attention/fused_gdn_gating/ npu_fused_gdn_gating A2/A3上的门控融合AscendC核

一次普通前传的函数调用链

Prefill

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Qwen3_5DecoderLayer.forward
-> input_layernorm
-> QwenGatedDeltaNetAttention.forward
[patched to AscendGatedDeltaNetAttention.forward]
-> in_proj_qkvz / in_proj_ba
-> torch.ops.vllm.qwen_gdn_attention_core
-> AscendGatedDeltaNetAttention._forward_core
-> torch.ops._C_ascend.npu_causal_conv1d_custom(run_mode=0)
-> rearrange_mixed_qkv
-> DeviceOperator.fused_gdn_gating
-> chunk_gated_delta_rule
-> Triton chunk前处理
-> _C_ascend.chunk_gated_delta_rule_fwd_h
-> _C_ascend.chunk_fwd_o
-> 写回ssm_state
-> AscendRMSNormGated
-> out_proj局部GEMM
-> TP AllReduce(sum) # TP=2新增的第1次归约
-> post_attention_layernorm
-> gate_up_proj + SwiGLU # 各rank计算一半中间维
-> down_proj局部GEMM
-> TP AllReduce(sum) # TP=2新增的第2次归约

Decode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Qwen3_5DecoderLayer.forward
-> input_layernorm
-> QwenGatedDeltaNetAttention.forward
-> in_proj_qkvz / in_proj_ba
-> torch.ops.vllm.qwen_gdn_attention_core
-> AscendGatedDeltaNetAttention._forward_core
-> _C_ascend.npu_causal_conv1d_custom(run_mode=1)
-> rearrange_mixed_qkv
-> DeviceOperator.fused_gdn_gating
-> l2norm_fwd(q, k)
-> _C_ascend.npu_recurrent_gated_delta_rule
-> 原地更新ssm_state
-> AscendRMSNormGated
-> out_proj局部GEMM
-> TP AllReduce(sum) # TP=2新增的第1次归约
-> post_attention_layernorm
-> gate_up_proj + SwiGLU # 各rank计算一半中间维
-> down_proj局部GEMM
-> TP AllReduce(sum) # TP=2新增的第2次归约

算子总表

下表以BF16、非量化的A2/A3主路径为主;量化后linear会由相应QuantizeMethod选择不同GEMM,不能把它固定理解为某一个底层矩阵乘算子。

数学操作 vLLM/vLLM-Ascend函数 主要NPU算子
decoder输入Norm/残差 AscendQwen3_5DecoderLayer.forward、AscendGemmaRMSNorm _C_ascend.npu_gemma_rms_norm等,依设备分支而定
$q,k,v,z$投影 AscendMergedColumnParallelLinear、in_proj_qkvz 非量化时torch.ops.vllm.unquantized_gemm,最终由NPU linear/matmul执行
$b,a$投影 AscendMergedColumnParallelLinear、in_proj_ba 同上
因果depthwise Conv1D + SiLU AscendGatedDeltaNetAttention._forward_core _C_ascend.npu_causal_conv1d_custom
衰减门和更新门 DeviceOperator.fused_gdn_gating _C_ascend.npu_fused_gdn_gating
q/k归一化 l2norm_fwd Triton NPU L2Norm kernel
prefill GDN chunk_gated_delta_rule 多个Triton kernel + _C_ascend.chunk_gated_delta_rule_fwd_h + _C_ascend.chunk_fwd_o
decode GDN _forward_core _C_ascend.npu_recurrent_gated_delta_rule
输出Norm和$z$门控 AscendRMSNormGated layer_norm_fwd_npu Triton kernel
GDN输出投影 AscendRowParallelLinear、out_proj 局部GEMM + TP AllReduce;可选npu_mm_all_reduce_base融合
Dense MLP输入投影 AscendMergedColumnParallelLinear、gate_up_proj 各rank局部GEMM,无AllGather(基本TP路径)
Dense MLP激活 AscendSiluAndMul torch_npu.npu_swiglu,各rank本地执行
Dense MLP输出投影 AscendRowParallelLinear、down_proj 局部GEMM + TP AllReduce;可选matmul-allreduce融合

总结

Qwen3.6 Dense的一个GDN decoder层不是单个“GDN算子”,而是RMSNorm/残差 -> GDN mixer -> RMSNorm/残差 -> Dense MLP。其中GDN mixer又包含两次输入投影、因果depthwise Conv1D、门控参数计算、q/k归一化、Gated Delta Rule、RMSNormGated和输出投影。

vLLM-Ascend对同一组GDN数学公式使用两种核心执行方式:prefill用64-token chunk并行算法提高NPU利用率,decode用npu_recurrent_gated_delta_rule直接更新定长状态。AscendGDNAttentionMetadataBuilder负责生成变长序列、chunk和状态索引,ops/gdn.py负责算子编排,最终计算下沉到Triton NPU与仓库内AscendC自定义算子。

在基本TP=2路径中,GDN的head、权重、conv_state和ssm_state都按rank减半,本地GDN核心不需要跨卡通信;每个GDN decoder层真正新增的是两次求和归约,分别位于GDN out_proj和MLP down_proj之后。vLLM-Ascend可把局部GEMM与AllReduce融合,也可在sequence parallel路径中改用AllGather/ReduceScatter,但这些优化不改变“两边局部贡献最终必须合并”的数学要求。

代码与配置来源