import argparse from concurrent.futures import ThreadPoolExecutor from datetime import datetime, timezone import json import math from pathlib import Path import sys import threading import time sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) from client import Client, Failure, check def main(): parser = argparse.ArgumentParser() parser.add_argument('--duration', type=float, default=15) parser.add_argument('--concurrency', type=int, default=24) parser.add_argument('--output', required=True) parser.add_argument('--ready-file') args = parser.parse_args() check(1 <= args.duration <= 3600 and 1 <= args.concurrency <= 128, 'invalid load parameters') startup = time.monotonic() c = Client() alice, bob, eve, chat = c.bootstrap() timing = {} def warm_start(): timing['warm_deadline'] = time.monotonic() + 3 def measure_start(): timing['started'] = time.monotonic() timing['started_epoch'] = time.time() timing['started_utc'] = datetime.now(timezone.utc).isoformat() timing['deadline'] = timing['started'] + args.duration if args.ready_file: Path(args.ready_file).write_text(json.dumps({'measurement_started_epoch': timing['started_epoch']}), encoding='utf-8') warm_barrier = threading.Barrier(args.concurrency, action=warm_start, timeout=120) measurement_barrier = threading.Barrier(args.concurrency, action=measure_start, timeout=120) def worker(index): client = Client(timeout=5) warm_barrier.wait() sequence = 0 while time.monotonic() < timing['warm_deadline']: try: client.message(alice, chat, f'warm-{index}-{sequence}') except Failure: pass sequence += 1 measurement_barrier.wait() latencies, errors = [], 0 while time.monotonic() < timing['deadline']: started = time.monotonic() try: client.message(alice, chat, f'active-{index}-{sequence}') latencies.append(time.monotonic() - started) except Failure: errors += 1 sequence += 1 return latencies, errors with ThreadPoolExecutor(max_workers=args.concurrency) as executor: results = list(executor.map(worker, range(args.concurrency))) elapsed = time.monotonic() - timing['started'] latencies = sorted(value for values, _ in results for value in values) errors = sum(number for _, number in results) total = len(latencies) + errors def percentile(value): return round(1000 * latencies[max(0, math.ceil(value * len(latencies)) - 1)], 3) if latencies else None result = {'lab': 3, 'workload': 'closed-loop POST messages; synchronized active window; no retries', 'requested_duration_seconds': args.duration, 'warmup_seconds': 3, 'startup_seconds': round(timing['started']-startup, 3), 'measurement_started_utc': timing['started_utc'], 'measurement_started_epoch': timing['started_epoch'], 'measurement_finished_epoch': time.time(), 'elapsed_seconds': round(elapsed, 3), 'concurrency': args.concurrency, 'successful_requests': len(latencies), 'failed_requests': errors, 'error_ratio': errors/total if total else None, 'successful_rps': round(len(latencies)/elapsed, 3), 'successful_latency_ms': {'p50': percentile(.5), 'p95': percentile(.95), 'p99': percentile(.99)}, 'maximum_successful_latency_ms': round(1000*max(latencies), 3) if latencies else None, 'note': 'Client construction and warmup excluded. Active window includes drain of in-flight requests. Success percentiles only; closed-loop coordinated omission remains.'} Path(args.output).write_text(json.dumps(result, indent=2) + '\n', encoding='utf-8') print(json.dumps(result, indent=2)) check(bool(latencies), 'no successful writes') if __name__ == '__main__': main()