forked from mtusi2026/mtusi2026lab3
120 lines
20 KiB
Python
120 lines
20 KiB
Python
from collections import defaultdict
|
||
from datetime import datetime
|
||
import json
|
||
from pathlib import Path
|
||
import statistics
|
||
|
||
ROOT = Path(__file__).resolve().parents[1]
|
||
OUT = ROOT / 'evidence'
|
||
SCALING = OUT / 'scaling'
|
||
|
||
|
||
def read(path):
|
||
return json.loads(path.read_text(encoding='utf-8-sig'))
|
||
|
||
|
||
def analysis(rows):
|
||
selected = [row for row in rows if row['series'] == 'active-window' and row['concurrency'] == 64]
|
||
if len(selected) < 4:
|
||
return
|
||
by_pool = {pool: [row for row in selected if row['pool'] == pool] for pool in (8, 1)}
|
||
rates = {pool: statistics.mean(row['successful_rps'] for row in values) for pool, values in by_pool.items()}
|
||
p95 = {pool: statistics.mean(row['successful_latency_ms']['p95'] for row in values) for pool, values in by_pool.items()}
|
||
growth = 100 * (rates[1] / rates[8] - 1)
|
||
latency_change = 100 * (1 - p95[1] / p95[8])
|
||
fixed = {count: statistics.mean(row['successful_rps'] for row in rows if row['series'] == 'fixed' and row['replicas'] == count) for count in (1, 2, 4)}
|
||
growing = {count: statistics.mean(row['successful_rps'] for row in rows if row['series'] == 'growing' and row['replicas'] == count) for count in (1, 2, 4)}
|
||
confirmed = {count: statistics.mean(row['successful_rps'] for row in rows if row['series'] == 'confirmation' and row['replicas'] == count) for count in (2, 4)}
|
||
lines = ['# Разбор исследования', '', '## Гипотеза и воспроизводимость', '', 'Гипотеза: репликация без увеличения суммарного CPU/RAM не даёт линейного ускорения; слишком большой пул при жёстком CPU-лимите может увеличивать конкуренцию за CPU и хвостовую задержку. Все запросы синтетические, без вложений, через HAProxy. Каждый POST имеет уникальный Idempotency-Key. Сессии создаются до измерения.', '', 'Команды из корня проекта после запуска стенда: `python scripts/research.py --duration 15 --repeats 2`, `python scripts/confirm.py`, `python scripts/pool_study.py`, `python scripts/summarize.py`. Перед ними установите requirements-research.txt и BASE_URL для выбранного порта. Настройки и порядок прогонов фиксируются в scaling/environment.json.', '', '## Цена масштабирования', '', f'При фиксированных суммарных 1 CPU/512 MiB API: 1/2/4 реплики дали {fixed[1]:.2f}/{fixed[2]:.2f}/{fixed[4]:.2f} RPS. При росте бюджета по 0.5 CPU/256 MiB на реплику: {growing[1]:.2f}/{growing[2]:.2f}/{growing[4]:.2f} RPS. Добавление CPU помогает, но переход 2 → 4 дал лишь {100*(growing[4]/growing[2]-1):.1f}% при удвоении API-ресурсов.', '', f'Контрольный порядок 4 → 2 → 2 → 4 дал для двух реплик {confirmed[2]:.2f}, для четырёх {confirmed[4]:.2f} RPS. Он не подтвердил первоначальный вывод о безусловном преимуществе двух реплик. Одинаковая конфигурация в разные моменты даёт разные RPS: есть дрейф нагрузки host и CPU throttling. Поэтому уменьшение числа реплик не объявляется доказанным улучшением. Две реплики выбраны как обязательный минимум доступности.', '', 'Публичный driver включает создание потоков и SSL contexts в elapsed. При 64 клиентах этот старт значителен. Первые графики показывают именно его end-to-end результат. Сравнение разной конкуренции уточнено отдельным генератором с barrier, 3 секундами прогрева и 15 секундами активной нагрузки; его elapsed включает только активное окно и завершение отправленных запросов.', '', '## Подтверждённое улучшение', '', f'При неизменных четырёх API по 0.5 CPU/256 MiB, PostgreSQL 1 CPU/512 MiB и LB 0.5 CPU/128 MiB выполнен порядок pool=8 → 1 → 1 → 8, 64 клиента. Средний активный throughput: {rates[8]:.3f} → {rates[1]:.3f} RPS ({growth:+.2f}%). Среднее p95 отдельных прогонов: {p95[8]:.3f} → {p95[1]:.3f} ms (снижение {latency_change:.2f}%). Ошибок в этих четырёх прогонах: ' + str(sum(row['failed_requests'] for row in selected)) + '.', '', 'Улучшение — ограничение числа одновременных операций с БД на CPU-ограниченной API-реплике. Изменён DB_POOL_SIZE по умолчанию с 8 на 1 в compose, bootstrap и приложении. Это ограничивает активную конкуренцию и переносит ожидание в контролируемую очередь пула. Настройка подтверждена для этого профиля; при других CPU/SQL/latency её надо измерять заново. Большой пул сам по себе не означает большую пропускную способность.', '', '', '', '', '', '## Насыщение и ресурсы', '', '| Пул, 64 клиента | Компонент | CPU, среднее % одного ядра | CPU, max % | RAM, max MiB | Максимум ожидающих pool на реплике |', '| --- | --- | --- | --- | --- | --- |']
|
||
for pool, values in by_pool.items():
|
||
collected = defaultdict(list)
|
||
waiting = 0
|
||
for row in values:
|
||
name = f"active-{row['repeat']}-p{pool}-c64"
|
||
for sample in read(SCALING / (name + '-resources.json')):
|
||
if row['measurement_started_epoch'] <= sample['at'] <= row['measurement_finished_epoch']:
|
||
for item in sample['containers']:
|
||
service = item['Name'].rsplit('-', 2)[-2]
|
||
import re
|
||
memory = re.fullmatch(r'([\d.]+)([A-Za-z]+)', item['MemUsage'].split('/')[0].strip())
|
||
scale = {'B': 1/1024**2, 'KiB': 1/1024, 'MiB': 1, 'GiB': 1024}
|
||
memory_mb = float(memory[1])*scale[memory[2]]
|
||
collected[service].append((float(item['CPUPerc'].rstrip('%')), memory_mb))
|
||
for sample in read(SCALING / (name + '-pool.json')):
|
||
if row['measurement_started_epoch'] <= datetime.fromisoformat(sample['at']).timestamp() <= row['measurement_finished_epoch']:
|
||
waiting = max(waiting, sample['stats'].get('requests_waiting', 0))
|
||
for service, samples in sorted(collected.items()):
|
||
lines.append(f'| {pool} | {service} | {statistics.mean(value[0] for value in samples):.2f} | {max(value[0] for value in samples):.2f} | {max(value[1] for value in samples):.2f} | {waiting if service == "api" else "—"} |')
|
||
lines += ['', 'Для API среднее относится к одной реплике; суммарная загрузка — примерно в четыре раза больше. Лимит каждой API — 50% одного ядра. PostgreSQL ограничен 100%, LB — 50%. Снимки показывают приближение API к CPU quota и накопление очередей пула; предела CPU PostgreSQL/LB этот профиль не достиг. При 64 клиентах ожидание пула наблюдается непосредственно в requests_waiting, requests_queued и requests_wait_ms. Увеличение количества соединений на этих CPU-лимитах не устраняет очередь, а ухудшает итоговый throughput.', '', 'Точка насыщения относится к выбранному профилю и очереди синхронного пути, а не к универсальной capacity БД: переход от 4 к 16/64 клиентам с pool=8 уже не даёт роста полезной скорости и увеличивает p95. На 64 клиентах очередь пула зафиксирована напрямую. Чистый аппаратный предел PostgreSQL или HAProxy не измерен; утверждать обратное по этим данным нельзя.', '', '## Отказы, инциденты и ограничения', '', 'Итоговые функциональные проверки и отказы на настроенном стенде приведены в RESULTS.md, исходные выводы — в соседних TXT/JSON. Сохранность проверяется прежним токеном и сравнением подтверждённых сообщений. Rolling replacement фиксирует старые/новые ID и время замены внутри активного окна нагрузки.', '', 'Во время первого запуска активной серии Compose --wait отказался продолжить из-за оставшегося unhealthy после нагрузки состояния одной реплики. Первые два измерения завершились без HTTP-ошибок; третье ещё не начиналось. Hook эксперимента исправлен: явно ожидает восстановления readiness до 90 секунд. Серия продолжена с --resume без удаления завершённых результатов. Подробности: scaling/active-window-incident.txt. Under CPU pressure readiness использует тот же ограниченный pool и тоже может задерживаться; отдельный резерв readiness-подключений не реализован.', '', 'Два повтора сравнения пула и короткие окна не являются статистическим доказательством для любого оборудования. Порядок ABBA снижает влияние временного дрейфа, но не устраняет его полностью. Closed loop сохраняет coordinated omission; клиент, HTTP и Docker Desktop входят в путь. На машине есть соседний учебный стенд, его конфигурация не менялась. Между прогонами растёт набор данных. Один Docker host, единственные БД и LB остаются SPOF.']
|
||
(OUT / 'ANALYSIS.md').write_text('\n'.join(lines) + '\n', encoding='utf-8')
|
||
|
||
|
||
def main():
|
||
rows = read(SCALING / 'results.json')
|
||
from research import graph
|
||
graph(rows)
|
||
if any(row['series'] == 'active-window' for row in rows):
|
||
from pool_study import graph as graph_active
|
||
graph_active(rows)
|
||
environment = read(SCALING / 'environment.json')
|
||
lines = ['# Фактические результаты', '', 'Дата измерений UTC: ' + environment['date_utc'] + '.', '', 'Команды: `python scripts/verify.py`, `python scripts/research.py --duration 15 --repeats 2`. Адрес: ' + environment['base_url'] + '.', '', '## Функциональные проверки', '']
|
||
for name in ('contract', 'smoke', 'concurrent', 'persistence', 'public-failover', 'rolling-action', 'smoke-after-rolling'):
|
||
path = OUT / (name + '.txt')
|
||
lines.append(f'- [{name}]({path.name}): см. фактический вывод.')
|
||
lines += ['', '## Отказы', '', '| Остановленный контейнер | Записи / с | Чтения / с | Ошибки | Восстановление, с | Потеря подтверждений |', '| --- | --- | --- | --- | --- | --- |']
|
||
for row in read(OUT / 'failover-matrix.json'):
|
||
lines.append(f"| {row['container']} | {row['successful_writes']/row['elapsed_seconds']:.2f} | {row['successful_reads']/row['elapsed_seconds']:.2f} | {row['failed_attempts']} | {row['recovery_seconds']:.3f} | {row['lost_confirmations']} |")
|
||
rolling = read(OUT / 'rolling-load.json')
|
||
lines += ['', f"Rolling replacement: {rolling['successful_requests']} успешных записей, {rolling['failed_requests']} ошибок ({rolling['error_ratio']*100:.2f}%), {rolling['successful_rps']:.2f} RPS, p95={rolling['successful_latency_ms']['p95']:.2f} ms. Это замена без предварительного drain backend; обнаружение отказа допускает краткие ошибки, автоматического retry в этом профиле нет. После замены публичный smoke проходит.", '', '## Среда', '', f"Docker VM: {environment['docker']['NCPU']} CPU, {environment['docker']['MemTotal']/1024**3:.2f} GiB RAM; {environment['docker']['OperatingSystem']}; Engine {environment['docker']['ServerVersion']}. Host: {environment['platform']}.", '', 'Объём данных до: `' + json.dumps(environment['dataset_before']) + '`, после: `' + json.dumps(environment['dataset_after']) + '`.', '', '## Масштабирование', '', 'Фиксированный бюджет: суммарно 1 CPU/512 MiB API. Растущий: по 0.5 CPU/256 MiB каждой API. PostgreSQL 1 CPU/512 MiB, LB 0.5 CPU/128 MiB во всех сериях. Таблица содержит среднее RPS по повторам и диапазон p95 отдельных прогонов; это не объединённый percentile.', '', '| Серия | Реплики | Пул каждой | Клиенты | RPS, среднее | RPS, min–max | p50, ms | p95, ms | p99, ms | Ошибок |', '| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |']
|
||
groups = defaultdict(list)
|
||
for row in rows:
|
||
groups[(row['series'], row['replicas'], row['pool'], row['concurrency'])].append(row)
|
||
for (series, replicas, pool, concurrency), values in groups.items():
|
||
rates = [r['successful_rps'] for r in values]
|
||
latencies = {p: [r['successful_latency_ms'][p] for r in values] for p in ('p50', 'p95', 'p99')}
|
||
lines.append(f"| {series} | {replicas} | {pool} | {concurrency} | {statistics.mean(rates):.2f} | {min(rates):.2f}–{max(rates):.2f} | {statistics.mean(latencies['p50']):.1f} | {min(latencies['p95']):.1f}–{max(latencies['p95']):.1f} | {statistics.mean(latencies['p99']):.1f} | {sum(r['failed_requests'] for r in values)} |")
|
||
lines += ['', '', '', 'Публичный driver включает создание клиентских потоков/SSL contexts в elapsed. Его RPS при разной конкуренции содержит заметные расходы старта генератора. Строки active-window измерены после подготовки клиентов и 3 секунд прогрева, включая завершение запросов после дедлайна; эти методики нельзя смешивать.', '']
|
||
if any(row['series'] == 'active-window' for row in rows):
|
||
lines += ['', '']
|
||
lines += ['## Наблюдение ресурсов', '', '| Серия / прогон | Компонент | CPU, среднее % одного ядра | CPU, максимум % | RAM, максимум MiB |', '| --- | --- | --- | --- | --- |']
|
||
resources = {}
|
||
for path in sorted(SCALING.glob('*-resources.json')):
|
||
values = defaultdict(list)
|
||
summary = read(path.with_name(path.name.replace('-resources.json', '.json')))
|
||
for snapshot in read(path):
|
||
if 'measurement_started_epoch' in summary and not summary['measurement_started_epoch'] <= snapshot['at'] <= summary['measurement_finished_epoch']:
|
||
continue
|
||
for item in snapshot['containers']:
|
||
service = item['Name'].rsplit('-', 2)[-2]
|
||
memory = item['MemUsage'].split('/')[0].strip()
|
||
factors = {'B': 1/1024**2, 'KiB': 1/1024, 'MiB': 1, 'GiB': 1024}
|
||
import re
|
||
match = re.fullmatch(r'([\d.]+)([A-Za-z]+)', memory)
|
||
memory_mb = float(match[1]) * factors[match[2]] if match else 0
|
||
values[service].append((float(item['CPUPerc'].rstrip('%')), memory_mb))
|
||
for service, samples in sorted(values.items()):
|
||
cpu = [c for c, _ in samples]
|
||
resources[(path.stem, service)] = statistics.mean(cpu)
|
||
lines.append(f'| {path.stem.removesuffix("-resources")} | {service} | {statistics.mean(cpu):.2f} | {max(cpu):.2f} | {max(m for _, m in samples):.2f} |')
|
||
lines += ['', 'Для API CPU/RAM в этой таблице относятся к отдельным контейнерам, усреднённым по репликам и снимкам; максимум — отдельный контейнер. Суммарный CPU API вычисляется умножением среднего на число реплик. Docker CPU 100% соответствует одному ядру, независимо от quota.', '', '## Счётчики ожидания пула', '', '| Прогон | Реплик со снимками | Запросы в очереди, прирост | Ожидание, ms, прирост | Максимум ожидающих в снимке |', '| --- | --- | --- | --- | --- |']
|
||
for path in sorted(SCALING.glob('*-pool.json')):
|
||
by_instance = defaultdict(list)
|
||
summary = read(path.with_name(path.name.replace('-pool.json', '.json')))
|
||
for sample in read(path):
|
||
if 'measurement_started_epoch' in summary and not summary['measurement_started_epoch'] <= datetime.fromisoformat(sample['at']).timestamp() <= summary['measurement_finished_epoch']:
|
||
continue
|
||
by_instance[sample['instance']].append(sample['stats'])
|
||
queued, wait, maximum = 0, 0, 0
|
||
for samples in by_instance.values():
|
||
queued += samples[-1].get('requests_queued', 0) - samples[0].get('requests_queued', 0)
|
||
wait += samples[-1].get('requests_wait_ms', 0) - samples[0].get('requests_wait_ms', 0)
|
||
maximum = max(maximum, *(sample.get('requests_waiting', 0) for sample in samples))
|
||
lines.append(f'| {path.stem.removesuffix("-pool")} | {len(by_instance)} | {queued} | {wait} | {maximum} |')
|
||
lines += ['', 'Счётчики берутся каждые 5 секунд и включают readiness и вспомогательные запросы; прирост между первым и последним снимком покрывает часть измерения. Это диагностический сигнал, а не точный процент запросов измерительного окна.', '', '## Границы вывода', '', 'Короткий closed-loop профиль, два повтора основных серий, фиксированный порядок и растущий набор данных. Percentiles считаются только по успехам. Есть расходы генератора и Docker Desktop, а также соседний учебный стенд; его работа не изменялась. Полученные RPS не являются универсальной production capacity. Данные и графики получены реальным запуском, а не оценены по формуле.']
|
||
(OUT / 'RESULTS.md').write_text('\n'.join(lines) + '\n', encoding='utf-8')
|
||
analysis(rows)
|
||
|
||
|
||
if __name__ == '__main__':
|
||
main()
|