#!/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()