VoxelForge/Standalone/Research/WorldAssemblerM3/Linux152/RunL152Timing.py

#!/usr/bin/env python3
"""L80 comparison of L152 with the assembler/world baseline."""
from __future__ import annotations

import json
import os
import re
import statistics
import subprocess
import time
from pathlib import Path


ROOT = Path(__file__).resolve().parents[4]
OUT = ROOT / "Saved/Linux/l152/timing"
DATA = ROOT / "Standalone/data/owner_world.json"
BINARIES = {
    "assembler-world": (
        ROOT / "Saved/Linux/l137/bin/VoxelForgeCoreHeadless-l137-aa-a",
        "4499fb2a8a4ede7d6cbc68d1b794f104658cdaae93ed9cacbc91fe7ff3fc3621"),
    "planner-head": (
        ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-l152-clang",
        "b299076d814ff7cc098aa373cdc3a26533ed8bfe1ef6df1ea9de4d400d231b25"),
}
CAMERAS = {
    0: (8.0, 16.0, -372.2626953125),
    1: (25.8369140625, 3.19921875, -737.0),
    2: (19.166015625, -14.2001953125, -753.3740234375),
    3: (-20.0625, -5.068359375, -900.353515625),
}
PIPELINE = re.compile(r"^\[StreamPipeline\] (.*)$", re.M)
FIELDS = re.compile(r"([a-zA-Z0-9_]+)=([^ ]+)")
NEAR = re.compile(
    r"^\[WorldAssemblerNearLODReady\] lods=0-2 tiles=(\d+)/(\d+) cold_ready_s=([0-9.]+)$",
    re.M)
STAMP = re.compile(r"^\[VoxelForgeSourceStamp\] sha256=([0-9a-f]+)$", re.M)


def run(strate: int, workers: int, version: str, phase: str, replicate: int) -> dict:
    OUT.mkdir(parents=True, exist_ok=True)
    binary, expected_stamp = BINARIES[version]
    camera = ",".join(f"{value:.12f}" for value in CAMERAS[strate]) + ",0,0"
    label = f"s{strate}-w{workers}-{version}-{phase}{replicate}"
    log = OUT / f"{label}.log"
    command = [
        "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
        "timeout", "1740s", str(binary), str(DATA), "--world-assembler-prototype",
        "--stream-benchmark", "--stream-pipeline", f"--workers={workers}",
        "--clip-radius=3", "--max-clip-level=8", "--max-level=8",
        f"--camera={camera}", "--profile-lod-work", "--stream-scheduler-policy=3",
    ]
    started = time.monotonic()
    with log.open("w", encoding="utf-8") as output:
        proc = subprocess.run(command, cwd=ROOT, stdout=output,
                              stderr=subprocess.STDOUT, check=False, timeout=1740)
    content = log.read_text(encoding="utf-8", errors="replace")
    pipeline, near, stamp = PIPELINE.search(content), NEAR.search(content), STAMP.search(content)
    if (proc.returncode or pipeline is None or near is None or stamp is None
            or stamp.group(1) != expected_stamp):
        raise SystemExit(f"L80 timing failed or source stamp mismatch: {log}; exit={proc.returncode}")
    fields = dict(FIELDS.findall(pipeline.group(1)))
    row = {
        "strate": strate, "workers": workers, "version": version,
        "phase": phase, "replicate": replicate, "source_stamp": stamp.group(1),
        "lod02_ready_s": float(near.group(3)),
        "whole_view_ready_s": float(fields["whole_view_ready"].removesuffix("s")),
        "whole_tiles": int(fields["whole_tiles"].split("/")[0]),
        "wall_s": round(time.monotonic() - started, 3),
        "log": str(log.relative_to(ROOT)),
    }
    print("[L152TimingRun] " + json.dumps(row, sort_keys=True), flush=True)
    return row


def quiet_machine() -> tuple[float, float]:
    load_1m = os.getloadavg()[0]

    def totals() -> tuple[int, int]:
        fields = Path("/proc/stat").read_text().splitlines()[0].split()
        values = [int(value) for value in fields[1:]]
        return sum(values), values[3] + values[4]

    before = totals()
    time.sleep(2.0)
    after = totals()
    idle = 100.0 * (after[1] - before[1]) / max(1, after[0] - before[0])
    return load_1m, idle


