diff --git a/benchmarks/microbenchmarks/README.md b/benchmarks/microbenchmarks/README.md
index ba868b0f0..8dddf4de4 100644
--- a/benchmarks/microbenchmarks/README.md
+++ b/benchmarks/microbenchmarks/README.md
@@ -2,6 +2,8 @@
 
 This directory contains lightweight Python microbenchmarks for selected
 Transformer Engine kernels and helper scripts for comparing benchmark CSVs.
+Timing is powered by [`usv`](https://github.com/matthiasdiener/usv) (install it
+in your environment first, e.g. `pip install -e /path/to/usv`).
 
 ## Benchmarks
 
@@ -31,6 +33,30 @@ python benchmark_gemm.py --csv --csv-samples gemm_samples.csv
 The samples CSV contains one row per timing sample with columns for all
 benchmark parameters plus `label`, `sample_idx`, and `time_ms`.
 
+## Timing options (usv)
+
+Each benchmark prints **one line per run** and finishes with a terminal-only
+min / median / max throughput summary across all cases. Timing is delegated to
+`usv`, so the following optional flags are available on every benchmark (all off
+by default, so the default behavior is unchanged):
+
+| Flag | Meaning |
+| --- | --- |
+| `--interleave` | Sample a run's callables (e.g. fwd / fwd+bwd) round-robin, spreading time-correlated noise across them. |
+| `--warmup N` | Untimed warmup iterations per benchmark. |
+| `--iters N` | Timed samples per benchmark. If unset, sample until ~0.2 s of kernel time elapses (autorange-like). |
+| `--cache-flush` | Flush an L2-sized buffer before each sample (cold-cache timing). |
+| `--cudagraph` | Capture each callable into a CUDA/HIP graph and time replays (removes launch overhead). |
+| `--rotate` | Rotate inputs through an L2-sized ring of buffers (defeats L2 residency). |
+| `--cooldown SECONDS` | Idle sleep after each benchmark to let the GPU cool. |
+| `--monitor` | Sample `rocm-smi` during timing and warn if the GPU clock drifts (AMD). |
+| `--timeout SECONDS` | Abort a benchmark if timing exceeds this many seconds (GPU-hang guard). |
+
+```bash
+python benchmark_gemm.py --interleave --rotate
+python benchmark_gemm.py --iters 200 --cache-flush --monitor
+```
+
 ## Shared configuration
 
 Common benchmark settings live in `utils.py`.
@@ -54,11 +80,16 @@ Use `run_benchmarks(test_cases, bench_fn, param_columns)`.
   `make_metric_record(...)` or `make_forward_backward_metric_records(...)`.
 
 Each metric record represents one benchmark line such as `GEMM Forward`. The
-runner prints that line to stdout and expands it into two CSV columns:
+runner prints all of a run's metrics on a single line and expands each into two
+CSV columns:
 
 - `<label> Time (ms)`
 - `<label> <unit>`
 
+To time the callables, `bench_fn` uses `time_funcs({name: callable})` (which
+honors the usv flags above and enables `--interleave`); `make_input(shape,
+dtype, ...)` returns a rotation-aware input factory that respects `--rotate`.
+
 For example, a `GEMM Forward` metric with unit `TFLOPS` becomes:
 
 - `GEMM Forward Time (ms)`
diff --git a/benchmarks/microbenchmarks/benchmark_casting.py b/benchmarks/microbenchmarks/benchmark_casting.py
index 42f279e72..6502fc0c2 100755
--- a/benchmarks/microbenchmarks/benchmark_casting.py
+++ b/benchmarks/microbenchmarks/benchmark_casting.py
@@ -21,6 +21,7 @@
 from utils import (
     MODEL_HIDDEN_SIZES, M_SIZE_LIST,
     time_func, compute_gbps, make_metric_record, run_benchmarks,
+    make_input,
 )
 
 TE_FP8_E4M3 = tex.DType.kFloat8E4M3
