Files
mtusi2026lab3/scripts/load_active.py
T

82 lines
3.8 KiB
Python

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