From 0788f1fdd01a059dbaa31a80b120c8f584fdc623 Mon Sep 17 00:00:00 2001 From: Xiaoyu Zhang <1182563586@qq.com> Date: Tue, 20 Oct 2026 16:35:11 +0800 Subject: [PATCH] [Refactor] kernels: Register agent-generated kernels under their KDA / Cake backend (#45277) Co-authored-by: Claude Opus 5.5 --- python/sglang/kernels/README.md | 16 +++++++--------- python/sglang/kernels/fused_op.py | 5 +++++ python/sglang/kernels/ops/attention/__init__.py | 4 ++-- python/sglang/kernels/ops/diffusion/__init__.py | 6 +++--- python/sglang/kernels/ops/sampling/__init__.py | 4 ++-- python/sglang/kernels/spec.py | 1 + .../unit/kernels/test_kernels_namespace.py | 14 ++++++++++++++ 7 files changed, 34 insertions(+), 16 deletions(-) diff --git a/python/sglang/kernels/README.md b/python/sglang/kernels/README.md index f7c6475d79..f1fe42e0c8 100644 --- a/python/sglang/kernels/README.md +++ b/python/sglang/kernels/README.md @@ -104,16 +104,17 @@ and will keep growing; they are implementation homes, not operator groups. (Humanize2) workflow, in CUDA, Triton, or CuTe DSL, with their JIT sources in `kda_kernels/csrc/`. `KernelBackend.KDA` records that provenance. - `cake_kernels/` — thin adapters to Cake-generated kernels that FlashInfer - distributes (generated sources and caches stay in FlashInfer); they register - with the provenance of that library (`KernelBackend.FLASHINFER`). + distributes (generated sources and caches stay in FlashInfer). + `KernelBackend.CAKE` records that provenance. Their public ops are registered into the logical groups with `KernelSpec(op=".", backend=..., target="sglang.kernels.kda_kernels.:")` (or a `cake_kernels` target), and runtime code imports the `ops.` facade, never these packages. Put a new agent-generated kernel in the matching -directory with its provenance (see `kda_kernels/README.md`). List them from the -registry by target (an agent kernel that is the op's only implementation may -keep its language backend, e.g. `TRITON`): +directory and register it with that directory's backend (`KDA` or `CAKE`), +whatever language it is written in (see `kda_kernels/README.md`); +`test_kernels_namespace.py` enforces the pairing. List them from the registry +by backend: ```python import sglang.kernels.ops # populate the registry @@ -122,10 +123,7 @@ from sglang.kernels import KernelBackend, registry agent_kernels = [ spec for spec in registry.all_specs() - if spec.backend is KernelBackend.KDA - or spec.target.startswith( - ("sglang.kernels.kda_kernels.", "sglang.kernels.cake_kernels.") - ) + if spec.backend in (KernelBackend.KDA, KernelBackend.CAKE) ] ``` diff --git a/python/sglang/kernels/fused_op.py b/python/sglang/kernels/fused_op.py index 5ed99d74fb..d19d5403c7 100644 --- a/python/sglang/kernels/fused_op.py +++ b/python/sglang/kernels/fused_op.py @@ -109,6 +109,7 @@ BACKEND_METHODS: Dict[KernelBackend, str] = { KernelBackend.FLYDSL: "forward_flydsl", KernelBackend.HELION: "forward_helion", KernelBackend.KDA: "forward_kda", + KernelBackend.CAKE: "forward_cake", KernelBackend.FLASHINFER: "forward_flashinfer", KernelBackend.DEEPGEMM: "forward_deepgemm", KernelBackend.AITER: "forward_aiter", @@ -124,6 +125,7 @@ _METHOD_BACKEND_LABELS: Dict[str, str] = { # explicitly when wanted. Per-op priority overrides this (see BaseFusedOp). DEFAULT_PRIORITY: Tuple[KernelBackend, ...] = ( KernelBackend.KDA, + KernelBackend.CAKE, KernelBackend.AOT, KernelBackend.JIT, KernelBackend.FLASHINFER, @@ -428,6 +430,9 @@ class BaseFusedOp(nn.Module, ABC): def forward_kda(self, *args, **kwargs): raise NotImplementedError(f"{self._op_label()}: no KDA backend") + def forward_cake(self, *args, **kwargs): + raise NotImplementedError(f"{self._op_label()}: no Cake backend") + def forward_flashinfer(self, *args, **kwargs): raise NotImplementedError(f"{self._op_label()}: no flashinfer backend") diff --git a/python/sglang/kernels/ops/attention/__init__.py b/python/sglang/kernels/ops/attention/__init__.py index 8e5ea819e6..d23cc247c5 100644 --- a/python/sglang/kernels/ops/attention/__init__.py +++ b/python/sglang/kernels/ops/attention/__init__.py @@ -75,7 +75,7 @@ del _mod, _fn register_kernel( KernelSpec( op="attention.kda_qwen38_qsa_sm121", - backend=KernelBackend.TRITON, + backend=KernelBackend.KDA, target=("sglang.kernels.kda_kernels.qwen38_qsa_sm121:qwen38_qsa_sm121"), capabilities=frozenset( {CapabilityRequirement.cuda(min_sm=(12, 1), max_sm=(12, 1))} @@ -123,7 +123,7 @@ def qwen38_qsa_sm121_varlen( "unsupported SM121 QSA call: expected BF16 D=256, 12:1 GQA, " "TP1 24Q/2KV or TP2 12Q/1KV, bs<=128, and selected KV<=2055" ) - return get_kernel("attention.kda_qwen38_qsa_sm121", KernelBackend.TRITON)( + return get_kernel("attention.kda_qwen38_qsa_sm121", KernelBackend.KDA)( q, k, v, diff --git a/python/sglang/kernels/ops/diffusion/__init__.py b/python/sglang/kernels/ops/diffusion/__init__.py index 2f60b0c617..b6dd1315da 100644 --- a/python/sglang/kernels/ops/diffusion/__init__.py +++ b/python/sglang/kernels/ops/diffusion/__init__.py @@ -149,7 +149,7 @@ _SPECS: tuple[tuple[str, KernelBackend, str, frozenset], ...] = ( ), ( "diffusion.scale_residual_norm_scale_shift_nvfp4", - KernelBackend.JIT, + KernelBackend.KDA, "sglang.kernels.kda_kernels.norm_scale_shift_jit:try_fused_scale_residual_norm_scale_shift_nvfp4", _CUDA, ), @@ -173,13 +173,13 @@ _SPECS: tuple[tuple[str, KernelBackend, str, frozenset], ...] = ( ), ( "diffusion.layernorm_modulate", - KernelBackend.TRITON, + KernelBackend.KDA, "sglang.kernels.kda_kernels.layernorm_modulate_triton:fused_layernorm_modulate", _CUDA, ), ( "diffusion.qk_head_layernorm", - KernelBackend.TRITON, + KernelBackend.KDA, "sglang.kernels.kda_kernels.layernorm_modulate_triton:fused_qk_head_layernorm", _CUDA, ), diff --git a/python/sglang/kernels/ops/sampling/__init__.py b/python/sglang/kernels/ops/sampling/__init__.py index d0dee0cfd3..bf9a43f07e 100644 --- a/python/sglang/kernels/ops/sampling/__init__.py +++ b/python/sglang/kernels/ops/sampling/__init__.py @@ -19,7 +19,7 @@ if TYPE_CHECKING: register_kernel( KernelSpec( op="sampling.softmax", - backend=KernelBackend.FLASHINFER, + backend=KernelBackend.CAKE, target="sglang.kernels.cake_kernels.sampling:softmax", capabilities=frozenset( { @@ -32,7 +32,7 @@ register_kernel( def cake_softmax(logits: torch.Tensor) -> torch.Tensor: """Explicit Cake softmax entry point for Blackwell qualification.""" - return get_kernel("sampling.softmax", KernelBackend.FLASHINFER)(logits) + return get_kernel("sampling.softmax", KernelBackend.CAKE)(logits) def softmax( diff --git a/python/sglang/kernels/spec.py b/python/sglang/kernels/spec.py index 18e0912d7e..90e6c6c180 100644 --- a/python/sglang/kernels/spec.py +++ b/python/sglang/kernels/spec.py @@ -46,6 +46,7 @@ class KernelBackend(str, Enum): FLYDSL = "flydsl" # FlyDSL MLIR compiler (device=HIP, gfx950) HELION = "helion" KDA = "KDA" # Kernel Design Agents generated implementation + CAKE = "cake" # Cake-generated implementation, distributed by FlashInfer FLASHINFER = "flashinfer" DEEPGEMM = "deepgemm" AITER = "aiter" # AMD aiter library (device=HIP) diff --git a/test/registered/unit/kernels/test_kernels_namespace.py b/test/registered/unit/kernels/test_kernels_namespace.py index 1eb7755c90..6abc19c72b 100644 --- a/test/registered/unit/kernels/test_kernels_namespace.py +++ b/test/registered/unit/kernels/test_kernels_namespace.py @@ -224,6 +224,20 @@ def test_operator_and_test_groups_agree(): assert actual <= groups, actual - groups +def test_agent_kernels_register_their_backend(): + """Agent-generated kernels are listed by backend, so directory and backend must agree.""" + agent_backends = { + "sglang.kernels.kda_kernels.": KernelBackend.KDA, + "sglang.kernels.cake_kernels.": KernelBackend.CAKE, + } + for spec in K.registry.all_specs(): + expected = next( + (b for p, b in agent_backends.items() if spec.target.startswith(p)), None + ) + if expected is not None or spec.backend in agent_backends.values(): + assert spec.backend is expected, spec + + def test_inventory_targets_survive_module_moves(): """Moving a module without its lazy target otherwise breaks only on first call.""" root = Path(K.__file__).resolve().parents[3] / "python"