@@ -62,17 +63,18 @@ def bench_cast(Case, M, hidden_size, direction, fp8_dtype, dtype_str):
     quantizer = Float8Quantizer(scale, amax, fp8_dtype)
 
     if direction == "quantize":
-        x = torch.randn(M, hidden_size, dtype=torch.bfloat16, device=device)
-        out = quantizer(x)
-        cast_func = lambda: quantizer.quantize(x, out=out)
+        next_x = make_input((M, hidden_size), torch.bfloat16, device=device)
+        out = quantizer(next_x())
+        cast_func = lambda: quantizer.quantize(next_x(), out=out)
         total_bytes = numel * (2 + 1)  # BF16 read + FP8 write
     else:
+        # Dequantize reads an FP8 tensor; --rotate is a no-op for this direction.
         x = torch.randn(M, hidden_size, dtype=torch.bfloat16, device=device)
         fp8_tensor = quantizer(x)
         cast_func = lambda: fp8_tensor.dequantize()
         total_bytes = numel * (1 + 2)  # FP8 read + BF16 write
 
-    ms, measurement = time_func(cast_func, method="blocked")
+    ms, measurement = time_func(cast_func)
     gbps = compute_gbps(total_bytes, ms)
 
     return [make_metric_record(CAST_LABEL, ms, "GB/s", gbps, measurement=measurement)]
diff --git a/benchmarks/microbenchmarks/benchmark_gemm.py b/benchmarks/microbenchmarks/benchmark_gemm.py
index 2069156b7..2e68f8d6d 100755
--- a/benchmarks/microbenchmarks/benchmark_gemm.py
+++ b/benchmarks/microbenchmarks/benchmark_gemm.py
@@ -10,7 +10,8 @@
 import transformer_engine.pytorch as te
 from utils import (
     generate_gemm_test_cases,
-    time_func, compute_tflops, make_forward_backward_metric_records, run_benchmarks,
+    time_funcs, compute_tflops, make_forward_backward_metric_records, run_benchmarks,
+    make_input,
 )
 
 BENCHMARK_LABEL = "GEMM"
@@ -20,13 +21,16 @@ def bench_gemm(Case, M, N, K, dtype):
     device = "cuda"
 
     linear = te.Linear(K, N, bias=False).to(device=device, dtype=dtype)
-    x = torch.randn(M, K, dtype=dtype, device=device, requires_grad=True)
+    next_x = make_input((M, K), dtype, device=device, requires_grad=True)
+
+    def fwd_func():
+        return linear(next_x())
 
-    fwd_func = lambda: linear(x)
     out = fwd_func()
     grad_out = torch.randn_like(out)
 
     def fwd_bwd_func():
+        x = next_x()
         out = linear(x)
         out.backward(grad_out)
         x.grad = None
@@ -37,9 +41,9 @@ def fwd_bwd_func():
     fwd_flops = 2 * M * N * K
     bwd_flops = 2 * fwd_flops  # dX + dW
 
-    fwd_ms, fwd_measurement = time_func(fwd_func)
-    fwd_bwd_ms, fwd_bwd_measurement = time_func(fwd_bwd_func)
-    bwd_ms = fwd_bwd_ms - fwd_ms
+    ms = time_funcs({"fwd": fwd_func, "fwd_bwd": fwd_bwd_func})
+    fwd_ms = ms["fwd"].median * 1e3
+    bwd_ms = ms["fwd_bwd"].median * 1e3 - fwd_ms
 
     fwd_tflops = compute_tflops(fwd_flops, fwd_ms)
     bwd_tflops = compute_tflops(bwd_flops, bwd_ms)
@@ -52,8 +56,8 @@ def fwd_bwd_func():
         bwd_ms,
         bwd_tflops,
         backward_derived=True,
-        fwd_measurement=fwd_measurement,
-        fwd_bwd_measurement=fwd_bwd_measurement,
+        fwd_measurement=ms["fwd"],
+        fwd_bwd_measurement=ms["fwd_bwd"],
     )
 
 
