diff --git a/.claude/rules/bench.md b/.claude/rules/bench.md index 61d10d37..685239b4 100644 --- a/.claude/rules/bench.md +++ b/.claude/rules/bench.md @@ -36,29 +36,11 @@ paths: остановка реплик, посекундные RPS и ошибки) и `rollout` (та же нагрузка во время `scripts/rolling-update.sh`). -Что меняется (стенд и профиль `failover` — change `graceful-failover`, -сделано; нагрузка, метрики и графики трека 1 — change `scaling-bench`): - -- **стенд:** тот же compose с HAProxy и N репликами `api` вместо - одного контейнера; при N = 1 профили лабы 2 работают как раньше. - Число реплик (`replicas`), их лимиты и лимиты HAProxy (`lb_cpus`, - `lb_memory`) — поля `Profile`, в паспорт; лимит генератора — ещё - предстоит (`scaling-bench`); -- **нагрузка:** открытая модель (`ramping-arrival-rate` ступенями до - нарушения SLO, плюс фиксированные уровни), один смешанный профиль - для всех конфигураций. Вход по Basic — до прогона, не в замере; -- **генератор** получает лимит CPU: стенд и k6 делят один хост, а - серии сравнивают CPU-бюджеты; -- **метрики** — ещё распределение ответов по `X-Instance-Id`, - статистика HAProxy (очередь, повторы, время ответа сервера), commit/s - и соединения Postgres по `wait_event`. Новые столбцы `runs.csv` — в - конец; -- **графики** — SVG скриптом на stdlib из `runs.csv` (правило «без - новых зависимостей» ниже действует). - -Это смена методики: метки лабы 2 с метками лабы 3 не сравниваются, -базовый замер снимается заново. Профили лабы 2 (`full`, `restore*`) -продолжают работать и после перехода на N реплик. +Стенд с N репликами и профиль `failover` — change `graceful-failover`; +нагрузка, метрики и графики трека 1 — change `scaling-bench` (раздел +«Серии трека 1» ниже). Это смена методики: метки лабы 2 с метками лабы +3 не сравниваются, базовый замер снимается заново. Профили лабы 2 +(`full`, `restore*`) продолжают работать и после перехода на N реплик. Стенд с LB (design change `graceful-failover`, решение 6): @@ -98,8 +80,10 @@ paths: | `run.py` (профили `restore`, `restore_quick`), `k6/after_backup.js`, `k6/restore_check.js` | `make bench_restore`, `make bench_restore_quick` | тот же стенд без матрицы прогонов: backup под записью, восстановление в новое хранилище, сверка, RTO и потеря, кэш до и после `FLUSHALL` | | `run.py` (профили `failover`, `failover_quick`), `failover.py`, `k6/failover.js`, `k6/retry.js` | `make bench_failover`, `make bench_failover_quick` | две реплики с лимитами рабочего стенда, постоянная интенсивность записи с ключом и чтения, каждая реплика в каждом режиме (`stop`, `kill`, `pause`) с возвратом: посекундная шкала, время обнаружения и восстановления, сверка записей; результаты — `evidence/failover/<метка>/` | | `run.py` (профили `rollout`, `rollout_quick`), `rollout.py`, `k6/failover.js`, `k6/retry.js`, `scripts/rolling-update.sh` | `make bench_rollout`, `make bench_rollout_quick` | две реплики с лимитами рабочего стенда на образе прежнего commit, та же постоянная нагрузка, посреди неё — поочерёдная замена на образ текущего checkout: посекундная шкала с ответами старых и новых реплик, шаги по каждой реплике, контейнеры, образы и ревизия схемы до и после, сверка записей; результаты — `evidence/rollout/<метка>/` | -| `compare.py` | `make bench_compare` | дельта двух меток стенда, эффект или шум | -| `ab.py` | `make bench_ab` | стенд «до» и «после» одного изменения подряд, в одной сессии хоста | +| `run.py` (профили `scaling_*`), `scaling.py`, `sampler.sh`, `k6/mixed.js` | `make bench_scaling SERIES=a\|b\|pool\|ab`, `make bench_scaling_quick` | серии трека 1: конфигурации реплик и лимитов, на каждую ячейку — свежий стенд, открытая модель, фиксированные уровни и поиск R* по SLO, посекундный сэмплер контейнеров, ВМ, LB и PostgreSQL; результаты — `evidence/bench/<метка>/` | +| `plots.py` | `make bench_plots LABELS="…"` | графики SVG и сводка серий (R* от числа реплик, p95 от интенсивности, CPU по компонентам, точка насыщения) — `evidence/plots//` | +| `compare.py` | `make bench_compare` | дельта двух меток стенда (ячейки матрицы или общие конфигурации серий), эффект или шум | +| `ab.py` | `make bench_ab [SERIES=…]` | стенд «до» и «после» одного изменения подряд, в одной сессии хоста; с `SERIES` — серия трека 1 вместо матрицы | ## Что не меняется между метками @@ -139,8 +123,13 @@ paths: `POSTGRES_HOST`. Файл backup живёт только в `.work/`: в нём хэши паролей и токенов; - **генератор:** `grafana/k6` той же версии и digest, в той же - docker-сети; в профилях лабы 2 без лимита CPU, в профилях трека 1 — - с лимитом из `Profile`; + docker-сети; в профилях лабы 2, `failover` и `rollout` без лимита, в + сериях трека 1 — 2 CPU / 1 ГиБ без swap (`generator_cpus`, + `generator_memory`), сэмплер — 0,25 CPU / 128 МиБ (`sampler_cpus`, + `sampler_memory`). Их лимиты — часть методики серий; +- **PostgreSQL `max_connections`:** 100, как у образа (`-c + max_connections` в override); у серий — из конфигурации ячейки, + лимиты конфигурации в паспорте (`limits.<конфигурация>`); - **профиль `full`:** размеры, конкуренция, повторы, прогрев и длительности, длина текста, порция наполнения, зерно выбора курсоров и сдвиг зерна для прогрева, порог пометки `generator`, лимиты и срок @@ -238,6 +227,72 @@ paths: `quick-rollout-*` — в `.gitignore`. Замер для отчёта — `make bench_rollout` после проверки хоста, рабочий стенд остановлен. +## Серии трека 1 (`scaling_*`) + +Доказательство уровня «5», трек 1 «Цена масштабирования» (design change +`scaling-bench`; гипотезы H1–H3 — его решение 10 и `REPORT.md`). +Матрицу не снимает; метки серий сравниваются только с метками серий. + +- **Серии и конфигурации** (реплик × CPU / память, `max_connections`): + `a` — бюджет 4 CPU / 2 ГиБ: 1 × 4, 2 × 2, 4 × 1; `b` — 1…6 × 1 CPU / + 512 МиБ; `pool` — 4 × 1 при 100 и 50; `ab` — 1 × 1 и 6 × 1 («до/после» + и A/A, метка `scaling-aa`); `quick` — самопроверка. Общие поля — в + `scaling_profile()` `run.py`, чтобы методика серий не расходилась. +- **Бюджет:** PostgreSQL 2 / 1 ГиБ, HAProxy 1 / 256 МиБ, Valkey 0,5 / + 128 МиБ, k6 2 / 1 ГиБ, сэмплер 0,25 / 128 МиБ — 5,75 CPU без реплик. + Сумма CPU конфигурации больше CPU ВМ — отказ до стенда (код 2); поэтому + серия `b` — до 6 реплик (11,75 CPU), граница пула на дефолтах (k = 7) + — управляемым опытом `pool`. Бюджет — `meta.budget`. +- **Ячейка** — конфигурация × повтор, 3 повтора, каждая на свежем стенде + (`down -v`, миграции, данные: читаемый чат 10 000, 10 чатов записи). + Порядок — круги, перестановка с зерном `order_seed`, повтор одной + конфигурации не стоит подряд; план — `meta.plan` до первой ячейки. +- **Ступень** — один запуск `k6/mixed.js` (смесь 70/20/10, три сценария + `ramping-arrival-rate`): прогрев 15 с с нуля (первая ступень и после + паузы) или 5 с подъёма, окно 20 с. Тег `window` по + `exec.scenario.startTime`; окно на часах ВМ — от `t0` из `setup()`. + Сначала фиксированные 250 и 500/с, затем поиск R*: L0 = ступенька + `100 × 1,25^i` ≥ max(300 × реплик, пройденный фиксированный), подъём + или спуск, два деления по среднему геометрическому (`scaling.Search`). +- **SLO:** p95 успешных ≤ 200 мс и (ошибки + короткие страницы + + недосланные) / запланированные ≤ 1 %. Нарушила — пауза 10 с и + `wait_ready`. Ошибок > 50 % или p95 > 2 с — досрочный выход k6 (код + 99), причина `abort`. +- **Генератор с лимитом и брак:** CPU k6 ≥ 1,8 ядра, его троттлинг ≥ 10 % + или недосланные при CPU k6 ≥ 70 % лимита (`vus` k6 — выборка раз в + секунду, «свободные VU» по нему не видны). Брак останавливает поиск, + R* — нижняя граница (`generator_bound`); лечение — поднять лимит + (смена методики) и переснять серию. +- **Сэмплер** `mtusi-bench-sampler` (`bench/sampler.sh` на образе + PostgreSQL стенда, `--cgroupns host`): раз в секунду `cpu.stat`, + `memory.current`, `cpu.pressure` каждого контейнера, `/proc/stat` и + PSI ВМ, CSV статистики HAProxy, а одним постоянным соединением `psql + \watch` — `pg_stat_activity` по адресам реплик и `wait_event`, + `pg_stat_database`, `pg_stat_wal`, `pg_stat_io`. Его соединение + занимает слот: граница пула — `max_connections − 1`. Строки ступени, + признаки узкого места и пороги — `scaling.py` (`THRESHOLDS`). +- **Файлы метки:** `runs.csv` (строка на ступень, новые столбцы в + конце), `searches.csv` (строка на ячейку), `samples.csv` (посекундно + в окнах), `prefill.csv`, `summary.md`, `p95-by-rate.svg`, + `cpu-by-component.svg`, `raw/<ячейка>-a<попытка>-s.json`, + `raw/…-errors.log` (5xx и «too many clients»: строки PostgreSQL, API, + LB без секретов), `progress.json`. +- **Продолжение:** `RESUME=1` — тот же профиль и commit, дерево чистое + без каталога своей метки; готовые ячейки (строка в `searches.csv`) + пропускаются, прерванная снимается с попыткой +1. Метку каждой серии + коммитить до запуска следующей: иначе паспорт следующей — `dirty: + true`. +- **Блокировка** `bench/.bench.lock` (`flock`) — для всех профилей: + второй прогон — код 2. Остатки стенда серии удаляет сама (блокировка + взята, значит, прогона нет); прочие профили по-прежнему отказывают. +- **Сравнение и «до/после»:** `make bench_compare` у серий — по общим + конфигурациям (R*, задержки на фиксированных уровнях, CPU на запрос, + CPU PostgreSQL на R*; шум `AA` — наибольшее |Δ медианы R*|); серия + против матрицы — отказ. `make bench_ab … SERIES=ab` снимает серию + вместо матрицы. +- **Графики:** `make bench_plots LABELS="scaling-a scaling-b"` — + `evidence/plots/scaling/`; пробные `quick-*` — в `.gitignore`. + ## Как писать - Стенд — чёрный ящик: `run.py`, `k6/` и `compare.py` не импортируют @@ -280,6 +335,8 @@ paths: прочитал бы рабочий `.env`. - Скрипты `bench/` на хосте — только stdlib Python, запуск `uv run python bench/<файл>.py`. Новых зависимостей не добавлять. + `bench/sampler.sh` — bash, работает только внутри контейнера + сэмплера, на хосте не запускается. - Сценарии k6 — JavaScript без Node.js: только встроенные модули k6. Заголовок идентификации собирается в одном месте `lib.js`: Bearer, как `Actor.headers()` в `student-tests/`. Отправка сообщения — только @@ -351,11 +408,16 @@ paths: в конце. - В результатах нет секретов, `.env` и абсолютных путей домашнего каталога; данные синтетические. -- Перед полной матрицей хост должен быть в состоянии, которое можно - проверить: питание от сети, swap около нуля (`sysctl vm.swapusage`), - память свободна (`memory_pressure`), посторонних контейнеров нет. - Если swap занят или память под давлением — перезагрузить ноутбук; - если условия выполнены, перезагрузка не обязательна. Состояние +- Перед замером для отчёта (полная матрица, серии трека 1, профили + `failover` и `rollout`) хост должен быть в состоянии, которое можно + проверить: питание от сети, давления на память нет и свободной памяти + хватает на стенд (`memory_pressure`), посторонних контейнеров нет. + Занятый swap сам по себе не помеха (указание пользователя 2026-10-10): + в него уходят неактивные страницы. Помеха — выгрузка во время прогона: + `run.py` пишет счётчик `Swapouts` (`vm_stat`) в начале и в конце + (`host_state.swapouts`) и предупреждает о приросте; у серий — ещё по + ячейке и ступени (`host_swapouts`, пометка `host_swap`). Давление на + память или батарея — перезагрузить или подключить питание. Состояние записывается в паспорт (`host_state`), в отчёте оно указывается по паспорту, а не по плану. Во время прогона ноутбук не нагружать и не закрывать крышку: цели `bench*` запускаются под `caffeinate -isu` diff --git a/.claude/skills/run-mtusi-messenger/SKILL.md b/.claude/skills/run-mtusi-messenger/SKILL.md index 7ae8a71a..60e609e9 100644 --- a/.claude/skills/run-mtusi-messenger/SKILL.md +++ b/.claude/skills/run-mtusi-messenger/SKILL.md @@ -134,6 +134,7 @@ make bench_failover_quick # отказ каждой репли make rolling_update # новый код на реплики без простоя: сборка, миграции один раз, по одной: новая UP → старая drain → stop → rm make rolling_update COMMIT= MIGRATE=0 # откат на образ прежнего commit (git archive), схема остаётся новой make bench_rollout_quick # замена под нагрузкой на своём стенде mtusi-bench с образа прежнего commit, ~2 мин +make bench_scaling_quick # самопроверка серий трека 1: две ячейки, открытая модель, поиск R*, сэмплер, ~5 мин make replicas # вернуть остановленные реплики (те же ID), ждать healthy make replicas API_REPLICAS=3 # разово 3 реплики; LB видит новую за 1–3 с без правки конфига make down # удалить контейнеры, volume с данными остаётся diff --git a/.gitignore b/.gitignore index 3397bb76..8c927732 100644 --- a/.gitignore +++ b/.gitignore @@ -38,5 +38,9 @@ evidence/failover/quick-*/ evidence/rollout/quick-*/ # сравнения пробных меток evidence/compare/*quick-* +# make bench_plots на пробных метках +evidence/plots/quick-*/ +# блокировка стенда bench/ (один прогон любого профиля) +bench/.bench.lock # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. diff --git a/Makefile b/Makefile index 103e00cf..bf3d130e 100644 --- a/Makefile +++ b/Makefile @@ -270,20 +270,53 @@ bench_rollout: bench_rollout_quick: $(KEEP_AWAKE) uv run python bench/run.py --profile rollout_quick --label quick-rollout-$(shell date -u +%Y%m%dT%H%M%SZ) -# дельта двух меток по ячейкам матрицы: BEFORE и AFTER обязательны, AA — -# метка того же кода, что BEFORE, для уровня шума; результат — -# evidence/compare/$(BEFORE)__$(AFTER).md +SCALING_LABEL ?= scaling-$(SERIES) + +# уровень 5, трек 1 «Цена масштабирования»: серия на стенде mtusi-bench — +# SERIES=a (бюджет 4 CPU: 1 × 4, 2 × 2, 4 × 1, ~50 мин), b (1…6 реплик по +# 1 CPU, ~100 мин), pool (4 реплики при max_connections 100 и 50, ~35 мин), +# ab (1 × 1 и 6 × 1 для «до/после» и A/A, ~35 мин); каждая ячейка — свежий +# стенд, открытая модель, поиск R* по SLO; результат — +# evidence/bench/$(SCALING_LABEL)/. RESUME=1 — продолжить прерванную метку +# на том же commit +.PHONY: bench_scaling +bench_scaling: + @if [ -z "$(SERIES)" ]; then \ + echo "SERIES is required: make bench_scaling SERIES=a|b|pool|ab|quick [SCALING_LABEL=...] [RESUME=1]"; \ + exit 2; \ + fi + $(KEEP_AWAKE) uv run python bench/run.py --profile scaling_$(SERIES) --label $(SCALING_LABEL) $(if $(RESUME),--resume) + +# самопроверка серий: две ячейки (1 × 1 и 2 × 1 при max_connections 50), +# короткие окна, ~5 мин; в git не идёт +.PHONY: bench_scaling_quick +bench_scaling_quick: + $(KEEP_AWAKE) uv run python bench/run.py --profile scaling_quick --label quick-scaling-$(shell date -u +%Y%m%dT%H%M%SZ) + +PLOTS ?= scaling + +# графики и сводка серий трека 1 из меток LABELS (через пробел): +# R* от числа реплик, p95 от интенсивности, CPU по компонентам, точка +# насыщения; результат — evidence/plots/$(PLOTS)/, пересоздаётся +.PHONY: bench_plots +bench_plots: + uv run python bench/plots.py --labels "$(LABELS)" --out "$(PLOTS)" + +# дельта двух меток по ячейкам матрицы или, у серий трека 1, по общим +# конфигурациям: BEFORE и AFTER обязательны, AA — метка того же кода, что +# BEFORE, для уровня шума; результат — evidence/compare/$(BEFORE)__$(AFTER).md .PHONY: bench_compare bench_compare: uv run python bench/compare.py --before "$(BEFORE)" --after "$(AFTER)" --aa "$(AA)" # «до» и «после» подряд в одной сессии, два прогона bench: bench для # BEFORE, commit доказательств, git revert commit REAPPLY (возврат -# откаченного изменения), затем bench для AFTER. Сам делает два коммита; -# рабочее дерево должно быть чистым +# откаченного изменения), затем bench для AFTER. С SERIES=<серия> вместо +# полной матрицы — серия трека 1 (make bench_scaling). Сам делает два +# коммита; рабочее дерево должно быть чистым .PHONY: bench_ab bench_ab: - uv run python bench/ab.py --before "$(BEFORE)" --after "$(AFTER)" --reapply "$(REAPPLY)" + $(KEEP_AWAKE) uv run python bench/ab.py --before "$(BEFORE)" --after "$(AFTER)" --reapply "$(REAPPLY)" $(if $(SERIES),--series "$(SERIES)") # ------------------------- diff --git a/REPORT.md b/REPORT.md index e17950a4..4ccfc0d0 100644 --- a/REPORT.md +++ b/REPORT.md @@ -623,6 +623,138 @@ swap занят 920 МиБ, но выгрузки за прогон не был займёт больше времени, но на шаги замены не влияет: она идёт до миграции. +### Цена масштабирования (трек 1, change `scaling-bench`) + +Уровень «5», трек 1 `README.md`. Гипотезы записаны и закоммичены до +первой серии (design `scaling-bench`, решение 10); результат каждой — +ниже, как получился. + +**Гипотезы.** + +- **H1. Фиксированный бюджет** (серия `a`, опора R*(1 × 1) — из серии + `b`: в серии `a` конфигурации 1 × 1 нет). При бюджете приложения + 4 CPU / 2 ГиБ одна реплика 1 × 4 использует около одного ядра: один + процесс uvicorn, один поток event loop, GIL не даёт распараллелить + Python-код и в потоках executor. Поэтому R*(1 × 4) ≈ R*(1 × 1), а 2 × 2 + и 4 × 1 растут почти пропорционально числу процессов, пока не упрёмся + в PostgreSQL, LB или хост. + - Предсказание: R*(1 × 1) ≈ 550–700/с; R*(1 × 4) / R*(1 × 1) — 0,9–1,15; + R*(2 × 2) ≥ 1,7 × R*(1 × 1); R*(4 × 1) ≥ 3 × R*(1 × 1) или признак + общего ресурса на 4 × 1. + - Механизм: CPU контейнера 1 × 4 по секундам на ступенях R* и выше — + около 1,0–1,2 ядра (`samples.csv`), троттлинг 1 × 4 около 0. + - Подтвердит — всё вместе: отношение в [0,9; 1,15]; посекундный + максимум CPU 1 × 4 ≤ 1,3 ядра, среднее на перегрузке ≤ 1,2; 2 × 2 ≥ + 1,7 × R*(1 × 1); 4 × 1 ≥ 3 × R*(1 × 1) или сработал признак `db_*` / + `pool` / `lb` / `host` / `host_cost`. + - Опровергнет — хотя бы одно: R*(1 × 4) ≥ 1,25 × R*(1 × 1) или CPU + 1 × 4 ≥ 1,5 ядра на перегрузке (процесс параллелится, и `workers` — + не единственный способ занять бюджет); R*(2 × 2) < 1,5 × R*(1 × 1) + без признака общего ресурса. +- **H1б. Троттлинг 1 × 1.** p99 у 1 × 1 хуже, чем у 1 × 4, из-за + троттлинга CFS (квота 100 мс на период 100 мс). Наш разбор до + прогона: один поток не выбирает больше 100 мс за период, троттлинг + требует второго потока (executor, время ядра на сеть) или работы у + самой квоты. Вероятный исход — на 250 и 500/с троттлинг < 1 % периодов + (H1б опровергнется), на ступени R* — заметный. + - Подтвердит: на 500/с троттлинг 1 × 1 ≥ 1 % периодов и p99 1 × 1 > + p99 1 × 4, разбросы не пересекаются. Опровергнет: троттлинг < 1 % + или разбросы p99 пересекаются. +- **H2. Рост ресурсов** (серия `b`, k = 1…6 по 1 CPU, PostgreSQL 2 CPU / + 1 ГиБ фиксирован). R*(k) растёт почти линейно, пока каждая реплика + упирается в свой CPU; рост останавливается, когда PostgreSQL выходит + на свой лимит CPU или на запись WAL и commit. Арифметика до прогона: + PostgreSQL тратит 0,3–0,45 мс CPU на запрос (калибровка `bench_quick`), + 2 ядра кончатся около 4 500–6 500/с, то есть при k ≈ 7–9, а + производительных ядер у хоста 6. Поэтому сильна **конкурирующая + гипотеза H2-хост**: рост остановит хост раньше PostgreSQL (признак + `host_cost` — CPU реплики на запрос растёт при той же нагрузке на + реплику; `host` — задачи ВМ ждут CPU). + - Предсказание: эффективность R*(k) / (k × R*(1)) ≥ 0,85 при k ≤ 3; + k_sat ∈ {4, 5}; на k_sat + 1 — `host_cost` (или `host`) либо `db_cpu`, + вероятнее `host_cost`. + - H2 подтвердит: на k_sat + 1 (или k = 6 без k_sat) срабатывает + `db_cpu` или `db_wal`, а CPU реплики падает ниже 0,9 — реплики ждут + базу. + - H2 опровергнет: на k_sat + 1 CPU PostgreSQL < 1,4 ядра и нет `db_wal` + / `db_lock` — причину называет другой признак (`host_cost`, `host`, + `lb`, `pool`); либо k_sat нет, и эффективность при k = 6 ≥ 0,8. +- **H3. Граница пула** (серия `pool`). Пул приложения — 10 + 5 = 15 на + реплику, пользователь приложения — суперпользователь (резерв + `superuser_reserved_connections` его не держит), сэмплер занимает 1 + соединение. На дефолтах граница — k = 7, вне серии `b`; опыт — 4 + реплики при `max_connections` 100 (61 ≤ 100) и 50 (61 > 50). + - Предсказание: при 100 отказов «too many clients» нет, на R* и выше + `pool_busy_share` > 0, `db_conn_replica_max` доходит до 15; при 50, + когда пулы вместе вырастают за 49 соединений, — отказы в журнале + PostgreSQL и 5xx клиенту, R*(50) < R*(100), разбросы не пересекаются. + По коду отказ даст 500 `internal`, а не 503: SQLSTATE 53300 нет в + `UNAVAILABLE_SQLSTATES` (`src/infra/db/errors.py`), а спек + `data-storage` требует 503. + - Подтвердит: при 50 есть отказы и ошибки ≥ 1 % на уровне, который при + 100 проходит; R*(50) < R*(100) без пересечения; при 100 отказов нет. + - Опровергнет: при 50 отказов нет ни на одном уровне до нарушения SLO + — реплики упираются в CPU раньше, чем копятся соединения. + +**Методика** (`make bench_scaling SERIES=…`, `bench/run.py` профили +`scaling_*`, правила — `.claude/rules/bench.md`, раздел «Серии трека 1»): + +- Хост: Apple M3 Pro, 6 производительных и 6 энергоэффективных ядер, + 18 ГиБ; ВМ Docker — 12 vCPU, 7,75 GiB. CFS-лимиты к ядрам не + привязаны: при занятых больше 6 vCPU часть работы идёт на + энергоэффективных ядрах. +- Бюджет (сумма CPU стенда и генератора не больше CPU ВМ, иначе отказ + до стенда): + + | Контейнер | CPU | Память | + |---|---|---| + | PostgreSQL | 2 | 1 ГиБ | + | HAProxy | 1 | 256 МиБ | + | Valkey | 0,5 | 128 МиБ | + | k6 | 2 | 1 ГиБ | + | сэмплер | 0,25 | 128 МиБ | + | **без реплик** | **5,75** | **2,5 ГиБ** | + + | Серия | Конфигурации | Σ CPU | + |---|---|---| + | `a` | 1 × 4 / 2 ГиБ, 2 × 2 / 1 ГиБ, 4 × 1 / 512 МиБ | 9,75 | + | `b` | k × 1 / 512 МиБ, k = 1…6 | 6,75…11,75 | + | `pool` | 4 × 1 / 512 МиБ при `max_connections` 100 и 50 | 9,75 | + | `ab` | 1 × 1 и 6 × 1 (как в `b`) | 6,75 и 11,75 | + + Серия `b` — до 6 реплик: при 7 сумма лимитов 12,75 CPU > 12 vCPU, и + лимит перестал бы быть гарантией. +- Профиль — открытая модель k6 (`k6/mixed.js`): 70 % — страница истории + (`limit=50`, курсор из пула) читаемого чата из 10 000 сообщений, 20 % — + отправка с новым `Idempotency-Key` в один из 10 чатов записи, 10 % — + `GET /users/me`. Вход по Basic — до ступеней. +- Ступень — один запуск k6: прогрев (15 с с нуля у первой ступени и + после паузы, иначе 5 с подъёма от прежнего уровня) и окно 20 с. + Сначала 250 и 500 запросов/с, затем поиск: начало — ступенька + `100 × 1,25^i` ≥ max(300 × реплик, пройденный фиксированный); подъём + до первой нарушившей (если нарушена первая — спуск), затем два деления + по среднему геометрическому. Разрешение — не грубее 6 %. +- SLO ступени: p95 успешных ≤ 200 мс и (ошибки + неполные страницы + + недосланные генератором) / запланированные ≤ 1 %. R* — наибольший + прошедший уровень поиска. +- Ячейка — конфигурация × повтор, 3 повтора, каждая на свежем стенде; + порядок — круги с перемешиванием (зерно 20261011). В отчёт — медиана + и min–max. +- Метрики ступени — посекундный сэмплер (cgroup каждого контейнера: + CPU, троттлинг, память; загрузка и PSI ВМ; статистика HAProxy; + PostgreSQL: соединения по репликам и `wait_event`, commit/s, WAL), + итог k6 по окну и распределение по `X-Instance-Id`. Узкое место + называется признаками с порогами, заданными до прогонов + (`THRESHOLDS` в `bench/scaling.py`): `app`, `db_cpu`, `db_wal`, + `db_lock`, `pool`, `lb`, `host`, `host_cost`, `generator`. +- Точка насыщения k_sat серии `b` — наименьшее k ≤ 5, при котором + медиана R*(k + 1) < 1,1 × R*(k); причина — признак общего ресурса на + k_sat + 1, не сработавший на k_sat − 1. + +**Результат** — после серий. + +**Итог по гипотезам** — после серий. + ## Ограничения и следующие шаги TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. diff --git a/bench/ab.py b/bench/ab.py index 250e1f41..812875c2 100644 --- a/bench/ab.py +++ b/bench/ab.py @@ -1,6 +1,8 @@ """Два прогона подряд: «до» и «после» одного изменения, в одной сессии. -Запуск — `make bench_ab BEFORE=<метка> AFTER=<метка> REAPPLY=`. +Запуск — `make bench_ab BEFORE=<метка> AFTER=<метка> REAPPLY= +[SERIES=<серия>]`; с `SERIES` вместо полной матрицы снимается серия трека 1 +(`make bench_scaling`). В рабочем дереве должен лежать код «до», а изменение — быть закоммиченным и откаченным отдельным commit; `REAPPLY` — commit отката. Скрипт снимает стенд «до», коммитит его результаты, возвращает изменение @@ -51,13 +53,26 @@ def problems(args: argparse.Namespace) -> list[str]: return found +def run_step(args: argparse.Namespace, label: str) -> list[str]: + """Прогон стенда: полная матрица или серия трека 1 (`--series`, + решение 11 design change `scaling-bench`).""" + if args.series: + return [ + "make", + "bench_scaling", + f"SERIES={args.series}", + f"SCALING_LABEL={label}", + ] + return ["make", "bench", f"BENCH_LABEL={label}"] + + def steps(args: argparse.Namespace) -> list[list[str]]: return [ - ["make", "bench", f"BENCH_LABEL={args.before}"], + run_step(args, args.before), ["git", "add", f"evidence/bench/{args.before}"], ["git", "commit", "-m", f"docs: add {args.before} bench evidence"], ["git", "revert", "--no-edit", args.reapply], - ["make", "bench", f"BENCH_LABEL={args.after}"], + run_step(args, args.after), ] @@ -67,6 +82,8 @@ def main(argv: list[str]) -> int: parser.add_argument("--after", default="") parser.add_argument("--reapply", default="") parser.add_argument("--dry-run", action="store_true") + # серия трека 1 вместо полной матрицы: a, b, pool, ab, quick + parser.add_argument("--series", default="") args = parser.parse_args(argv) if not (args.before and args.after and args.reapply): print( diff --git a/bench/bench.compose.yml b/bench/bench.compose.yml index b1bdc6a9..6efe5be1 100644 --- a/bench/bench.compose.yml +++ b/bench/bench.compose.yml @@ -15,8 +15,15 @@ services: # упавший контейнер не поднимается сам: прогон помечается stand_down restart: "no" # auto_explain загружен, но выключен (log_min_duration = -1): run.py - # включает его только на этапе плана, между прогонами - command: ["postgres", "-c", "shared_preload_libraries=auto_explain"] + # включает его только на этапе плана, между прогонами. max_connections + # — конфигурация серии трека 1 (граница пула), у прочих профилей 100, + # как у образа (решение 1 design change scaling-bench) + command: + - postgres + - -c + - shared_preload_libraries=auto_explain + - -c + - max_connections=${BENCH_DB_MAX_CONNECTIONS:?run make bench} ports: !reset [] deploy: resources: diff --git a/bench/compare.py b/bench/compare.py index 1b60295e..b0a4eb08 100644 --- a/bench/compare.py +++ b/bench/compare.py @@ -18,6 +18,8 @@ from dataclasses import dataclass from pathlib import Path from typing import Any +import scaling + ROOT = Path(__file__).resolve().parents[1] BENCH_DIR = ROOT / "evidence" / "bench" OUT_DIR = ROOT / "evidence" / "compare" @@ -103,19 +105,36 @@ def flatten(prefix: str, value: Any, into: dict[str, Any]) -> None: into[prefix] = value -def methodology(label: Label) -> dict[str, Any]: +def is_series(label: Label) -> bool: + """Метка серии трека 1 (design change `scaling-bench`, решение 11).""" + return bool(label.meta.get("profile", {}).get("series")) + + +def methodology( + label: Label, + configs: set[str] | None = None, +) -> dict[str, Any]: """Параметры, которые у сравнимых меток обязаны совпадать. Профиль, лимиты всех контейнеров стенда, образ генератора, образы и настройки PostgreSQL и Valkey, окружение приложения (решение 8 design change `bench-postgres`). У Valkey настройки — `maxmemory*` из - `valkey.conf`: правку конфигурации образ не покажет. + `valkey.conf`: правку конфигурации образ не покажет. У серий трека 1 + имя, серия и состав конфигураций к методике не относятся, лимиты — по + общим конфигурациям `configs` (решение 11 design change + `scaling-bench`). """ meta = label.meta stand = meta.get("stand", {}) flat: dict[str, Any] = {} - flatten("profile", meta.get("profile", {}), flat) - flatten("limits", meta.get("limits", {}), flat) + profile = dict(meta.get("profile", {})) + limits = meta.get("limits", {}) + if configs is not None: + for key in ("name", "series", "configs"): + profile.pop(key, None) + limits = {key: limits[key] for key in configs if key in limits} + flatten("profile", profile, flat) + flatten("limits", limits, flat) for name, value in ( ("generator.image", meta.get("generator", {}).get("image")), ("stand.postgres.image", stand.get("postgres", {}).get("image")), @@ -135,9 +154,22 @@ def methodology(label: Label) -> dict[str, Any]: return flat -def check_methodology(first: Label, second: Label) -> list[str]: - """Отказ при различии; возвращает параметры, записанные в одной метке.""" - a, b = methodology(first), methodology(second) +def check_methodology( + first: Label, + second: Label, + configs: set[str] | None = None, +) -> list[str]: + """Отказ при различии; возвращает параметры, записанные в одной метке. + + `configs` — общие конфигурации серий трека 1; None — матрица.""" + if is_series(first) != is_series(second): + series = first if is_series(first) else second + raise CompareError( + "different methodology: track 1 series " + f"{series.name} and matrix " + f"{(second if series is first else first).name}", + ) + a, b = methodology(first, configs), methodology(second, configs) # с change graceful-failover в пути запроса стоит HAProxy, и паспорт # пишет число реплик; метка без него снята мимо LB — другая методика # (решение 6 design change graceful-failover), а не «параметр @@ -145,7 +177,7 @@ def check_methodology(first: Label, second: Label) -> list[str]: without_lb = [ label.name for label, flat in ((first, a), (second, b)) - if "limits.api_replicas" not in flat + if configs is None and "limits.api_replicas" not in flat ] if len(without_lb) == 1: raise CompareError( @@ -261,8 +293,18 @@ def passport_rows(labels: list[Label]) -> list[str]: ) def host(meta: dict[str, Any]) -> str: - start = meta.get("host_state", {}).get("start", {}) - return f"swap {start.get('swap_used_mib')} МиБ, {start.get('power')}" + # занятый swap — не помеха; помеха — выгрузка за прогон (решение 12 + # design change scaling-bench) + state = meta.get("host_state", {}) + start = state.get("start", {}) + before = start.get("swapouts") + after = state.get("end", {}).get("swapouts") + swapped = ( + f"выгрузок в swap за прогон {after - before}" + if before is not None and after is not None + else f"swap {start.get('swap_used_mib')} МиБ" + ) + return f"{swapped}, {start.get('power')}" def versions(meta: dict[str, Any]) -> str: found = meta.get("app_image", {}).get("versions", {}) @@ -431,6 +473,218 @@ def render( return "\n".join(lines) + "\n" +@dataclass(frozen=True) +class SeriesRow: + """Общая конфигурация двух меток серий: R* повторов и числа сводки.""" + + config: str + before: dict[str, Any] + after: dict[str, Any] + + @property + def delta(self) -> float: + return (self.after["r_star"] / self.before["r_star"] - 1) * 100 + + @property + def overlap(self) -> bool: + a, b = self.before["r_stars"], self.after["r_stars"] + return min(a) <= max(b) and min(b) <= max(a) + + +def series_stats(label: Label) -> dict[str, dict[str, Any]]: + """Сводка конфигураций серии (`scaling.config_stats`) с R* полных + ячеек; ячейки с браком генератора в сравнение не входят.""" + directory = BENCH_DIR / label.name + searches = scaling.read_csv(directory / "searches.csv") + return { + c["config"]: c + for c in scaling.config_stats(label.meta, label.runs, searches) + } + + +def series_notes(label: Label, stats: dict[str, dict[str, Any]]) -> list[str]: + """Что мешает считать метку серии чистым замером: прочее — как у + матрицы, но нарушения SLO на ступенях поиска — норма, а не пометка.""" + meta = label.meta + found = [] + if meta.get("status") != "complete": + found.append(f"статус {meta.get('status')}: {meta.get('reason')}") + if meta.get("git", {}).get("dirty"): + found.append("незакоммиченные изменения (`dirty: true`)") + if meta.get("overrides"): + found.append(f"отладочные переопределения {meta['overrides']}") + found += [f"хост: {text}" for text in meta.get("host_warnings", [])] + bound = [cell for c in stats.values() for cell in c["generator_bound"]] + if bound: + found.append( + "брак генератора, ячейки не сравниваются: " + ", ".join(bound), + ) + marked = sorted( + { + run["cell"] + for run in label.runs + if {"oom", "app_down", "stand_down", "host_swap"} + & set((run.get("flags") or "").split()) + }, + ) + if marked: + found.append( + "ячейки с отказом стенда или выгрузкой: " + ", ".join(marked), + ) + return [f"`{label.name}`: {text}" for text in found] + + +def series_noise(aa: Label, before: Label) -> tuple[float, str]: + """Шум A/A серий: наибольшее по общим конфигурациям |Δ медианы R*|.""" + first, second = series_stats(aa), series_stats(before) + common = [ + SeriesRow(config=key, before=first[key], after=second[key]) + for key in first + if key in second + and first[key]["r_stars"] + and second[key]["r_stars"] + and first[key]["r_star"] + ] + if not common: + raise CompareError( + f"labels {aa.name} and {before.name} have no common configs", + ) + worst = max(common, key=lambda row: abs(row.delta)) + return abs(worst.delta), worst.config + + +def render_series( + before: Label, + after: Label, + aa: Label | None, + command: str, +) -> str: + """Сравнение меток серий трека 1 по общим конфигурациям (решение 11 + design change `scaling-bench`).""" + first, second = series_stats(before), series_stats(after) + common = [key for key in first if key in second] + if not common: + raise CompareError("labels have no common track 1 configs") + unverified = check_methodology(before, after, set(common)) + labels = [before, after] + floor = None + if aa is not None: + aa_stats = series_stats(aa) + unverified += check_methodology( + aa, + before, + {key for key in aa_stats if key in first}, + ) + floor = series_noise(aa, before) + labels.append(aa) + remarks = list(unverified) + remarks += series_notes(before, first) + series_notes(after, second) + if aa is not None: + remarks += series_notes(aa, series_stats(aa)) + remarks += [ + f"конфигурация {key} есть только в `{label.name}`: не сравнивается" + for key, label in [ + *((k, before) for k in first if k not in second), + *((k, after) for k in second if k not in first), + ] + ] + rows = [ + SeriesRow(config=key, before=first[key], after=second[key]) + for key in common + if first[key]["r_stars"] + and second[key]["r_stars"] + and first[key]["r_star"] + ] + lines = [ + f"# Сравнение серий: `{before.name}` → `{after.name}`", + "", + f"- Команда: `{command}`", + "- Метки серий трека 1 сравниваются по общим конфигурациям. R* — " + "медиана повторов, в скобках min–max; Δ R* — отношение медиан " + "минус единица. Ячейки с браком генератора не входят.", + "- Задержки — медианы по повторам на фиксированных уровнях, «до → " + "после»; CPU на запрос — CPU реплик на успешный запрос на втором " + "фиксированном уровне; CPU PostgreSQL — на ступени R*.", + ] + if floor is None: + lines.append( + "- Уровень шума не задан (`AA`): вывод говорит только, " + "пересекаются ли разбросы повторов.", + ) + else: + lines += [ + f"- Уровень шума — наибольшее по общим конфигурациям изменение " + f"медианы R* между `{aa.name if aa else ''}` и `{before.name}`: " + f"{floor[0]:.1f}% ({floor[1]}). Он имеет смысл, только если код " + "приложения в этих метках одинаков; это проверяется по git.", + "- «Эффект» — разбросы повторов не пересекаются и изменение " + "медианы больше уровня шума; иначе «в пределах шума».", + ] + lines += [ + "", + "## Метки", + "", + *passport_rows(labels), + "", + "## Замечания", + "", + ] + lines += [f"- {text}" for text in dict.fromkeys(remarks)] or ["Нет."] + fixed = before.meta["profile"].get("fixed_rps") or [] + second_level = ( + fixed[1] if len(fixed) > 1 else (fixed[0] if fixed else None) + ) + lines += [ + "", + "## R* по общим конфигурациям", + "", + "| Конфигурация | R* до | R* после | Δ R* | Вывод | " + + " | ".join(f"p95 / p99 на {lvl}, мс" for lvl in fixed) + + f" | CPU на запрос на {second_level}, мкс | CPU PostgreSQL на R*, " + "ядер |", + "|---|---|---|---|---|" + "---|" * len(fixed) + "---|---|", + ] + for row in rows: + a, b = row.before, row.after + if floor is None: + verdict = ( + "разбросы пересекаются" + if row.overlap + else "разбросы не пересекаются" + ) + elif not row.overlap and abs(row.delta) > floor[0]: + verdict = "эффект" + else: + verdict = "в пределах шума" + latency = [] + for lvl in fixed: + fa, fb = a["fixed"].get(lvl) or {}, b["fixed"].get(lvl) or {} + latency.append( + f"{scaling.fmt(fa.get('p95'), 1)} → " + f"{scaling.fmt(fb.get('p95'), 1)} / " + f"{scaling.fmt(fa.get('p99'), 1)} → " + f"{scaling.fmt(fb.get('p99'), 1)}", + ) + us_a = (a["fixed"].get(second_level) or {}).get("app_us") + us_b = (b["fixed"].get(second_level) or {}).get("app_us") + lines.append( + f"| {row.config} | {scaling.spread(a['r_stars'])} | " + f"{scaling.spread(b['r_stars'])} | {row.delta:+.1f}% | " + f"{verdict} | " + + " | ".join(latency) + + f" | {scaling.fmt(us_a, 0)} → {scaling.fmt(us_b, 0)} | " + f"{scaling.fmt(a['db_cpu_r'], 2)} → {scaling.fmt(b['db_cpu_r'], 2)} |", + ) + if rows: + deltas = [row.delta for row in rows] + lines += [ + "", + f"Δ R* по конфигурациям: от {min(deltas):+.1f}% до " + f"{max(deltas):+.1f}%.", + ] + return "\n".join(lines) + "\n" + + def main(argv: list[str]) -> int: parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) parser.add_argument("--before", default="") @@ -448,12 +702,15 @@ def main(argv: list[str]) -> int: if args.aa: command += f" AA={args.aa}" try: - text = render( - load(args.before), - load(args.after), - load(args.aa) if args.aa else None, - command, - ) + before, after = load(args.before), load(args.after) + aa = load(args.aa) if args.aa else None + if any(is_series(x) for x in (before, after, aa) if x is not None): + for other in (after, aa): + if other is not None: + check_methodology(before, other, set()) + text = render_series(before, after, aa, command) + else: + text = render(before, after, aa, command) except CompareError as exc: print(f"compare failed: {exc}", flush=True) return 1 diff --git a/bench/k6/mixed.js b/bench/k6/mixed.js new file mode 100644 index 00000000..76df0009 --- /dev/null +++ b/bench/k6/mixed.js @@ -0,0 +1,217 @@ +// Ступень серии трека 1 (решения 2–3 design change scaling-bench): +// открытая модель, три сценария ramping-arrival-rate с долями смеси — +// страница истории читаемого чата, отправка с новым Idempotency-Key в один +// из чатов записи, GET /users/me. Ступень — подъём от START до LEVEL за +// WARMUP_S (в замер не входит) и окно MEASURE_S с постоянной +// интенсивностью. Каждый запрос получает тег window (warm / hold) по +// времени отправки от начала сценария; итог содержит подметрики окна. +// Время setup (t0) — часы ВМ Docker: по нему run.py режет отсчёты +// сэмплера. Вход по Basic — в prepare.js, до ступеней. +import exec from "k6/execution"; +import http from "k6/http"; +import { check } from "k6"; +import { SharedArray } from "k6/data"; +import { Counter } from "k6/metrics"; + +import { + API, + PAGE_LIMIT, + SUMMARY_TREND_STATS, + WORK_DIR, + authHeaders, + messageHeaders, + mulberry32, + summaryFiles, + syntheticText, +} from "./lib.js"; + +const fixture = JSON.parse(open(`${WORK_DIR}/fixture.json`)); +const cursors = new SharedArray( + "cursors", + () => JSON.parse(open(`${WORK_DIR}/cursors.json`)).cursors, +); +const LEVEL = Number(__ENV.LEVEL); +const START = Number(__ENV.START || 0); +// «read:0.7,write:0.2,me:0.1» — Profile.mix +const MIX = (__ENV.MIX || "read:0.7,write:0.2,me:0.1") + .split(",") + .map((item) => item.split(":")) + .map(([name, share]) => [name, Number(share)]); +const WARMUP_S = Number(__ENV.WARMUP_S); +const MEASURE_S = Number(__ENV.MEASURE_S); +const WARMUP_MS = WARMUP_S * 1000; +// больше timeout server LB (10 с): клиент видит ответ LB, а не свой таймаут +const TIMEOUT_S = Number(__ENV.TIMEOUT || 15); +const PRE_VUS_PER_RPS = Number(__ENV.PRE_VUS_PER_RPS || 0.05); +const MAX_VUS_PER_RPS = Number(__ENV.MAX_VUS_PER_RPS || 0.2); +const SEED = Number(__ENV.SEED || 0); +const STEP = Number(__ENV.STEP || 0); +// короткие ID реплик: подметрики распределения по X-Instance-Id +const INSTANCES = (__ENV.INSTANCES || "").split(",").filter((x) => x); +const ABORT_ERRORS = Number(__ENV.ABORT_ERRORS || 0.5); +const ABORT_P95_MS = Number(__ENV.ABORT_P95_MS || 2000); +// коды неуспешных ответов окна (bench/scaling.py, ERROR_STATUSES) +const ERROR_STATUSES = [0, 400, 401, 403, 404, 409, 422, 429, 500, 502, 503, 504]; + +const READ_URL = `${API}/chats/${fixture.readChatId}/messages`; +const READ_HEADERS = authHeaders(fixture.tokens[fixture.readerId]); +const USERS = [fixture.readerId, ...fixture.memberIds]; +const WRITE_CHATS = fixture.writeChatIds || [fixture.writeChatId]; + +const shortPages = new Counter("short_pages"); +const instanceOk = new Counter("instance_ok"); + +function scenario(name, share) { + const target = Math.round(LEVEL * share); + const start = Math.round(START * share); + return { + executor: "ramping-arrival-rate", + exec: name, + startRate: start, + timeUnit: "1s", + preAllocatedVUs: Math.ceil(target * PRE_VUS_PER_RPS) + 10, + maxVUs: Math.ceil(target * MAX_VUS_PER_RPS) + 20, + stages: [ + { target, duration: `${WARMUP_S}s` }, + { target, duration: `${MEASURE_S}s` }, + ], + // запрос, начатый в конце окна, успевает дождаться ответа или таймаута + gracefulStop: `${TIMEOUT_S + 1}s`, + }; +} + +const HOLD = "window:hold"; +const thresholds = { + // досрочный выход по подметрикам окна (код k6 99): перегрузка не тянется + // до конца ступени + [`http_req_duration{${HOLD},expected_response:true}`]: [ + "max>=0", + { + threshold: `p(95)<${ABORT_P95_MS}`, + abortOnFail: true, + delayAbortEval: `${WARMUP_S + 5}s`, + }, + ], + [`http_req_failed{${HOLD}}`]: [ + "rate>=0", + { + threshold: `rate<=${ABORT_ERRORS}`, + abortOnFail: true, + delayAbortEval: `${WARMUP_S + 5}s`, + }, + ], + [`short_pages{${HOLD}}`]: ["count>=0"], + [`checks{${HOLD}}`]: ["rate>=0"], +}; +// остальные пороги всегда выполняются: они нужны, чтобы подметрики попали +// в итог +for (const [name] of MIX) { + thresholds[`http_reqs{${HOLD},scenario:${name}}`] = ["count>=0"]; + thresholds[`http_req_failed{${HOLD},scenario:${name}}`] = ["rate>=0"]; + thresholds[ + `http_req_duration{${HOLD},expected_response:true,scenario:${name}}` + ] = ["max>=0"]; + thresholds[`http_reqs{scenario:${name}}`] = ["count>=0"]; + thresholds[`http_req_failed{scenario:${name}}`] = ["rate>=0"]; +} +for (const id of [...INSTANCES, "-"]) { + thresholds[`instance_ok{${HOLD},instance:${id}}`] = ["count>=0"]; +} +for (const status of ERROR_STATUSES) { + thresholds[`http_reqs{${HOLD},status:${status}}`] = ["count>=0"]; +} + +export const options = { + scenarios: Object.fromEntries( + MIX.map(([name, share]) => [name, scenario(name, share)]), + ), + summaryTrendStats: SUMMARY_TREND_STATS, + thresholds, +}; + +export function setup() { + return { t0: Date.now() }; +} + +// тег окна по времени отправки от начала сценария +function windowTag() { + return Date.now() - exec.scenario.startTime < WARMUP_MS ? "warm" : "hold"; +} + +function counted(res, ok, window) { + if (ok) { + instanceOk.add(1, { + window, + instance: res.headers["X-Instance-Id"] || "-", + }); + } +} + +let random = null; + +export function read() { + if (random === null) { + random = mulberry32(SEED + exec.vu.idInTest); + } + const window = windowTag(); + const cursor = encodeURIComponent( + cursors[Math.floor(random() * cursors.length)], + ); + const res = http.get(`${READ_URL}?limit=${PAGE_LIMIT}&cursor=${cursor}`, { + headers: READ_HEADERS, + timeout: `${TIMEOUT_S}s`, + tags: { window }, + responseCallback: http.expectedStatuses(200), + }); + const full = res.status === 200 && res.json("items.#") === PAGE_LIMIT; + if (res.status === 200 && !full) { + // неполная страница при 200: отдельный счётчик, без двойного учёта + shortPages.add(1, { window }); + } + check(res, { "read 200 full page": () => full }, { window }); + counted(res, full, window); +} + +export function write() { + const n = exec.scenario.iterationInTest; + const sender = fixture.memberIds[n % fixture.memberIds.length]; + const chat = WRITE_CHATS[ + Math.floor(n / fixture.memberIds.length) % WRITE_CHATS.length + ]; + const window = windowTag(); + const res = http.post( + `${API}/chats/${chat}/messages`, + JSON.stringify({ text: syntheticText(`s${STEP}`, n) }), + { + // ключ — новый на каждую отправку (lib.js); стенд не повторяет + headers: messageHeaders(fixture.tokens[sender]), + responseType: "none", + timeout: `${TIMEOUT_S}s`, + tags: { window }, + responseCallback: http.expectedStatuses(201), + }, + ); + const ok = res.status === 201; + check(res, { "write 201": () => ok }, { window }); + counted(res, ok, window); +} + +export function me() { + const n = exec.scenario.iterationInTest; + const user = USERS[n % USERS.length]; + const window = windowTag(); + const res = http.get(`${API}/users/me`, { + headers: authHeaders(fixture.tokens[user]), + responseType: "none", + timeout: `${TIMEOUT_S}s`, + tags: { window }, + responseCallback: http.expectedStatuses(200), + }); + const ok = res.status === 200; + check(res, { "me 200": () => ok }, { window }); + counted(res, ok, window); +} + +export function handleSummary(data) { + return summaryFiles(data); +} diff --git a/bench/k6/prepare.js b/bench/k6/prepare.js index acc693d5..582aaa08 100644 --- a/bench/k6/prepare.js +++ b/bench/k6/prepare.js @@ -6,6 +6,8 @@ import { WORK_DIR, createChat, register } from "./lib.js"; const MEMBERS = Number(__ENV.MEMBERS || 10); +// чатов записи (Profile.write_chats): у прежних профилей один +const WRITE_CHATS = Math.max(1, Number(__ENV.WRITE_CHATS || 1)); // уровни фоновых чатов: «10x5000,100x400» — число чатов x сообщений в чате const BACKGROUND = (__ENV.BACKGROUND || "") .split(",") @@ -40,12 +42,22 @@ export function setup() { bgChats.push({ id: createChat(reader.token, title, everyone), size }); } } + const readChatId = createChat(reader.token, "bench read", everyone); + // чаты записи со всеми пользователями: серии трека 1 делят вставки на + // WRITE_CHATS правых краёв индекса истории (решение 2 design change + // scaling-bench); прежние сценарии пишут в первый — writeChatId + const writeChatIds = []; + for (let i = 0; i < WRITE_CHATS; i++) { + const title = i === 0 ? "bench write" : `bench write #${i}`; + writeChatIds.push(createChat(reader.token, title, everyone)); + } return { readerId: reader.id, memberIds, tokens, - readChatId: createChat(reader.token, "bench read", everyone), - writeChatId: createChat(reader.token, "bench write", everyone), + readChatId, + writeChatId: writeChatIds[0], + writeChatIds, bgChats, }; } diff --git a/bench/plots.py b/bench/plots.py new file mode 100644 index 00000000..4572c633 --- /dev/null +++ b/bench/plots.py @@ -0,0 +1,953 @@ +"""Графики серий трека 1: SVG текстом, только stdlib. + +Запуск — `make bench_plots LABELS="scaling-a scaling-b" [PLOTS=scaling]`, +результат — `evidence/plots//`: `rstar-by-replicas.svg`, +`p95-by-rate-<серия>.svg`, `cpu-by-component.svg` и `summary.md` (R*, +эффективность роста, R*(1 × 4) / R*(1 × 1), точка насыщения и признаки на +k_sat ± 1). Серия при завершении строит свои `p95-by-rate.svg` и +`cpu-by-component.svg` в каталоге метки (`render_series`). Данные — +`meta.json`, `searches.csv`, `runs.csv` меток; графики выводятся из +неизменяемых меток и пересоздаются той же командой. Решение 13 design +change `scaling-bench`; палитра — категориальные слоты по порядку, +проверенные валидатором на CVD, у каждой метки — `` с числами. +""" + +import argparse +import json +import math +import shutil +import sys +from pathlib import Path +from typing import Any +from xml.sax.saxutils import escape + +import scaling + +ROOT = Path(__file__).resolve().parents[1] +BENCH_DIR = ROOT / "evidence" / "bench" +OUT_DIR = ROOT / "evidence" / "plots" +# категориальные слоты в фиксированном порядке (проверены на CVD для +# соседних пар): конфигурации и компоненты получают цвет по позиции +SERIES = ( + "#2a78d6", + "#eb6834", + "#1baf7a", + "#eda100", + "#e87ba4", + "#008300", + "#6250d6", + "#e34948", +) +SURFACE = "#fcfcfb" +INK = "#0b0b0b" +INK_2 = "#52514e" +MUTED = "#898781" +GRID = "#e1e0d9" +AXIS = "#c3c2b7" +FONT = 'system-ui, -apple-system, "Segoe UI", sans-serif' +COMPONENTS = ( + ("app_cpu_cores", "реплики API"), + ("db_cpu_cores", "PostgreSQL"), + ("lb_cpu_cores", "HAProxy"), + ("cache_cpu_cores", "Valkey"), + ("generator_cpu_cores", "k6"), + ("vm_rest", "остальное в ВМ"), +) + + +class Svg: + """Минимальный построитель SVG: элементы — строки.""" + + def __init__(self, width: int, height: int, title: str) -> None: + self.width = width + self.height = height + self.parts = [ + f'<rect x="0" y="0" width="{width}" height="{height}" ' + f'fill="{SURFACE}"/>', + self.text_el(24, 30, title, size=16, weight=600), + ] + + @staticmethod + def text_el( + x: float, + y: float, + text: str, + *, + size: int = 12, + color: str = INK_2, + anchor: str = "start", + weight: int = 400, + rotate: bool = False, + ) -> str: + transform = ( + f' transform="rotate(-90 {x:.1f} {y:.1f})"' if rotate else "" + ) + return ( + f'<text x="{x:.1f}" y="{y:.1f}" font-size="{size}" ' + f'font-weight="{weight}" fill="{color}" text-anchor="{anchor}"' + f"{transform}>{escape(text)}</text>" + ) + + def text(self, *args: Any, **kwargs: Any) -> None: + self.parts.append(self.text_el(*args, **kwargs)) + + def line( + self, + x1: float, + y1: float, + x2: float, + y2: float, + *, + color: str = GRID, + width: float = 1, + dash: str = "", + ) -> None: + extra = f' stroke-dasharray="{dash}"' if dash else "" + self.parts.append( + f'<line x1="{x1:.1f}" y1="{y1:.1f}" x2="{x2:.1f}" y2="{y2:.1f}" ' + f'stroke="{color}" stroke-width="{width}"{extra}/>', + ) + + def polyline(self, points: list[tuple[float, float]], color: str) -> None: + if len(points) < 2: + return + coords = " ".join(f"{x:.1f},{y:.1f}" for x, y in points) + self.parts.append( + f'<polyline points="{coords}" fill="none" stroke="{color}" ' + 'stroke-width="2" stroke-linejoin="round" ' + 'stroke-linecap="round"/>', + ) + + def dot( + self, + x: float, + y: float, + color: str, + tip: str, + *, + hollow: bool = False, + ) -> None: + fill = SURFACE if hollow else color + self.parts.append( + f'<g><title>{escape(tip)}' + f'' + f'', + ) + + def bar( + self, + x: float, + y: float, + width: float, + height: float, + color: str, + tip: str, + *, + top: bool, + ) -> None: + """Сегмент столбика; верхний — со скруглённым концом 4 px.""" + if height <= 0: + return + if top and height > 4: + r = 4 + path = ( + f"M{x:.1f},{y + height:.1f} L{x:.1f},{y + r:.1f} " + f"Q{x:.1f},{y:.1f} {x + r:.1f},{y:.1f} " + f"L{x + width - r:.1f},{y:.1f} " + f"Q{x + width:.1f},{y:.1f} {x + width:.1f},{y + r:.1f} " + f"L{x + width:.1f},{y + height:.1f} Z" + ) + shape = f'' + else: + shape = ( + f'' + ) + self.parts.append(f"{escape(tip)}{shape}") + + def legend( + self, + items: list[tuple[str, str, str]], + x: float, + y: float, + width: float, + ) -> float: + """Легенда строками: (цвет, подпись, вид — line, dot, box, dash).""" + cx, cy = x, y + for color, label, kind in items: + item_w = 34 + 7 * len(label) + if cx + item_w > x + width: + cx, cy = x, cy + 20 + if kind == "box": + self.parts.append( + f'', + ) + elif kind == "dot": + self.parts.append( + f'', + ) + else: + self.line( + cx, + cy - 3, + cx + 16, + cy - 3, + color=color, + width=2, + dash="5 4" if kind == "dash" else "", + ) + self.text(cx + 22, cy + 1, label, color=INK_2) + cx += item_w + return cy + + def render(self) -> str: + body = "\n".join(self.parts) + return ( + '\n{body}\n\n' + ) + + +def nice_ticks(high: float, count: int = 5) -> list[float]: + """Круглые деления оси от 0 до ≥ high.""" + if high <= 0: + return [0, 1] + raw = high / count + power = 10 ** math.floor(math.log10(raw)) + step = next(m * power for m in (1, 2, 2.5, 5, 10) if m * power >= raw) + ticks = [0.0] + while ticks[-1] < high: + ticks.append(round(ticks[-1] + step, 6)) + return ticks + + +def log_ticks(low: float, high: float) -> list[float]: + ticks = [] + exp = math.floor(math.log10(low)) + while 10**exp <= high * 1.0001: + for m in (1, 2, 5): + value = m * 10**exp + if low * 0.9999 <= value <= high * 1.0001: + ticks.append(value) + exp += 1 + return ticks + + +def compact(value: float) -> str: + if value >= 1000: + text = f"{value / 1000:.1f}".rstrip("0").rstrip(".") + return f"{text}K" + if value == int(value): + return str(int(value)) + return f"{value:g}" + + +# ------------------------------------------------------------- данные + + +def load(label_dir: Path) -> dict[str, Any]: + meta = json.loads((label_dir / "meta.json").read_text(encoding="utf-8")) + runs = scaling.read_csv(label_dir / "runs.csv") + searches = scaling.read_csv(label_dir / "searches.csv") + return { + "name": label_dir.name, + "meta": meta, + "runs": runs, + "searches": searches, + "series": meta["profile"].get("series"), + "stats": scaling.config_stats(meta, runs, searches), + "chosen": scaling.chosen_steps(runs, searches), + } + + +def p95_points( + label: dict[str, Any], + config: str, +) -> tuple[list[tuple[float, float, int]], list[tuple[float, float, int]]]: + """Медиана p95 по повторам на каждом уровне: ступени лестницы и + фиксированные — линия, деления — отдельные точки.""" + line: dict[float, list[float]] = {} + split: dict[float, list[float]] = {} + for search in label["searches"]: + if search["config"] != config: + continue + for step in label["chosen"].get(search["cell"], []): + level = scaling.num(step.get("level")) + p95 = scaling.num(step.get("p95_ms")) + if level is None or p95 is None or p95 <= 0: + continue + target = split if step.get("step_kind") == "bisect" else line + target.setdefault(level, []).append(p95) + + def medians( + data: dict[float, list[float]], + ) -> list[tuple[float, float, int]]: + return [ + (level, scaling.median(values) or 0, len(values)) + for level, values in sorted(data.items()) + ] + + return medians(line), medians(split) + + +def component_values( + label: dict[str, Any], + config: str, +) -> dict[str, float | None]: + """CPU по компонентам на ступени R*: медиана по ячейкам.""" + rows = [] + for search in label["searches"]: + if search["config"] != config or search["status"] != "complete": + continue + row = scaling.step_at( + label["chosen"].get(search["cell"], []), + scaling.num(search["r_star_rps"]), + ) + if row is not None: + rows.append(row) + values: dict[str, float | None] = {} + for key, _ in COMPONENTS[:-1]: + values[key] = scaling.median(scaling.num(r.get(key)) for r in rows) + stand = sum(v or 0 for v in values.values()) + vm = scaling.median(scaling.num(r.get("vm_busy_cores")) for r in rows) + values["vm_rest"] = None if vm is None else max(0.0, vm - stand) + values["vm_busy_cores"] = vm + return values + + +# ------------------------------------------------------------ графики + + +def plot_p95(label: dict[str, Any], title: str) -> str: + stats = label["stats"] + width, height = 860, 520 + left, right, top, bottom = 76, 24, 96, 64 + svg = Svg(width, height, title) + svg.text( + 24, + 52, + f"Метка {label['name']}: медиана p95 успешных запросов по повторам " + "на каждом уровне; полые точки — ступени деления", + color=INK_2, + ) + data = {c["config"]: p95_points(label, c["config"]) for c in stats} + levels = [p[0] for line, split in data.values() for p in line + split] + values = [p[1] for line, split in data.values() for p in line + split] + if not levels: + svg.text(left, top + 40, "Нет данных", color=MUTED) + return svg.render() + x_ticks = nice_ticks(max(levels) * 1.05) + low = 10 ** math.floor(math.log10(max(min(values), 0.5))) + high = 10 ** math.ceil(math.log10(max(max(values), 250))) + y_ticks = log_ticks(low, high) + plot_w = width - left - right + plot_h = height - top - bottom + + def sx(value: float) -> float: + return left + value / x_ticks[-1] * plot_w + + def sy(value: float) -> float: + span = math.log10(high) - math.log10(low) + return ( + top + + plot_h + - (math.log10(value) - math.log10(low)) / span * plot_h + ) + + for tick in y_ticks: + svg.line(left, sy(tick), left + plot_w, sy(tick)) + svg.text( + left - 8, + sy(tick) + 4, + compact(tick), + color=MUTED, + anchor="end", + ) + for tick in x_ticks: + svg.text( + sx(tick), + top + plot_h + 18, + compact(tick), + color=MUTED, + anchor="middle", + ) + svg.line(left, top + plot_h, left + plot_w, top + plot_h, color=AXIS) + slo = label["meta"]["profile"].get("slo_p95_ms", 200) + svg.line( + left, + sy(slo), + left + plot_w, + sy(slo), + color=INK_2, + width=1.5, + dash="6 4", + ) + svg.text( + left + plot_w - 4, + sy(slo) - 6, + f"SLO p95 {slo:g} мс", + color=INK_2, + anchor="end", + ) + svg.text( + left + plot_w / 2, + height - 18, + "Интенсивность, запросов/с", + anchor="middle", + ) + svg.text( + 20, + top + plot_h / 2, + "p95, мс (логарифмическая шкала)", + anchor="middle", + rotate=True, + ) + legend = [] + for index, c in enumerate(stats): + color = SERIES[index % len(SERIES)] + line, split = data[c["config"]] + svg.polyline([(sx(x), sy(y)) for x, y, _ in line], color) + for x, y, n in line: + svg.dot( + sx(x), + sy(y), + color, + f"{c['config']}: {x:.0f} запросов/с, p95 {y:.1f} мс (повторов {n})", + ) + for x, y, n in split: + svg.dot( + sx(x), + sy(y), + color, + f"{c['config']}: деление {x:.0f} запросов/с, p95 {y:.1f} мс (повторов {n})", + hollow=True, + ) + legend.append((color, c["config"], "line")) + svg.legend(legend, left, 76, plot_w) + return svg.render() + + +def plot_cpu(labels: list[dict[str, Any]], title: str) -> str: + bars = [] + for label in labels: + prefix = f"{label['series']}: " if len(labels) > 1 else "" + for c in label["stats"]: + bars.append( + ( + f"{prefix}{c['config']}", + component_values(label, c["config"]), + c, + ), + ) + vm_cpus = labels[0]["meta"].get("docker", {}).get("vm_cpus") or 12 + perf = labels[0]["meta"].get("host", {}).get("performance_cores") + width = max(720, 120 + 78 * len(bars)) + height = 560 + left, right, top, bottom = 64, 24, 130, 84 + svg = Svg(width, height, title) + svg.text( + 24, + 52, + "Медиана занятых ядер по ячейкам на ступени R*;", + color=INK_2, + ) + svg.text( + 24, + 70, + "«остальное в ВМ» — загрузка ВМ сверх контейнеров стенда", + color=INK_2, + ) + plot_w = width - left - right + plot_h = height - top - bottom + y_ticks = nice_ticks(max(vm_cpus, 1) * 1.05) + + def sy(value: float) -> float: + return top + plot_h - value / y_ticks[-1] * plot_h + + for tick in y_ticks: + svg.line(left, sy(tick), left + plot_w, sy(tick)) + svg.text( + left - 8, + sy(tick) + 4, + compact(tick), + color=MUTED, + anchor="end", + ) + svg.line(left, sy(0), left + plot_w, sy(0), color=AXIS) + svg.line( + left, + sy(vm_cpus), + left + plot_w, + sy(vm_cpus), + color=INK_2, + width=1.5, + dash="6 4", + ) + svg.text( + left + plot_w - 4, + sy(vm_cpus) - 6, + f"{vm_cpus} vCPU ВМ", + color=INK_2, + anchor="end", + ) + if perf: + svg.line( + left, + sy(perf), + left + plot_w, + sy(perf), + color=MUTED, + width=1.5, + dash="2 4", + ) + svg.text( + left + plot_w - 4, + sy(perf) - 6, + f"{perf} производительных ядер хоста", + color=INK_2, + anchor="end", + ) + slot = plot_w / max(1, len(bars)) + bar_w = min(24.0, slot * 0.6) + for index, (name, values, c) in enumerate(bars): + x = left + slot * index + (slot - bar_w) / 2 + base = 0.0 + present = [(k, lbl) for k, lbl in COMPONENTS if values.get(k)] + for number, (key, label_text) in enumerate(COMPONENTS): + value = values.get(key) or 0 + if value <= 0: + continue + y_top = sy(base + value) + h = sy(base) - y_top + # 2 px поверхности между сегментами + gap = 2 if base > 0 else 0 + svg.bar( + x, + y_top, + bar_w, + max(0.0, h - gap), + SERIES[number], + f"{name}: {label_text} {value:.2f} ядра (R* {c['r_star'] or 0:.0f} запросов/с)", + top=key == present[-1][0], + ) + base += value + svg.text( + x + bar_w / 2, + sy(base) - 6, + f"{base:.1f}", + color=INK, + anchor="middle", + ) + svg.text( + x + bar_w / 2, + top + plot_h + 18, + name, + color=MUTED, + anchor="middle", + ) + svg.text( + x + bar_w / 2, + top + plot_h + 34, + f"R* {c['r_star'] or 0:.0f}", + color=MUTED, + anchor="middle", + ) + svg.text( + 16, + top + plot_h / 2, + "Занятые ядра", + anchor="middle", + rotate=True, + ) + svg.legend( + [(SERIES[i], text, "box") for i, (_, text) in enumerate(COMPONENTS)], + left, + 98, + plot_w, + ) + return svg.render() + + +def plot_rstar(labels: list[dict[str, Any]], title: str) -> str: + growth = next((x for x in labels if x["series"] == "b"), None) + budget = next((x for x in labels if x["series"] == "a"), None) + width, height = 860, 520 + left, right, top, bottom = 76, 24, 96, 64 + svg = Svg(width, height, title) + svg.text( + 24, + 52, + "Медиана R* по повторам, усы — min–max; пунктир — линейный рост " + "k × R*(1 × 1) серии b", + color=INK_2, + ) + sat = scaling.saturation(growth["stats"]) if growth else None + by_k = sat["by_k"] if sat else {} + base = by_k[1]["r_star"] if 1 in by_k else None + values = [max(c["r_stars"] or [0]) for c in by_k.values()] + if budget: + values += [max(c["r_stars"] or [0]) for c in budget["stats"]] + max_k = max( + [ + *by_k.keys(), + 4, + *(c["replicas"] for c in (budget or {}).get("stats", [])), + ], + ) + if base: + values.append(base * max_k) + y_ticks = nice_ticks(max(values or [1]) * 1.05) + plot_w = width - left - right + plot_h = height - top - bottom + + def sx(k: float) -> float: + return left + (k - 0.5) / max_k * plot_w + + def sy(value: float) -> float: + return top + plot_h - value / y_ticks[-1] * plot_h + + for tick in y_ticks: + svg.line(left, sy(tick), left + plot_w, sy(tick)) + svg.text( + left - 8, + sy(tick) + 4, + compact(tick), + color=MUTED, + anchor="end", + ) + for k in range(1, max_k + 1): + svg.text( + sx(k), + top + plot_h + 18, + str(k), + color=MUTED, + anchor="middle", + ) + svg.line(left, sy(0), left + plot_w, sy(0), color=AXIS) + svg.text( + left + plot_w / 2, + height - 18, + "Число реплик API", + anchor="middle", + ) + svg.text( + 20, + top + plot_h / 2, + "R*, запросов/с", + anchor="middle", + rotate=True, + ) + legend = [] + if base: + svg.line( + sx(1), + sy(base), + sx(max_k), + sy(base * max_k), + color=MUTED, + width=1.5, + dash="6 4", + ) + legend.append((MUTED, "линейный рост от 1 × 1", "dash")) + if by_k: + color = SERIES[0] + points = [] + for k, c in sorted(by_k.items()): + if c["r_star"] is None: + continue + lo, hi = min(c["r_stars"]), max(c["r_stars"]) + svg.line(sx(k), sy(lo), sx(k), sy(hi), color=color, width=1.5) + svg.line( + sx(k) - 5, + sy(lo), + sx(k) + 5, + sy(lo), + color=color, + width=1.5, + ) + svg.line( + sx(k) - 5, + sy(hi), + sx(k) + 5, + sy(hi), + color=color, + width=1.5, + ) + points.append((k, c)) + svg.polyline([(sx(k), sy(c["r_star"])) for k, c in points], color) + for k, c in points: + eff = sat["efficiency"].get(k) if sat else None + svg.dot( + sx(k), + sy(c["r_star"]), + color, + f"серия b, {k} × 1: R* {scaling.spread(c['r_stars'])} запросов/с" + + (f", эффективность {eff:.2f}" if eff is not None else ""), + ) + if points: + k, c = points[-1] + svg.text( + sx(k) + 10, + sy(c["r_star"]) + 4, + f"{c['r_star']:.0f}", + color=INK, + ) + legend.append((color, "серия b: k × 1 CPU", "line")) + if sat and sat["k_sat"]: + k = sat["k_sat"] + svg.line( + sx(k), + top, + sx(k), + top + plot_h, + color=INK_2, + width=1, + dash="2 4", + ) + svg.text(sx(k) + 6, top + 14, f"k_sat = {k}", color=INK_2) + if budget: + color = SERIES[1] + for c in budget["stats"]: + if c["r_star"] is None: + continue + k = c["replicas"] + lo, hi = min(c["r_stars"]), max(c["r_stars"]) + svg.line( + sx(k) + 14, + sy(lo), + sx(k) + 14, + sy(hi), + color=color, + width=1.5, + ) + svg.dot( + sx(k) + 14, + sy(c["r_star"]), + color, + f"серия a, {k} × {c['replica_cpus']}: R* {scaling.spread(c['r_stars'])} запросов/с", + ) + svg.text( + sx(k) + 24, + sy(c["r_star"]) + 4, + f"{k} × {c['replica_cpus']}", + color=INK_2, + ) + legend.append((color, "серия a: бюджет 4 CPU", "dot")) + svg.legend(legend, left, 76, plot_w) + return svg.render() + + +# ------------------------------------------------------------ сводка + + +def render_combined_summary(labels: list[dict[str, Any]], command: str) -> str: + growth = next((x for x in labels if x["series"] == "b"), None) + sat = scaling.saturation(growth["stats"]) if growth else None + base = None + if sat and 1 in sat["by_k"]: + base = sat["by_k"][1] + # host_cost всех серий — против 1 × 1 серии b (в серии a её нет) + for label in labels: + for c in label["stats"]: + scaling.apply_host_cost(c, base["app_us_marginal"]) + lines = [ + "# Цена масштабирования: сводка серий", + "", + f"- Команда: `{command}`", + "- Метки: " + + ", ".join( + f"`{x['name']}` (серия `{x['series']}`, commit " + f"`{x['meta']['git']['commit']}`, {x['meta']['status']})" + for x in labels + ), + "- R* — медиана (min–max) по повторам; эффективность — R* / (k × " + "R*(1 × 1)), опора — 1 × 1 серии `b`; предельный CPU на запрос — " + "наклон CPU реплик от успешных запросов/с по ступеням, прошедшим " + "SLO; host_cost — он же против 1 × 1 серии `b` (порог " + f"{scaling.THRESHOLDS['host_cost']})", + "", + "## R* по конфигурациям", + "", + "| Серия | Конфигурация | R*, запросов/с | Эффективность | p95 на " + "250 / 500, мс | p99 на 250 / 500, мс | CPU реплик на запрос на 500, " + "мкс | Предельный CPU на запрос, мкс | host_cost | Признаки на R* | " + "Признаки на первой нарушившей |", + "|---|---|---|---|---|---|---|---|---|---|---|", + ] + for label in labels: + for c in label["stats"]: + k = c["replicas"] + eff = ( + c["r_star"] / (k * base["r_star"]) + if base and base["r_star"] and c["r_star"] is not None + else None + ) + f250 = c["fixed"].get(250) or {} + f500 = c["fixed"].get(500) or {} + us = f500.get("app_us") + cost = c.get("host_cost") + signs_r = list(c["signs_r"]) + signs_f = list(c["signs_f"]) + lines.append( + f"| {label['series']} | {c['config']} | " + f"{scaling.spread(c['r_stars'])} | {scaling.fmt(eff, 2)} | " + f"{scaling.fmt(f250.get('p95'), 1)} / " + f"{scaling.fmt(f500.get('p95'), 1)} | " + f"{scaling.fmt(f250.get('p99'), 1)} / " + f"{scaling.fmt(f500.get('p99'), 1)} | {scaling.fmt(us, 0)} | " + f"{scaling.fmt(c.get('app_us_marginal'), 0)} | " + f"{scaling.fmt(cost, 2)} | {' '.join(signs_r) or '—'} | " + f"{' '.join(signs_f) or '—'} |", + ) + lines.append("") + budget = next((x for x in labels if x["series"] == "a"), None) + if budget and base and base["r_star"]: + one = next((c for c in budget["stats"] if c["replicas"] == 1), None) + if one and one["r_star"] is not None: + lines += [ + "## Фиксированный бюджет", + "", + f"R*(1 × {one['replica_cpus']}) / R*(1 × 1) = " + f"{one['r_star']:.0f} / {base['r_star']:.0f} = " + f"**{one['r_star'] / base['r_star']:.2f}** (H1: 0,9–1,15). " + "Посекундный максимум CPU реплики 1 × " + f"{one['replica_cpus']} за серию: " + f"{scaling.fmt(one['app_cpu_second_max'], 2)} ядра.", + "", + ] + if sat: + lines += [ + "## Точка насыщения (серия `b`)", + "", + f"Правило: наименьшее k ≤ 5, при котором медиана R*(k + 1) < " + f"{scaling.THRESHOLDS['k_sat_gain']} × R*(k).", + "", + "| k | R*, запросов/с | Прирост к k − 1 | Эффективность | " + "CPU реплики на R*, ядер на реплику | CPU PostgreSQL на R*, " + "ядер | Признаки на R* | Признаки на первой нарушившей |", + "|---|---|---|---|---|---|---|---|", + ] + previous = None + for k, c in sorted(sat["by_k"].items()): + gain = ( + c["r_star"] / previous - 1 + if previous and c["r_star"] is not None + else None + ) + per = c["app_cpu_r"] / k if c["app_cpu_r"] is not None else None + lines.append( + f"| {k} | {scaling.spread(c['r_stars'])} | " + + (f"{gain * 100:+.0f} %" if gain is not None else "—") + + f" | {scaling.fmt(sat['efficiency'].get(k), 2)} | " + f"{scaling.fmt(per, 2)} | {scaling.fmt(c['db_cpu_r'], 2)} | " + f"{' '.join(c['signs_r']) or '—'} | " + f"{' '.join(c['signs_f']) or '—'} |", + ) + previous = c["r_star"] + k_sat = sat["k_sat"] + lines += [ + "", + "k_sat: " + + ( + f"**{k_sat}** — признаки на k_sat − 1, k_sat и k_sat + 1 — " + "строки таблицы выше" + if k_sat + else "нет: в пределах серии каждая реплика добавляет не " + "меньше 10 %" + ), + "", + ] + return "\n".join(lines) + + +def render_series(label_dir: Path) -> None: + """Графики серии в каталоге метки: p95 от интенсивности и CPU по + компонентам на R*.""" + try: + label = load(label_dir) + except (OSError, ValueError, KeyError): + return + if not label["searches"]: + return + series = label["series"] + (label_dir / "p95-by-rate.svg").write_text( + plot_p95(label, f"Серия {series}: p95 от интенсивности"), + encoding="utf-8", + ) + (label_dir / "cpu-by-component.svg").write_text( + plot_cpu([label], f"Серия {series}: CPU по компонентам на R*"), + encoding="utf-8", + ) + + +def render_combined(names: list[str], out_name: str, command: str) -> Path: + labels = [load(BENCH_DIR / name) for name in names] + out = OUT_DIR / out_name + if out.exists(): + shutil.rmtree(out) + out.mkdir(parents=True) + (out / "rstar-by-replicas.svg").write_text( + plot_rstar(labels, "R* от числа реплик API"), + encoding="utf-8", + ) + for label in labels: + (out / f"p95-by-rate-{label['series']}.svg").write_text( + plot_p95(label, f"Серия {label['series']}: p95 от интенсивности"), + encoding="utf-8", + ) + (out / "cpu-by-component.svg").write_text( + plot_cpu(labels, "CPU по компонентам на R*"), + encoding="utf-8", + ) + (out / "summary.md").write_text( + render_combined_summary(labels, command), + encoding="utf-8", + ) + return out + + +def main(argv: list[str]) -> int: + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument("--labels", default="") + parser.add_argument("--out", default="scaling") + args = parser.parse_args(argv) + names = args.labels.split() + if not names: + print( + 'labels are required: make bench_plots LABELS="