tools/sass_dataloader_stub.py

#!/usr/bin/env python3
"""
SASS-augmented trace dataloader stub.

Cross-attention architecture: trace queries, SASS keys/values -> per-timestep
features.

This stub is the data-side contract for that architecture. It loads
`tensor_input.npz` (the [24, T] ViT input) and `sass_modality.npz` (per-kernel
[N_pc, F] SASS matrices) for a single motif and yields the tensors a future
torch `nn.Module` would consume. No torch dependency — this host is CPU-only
and torch isn't installed; the same shapes carry over to PyTorch one-to-one.

Shape contract per sample:

  trace_input          : float32 [C=24, T=512]              ViT input image
  regime_family        : float32 [T=512, F=4]               per-bin one-hot family
  subregime            : float32 [T=512, Z=20]              multi-hot within family
  structural           : float32 [T=512, K=17]              per-kernel structural attrs
  boundaries           : float32 [T=512]                    Gaussian-smoothed transition target
  gt_segments          : list[(start, end, fam, sub[20], struct[17])]  TAS transcript
  workload_l1          : int64   [T=512]                    per-bin single L1 id (-1 idle)
  workload_l2          : int64   [T=512]                    per-bin single L2 id (-1 idle)
  workload_l1_multihot : float32 [T=512, 12]                per-bin multi-hot L1 (overlap)
  workload_l2_multihot : float32 [T=512, 73]                per-bin multi-hot L2 (overlap)
  multihot_n_active    : float32 [T=512]                    # concurrent L1 classes per bin
  mask_any             : float32 [T=512]                    1 = some kernel runs
  bin_kernel_id        : int64   [T=512]                    which kernel (-1 = idle)
  sass_matrix          : float32 [K, N_pc_max, F=9]         per-kernel SASS, padded
  sass_pc_mask         : float32 [K, N_pc_max]              1 on real PCs, 0 on pad

Cross-attention wiring (forward-pass pseudocode in the docstring below):
  Q = trace_patch_embeddings              [B, S_q, d]   from the ViT trunk
  K = sass_proj(sass_matrix[bin_k])       [B, N_pc, d]  per-bin kernel lookup
  V = sass_proj(sass_matrix[bin_k])       [B, N_pc, d]
  attn = softmax(Q K^T / sqrt(d)) * sass_pc_mask
  out  = attn @ V                         [B, S_q, d]

The per-bin kernel index is the bridge between the time grid (from nsys
kernel_intervals) and the SASS matrix store (per-kernel-function). For
unprofiled bins (`bin_kernel_id == -1`) the convention is to set Q's attention
output to zero — i.e. the trace-only path is preserved when SASS isn't
applicable.

Usage:
  python tools/sass_dataloader_stub.py kernels/vector_add/_out
"""

from __future__ import annotations

import argparse
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Optional

import numpy as np


@dataclass
class SASSSample:
    """One motif's worth of data, in the shape a SASS-augmented ViT consumes."""

    trace_input: np.ndarray      # float32 [C, T]   — tensor_input.npz `data`
    counter_names: list[str]
    time_edges_ns: np.ndarray    # int64   [T+1]
    regime_family: Optional[np.ndarray]            # float32 [T, F=4]
    regime_family_names: Optional[list[str]]
    subregime: Optional[np.ndarray]                # float32 [T, Z=20]
    subregime_names: Optional[list[str]]
    subregime_family_idx: Optional[np.ndarray]     # int64   [Z]
    structural: Optional[np.ndarray]               # float32 [T, K=17]
    structural_names: Optional[list[str]]
    boundaries: Optional[np.ndarray]               # float32 [T]
    gt_segments: Optional[np.ndarray]              # object [S] of 5-tuples
    mask_any: Optional[np.ndarray]                 # float32 [T]
    mask_profiled: Optional[np.ndarray]            # float32 [T]
    # Single-label + additive multi-hot (overlapping-label) workload targets.
    workload_l1: Optional[np.ndarray]              # int64   [T]   (-1 = unlabeled)
    workload_l2: Optional[np.ndarray]              # int64   [T]   (-1 = unlabeled)
    workload_l1_multihot: Optional[np.ndarray]     # float32 [T, 12]  multi-label head target
    workload_l2_multihot: Optional[np.ndarray]     # float32 [T, 73]
    multihot_n_active: Optional[np.ndarray]        # float32 [T]   # concurrent L1 classes
    mask_multilabel: Optional[np.ndarray]          # float32 [T]   1 where >=1 class active
    vocab_l1: Optional[list[str]]
    vocab_l2: Optional[list[str]]
    bin_kernel_id: np.ndarray    # int64   [T]      — -1 for idle bins
    sass_matrix: np.ndarray      # float32 [K, N_pc_max, F]
    sass_pc_mask: np.ndarray     # float32 [K, N_pc_max]
    sass_column_names: list[str]
    sass_kernel_names: list[str]  # length K (functions, demangled)


