Measure maximized NATS cluster: 8 cores, 16 GiB, tmpfs JetStream.

Same NS1 ladder as 20260912T051237Z. Product streams restored to ZFS;
raised cores, RAM, and max_mem stay on 510–513.

packages/verae-nats-cluster/scripts/build-ns1-study-report.py

@@ -57,6 +57,9 @@ JS_LABELS = {
     "js-4p-50k-128-r3": "4p 50k×128 B",
     "js-4p-20k-1k-r3": "4p 20k×1 KiB",
     "js-2p2s-20k-128-r3": "2p2s pull 20k×128 B",
+    "js-mem-1p-20k-128-r3": "mem 1p 128 B",
+    "js-mem-4p-50k-128-r3": "mem 4p 128 B",
+    "js-mem-4p-20k-1k-r3": "mem 4p 1 KiB",
 }
 LAT_LABELS = {
     "lat-ping-1k-128": "Ping\n1k×128 B",
@@ -286,11 +289,117 @@ def figure(name: str, caption: str) -> str:
     return f"![{caption}](charts/{name})\n\n*{caption}*"
 
 
-def write_markdown(folder: Path, thru: list[dict[str, str]], lats: list[dict[str, str]]) -> str:
+def ratio(new: str | None, old: str | None) -> str:
+    if not new or not old:
+        return "—"
+    a, b = float(new), float(old)
+    if b == 0:
+        return "—"
+    return f"{a / b:.2f}×"
+
+
+def delay_ms_val(p: dict[str, str] | None, key: str) -> str | None:
+    if not p or not p.get(key):
+        return None
+    return str(ms(p[key]))
+
+
+def delta_table(
+    thru: list[dict[str, str]],
+    lats: list[dict[str, str]],
+    base_thru: list[dict[str, str]],
+    base_lats: list[dict[str, str]],
+    base_stamp: str,
+) -> str:
+    bt = {p["run"]: p for p in base_thru}
+    nt = {p["run"]: p for p in thru}
+    bl = {p["run"]: p for p in base_lats}
+    nl = {p["run"]: p for p in lats}
+    keys = [
+        ("core-1p1s-50k-128", "pub", "Core 1p1s 128 B pub msgs/s"),
+        ("core-8p8s-200k-128", "agg", "Core 8p8s 128 B aggregate msgs/s"),
+        ("js-1p-20k-128-r3", "pub", "JS file r=3 1p 128 B pub msgs/s"),
+        ("js-4p-50k-128-r3", "pub", "JS file r=3 4p 128 B pub msgs/s"),
+        ("js-4p-20k-1k-r3", "pub", "JS file r=3 4p 1 KiB pub msgs/s"),
+        ("js-mem-1p-20k-128-r3", "pub", "JS memory r=3 1p 128 B pub msgs/s"),
+        ("js-mem-4p-50k-128-r3", "pub", "JS memory r=3 4p 128 B pub msgs/s"),
+    ]
+    lines = [
+        f"| Metric | Baseline `{base_stamp}` | This run | Ratio |",
+        "|--------|-------------------------|----------|-------|",
+    ]
+    for run, kind, label in keys:
+        old, new = bt.get(run), nt.get(run)
+        ok = "pub_msgs" if kind == "pub" else "agg_msgs"
+        ov = old.get(ok) if old else None
+        nv = new.get(ok) if new else None
+        lines.append(f"| {label} | {fmt_int(ov)} | {fmt_int(nv)} | {ratio(nv, ov)} |")
+    old_p, new_p = bl.get("lat-ping-1k-128"), nl.get("lat-ping-1k-128")
+    if old_p or new_p:
+        ov = delay_ms_val(old_p, "p99")
+        nv = delay_ms_val(new_p, "p99")
+        # smaller delay is better — invert ratio label
+        r = "—"
+        if ov and nv and float(nv) != 0:
+            r = f"{float(ov) / float(nv):.2f}× faster" if float(nv) < float(ov) else f"{float(nv) / float(ov):.2f}× slower"
+        lines.append(
+            f"| Ping p99 (ms) | {old_p.get('p99') if old_p else '—'} | {new_p.get('p99') if new_p else '—'} | {r} |"
+        )
+    return "\n".join(lines)
+
+
+def chart_delta(
+    thru: list[dict[str, str]],
+    base_thru: list[dict[str, str]],
+    dest: Path,
+) -> None:
+    bt = {p["run"]: p for p in base_thru}
+    nt = {p["run"]: p for p in thru}
+    labels = ["Core 1p\n128 B pub", "JS file 1p\n128 B", "JS file 4p\n128 B", "JS mem 1p\n128 B"]
+    keys = ["core-1p1s-50k-128", "js-1p-20k-128-r3", "js-4p-50k-128-r3", "js-mem-1p-20k-128-r3"]
+    old = [int(bt[k]["pub_msgs"]) if k in bt and bt[k].get("pub_msgs") else 0 for k in keys]
+    new = [int(nt[k]["pub_msgs"]) if k in nt and nt[k].get("pub_msgs") else 0 for k in keys]
+    if not any(new):
+        return
+    fig, ax = plt.subplots(figsize=(9.2, 4.4))
+    x = list(range(len(labels)))
+    w = 0.35
+    ax.bar([i - w / 2 for i in x], old, w, label="Baseline 1c/1G/ZFS", color=MUTED)
+    ax.bar([i + w / 2 for i in x], new, w, label="8c/16G/tmpfs (+ mem rows)", color=INDIGO)
+    ax.set_xticks(x, labels)
+    ax.set_yscale("log")
+    ax.set_ylabel("publish messages / second (log)")
+    ax.set_title("Measured delta vs 20260912T051237Z")
+    ax.legend(loc="upper right")
+    ax.set_axisbelow(True)
+    save(fig, dest / "delta-vs-baseline.png")
+
+
+def write_markdown(
+    folder: Path,
+    thru: list[dict[str, str]],
+    lats: list[dict[str, str]],
+    compare: Path | None = None,
+) -> str:
     before = kv_file(folder / "host-before.txt")
     after = kv_file(folder / "host-after.txt")
     stamp = folder.name
     method = (Path(__file__).resolve().parent / "ns1-study-methodology.md").read_text(encoding="utf-8")
+    delta_md = ""
+    base_thru: list[dict[str, str]] = []
+    base_lats: list[dict[str, str]] = []
+    if compare and compare.is_dir():
+        base_thru, base_lats = load_runs(compare)
+        delta_md = (
+            f"## Measured delta vs `{compare.name}`\n\n"
+            "Baseline: 1 core / 1 GiB / JetStream on ZFS. This run: 8 cores / 16 GiB / "
+            "JetStream **tmpfs** (file r=3) plus extra **memory** store rows. veth/10G unchanged.\n\n"
+            + delta_table(thru, lats, base_thru, base_lats, compare.name)
+            + "\n"
+        )
+        if (folder / "charts" / "delta-vs-baseline.png").exists():
+            delta_md += "\n" + figure("delta-vs-baseline.png", "Baseline vs maximized publish rates (log)")
+            delta_md += "\n"
     figs = []
     charts_dir = folder / "charts"
     if (charts_dir / "core-throughput.png").exists():
@@ -308,11 +417,11 @@ def write_markdown(folder: Path, thru: list[dict[str, str]], lats: list[dict[str
     js1 = next((p for p in thru if p["run"] == "js-1p-20k-128-r3"), None)
     core1 = next((p for p in thru if p["run"] == "core-1p1s-50k-128"), None)
 
-    md = f"""**Progress report (second study)** · run `{stamp}` (UTC)
+    md = f"""**Progress report (maximized NS1 study)** · run `{stamp}` (UTC)
 
-> **Execution provenance.** Every process for this study ran on **NS1.GEORGELAMBERT.ORG** (`70.88.205.138`): the orchestrator (`study-on-ns1.sh`), `nats bench`, `latency.mjs` (inside LXC 510 on this hypervisor), charting (`matplotlib`), and HTML/PDF (`pandoc` + `weasyprint`). The operator laptop did **not** publish, subscribe, draw charts, or render the PDF. Traffic stayed on `vmbr1` from LXC **510** to `nats-a/b/c` (**511–513**).
+> **Execution provenance.** Every process for this study ran on **NS1.GEORGELAMBERT.ORG** (`70.88.205.138`): `maximize-ns1-study.sh` (cores/RAM/`max_mem`/tmpfs), then `study-on-ns1.sh`, `nats bench`, `latency.mjs` (LXC 510), matplotlib, pandoc, weasyprint. Traffic stayed on `vmbr1`. veth/10G was **not** changed. After the ladder, JetStream was put back on ZFS and product streams were re-created; **8 cores / 16 GiB / max_mem 8G stay**.
 
-This is a full methodology write-up plus the numbers from that on-host run. The earlier report (`nats-cluster-bench`, run `20260912T045131Z`) used the same cluster but was **orchestrated and rendered off-box**. Use this document when you need “it was all run on 138.”
+{delta_md}
 
 ---
 
@@ -407,8 +516,8 @@ def render(md_path: Path, html_path: Path, pdf_path: Path) -> None:
         '<div class="doc-banner">'
         '<nav class="site"><a href="/">zapier.georgelambert.org</a>'
         ' · <a href="/index-md.html">Markdown indexes</a></nav>'
-        '<div class="kicker">Verae Time × Zapier · progress report · run on NS1.GEORGELAMBERT.ORG</div>'
-        "<h1>NATS cluster message speed — NS1 host study</h1>"
+        '<div class="kicker">Verae Time × Zapier · progress report · maximized NS1 study</div>'
+        "<h1>NATS cluster message speed — maximized (RAM disk + 8 cores)</h1>"
         '<div class="source-path">packages/zapier-decisions/reports/nats-cluster-bench-ns1.md</div>'
         "</div>\n",
         encoding="utf-8",
@@ -440,9 +549,13 @@ def render(md_path: Path, html_path: Path, pdf_path: Path) -> None:
 
 def main() -> int:
     folder = Path(sys.argv[1] if len(sys.argv) > 1 else ".")
+    compare = Path(sys.argv[2]) if len(sys.argv) > 2 and sys.argv[2] else None
     thru, lats = load_runs(folder)
     charts(thru, lats, folder / "charts")
-    md = write_markdown(folder, thru, lats)
+    if compare and compare.is_dir():
+        base_thru, _base_lats = load_runs(compare)
+        chart_delta(thru, base_thru, folder / "charts")
+    md = write_markdown(folder, thru, lats, compare if compare and compare.is_dir() else None)
     md_path = folder / "nats-cluster-bench-ns1.md"
     md_path.write_text(md, encoding="utf-8")
     html_path = folder / "nats-cluster-bench-ns1.html"