"""Validate and time actual solutions against independent task references.""" import argparse import contextlib import fcntl import hashlib import importlib.util import json import os from pathlib import Path import statistics import sys import time import traceback from task_acceptance import compare_output parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1]) parser.add_argument( "--data-root", type=Path, help="Optional materialized dataset with the same paths" ) parser.add_argument("--lock-directory", type=Path, required=True) parser.add_argument( "--cache-directory", type=Path, help="Writable module and reference cache" ) parser.add_argument("--definition", action="append") parser.add_argument("--suite", choices=["first", "dev", "all"], default="first") parser.add_argument("--only-default", action="store_true") parser.add_argument("--report", required=True, type=Path) parser.add_argument("--validation-only", action="store_true") parser.add_argument("--scale-probe", action="store_true") parser.add_argument("--gpu", required=True) parser.add_argument("--workload", action="append") parser.add_argument("--solution", action="append") parser.add_argument( "--candidate", action="append", default=[], help="Extra run() module for comparing a candidate on one selected definition", ) parser.add_argument("--reference-cache", action="store_true") parser.add_argument("--graph-timing", action="store_true") parser.add_argument( "--strict-diagnostic", action="store_true", help="Also report the historical FP32 bound for GDN; does not affect task acceptance", ) args = parser.parse_args() SOURCE = args.root.resolve() DATA = args.data_root.resolve() if args.data_root else SOURCE CACHE = ( args.cache_directory.resolve() if args.cache_directory else SOURCE / "results/audit-cache" ) GPU = args.gpu LOCKS = args.lock_directory LOCKS.mkdir(exist_ok=True, parents=True) os.environ["CUDA_VISIBLE_DEVICES"] = GPU stack = contextlib.ExitStack() for suffix in ["", ".lock"]: handle = stack.enter_context((LOCKS / (GPU + suffix)).open("a+")) fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB) import torch from safetensors.torch import load_file torch.set_num_threads(8) torch.backends.cuda.matmul.allow_tf32 = False torch._inductor.config.compile_threads = 1 def load_function(name, path): identifier = "_audit_" + hashlib.sha256(name.encode()).hexdigest()[:20] package = path.parent spec = importlib.util.spec_from_file_location( identifier, package / "__init__.py", submodule_search_locations=[str(package)] ) if path.name != "main.py": spec = importlib.util.spec_from_file_location(identifier, path) module = importlib.util.module_from_spec(spec) sys.modules[identifier] = module spec.loader.exec_module(module) if path.name == "main.py": spec = importlib.util.spec_from_file_location(identifier + ".main", path) child = importlib.util.module_from_spec(spec) sys.modules[spec.name] = child spec.loader.exec_module(child) module = child return module.run, getattr(module, "prepare", None) def normalize(result, definition): return ( list(result.values()) if isinstance(result, dict) else list(result) if isinstance(result, (tuple, list)) else [result] ) def compare(actual, expected, definition, config): values = normalize(actual, definition) assert len(values) == len(expected) metrics = {} for name, value, reference in zip(definition["outputs"], values, expected): metrics[name] = compare_output(value, reference, config["tolerance"]) return metrics def measure(function, inputs, timing): for _ in range(timing["warmup"]): _result = function(*inputs) torch.cuda.synchronize() samples = [] for _ in range(timing["iters"] * timing["trials"]): start = torch.cuda.Event(enable_timing=True) end = torch.cuda.Event(enable_timing=True) start.record() _result = function(*inputs) end.record() end.synchronize() samples.append(start.elapsed_time(end) * 1000) return { "median_us": statistics.median(samples), "samples_us": samples, "method": "CUDA events over eager calls", } def measure_graph(function, inputs, timing, definition, config, expected): for _ in range(max(3, timing["warmup"])): result = function(*inputs) torch.cuda.synchronize() graph = torch.cuda.CUDAGraph() with torch.cuda.graph(graph): for _ in range(timing["iters"]): result = function(*inputs) graph.replay() torch.cuda.synchronize() compare(result, expected, definition, config) samples = [] for _ in range(timing["trials"]): start = torch.cuda.Event(enable_timing=True) end = torch.cuda.Event(enable_timing=True) start.record() graph.replay() end.record() end.synchronize() samples.append(start.elapsed_time(end) * 1000 / timing["iters"]) return { "median_us": statistics.median(samples), "samples_us": samples, "method": "CUDA graph, iters calls per replay", "calls_per_replay": timing["iters"], } definitions = { json.loads(f.read_text())["name"]: json.loads(f.read_text()) for f in (SOURCE / "definitions").rglob("*.json") } solutions = {} for f in (SOURCE / "solutions").rglob("*.json"): s = json.loads(f.read_text()) solutions.setdefault(s["definition"], []).append(s) rows_by_name = { f.stem: [json.loads(l)["workload"] for l in f.read_text().splitlines()] for f in (SOURCE / "workloads").rglob("*.jsonl") } args.report.parent.mkdir(exist_ok=True, parents=True) failures = 0 with args.report.open("w") as report, torch.inference_mode(): def emit(row): report.write(json.dumps(row) + "\n") report.flush() emit( { "type": "environment", "gpu": torch.cuda.get_device_name(), "torch": torch.__version__, "suite": args.suite, "pythonpath": os.environ.get("PYTHONPATH"), "started_at": time.time(), } ) for name, definition in definitions.items(): if args.definition and name not in args.definition: continue config = json.loads((SOURCE / "tasks" / f"{name}.json").read_text()) rows = rows_by_name[name] if args.suite == "dev": rows = [row for row in rows if row["uuid"] in config["dev"]] if args.suite == "first": rows = rows[:1] if args.workload: rows = [row for row in rows if row["uuid"] in args.workload] candidates = [] for solution in solutions[name]: if args.only_default and solution["name"] == "sglang_" + name: continue digest = hashlib.sha256( json.dumps(solution, sort_keys=True).encode() ).hexdigest() package = CACHE / "modules" / digest for source in solution["sources"]: target = package / source["path"] if not target.resolve().is_relative_to(package.resolve()): raise ValueError("Source path escapes package") target.parent.mkdir(parents=True, exist_ok=True) target.write_text(source["content"]) (package / "__init__.py").touch() entry = solution["spec"]["entry_point"].split("::")[0] candidates.append((solution["name"], package / entry)) if args.candidate: assert args.definition and len(args.definition) == 1 candidates.extend((Path(p).stem, Path(p)) for p in args.candidate) if args.solution: candidates = [(s, p) for s, p in candidates if s in args.solution] ns = {} exec(definition["reference"], ns) reference = ns["run"] for solution, path in candidates: try: function, prepare = load_function(solution, path) except Exception: failures += 1 emit( { "type": "load", "definition": name, "solution": solution, "status": "failed", "error": traceback.format_exc(), } ) print("LOAD FAILED", name, solution, flush=True) continue for row in rows: inputs = [] saved = [] expected = [] result = { "type": "workload", "definition": name, "solution": solution, "uuid": row["uuid"], "axes": row["axes"], "solution_sha256": hashlib.sha256(path.read_bytes()).hexdigest(), "definition_sha256": hashlib.sha256( json.dumps(definition, sort_keys=True).encode() ).hexdigest(), "task_sha256": hashlib.sha256( json.dumps(config, sort_keys=True).encode() ).hexdigest(), } try: for key in definition["inputs"]: desc = row["inputs"][key] value = ( desc["value"] if desc["type"] == "scalar" else load_file(str(DATA / desc["path"]), device="cuda")[ desc["tensor_key"] ] ) inputs.append(value) saved.append( value.clone() if isinstance(value, torch.Tensor) else value ) cache_key = hashlib.sha256( json.dumps( { "reference": definition["reference"], "row": row, "torch": torch.__version__, }, sort_keys=True, ).encode() ).hexdigest() cache = CACHE / "references" / (cache_key + ".pt") if args.reference_cache and cache.exists(): expected = [ value.to("cuda") for value in torch.load(cache, weights_only=True) ] else: expected = [ value.clone() for value in normalize(reference(*inputs), definition) ] if args.reference_cache: cache.parent.mkdir(exist_ok=True, parents=True) torch.save([value.cpu() for value in expected], cache) actual_result = function(*inputs) result["errors"] = compare( actual_result, expected, definition, config ) if args.strict_diagnostic and name.startswith("gdn_"): result["strict_fp32_diagnostic"] = {} for key, value, target in zip( definition["outputs"], normalize(actual_result, definition), expected, ): if value.dtype == torch.float32: close = torch.isclose( value, target, rtol=1e-4, atol=2e-5 ) result["strict_fp32_diagnostic"][key] = { "rtol": 1e-4, "atol": 2e-5, "mismatched_elements": int((~close).sum()), "elements": close.numel(), "passes": bool(close.all()), } for key, value, original in zip( definition["inputs"], inputs, saved ): if isinstance(value, torch.Tensor): assert torch.equal( value.contiguous().view(torch.uint8), original.contiguous().view(torch.uint8), ), key + " input mutated" if args.scale_probe and "scale" in definition["inputs"]: index = list(definition["inputs"]).index("scale") original = inputs[index] inputs[index] = ( definition["axes"]["head_size"]["value"] ** -0.5 if original is None or original == 0 else original ) * 0.5 target = [ value.clone() for value in normalize(reference(*inputs), definition) ] result["scale_probe"] = compare( function(*inputs), target, definition, config ) inputs[index] = original if not args.validation_only: result["run_timing"] = measure( function, inputs, config["timing"] ) if prepare: launch = prepare(*inputs) result["prepared_timing"] = measure( lambda *unused: launch(), inputs, config["timing"] ) if args.graph_timing: try: launch_function = ( (lambda *unused: launch()) if prepare else function ) result["graph_timing"] = measure_graph( launch_function, inputs, config["timing"], definition, config, expected, ) except Exception: result["graph_error"] = traceback.format_exc() for key, value, original in zip( definition["inputs"], inputs, saved ): if isinstance(value, torch.Tensor): assert torch.equal( value.contiguous().view(torch.uint8), original.contiguous().view(torch.uint8), ), key + " input mutated during timing" result["inputs_unchanged"] = True result["status"] = "passed" except Exception: failures += 1 result.update(status="failed", error=traceback.format_exc()) emit(result) print( result["status"], name, solution, row["axes"], result.get("run_timing", {}).get("median_us"), flush=True, ) inputs = saved = expected = actual_result = None function = prepare = None if failures: raise SystemExit(f"{failures} failed cases; see {args.report}")