"""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()