diff --git a/benchmark/bench_linear_attention/bench_kda_decode.py b/benchmark/bench_linear_attention/bench_kda_decode.py new file mode 100644 index 000000000..e1bd86f35 --- /dev/null +++ b/benchmark/bench_linear_attention/bench_kda_decode.py @@ -0,0 +1,395 @@ +""" +Benchmark & Correctness: KDA Packed Decode vs Baseline Decode. + +Compares: + - Baseline: split(mixed_qkv) -> view -> fused_sigmoid_gating_delta_rule_update(is_kda=True) + - Packed: fused_recurrent_kda_packed_decode (single fused kernel) + +Differences from the GDN packed decode benchmark: + - KDA gate ``a`` is per-K with shape ``[B, HV * K]`` (instead of ``[B, HV]``). + - KDA ``dt_bias`` is per-K with shape ``[HV * K]`` (instead of ``[HV]``). + - State decay in the kernel is a per-K vector ``exp(g)`` (instead of a scalar). + +Reports correctness (output & state matching) and performance (us, speedup). + +Usage: + python bench_kda_decode.py # default sweep + python bench_kda_decode.py --mode bench # benchmark only + python bench_kda_decode.py --mode correctness # correctness only +""" + +import argparse + +import torch + +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, +) + + +def make_inputs( + B: int, + H: int, + HV: int, + K: int, + V: int, + pool_size: int, + device: str, + dtype: torch.dtype, + seed: int = 42, +): + """Create all input tensors for a single benchmark / correctness run.""" + torch.manual_seed(seed) + + qkv_dim = 2 * H * K + HV * V + mixed_qkv = torch.randn(B, qkv_dim, device=device, dtype=dtype) * 0.1 + # KDA per-K gate: a is [B, HV*K], dt_bias is [HV*K]. + a = torch.randn(B, HV * K, device=device, dtype=dtype) * 0.5 - 1.0 + b = torch.randn(B, HV, device=device, dtype=dtype) * 0.5 + A_log = torch.randn(HV, device=device, dtype=torch.float32) * 0.2 + dt_bias = torch.randn(HV * K, device=device, dtype=torch.float32) * 0.1 + + ssm_states = torch.randn(pool_size, HV, V, K, device=device, dtype=dtype) * 0.01 + cache_indices = torch.arange(B, device=device, dtype=torch.int32) + + cu_seqlens = torch.arange(B + 1, device=device, dtype=torch.long) + + return dict( + B=B, + H=H, + HV=HV, + K=K, + V=V, + qkv_dim=qkv_dim, + pool_size=pool_size, + mixed_qkv=mixed_qkv.contiguous(), + a=a.contiguous(), + b=b.contiguous(), + A_log=A_log, + dt_bias=dt_bias, + ssm_states=ssm_states.contiguous(), + cache_indices=cache_indices, + cu_seqlens=cu_seqlens, + ) + + +def run_baseline(inp): + """Baseline path: split -> view -> fused_sigmoid_gating_delta_rule_update. + + Mirrors the existing decode path in ``KDAAttnBackend.forward_decode`` + (post conv1d, pre-packed-optimization). + """ + B, H, HV, K, V = inp["B"], inp["H"], inp["HV"], inp["K"], inp["V"] + mixed_qkv = inp["mixed_qkv"] + ssm_states = inp["ssm_states"].clone() + + q_flat, k_flat, v_flat = torch.split(mixed_qkv, [H * K, H * K, HV * V], dim=-1) + q = q_flat.view(1, B, H, K) + k = k_flat.view(1, B, H, K) + v = v_flat.view(1, B, HV, V) + + o = fused_sigmoid_gating_delta_rule_update( + A_log=inp["A_log"], + dt_bias=inp["dt_bias"], + q=q, + k=k, + v=v, + a=inp["a"], + b=inp["b"], + initial_state_source=ssm_states, + initial_state_indices=inp["cache_indices"], + cu_seqlens=inp["cu_seqlens"], + use_qk_l2norm_in_kernel=True, + softplus_beta=1.0, + softplus_threshold=20.0, + is_kda=True, + ) + return o, ssm_states + + +def run_packed(inp): + """Packed path: single fused kernel directly on mixed_qkv.""" + B, HV, K, V = inp["B"], inp["HV"], inp["K"], inp["V"] + ssm_states = inp["ssm_states"].clone() + out = inp["mixed_qkv"].new_empty(B, 1, HV, V) + + fused_recurrent_kda_packed_decode( + mixed_qkv=inp["mixed_qkv"], + a=inp["a"], + b=inp["b"], + A_log=inp["A_log"], + dt_bias=inp["dt_bias"], + scale=inp["K"] ** -0.5, + initial_state=ssm_states, + out=out, + ssm_state_indices=inp["cache_indices"], + use_qk_l2norm_in_kernel=True, + ) + return out.transpose(0, 1), ssm_states + + +def check_correctness(B, H, HV, K, V, pool_size, device, dtype, seed=42): + """Run correctness check for a single config. Returns True if PASS.""" + tag = f"B={B:>4} H={H:>2} HV={HV:>2} K={K:>3} V={V:>3} pool={pool_size:>4}" + + inp = make_inputs(B, H, HV, K, V, pool_size, device, dtype, seed=seed) + + o_baseline, state_baseline = run_baseline(inp) + o_packed, state_packed = run_packed(inp) + + atol = 2e-2 if dtype != torch.float32 else 1e-4 + rtol = 1e-2 if dtype != torch.float32 else 1e-4 + + out_diff = (o_packed.float() - o_baseline.float()).abs().max().item() + output_ok = out_diff <= max(atol, rtol * o_baseline.float().abs().max().item()) + + indices = inp["cache_indices"] + st_diff = ( + (state_packed[indices].float() - state_baseline[indices].float()) + .abs() + .max() + .item() + ) + state_ok = st_diff <= max( + atol, rtol * state_baseline[indices].float().abs().max().item() + ) + + passed = output_ok and state_ok + if passed: + print( + f" [PASS] {tag} (out max_diff={out_diff:.2e}, state max_diff={st_diff:.2e})" + ) + else: + print( + f" [FAIL] {tag} out max_diff={out_diff:.6f}, state max_diff={st_diff:.6f}" + ) + return passed + + +def bench_shape(B, H, HV, K, V, pool_size, device, dtype): + """Benchmark baseline vs packed for a single config.""" + inp = make_inputs(B, H, HV, K, V, pool_size, device, dtype) + + def fn_baseline(): + q_flat, k_flat, v_flat = torch.split( + inp["mixed_qkv"], [H * K, H * K, HV * V], dim=-1 + ) + q = q_flat.view(1, B, H, K) + k = k_flat.view(1, B, H, K) + v = v_flat.view(1, B, HV, V) + fused_sigmoid_gating_delta_rule_update( + A_log=inp["A_log"], + dt_bias=inp["dt_bias"], + q=q, + k=k, + v=v, + a=inp["a"], + b=inp["b"], + initial_state_source=inp["ssm_states"], + initial_state_indices=inp["cache_indices"], + cu_seqlens=inp["cu_seqlens"], + use_qk_l2norm_in_kernel=True, + softplus_beta=1.0, + softplus_threshold=20.0, + is_kda=True, + ) + + out_buf = inp["mixed_qkv"].new_empty(B, 1, HV, V) + + def fn_packed(): + fused_recurrent_kda_packed_decode( + mixed_qkv=inp["mixed_qkv"], + a=inp["a"], + b=inp["b"], + A_log=inp["A_log"], + dt_bias=inp["dt_bias"], + scale=K**-0.5, + initial_state=inp["ssm_states"], + out=out_buf, + ssm_state_indices=inp["cache_indices"], + use_qk_l2norm_in_kernel=True, + ) + + # Intentionally wall-clock CUDA-event timing, not the shared do_bench / + # do_bench_cudagraph util: ~2/3 of the packed win is eager CPU dispatch + # (split + 3x unflatten + extra launch), which graph capture / L2-flush + # harnesses amortize away. Decode runs these ops eagerly every step, so + # wall-clock is the production-relevant metric (~1.7x vs ~1.3x kernel-only). + warmup, iters = 50, 200 + for _ in range(warmup): + fn_baseline() + fn_packed() + torch.cuda.synchronize() + + def _time(fn): + start = torch.cuda.Event(enable_timing=True) + end = torch.cuda.Event(enable_timing=True) + start.record() + for _ in range(iters): + fn() + end.record() + torch.cuda.synchronize() + return start.elapsed_time(end) / iters # ms + + ms_baseline = _time(fn_baseline) + ms_packed = _time(fn_packed) + + speedup = ms_baseline / ms_packed if ms_packed > 0 else float("inf") + saved_us = (ms_baseline - ms_packed) * 1000 + + print( + f" {B:>5} {H:>3} {HV:>3} {K:>3} {V:>3} | " + f"{ms_baseline * 1000:>10.1f} | " + f"{ms_packed * 1000:>10.1f} | " + f"{speedup:>7.2f}x | " + f"{saved_us:>+9.1f}" + ) + + +def run_correctness(device, dtype): + print("=" * 80) + print("Correctness: Baseline KDA Decode vs Packed KDA Decode") + print("=" * 80) + + shapes = [ + # (B, H, HV, K, V, pool_size) + (1, 16, 16, 128, 128, 32), + (4, 16, 16, 128, 128, 32), + (16, 16, 16, 128, 128, 64), + (32, 16, 16, 128, 128, 128), + (64, 16, 16, 128, 128, 128), + (128, 16, 16, 128, 128, 256), + (256, 16, 16, 128, 128, 512), + # Asymmetric H vs HV + (1, 32, 32, 128, 128, 32), + (32, 32, 32, 128, 128, 128), + (64, 32, 32, 128, 128, 128), + # Edge case + (1, 16, 16, 128, 128, 32), + (2, 16, 16, 128, 128, 32), + ] + + all_pass = True + for B, H, HV, K, V, pool_size in shapes: + if not check_correctness(B, H, HV, K, V, pool_size, device, dtype): + all_pass = False + + # PAD_SLOT_ID test: some indices < 0 should output zeros and skip state update. + print("\n PAD_SLOT_ID test (indices with -1):") + inp = make_inputs(32, 16, 16, 128, 128, 128, device, dtype) + pad_mask = torch.zeros(32, device=device, dtype=torch.bool) + pad_mask[::4] = True + inp["cache_indices"] = torch.where( + pad_mask, + torch.tensor(-1, device=device, dtype=torch.int32), + inp["cache_indices"], + ) + o_baseline, _ = run_baseline(inp) + o_packed, _ = run_packed(inp) + try: + torch.testing.assert_close(o_packed, o_baseline, atol=2e-2, rtol=1e-2) + print(" [PASS] PAD_SLOT_ID=-1 handling") + except AssertionError as e: + print(f" [FAIL] PAD_SLOT_ID=-1 handling: {e}") + all_pass = False + + print() + print("ALL PASSED." if all_pass else "SOME FAILED.") + return all_pass + + +def run_benchmark(device, dtype, args): + print() + print("=" * 85) + print("Benchmark: Baseline KDA Decode vs Packed KDA Decode") + print("=" * 85) + + K = args.head_size_k + V = args.head_size_v + pool_size = args.pool_size + + bench_configs = [] + for B in args.batch_sizes: + for H in args.num_q_heads: + for HV in args.num_v_heads: + bench_configs.append((B, H, HV)) + + print(f" Config: K={K}, V={V}, pool_size={pool_size}, dtype={dtype}") + print( + f" {'B':>5} {'H':>3} {'HV':>3} {'K':>3} {'V':>3} | " + f"{'base (us)':>10} | " + f"{'packed (us)':>10} | " + f"{'speedup':>8} | " + f"{'saved (us)':>10}" + ) + print(" " + "-" * 80) + + for B, H, HV in bench_configs: + # Packed kernel requires HV % H == 0 (GVA / grouped query layout). + if HV % H != 0: + continue + actual_pool = max(pool_size, B + 16) + bench_shape(B, H, HV, K, V, actual_pool, device, dtype) + + +def main(): + parser = argparse.ArgumentParser( + description="Benchmark & Correctness: KDA Packed Decode vs Baseline" + ) + parser.add_argument( + "--mode", + choices=["all", "correctness", "bench"], + default="all", + ) + parser.add_argument( + "--dtype", + choices=["float16", "bfloat16", "float32"], + default="bfloat16", + ) + parser.add_argument("--head-size-k", type=int, default=128) + parser.add_argument("--head-size-v", type=int, default=128) + parser.add_argument("--pool-size", type=int, default=512) + parser.add_argument( + "--batch-sizes", + type=int, + nargs="+", + default=[1, 4, 8, 16, 32, 64, 128, 256], + ) + parser.add_argument( + "--num-q-heads", + type=int, + nargs="+", + default=[16, 32], + ) + parser.add_argument( + "--num-v-heads", + type=int, + nargs="+", + default=[16, 32], + ) + args = parser.parse_args() + + device = "cuda" + dtype = getattr(torch, args.dtype) + + cap = torch.cuda.get_device_capability() + dev_name = torch.cuda.get_device_name() + print(f"Device: {dev_name} (SM {cap[0]}{cap[1]})") + + if args.mode in ("all", "correctness"): + all_pass = run_correctness(device, dtype) + if not all_pass and args.mode == "all": + print("\nSkipping benchmark due to correctness failures.") + return 1 + + if args.mode in ("all", "bench"): + run_benchmark(device, dtype, args) + + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/python/sglang/srt/layers/attention/fla/fused_recurrent.py b/python/sglang/srt/layers/attention/fla/fused_recurrent.py index f110770c0..67c58592f 100644 --- a/python/sglang/srt/layers/attention/fla/fused_recurrent.py +++ b/python/sglang/srt/layers/attention/fla/fused_recurrent.py @@ -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 diff --git a/python/sglang/srt/layers/attention/linear/kda_backend.py b/python/sglang/srt/layers/attention/linear/kda_backend.py index bb77eaafe..d4e63cac8 100644 --- a/python/sglang/srt/layers/attention/linear/kda_backend.py +++ b/python/sglang/srt/layers/attention/linear/kda_backend.py @@ -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 diff --git a/python/sglang/srt/layers/attention/linear/kernels/kda_triton.py b/python/sglang/srt/layers/attention/linear/kernels/kda_triton.py index 2d6d54d9e..c5c797791 100644 --- a/python/sglang/srt/layers/attention/linear/kernels/kda_triton.py +++ b/python/sglang/srt/layers/attention/linear/kernels/kda_triton.py @@ -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, diff --git a/test/registered/attention/test_kda_kernels.py b/test/registered/attention/test_kda_kernels.py index 96cb1e9e8..b88c03b68 100644 --- a/test/registered/attention/test_kda_kernels.py +++ b/test/registered/attention/test_kda_kernels.py @@ -3,6 +3,9 @@ import unittest import torch from sglang.srt.layers.attention.fla.cumsum import chunk_local_cumsum +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, ) @@ -241,5 +244,209 @@ class TestKDAGateChunkCumsum(unittest.TestCase): ) +@unittest.skipIf(not torch.cuda.is_available(), "Test requires CUDA") +class TestKDAPackedDecode(unittest.TestCase): + """Verify ``fused_recurrent_kda_packed_decode`` matches the existing decode + path (split + unflatten + ``fused_sigmoid_gating_delta_rule_update``).""" + + @staticmethod + def _make_inputs(B, H, HV, K, V, pool_size, dtype, device, seed=42): + torch.manual_seed(seed) + qkv_dim = 2 * H * K + HV * V + mixed_qkv = ( + torch.randn(B, qkv_dim, dtype=dtype, device=device) * 0.1 + ).contiguous() + a = ( + torch.randn(B, HV * K, dtype=dtype, device=device) * 0.5 - 1.0 + ).contiguous() + b = (torch.randn(B, HV, dtype=dtype, device=device) * 0.5).contiguous() + A_log = torch.randn(HV, dtype=torch.float32, device=device) * 0.2 + dt_bias = torch.randn(HV * K, dtype=torch.float32, device=device) * 0.1 + ssm_states = ( + torch.randn(pool_size, HV, V, K, dtype=dtype, device=device) * 0.01 + ).contiguous() + cache_indices = torch.arange(B, device=device, dtype=torch.int32) + return mixed_qkv, a, b, A_log, dt_bias, ssm_states, cache_indices + + @staticmethod + def _run_baseline( + mixed_qkv, a, b, A_log, dt_bias, ssm_states, cache_indices, H, HV, K, V + ): + B = mixed_qkv.shape[0] + q_flat, k_flat, v_flat = torch.split(mixed_qkv, [H * K, H * K, HV * V], dim=-1) + q = q_flat.view(1, B, H, K) + k = k_flat.view(1, B, H, K) + v = v_flat.view(1, B, HV, V) + # The real backend passes query_start_loc = [0, 1, ..., B] so that + # each of the B tokens becomes its own length-1 sequence with an + # independent state; without this the kernel would share state. + cu_seqlens = torch.arange(B + 1, device=mixed_qkv.device, dtype=torch.int32) + return fused_sigmoid_gating_delta_rule_update( + A_log=A_log, + dt_bias=dt_bias, + softplus_beta=1.0, + softplus_threshold=20.0, + q=q, + k=k, + v=v, + a=a, + b=b, + initial_state_source=ssm_states, + initial_state_indices=cache_indices, + cu_seqlens=cu_seqlens, + scale=K**-0.5, + use_qk_l2norm_in_kernel=True, + is_kda=True, + ) + + @staticmethod + def _run_packed( + mixed_qkv, a, b, A_log, dt_bias, ssm_states, cache_indices, HV, K, V + ): + B = mixed_qkv.shape[0] + out = mixed_qkv.new_empty(B, 1, HV, V) + fused_recurrent_kda_packed_decode( + mixed_qkv=mixed_qkv, + a=a, + b=b, + A_log=A_log, + dt_bias=dt_bias, + scale=K**-0.5, + initial_state=ssm_states, + out=out, + ssm_state_indices=cache_indices, + use_qk_l2norm_in_kernel=True, + ) + return out.transpose(0, 1) + + def _check(self, B, H, HV, K, V): + device = get_device() + dtype = torch.bfloat16 + pool_size = B + 4 + mixed_qkv, a, b, A_log, dt_bias, ssm_states, cache_indices = self._make_inputs( + B, H, HV, K, V, pool_size, dtype, device + ) + s_packed = ssm_states.clone() + s_baseline = ssm_states.clone() + + o_packed = self._run_packed( + mixed_qkv, a, b, A_log, dt_bias, s_packed, cache_indices, HV, K, V + ) + o_baseline = self._run_baseline( + mixed_qkv, a, b, A_log, dt_bias, s_baseline, cache_indices, H, HV, K, V + ) + + torch.testing.assert_close( + o_packed.float(), o_baseline.float(), atol=2e-2, rtol=1e-2 + ) + torch.testing.assert_close( + s_packed[cache_indices].float(), + s_baseline[cache_indices].float(), + atol=2e-2, + rtol=1e-2, + ) + + def test_b1(self): + self._check(B=1, H=16, HV=16, K=128, V=128) + + def test_b4(self): + self._check(B=4, H=16, HV=16, K=128, V=128) + + def test_b32(self): + self._check(B=32, H=16, HV=16, K=128, V=128) + + def test_b128(self): + self._check(B=128, H=16, HV=16, K=128, V=128) + + def test_asymmetric_heads(self): + # Common KDA config with HV > H (grouped query). + self._check(B=8, H=8, HV=16, K=128, V=128) + + def test_pad_slot(self): + """Entries with state_idx == -1 must produce zero output and skip state writeback.""" + device = get_device() + dtype = torch.bfloat16 + B, H, HV, K, V = 8, 16, 16, 128, 128 + pool_size = B + 4 + mixed_qkv, a, b, A_log, dt_bias, ssm_states, cache_indices = self._make_inputs( + B, H, HV, K, V, pool_size, dtype, device + ) + # Mark every other request as padded. + cache_indices = cache_indices.clone() + cache_indices[::2] = -1 + + s_packed = ssm_states.clone() + s_baseline = ssm_states.clone() + o_packed = self._run_packed( + mixed_qkv, a, b, A_log, dt_bias, s_packed, cache_indices, HV, K, V + ) + o_baseline = self._run_baseline( + mixed_qkv, a, b, A_log, dt_bias, s_baseline, cache_indices, H, HV, K, V + ) + torch.testing.assert_close( + o_packed.float(), o_baseline.float(), atol=2e-2, rtol=1e-2 + ) + + def test_production_shapes_through_dispatcher(self): + """Go through ``TritonKDAKernel.packed_decode`` with the exact tensor + shapes the KimiDeltaAttention model produces at decode time, so the + a/b/A_log/dt_bias reshape-normalization is unit-tested (not only E2E). + + Production decode shapes (see kimi_linear.py forward + __init__): + - a (forget_gate): [B, HV*K] (2D, not unflattened in decode) + - b (beta): [1, B, HV] (unsqueeze(0), pre-sigmoid) + - A_log: [1, 1, HV, 1] + - dt_bias: [HV*K] + """ + from sglang.srt.layers.attention.linear.kernels.kda_triton import ( + TritonKDAKernel, + ) + + device = get_device() + dtype = torch.bfloat16 + B, H, HV, K, V = 4, 16, 16, 128, 128 + pool_size = B + 4 + mixed_qkv, a, b, A_log, dt_bias, ssm_states, cache_indices = self._make_inputs( + B, H, HV, K, V, pool_size, dtype, device + ) + + # Reshape the flat reference tensors into the production layouts. + b_prod = b.unsqueeze(0) # [B, HV] -> [1, B, HV] + A_log_prod = A_log.view(1, 1, HV, 1) # [HV] -> [1, 1, HV, 1] + + kernel = TritonKDAKernel() + self.assertTrue(kernel.supports_packed_decode) + + s_packed = ssm_states.clone() + out = kernel.packed_decode( + mixed_qkv, + a, + b_prod, + A_log=A_log_prod, + dt_bias=dt_bias, + scale=K**-0.5, + ssm_states=s_packed, + cache_indices=cache_indices, + num_v_heads=HV, + head_v_dim=V, + ) + + s_baseline = ssm_states.clone() + o_baseline = self._run_baseline( + mixed_qkv, a, b, A_log, dt_bias, s_baseline, cache_indices, H, HV, K, V + ) + + # Dispatcher returns [1, B, HV, V], same layout as the baseline. + torch.testing.assert_close( + out.float(), o_baseline.float(), atol=2e-2, rtol=1e-2 + ) + torch.testing.assert_close( + s_packed[cache_indices].float(), + s_baseline[cache_indices].float(), + atol=2e-2, + rtol=1e-2, + ) + + if __name__ == "__main__": unittest.main()