scripts/capture_gpt_oss_model_trace.py

#!/usr/bin/env python3
"""
Capture one ChipWhisperer trace for a real GPT-OSS forward pass and save a
timeline that can be aligned to the ADC samples.

This script intentionally forces the sequential expert execution path by
replacing each GPT-OSS experts module forward() with an instrumented Python
loop that mirrors the stock transformers implementation.
"""

import argparse
import inspect
import json
import os
import random
import time
import types
from datetime import datetime
from pathlib import Path
from typing import Any

os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")

import numpy as np
import torch
import torch.nn.functional as F
from transformers import AutoModelForCausalLM, AutoTokenizer, Mxfp4Config

from train_classifier import ScopeConfig, configure_scope, connect_scope, ensure_dir, nvml_snapshot, set_seed


def now_stamp() -> str:
    return datetime.now().strftime("%Y%m%d_%H%M%S")


def _delay_ms(ms: float, mode: str = "busy") -> None:
    delay = float(ms)
    if delay <= 0.0:
        return
    if str(mode).lower() == "sleep":
        time.sleep(delay / 1000.0)
        return
    target = time.perf_counter() + delay / 1000.0
    while time.perf_counter() < target:
        pass


def _count_by_expert(router_indices: torch.Tensor, num_experts: int) -> list[int]:
    counts = torch.bincount(router_indices.reshape(-1).to(torch.int64), minlength=num_experts)
    return [int(x) for x in counts.cpu().tolist()]


def _resample_trace(trace: np.ndarray, target_len: int) -> np.ndarray:
    src = np.asarray(trace, dtype=np.float32)
    target_len = int(target_len)
    if target_len < 1:
        raise ValueError("target_len must be >= 1")
    if src.ndim != 1:
        raise ValueError("trace must be 1D")
    if src.shape[0] == target_len:
        return src.astype(np.float32, copy=True)
    if src.shape[0] == 1:
        return np.repeat(src.astype(np.float32), target_len)
    src_x = np.linspace(0.0, 1.0, num=src.shape[0], dtype=np.float64)
    dst_x = np.linspace(0.0, 1.0, num=target_len, dtype=np.float64)
    return np.interp(dst_x, src_x, src).astype(np.float32)


def _json_default(obj: Any):
    if isinstance(obj, (np.integer,)):
        return int(obj)
    if isinstance(obj, (np.floating,)):
        return float(obj)
    if isinstance(obj, np.ndarray):
        return obj.tolist()
    raise TypeError("Object of type {} is not JSON serializable".format(type(obj).__name__))


