| """Batch driver: run many families/versions on one trn2 host. |
| |
| python harness/batch.py --hw dataset/ [--workers 4] [--shapes ...] [--reps 2] [--force] [--tar out.tgz] |
| python harness/batch.py --sim dataset/ [--workers 4] |
| |
| - Finds every version dir under the given paths. |
| - One lane per Neuron device (trn2.3xlarge: 1, trn2.48xlarge: 16). Lane d runs, for each version it |
| pulls from the queue, compile+parity (`hwc`) then profile (`hwp`) on the first logical core of |
| device d -- one process at a time per chip, so a profile never shares its chip with another run. |
| LNC=1 versions run first, then LNC=2 (never mixed on the host at the same time). |
| - Resumable: a version is skipped if its results are complete and current (kernel sha256 and |
| manifest unchanged, see `fingerprint`). --force reruns. |
| - Every outcome appends a line to batch_status.jsonl in the package root (parent of harness/) and |
| prints a final table with |
| the failure class (HWPARITYFAIL, CAPFAIL, INGESTFAIL, LNCMISMATCH, NONEFF, COMPILEFAIL, SIMFAIL). |
| """ |
| import argparse, glob, hashlib, json, os, subprocess, sys, tarfile, time |
| from concurrent.futures import ThreadPoolExecutor |
|
|
| HERE = os.path.dirname(os.path.abspath(__file__)) |
| RUN = os.path.join(HERE, "run.py") |
| CLASSES = ("COMPILEFAIL", "HWPARITYFAIL", "CAPFAIL", "INGESTFAIL", "LNCMISMATCH", "NONEFF") |
|
|
|
|
| def yload(p): |
| import yaml |
| return yaml.safe_load(open(p)) |
|
|
|
|
| def versions(paths): |
| out = [] |
| for p in paths: |
| for m in sorted(glob.glob(os.path.join(os.path.abspath(p), "**", "manifest.yaml"), recursive=True)): |
| vd = os.path.dirname(m) |
| if os.path.isfile(os.path.join(os.path.dirname(vd), "family.yaml")): |
| out.append(vd) |
| return out |
|
|
|
|
| EXEC_KEYS = ("entry", "launch_grid", "shapes", "extra_outputs", "call_adapter", "deps", "port") |
|
|
|
|
| def fingerprint(vd): |
| """Hash of everything that affects execution. Manifest metadata (provenance, labels, summaries) |
| is excluded, so editing it does not invalidate results.""" |
| h = hashlib.sha256() |
| fd = os.path.dirname(vd) |
| man = yload(os.path.join(vd, "manifest.yaml")) |
| h.update(json.dumps({k: man.get(k) for k in EXEC_KEYS}, sort_keys=True).encode()) |
| for p in [os.path.join(vd, "kernel.py"), os.path.join(fd, "family.yaml"), |
| os.path.join(fd, "inputs.py"), os.path.join(fd, "reference.py")] + sorted(glob.glob(os.path.join(fd, "adapter*.py"))) + sorted(glob.glob(os.path.join(vd, "deps", "**", "*.py"), recursive=True)): |
| h.update(open(p, "rb").read()) |
| return h.hexdigest() |
|
|
|
|
| def complete(vd, mode): |
| rd = os.path.join(vd, "results") |
| fp = os.path.join(rd, f".fingerprint_{mode}") |
| if not os.path.isfile(fp) or open(fp).read().strip() != fingerprint(vd): |
| return False |
| if mode == "sim": |
| p = os.path.join(rd, "sim_parity.json") |
| return os.path.isfile(p) and json.load(open(p)).get("pass") |
| p, t = os.path.join(rd, "hw_parity.json"), os.path.join(rd, "timing.json") |
| return os.path.isfile(p) and json.load(open(p)).get("pass") and os.path.isfile(t) |
|
|
|
|
| def run_phase(phase, vd, core, shapes, reps, logdir): |
| man = yload(os.path.join(vd, "manifest.yaml")) |
| env = dict(os.environ, NEURON_LOGICAL_NC_CONFIG=str(man.get("launch_grid", 1)), NEURON_RT_VISIBLE_CORES=str(core)) |
| env.setdefault("NEURON_PLATFORM_TARGET_OVERRIDE", "trn2"); env.setdefault("NKI_LNC1_SHARED_HBM", "0"); env.setdefault("TORCH_DEVICE_BACKEND_AUTOLOAD", "0") |
| cmd = [sys.executable, RUN, "--_one", phase, vd, "--reps", str(reps)] + (["--shapes", shapes] if shapes else []) |
| log = os.path.join(logdir, man["id"].replace("/", "__") + f".{phase}.log") |
| t0 = time.time() |
| with open(log, "w") as f: |
| rc = subprocess.run(cmd, env=env, stdout=f, stderr=subprocess.STDOUT).returncode |
| txt = open(log, errors="ignore").read() |
| cls = next((c for c in CLASSES if c in txt), None) |
| if rc and not cls: |
| cls = {"hwc": "COMPILEFAIL", "hwp": "PROFILEFAIL", "sim": "SIMFAIL"}[phase] |
| return {"id": man["id"], "phase": phase, "rc": rc, "class": cls, "core": core, "lnc": man.get("launch_grid", 1), |
| "wall_s": round(time.time() - t0, 1), "log": log} |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| g = ap.add_mutually_exclusive_group(required=True) |
| g.add_argument("--hw", nargs="+"); g.add_argument("--sim", nargs="+") |
| ap.add_argument("--workers", type=int, default=0, help="hw: device lanes (default all devices); sim: threads (default 4)") |
| ap.add_argument("--shapes", default="") |
| ap.add_argument("--reps", type=int, default=2) |
| ap.add_argument("--force", action="store_true") |
| ap.add_argument("--devices", type=int, default=0, help="Neuron devices on the host (default: count /dev/neuron*)") |
| ap.add_argument("--tar", default="") |
| a = ap.parse_args() |
| mode = "hw" if a.hw else "sim" |
| paths = a.hw or a.sim |
| vds = versions(paths) |
| base = os.path.dirname(HERE) |
| logdir = os.path.join(base, "batch_logs"); os.makedirs(logdir, exist_ok=True) |
| status = open(os.path.join(base, "batch_status.jsonl"), "a") |
| todo = [v for v in vds if a.force or not complete(v, mode)] |
| print(f"{len(vds)} versions, {len(vds) - len(todo)} already complete, {len(todo)} to run ({mode})", flush=True) |
| results = {} |
|
|
| def record(r): |
| status.write(json.dumps(dict(r, t=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()))) + "\n"); status.flush() |
| print(f"{'OK ' if r['rc'] == 0 else 'FAIL'} {r['phase']} {r['id']} core={r['core']} {r['wall_s']}s {r['class'] or ''}", flush=True) |
|
|
| if mode == "sim": |
| with ThreadPoolExecutor(a.workers or 4) as ex: |
| for v, r in ex.map(lambda v: (v, run_phase("sim", v, 0, a.shapes, a.reps, logdir)), todo): |
| record(r); results[r["id"]] = r |
| if r["rc"] == 0: |
| open(os.path.join(v, "results", ".fingerprint_sim"), "w").write(fingerprint(v)) |
| else: |
| by_lnc = {1: [v for v in todo if yload(os.path.join(v, "manifest.yaml")).get("launch_grid", 1) == 1], |
| 2: [v for v in todo if yload(os.path.join(v, "manifest.yaml")).get("launch_grid", 1) == 2]} |
| ndev = a.devices or max(1, len(glob.glob("/dev/neuron[0-9]*"))) |
| cpd = {1: 8, 2: 4} |
| lanes = max(1, min(a.workers, ndev)) if a.workers else ndev |
| print(f"{ndev} Neuron device(s); {lanes} device lanes (each: compile -> profile, serial on its own chip)", flush=True) |
| for lnc in (1, 2): |
| queue = [v for v in todo if yload(os.path.join(v, "manifest.yaml")).get("launch_grid", 1) == lnc] |
| if not queue: |
| continue |
|
|
| def lane(d): |
| core = d * cpd[lnc] |
| while True: |
| try: |
| v = queue.pop(0) |
| except IndexError: |
| return |
| r = run_phase("hwc", v, core, a.shapes, a.reps, logdir); record(r); results[r["id"]] = r |
| if r["rc"]: |
| continue |
| r = run_phase("hwp", v, core, a.shapes, a.reps, logdir); record(r); results[r["id"]] = r |
| if r["rc"] == 0: |
| open(os.path.join(v, "results", ".fingerprint_hw"), "w").write(fingerprint(v)) |
| with ThreadPoolExecutor(lanes) as ex: |
| list(ex.map(lane, range(lanes))) |
| status.close() |
| fails = {k: v for k, v in results.items() if v["rc"]} |
| by = {} |
| for v in fails.values(): |
| by.setdefault(v["class"], []).append(v["id"]) |
| print(f"\nBATCH DONE {mode}: ran {len(results)}, ok {len(results) - len(fails)}, failed {len(fails)}") |
| for c, ids in sorted(by.items()): |
| print(f" {c}: {len(ids)} e.g. {ids[:5]}") |
| if a.tar: |
| with tarfile.open(a.tar, "w:gz") as tf: |
| for v in vds: |
| rd = os.path.join(v, "results") |
| if os.path.isdir(rd): |
| tf.add(rd, arcname=os.path.relpath(rd, os.path.commonpath([os.path.abspath(x) for x in paths] + [rd]) if len(paths) > 1 else os.path.dirname(os.path.abspath(paths[0]))), |
| filter=lambda ti: None if "/_work" in ti.name else ti) |
| tf.add(os.path.join(base, "batch_status.jsonl"), arcname="batch_status.jsonl") |
| print("tarball", a.tar) |
| sys.exit(1 if fails else 0) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
