114 lines
5.3 KiB
Python
114 lines
5.3 KiB
Python
"""Add the reviewed CPU acceptance prerequisite to the fixed measurement entry."""
|
|
|
|
import argparse
|
|
import fcntl
|
|
from pathlib import Path
|
|
import os
|
|
import signal
|
|
from types import FunctionType
|
|
|
|
import track_b_gino_shapenet_entry as legacy
|
|
from track_b_gino_paper_keyword_patch import patch_identity
|
|
from track_b_gino_shapenet_entry import checked, read, save, sha, process_identity
|
|
|
|
|
|
ROOT = legacy.MEASUREMENT_ROOT.with_name("track-b-gino-shapenet611-import-checked-2026-11-19")
|
|
ORIGINAL_CONTRACT = "139fec49b7e4627b55ad12f3a129bec75ecc2446811c23a24f376dae207094aa"
|
|
WORKER = Path(__file__).with_name("track_b_gino_import_checked_worker.py").resolve()
|
|
|
|
|
|
def contract(path):
|
|
c = legacy.contract(path)
|
|
if c["mode"] != "measurement" or c["environment_ruling"] != "h-0d21f3bd":
|
|
raise PermissionError("Only the reviewed measurement environment delta is supported")
|
|
return c
|
|
|
|
|
|
def accepted_environment(c):
|
|
patch = patch_identity(c)
|
|
pin = c["environment_acceptance"]
|
|
receipt = read(checked(pin["path"], pin["sha256"]))
|
|
python = Path(c["environment"]["python"])
|
|
cfg = python.parent.parent / "pyvenv.cfg"
|
|
if (receipt["status"] != "PASS" or receipt["environment_ruling"] != c["environment_ruling"]
|
|
or receipt["original_contract_sha256"] != ORIGINAL_CONTRACT
|
|
or receipt["comparison_contract_sha256"] != c["comparison_contract_sha256"]
|
|
or receipt["paper_compatibility"] != c["paper_compatibility"]
|
|
or receipt["patched_decoder_file_sha256"] != patch["patched_file_sha256"]
|
|
or receipt["cuda_visible_devices"] != "" or receipt["scientific_training"] is not False
|
|
or receipt["heldout_target_reads"] != 0 or receipt["paper_decoder_cpu_forward"] is not True
|
|
or receipt["paper_loader_learning_only"] is not True or receipt["paper_metric_cpu"] is not True
|
|
or receipt["audited_learning_cases"] != [c["split"]["train"][0]]
|
|
or receipt["package_versions"] != c["environment"]["package_versions"]
|
|
or receipt["neuralop_commit"] != c["environment"]["neuralop_commit"]
|
|
or receipt["torch_cuda_build"] != c["environment"]["torch_cuda"]
|
|
or receipt["interpreter_path"] != str(python)
|
|
or receipt["interpreter_resolved_path"] != str(python.resolve(strict=True))
|
|
or receipt["interpreter_sha256"] != sha(python)
|
|
or receipt["pyvenv_cfg_sha256"] != sha(cfg)
|
|
or not os.access(python, os.X_OK)):
|
|
raise PermissionError("Matching CPU acceptance and isolated interpreter are required")
|
|
return receipt
|
|
|
|
|
|
def dispatch_guard(root, path):
|
|
def supervise(command, *args, **kwargs):
|
|
if Path(command[1]).name != "track_b_gino_shapenet_worker.py":
|
|
raise RuntimeError("Unexpected source worker route")
|
|
# The original guard's monitor closes over this exact command list.
|
|
# Select the checked wrapper before the shared supervisor can spawn.
|
|
command[1] = str(WORKER)
|
|
return legacy.supervise(command, *args, **kwargs)
|
|
|
|
namespace = dict(legacy.dispatch_guard.__globals__, contract=contract, supervise=supervise)
|
|
return FunctionType(legacy.dispatch_guard.__code__, namespace, legacy.dispatch_guard.__name__)(root, path)
|
|
|
|
|
|
def authorized_child(root):
|
|
root = Path(root).resolve()
|
|
if root != ROOT:
|
|
raise PermissionError("Only the new fixed measurement root")
|
|
c = contract(root / "contract.json")
|
|
accepted_environment(c)
|
|
namespace = dict(legacy.authorized_child.__globals__, MEASUREMENT_ROOT=ROOT, contract=contract)
|
|
return FunctionType(legacy.authorized_child.__code__, namespace, legacy.authorized_child.__name__)(root)
|
|
|
|
|
|
def run(root):
|
|
root = Path(root).resolve()
|
|
if root != ROOT:
|
|
raise PermissionError("Only the new fixed measurement root")
|
|
path = root / "contract.json"
|
|
c = contract(path)
|
|
accepted_environment(c)
|
|
legacy.validate_review(root)
|
|
authorization = read(root / "stage-authorization.json")
|
|
if (authorization["contract_sha256"] != sha(path) or authorization["decision"] != "APPROVED"
|
|
or authorization["mode"] != "measurement"):
|
|
raise PermissionError("Exact stage authorization is required")
|
|
with (root / "entry.lock").open("a") as lock:
|
|
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
|
if (root / "started.json").exists() or (legacy.MEASUREMENT_ROOT / "started.json").exists():
|
|
raise FileExistsError("The measurement attempt already has a start record")
|
|
environment = accepted_environment(c)
|
|
save(root / "started.json", dict(
|
|
coordinator=process_identity(os.getpid()), contract_sha256=sha(path),
|
|
cpu_acceptance_sha256=c["environment_acceptance"]["sha256"],
|
|
interpreter_path=environment["interpreter_path"], interpreter_sha256=environment["interpreter_sha256"]))
|
|
|
|
def request_stop(signum, _frame):
|
|
raise KeyboardInterrupt(signal.Signals(signum).name)
|
|
|
|
handler = signal.signal(signal.SIGTERM, request_stop)
|
|
try:
|
|
return dispatch_guard(root, path)
|
|
finally:
|
|
signal.signal(signal.SIGTERM, handler)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("root", type=Path)
|
|
args = parser.parse_args()
|
|
raise SystemExit(run(args.root))
|