class TimelineRecorder:
    def __init__(self, scope_info: dict[str, Any] | None, trigger_delay_ms: float):
        self.scope_info = scope_info or {}
        self.trigger_delay_ms = float(trigger_delay_ms)
        self.adc_freq_effective = float(self.scope_info.get("adc_freq_effective", 0.0))
        self.pretrigger_ms_effective = float(self.scope_info.get("pretrigger_ms_effective", 0.0))
        self.events: list[dict[str, Any]] = []
        self.router_artifacts: dict[str, dict[str, Any]] = {}
        self.model_start_event: torch.cuda.Event | None = None
        self.model_end_event: torch.cuda.Event | None = None
        self.trigger_high_perf_ns: int | None = None
        self.model_start_enqueue_perf_ns: int | None = None
        self.current_phase = "uncaptured"
        self.current_decode_step: int | None = None

    def set_phase(self, phase: str, decode_step_idx: int | None = None) -> None:
        self.current_phase = str(phase)
        self.current_decode_step = None if decode_step_idx is None else int(decode_step_idx)

    def mark_trigger_high(self) -> None:
        self.trigger_high_perf_ns = time.perf_counter_ns()

    def mark_model_start(self, stream: torch.cuda.Stream) -> None:
        event = torch.cuda.Event(enable_timing=True)
        event.record(stream)
        self.model_start_event = event
        self.model_start_enqueue_perf_ns = time.perf_counter_ns()

    def mark_model_end(self, stream: torch.cuda.Stream) -> None:
        event = torch.cuda.Event(enable_timing=True)
        event.record(stream)
        self.model_end_event = event

    def event(
        self,
        name: str,
        *,
        stream: torch.cuda.Stream,
        layer_idx: int | None = None,
        expert_idx: int | None = None,
        **extra: Any,
    ) -> None:
        evt = torch.cuda.Event(enable_timing=True)
        evt.record(stream)
        rec = {
            "name": str(name),
            "phase": str(self.current_phase),
            "decode_step_idx": None if self.current_decode_step is None else int(self.current_decode_step),
            "layer_idx": None if layer_idx is None else int(layer_idx),
            "expert_idx": None if expert_idx is None else int(expert_idx),
            "enqueue_perf_counter_ns": int(time.perf_counter_ns()),
            "cuda_event": evt,
        }
        rec.update(extra)
        self.events.append(rec)

    def save_router(
        self,
        *,
        layer_idx: int,
        batch_size: int,
        seq_len: int,
        router_scores: torch.Tensor,
        router_indices: torch.Tensor,
        num_experts: int,
    ) -> None:
        top_k = int(router_indices.shape[-1])
        idx_reshaped = router_indices.reshape(batch_size, seq_len, top_k).detach().cpu().to(torch.int16)
        scores_reshaped = router_scores.reshape(batch_size, seq_len, top_k).detach().cpu().to(torch.float32)
        step_idx = -1 if self.current_decode_step is None else int(self.current_decode_step)
        key = "{}_step_{:03d}_layer_{:02d}".format(str(self.current_phase), step_idx, int(layer_idx))
        self.router_artifacts[key] = {
            "phase": str(self.current_phase),
            "decode_step_idx": None if self.current_decode_step is None else int(self.current_decode_step),
            "layer_idx": int(layer_idx),
            "batch_size": int(batch_size),
            "seq_len": int(seq_len),
            "top_k": int(top_k),
            "counts_by_expert": _count_by_expert(router_indices, num_experts),
            "router_indices": idx_reshaped,
            "router_scores": scores_reshaped,
        }

    def finalize(self) -> list[dict[str, Any]]:
        if self.model_start_event is None:
            raise RuntimeError("model start event was not recorded")
        finalized: list[dict[str, Any]] = []
        for rec in self.events:
            evt = rec.pop("cuda_event")
            cuda_ms_from_model_start = float(self.model_start_event.elapsed_time(evt))
            ms_from_trigger = float(self.trigger_delay_ms + cuda_ms_from_model_start)
            out = dict(rec)
            out["cuda_ms_from_model_start"] = cuda_ms_from_model_start
            out["ms_from_trigger"] = ms_from_trigger
            if self.adc_freq_effective > 0.0:
                out["trace_sample_index"] = int(
                    round((ms_from_trigger + self.pretrigger_ms_effective) * 1e-3 * self.adc_freq_effective)
                )
            else:
                out["trace_sample_index"] = None
            finalized.append(out)
        finalized.sort(
            key=lambda x: (
                float(x.get("cuda_ms_from_model_start", 0.0)),
                str(x.get("name", "")),
                -1 if x.get("layer_idx") is None else int(x["layer_idx"]),
            )
        )
        return finalized

    def model_elapsed_ms(self) -> float | None:
        if self.model_start_event is None or self.model_end_event is None:
            return None
        return float(self.model_start_event.elapsed_time(self.model_end_event))


