File size: 7,329 Bytes
cb49561 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | import json
import os
import shutil
import stat
import subprocess
import sys
import tempfile
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import grader_core
TESTS_DIR = os.path.dirname(os.path.abspath(__file__))
DELIVERABLE = "/app/output"
ENTRY_POINT = "executor.py"
LOG_DIR = "/logs/verifier"
CORE_MODULES = ("worker.py", "graph_spec.py", "reference_executor.py")
SPLIT = os.environ.get("GRADE_SPLIT", "final")
PRIVATE = SPLIT == "final"
PREFLIGHT_TIMEOUT_SEC = 120.0
_RESULT = {}
def _sealed_seeds():
path = os.path.join(TESTS_DIR, "hidden_data", SPLIT, "seeds.json")
with open(path) as fh:
return [int(s) for s in json.load(fh)["seeds"]]
def _privilege_drop():
"""Run candidate code as uid 1001, never as root.
Returns (argv prefix, extra Popen kwargs). `runuser` is the normal path; the
Popen user=/group= form is a binary-free fallback so that a base image without
util-linux cannot silently turn every rollout into a zero.
"""
runuser = shutil.which("runuser")
if runuser:
return [runuser, "-u", "agent", "--"], {}
setpriv = shutil.which("setpriv")
if setpriv:
return [setpriv, "--reuid=1001", "--regid=1001", "--clear-groups", "--"], {}
return [], {"user": 1001, "group": 1001}
def _reject_links(root):
"""Refuse a submission tree containing anything but plain files and directories.
A symlink or a hard link inside the deliverable would let a privileged copy
materialise a file from outside the deliverable into the directory the score is
computed from.
"""
if os.path.islink(root):
raise RuntimeError("%s is a symlink" % root)
for dirpath, dirnames, filenames in os.walk(root, followlinks=False):
for name in dirnames + filenames:
path = os.path.join(dirpath, name)
st = os.lstat(path)
if stat.S_ISLNK(st.st_mode):
raise RuntimeError("symlink in the deliverable: %s" % path)
if stat.S_ISREG(st.st_mode) and st.st_nlink > 1:
raise RuntimeError("hard link in the deliverable: %s" % path)
if not (stat.S_ISREG(st.st_mode) or stat.S_ISDIR(st.st_mode)):
raise RuntimeError("not a regular file or directory: %s" % path)
def _stage():
"""Copy the verifier's own modules and the submission into a root-owned run dir."""
run = tempfile.mkdtemp(prefix="grade_", dir="/tmp")
for name in CORE_MODULES:
shutil.copy2(os.path.join(TESTS_DIR, name), os.path.join(run, name))
dst = os.path.join(run, "submission")
_reject_links(DELIVERABLE)
shutil.copytree(DELIVERABLE, dst, symlinks=True)
for dirpath, dirnames, filenames in os.walk(run):
os.chown(dirpath, 0, 0)
os.chmod(dirpath, 0o755)
for name in filenames:
path = os.path.join(dirpath, name)
os.chown(path, 0, 0)
os.chmod(path, 0o644)
os.chmod(run, 0o755)
return run
def _preflight(run, prefix, popen_kwargs):
"""Import the entry point in a throwaway unprivileged process, for a clear message."""
code = ("import sys; sys.path.insert(0, %r); sys.path.insert(0, %r); "
"import executor; assert callable(executor.build_executor)"
% (run, os.path.join(run, "submission")))
proc = subprocess.run(prefix + [sys.executable, "-I", "-B", "-c", code],
capture_output=True, text=True, cwd=run,
timeout=PREFLIGHT_TIMEOUT_SEC, check=False,
start_new_session=True, **popen_kwargs)
return proc.returncode, (proc.stderr or "")[-2000:]
def _grade():
if _RESULT:
return _RESULT
record = {
"metric_name": "geometric_mean_speedup",
"metric": 0.0,
"valid": False,
"failure": None,
"split": SPLIT,
"per_instance": [],
"n_instances": 0,
"n_equivalent": 0,
"preflight_rc": None,
"preflight_stderr": "",
}
run = None
try:
entry = os.path.join(DELIVERABLE, ENTRY_POINT)
if not os.path.isfile(entry):
raise RuntimeError("no entry point at %s" % entry)
prefix, popen_kwargs = _privilege_drop()
run = _stage()
rc, err = _preflight(run, prefix, popen_kwargs)
record["preflight_rc"] = rc
record["preflight_stderr"] = err
if rc != 0:
raise RuntimeError("executor.py could not be imported (rc=%s)" % rc)
measured = grader_core.measure(_sealed_seeds(), run, python=sys.executable,
launch_prefix=prefix,
popen_kwargs=popen_kwargs)
record.update({k: measured[k] for k in
("metric", "valid", "failure", "per_instance",
"n_instances", "n_equivalent")})
record["stderr_tail"] = measured.get("stderr_tail", "")
except Exception as exc:
record["metric"] = 0.0
record["valid"] = False
record["failure"] = "%s: %s" % (type(exc).__name__, exc)
finally:
if run:
shutil.rmtree(run, ignore_errors=True)
os.makedirs(LOG_DIR, exist_ok=True)
with open(os.path.join(LOG_DIR, "metric.json"), "w") as fh:
json.dump(record, fh, indent=2, sort_keys=True)
_RESULT.update(record)
return record
def test_deliverable_is_present_and_importable():
"""The graded deliverable exists at the declared path and imports cleanly."""
record = _grade()
assert record["preflight_rc"] == 0, (
"executor.py missing or not importable: %s\n%s"
% (record["failure"], record.get("preflight_stderr", "")))
def test_output_matches_the_reference_on_every_sealed_instance():
"""Every sealed instance is executed and its output matches the reference."""
record = _grade()
assert record["n_instances"] > 0, "no instance completed: %s" % record["failure"]
bad = [i for i, r in enumerate(record["per_instance"]) if not r["equivalent"]]
assert not bad, (
"outputs differ from the reference on instance(s) %s of %d (tolerances: "
"max abs <= %g, relative Frobenius <= %g)"
% (bad, record["n_instances"], grader_core.ABS_TOL, grader_core.REL_TOL))
assert record["valid"], "measurement did not complete: %s" % record["failure"]
def test_speedup_metric_is_recorded():
"""The geometric-mean speedup is measured and written to metric.json."""
record = _grade()
assert os.path.isfile(os.path.join(LOG_DIR, "metric.json"))
print("instances=%d equivalent=%d geometric-mean speedup=%.4f"
% (record["n_instances"], record["n_equivalent"], record["metric"]))
ratios = sorted(r["ratio"] for r in record["per_instance"])
if ratios:
print("per-instance speedup: min %.4f median %.4f max %.4f"
% (ratios[0], ratios[len(ratios) // 2], ratios[-1]))
if PRIVATE:
for r in record["per_instance"]:
print(" seed %6d T=%-4d d=%-5d L=%-3d ref %8.2f ms sub %8.2f ms ratio %.4f"
% (r["seed"], r["shape"]["T"], r["shape"]["d_model"],
r["shape"]["n_layers"], r["ref_best_s"] * 1e3,
r["sub_best_s"] * 1e3, r["ratio"]))
assert record["metric"] >= 0.0
|