diff --git a/benchmarks/microbenchmarks/benchmark_gemm_fp8.py b/benchmarks/microbenchmarks/benchmark_gemm_fp8.py
index 7b037b7a6..8a6a634d9 100755
--- a/benchmarks/microbenchmarks/benchmark_gemm_fp8.py
+++ b/benchmarks/microbenchmarks/benchmark_gemm_fp8.py
@@ -16,7 +16,8 @@
 from transformer_engine.common.recipe import DelayedScaling, Format
 from utils import (
     generate_gemm_test_cases,
-    time_func, compute_tflops, make_forward_backward_metric_records, run_benchmarks,
+    time_funcs, compute_tflops, make_forward_backward_metric_records, run_benchmarks,
+    make_input,
 )
 
 RECIPES = {
@@ -36,14 +37,15 @@ def bench_fp8_gemm(Case, M, N, K, dtype):
     device = "cuda"
 
     linear = te.Linear(K, N, bias=False).to(device=device, dtype=dtype)
-    x = torch.randn(M, K, dtype=dtype, device=device, requires_grad=True)
+    next_x = make_input((M, K), dtype, device=device, requires_grad=True)
     grad_out = torch.randn(M, N, dtype=dtype, device=device)
 
     def fwd_func():
         with te.fp8_autocast(enabled=True, fp8_recipe=FP8_RECIPE):
-            return linear(x)
+            return linear(next_x())
 
     def fwd_bwd_func():
+        x = next_x()
         with te.fp8_autocast(enabled=True, fp8_recipe=FP8_RECIPE):
             out = linear(x)
             out.backward(grad_out)
@@ -53,9 +55,9 @@ def fwd_bwd_func():
     fwd_flops = 2 * M * N * K
     bwd_flops = 2 * fwd_flops
 
-    fwd_ms, fwd_measurement = time_func(fwd_func)
-    fwd_bwd_ms, fwd_bwd_measurement = time_func(fwd_bwd_func)
-    bwd_ms = fwd_bwd_ms - fwd_ms
+    ms = time_funcs({"fwd": fwd_func, "fwd_bwd": fwd_bwd_func})
+    fwd_ms = ms["fwd"].median * 1e3
+    bwd_ms = ms["fwd_bwd"].median * 1e3 - fwd_ms
 
     fwd_tflops = compute_tflops(fwd_flops, fwd_ms)
     bwd_tflops = compute_tflops(bwd_flops, bwd_ms)
@@ -68,8 +70,8 @@ def fwd_bwd_func():
         bwd_ms,
         bwd_tflops,
         backward_derived=True,
-        fwd_measurement=fwd_measurement,
-        fwd_bwd_measurement=fwd_bwd_measurement,
+        fwd_measurement=ms["fwd"],
+        fwd_bwd_measurement=ms["fwd_bwd"],
     )
 
 
diff --git a/benchmarks/microbenchmarks/benchmark_grouped_gemm.py b/benchmarks/microbenchmarks/benchmark_grouped_gemm.py
index a576568a0..ac2760fb7 100755
--- a/benchmarks/microbenchmarks/benchmark_grouped_gemm.py
+++ b/benchmarks/microbenchmarks/benchmark_grouped_gemm.py
@@ -6,12 +6,14 @@
 ###############################################################################
 
 import torch
+import transformer_engine.pytorch as te
 from utils import (
     DTYPE_LIST,
-    time_func,
+    time_funcs,
     compute_tflops,
     make_forward_backward_metric_records,
     run_benchmarks,
+    make_input,
 )
 
 BENCHMARK_LABEL = "Grouped GEMM"
@@ -97,118 +99,54 @@ def generate_grok_v2_test_cases():
     )
 
 
-def make_fwd_bwd_funcs_te(x, w, group_lens, activation_dtype):
-    from transformer_engine.pytorch.cpp_extensions import general_grouped_gemm
+def bench_grouped_gemm(Case, B, M, N, K, dtype):
+    device = "cuda"
 