def _bin_kernel_index(time_edges_ns: np.ndarray,
                      kernels: np.ndarray) -> np.ndarray:
    """For each time bin, return the index (into `kernels`) of the kernel that
    overlaps the bin's center, or -1 if no kernel overlaps.

    Bins are half-open [edges[t], edges[t+1]); kernel intervals are inclusive.
    """
    if kernels.size == 0:
        return np.full(time_edges_ns.shape[0] - 1, -1, dtype=np.int64)
    centers = (time_edges_ns[:-1] + time_edges_ns[1:]) // 2
    starts = kernels[:, 0]
    ends = kernels[:, 1]
    idx = np.clip(np.searchsorted(starts, centers, side="right") - 1,
                  0, len(kernels) - 1)
    inside = (centers >= starts[idx]) & (centers <= ends[idx])
    return np.where(inside, idx, -1).astype(np.int64)


def _bin_kernel_function_index(
    bin_kernel_id: np.ndarray, kernels: np.ndarray,
    sass_kernel_names: list[str],
    nsys_kernel_names: Optional[list[str]],
    launch_function_index: Optional[np.ndarray] = None,
) -> np.ndarray:
    """Map per-bin kernel-launch index -> per-bin kernel-function index.

    SASS matrices are keyed by kernel *function*, not by individual launch.
    Two precomputed inputs let us avoid the legacy "function-0 for every
    active bin" fallback on heterogeneous traces:
      - `launch_function_index[K]`: the per-launch function index already
        baked into `tensor_input.npz` (post-migration). When present, every
        active bin's index is just a gather from this array.
      - `nsys_kernel_names[K]`: per-launch mangled name, used to compute the
        function index from `sass_kernel_names` when no precomputed index is
        attached.
    Final fallback: function-0 for every active bin.
    """
    T = bin_kernel_id.shape[0]
    out = np.full(T, -1, dtype=np.int64)
    if not sass_kernel_names:
        return out
    if launch_function_index is not None and len(launch_function_index) > 0:
        active = bin_kernel_id >= 0
        if active.any():
            out[active] = launch_function_index[bin_kernel_id[active]]
        return out
    if nsys_kernel_names is None:
        out[bin_kernel_id >= 0] = 0
        return out
    name_to_fn = {n: i for i, n in enumerate(sass_kernel_names)}
    for t in range(T):
        k = int(bin_kernel_id[t])
        if k < 0 or k >= len(nsys_kernel_names):
            continue
        out[t] = name_to_fn.get(nsys_kernel_names[k], -1)
    return out


def _pad_sass_matrices(matrices: list[np.ndarray]) -> tuple[np.ndarray, np.ndarray]:
    """Stack per-kernel [N_pc_k, F] matrices into one padded [K, N_pc_max, F].

    Returns (sass_matrix, sass_pc_mask).
    """
    if not matrices:
        return (np.zeros((0, 0, 0), dtype=np.float32),
                np.zeros((0, 0), dtype=np.float32))
    F = matrices[0].shape[1]
    N_pc_max = max(M.shape[0] for M in matrices)
    K = len(matrices)
    out = np.zeros((K, N_pc_max, F), dtype=np.float32)
    mask = np.zeros((K, N_pc_max), dtype=np.float32)
    for k, M in enumerate(matrices):
        out[k, :M.shape[0]] = M.astype(np.float32)
        mask[k, :M.shape[0]] = 1.0
    return out, mask


