File size: 4,022 Bytes
26a2f09 | 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 | """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]
# No policy result can stop the remaining paired attempts.
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()
|