-    B = int(group_lens.numel())
-    N = int(w.shape[1])
-    K = int(w.shape[2])
+    # Match the dense GEMM benchmark: drive te.GroupedLinear directly (see #639)
+    # rather than the lower-level general_grouped_gemm, so fwd + dgrad + wgrad and
+    # the framework overhead are all captured.
+    grouped = te.GroupedLinear(B, K, N, bias=False).to(device=device, dtype=dtype)
+    next_x = make_input((B * M, K), dtype, device=device, requires_grad=True)
 
+    group_lens = generate_grouped_gemm_group_lens(B, M, balance=True)
     m_splits = [int(v) for v in group_lens.tolist()]
-    assert len(m_splits) == B
-    sum_M = sum(m_splits)
-    assert x.numel() > 0 and x.shape[0] == sum_M
-
-    x_view = x.reshape(-1, x.shape[-1])
-    xs = list(torch.split(x_view, m_splits))
-    weights = [w[i] for i in range(B)]
-
-    out = torch.empty((sum_M, N), device=x.device, dtype=activation_dtype)
-
-    def fwd_func_te():
-        general_grouped_gemm(
-            A=weights,
-            B=xs,
-            out=[out],
-            quantization_params=[None] * B,
-            out_dtype=activation_dtype,
-            single_output=True,
-            m_splits=m_splits,
-            use_bias=False,
-            bias=None,
-            layout="TN",
-        )
-        return out
-
-    dx = torch.empty((sum_M, K), device=x.device, dtype=activation_dtype)
-    dxs = list(torch.split(dx, m_splits))
-
-    dw_stacked = torch.empty((B, N, K), device=x.device, dtype=activation_dtype)
-    dws = [dw_stacked[i] for i in range(B)]
-
-    def bwd_func_te(grad_out):
-        go = grad_out.view(-1, grad_out.shape[-1])
-        splits = torch.split(go, m_splits)
-
-        general_grouped_gemm(
-            A=weights,
-            B=splits,
-            out=dxs,
-            quantization_params=[None] * B,
-            out_dtype=activation_dtype,
-            single_output=False,
-            layout="NN",
-            m_splits=m_splits,
-            grad=False,
-            use_bias=False,
-            bias=None,
-        )
-
-        general_grouped_gemm(
-            A=xs,
-            B=splits,
-            out=dws,
-            quantization_params=[None] * B,
-            out_dtype=activation_dtype,
-            single_output=False,
-            layout="NT",
-            m_splits=m_splits,
-            grad=False,
-            use_bias=False,
-            bias=None,
-            accumulate=False,
-        )
-
-        return dx, dw_stacked
-
-    return fwd_func_te, bwd_func_te
-
 
-def bench_grouped_gemm(Case, B, M, N, K, dtype):
-    device = "cuda"
+    def fwd_func():
+        return grouped(next_x(), m_splits)
 
-    x = torch.randn((B * M, K), dtype=dtype, device=device, requires_grad=True)
-    w = torch.randn((B, N, K), dtype=dtype, device=device, requires_grad=True)
-    group_lens = generate_grouped_gemm_group_lens(B, M, balance=True).to(device)
+    out = fwd_func()
+    grad_out = torch.randn_like(out)
 
-    x_te = x.clone().detach()
-    w_te = w.clone().detach()
-    fwd_func_te, bwd_func_te_inner = make_fwd_bwd_funcs_te(
-        x_te, w_te, group_lens, activation_dtype=dtype
-    )
+    def fwd_bwd_func():
+        x = next_x()
+        out = grouped(x, m_splits)
+        out.backward(grad_out)
+        x.grad = None
+        for p in grouped.parameters():
+            p.grad = None
 
-    out_te = fwd_func_te()
-    grad_out = torch.randn_like(out_te)
-    bwd_func_te = lambda: bwd_func_te_inner(grad_out)
+    fwd_bwd_func()
 