def load_motif(out_dir: Path) -> SASSSample:
    """Load tensor_input + (optional) labels + sass_modality for one motif."""
    tin_path = out_dir / "input" / "tensor_input.npz"
    sass_path = out_dir / "sass" / "sass_modality.npz"
    if not tin_path.exists():
        raise FileNotFoundError(tin_path)
    if not sass_path.exists():
        raise FileNotFoundError(sass_path)

    tin = np.load(tin_path, allow_pickle=True)
    trace_input = tin["data"].astype(np.float32)
    counter_names = list(tin["counter_names"])
    edges = tin["time_edges_ns"].astype(np.int64)
    kernels = tin["kernels"].astype(np.int64)
    nsys_kernel_names = (
        list(tin["kernel_names"]) if "kernel_names" in tin.files else None
    )
    launch_function_index = (
        tin["kernel_function_index"].astype(np.int64)
        if "kernel_function_index" in tin.files else None
    )

    labels_path = out_dir / "labels" / "labels.npz"
    regime_family = subregime = structural = None
    regime_family_names = subregime_names = structural_names = None
    subregime_family_idx = None
    boundaries = None
    gt_segments = None
    mask_any = mask_prof = None
    workload_l1 = workload_l2 = None
    workload_l1_multihot = workload_l2_multihot = None
    multihot_n_active = mask_multilabel = None
    vocab_l1 = vocab_l2 = None
    if labels_path.exists():
        lab = np.load(labels_path, allow_pickle=True)
        # Every label key is loaded present-aware so the loader works across
        # the schema's additive evolution: a labels.npz that lacks a key
        # leaves the corresponding target None instead of raising.
        def _opt(key, cast=None):
            if key not in lab.files:
                return None
            v = lab[key]
            return v.astype(cast) if cast is not None else v

        regime_family = _opt("regime_family", np.float32)
        regime_family_names = list(lab["regime_family_names"]) \
            if "regime_family_names" in lab.files else None
        subregime = _opt("subregime", np.float32)
        subregime_names = list(lab["subregime_names"]) \
            if "subregime_names" in lab.files else None
        subregime_family_idx = _opt("subregime_family_idx", np.int64)
        structural = _opt("structural", np.float32)
        structural_names = list(lab["structural_names"]) \
            if "structural_names" in lab.files else None
        mask_any = _opt("mask_any_kernel", np.float32)
        mask_prof = _opt("mask_profiled", np.float32)
        boundaries = _opt("boundaries", np.float32)
        if "gt_segments" in lab.files:
            gt_segments = lab["gt_segments"]

        # Single-label workload ids (the existing softmax-head targets).
        workload_l1 = _opt("workload_l1", np.int64)
        workload_l2 = _opt("workload_l2", np.int64)
        # Additive multi-hot (overlapping-label) tracks — the sigmoid /
        # multi-label head targets. float32 so they drop straight into a
        # BCEWithLogits loss. For the sequential corpus these are the one-hot
        # of workload_l{1,2}; in genuinely fused traces (e.g. a warp-
        # specialized GEMM) a bin can carry >=2 active classes.
        workload_l1_multihot = _opt("workload_l1_multihot", np.float32)
        workload_l2_multihot = _opt("workload_l2_multihot", np.float32)
        multihot_n_active = _opt("multihot_n_active", np.float32)
        if multihot_n_active is not None:
            # multi-label analog of mask_labeled: 1 where >=1 class is active.
            mask_multilabel = (multihot_n_active > 0).astype(np.float32)
        vocab_l1 = list(lab["vocab_l1"]) if "vocab_l1" in lab.files else None
        vocab_l2 = list(lab["vocab_l2"]) if "vocab_l2" in lab.files else None

    sass = np.load(sass_path, allow_pickle=True)
    sass_matrices = [np.asarray(m) for m in sass["matrices"]]
    sass_kernel_names = list(sass["kernel_names"])
    sass_column_names = list(sass["column_names"])
    sass_matrix, sass_pc_mask = _pad_sass_matrices(sass_matrices)

    launch_idx = _bin_kernel_index(edges, kernels)
    bin_kernel_id = _bin_kernel_function_index(
        launch_idx, kernels, sass_kernel_names, nsys_kernel_names,
        launch_function_index=launch_function_index,
    )

    return SASSSample(
        trace_input=trace_input,
        counter_names=counter_names,
        time_edges_ns=edges,
        regime_family=regime_family,
        regime_family_names=regime_family_names,
        subregime=subregime,
        subregime_names=subregime_names,
        subregime_family_idx=subregime_family_idx,
        structural=structural,
        structural_names=structural_names,
        boundaries=boundaries,
        gt_segments=gt_segments,
        mask_any=mask_any,
        mask_profiled=mask_prof,
        workload_l1=workload_l1,
        workload_l2=workload_l2,
        workload_l1_multihot=workload_l1_multihot,
        workload_l2_multihot=workload_l2_multihot,
        multihot_n_active=multihot_n_active,
        mask_multilabel=mask_multilabel,
        vocab_l1=vocab_l1,
        vocab_l2=vocab_l2,
        bin_kernel_id=bin_kernel_id,
        sass_matrix=sass_matrix,
        sass_pc_mask=sass_pc_mask,
        sass_column_names=sass_column_names,
        sass_kernel_names=sass_kernel_names,
    )


