forked from mtusi2026/mtusi2026lab3
82 lines
3.8 KiB
Python
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()
|