-    fwd_total_flops = 2 * B * M * N * K
-    bwd_total_flops = 2 * fwd_total_flops
+    fwd_flops = 2 * B * M * N * K
+    bwd_flops = 2 * fwd_flops  # dX + dW
 
-    fwd_te_ms, fwd_measurement = time_func(fwd_func_te)
-    bwd_te_ms, bwd_measurement = time_func(bwd_func_te)
+    ms = time_funcs({"fwd": fwd_func, "fwd_bwd": fwd_bwd_func})
+    fwd_ms = ms["fwd"].median * 1e3
+    bwd_ms = ms["fwd_bwd"].median * 1e3 - fwd_ms
 
-    fwd_te_tflops = compute_tflops(fwd_total_flops, fwd_te_ms)
-    bwd_te_tflops = compute_tflops(bwd_total_flops, bwd_te_ms)
+    fwd_tflops = compute_tflops(fwd_flops, fwd_ms)
+    bwd_tflops = compute_tflops(bwd_flops, bwd_ms)
 
     return make_forward_backward_metric_records(
         BENCHMARK_LABEL,
         "TFLOPS",
-        fwd_te_ms,
-        fwd_te_tflops,
-        bwd_te_ms,
-        bwd_te_tflops,
-        fwd_measurement=fwd_measurement,
-        bwd_measurement=bwd_measurement,
+        fwd_ms,
+        fwd_tflops,
+        bwd_ms,
+        bwd_tflops,
+        backward_derived=True,
+        fwd_measurement=ms["fwd"],
+        fwd_bwd_measurement=ms["fwd_bwd"],
     )
 
 
diff --git a/benchmarks/microbenchmarks/benchmark_normalization.py b/benchmarks/microbenchmarks/benchmark_normalization.py
index 577bec3d9..7a9807de6 100755
--- a/benchmarks/microbenchmarks/benchmark_normalization.py
+++ b/benchmarks/microbenchmarks/benchmark_normalization.py
@@ -17,7 +17,8 @@
 import transformer_engine.pytorch as te
 from utils import (
     DTYPE_LIST, MODEL_HIDDEN_SIZES, M_SIZE_LIST,
-    time_func, compute_gbps, make_forward_backward_metric_records, run_benchmarks,
+    time_funcs, compute_gbps, make_forward_backward_metric_records, run_benchmarks,
+    make_input,
 )
 
 NORM_TYPES = [
@@ -49,13 +50,16 @@ def bench_norm(Case, M, hidden_size, norm_name, norm_cls, dtype):
     device = "cuda"
 
     norm = norm_cls(hidden_size).to(device=device, dtype=dtype)
-    x = torch.randn(M, hidden_size, dtype=dtype, device=device, requires_grad=True)
+    next_x = make_input((M, hidden_size), dtype, device=device, requires_grad=True)
+
+    def fwd_func():
+        return norm(next_x())
 
-    fwd_func = lambda: norm(x)
     out = fwd_func()
     grad_out = torch.randn_like(out)
 
     def fwd_bwd_func():
+        x = next_x()
         out = norm(x)
         out.backward(grad_out)
         x.grad = None
@@ -64,13 +68,13 @@ def fwd_bwd_func():
 
     fwd_bwd_func()
 
-    elem_bytes = x.element_size()
+    elem_bytes = torch.empty(0, dtype=dtype).element_size()
     fwd_bytes = 2 * M * hidden_size * elem_bytes   # read x, write y
     bwd_bytes = 4 * M * hidden_size * elem_bytes   # read grad+x+y, write grad_x
 
-    fwd_ms, fwd_measurement = time_func(fwd_func)
-    fwd_bwd_ms, fwd_bwd_measurement = time_func(fwd_bwd_func)
-    bwd_ms = fwd_bwd_ms - fwd_ms
+    ms = time_funcs({"fwd": fwd_func, "fwd_bwd": fwd_bwd_func})
+    fwd_ms = ms["fwd"].median * 1e3
+    bwd_ms = ms["fwd_bwd"].median * 1e3 - fwd_ms
 
     fwd_gbps = compute_gbps(fwd_bytes, fwd_ms)
     bwd_gbps = compute_gbps(bwd_bytes, bwd_ms)
@@ -83,8 +87,8 @@ def fwd_bwd_func():
         bwd_ms,
         bwd_gbps,
         backward_derived=True,
-        fwd_measurement=fwd_measurement,
-        fwd_bwd_measurement=fwd_bwd_measurement,
+        fwd_measurement=ms["fwd"],
+        fwd_bwd_measurement=ms["fwd_bwd"],
     )
 
 