class GptOssForwardInstrumentor:
    def __init__(self, model: torch.nn.Module, recorder: TimelineRecorder):
        self.model = model
        self.recorder = recorder
        self.hooks = []
        self.original_forwards: list[tuple[torch.nn.Module, Any]] = []

    def install(self) -> None:
        for layer_idx, layer in enumerate(self.model.model.layers):
            self.hooks.append(layer.register_forward_pre_hook(self._make_layer_pre_hook(layer_idx), prepend=True))
            self.hooks.append(layer.register_forward_hook(self._make_layer_post_hook(layer_idx)))
            self._patch_mlp(layer.mlp, layer_idx)
            self._patch_experts(layer.mlp.experts, layer_idx)

    def remove(self) -> None:
        for handle in self.hooks:
            handle.remove()
        self.hooks.clear()
        for module, orig_forward in reversed(self.original_forwards):
            module.forward = orig_forward
        self.original_forwards.clear()

    def _make_layer_pre_hook(self, layer_idx: int):
        def hook(module, inputs):
            self.recorder.event("decoder_layer_start", stream=torch.cuda.current_stream(), layer_idx=layer_idx)

        return hook

    def _make_layer_post_hook(self, layer_idx: int):
        def hook(module, inputs, output):
            self.recorder.event("decoder_layer_end", stream=torch.cuda.current_stream(), layer_idx=layer_idx)

        return hook

    def _patch_module_forward(self, module: torch.nn.Module, fn) -> None:
        self.original_forwards.append((module, module.forward))
        module.forward = types.MethodType(fn, module)

    def _patch_mlp(self, mlp: torch.nn.Module, layer_idx: int) -> None:
        recorder = self.recorder

        def patched_forward(this, hidden_states):
            batch_size, seq_len, hidden_dim = hidden_states.shape
            hidden_states_flat = hidden_states.reshape(-1, hidden_dim)
            stream = torch.cuda.current_stream()

            recorder.event("mlp_router_start", stream=stream, layer_idx=layer_idx)
            _, router_scores, router_indices = this.router(hidden_states_flat)
            recorder.event("mlp_router_end", stream=stream, layer_idx=layer_idx)
            recorder.save_router(
                layer_idx=layer_idx,
                batch_size=int(batch_size),
                seq_len=int(seq_len),
                router_scores=router_scores,
                router_indices=router_indices,
                num_experts=int(this.experts.num_experts),
            )

            recorder.event("moe_block_start", stream=stream, layer_idx=layer_idx)
            hidden_states_flat = this.experts(hidden_states_flat, router_indices, router_scores)
            recorder.event("moe_block_end", stream=stream, layer_idx=layer_idx)

            hidden_states_out = hidden_states_flat.reshape(batch_size, seq_len, hidden_dim)
            return hidden_states_out, router_scores

        self._patch_module_forward(mlp, patched_forward)

    def _patch_experts(self, experts: torch.nn.Module, layer_idx: int) -> None:
        recorder = self.recorder

        def patched_forward(this, hidden_states: torch.Tensor, router_indices=None, routing_weights=None):
            stream = torch.cuda.current_stream()
            recorder.event("experts_loop_start", stream=stream, layer_idx=layer_idx)

            next_states = torch.zeros_like(hidden_states, dtype=hidden_states.dtype, device=hidden_states.device)
            with torch.no_grad():
                expert_mask = F.one_hot(router_indices, num_classes=this.num_experts)
                expert_mask = expert_mask.permute(2, 1, 0)
                expert_hit = torch.greater(expert_mask.sum(dim=(-1, -2)), 0).nonzero()

            hit_list = [int(x[0].item()) for x in expert_hit if int(x[0].item()) != int(this.num_experts)]
            recorder.event(
                "experts_hitlist_ready",
                stream=stream,
                layer_idx=layer_idx,
                hit_experts=hit_list,
                num_hit_experts=len(hit_list),
            )

            for loop_order, expert_idx_t in enumerate(expert_hit):
                expert_idx = int(expert_idx_t[0].item())
                if expert_idx == int(this.num_experts):
                    continue

                top_k_pos, token_idx = torch.where(expert_mask[expert_idx])
                recorder.event(
                    "expert_start",
                    stream=stream,
                    layer_idx=layer_idx,
                    expert_idx=expert_idx,
                    loop_order=int(loop_order),
                    token_count=int(token_idx.numel()),
                    topk_hits=int(top_k_pos.numel()),
                )

                current_state = hidden_states[token_idx]

                recorder.event("gate_up_start", stream=stream, layer_idx=layer_idx, expert_idx=expert_idx)
                gate_up = current_state @ this.gate_up_proj[expert_idx] + this.gate_up_proj_bias[expert_idx]
                recorder.event("gate_up_end", stream=stream, layer_idx=layer_idx, expert_idx=expert_idx)

                recorder.event("swiglu_start", stream=stream, layer_idx=layer_idx, expert_idx=expert_idx)
                gated_output = this._apply_gate(gate_up)
                recorder.event("swiglu_end", stream=stream, layer_idx=layer_idx, expert_idx=expert_idx)

                recorder.event("down_proj_start", stream=stream, layer_idx=layer_idx, expert_idx=expert_idx)
                out = gated_output @ this.down_proj[expert_idx] + this.down_proj_bias[expert_idx]
                recorder.event("down_proj_end", stream=stream, layer_idx=layer_idx, expert_idx=expert_idx)

                recorder.event("expert_accum_start", stream=stream, layer_idx=layer_idx, expert_idx=expert_idx)
                weighted_output = out * routing_weights[token_idx, top_k_pos, None]
                next_states.index_add_(0, token_idx, weighted_output.to(hidden_states.dtype))
                recorder.event("expert_end", stream=stream, layer_idx=layer_idx, expert_idx=expert_idx)

            recorder.event("experts_loop_end", stream=stream, layer_idx=layer_idx)
            return next_states

        self._patch_module_forward(experts, patched_forward)


def parse_args():
    p = argparse.ArgumentParser(description="Capture a real GPT-OSS model forward with synchronized power trace")
    p.add_argument("--model-name", default="openai/gpt-oss-20b")
    p.add_argument("--run-root", default="model_trace_runs")
    p.add_argument("--run-name", default="")
    p.add_argument("--seed", type=int, default=7)

    p.add_argument("--prompt", default="The capital of Georgia is")
    p.add_argument("--prompt-file", default="")
    p.add_argument("--repeat-prompt", type=int, default=32)
    p.add_argument("--max-input-tokens", type=int, default=256)
    p.add_argument("--capture-phase", choices=["prefill", "decode", "both"], default="decode")
    p.add_argument("--decode-steps", type=int, default=1)
    p.add_argument(
        "--decode-warmup-steps",
        type=int,
        default=0,
        help="Run uncaptured decode steps after prefill and before arming the scope",
    )

    p.add_argument("--capture-ms", type=float, default=120.0)
    p.add_argument(
        "--decode-ms-budget-per-step",
        type=float,
        default=75.0,
        help="Used only when --capture-ms <= 0 to auto-size a continuous decode capture",
    )
    p.add_argument(
        "--capture-margin-ms",
        type=float,
        default=250.0,
        help="Extra margin added when auto-sizing capture_ms for continuous decode",
    )
    p.add_argument("--gain-db", type=float, default=10.0)
    p.add_argument("--clkgen-freq", type=float, default=150e6)
    p.add_argument("--pretrigger-ms", type=float, default=0.0)
    p.add_argument("--scope-stream", action="store_true")
    p.add_argument("--scope-stream-target-msps", type=float, default=20.0)
    p.add_argument("--scope-adc-bits-per-sample", type=int, choices=[8, 12], default=12)
    p.add_argument("--scope-stream-segment-size", type=int, default=65536)
    p.add_argument("--scope-stream-segment-threshold", type=int, default=65536)
    p.add_argument("--trigger-delay-ms", type=float, default=0.2)
    p.add_argument("--trigger-delay-mode", choices=["busy", "sleep"], default="busy")
    p.add_argument("--warmup-forwards", type=int, default=2)
    p.add_argument("--base-feature-len-per-10ms", type=int, default=16384)
    p.add_argument("--save-trace-dtype", choices=["float32", "float16"], default="float32")
    p.add_argument("--save-resampled-trace", action="store_true")
    p.add_argument("--no-save-resampled-trace", dest="save_resampled_trace", action="store_false")

    p.add_argument("--no-scope", action="store_true", help="Run the model and save timings without ChipWhisperer")
    p.add_argument("--save-logits", action="store_true")
    p.set_defaults(save_resampled_trace=True)
    return p.parse_args()


