"""Трек 1: фиксированные/растущие ресурсы, насыщение PostgreSQL, улучшение. Учебные данные добавляются; volumes не удаляются. По завершении восстанавливает обычную конфигурацию. Сводки не содержат сессионных токенов. """ import argparse import csv import hashlib import json import os import platform import random import subprocess import time from pathlib import Path from benchmark import fixture, measure from replicas import compose, containers, docker, wait_ready, wait_visible ROOT = Path(__file__).resolve().parents[1] DEST = ROOT / "evidence/lab3-research" def cpu_stats(): result = {} for service in ["api", "postgres", "redis", "lb"]: for cid in compose("ps", "-q", service).split(): raw = docker("exec", cid, "cat", "/sys/fs/cgroup/cpu.stat") memory = docker( "exec", cid, "cat", "/sys/fs/cgroup/memory.current", "/sys/fs/cgroup/memory.peak" ).split() result[cid] = { "service": service, "memory_current_bytes": int(memory[0]), "memory_peak_bytes": int(memory[1]), **{line.split()[0]: int(line.split()[1]) for line in raw.splitlines()}, } return result def pg_stats(): # Не выводим env/password и не меняем данные. query = "SELECT json_build_object('commits',xact_commit,'rollbacks',xact_rollback,'blocks_read',blks_read,'blocks_hit',blks_hit,'temp_bytes',temp_bytes) FROM pg_stat_database WHERE datname=current_database()" result = subprocess.check_output( [ "docker", "compose", "--env-file", os.environ.get("ENV_FILE", ".env"), "exec", "-T", "postgres", "sh", "-c", 'exec psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -At', ], input=query, text=True, cwd=ROOT, ) return json.loads(result) def configure(replicas, cpus, memory, db_cpus, pool=10): os.environ.update( API_REPLICAS=str(replicas), API_CPUS=str(cpus), API_MEMORY=memory, POSTGRES_CPUS=str(db_cpus), DATABASE_POOL_SIZE=str(pool), LOG_LEVEL="WARNING", ) compose("up", "-d", "--no-build", "--wait") ids = containers() assert len(ids) == replicas for cid in ids: wait_visible(wait_ready(cid)) def main(): global DEST parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "--full", action="store_true", help="Полная матрица 1/2/4; без флага короткая проверка ресурса БД", ) parser.add_argument("--duration", type=int, default=12) parser.add_argument("--repeats", type=int, default=2) parser.add_argument("--concurrency", type=int, default=32) args = parser.parse_args() if not args.full: DEST = ROOT / "evidence/lab3-control" args.duration = min(args.duration, 8) args.repeats = 1 DEST.mkdir(parents=True, exist_ok=True) machine = { "host": platform.platform(), "architecture": platform.machine(), "docker": json.loads(docker("info", "--format", "{{json .}}")), } # Keep only hardware/runtime fields. Docker Info also has registry/user info. machine["docker"] = { k: machine["docker"].get(k) for k in [ "ServerVersion", "NCPU", "MemTotal", "KernelVersion", "OperatingSystem", "Architecture", ] } machine["application"] = { "schema_revision": "006", "message_storage": "UTF-8 bytea", "source_sha256": { str(path.relative_to(ROOT)): hashlib.sha256(path.read_bytes()).hexdigest() for path in sorted((ROOT / "src").rglob("*.py")) }, "configuration_sha256": { name: hashlib.sha256((ROOT / name).read_bytes()).hexdigest() for name in ["compose.yaml", "infra/haproxy.cfg", "scripts/benchmark.py"] }, } machine["method"] = { "warmup_seconds": 3, "repeats": args.repeats, "duration_seconds": args.duration, "concurrency": args.concurrency, "profile": "80% POST unique keys, 20% GET first page limit20, 20 seed messages; fresh chat per run", "generator": "Python http.client, one persistent connection per thread, closed-loop, no retries", "limits": "PostgreSQL 0.25 CPU/512MiB baseline, LB 0.5CPU/128MiB, Redis 0.25CPU/128MiB", "randomization_seed": 20261106, } (DEST / "method.json").write_text(json.dumps(machine, ensure_ascii=False, indent=2) + "\n") jobs = [] for repeat in range(args.repeats): for count in [1, 2, 4]: jobs += [ dict( series="fixed", replicas=count, cpus=2 / count, memory=f"{1024 // count}m", db=0.25, concurrency=args.concurrency, repeat=repeat, ), dict( series="growing", replicas=count, cpus=1, memory="256m", db=0.25, concurrency=args.concurrency, repeat=repeat, ), ] random.Random(20261106).shuffle(jobs) # Additional load sweep establishes a plateau; the final series tests a # hypothesis that allocating more CPU to PostgreSQL raises throughput. for repeat in range(args.repeats): for concurrency in [8, 64]: jobs.append( dict( series="saturation", replicas=4, cpus=1, memory="256m", db=0.25, concurrency=concurrency, repeat=repeat, ) ) jobs.append( dict( series="improved-db", replicas=4, cpus=1, memory="256m", db=1, concurrency=args.concurrency, repeat=repeat, ) ) if not args.full: jobs = [ job for job in jobs if job["replicas"] == 4 and job["series"] in {"growing", "improved-db"} and job["concurrency"] == args.concurrency ] results = [] try: for index, job in enumerate(jobs): print(f"[{index + 1}/{len(jobs)}] {job}", flush=True) configure(job["replicas"], job["cpus"], job["memory"], job["db"]) actor, chat = fixture() measure(actor, chat, 3, job["concurrency"]) before = cpu_stats() pg_before = pg_stats() began = time.monotonic() report, _ = measure(actor, chat, args.duration, job["concurrency"]) elapsed = time.monotonic() - began pg_after = pg_stats() after = cpu_stats() cpu = {} for cid, end in after.items(): if cid not in before: continue delta = {k: end[k] - before[cid][k] for k in end if k != "service"} cpu[cid[:12]] = { "service": end["service"], "memory_current_mib": round(end["memory_current_bytes"] / 1048576, 2), "memory_peak_lifetime_mib": round(end["memory_peak_bytes"] / 1048576, 2), "cpu_cores_used": round(delta["usage_usec"] / 1e6 / elapsed, 3), "throttled_seconds": round(delta.get("throttled_usec", 0) / 1e6, 3), "throttled_period_ratio": round( delta.get("nr_throttled", 0) / max(1, delta.get("nr_periods", 0)), 3 ), } row = { "job": job, "report": report, "cpu": cpu, "postgres_delta": {k: pg_after[k] - pg_before[k] for k in pg_before}, } results.append(row) (DEST / f"run-{index + 1:02}.json").write_text( json.dumps(row, ensure_ascii=False, indent=2) + "\n" ) print( "RPS", report["rps"], "errors", report["errors"], "p95", report["all_attempt_latency_ms"]["p95"], flush=True, ) (DEST / "results.json").write_text(json.dumps(results, ensure_ascii=False, indent=2) + "\n") with (DEST / "summary.csv").open("w") as f: fields = [ "series", "replicas", "cpus", "memory", "db", "concurrency", "repeat", "rps", "p95_ms", "errors", "postgres_cores", ] writer = csv.DictWriter(f, fieldnames=fields) writer.writeheader() for row in results: writer.writerow( { **row["job"], "rps": row["report"]["rps"], "p95_ms": row["report"]["all_attempt_latency_ms"]["p95"], "errors": sum(row["report"]["errors"].values()), "postgres_cores": sum( c["cpu_cores_used"] for c in row["cpu"].values() if c["service"] == "postgres" ), } ) print( "PASS: research series complete; inspect results before drawing conclusions", flush=True ) finally: for key in [ "API_REPLICAS", "API_CPUS", "API_MEMORY", "POSTGRES_CPUS", "DATABASE_POOL_SIZE", "LOG_LEVEL", ]: os.environ.pop(key, None) compose("up", "-d", "--no-build", "--wait") for cid in containers(): wait_visible(wait_ready(cid)) print("Default two-replica configuration restored", flush=True) if __name__ == "__main__": main()