diff --git a/benchmarks/microbenchmarks/utils.py b/benchmarks/microbenchmarks/utils.py
index 4eef29556..10471a11c 100644
--- a/benchmarks/microbenchmarks/utils.py
+++ b/benchmarks/microbenchmarks/utils.py
@@ -8,7 +8,8 @@
 
 import argparse
 import torch
-import torch.utils.benchmark as benchmark
+
+import usv
 
 # ---------------------------------------------------------------------------
 # Sequence / batch-token sizes
@@ -88,22 +89,81 @@ def generate_gemm_test_cases(configs=None, m_sizes=None, dtypes=None):
 # Timing helpers
 # ---------------------------------------------------------------------------
 
-def time_func(fn, method="adaptive", min_run_time=DEFAULT_MIN_RUN_TIME_SECONDS):
-    """Time *fn* and return ``(mean_ms, measurement)``.
+# Parsed CLI args (usv timing options, rotation, ...); populated by run_benchmarks.
+_ARGS = None
 
-    The ``Measurement`` object carries per-sample times accessible via
-    ``measurement.times`` (total wall time per run) and
-    ``measurement.number_per_run``.
 
-    method: "adaptive" uses adaptive_autorange (good for compute-bound),
-            "blocked"  uses blocked_autorange  (good for memory-bound).
-    """
-    timer = benchmark.Timer(stmt="fn()", globals={"fn": fn})
-    if method == "blocked":
-        m = timer.blocked_autorange(min_run_time=min_run_time)
+def _usv_opts():
+    """Translate the parsed CLI flags into ``usv.do_bench_many`` keyword args."""
+    a = _ARGS
+    if a is None:
+        return {"min_iters_time": DEFAULT_MIN_RUN_TIME_SECONDS}
+    opts = {
+        "interleave": getattr(a, "interleave", False),
+        "cache_flush": getattr(a, "cache_flush", False),
+        "cudagraph": getattr(a, "cudagraph", False),
+        "monitor": getattr(a, "monitor", False),
+    }
+    warmup = getattr(a, "warmup", None)
+    if warmup is not None:
+        opts["warmup"] = warmup
+    iters = getattr(a, "iters", None)
+    if iters is not None:
+        opts["iters"] = iters
     else:
-        m = timer.adaptive_autorange(min_run_time=min_run_time)
-    return m.mean * 1e3, m
+        # Mimic torch.utils.benchmark autorange: sample until this much kernel
+        # time elapses (the iters count acts as a floor).
+        opts["min_iters_time"] = DEFAULT_MIN_RUN_TIME_SECONDS
+    cooldown = getattr(a, "cooldown", 0.0)
+    if cooldown:
+        opts["cooldown_s"] = cooldown
+    timeout = getattr(a, "timeout", None)
+    if timeout is not None:
+        opts["timeout"] = timeout
+    return opts
+
+
+def time_funcs(funcs):
+    """Time a ``{name: callable}`` group with usv; return ``{name: Measurement}``.
+
+    Honors the global CLI options (``--interleave``, ``--warmup`` / ``--iters``,
+    ``--cache-flush``, ``--cudagraph``, ``--cooldown``, ``--monitor``,
+    ``--timeout``).  With ``--interleave`` the callables are sampled round-robin,
+    so time-correlated noise is spread across them instead of biasing one.
+    """
+    return usv.do_bench_many(dict(funcs), **_usv_opts())
+
+
+def time_func(fn, method=None, min_run_time=None):
+    """Time a single callable with usv; return ``(median_ms, Measurement)``.
+
+    ``method`` / ``min_run_time`` are accepted for backwards compatibility and
+    ignored - timing is controlled by the CLI flags parsed by run_benchmarks.
+    """
+    m = time_funcs({"_": fn})["_"]
+    return m.median * 1e3, m
+
+
+def rotating(factory):
+    """Return a zero-arg callable yielding an input to time.
+
+    With ``--rotate`` it cycles through an L2-sized ring of freshly built
+    buffers (:func:`usv.rotating_buffers`) so back-to-back launches touch
+    different memory; otherwise it returns a single cached buffer each call.
+    """
+    if _ARGS is not None and getattr(_ARGS, "rotate", False):
+        return usv.rotating_buffers(factory)
+    cached = factory()
+    return lambda: cached
+
+
+def make_input(shape, dtype, *, device="cuda", requires_grad=False):
+    """Rotation-aware input: a zero-arg callable returning a ``torch.randn`` tensor."""
+    return rotating(
+        lambda: torch.randn(
+            *shape, dtype=dtype, device=device, requires_grad=requires_grad
+        )
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -129,8 +189,8 @@ def make_metric_record(label, ms, unit, throughput, derived=False,
     ``run_benchmarks`` formats these records for stdout and expands them into
     ``<label> Time (ms)`` and ``<label> <unit>`` CSV columns.
 
-    If *measurement* is provided (a ``torch.utils.benchmark.Measurement``),
-    the per-sample times are available for the ``--csv-samples`` output.
+    If *measurement* is provided (a :class:`usv.Measurement`), its per-call
+    samples are available for the ``--csv-samples`` output.
     Records with *samples_only=True* are excluded from stdout and the main
     CSV but their samples are still written to the samples CSV.
     """
@@ -221,20 +281,51 @@ def _metric_row_from_records(metric_records):
     return row
 
 
-def _print_metric_records(metric_records):
-    printable = [m for m in metric_records if not m.get("samples_only")]
-    if not printable:
-        return
-    label_width = max(24, *(len(metric["label"]) for metric in printable))
-    for metric in printable:
+def _format_case_line(case_label, metric_records):
+    """Render one benchmark run as a single line: ``params | metric | metric``."""
+    parts = []
+    for metric in metric_records:
+        if metric.get("samples_only"):
+            continue
         ms_str = _format_metric_number(metric["ms"], metric.get("ms_precision", 3))
         throughput_str = _format_metric_number(
             metric["throughput"], metric.get("throughput_precision", 2)
         )
         derived_suffix = " (derived)" if metric.get("derived", False) else ""
+        parts.append(
+            f"{metric['label']} {ms_str} ms {throughput_str} "
+            f"{metric['unit']}{derived_suffix}"
+        )
+    return f"{case_label} | " + " | ".join(parts)
+
+
+def _print_summary(all_case_metrics):
+    """Print per-metric min / median / max throughput across all cases.
+
+    Terminal-only aggregate; deliberately not written to any CSV.
+    """
+    from statistics import median
+
+    summary = {}  # label -> [unit, [throughputs]]
+    order = []
+    for _case_params, records in all_case_metrics:
+        for metric in records:
+            if metric.get("samples_only"):
+                continue
+            label = metric["label"]
+            if label not in summary:
+                summary[label] = [metric["unit"], []]
+                order.append(label)
+            summary[label][1].append(metric["throughput"])
+    if not order:
+        return
+    width = max(len(label) for label in order)
+    print(f"\nSummary (throughput over {len(all_case_metrics)} cases):")
+    for label in order:
+        unit, vals = summary[label]
         print(
-            f"  {metric['label']:<{label_width}} {ms_str} ms | "
-            f"{throughput_str} {metric['unit']}{derived_suffix}"
+            f"  {label:<{width}}  min {min(vals):.2f}  "
+            f"median {median(vals):.2f}  max {max(vals):.2f}  {unit}"
         )
 
 
@@ -275,6 +366,46 @@ def make_parser(**kwargs):
             "--csv-samples is ignored in this mode."
         ),
     )
+    # usv timing options (all optional; the defaults preserve prior behavior).
+    parser.add_argument(
+        "--interleave", action="store_true", default=False,
+        help="Sample each benchmark's callables round-robin (usv --interleave).",
+    )
+    parser.add_argument(
+        "--warmup", type=int, default=None, metavar="N",
+        help="Untimed warmup iterations per benchmark (usv default if unset).",
+    )
+    parser.add_argument(
+        "--iters", type=int, default=None, metavar="N",
+        help=(
+            "Timed samples per benchmark. If unset, sample until "
+            f"{DEFAULT_MIN_RUN_TIME_SECONDS}s of kernel time elapses."
+        ),
+    )
+    parser.add_argument(
+        "--cache-flush", action="store_true", default=False,
+        help="Flush an L2-sized buffer before each sample (cold-cache timing).",
+    )
+    parser.add_argument(
+        "--cudagraph", action="store_true", default=False,
+        help="Capture each callable into a CUDA/HIP graph and time replays.",
+    )
+    parser.add_argument(
+        "--rotate", action="store_true", default=False,
+        help="Rotate inputs through an L2-sized ring of buffers (usv).",
+    )
+    parser.add_argument(
+        "--cooldown", type=float, default=0.0, metavar="SECONDS",
+        help="Idle sleep after each benchmark to let the GPU cool down.",
+    )
+    parser.add_argument(
+        "--monitor", action="store_true", default=False,
+        help="Sample rocm-smi during timing; warn on GPU clock drift (AMD).",
+    )
+    parser.add_argument(
+        "--timeout", type=float, default=None, metavar="SECONDS",
+        help="Abort a benchmark if timing exceeds this many seconds (hang guard).",
+    )
     return parser
 
 
@@ -334,6 +465,9 @@ def run_benchmarks(test_cases, bench_fn, param_columns, default_csv=None,
     if args is None:
         args = make_parser().parse_args()
 
+    global _ARGS
+    _ARGS = args
+
     if args.kernel_profile:
         from torch.profiler import profile, ProfilerActivity
 
@@ -344,13 +478,10 @@ def run_benchmarks(test_cases, bench_fn, param_columns, default_csv=None,
 
     for case in test_cases:
         label = "  ".join(f"{k}={case[k]}" for k in param_columns)
-        print(f"\n{'='*60}")
-        print(f"Testing: {label}")
-        print(f"{'='*60}")
 
         metric_records = bench_fn(**case)
         metric_row = _metric_row_from_records(metric_records)
-        _print_metric_records(metric_records)
+        print(_format_case_line(label, metric_records))
         current_metric_columns = list(metric_row.keys())
 
         if resolved_metric_columns is None:
@@ -419,6 +550,8 @@ def run_benchmarks(test_cases, bench_fn, param_columns, default_csv=None,
                 )
                 all_kernel_rows.append(kr)
 
+    _print_summary(all_case_metrics)
+
     if args.csv is not None:
         import pandas as pd
         out_csv = args.csv if isinstance(args.csv, str) else (
@@ -460,13 +593,12 @@ def run_benchmarks(test_cases, bench_fn, param_columns, default_csv=None,
                 if measurement is None:
                     continue
                 lbl = metric["label"]
-                for i, t in enumerate(measurement.times):
+                for i, t in enumerate(measurement.samples):
                     sr = dict(case_params)
                     sr["label"] = lbl
                     sr["sample_idx"] = i
-                    # measurement.times is already per-iteration (raw block time
-                    # divided by number_per_run); convert seconds -> ms only.
-                    sr["time_ms"] = t * 1e3
+                    # usv Measurement.samples are per-call seconds; -> ms.
+                    sr["time_ms"] = float(t) * 1e3
                     sample_rows.append(sr)
         if sample_rows:
             df = pd.DataFrame(