def resolve_capture_ms(args) -> float:
    requested = float(args.capture_ms)
    if requested > 0.0:
        return requested
    if str(args.capture_phase) not in ("decode", "both"):
        raise ValueError("--capture-ms must be > 0 unless decode is part of the captured phase")
    decode_budget = float(args.decode_ms_budget_per_step) * max(1, int(args.decode_steps))
    total = decode_budget + float(args.capture_margin_ms)
    if str(args.capture_phase) == "both":
        total += max(100.0, 0.5 * decode_budget)
    return total


def load_prompt_text(args) -> str:
    if args.prompt_file:
        return Path(args.prompt_file).read_text()
    return str(args.prompt)


def build_inputs(tokenizer, prompt_text: str, max_input_tokens: int) -> dict[str, torch.Tensor]:
    encoded = tokenizer(prompt_text, return_tensors="pt", truncation=True, max_length=int(max_input_tokens))
    return {k: v for k, v in encoded.items()}


def _ones_column_like(mask: torch.Tensor) -> torch.Tensor:
    return torch.ones((mask.shape[0], 1), device=mask.device, dtype=mask.dtype)


def _argmax_next_token(outputs) -> torch.Tensor:
    return outputs.logits[:, -1:].argmax(dim=-1)


def run_prefill(model, inputs_gpu: dict[str, torch.Tensor]) -> tuple[Any, float]:
    start = torch.cuda.Event(enable_timing=True)
    end = torch.cuda.Event(enable_timing=True)
    start.record()
    outputs = model(**inputs_gpu, use_cache=True)
    end.record()
    end.synchronize()
    return outputs, float(start.elapsed_time(end))


def save_run_outputs(
    run_dir: Path,
    *,
    args,
    trace: np.ndarray | None,
    scope_capture_call_ms: float | None,
    trace_extract_ms: float | None,
    scope_info: dict[str, Any] | None,
    recorder: TimelineRecorder,
    prompt_text: str,
    inputs_cpu: dict[str, torch.Tensor],
    outputs,
    model_name: str,
    sequential_source: str,
    gpu_before: dict[str, Any] | None,
    gpu_after: dict[str, Any] | None,
    prefill_summary: dict[str, Any] | None,
    decode_summary: dict[str, Any] | None,
) -> None:
    ensure_dir(run_dir)

    resampled_trace = None
    resampled_len = None
    resample_capture_ms = None
    if trace is not None:
        trace_dtype = np.float16 if str(args.save_trace_dtype) == "float16" else np.float32
        np.save(run_dir / "trace.npy", trace.astype(trace_dtype))
        if bool(args.save_resampled_trace):
            if scope_info is not None and scope_info.get("capture_ms_effective") is not None:
                resample_capture_ms = float(scope_info["capture_ms_effective"])
            else:
                resample_capture_ms = float(getattr(args, "capture_ms_resolved", args.capture_ms))
            resampled_len = int(round(float(args.base_feature_len_per_10ms) * resample_capture_ms / 10.0))
            resampled_len = max(1, resampled_len)
            resampled_trace = _resample_trace(trace, resampled_len)
            np.save(run_dir / "trace_resampled.npy", resampled_trace)

    (run_dir / "prompt.txt").write_text(prompt_text)
    torch.save(inputs_cpu, run_dir / "inputs.pt")
    torch.save(recorder.router_artifacts, run_dir / "expert_selections.pt")

    timeline = recorder.finalize()
    with (run_dir / "timeline.json").open("w") as f:
        json.dump(timeline, f, indent=2, default=_json_default)

    logits_summary = None
    if outputs is not None and hasattr(outputs, "logits"):
        last_logits = outputs.logits[:, -1, :].detach().float().cpu()
        top_vals, top_idx = torch.topk(last_logits, k=min(10, last_logits.shape[-1]), dim=-1)
        logits_summary = {
            "last_token_top_ids": [[int(x) for x in row] for row in top_idx.tolist()],
            "last_token_top_vals": [[float(x) for x in row] for row in top_vals.tolist()],
        }
        torch.save({"last_token_logits": last_logits}, run_dir / "outputs.pt")

    meta = {
        "created_at": datetime.now().isoformat(),
        "model_name": str(model_name),
        "sequential_experts_mode": "instrumented_python_loop",
        "sequential_experts_verified_from_source": bool("for expert_idx in expert_hit" in sequential_source),
        "scope": scope_info,
        "scope_capture_call_ms": scope_capture_call_ms,
        "trace_extract_ms": trace_extract_ms,
        "trace_saved": trace is not None,
        "trace_saved_dtype": str(args.save_trace_dtype) if trace is not None else None,
        "raw_trace_len": None if trace is None else int(trace.shape[0]),
        "resampled_trace_len": None if resampled_trace is None else int(resampled_trace.shape[0]),
        "resample_capture_ms": resample_capture_ms,
        "save_resampled_trace": bool(args.save_resampled_trace),
        "base_feature_len_per_10ms": int(args.base_feature_len_per_10ms),
        "capture_ms_requested": float(args.capture_ms),
        "capture_ms_resolved": float(getattr(args, "capture_ms_resolved", args.capture_ms)),
        "capture_phase": str(args.capture_phase),
        "decode_steps_requested": int(args.decode_steps),
        "decode_warmup_steps": int(args.decode_warmup_steps),
        "trigger_delay_ms": float(args.trigger_delay_ms),
        "trigger_delay_mode": str(args.trigger_delay_mode),
        "prompt_chars": int(len(prompt_text)),
        "repeat_prompt": int(args.repeat_prompt),
        "max_input_tokens": int(args.max_input_tokens),
        "input_shape": {k: list(v.shape) for k, v in inputs_cpu.items()},
        "gpu_before": gpu_before,
        "gpu_after": gpu_after,
        "prefill": prefill_summary,
        "decode": decode_summary,
        "model_elapsed_ms": recorder.model_elapsed_ms(),
        "timeline_event_count": int(len(timeline)),
        "router_artifact_count": int(len(recorder.router_artifacts)),
        "router_summary": {
            key: {
                "phase": str(layer_data["phase"]),
                "decode_step_idx": layer_data["decode_step_idx"],
                "layer_idx": int(layer_data["layer_idx"]),
                "seq_len": int(layer_data["seq_len"]),
                "top_k": int(layer_data["top_k"]),
                "counts_by_expert": layer_data["counts_by_expert"],
            }
            for key, layer_data in recorder.router_artifacts.items()
        },
        "logits_summary": logits_summary,
    }

    with (run_dir / "capture_meta.json").open("w") as f:
        json.dump(meta, f, indent=2, default=_json_default)


