From 793941693f5a9282fb99f3ecda9e26ca16ae8617 Mon Sep 17 00:00:00 2001
From: smarm-agent <agent@smarm.sandbox>
Date: Mon, 15 Jun 2026 11:21:43 +0000
Subject: [PATCH] benches: salvage generic tooling from the excised spin work

Carries forward the non-spin parts of the dropped spin-tooling commit:
- .gitignore: __pycache__/ and *.pyc
- sweep.py: generic vs-tokio comparison summary (no spin_sweep coupling)
The spin_sweep README docs from that commit are intentionally left behind.
---
 .gitignore       |  2 ++
 benches/sweep.py | 85 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 87 insertions(+)

diff --git a/.gitignore b/.gitignore
index 116a693..f63a5bb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,5 @@ target
 Cargo.lock
 smarm_trace.json
 /bench_results/
+__pycache__/
+*.pyc
diff --git a/benches/sweep.py b/benches/sweep.py
index af3c12c..7eb1bcf 100755
--- a/benches/sweep.py
+++ b/benches/sweep.py
@@ -243,6 +243,90 @@ def check_regressions(current: dict, baseline: dict) -> bool:
 # Pretty print
 # ---------------------------------------------------------------------------
 
+def _threads(label: str) -> int | None:
+    """Worker-thread count implied by a runtime label.
+
+    tokio's `current_thread` is a single-threaded executor (1); an explicit
+    `multi N-thread` is N; a bare `multi-thread` has no count (None) — tokio's
+    default work-stealing pool, paired against smarm's widest config.
+    """
+    if "current_thread" in label:
+        return 1
+    m = re.search(r"(\d+)-thread", label)
+    return int(m.group(1)) if m else None
+
+
+def vs_tokio(results: dict) -> list[tuple]:
+    """Per bench, like-for-like smarm-vs-tokio rows matched by thread count.
+
+    Exact thread-count matches are paired directly (smarm 1-thread vs tokio
+    current_thread, smarm 4-thread vs tokio multi 4-thread, …). tokio's bare
+    `multi-thread` (no explicit count) is paired against the widest unmatched
+    smarm multi-thread config. Lower median µs = faster; ratio = tokio_med /
+    smarm_med, so ratio > 1 means smarm is that many times faster.
+
+    Returns rows of (bench, smarm_label, smarm_med, tokio_label, tokio_med,
+    ratio, winner). Benches without a comparable pair are skipped.
+    """
+    rows: list[tuple] = []
+    for bench, runtimes in sorted(results.items()):
+        smarm: dict[int, tuple[str, int]] = {}
+        tokio: dict[int, tuple[str, int]] = {}
+        tokio_default: tuple[str, int] | None = None  # bare 'multi-thread'
+        for label, data in runtimes.items():
+            n = _threads(label)
+            if label.startswith("smarm"):
+                if n is not None:
+                    smarm[n] = (label, data["median"])
+            elif label.startswith("tokio"):
+                if n is None:
+                    tokio_default = (label, data["median"])
+                else:
+                    tokio[n] = (label, data["median"])
+
+        def row(s: tuple[str, int], t: tuple[str, int]):
+            s_label, s_med = s
+            t_label, t_med = t
+            if s_med == 0:
+                return None
+            ratio = t_med / s_med
+            return (bench, s_label, s_med, t_label, t_med, ratio,
+                    "smarm" if ratio >= 1.0 else "tokio")
+
+        matched: set[int] = set()
+        for n in sorted(set(smarm) & set(tokio)):
+            r = row(smarm[n], tokio[n])
+            if r:
+                rows.append(r)
+                matched.add(n)
+        # tokio's default multi pool vs the widest smarm config not already paired.
+        if tokio_default is not None:
+            rem = [n for n in smarm if n not in matched and n > 1]
+            if rem:
+                r = row(smarm[max(rem)], tokio_default)
+                if r:
+                    rows.append(r)
+    return rows
+
+
+def print_vs_tokio(results: dict) -> None:
+    """Human summary + greppable VSTOKIO lines (best smarm vs best tokio)."""
+    rows = vs_tokio(results)
+    if not rows:
+        return
+    print("\n  vs tokio  (like-for-like by thread count; ratio>1 = smarm faster, lower µs better)")
+    print(f"  {'-'*78}")
+    for bench, s_label, s_med, t_label, t_med, ratio, winner in rows:
+        print(
+            f"  {bench:<22} {s_label} {s_med}µs  vs  {t_label} {t_med}µs"
+            f"  →  {ratio:.2f}x ({winner})"
+        )
+    # Machine-readable, one line per bench:
+    #   VSTOKIO,<bench>,<smarm_label>,<smarm_us>,<tokio_label>,<tokio_us>,<ratio>,<winner>
+    for bench, s_label, s_med, t_label, t_med, ratio, winner in rows:
+        print(f"VSTOKIO,{bench},{s_label},{s_med},{t_label},{t_med},{ratio:.3f},{winner}")
+
+
 def print_results(results: dict, label: str = "") -> None:
     if label:
         print(f"\n{'='*70}")
@@ -257,6 +341,7 @@ def print_results(results: dict, label: str = "") -> None:
                 f"  {rt_label:>28} | {data['result']:>10} | "
                 f"{data['median']:>10} | {data['min']:>8} | {data['max']:>8}"
             )
+    print_vs_tokio(results)
 
 
 def print_sweep_table(sweep_results: list[tuple[int, int, dict]]) -> None: