[KDA] Support KDA packed decode (#26586)
Co-authored-by: luoyuan.luo <luoyuan.luo@antgroup.com>
This commit is contained in:
Yuan Luo
@@ -402,6 +402,265 @@ def fused_recurrent_gated_delta_rule_packed_decode(
|
||||
return out, initial_state
|
||||
|
||||
|
||||
@triton.jit
|
||||
def fused_recurrent_kda_packed_decode_kernel(
|
||||
mixed_qkv,
|
||||
a,
|
||||
b,
|
||||
A_log,
|
||||
dt_bias,
|
||||
o,
|
||||
h0,
|
||||
ht,
|
||||
ssm_state_indices,
|
||||
scale,
|
||||
stride_mixed_qkv_tok: tl.constexpr,
|
||||
stride_a_tok: tl.constexpr,
|
||||
stride_b_tok: tl.constexpr,
|
||||
stride_init_state_token: tl.constexpr,
|
||||
stride_final_state_token: tl.constexpr,
|
||||
stride_indices_seq: tl.constexpr,
|
||||
H: tl.constexpr,
|
||||
HV: tl.constexpr,
|
||||
K: tl.constexpr,
|
||||
V: tl.constexpr,
|
||||
BK: tl.constexpr,
|
||||
BV: tl.constexpr,
|
||||
SOFTPLUS_THRESHOLD: tl.constexpr,
|
||||
USE_QK_L2NORM_IN_KERNEL: tl.constexpr,
|
||||
):
|
||||
"""KDA packed decode: same shape as the GDN packed decode kernel, but
|
||||
with a per-K gate (``a`` is ``[B, HV*K]`` and ``dt_bias`` is ``[HV*K]``),
|
||||
so the state decay is a per-K vector ``exp(g)`` rather than a scalar."""
|
||||
i_v, i_nh = tl.program_id(0), tl.program_id(1)
|
||||
i_n, i_hv = i_nh // HV, i_nh % HV
|
||||
i_h = i_hv // (HV // H)
|
||||
|
||||
o_k = tl.arange(0, BK)
|
||||
o_v = i_v * BV + tl.arange(0, BV)
|
||||
mask_k = o_k < K
|
||||
mask_v = o_v < V
|
||||
mask_h = mask_v[:, None] & mask_k[None, :]
|
||||
|
||||
state_idx = tl.load(ssm_state_indices + i_n * stride_indices_seq).to(tl.int64)
|
||||
p_o = o + (i_n * HV + i_hv) * V + o_v
|
||||
|
||||
if state_idx < 0:
|
||||
zero = tl.zeros([BV], dtype=tl.float32).to(p_o.dtype.element_ty)
|
||||
tl.store(p_o, zero, mask=mask_v)
|
||||
return
|
||||
|
||||
p_h0 = h0 + state_idx * stride_init_state_token
|
||||
p_h0 = p_h0 + i_hv * V * K + o_v[:, None] * K + o_k[None, :]
|
||||
b_h = tl.load(p_h0, mask=mask_h, other=0).to(tl.float32)
|
||||
|
||||
p_mixed = mixed_qkv + i_n * stride_mixed_qkv_tok
|
||||
q_off = i_h * K + o_k
|
||||
k_off = (H * K) + i_h * K + o_k
|
||||
v_off = (2 * H * K) + i_hv * V + o_v
|
||||
b_q = tl.load(p_mixed + q_off, mask=mask_k, other=0).to(tl.float32)
|
||||
b_k = tl.load(p_mixed + k_off, mask=mask_k, other=0).to(tl.float32)
|
||||
b_v = tl.load(p_mixed + v_off, mask=mask_v, other=0).to(tl.float32)
|
||||
|
||||
if USE_QK_L2NORM_IN_KERNEL:
|
||||
b_q = b_q / tl.sqrt(tl.sum(b_q * b_q) + 1e-6)
|
||||
b_k = b_k / tl.sqrt(tl.sum(b_k * b_k) + 1e-6)
|
||||
b_q = b_q * scale
|
||||
|
||||
# KDA per-K gate: load BK values of ``a`` and ``dt_bias`` for this head.
|
||||
p_a = a + i_n * stride_a_tok + i_hv * K + o_k
|
||||
p_dt = dt_bias + i_hv * K + o_k
|
||||
b_a = tl.load(p_a, mask=mask_k, other=0).to(tl.float32)
|
||||
b_dt = tl.load(p_dt, mask=mask_k, other=0).to(tl.float32)
|
||||
A_log_val = tl.load(A_log + i_hv).to(tl.float32)
|
||||
|
||||
x = b_a + b_dt
|
||||
softplus_x = tl.where(x <= SOFTPLUS_THRESHOLD, tl.log(1.0 + tl.exp(x)), x)
|
||||
b_g = -tl.exp(A_log_val) * softplus_x # [BK]
|
||||
|
||||
b_val = tl.load(b + i_n * stride_b_tok + i_hv).to(tl.float32)
|
||||
# Keep beta in fp32 (no bf16 round-trip) to match the generic decode
|
||||
# kernel `fused_sigmoid_gating_delta_rule_update`, which is the reference
|
||||
# validated against torch.
|
||||
beta_val = tl.sigmoid(b_val).to(tl.float32)
|
||||
|
||||
# Per-K decay: each K-row of the [V, K] state decays by its own exp(g_k).
|
||||
b_h *= exp(b_g)[None, :]
|
||||
b_v -= tl.sum(b_h * b_k[None, :], 1)
|
||||
b_v *= beta_val
|
||||
b_h += b_v[:, None] * b_k[None, :]
|
||||
b_o = tl.sum(b_h * b_q[None, :], 1)
|
||||
tl.store(p_o, b_o.to(p_o.dtype.element_ty), mask=mask_v)
|
||||
|
||||
p_ht = ht + state_idx * stride_final_state_token
|
||||
p_ht = p_ht + i_hv * V * K + o_v[:, None] * K + o_k[None, :]
|
||||
tl.store(p_ht, b_h.to(p_ht.dtype.element_ty), mask=mask_h)
|
||||
|
||||
|
||||
def fused_recurrent_kda_packed_decode(
|
||||
mixed_qkv: torch.Tensor,
|
||||
a: torch.Tensor,
|
||||
b: torch.Tensor,
|
||||
A_log: torch.Tensor,
|
||||
dt_bias: torch.Tensor,
|
||||
scale: float,
|
||||
initial_state: torch.Tensor,
|
||||
out: torch.Tensor,
|
||||
ssm_state_indices: torch.Tensor,
|
||||
use_qk_l2norm_in_kernel: bool = False,
|
||||
) -> tuple[torch.Tensor, torch.Tensor]:
|
||||
"""KDA T=1 decode fast path. Mirrors ``fused_recurrent_gated_delta_rule_packed_decode``
|
||||
but the gate ``g`` is a per-K vector instead of a scalar.
|
||||
|
||||
Args:
|
||||
mixed_qkv: ``[B, 2*H*K + HV*V]`` packed projection output after conv1d.
|
||||
Requires ``num_q_heads == num_k_heads == H`` and ``head_q_dim == head_k_dim == K``.
|
||||
a: ``[B, HV*K]`` per-K gate input (typically reshaped from ``[B, HV, K]``).
|
||||
b: ``[B, HV]`` beta input (post-sigmoid scalar per head).
|
||||
A_log: ``[HV]`` log-space decay parameter.
|
||||
dt_bias: ``[HV*K]`` per-K time-step bias.
|
||||
scale: attention scale factor (typically ``head_k_dim ** -0.5``).
|
||||
initial_state: ``[num_slots, HV, V, K]`` full state pool, updated in place.
|
||||
out: ``[B, 1, HV, V]`` contiguous output buffer.
|
||||
ssm_state_indices: ``[B]`` per-request state slot indices (-1 = skip).
|
||||
use_qk_l2norm_in_kernel: apply per-head L2 norm to Q/K inside the kernel.
|
||||
"""
|
||||
if mixed_qkv.ndim != 2:
|
||||
raise ValueError(
|
||||
f"`mixed_qkv` must be a 2D tensor (got ndim={mixed_qkv.ndim})."
|
||||
)
|
||||
if mixed_qkv.stride(-1) != 1:
|
||||
raise ValueError("`mixed_qkv` must be contiguous in the last dim.")
|
||||
if a.ndim != 2 or b.ndim != 2:
|
||||
raise ValueError(
|
||||
f"`a` and `b` must be 2D tensors (got a.ndim={a.ndim}, b.ndim={b.ndim})."
|
||||
)
|
||||
if a.stride(-1) != 1 or b.stride(-1) != 1:
|
||||
raise ValueError("`a`/`b` must be contiguous in the last dim.")
|
||||
if A_log.ndim != 1 or dt_bias.ndim != 1:
|
||||
raise ValueError("`A_log`/`dt_bias` must be 1D tensors.")
|
||||
if A_log.stride(0) != 1 or dt_bias.stride(0) != 1:
|
||||
raise ValueError("`A_log`/`dt_bias` must be contiguous.")
|
||||
if ssm_state_indices.ndim != 1:
|
||||
raise ValueError(
|
||||
f"`ssm_state_indices` must be 1D for packed decode (got ndim={ssm_state_indices.ndim})."
|
||||
)
|
||||
if not out.is_contiguous():
|
||||
raise ValueError("`out` must be contiguous.")
|
||||
|
||||
dev = mixed_qkv.device
|
||||
if any(
|
||||
t.device != dev
|
||||
for t in (a, b, A_log, dt_bias, initial_state, out, ssm_state_indices)
|
||||
):
|
||||
raise ValueError("All inputs must be on the same device.")
|
||||
|
||||
B = mixed_qkv.shape[0]
|
||||
if a.shape[0] != B or b.shape[0] != B:
|
||||
raise ValueError(
|
||||
"Mismatched batch sizes: "
|
||||
f"mixed_qkv.shape[0]={B}, a.shape[0]={a.shape[0]}, b.shape[0]={b.shape[0]}."
|
||||
)
|
||||
if ssm_state_indices.shape[0] != B:
|
||||
raise ValueError(
|
||||
f"`ssm_state_indices` must have shape [B] (got {tuple(ssm_state_indices.shape)}; expected ({B},))."
|
||||
)
|
||||
|
||||
if initial_state.ndim != 4:
|
||||
raise ValueError(
|
||||
f"`initial_state` must be a 4D tensor (got ndim={initial_state.ndim})."
|
||||
)
|
||||
if initial_state.stride(-1) != 1:
|
||||
raise ValueError("`initial_state` must be contiguous in the last dim.")
|
||||
HV, V, K = initial_state.shape[-3:]
|
||||
if a.shape[1] != HV * K:
|
||||
raise ValueError(
|
||||
f"`a` must have shape [B, HV*K] with HV={HV}, K={K} "
|
||||
f"(got a.shape={tuple(a.shape)})."
|
||||
)
|
||||
if b.shape[1] != HV:
|
||||
raise ValueError(
|
||||
f"`b` must have shape [B, HV] with HV={HV} (got b.shape={tuple(b.shape)})."
|
||||
)
|
||||
if A_log.numel() != HV:
|
||||
raise ValueError(f"`A_log` must have {HV} elements (got {A_log.numel()}).")
|
||||
if dt_bias.numel() != HV * K:
|
||||
raise ValueError(
|
||||
f"`dt_bias` must have {HV * K} elements (got {dt_bias.numel()})."
|
||||
)
|
||||
if out.shape != (B, 1, HV, V):
|
||||
raise ValueError(
|
||||
f"`out` must have shape {(B, 1, HV, V)} (got out.shape={tuple(out.shape)})."
|
||||
)
|
||||
|
||||
qkv_dim = mixed_qkv.shape[1]
|
||||
qk_dim = qkv_dim - HV * V
|
||||
if qk_dim <= 0 or qk_dim % 2 != 0:
|
||||
raise ValueError(
|
||||
f"Invalid packed `mixed_qkv` last dim={qkv_dim} for HV={HV}, V={V}."
|
||||
)
|
||||
q_dim = qk_dim // 2
|
||||
if q_dim % K != 0:
|
||||
raise ValueError(
|
||||
f"Invalid packed Q size {q_dim}: must be divisible by K={K}. "
|
||||
"KDA packed decode requires num_q_heads == num_k_heads and "
|
||||
"head_q_dim == head_k_dim."
|
||||
)
|
||||
H = q_dim // K
|
||||
if H <= 0 or HV % H != 0:
|
||||
raise ValueError(
|
||||
f"Invalid head config inferred from mixed_qkv: H={H}, HV={HV}."
|
||||
)
|
||||
|
||||
BK = triton.next_power_of_2(K)
|
||||
if triton.cdiv(K, BK) != 1:
|
||||
raise ValueError(
|
||||
f"Packed decode kernel only supports NK=1 (got K={K}, BK={BK})."
|
||||
)
|
||||
BV = min(triton.next_power_of_2(V), 32)
|
||||
num_stages = 3
|
||||
num_warps = 1
|
||||
|
||||
stride_mixed_qkv_tok = mixed_qkv.stride(0)
|
||||
stride_a_tok = a.stride(0)
|
||||
stride_b_tok = b.stride(0)
|
||||
stride_init_state_token = initial_state.stride(0)
|
||||
stride_final_state_token = initial_state.stride(0)
|
||||
stride_indices_seq = ssm_state_indices.stride(0)
|
||||
|
||||
NV = triton.cdiv(V, BV)
|
||||
grid = (NV, B * HV)
|
||||
fused_recurrent_kda_packed_decode_kernel[grid](
|
||||
mixed_qkv=mixed_qkv,
|
||||
a=a,
|
||||
b=b,
|
||||
A_log=A_log,
|
||||
dt_bias=dt_bias,
|
||||
o=out,
|
||||
h0=initial_state,
|
||||
ht=initial_state,
|
||||
ssm_state_indices=ssm_state_indices,
|
||||
scale=scale,
|
||||
stride_mixed_qkv_tok=stride_mixed_qkv_tok,
|
||||
stride_a_tok=stride_a_tok,
|
||||
stride_b_tok=stride_b_tok,
|
||||
stride_init_state_token=stride_init_state_token,
|
||||
stride_final_state_token=stride_final_state_token,
|
||||
stride_indices_seq=stride_indices_seq,
|
||||
H=H,
|
||||
HV=HV,
|
||||
K=K,
|
||||
V=V,
|
||||
BK=BK,
|
||||
BV=BV,
|
||||
SOFTPLUS_THRESHOLD=20.0,
|
||||
USE_QK_L2NORM_IN_KERNEL=use_qk_l2norm_in_kernel,
|
||||
num_warps=num_warps,
|
||||
num_stages=num_stages,
|
||||
)
|
||||
return out, initial_state
|
||||
|
||||
|
||||
class FusedRecurrentFunction(torch.autograd.Function):
|
||||
|
||||
@staticmethod
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
from typing import Tuple, Union
|
||||
from typing import Optional, Tuple, Union
|
||||
|
||||
import torch
|
||||
|
||||
@@ -66,9 +66,47 @@ class KDAKernelDispatcher:
|
||||
"KDA currently only supports 'triton'."
|
||||
)
|
||||
|
||||
self.supports_packed_decode = getattr(
|
||||
self.decode_kernel, "supports_packed_decode", False
|
||||
)
|
||||
|
||||
rank0_log(
|
||||
f"KDA kernel dispatcher: decode={self.decode_kernel.__class__.__name__}, "
|
||||
f"extend={self.extend_kernel.__class__.__name__}"
|
||||
f"extend={self.extend_kernel.__class__.__name__} "
|
||||
f"packed_decode={self.supports_packed_decode}"
|
||||
)
|
||||
|
||||
def packed_decode(
|
||||
self,
|
||||
mixed_qkv: torch.Tensor,
|
||||
a: torch.Tensor,
|
||||
b: torch.Tensor,
|
||||
*,
|
||||
A_log: torch.Tensor,
|
||||
dt_bias: torch.Tensor,
|
||||
scale: float,
|
||||
ssm_states: torch.Tensor,
|
||||
cache_indices: torch.Tensor,
|
||||
num_v_heads: int,
|
||||
head_v_dim: int,
|
||||
**kwargs,
|
||||
) -> Optional[torch.Tensor]:
|
||||
"""Attempt packed decode. Returns output tensor or None if the decode
|
||||
kernel does not support packed decode."""
|
||||
if not self.supports_packed_decode:
|
||||
return None
|
||||
return self.decode_kernel.packed_decode(
|
||||
mixed_qkv,
|
||||
a,
|
||||
b,
|
||||
A_log=A_log,
|
||||
dt_bias=dt_bias,
|
||||
scale=scale,
|
||||
ssm_states=ssm_states,
|
||||
cache_indices=cache_indices,
|
||||
num_v_heads=num_v_heads,
|
||||
head_v_dim=head_v_dim,
|
||||
**kwargs,
|
||||
)
|
||||
|
||||
def decode(
|
||||
@@ -157,6 +195,35 @@ class KDAAttnBackend(MambaAttnBackendBase):
|
||||
activation="silu",
|
||||
conv_state_indices=cache_indices,
|
||||
)
|
||||
|
||||
# Skip split + reshape by consuming the packed mixed_qkv directly in a
|
||||
# single fused Triton kernel (KDA per-K gate variant of GDN PR #20627).
|
||||
#
|
||||
# The packed kernel hard-assumes one token per sequence (T=1): it has no
|
||||
# query_start_loc / per-sequence loop. forward_decode is only entered in
|
||||
# decode mode (see HybridLinearAttnBackend.forward dispatch), where each
|
||||
# request contributes exactly one token, so #tokens == #requests. Multi-
|
||||
# token-per-seq speculative paths (target_verify / draft_extend) go
|
||||
# through forward_extend instead. Assert the invariant so a future
|
||||
# routing change fails loudly rather than silently corrupting state.
|
||||
if self.kernel_dispatcher.supports_packed_decode:
|
||||
assert qkv.shape[0] == cache_indices.shape[0], (
|
||||
"KDA packed decode requires one token per sequence (T=1): "
|
||||
f"got {qkv.shape[0]} tokens for {cache_indices.shape[0]} requests."
|
||||
)
|
||||
return self.kernel_dispatcher.packed_decode(
|
||||
mixed_qkv=qkv,
|
||||
a=a,
|
||||
b=b,
|
||||
A_log=layer.A_log,
|
||||
dt_bias=layer.dt_bias,
|
||||
scale=layer.head_k_dim**-0.5,
|
||||
ssm_states=ssm_states,
|
||||
cache_indices=cache_indices,
|
||||
num_v_heads=layer.num_v_heads,
|
||||
head_v_dim=layer.head_v_dim,
|
||||
)
|
||||
|
||||
q, k, v = qkv.split([layer.q_dim, layer.k_dim, layer.v_dim], dim=-1)
|
||||
q = q.unflatten(-1, (-1, layer.head_q_dim)).unsqueeze(0) # n (h d) -> 1 n h d
|
||||
k = k.unflatten(-1, (-1, layer.head_k_dim)).unsqueeze(0) # n (h d) -> 1 n h d
|
||||
|
||||
@@ -5,9 +5,12 @@ import torch
|
||||
from sglang.srt.layers.attention.linear.kernels.kernel_backend import (
|
||||
LinearAttnKernelBase,
|
||||
)
|
||||
from sglang.srt.utils import is_cpu
|
||||
from sglang.srt.utils import is_cpu, is_npu
|
||||
|
||||
if not is_cpu():
|
||||
from sglang.srt.layers.attention.fla.fused_recurrent import (
|
||||
fused_recurrent_kda_packed_decode,
|
||||
)
|
||||
from sglang.srt.layers.attention.fla.fused_sigmoid_gating_recurrent import (
|
||||
fused_sigmoid_gating_delta_rule_update,
|
||||
)
|
||||
@@ -17,6 +20,53 @@ if not is_cpu():
|
||||
class TritonKDAKernel(LinearAttnKernelBase):
|
||||
"""Triton-based kernel for KDA (Kimi Delta Attention) linear attention."""
|
||||
|
||||
supports_packed_decode: bool = not is_cpu() and not is_npu()
|
||||
|
||||
def packed_decode(
|
||||
self,
|
||||
mixed_qkv: torch.Tensor,
|
||||
a: torch.Tensor,
|
||||
b: torch.Tensor,
|
||||
*,
|
||||
A_log: torch.Tensor,
|
||||
dt_bias: torch.Tensor,
|
||||
scale: float,
|
||||
ssm_states: torch.Tensor,
|
||||
cache_indices: torch.Tensor,
|
||||
num_v_heads: int,
|
||||
head_v_dim: int,
|
||||
**kwargs,
|
||||
) -> torch.Tensor:
|
||||
"""Packed decode fast path: feed the conv-1d output ``mixed_qkv``
|
||||
straight into a single fused Triton kernel that does Q/K/V extraction,
|
||||
gate/beta computation, l2-norm, and the recurrent state update.
|
||||
|
||||
Returns output tensor of shape [1, B, HV, V] to match the existing
|
||||
decode kernel output layout.
|
||||
"""
|
||||
B = mixed_qkv.shape[0]
|
||||
# a may come in as [B, HV, K] (or [B, 1, HV*K]); b may come in as
|
||||
# [B, 1, HV]. Flatten both to the 2D shapes the kernel expects.
|
||||
if a.dim() != 2:
|
||||
a = a.reshape(B, -1)
|
||||
if b.dim() != 2:
|
||||
b = b.reshape(B, -1)
|
||||
out = mixed_qkv.new_empty(B, 1, num_v_heads, head_v_dim)
|
||||
fused_recurrent_kda_packed_decode(
|
||||
mixed_qkv=mixed_qkv,
|
||||
a=a,
|
||||
b=b,
|
||||
A_log=A_log.reshape(-1),
|
||||
dt_bias=dt_bias.reshape(-1),
|
||||
scale=scale,
|
||||
initial_state=ssm_states,
|
||||
out=out,
|
||||
ssm_state_indices=cache_indices,
|
||||
use_qk_l2norm_in_kernel=True,
|
||||
)
|
||||
# [B, 1, HV, V] -> [1, B, HV, V] view to match existing decode layout.
|
||||
return out.transpose(0, 1)
|
||||
|
||||
def decode(
|
||||
self,
|
||||
q: torch.Tensor,
|
||||
|
||||
Reference in New Issue
Block a user