def cross_attention_shapes_demo(sample: SASSSample,
                                d_model: int = 64,
                                patch_shape: tuple[int, int] = (4, 16)) -> None:
    """Print the shapes a forward pass would touch. No actual attention is run."""
    C, T = sample.trace_input.shape
    P_c, P_t = patch_shape
    assert C % P_c == 0 and T % P_t == 0, \
        f"patch {patch_shape} doesn't divide ({C}, {T})"
    n_tokens = (C // P_c) * (T // P_t)
    K, N_pc_max, F = sample.sass_matrix.shape

    print(f"trace_input        {sample.trace_input.shape}  dtype={sample.trace_input.dtype}")
    print(f"  -> patches       ({n_tokens}, {P_c * P_t})  "
          f"= ({C // P_c} * {T // P_t}, {P_c} * {P_t})")
    print(f"  -> Q             ({n_tokens}, {d_model})  via patch_embed Linear")
    print(f"sass_matrix        ({K}, {N_pc_max}, {F})")
    print(f"  -> K = V         ({K}, {N_pc_max}, {d_model})  via sass_proj Linear")
    print(f"bin_kernel_id      {sample.bin_kernel_id.shape}  "
          f"range=[{sample.bin_kernel_id.min()}, {sample.bin_kernel_id.max()}]")
    print(f"  -> per-token kernel index: ({n_tokens},) "
          f"(replicate the time-bin's kernel across the {C // P_c} channel patches)")
    print(f"attn output        ({n_tokens}, {d_model})  "
          f"= softmax(Q K^T / sqrt(d)) @ V, masked by sass_pc_mask")

    # Multi-label (overlapping-class) head targets, when present.
    if sample.workload_l1_multihot is not None:
        mh1 = sample.workload_l1_multihot
        mh2 = sample.workload_l2_multihot
        na = sample.multihot_n_active
        n_overlap = int((na >= 2).sum()) if na is not None else 0
        print(f"workload_l1_multihot {mh1.shape}  dtype={mh1.dtype}  "
              f"(sigmoid head target; BCEWithLogits over {mh1.shape[1]} L1 classes)")
        print(f"workload_l2_multihot {mh2.shape}  dtype={mh2.dtype}  "
              f"({mh2.shape[1]} L2 classes)")
        print(f"  -> bins with >=2 concurrent L1 classes: {n_overlap}/{mh1.shape[0]} "
              f"(0 for the sequential corpus; >0 only on fused/overlapping traces)")
    else:
        print("workload_l*_multihot  (absent — labels.npz pre-dates the "
              "multi-hot fields; re-run tools/build_labels.py)")


def main():
    ap = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    ap.add_argument("out_dir", type=Path)
    ap.add_argument("--d-model", type=int, default=64)
    args = ap.parse_args()
    sample = load_motif(args.out_dir.resolve())
    print(f"motif: {args.out_dir}")
    print(f"  counter_names ({len(sample.counter_names)}): "
          f"{sample.counter_names[:3]} ... {sample.counter_names[-2:]}")
    print(f"  sass kernel functions ({len(sample.sass_kernel_names)}): "
          f"{sample.sass_kernel_names}")
    print(f"  sass columns ({len(sample.sass_column_names)}): "
          f"{sample.sass_column_names}")
    print()
    cross_attention_shapes_demo(sample, d_model=args.d_model)


if __name__ == "__main__":
    main()