| """Bind, then run four independent controller attempts per confirmation case. |
| |
| This driver changes execution scheduling only. It uses spawn-isolated native |
| simulators, preserves the exact case/variant roster and original attempt runner, |
| and waits for all four controllers before the next case. Timing describes a |
| shared four-worker host, not isolated single-controller throughput. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| from concurrent.futures import ProcessPoolExecutor |
| from multiprocessing import get_context |
| from pathlib import Path |
|
|
| from dvidia_training import piper_grip_clock_cli as lifecycle |
| from dvidia_training import piper_grip_clock_benchmark as runner |
| from dvidia_training.piper_imitation_benchmark import _atomic_create, read, write, sha |
|
|
|
|
| SCHEMA = 'dvidia.piper-clock-execution/v0.3' |
| WORKERS = 4 |
|
|
|
|
| def declaration(root): |
| return dict(schema=SCHEMA, workers=WORKERS, process_start_method='spawn', |
| driver_sha256=sha(__file__), protocol_sha256=sha(Path(root)/'protocol.json'), |
| schedule='Dispatch clock, blind_clock, fixed, teacher for one case; await all four before next case.', |
| variants=list(lifecycle.CONFIRM_VARIANTS), |
| attempts_per_controller=128, scheduled_attempts=512, |
| timing_scope='Four concurrent independent simulator workers on a shared host; no isolated throughput or hard-real-time claim.', |
| physical_robot_ready=False) |
|
|
|
|
| def bind(root): |
| root = Path(root) |
| with lifecycle._locked(root): |
| lifecycle._study(root, mutable=True) |
| _atomic_create(root/'execution-driver.py', Path(__file__).read_bytes()) |
| write(root/'execution-plan.json', declaration(root)) |
|
|
|
|
| def _attempt(root, assets, case, variant): |
| root = Path(root) |
| model_path = root/('selected.json' if variant == 'clock' else 'blind.json') if variant in ('clock', 'blind_clock') else None |
| return runner.execute(root, Path(assets), case, variant, root/'confirmation'/case['id']/variant, |
| model_path=model_path) |
|
|
|
|
| def confirm(root, assets): |
| root, assets = Path(root).resolve(), Path(assets).resolve() |
| with lifecycle._locked(root): |
| protocol, frozen = lifecycle._frozen(root) |
| if (read(root/'execution-plan.json') != declaration(root) |
| or sha(root/'execution-driver.py') != sha(__file__) |
| or 'execution-plan.json' not in frozen['files'] |
| or 'execution-driver.py' not in frozen['files']): |
| raise ValueError('Parallel execution plan and driver must be bound before freeze.') |
| errors = [] |
| with ProcessPoolExecutor(max_workers=WORKERS, mp_context=get_context('spawn')) as pool: |
| for case in protocol['cases']['confirmation']: |
| futures = [pool.submit(_attempt, root, assets, case, variant) |
| for variant in lifecycle.CONFIRM_VARIANTS] |
| |
| for future in futures: |
| try: |
| future.result() |
| except Exception as exc: |
| errors.append((case['id'], exc)) |
| if errors: |
| case_id, error = errors[0] |
| raise RuntimeError( |
| f'{len(errors)} attempt(s) did not complete; all confirmation cases were dispatched. ' |
| f'Retain evidence before reconciliation (first failure: {case_id}).' |
| ) from error |
| return lifecycle._report(root) |
|
|
|
|
| def main(argv=None): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('command', choices=('bind', 'confirm')) |
| parser.add_argument('--study', type=Path, required=True) |
| parser.add_argument('--assets', type=Path) |
| args = parser.parse_args(argv) |
| if args.command == 'bind': |
| bind(args.study) |
| else: |
| if args.assets is None: |
| parser.error('confirm requires --assets') |
| confirm(args.study, args.assets) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