def main() -> int:
    if any(not path.is_file() for path in [DATA, *(entry[0] for entry in BINARIES.values())]):
        raise SystemExit("missing L152 timing input")
    OUT.mkdir(parents=True, exist_ok=True)
    load_1m, idle = quiet_machine()
    (OUT / "machine-load-before.txt").write_text(
        f"1-minute load: {load_1m:.2f}\n2-second CPU idle: {idle:.1f}%\n")
    print(f"[L152TimingGate] load_1m={load_1m:.2f} cpu_idle_2s={idle:.1f}%", flush=True)
    if load_1m >= 1.5 or idle < 97.0:
        raise SystemExit("timing refused: machine is above the L80 quiet-load gate")

    rows = []
    versions = tuple(BINARIES)
    for strate in range(4):
        for workers in (8, 12):
            for version in versions:
                run(strate, workers, version, "warmup", 0)
            for replicate in range(1, 6):
                order = versions if replicate % 2 else tuple(reversed(versions))
                for version in order:
                    rows.append(run(strate, workers, version, "measured", replicate))
                    (OUT / "runs-partial.json").write_text(
                        json.dumps(rows, indent=2) + "\n", encoding="utf-8")

    measured = [row for row in rows if row["phase"] == "measured"]
    summary = []
    for strate in range(4):
        for workers in (8, 12):
            group = [row for row in measured
                     if row["strate"] == strate and row["workers"] == workers]
            medians = {
                version: {
                    key: statistics.median(row[key] for row in group
                                           if row["version"] == version)
                    for key in ("lod02_ready_s", "whole_view_ready_s")
                }
                for version in versions
            }
            entry = {"strate": strate, "workers": workers,
                     "replicates_per_version": 5, "medians": medians}
            for key in ("lod02_ready_s", "whole_view_ready_s"):
                entry[f"planner_head_vs_assembler_world_{key}_delta_pct"] = round(
                    100.0 * (medians["planner-head"][key]
                             / medians["assembler-world"][key] - 1.0), 2)
                entry[f"{key}_paired_deltas_pct"] = [
                    round(100.0 * (
                        next(row[key] for row in group
                             if row["version"] == "planner-head"
                             and row["replicate"] == replicate)
                        / next(row[key] for row in group
                               if row["version"] == "assembler-world"
                               and row["replicate"] == replicate) - 1.0), 3)
                    for replicate in range(1, 6)]
            summary.append(entry)
    (OUT / "summary.json").write_text(json.dumps({
        "a_a_noise_floor_pct": 1.0,
        "timing_protocol": (
            "one warm-up per binary, five interleaved runs per cell, W8/W12, "
            "all four owner layers; L137 A/A median noise floor ±1%"),
        "runs": rows,
        "summary": summary,
    }, indent=2) + "\n", encoding="utf-8")
    failed_cells = []
    for entry in summary:
        for measure in ("lod02_ready_s", "whole_view_ready_s"):
            delta = entry[f"planner_head_vs_assembler_world_{measure}_delta_pct"]
            if delta > 1.0:
                failed_cells.append({"strate": entry["strate"],
                                     "workers": entry["workers"],
                                     "measure": measure, "delta_pct": delta})
    report = json.loads((OUT / "summary.json").read_text(encoding="utf-8"))
    report["performance_floor_pct"] = 1.0
    report["performance_floor_rule"] = (
        "pass when no L152 median is more than 1% slower than assembler/world")
    report["performance_floor_failures"] = failed_cells
    report["status"] = "PASS" if not failed_cells else "FAIL"
    (OUT / "summary.json").write_text(json.dumps(report, indent=2) + "\n",
                                      encoding="utf-8")
    print(f"[L152TimingSummary] cells={len(summary)} failing_metrics={len(failed_cells)} "
          f"status={'PASS' if not failed_cells else 'FAIL'}", flush=True)
    return 0 if not failed_cells else 1


if __name__ == "__main__":
    raise SystemExit(main())