def main():
    args = parse_args()
    args.capture_ms_resolved = float(resolve_capture_ms(args))
    set_seed(int(args.seed))
    if args.capture_phase in ("decode", "both") and int(args.decode_steps) < 1:
        raise ValueError("--decode-steps must be >= 1 when capture phase includes decode")
    if int(args.decode_warmup_steps) < 0:
        raise ValueError("--decode-warmup-steps must be >= 0")
    if args.capture_phase != "decode" and int(args.decode_warmup_steps) > 0:
        raise ValueError("--decode-warmup-steps is only supported with --capture-phase decode")

    prompt_text = load_prompt_text(args)
    prompt_text = " ".join([prompt_text] * max(1, int(args.repeat_prompt)))

    run_name = str(args.run_name).strip() or "gpt_oss_model_trace_{}".format(now_stamp())
    run_dir = Path(args.run_root).expanduser().resolve() / run_name
    ensure_dir(run_dir)

    scope = None
    scope_info = None
    if not bool(args.no_scope):
        scope = connect_scope()
        scope_info = configure_scope(
            scope,
            ScopeConfig(
                capture_ms=float(args.capture_ms_resolved),
                gain_db=float(args.gain_db),
                clkgen_freq=float(args.clkgen_freq),
                pretrigger_ms=float(args.pretrigger_ms),
                stream_mode=bool(args.scope_stream),
                stream_target_msps=float(args.scope_stream_target_msps),
                adc_bits_per_sample=int(args.scope_adc_bits_per_sample),
                stream_segment_size=int(args.scope_stream_segment_size),
                stream_segment_threshold=int(args.scope_stream_segment_threshold),
            ),
        )

    tokenizer = AutoTokenizer.from_pretrained(args.model_name)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    model = AutoModelForCausalLM.from_pretrained(
        args.model_name,
        device_map=torch.cuda.current_device(),
        quantization_config=Mxfp4Config(dequantize=True),
    )
    model.eval()

    sequential_source = inspect.getsource(type(model.model.layers[0].mlp.experts).forward)
    inputs_cpu = build_inputs(tokenizer, prompt_text, max_input_tokens=int(args.max_input_tokens))
    inputs_gpu = {k: v.to("cuda") for k, v in inputs_cpu.items()}
    if "attention_mask" not in inputs_gpu:
        inputs_gpu["attention_mask"] = torch.ones_like(inputs_gpu["input_ids"])

    with torch.inference_mode():
        for _ in range(max(0, int(args.warmup_forwards))):
            _ = model(**inputs_gpu, use_cache=False)
        torch.cuda.synchronize()

    recorder = TimelineRecorder(scope_info=scope_info, trigger_delay_ms=float(args.trigger_delay_ms))
    instrumentor = GptOssForwardInstrumentor(model, recorder)

    run_stream = torch.cuda.Stream()
    outputs = None
    trace = None
    capture_ret = None
    scope_capture_call_ms = None
    trace_extract_ms = None
    gpu_before = nvml_snapshot(0)
    prefill_summary = None
    decode_summary = {
        "captured_in_trace": bool(args.capture_phase in ("decode", "both")),
        "steps": [],
    }
    prefill_outputs = None
    past_key_values = None
    next_token = None
    decode_attention_mask = inputs_gpu["attention_mask"]

    if args.capture_phase == "decode":
        with torch.inference_mode():
            prefill_outputs, prefill_ms = run_prefill(model, inputs_gpu)
        past_key_values = prefill_outputs.past_key_values
        next_token = _argmax_next_token(prefill_outputs)
        prefill_summary = {
            "executed_before_capture": True,
            "captured_in_trace": False,
            "gpu_elapsed_ms": float(prefill_ms),
            "input_token_count": int(inputs_gpu["input_ids"].shape[-1]),
            "next_token_ids": [[int(x) for x in row] for row in next_token.detach().cpu().tolist()],
        }
        warmup_steps = int(args.decode_warmup_steps)
        if warmup_steps:
            with torch.inference_mode(), torch.cuda.stream(run_stream):
                for _ in range(warmup_steps):
                    decode_attention_mask = torch.cat(
                        [decode_attention_mask, _ones_column_like(decode_attention_mask)], dim=1
                    )
                    warm_outputs = model(
                        input_ids=next_token,
                        attention_mask=decode_attention_mask,
                        past_key_values=past_key_values,
                        use_cache=True,
                    )
                    next_token = _argmax_next_token(warm_outputs)
                    past_key_values = warm_outputs.past_key_values
            run_stream.synchronize()
            prefill_summary["decode_warmup_steps_before_capture"] = warmup_steps
            prefill_summary["next_token_ids_after_warmup"] = [
                [int(x) for x in row] for row in next_token.detach().cpu().tolist()
            ]

    instrumentor.install()

    try:
        if scope is not None:
            try:
                scope.sc.setFastSMC(0)
            except Exception:
                try:
                    scope.sc._fast_fifo_read_active = False
                except Exception:
                    pass

            scope.io.tio4 = "gpio_low"
            scope.arm()
            _delay_ms(1.0, mode=args.trigger_delay_mode)
            scope.io.tio4 = "gpio_high"
            recorder.mark_trigger_high()
            _delay_ms(float(args.trigger_delay_ms), mode=args.trigger_delay_mode)
        else:
            recorder.mark_trigger_high()

        with torch.inference_mode(), torch.cuda.stream(run_stream):
            recorder.mark_model_start(run_stream)

            if args.capture_phase in ("prefill", "both"):
                recorder.set_phase("prefill")
                recorder.event("prefill_start", stream=run_stream)
                outputs = model(**inputs_gpu, use_cache=True)
                recorder.event("prefill_end", stream=run_stream)
                prefill_summary = {
                    "executed_before_capture": False,
                    "captured_in_trace": True,
                    "input_token_count": int(inputs_gpu["input_ids"].shape[-1]),
                }
                past_key_values = outputs.past_key_values
                next_token = _argmax_next_token(outputs)
                if args.capture_phase == "prefill":
                    decode_summary["captured_in_trace"] = False

            if args.capture_phase in ("decode", "both"):
                if past_key_values is None or next_token is None:
                    raise RuntimeError("decode capture requested but KV cache was not prepared")
                for step_idx in range(int(args.decode_steps)):
                    recorder.set_phase("decode", step_idx)
                    recorder.event(
                        "decode_step_start",
                        stream=run_stream,
                        decode_input_token_ids=[[int(x) for x in row] for row in next_token.detach().cpu().tolist()],
                    )
                    decode_attention_mask = torch.cat(
                        [decode_attention_mask, _ones_column_like(decode_attention_mask)], dim=1
                    )
                    outputs = model(
                        input_ids=next_token,
                        attention_mask=decode_attention_mask,
                        past_key_values=past_key_values,
                        use_cache=True,
                    )
                    recorder.event("decode_step_end", stream=run_stream)
                    step_record = {
                        "step_idx": int(step_idx),
                        "input_token_ids": [[int(x) for x in row] for row in next_token.detach().cpu().tolist()],
                    }
                    next_token = _argmax_next_token(outputs)
                    step_record["next_token_ids"] = [[int(x) for x in row] for row in next_token.detach().cpu().tolist()]
                    decode_summary["steps"].append(step_record)
                    past_key_values = outputs.past_key_values

            recorder.set_phase("captured")
            recorder.event("captured_segment_end", stream=run_stream)
            recorder.mark_model_end(run_stream)

        if scope is not None:
            capture_t0 = time.perf_counter()
            capture_ret = scope.capture(poll_done=not bool(scope_info.get("stream_mode", False)))
            scope_capture_call_ms = 1000.0 * (time.perf_counter() - capture_t0)
        run_stream.synchronize()

        if scope is not None:
            if capture_ret:
                raise RuntimeError("ChipWhisperer capture timed out (no trigger?)")
            extract_t0 = time.perf_counter()
            trace = np.array(scope.get_last_trace(), dtype=np.float32)
            trace_extract_ms = 1000.0 * (time.perf_counter() - extract_t0)
    finally:
        if scope is not None:
            try:
                scope.io.tio4 = "gpio_low"
            except Exception:
                pass
        instrumentor.remove()

    save_run_outputs(
        run_dir,
        args=args,
        trace=trace,
        scope_capture_call_ms=scope_capture_call_ms,
        trace_extract_ms=trace_extract_ms,
        scope_info=scope_info,
        recorder=recorder,
        prompt_text=prompt_text,
        inputs_cpu=inputs_cpu,
        outputs=outputs if bool(args.save_logits) else None,
        model_name=args.model_name,
        sequential_source=sequential_source,
        gpu_before=gpu_before,
        gpu_after=nvml_snapshot(0),
        prefill_summary=prefill_summary,
        decode_summary=decode_summary,
    )

    summary_capture_ms = float(args.capture_ms_resolved)
    if scope_info is not None and scope_info.get("capture_ms_effective") is not None:
        summary_capture_ms = float(scope_info["capture_ms_effective"])
    capture_summary = {
        "run_dir": str(run_dir),
        "trace_saved": trace is not None,
        "trace_len": None if trace is None else int(trace.shape[0]),
        "resampled_trace_len": None
        if trace is None or not bool(args.save_resampled_trace)
        else int(round(float(args.base_feature_len_per_10ms) * summary_capture_ms / 10.0)),
        "model_elapsed_ms": recorder.model_elapsed_ms(),
        "gpu_before": gpu_before,
        "gpu_after": nvml_snapshot(0),
    }
    print(json.dumps(capture_summary, indent=2, default=_json_default), flush=True)


if __name__ == "__main__":
    main()