105 lines
4.7 KiB
Python
105 lines
4.7 KiB
Python
"""Prepare the reserve-only 1b revision and replay the unchanged guard."""
|
|
|
|
from copy import deepcopy
|
|
from functools import partial
|
|
from pathlib import Path
|
|
from tempfile import TemporaryDirectory
|
|
from types import FunctionType
|
|
from unittest.mock import Mock
|
|
|
|
from phase2_h1_worker_v2 import checked, save, sha
|
|
import phase3_item1b_fold0 as legacy
|
|
from s2_gpu_idle_gate import wait_idle
|
|
|
|
|
|
ROOT = legacy.ROOT.with_name("phase3-item1b-fold0-wait-reserve-2026-11-19")
|
|
OLD_BINDING = "ed6bfe113f9c0bf925684a62cf0c1bb09bfc7b1277e06fad628fc0e9e5bcd859"
|
|
OLD_REVIEW = "0fadd70d365e1015f835fb953691797811a032766d3a9c1b75f3b8e4678faf61"
|
|
|
|
|
|
def expected_contract():
|
|
checked(legacy.ROOT / "expected-review-binding.json", OLD_BINDING)
|
|
old = legacy.contract(legacy.ROOT / "contract.json")
|
|
revised = deepcopy(old)
|
|
revised["version"] = "phase3-item1b-fold0-screen-wait-reserve-v2"
|
|
revised["budget"].update(waiting_reserve_gpu_seconds=66, projected_new_gpu_seconds=13186)
|
|
source = Path(__file__).resolve()
|
|
revised["code_sha256"][str(source)] = sha(source)
|
|
return revised
|
|
|
|
|
|
def load_contract(path):
|
|
revision = legacy.read(path)
|
|
if revision != expected_contract():
|
|
raise PermissionError("Only the reserve-only revision is allowed")
|
|
budget = revision["budget"]
|
|
reserved = sum(budget[name] for name in (
|
|
"train_gpu_seconds", "screen_gpu_seconds",
|
|
"waiting_reserve_gpu_seconds", "finalization_gpu_seconds"))
|
|
if (budget["idle_wait_seconds"] != 60 or reserved != budget["projected_new_gpu_seconds"]
|
|
or budget["prior_item_gpu_seconds"] + reserved > budget["item_gpu_limit_seconds"]
|
|
or budget["prior_phase3_gpu_seconds"] + reserved > budget["phase3_gpu_limit_seconds"]):
|
|
raise PermissionError("Revised projection outside original authorization")
|
|
return revision
|
|
|
|
|
|
def replay(path, query_seconds):
|
|
clock = 0.
|
|
samples = []
|
|
|
|
def sleep(seconds):
|
|
nonlocal clock
|
|
clock += seconds
|
|
|
|
def snapshot(uuid):
|
|
samples.append(clock)
|
|
sleep(query_seconds)
|
|
return dict(uuid=uuid, idle=False, memory_MiB=1500, occupants=[])
|
|
|
|
dispatch = Mock(side_effect=AssertionError("Busy-card path must not dispatch"))
|
|
guarded = legacy.dispatch_guard
|
|
# The same compiled guard and the same shared wait run here. Only the
|
|
# recovery contract loader and the CPU simulation boundaries are supplied.
|
|
namespace = dict(
|
|
guarded.__globals__, contract=load_contract, snapshot=snapshot,
|
|
wait_idle=partial(wait_idle, clock=lambda: clock, sleep=sleep), supervise=dispatch)
|
|
guard = FunctionType(guarded.__code__, namespace, guarded.__name__)
|
|
with TemporaryDirectory(prefix="meltmind-fold0-busy-replay-") as scratch:
|
|
out = Path(scratch)
|
|
returned = guard(out, path)
|
|
result = legacy.read(out / "complete.json")
|
|
if not (returned == 1 and result["trigger"] == "IDLE_TIMEOUT" and dispatch.call_count == 0):
|
|
raise RuntimeError(f"Unexpected busy replay at {query_seconds} seconds")
|
|
return dict(query_seconds=query_seconds, sample_start_seconds=samples,
|
|
terminal=result["trigger"], dispatches=dispatch.call_count,
|
|
booked_wait_gpu_seconds=result["queue_wait_gpu_seconds"],
|
|
within_revised_reserve=result["queue_wait_gpu_seconds"] <= 66)
|
|
|
|
|
|
def prepare():
|
|
old_review_path = ROOT.parent / "meltassist-item1b-fold0-screen-review-2026-11-19/review.json"
|
|
checked(old_review_path, OLD_REVIEW)
|
|
ROOT.mkdir(exist_ok=False)
|
|
path = ROOT / "contract.json"
|
|
save(path, expected_contract())
|
|
cases = [replay(path, seconds) for seconds in (2., 6., 6.01)]
|
|
if (not all(case["within_revised_reserve"] for case in cases[:2])
|
|
or cases[2]["within_revised_reserve"]):
|
|
raise RuntimeError("Boundary and overhead witness differ from expectation")
|
|
receipt = dict(
|
|
status="BLOCKED_WAIT_RESERVE_NOT_HARD_BOUND", old_binding_sha256=OLD_BINDING,
|
|
old_independent_review_sha256=OLD_REVIEW, actual_revised_contract_sha256=sha(path),
|
|
unchanged_guard_sha256=sha(legacy.__file__), cases=cases,
|
|
deadline_seconds=60, waiting_reserve_gpu_seconds=66, revised_total_gpu_seconds=13186,
|
|
observation="Two 3s subprocess timeouts do not bound process setup, result collection "
|
|
"or scheduler overhead of the complete snapshot.",
|
|
proposals_evaluated=["2 seconds for full query", "3 seconds per subquery",
|
|
"3 seconds per subquery plus 10ms outside subprocess timeouts"],
|
|
training_scope_unchanged=True, actual_worker_dispatched=False, launch_ready=False)
|
|
save(ROOT / "cpu-guard-wait-replay.json", receipt)
|
|
print(receipt)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
prepare()
|