import json import math import os import select import signal import statistics import struct import subprocess import sys import time import numpy as np sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) import graph_spec _HDR = struct.Struct("<4sQ") N_WORKERS = 8 N_CPUS = 8 WARMUPS = 3 REPS = 15 BUILD_TIMEOUT_SEC = 20.0 CALL_TIMEOUT_SEC = 120.0 ABS_TOL = 1e-3 REL_TOL = 1e-3 AGENT_UID = 1001 class WorkerError(RuntimeError): """Any failure of a child: crash, protocol violation, timeout, bad output.""" def _uid_of(pid): try: with open("/proc/%d/status" % pid, "rb") as fh: for line in fh: if line.startswith(b"Uid:"): return int(line.split()[1]) except (OSError, IndexError, ValueError): pass return None def _tasks_stopped(pids): for pid in pids: try: tids = os.listdir("/proc/%d/task" % pid) except OSError: continue for tid in tids: try: with open("/proc/%d/task/%s/stat" % (pid, tid), "rb") as fh: state = fh.read().rsplit(b")", 1)[1].split()[0] except (OSError, IndexError): continue if state not in (b"T", b"Z", b"X"): return False return True class Child: """A worker subprocess, SIGSTOPped whenever it is not the one being timed.""" def __init__(self, kind, rundir, python, launch_prefix=(), env=None, popen_kwargs=None): self.kind = kind argv = list(launch_prefix) + [python, "-I", "-B", os.path.join(rundir, "worker.py"), kind] self.proc = subprocess.Popen( argv, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=rundir, env=env, close_fds=True, start_new_session=True, **(popen_kwargs or {})) self.rfd = self.proc.stdout.fileno() self.wfd = self.proc.stdin.fileno() self.stopped = False self._pids = None self._expect(b"HI", BUILD_TIMEOUT_SEC) def _send(self, cmd, payload=b""): buf = _HDR.pack(cmd.ljust(4, b"\0"), len(payload)) + payload off = 0 deadline = time.monotonic() + CALL_TIMEOUT_SEC while off < len(buf): if time.monotonic() > deadline: raise WorkerError("%s: timed out sending a request" % self.kind) _, w, _ = select.select([], [self.wfd], [], 1.0) if not w: continue try: off += os.write(self.wfd, buf[off:off + (1 << 20)]) except OSError as exc: raise WorkerError("%s: pipe closed while sending (%s)" % (self.kind, exc)) def _read_exactly(self, n, deadline): out = bytearray() while len(out) < n: remaining = deadline - time.monotonic() if remaining <= 0: raise WorkerError("%s: timed out waiting for a response" % self.kind) r, _, _ = select.select([self.rfd], [], [], min(1.0, remaining)) if not r: continue chunk = os.read(self.rfd, n - len(out)) if not chunk: raise WorkerError("%s: exited before responding (rc=%s)" % (self.kind, self.proc.poll())) out += chunk return bytes(out) def _expect(self, cmd, timeout): deadline = time.monotonic() + timeout got, ln = _HDR.unpack(self._read_exactly(_HDR.size, deadline)) payload = self._read_exactly(ln, deadline) if ln else b"" got = got.rstrip(b"\0") if got != cmd: raise WorkerError("%s: expected %r, got %r" % (self.kind, cmd, got)) return payload def _signal(self, sig): try: os.killpg(self.proc.pid, sig) except OSError: pass def tree_pids(self, refresh=False): """The child's own process tree, including anything it started itself.""" if self._pids is not None and not refresh: return self._pids seen, stack = [], [self.proc.pid] while stack: pid = stack.pop() seen.append(pid) try: for tid in os.listdir("/proc/%d/task" % pid): with open("/proc/%d/task/%s/children" % (pid, tid)) as fh: stack.extend(int(v) for v in fh.read().split()) except (OSError, ValueError): pass self._pids = seen return seen def freeze(self): """SIGSTOP, then wait until every thread has really stopped. Returning early would let this child's threads -- BLAS worker threads busy-spin for a while after the last call returns -- drain into the other child's timed region, which would bias whichever executor is measured second. """ if not self.stopped: self._signal(signal.SIGSTOP) self.stopped = True deadline = time.monotonic() + 2.0 while not _tasks_stopped(self.tree_pids()): if time.monotonic() > deadline: break time.sleep(0.0002) def thaw(self): if self.stopped: self._signal(signal.SIGCONT) self.stopped = False self._send(b"PING") self._expect(b"PONG", CALL_TIMEOUT_SEC) def build(self, seed): t0 = time.perf_counter() self._send(b"BLD", str(int(seed)).encode()) self._expect(b"RDY", BUILD_TIMEOUT_SEC) return time.perf_counter() - t0 def call(self, xb): """Round-trip one input. Returns (seconds, header, raw output bytes).""" t0 = time.perf_counter() self._send(b"CALL", xb) payload = self._expect(b"OUT", CALL_TIMEOUT_SEC) dt = time.perf_counter() - t0 head, _, body = payload.partition(b"|") return dt, head.decode("utf-8", "replace"), body def stderr_tail(self, limit=2000): self._signal(signal.SIGCONT) self._signal(signal.SIGKILL) try: return self.proc.stderr.read().decode("utf-8", "replace")[-limit:] except Exception: return "" def close(self): self._signal(signal.SIGCONT) self.stopped = False try: self._send(b"EXIT") self.proc.wait(timeout=10) except Exception: self._signal(signal.SIGKILL) try: self.proc.wait(timeout=10) except subprocess.TimeoutExpired: pass for stream in (self.proc.stdin, self.proc.stdout, self.proc.stderr): try: stream.close() except Exception: pass def _quiesce(active): """Stop every unprivileged process that is not part of `active`'s tree. An executor that detaches a helper into its own session would otherwise keep burning cycles while the other executor is on the clock. Only the privileged harness can do this, so the developer-side harness (which runs unprivileged) skips it; the minimum statistic is what protects a measurement there. """ if os.geteuid() != 0: return 0 keep_pids = set(active.tree_pids(refresh=True)) strays = 0 try: pids = [int(p) for p in os.listdir("/proc") if p.isdigit()] except OSError: return 0 for pid in pids: if pid in keep_pids or _uid_of(pid) != AGENT_UID: continue try: os.kill(pid, signal.SIGSTOP) strays += 1 except OSError: pass return strays def _check_output(head, body, spec): """Validate a returned tensor. Returns the array or raises WorkerError.""" T, d = spec["T"], spec["d_model"] try: ndim, dtype, dims = head.split(",") dims = tuple(int(v) for v in dims.split("x")) if dims else () except ValueError: raise WorkerError("unparseable output header %r" % head) if int(ndim) != 2 or dims != (T, d): raise WorkerError("output shape %r, expected (%d, %d)" % (dims, T, d)) if dtype != "float32": raise WorkerError("output dtype %r, expected float32" % dtype) if len(body) != T * d * 4: raise WorkerError("output payload is %d bytes, expected %d" % (len(body), T * d * 4)) return np.frombuffer(body, dtype=np.float32).reshape(T, d) def _errors(y, y_ref): a = y.astype(np.float64) b = y_ref.astype(np.float64) if not np.all(np.isfinite(a)): return float("inf"), float("inf") diff = np.abs(a - b) max_abs = float(diff.max()) if diff.size else 0.0 denom = float(np.linalg.norm(b)) rel = float(np.linalg.norm(diff) / denom) if denom > 0 else max_abs return max_abs, rel def measure_instance(seed, ref, sub, warmups=WARMUPS, reps=REPS): """Time one instance. Returns a record; raises WorkerError on any child failure.""" spec = graph_spec.sample_spec(seed) xbs = [np.ascontiguousarray(x).tobytes() for x in graph_spec.build_inputs(spec, warmups + reps)] ref.freeze() sub.thaw() build_sub = sub.build(seed) sub.freeze() ref.thaw() build_ref = ref.build(seed) ref.freeze() times = {id(ref): [], id(sub): []} max_abs = 0.0 max_rel = 0.0 strays = 0 for i, xb in enumerate(xbs): first, second = (ref, sub) if i % 2 == 0 else (sub, ref) got = {} for child in (first, second): other = sub if child is ref else ref other.freeze() strays += _quiesce(child) child.thaw() dt, head, body = child.call(xb) child.freeze() got[id(child)] = (dt, head, body) y_ref = _check_output(got[id(ref)][1], got[id(ref)][2], spec) y_sub = _check_output(got[id(sub)][1], got[id(sub)][2], spec) a, r = _errors(y_sub, y_ref) max_abs = max(max_abs, a) max_rel = max(max_rel, r) if i >= warmups: times[id(ref)].append(got[id(ref)][0]) times[id(sub)].append(got[id(sub)][0]) ref_t, sub_t = times[id(ref)], times[id(sub)] ref_best, sub_best = min(ref_t), min(sub_t) equivalent = bool(max_abs <= ABS_TOL and max_rel <= REL_TOL) return { "seed": int(seed), "shape": {k: spec[k] for k in ("d_model", "d_ff", "n_layers", "n_heads", "n_kv_heads", "T")}, "ref_best_s": ref_best, "sub_best_s": sub_best, "ref_median_s": statistics.median(ref_t), "sub_median_s": statistics.median(sub_t), "ref_jitter": statistics.median(ref_t) / ref_best - 1.0, "sub_jitter": statistics.median(sub_t) / sub_best - 1.0, "build_ref_s": build_ref, "build_sub_s": build_sub, "strays_stopped": strays, "max_abs_err": max_abs, "rel_fro_err": max_rel, "equivalent": equivalent, "ratio": (ref_best / sub_best) if (equivalent and sub_best > 0) else 0.0, } def child_env(): """The environment both children get. BLAS gets the full worker budget.""" return { "PATH": "/usr/local/bin:/usr/local/sbin:/usr/sbin:/usr/bin:/sbin:/bin", "HOME": "/tmp", "LANG": "C.UTF-8", "PYTHONDONTWRITEBYTECODE": "1", "PYTHONHASHSEED": "0", "OPENBLAS_NUM_THREADS": str(N_WORKERS), "OMP_NUM_THREADS": str(N_WORKERS), "MKL_NUM_THREADS": str(N_WORKERS), "NUMEXPR_NUM_THREADS": str(N_WORKERS), "EXEC_N_WORKERS": str(N_WORKERS), "EXEC_N_CPUS": str(N_CPUS), } def measure(seeds, rundir, python=sys.executable, launch_prefix=(), popen_kwargs=None): """Measure every instance and aggregate. Returns the metric record.""" env = child_env() ref = sub = None per_instance = [] failure = None stderr_tail = "" try: ref = Child("ref", rundir, python, (), env, None) sub = Child("sub", rundir, python, launch_prefix, env, popen_kwargs) for seed in seeds: per_instance.append(measure_instance(int(seed), ref, sub)) except WorkerError as exc: failure = str(exc) except Exception as exc: failure = "%s: %s" % (type(exc).__name__, exc) finally: if failure is not None and sub is not None: stderr_tail = sub.stderr_tail() for child in (ref, sub): if child is not None: try: child.close() except Exception: pass n_ok = sum(1 for r in per_instance if r["equivalent"]) valid = bool(failure is None and len(per_instance) == len(seeds) == n_ok) if valid: metric = math.exp( sum(math.log(r["ratio"]) for r in per_instance) / len(per_instance)) else: metric = 0.0 return { "metric_name": "geometric_mean_speedup", "metric": metric, "valid": valid, "failure": failure, "stderr_tail": stderr_tail, "n_instances": len(seeds), "n_equivalent": n_ok, "per_instance": per_instance, } def dump(record, path): with open(path, "w") as fh: json.dump(record, fh, indent=2, sort_keys=True)