Files
MeltMind/tools/prepare_phase3_item1b_fold0_wait_reserve.py
T

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()