scripts/capture_llm.py

"""Capture Qwen and DeepSeek operator boundaries during actual SGLang requests."""

import contextvars
import functools
import inspect
import json
import math
import os
from pathlib import Path

import torch


_CONTEXT = contextvars.ContextVar("llm_capture_context", default=None)


def _bind(function, args, kwargs):
    bound = inspect.signature(function).bind(*args, **kwargs)
    bound.apply_defaults()
    return bound.arguments


def _receipt(operation, **extra):
    context = _CONTEXT.get()
    return dict(context["request"], step=context["step"], operation=operation,
                scheduler_mode=context["mode"], scheduler_sequence_lengths=context["lengths"],
                **extra)


def _compact_pages(cache, table, lengths):
    """Copy every reachable physical page and preserve its complete contents.

    Only allocator pages outside every request's page table are omitted. The
    original page IDs are returned as provenance; no token values are changed.
    """
    page_size = cache.shape[1]
    columns = (int(lengths.max()) + page_size - 1) // page_size
    table = table[:, :columns].long()
    valid = torch.arange(columns, device=table.device)[None] < ((lengths + page_size - 1) // page_size)[:, None]
    selected = torch.unique(table[valid], sorted=True)
    if not selected.numel() or selected.min() < 0 or selected.max() >= cache.shape[0]:
        raise ValueError("Invalid live cache page table")
    mapped = torch.full_like(table, -1, dtype=torch.int32)
    mapped[valid] = torch.searchsorted(selected, table[valid]).to(torch.int32)
    return cache.index_select(0, selected), mapped, selected.to(torch.int32)


def _install_context(model_class):
    original_forward = model_class.forward
    counters = {}

    @functools.wraps(original_forward)
    def forward(self, *args, **kwargs):
        request_file = Path(os.environ["INFERENCE_CAPTURE_REQUEST"])
        if not request_file.is_file():
            return original_forward(self, *args, **kwargs)
        request = json.loads(request_file.read_text())
        bound = _bind(original_forward, (self, *args), kwargs)
        batch = bound["forward_batch"]
        mode = "decode" if batch.forward_mode.is_decode() else "prefill"
        key = (request["request_id"], mode)
        step = counters.get(key, 0)
        counters[key] = step + 1
        selected = mode == "prefill" or step in request.get("capture_decode_steps", [0, 1, 3, 15])
        if request.get("overlap_profile") and mode == "decode":
            batch_key = (request["request_id"], "decode_batch", len(batch.seq_lens))
            batch_step = counters.get(batch_key, 0)
            counters[batch_key] = batch_step + 1
            selected = batch_step < 4
        token = _CONTEXT.set({"request": request, "step": step, "mode": mode,
                              "selected": selected, "lengths": batch.seq_lens.tolist(),
                              "tokens": getattr(batch, "extend_num_tokens", None) or len(batch.seq_lens),
                              "prefix_lengths": getattr(batch, "extend_prefix_lens_cpu", None)})
        try:
            return original_forward(self, *args, **kwargs)
        finally:
            _CONTEXT.reset(token)

    model_class.forward = forward


def install_qwen(writer):
    from sglang.srt.models.qwen4_exp import Qwen4ExpForConditionalGeneration
    from sglang.kernels.ops.attention.fla import chunk
    from sglang.srt.layers.attention.linear.kernels.gdn_triton import TritonGDNKernel
    from sglang.srt.layers.attention.qsa.qsa_indexer import QSAIndexer
    from sglang.srt.layers.attention.qwen_sparse_attn_backend import QwenSparseAttnBackend

    _install_context(Qwen4ExpForConditionalGeneration)
    original_chunk = chunk.chunk_gated_delta_rule_fwd

    @functools.wraps(original_chunk)
    def prefill(*args, **kwargs):
        context = _CONTEXT.get()
        if context is None or not context["selected"]:
            return original_chunk(*args, **kwargs)
        values = _bind(original_chunk, args, kwargs)
        q, k, v = (values[key] for key in ("q", "k", "v"))
        indices = values["initial_state_indices"].long()
        state_pool = values["initial_state"]
        bounds = values["cu_seqlens"].tolist()
        pending = []
        name = "gated_delta_rule_prefill_h48_dk128_dv128"
        for sample, (start, end) in enumerate(zip(bounds, bounds[1:])):
            prefix = (context["prefix_lengths"] or [0] * len(indices))[sample]
            provenance = _receipt("chunk_gated_delta_rule_fwd after engine L2 normalization",
                                  sample_index=sample, prefix_tokens=prefix, selection_step=0,
                                  variant=f"tokens_{end-start}_cached_{bool(prefix)}",
                                  adapter="Repeat shared Q/K heads; transpose the engine state; widen BF16 beta without rounding.")
            if end == start or not writer.wants(name, provenance):
                continue
            repeats = v.shape[2] // q.shape[2]
            inputs = dict(Q=q[:, start:end].repeat_interleave(repeats, 2),
                          K=k[:, start:end].repeat_interleave(repeats, 2),
                          V=v[:, start:end].clone(), beta=values["beta"][:, start:end].float().clone(),
                          g=values["g"][:, start:end].float().clone(),
                          S0=state_pool[indices[sample:sample+1]].transpose(-1, -2).clone(),
                          q_scale=float(values["scale"]))
            pending.append((sample, start, end, inputs, provenance))
        result = original_chunk(*args, **kwargs)
        for sample, start, end, inputs, provenance in pending:
            outputs = {"O": result[1][:, start:end],
                       "S_final": state_pool[indices[sample:sample+1]].transpose(-1, -2)}
            writer.write(name, inputs, outputs, provenance)
        return result

    chunk.chunk_gated_delta_rule_fwd = prefill
    original_decode = TritonGDNKernel.packed_decode

    @functools.wraps(original_decode)
    def decode(self, *args, **kwargs):
        context = _CONTEXT.get()
        if context is None or not context["selected"]:
            return original_decode(self, *args, **kwargs)
        provenance = _receipt("TritonGDNKernel.packed_decode", layer_id=0,
                              adapter="Split actual packed QKV views; transpose the selected pre-update state.")
        name = "gated_delta_rule_decode_h48_dk128_dv128"
        if not writer.wants(name, provenance):
            return original_decode(self, *args, **kwargs)
        values = _bind(original_decode, (self, *args), kwargs)
        packed = values["mixed_qkv"]
        batch = packed.shape[0]
        q, k, v = packed.split((16*128, 16*128, 48*128), dim=-1)
        indices = values["cache_indices"].long()
        pool = values["ssm_states"]
        inputs = dict(Q=q.reshape(batch, 1, 16, 128).clone(),
                      K=k.reshape(batch, 1, 16, 128).clone(),
                      V=v.reshape(batch, 1, 48, 128).clone(),
                      a=values["a"].reshape(batch, 1, 48).clone(),
                      b=values["b"].reshape(batch, 1, 48).clone(),
                      A_log=values["A_log"].float().clone(), dt_bias=values["dt_bias"].clone(),
                      S0=pool[indices].transpose(-1, -2).clone(), q_scale=float(values["scale"]))
        result = original_decode(self, *args, **kwargs)
        writer.write(name, inputs, {"O": result.transpose(0, 1),
                                   "S_final": pool[indices].transpose(-1, -2)}, provenance)
        return result

    TritonGDNKernel.packed_decode = decode
    original_index = QSAIndexer.select_decode_tokens

    @functools.wraps(original_index)
    def index(self, *args, **kwargs):
        context = _CONTEXT.get()
        if context is None or not context["selected"]:
            return original_index(self, *args, **kwargs)
        provenance = _receipt("QSAIndexer.select_decode_tokens", layer_id=self.layer_id)
        name = "qsa_index_topk_decode_qwen38_h4_d128_topk512_c4"
        if not writer.wants(name, provenance):
            return original_index(self, *args, **kwargs)
        values = _bind(original_index, (self, *args), kwargs)
        cache = values["compressed_cache"]
        lengths = values["compressed_lengths"].to(torch.int32)
        pages, table, physical = _compact_pages(cache, values["compressed_page_table"], lengths)
        provenance.update(allocated_cache_shape=list(cache.shape), original_physical_page_ids=writer.tensor(physical, name),
                          adapter="Retain all live pages byte-for-byte and remap their page IDs; omit unreachable allocator pages.")
        query = values["q"]
        if query.shape[1] != self.index_n_heads:
            if torch.count_nonzero(query[:, self.index_n_heads:]):
                raise ValueError("QSA padded query heads are not zero")
            provenance.update(padded_query=writer.tensor(query, name),
                              query_adapter="Remove verified zero query heads inserted for the backend's eight-head tile.")
            query = query[:, :self.index_n_heads]
        inputs = dict(Q_idx=query.clone(), Kc_pages=pages, page_table=table,
                      num_complete_blocks=lengths.clone())
        result = original_index(self, *args, **kwargs)
        selected = result if values["defer_expansion"] else result[:, :2048:4] // 4
        provenance.update(engine_block_ids=writer.tensor(selected, name),
                          output_adapter="Serialize the engine's selected set in increasing logical-ID order; preserve membership and -1 suffix padding.")
        ordered = torch.full_like(selected, -1, dtype=torch.int32)
        for row in range(selected.shape[0]):
            ids = selected[row][selected[row] >= 0].long().sort().values
            ordered[row, :ids.numel()] = ids.to(torch.int32)
        writer.write(name, inputs, ordered, provenance)
        return result

    QSAIndexer.select_decode_tokens = index
    original_attention = QwenSparseAttnBackend.forward_decode

    @functools.wraps(original_attention)
    def attention(self, *args, **kwargs):
        context = _CONTEXT.get()
        if context is None or not context["selected"]:
            return original_attention(self, *args, **kwargs)
        values = _bind(original_attention, (self, *args), kwargs)
        layer, batch = values["layer"], values["forward_batch"]
        provenance = _receipt("QwenSparseAttnBackend.forward_decode", layer_id=layer.layer_id)
        name = "qsa_sparse_gqa_decode_qwen38_h24_kv2_d256_topk512_c4"
        if not writer.wants(name, provenance):
            return original_attention(self, *args, **kwargs)
        query = values["q"].reshape(-1, 24, 256).clone()
        selected = values["topk_indices"].clone()
        selected = selected if selected.shape[1] == 512 else selected[:, :2048:4] // 4
        result = original_attention(self, *args, **kwargs)
        pool = self.token_to_kv_pool
        key = pool.get_key_buffer(layer.layer_id)
        value = pool.get_value_buffer(layer.layer_id)
        page_size = pool.qsa_compressed_page_size * self.compress_ratio
        keys = key.reshape(-1, page_size, 2, 256)
        values_cache = value.reshape_as(keys)
        lengths = batch.seq_lens.to(torch.int32)
        rows = self.req_to_token_pool.req_to_token[batch.req_pool_indices.long()]
        table = rows[:, ::page_size] // page_size
        pages, table, physical = _compact_pages(keys, table, lengths)
        provenance.update(allocated_cache_shape=list(keys.shape), original_physical_page_ids=writer.tensor(physical, name),
                          adapter="Snapshot after the current-token KV write; retain every live page and remap physical IDs.")
        inputs = dict(Q=query, K_pages=pages, V_pages=values_cache.index_select(0, physical.long()),
                      page_table=table, block_ids=selected.to(torch.int32), context_lens=lengths.clone())
        writer.write(name, inputs, result.reshape(-1, 24, 256), provenance)
        return result

    QwenSparseAttnBackend.forward_decode = attention


def install_deepseek(writer):
    """Capture real EP shards and reconstruct complete logical operators."""
    import torch.distributed as dist
    from sglang.srt.models.deepseek_v4 import DeepseekV4ForCausalLM
    from sglang.srt.models import deepseek_v2
    from sglang.srt.layers import deep_gemm_wrapper
    from sglang.srt.layers.moe.moe_runner.deep_gemm import DeepGemmMoeQuantInfo
    from sgl_kernel import flash_mla

    original_recipes = DeepGemmMoeQuantInfo.scale_recipes

    @functools.wraps(original_recipes)
    def scale_recipes(self, *, activation_block_size, hidden_size, activation_scale_width):
        # The pinned engine's FP4 branch hardcodes group 128 even when its
        # standard dispatcher actually quantizes activations in groups of 32.
        # Pass the dispatcher's explicit metadata; leave all tensor bytes intact.
        if self.is_fp4_experts and not self.use_mxfp8:
            group = activation_block_size or 128
            if (hidden_size + group * 4 - 1) // (group * 4) != activation_scale_width:
                raise ValueError("FP4 expert activation metadata disagrees with packed scale width")
            return (1, group), (1, 32)
        return original_recipes(self, activation_block_size=activation_block_size,
                                hidden_size=hidden_size, activation_scale_width=activation_scale_width)

    DeepGemmMoeQuantInfo.scale_recipes = scale_recipes
    _install_context(DeepseekV4ForCausalLM)
    captured = set()
    weight_cache = {}

    def selected(name, provenance):
        return name in writer.enabled and writer._selection_key(name, provenance) not in captured

    def mark(name, provenance):
        captured.add(writer._selection_key(name, provenance))

    def gather(value, axis=0):
        value = value.contiguous()
        wire = value.view(torch.uint8) if value.dtype == torch.float8_e4m3fn else value
        lengths = [None] * dist.get_world_size()
        dist.all_gather_object(lengths, wire.shape[axis])
        shape = list(wire.shape)
        shape[axis] = max(lengths)
        padded = torch.zeros(shape, dtype=wire.dtype, device=wire.device)
        padded.narrow(axis, 0, wire.shape[axis]).copy_(wire)
        parts = [torch.empty_like(padded) for _ in lengths]
        dist.all_gather(parts, padded)
        if dist.get_rank() != 0:
            return None
        result = torch.cat([part.narrow(axis, 0, length).cpu() for part, length in zip(parts, lengths)], dim=axis)
        return result.view(value.dtype) if wire.dtype != value.dtype else result

    def scales(value, groups, source_group_size=32):
        if value.dtype == torch.int32:
            result = value.contiguous().view(torch.int8)
        elif value.dtype in (torch.uint8, torch.int8, torch.float8_e8m0fnu):
            result = value.contiguous().view(torch.int8)
        else:
            exponent = torch.log2(value.float())
            if not torch.equal(exponent, exponent.round()):
                raise ValueError("Activation scales are not exact powers of two")
            result = (exponent.to(torch.int32) + 127).to(torch.uint8).view(torch.int8)
        source_groups = groups * 32 // source_group_size
        if source_group_size % 32 or result.shape[-1] < source_groups:
            raise ValueError("Unexpected quantization scale width")
        # Packed int32 scales may include padding bytes in their final word.
        return result[..., :source_groups].repeat_interleave(source_group_size // 32, -1)

    original_gemm = deep_gemm_wrapper.grouped_gemm_nt_f8f8bf16_contig

    @functools.wraps(original_gemm)
    def gemm(lhs, rhs, out, m_indices, *args, **kwargs):
        context = _CONTEXT.get()
        if context is None or not context["selected"] or rhs[0].dtype not in (torch.uint8, torch.int8):
            return original_gemm(lhs, rhs, out, m_indices, *args, **kwargs)
        local_experts, n, packed_k = rhs[0].shape
        k = lhs[0].shape[-1]
        if local_experts * dist.get_world_size() != 384 or k != packed_k * 2:
            raise ValueError("Capture requires complete expert shards without tensor-sharded expert dimensions")
        name = f"grouped_gemm_fp8_fp4_e384_n{n}_k{k}_g32"
        provenance = _receipt("SGLang DeepGEMM grouped GEMM", selection_step=0 if context["mode"] == "prefill" else context["step"],
                              variant=f"{context['mode']}_{context['tokens']}_cached_{any(context['prefix_lengths'] or [])}",
                              adapter="Gather all expert shards; discard rows marked -1 by the engine; preserve group-32 activation scales or expand each actual group-128 scale into four identical bytes.")
        if name not in writer.definitions or not selected(name, provenance):
            return original_gemm(lhs, rhs, out, m_indices, *args, **kwargs)
        valid = (m_indices >= 0) & (m_indices < local_experts)
        a = lhs[0][valid].clone()
        recipe = kwargs.get("recipe_a", args[0] if args else None) or (1, 128)
        sa = scales(lhs[1], k // 32, recipe[1])[valid].clone()
        ids = m_indices[valid].to(torch.int32) + dist.get_rank() * local_experts
        result = original_gemm(lhs, rhs, out, m_indices, *args, **kwargs)
        y = out[valid].clone()
        a, sa, ids, y = (gather(t) for t in (a, sa, ids, y))
        weight_key = (rhs[0].data_ptr(), n, k)
        if weight_key not in weight_cache:
            weight_cache[weight_key] = (gather(rhs[0].view(torch.int8)), gather(scales(rhs[1], k // 32)))
        if dist.get_rank() == 0:
            weight, sw = weight_cache[weight_key]
            order = ids.argsort(stable=True)
            inputs = dict(Aq=a[order], Wq_packed=weight, scale_A=sa[order], scale_W=sw, expert_id=ids[order])
            writer.write(name, inputs, y[order], provenance)
            if n == 4608:
                for offset, label in ((0, "gate"),):
                    split_name = "grouped_gemm_fp8_fp4_e384_n2304_k5120_g32"
                    split = dict(inputs, Wq_packed=weight[:, offset:offset+2304], scale_W=sw[:, offset:offset+2304])
                    writer.write(split_name, split, y[order, offset:offset+2304],
                                 dict(provenance, variant=provenance["variant"] + "_" + label,
                                      output_adapter="Exact gate/up slice of the executed fused projection."))
        mark(name, provenance)
        return result

    deep_gemm_wrapper.grouped_gemm_nt_f8f8bf16_contig = gemm
    original_gate = deepseek_v2.MoEGate.forward

    @functools.wraps(original_gate)
    def gate(self, hidden_states, *args, **kwargs):
        context = _CONTEXT.get()
        if ("moe_router_gemm_topk_deepseek41_d5120_e384_topk6" in writer.enabled
                and context is not None and context["selected"] and dist.get_rank() == 0
                and self.e_score_correction_bias is not None):
            context["gate_input"] = (self, hidden_states.detach().clone())
        return original_gate(self, hidden_states, *args, **kwargs)

    deepseek_v2.MoEGate.forward = gate
    original_topk = deepseek_v2.vision_topk

    @functools.wraps(original_topk)
    def topk(moe, logits, input_ids, *args, **kwargs):
        result = original_topk(moe, logits, input_ids, *args, **kwargs)
        context = _CONTEXT.get()
        if context is None or not context["selected"] or dist.get_rank() != 0:
            return result
        name = "moe_router_gemm_topk_deepseek41_d5120_e384_topk6"
        provenance = _receipt("MoEGate.forward followed by vision_topk", layer_id=moe.layer_id,
                              selection_step=0 if context["mode"] == "prefill" else context["step"],
                              variant=f"{context['mode']}_{logits.shape[0]}")
        if not writer.wants(name, provenance):
            return result
        module, x = context.pop("gate_input")
        if module is not moe.gate:
            raise ValueError("Router input and output came from different layers")
        mask = torch.zeros(x.shape[0], dtype=torch.bool, device=x.device) if input_ids is None else input_ids == moe.config.image_token_id
        config = moe.topk.topk_config
        inputs = dict(X=x, W=module.weight, bias_text=module.e_score_correction_bias,
                      bias_image=module.e_score_correction_bias_vl, is_image_token=mask,
                      routed_scale=float(config.routed_scaling_factor))
        weights = result.topk_weights
        if not config.apply_routed_scaling_factor_on_output:
            weights = weights * config.routed_scaling_factor
            provenance["output_adapter"] = "Apply the engine's deferred routing scale to its selected weights."
        provenance["engine_expert_ids"] = writer.tensor(result.topk_ids.to(torch.int64), name)
        provenance["engine_expert_weights"] = writer.tensor(weights.float(), name)
        provenance["selection_order"] = "Serialize the unchanged selected expert set by increasing expert ID; permute the actual weights with their IDs."
        order = result.topk_ids.argsort(dim=-1)
        writer.write(name, inputs, {"expert_ids": result.topk_ids.gather(1, order).to(torch.int64),
                                   "expert_weights": weights.gather(1, order).float()}, provenance)
        return result

    deepseek_v2.vision_topk = topk
    original_mla = flash_mla.flash_mla_with_kvcache

    @functools.wraps(original_mla)
    def mla(*args, **kwargs):
        context = _CONTEXT.get()
        if context is None or not context["selected"] or context["mode"] != "decode":
            return original_mla(*args, **kwargs)
        values = _bind(original_mla, args, kwargs)
        extra = values.get("extra_k_cache")
        if extra is None or extra.shape[-1] != 288:
            return original_mla(*args, **kwargs)
        name = "mixed_mla_decode_deepseek41_h64_d512_k8128_k4512"
        provenance = _receipt("flash_mla_with_kvcache mixed FP8/FP4", adapter="Gather real query heads from all tensor-parallel ranks; preserve all referenced physical pages and remap indices.")
        if not selected(name, provenance):
            return original_mla(*args, **kwargs)
        heads = 64 // dist.get_world_size()
        query = gather(values["q"][..., :heads, :].clone(), axis=2)
        sink = gather(values["attn_sink"][:heads].clone())
        inputs = None
        if dist.get_rank() == 0:
            inputs = dict(Q=query, attn_sink=sink.float(), sm_scale=float(values["softmax_scale"]))
            for suffix, cache, indices, lengths in (("8", values["k_cache"], values["indices"], values["topk_length"]),
                                                    ("4", extra, values["extra_indices_in_kvcache"], values["extra_topk_length"])):
                indices = indices.clone().to(torch.int32)
                if lengths is not None:
                    indices.masked_fill_(torch.arange(indices.shape[-1], device=indices.device) >= lengths.reshape(-1, 1, 1), -1)
                valid = indices >= 0
                physical = torch.unique(indices[valid].long() // cache.shape[1], sorted=True)
                remapped = indices.clone()
                remapped[valid] = (torch.searchsorted(physical, indices[valid].long() // cache.shape[1]) * cache.shape[1] + indices[valid] % cache.shape[1]).to(torch.int32)
                inputs["KV" + suffix] = cache.index_select(0, physical).view(torch.int8).clone()
                inputs["indices" + suffix] = remapped
                provenance["physical_pages_" + suffix] = writer.tensor(physical, name)
                provenance["allocated_cache_" + suffix] = list(cache.shape)
        result = original_mla(*args, **kwargs)
        output = gather(result[0][..., :heads, :].clone(), axis=2)
        if dist.get_rank() == 0:
            writer.write(name, inputs, output, provenance)
        mark(name, provenance)
        return result

    flash_mla.flash_mla_with_kvcache = mla
    from sglang.srt.layers.attention.deepseek_v4_backend import DeepseekV4AttnBackend
    original_prefill = DeepseekV4AttnBackend._forward_prefill_sparse

    @functools.wraps(original_prefill)
    def prefill_context(self, *args, **kwargs):
        context = _CONTEXT.get()
        if context is None:
            return original_prefill(self, *args, **kwargs)
        values = _bind(original_prefill, (self, *args), kwargs)
        previous = context.get("mla_compress_ratio")
        context["mla_compress_ratio"] = values["compress_ratio"]
        try:
            return original_prefill(self, *args, **kwargs)
        finally:
            context["mla_compress_ratio"] = previous

    DeepseekV4AttnBackend._forward_prefill_sparse = prefill_context
    original_sparse = flash_mla.flash_mla_sparse_fwd

    @functools.wraps(original_sparse)
    def sparse_prefill(*args, **kwargs):
        context = _CONTEXT.get()
        if context is None or not context["selected"] or context["mode"] != "prefill":
            return original_sparse(*args, **kwargs)
        values = _bind(original_sparse, args, kwargs)
        q, kv, indices = (values[key] for key in ("q", "kv", "indices"))
        name = f"sparse_mla_prefill_h64_d512_k{indices.shape[-1]}"
        provenance = _receipt(
            "sgl_kernel.flash_mla.flash_mla_sparse_fwd", selection_step=0,
            variant=f"rows_{q.shape[0]}_compression_{context.get('mla_compress_ratio')}_cached_{any(context['prefix_lengths'] or [])}",
            compression_ratio=context.get("mla_compress_ratio"),
            adapter="Gather all logical query heads and outputs from tensor-parallel ranks; retain the complete BF16 workspace and original sparse indices.")
        if not selected(name, provenance):
            return original_sparse(*args, **kwargs)
        heads = 64 // dist.get_world_size()
        if q.shape[1] < heads or values["d_v"] != 512:
            raise ValueError("Unexpected DeepSeek sparse prefill dimensions")
        query = gather(q[:, :heads].clone(), axis=1)
        sink = gather(values["attn_sink"][:heads].clone())
        inputs = None
        if dist.get_rank() == 0:
            lengths = values["topk_length"]
            if lengths is None:
                lengths = torch.full((q.shape[0],), indices.shape[-1], dtype=torch.int32, device=q.device)
            inputs = dict(Q=query, KV=kv.clone(), indices=indices.clone(),
                          topk_length=lengths.clone(), attn_sink=sink.float(),
                          sm_scale=float(values["sm_scale"]))
        result = original_sparse(*args, **kwargs)
        output = gather(result[0][:, :heads].clone(), axis=1)
        if dist.get_rank() == 0:
            writer.write(name, inputs, output, provenance)
        mark(name, provenance)
        return result

    flash_mla.flash_mla_sparse_fwd = sparse_prefill


def make_input_ids(profile, tokenizer):
    """Reconstruct anonymized blocks from an explicitly authored code corpus."""
    import hashlib

    corpus = """User: Inspect a small Python service and add unit tests for its cache.
Assistant: I will read the implementation, check boundary cases, and test the change.
Tool output: class Cache: stores a mapping from keys to values and expiration times.
def lookup(cache, key, now):
    entry = cache.get(key)
    if entry is None or entry.expires_at <= now:
        return None
    return entry.value
Test cases: an absent key returns None; a valid key returns its value; expired
entries return None; replacing an entry updates its deadline. Use a controlled
clock so tests do not sleep. Keep the public interface unchanged.
Tool output: three tests passed. One test failed at the expiration boundary.
Assistant: The deadline comparison must include equality. I will fix that branch
and rerun the affected tests. The change only touches the lookup implementation.
User: Also check concurrent requests, empty strings, and repeated replacement.
"""
    tokens = tokenizer.encode(corpus, add_special_tokens=False)
    tokens = tokens * (1 + profile['block_size'] // len(tokens))
    result = []
    for block in profile['hash_ids']:
        digest = hashlib.sha256(f"20261014:{profile['session_id']}:{block}".encode()).digest()
        start = int.from_bytes(digest[:8], 'little') % len(tokens)
        result.extend(tokens[(start + offset) % len(tokens)] for offset in range(profile['block_size']))
    if len(result) != profile['input_tokens']:
        raise ValueError('Recorded hash blocks do not tile the complete input')
    return result


def main():
    import argparse
    import hashlib
    import importlib.metadata
    import signal
    import subprocess
    import time
    import requests
    import concurrent.futures
    from transformers import AutoTokenizer

    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--model-path', type=Path, required=True)
    parser.add_argument('--kind', choices=['qwen-next', 'deepseek41'], default='qwen-next')
    parser.add_argument('--output-root', type=Path, required=True)
    parser.add_argument('--case', action='append', default=[])
    parser.add_argument('--max-output-tokens', type=int)
    parser.add_argument('--port', type=int, default=30000)
    args = parser.parse_args()
    root = args.output_root.resolve()
    results = root / 'results'
    results.mkdir(parents=True, exist_ok=True)
    scripts = Path(__file__).resolve().parent
    fixture = json.loads((scripts / 'agentx_shapes.json').read_text())
    tokenizer = AutoTokenizer.from_pretrained(str(args.model_path))
    selected = args.case or ['short_request', 'cold_main', '256k_context_p10',
                             '256k_context_p50', '256k_context_p90', '256k_context_p99',
                             'subagent_typical', 'auxiliary_typical', 'fully_reused', '256k_long_output']
    if args.kind == 'deepseek41' and not args.case:
        selected = ['short_request', 'cold_main', 'full_context_p10', 'full_context_p50',
                    'full_context_p90', 'full_context_p99', 'subagent_typical',
                    'auxiliary_typical', 'fully_reused', 'long_output']
    profiles = {row['label']: row for row in fixture['profiles']}
    overlaps = {row['label']: row for row in fixture['overlap_profiles']}
    request_file = results / 'active_request.json'
    request_file.unlink(missing_ok=True)
    environment = dict(os.environ, INFERENCE_CAPTURE_ROOT=str(root),
                       INFERENCE_CAPTURE_DEFINITIONS=str(scripts.parent / 'definitions'),
                       INFERENCE_CAPTURE_REQUEST=str(request_file), INFERENCE_CAPTURE_MODEL=args.kind,
                       PYTHONPATH=str(scripts) + os.pathsep + os.environ.get('PYTHONPATH', ''),
                       PYTHONDONTWRITEBYTECODE='1', OMP_NUM_THREADS='8')
    command = ['python', '-m', 'sglang.launch_server', '--model-path', str(args.model_path),
               '--host', '127.0.0.1', '--port', str(args.port), '--dtype', 'bfloat16',
               '--moe-runner-backend', 'flashinfer_cutlass', '--ple-offload-embedding',
               '--linear-attn-decode-backend', 'triton', '--linear-attn-prefill-backend', 'triton',
               '--mamba-ssm-dtype', 'float32', '--disable-cuda-graph', '--disable-overlap-schedule',
               '--chunked-prefill-size', '4096', '--mem-fraction-static', '0.8',
               '--max-running-requests', '24', '--max-mamba-cache-size', '120']
    if args.kind == 'deepseek41':
        environment['SGLANG_ENABLE_DSV41_ENGRAM_HOST_TABLE'] = '1'
        environment['SGLANG_DSV41_ENGRAM_HOST_TABLE_LAYOUT'] = 'shared'
        environment['SGLANG_DSV4_KV_LAYOUT'] = 'v41'
        environment['SGLANG_DSV4_COMPRESSED_KV_LAYOUT'] = 'auto'
        command = ['python', '-m', 'sglang.launch_server', '--model-path', str(args.model_path),
                   '--host', '127.0.0.1', '--port', str(args.port), '--dtype', 'bfloat16',
                   '--trust-remote-code', '--tp-size', '4', '--ep-size', '4',
                   '--moe-runner-backend', 'deep_gemm', '--moe-a2a-backend', 'none',
                   '--disable-shared-experts-fusion', '--disable-cuda-graph', '--disable-overlap-schedule',
                   '--cuda-graph-backend-prefill', 'disabled', '--chunked-prefill-size', '4096',
                   '--mem-fraction-static', '0.9', '--max-running-requests', '24', '--watchdog-timeout', '3600']
    model, revision = (('deepseek-ai/DeepSeek-V4.1-Flash', '5254448103b6254fc646dacbca1cbbf20e9216c1')
                       if args.kind == 'deepseek41' else
                       ('nvidia/Qwen3.8-Flash-Next-NVFP4', 'fc694b54fb0174e0913e6adf86691ef85a4ead47'))
    provenance = dict(model=model, model_revision=revision,
                      engine='SGLang', engine_version=importlib.metadata.version('sglang'),
                      server_command=command,
                      serving_environment={key: value for key, value in environment.items() if key.startswith('SGLANG_')},
                      agentx_dataset=fixture['dataset'],
                      agentx_revision=fixture['revision'],
                      prompt_reconstruction='Public AgentX hash blocks select deterministic spans of an authored code corpus; original prompt text is unavailable. Input IDs preserve exact recorded block lengths.',
                      fixture_sha256=hashlib.sha256((scripts / 'agentx_shapes.json').read_bytes()).hexdigest())
    if args.kind == 'deepseek41':
        provenance['engine_adapter'] = 'Pass actual dispatcher activation-group metadata to DeepGEMM; the pinned FP4-expert recipe otherwise hardcodes group 128 for group-32 activations. Tensor bytes and model architecture are unchanged.'
    (results / 'server.json').write_text(json.dumps(provenance, indent=2) + '\n')
    base = f'http://127.0.0.1:{args.port}'
    with (results / 'server.log').open('a') as log:
        server = subprocess.Popen(command, env=environment, stdout=log, stderr=subprocess.STDOUT,
                                  start_new_session=True)
        try:
            deadline = time.monotonic() + 1800
            while True:
                if server.poll() is not None:
                    raise RuntimeError(f'Serving exited {server.returncode}; see {results / "server.log"}')
                try:
                    if requests.get(base + '/health', timeout=5).ok:
                        break
                except requests.RequestException:
                    pass
                if time.monotonic() > deadline:
                    raise TimeoutError('Serving startup exceeded 1800 seconds')
                time.sleep(2)
            for label in selected:
                if label in overlaps:
                    group = overlaps[label]
                    requests.get(base + '/flush_cache', timeout=30).raise_for_status()
                    members = [dict(member, session_id=group['session_id']) for member in group['requests']]
                    payloads = [{'input_ids': make_input_ids(member, tokenizer),
                                 'sampling_params': {'temperature': 0, 'max_new_tokens': min(member['output_tokens'], args.max_output_tokens or member['output_tokens']), 'ignore_eos': True}}
                                for member in members]
                    receipt = dict(provenance, request_id=args.kind.replace('-', '_') + '_' + label,
                                   overlap_profile={key: value for key, value in group.items() if key != 'requests'},
                                   members=[{key: value for key, value in member.items() if key not in ('hash_ids', 'cache_predecessor')} for member in members],
                                   scheduling='Submit the observed overlapping requests together; record the actual engine batch, without claiming to reproduce their original timing.')
                    temporary = request_file.with_suffix('.tmp')
                    temporary.write_text(json.dumps(receipt)); temporary.replace(request_file)
                    (results / (label + '.request.json')).write_text(json.dumps(payloads) + '\n')
                    print('REQUEST', label, len(payloads), 'concurrent requests', flush=True)
                    def submit(payload):
                        started = time.time()
                        response = requests.post(base + '/generate', json=payload, timeout=5400)
                        response.raise_for_status()
                        return dict(started_at=started, finished_at=time.time(), response=response.json())
                    with concurrent.futures.ThreadPoolExecutor(max_workers=len(payloads)) as pool:
                        receipt['responses'] = list(pool.map(submit, payloads))
                    (results / (label + '.json')).write_text(json.dumps(receipt, indent=2) + '\n')
                    request_file.unlink(missing_ok=True)
                    print('COMPLETE', label, flush=True)
                    continue
                profile = profiles[label]
                requests.get(base + '/flush_cache', timeout=30).raise_for_status()
                predecessor = profile.get('cache_predecessor')
                if predecessor:
                    warm = dict(profile, **predecessor)
                    response = requests.post(base + '/generate', json={
                        'input_ids': make_input_ids(warm, tokenizer),
                        'sampling_params': {'temperature': 0, 'max_new_tokens': 1, 'ignore_eos': True},
                    }, timeout=3600)
                    response.raise_for_status()
                    (results / (label + '.warmup.json')).write_text(json.dumps(response.json()) + '\n')
                output_tokens = min(profile['output_tokens'], args.max_output_tokens or profile['output_tokens'])
                payload = {'input_ids': make_input_ids(profile, tokenizer),
                           'sampling_params': {'temperature': 0, 'max_new_tokens': output_tokens, 'ignore_eos': True}}
                receipt = dict(provenance, request_id=args.kind.replace('-', '_') + '_' + label,
                               agentx_profile={k: v for k, v in profile.items() if k not in ('hash_ids', 'cache_predecessor')},
                               actual_requested_output_tokens=output_tokens,
                               capture_decode_steps=sorted({0, 1, 2, 3, max(0, output_tokens//2-1), max(0, output_tokens-2)}),
                               input_ids_sha256=hashlib.sha256(json.dumps(payload['input_ids']).encode()).hexdigest(),
                               cache_predecessor_locator=predecessor['locator'] if predecessor else None)
                temporary = request_file.with_suffix('.tmp')
                temporary.write_text(json.dumps(receipt)); temporary.replace(request_file)
                (results / (label + '.request.json')).write_text(json.dumps(payload) + '\n')
                print('REQUEST', label, len(payload['input_ids']), output_tokens, flush=True)
                response = requests.post(base + '/generate', json=payload, timeout=5400)
                receipt.update(status_code=response.status_code, response=response.json() if response.ok else response.text)
                (results / (label + '.json')).write_text(json.dumps(receipt, indent=2) + '\n')
                response.raise_for_status()
                request_file.unlink(missing_ok=True)
                print('COMPLETE', label, flush=True)
        finally:
            request_file.unlink(missing_ok=True)
            if server.poll() is None:
                os.killpg(server.pid, signal.SIGTERM)
                try:
                    server.wait(timeout=30)
                except subprocess.TimeoutExpired:
                    os.killpg(server.pid, signal.SIGKILL)
                    server.wait()


if __name__ == '__main__':
    main()