scripts/benchmark_solutions.py

"""Build native Trace solutions, validate complete outputs, and time on a local GPU."""

import argparse
import contextlib
import fcntl
import json
import os
from pathlib import Path
import statistics
import time
import traceback

from task_acceptance import compare_output


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1])
    parser.add_argument("--capture-root", type=Path, help="Read fresh capture inputs and receipts from this directory")
    parser.add_argument("--solution", action="append", help="Solution name substring; repeatable")
    parser.add_argument("--gpu", required=True, help="Local NVIDIA GPU UUID")
    parser.add_argument("--lock-directory", type=Path, required=True)
    parser.add_argument("--report", type=Path, required=True)
    parser.add_argument("--limit", type=int, help="Maximum workloads per solution for an initial check")
    parser.add_argument("--validation-only", action="store_true")
    parser.add_argument("--compare-to", choices=("reference", "capture"), default="reference")
    parser.add_argument("--workload", action="append", help="Restrict to these workload UUIDs")
    args = parser.parse_args()
    root = args.root.resolve()
    data_root = args.capture_root.resolve() if args.capture_root else root
    cache = root / "results/baselines/cache"
    for name, suffix in {
        "FIB_CACHE_PATH": "trace", "XDG_CACHE_HOME": "xdg",
        "TRITON_CACHE_DIR": "triton", "TORCHINDUCTOR_CACHE_DIR": "inductor",
        "TORCH_EXTENSIONS_DIR": "extensions", "CUDA_CACHE_PATH": "cuda",
        "FLASHINFER_WORKSPACE_BASE": "flashinfer", "TVM_FFI_CACHE_DIR": "tvm",
        "DG_JIT_CACHE_DIR": "deepgemm", "SGLANG_CACHE_DIR": "sglang",
        "TILELANG_CACHE_DIR": "tilelang",
    }.items():
        os.environ.setdefault(name, str(cache / suffix))
    os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
    os.environ.setdefault("OMP_NUM_THREADS", "8")
    os.environ.setdefault("MAX_JOBS", "32")
    args.lock_directory.mkdir(parents=True, exist_ok=True)
    args.report.parent.mkdir(parents=True, exist_ok=True)
    with contextlib.ExitStack() as stack:
        for suffix in ("", ".lock"):
            lock = stack.enter_context((args.lock_directory / (args.gpu + suffix)).open("a+"))
            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
        import torch
        from safetensors.torch import load_file
        from flashinfer_bench.compile import BuilderRegistry
        from flashinfer_bench.data import Definition, Solution

        torch.set_num_threads(8)
        torch.backends.cuda.matmul.allow_tf32 = False
        definitions = {
            definition.name: definition
            for path in (root / "definitions").rglob("*.json")
            for definition in [Definition.model_validate_json(path.read_text())]
        }
        receipt_path = data_root / "captures.jsonl"
        if not receipt_path.exists():
            receipt_path = data_root / "results/captures.jsonl"
        receipts = {
            row["uuid"]: row for line in receipt_path.read_text().splitlines()
            for row in [json.loads(line)]
        }
        workloads = {}
        for path in (data_root / "workloads").rglob("*.jsonl"):
            for line in path.read_text().splitlines():
                row = json.loads(line)
                workloads.setdefault(row["definition"], []).append(row["workload"])
        solutions = [
            solution for path in sorted((root / "solutions").rglob("*.json"))
            for solution in [Solution.model_validate_json(path.read_text())]
            if not args.solution or any(name in solution.name for name in args.solution)
        ]
        if not solutions:
            raise ValueError("No solutions selected")

        def load(descriptor):
            if descriptor["type"] == "scalar":
                return descriptor["value"]
            if descriptor["type"] != "safetensors":
                raise ValueError("Only complete captured inputs are accepted")
            return load_file(str(data_root / descriptor["path"]), device="cuda")[descriptor["tensor_key"]]

        def compare(actual, expected, definition, output_name):
            config = json.loads((root / 'tasks' / f'{definition}.json').read_text())
            return compare_output(actual, expected, config['tolerance'])

        def measure(function):
            for _ in range(3):
                function()
            torch.cuda.synchronize()
            graph = torch.cuda.CUDAGraph()
            with torch.cuda.graph(graph):
                graph_output = function()
            graph.replay()
            torch.cuda.synchronize()
            start, end = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
            start.record()
            graph.replay()
            end.record()
            end.synchronize()
            single_ms = start.elapsed_time(end)
            repeats = max(1, min(1000, int(20 / max(single_ms, .001))))
            samples = []
            for _ in range(5):
                start.record()
                for _ in range(repeats):
                    graph.replay()
                end.record()
                end.synchronize()
                samples.append(start.elapsed_time(end) * 1000 / repeats)
            return {"median_us": statistics.median(samples), "samples_us": samples,
                    "repeats": repeats, "method": "CUDA events over CUDA Graph replays",
                    "scope": "complete solution call, including input adapters"}

        failures = 0
        with args.report.open("w") as report, torch.inference_mode():
            header = {"type": "environment", "gpu_uuid": args.gpu,
                      "gpu_name": torch.cuda.get_device_name(), "torch": torch.__version__,
                      "started_at": time.time(), "comparison": "all output elements against " + args.compare_to,
                      "solution_count": len(solutions)}
            report.write(json.dumps(header) + "\n")
            report.flush()
            for solution in solutions:
                definition = definitions[solution.definition]
                if definition.name not in workloads:
                    raise ValueError(f"No captured workloads for {definition.name}")
                runnable = BuilderRegistry.get_instance().build(definition, solution)
                selected = workloads[definition.name]
                if args.workload:
                    selected = [workload for workload in selected if workload["uuid"] in args.workload]
                if args.limit is not None:
                    selected = selected[:args.limit]
                reference = None
                if args.compare_to == "reference":
                    namespace = {}
                    exec(compile(definition.reference, definition.name, "exec"), namespace)
                    reference = namespace["run"]
                for workload in selected:
                    row = {"type": "workload", "solution": solution.name,
                           "definition": definition.name, "uuid": workload["uuid"],
                           "axes": workload["axes"]}
                    inputs = actual = expected = outputs = reference_outputs = None
                    try:
                        inputs = [load(workload["inputs"][key]) for key in definition.inputs]
                        actual = runnable(*inputs)
                        outputs = list(actual) if isinstance(actual, (tuple, list)) else [actual]
                        descriptors = receipts[workload["uuid"]].get("expected_output")
                        if reference is None and descriptors is None:
                            raise ValueError("This imported workload has no saved engine output; compare to reference")
                        if descriptors is not None and "type" in descriptors:
                            descriptors = {next(iter(definition.outputs)): descriptors}
                        if len(outputs) != len(definition.outputs):
                            raise AssertionError("Output count differs")
                        if reference is not None:
                            reference_result = reference(*inputs)
                            reference_outputs = list(reference_result) if isinstance(reference_result, (tuple, list)) else [reference_result]
                            reference_result = None
                        row["errors"] = {}
                        for index, (key, value) in enumerate(zip(definition.outputs, outputs)):
                            expected = reference_outputs[index] if reference_outputs is not None else load(descriptors[key])
                            row["errors"][key] = compare(value, expected, definition.name, key)
                        row["validation"] = "passed"
                        actual = expected = outputs = reference_outputs = None
                        if not args.validation_only:
                            row["timing"] = measure(lambda: runnable(*inputs))
                        row["status"] = "passed"
                    except Exception:
                        row.update(status="failed", error=traceback.format_exc())
                        failures += 1
                    finally:
                        inputs = actual = expected = outputs = reference_outputs = None
                    report.write(json.dumps(row) + "\n")
                    report.flush()
                    print(row["status"], solution.name, workload["axes"],
                          row.get("timing", {}).get("median_us"), flush=True)
        if failures:
            raise SystemExit(f"{failures} failed workloads; see {args.report}")


if __name__ == "__main__":
    main()