Files
mtusi2026lab3/openspec/changes/scaling-bench/design.md
T
ricoromaandClaude Opus 5.5 02fd3d8a36 feat: add track 1 scaling series to the bench stand
Series a/b/pool/ab/quick in bench/run.py: per-cell fresh stand with the
configuration's replicas and max_connections, open-model mixed profile
(k6/mixed.js), fixed levels and R* search by SLO, a sampler container
for cgroup, VM, HAProxy and PostgreSQL metrics, resume and a stand
lock. Pure helpers in bench/scaling.py, SVG plots in bench/plots.py,
series mode for bench_compare and bench_ab. Hypotheses H1-H3 go to
REPORT.md before the first series.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-11 03:28:36 +03:00

91 KiB
Raw Blame History

Design

Context

Мотивация — proposal.md, «Why». Требования — дельта load-benchmark. Стенд bench/ и его инварианты — .claude/rules/bench.md. LB и пул — balancer.md, infra.md. Трек 1 в плане — PLAN.md, «Трек 5». Указания пользователя от 2026-10-10 — заметки основной сессии: swap, гипотеза 1, workers.

Стенд сейчас (commit 84ee13c, архив rolling-update):

  • bench/run.py: Profile (поля методики), Stand (проект compose mtusi-bench), Bench. Профили:

    • матрица лаб 1–2: full, quick, restore* — закрытая модель, фиксированное число клиентов k6;
    • failover*, rollout* — постоянная интенсивность (constant-arrival-rate), две реплики с лимитами рабочего стенда.
  • Stand.start() поднимает свежий стенд:

    1. PostgreSQL и Valkey;
    2. миграции run --rm migrate;
    3. реплики api и haproxy (container_name: mtusi-bench-haproxy);
    4. контейнер k6 mtusi-bench-k6 без лимитов, sleep infinity; в нём docker exec k6 run.

    Готовность — LB видит UP все реплики по их адресам (wait_ready).

  • Подготовка постоянной нагрузки — общий хелпер Bench.prepare_load(): prepare.js, наполнение по расписанию (prefill.js), VACUUM (ANALYZE) + CHECKPOINT, пул курсоров (cursors.js).

  • Метрики: CPU приложения (сумма usage_usec реплик), PostgreSQL и k6 — снимки cpu.stat до и после прогона (Stand.snapshot). RSS реплик — раз в секунду (Watcher, docker exec в каждую реплику). Троттлинга, LB, соединений и ожиданий PostgreSQL, загрузки ВМ в таблицах нет.

  • Хост: в host_state() — занятый swap, свободная память, питание. Предупреждение — swap > 1024 МиБ (SWAP_WARN_MIB).

  • compare.py знает только ячейки матрицы (сценарий, размер, конкуренция). ab.py всегда запускает make bench.

Хост (2026-10-11, проверено):

Что Значение
Процессор Apple M3 Pro: 6 производительных и 6 энергоэффективных ядер (hw.perflevel0/1.physicalcpu), 18 ГиБ
ВМ Docker 12 vCPU, 7,75 GiB, Docker 29.8.2, ядро 7.0.14-linuxkit
cgroup v2, драйвер cgroupfs
PSI /proc/pressure/cpu в ВМ есть
  • Разведка. Разовый контейнер на образе PostgreSQL стенда с --cgroupns=host читает /sys/fs/cgroup/docker/<полный id>/cpu.stat, memory.current и cpu.pressure любого контейнера. В cpu.stat есть nr_periods, nr_throttled, throttled_usec. В образе есть date +%s%N (часы ВМ), psql и sed.
  • vCPU и ядра. CFS-лимиты Docker к ядрам не привязаны. vCPU ВМ — потоки macOS. Когда занято больше 6 vCPU, часть работы идёт на энергоэффективных ядрах, и «1 CPU» квоты даёт меньше работы.

PostgreSQL 18.6 (рабочий стенд, проверено запросом):

  • в pg_stat_wal — wal_records, wal_fpi, wal_bytes;
  • fsync WAL — в pg_stat_io (object = 'wal', fsyncs);
  • в pg_stat_database — xact_commit, xact_rollback, sessions, sessions_fatal, numbackends.

Пользователь приложения — POSTGRES_USER образа, то есть суперпользователь (rolsuper = t). Поэтому superuser_reserved_connections (3) его не ограничивает: приложению доступны все max_connections (100).

Приложение (код не меняется, факты для гипотез):

  • Пул. 10 + 5 соединений на реплику (src/config/settings.py), ожидание свободного — до 5 с.
  • Готовность. /health/ready берёт соединение из того же пула и ждёт его не дольше 2 с.
  • Ошибки БД. get_db_session переводит в 503 только ошибки, которые is_db_unavailable считает недоступностью (src/infra/db/errors.py). SQLSTATE 53300 («too many clients») в UNAVAILABLE_SQLSTATES нет — по коду такой отказ даст 500. Спек data-storage («Недоступность PostgreSQL», «Ограниченный пул») требует 503. Это предсказание гипотезы H3 (решение 10), а не правка этого change.
  • uvloop и httptools уже работают: fastapi[all] ставит uvicorn[standard], в uv.lock — uvloop 0.22.1 и httptools 0.8.0, а uvicorn.run без loop= выбирает их сам. Кандидат №3 PLAN.md («uvloop/httptools») отпадает (решение 11).

LB. У слотов server-template нет maxconn, поэтому HAProxy не держит очередь к репликам: qcur и qtime ожидаемо 0. Запрос ждёт уже в реплике (accept, event loop) и в её пуле.

Калибровка — make bench_quick, метка quick-20261010T220924Z, commit de654a1, одна реплика 1 CPU за LB, закрытая модель:

Сценарий Потолок реплики, запросов/с CPU реплики CPU PostgreSQL
Чтение страницы 650–730 1,00 0,16–0,19
Запись 540–620 1,00 0,19–0,26

Отсюда:

  • CPU PostgreSQL на запрос — около 0,3–0,45 мс;
  • потолок одной реплики на смеси 70/20/10 — около 550–700 запросов/с.

Указания пользователя (2026-10-10):

  • помеха замеру — выгрузка в swap за прогон (прирост Swapouts), а не занятый swap;
  • гипотеза 1: опора R*(1 × 1) — из серии B; механизм проверяется по CPU реплики 1 × 4 по секундам и по cpu.stat;
  • workers=N запрещён (run-modes.md); контрольную конфигурацию «1 контейнер × 4 workers» пользователь отклонил.

Goals / Non-Goals

Goals:

  • Найти R* каждой конфигурации серий A, B и pool открытой моделью, с разбросом по трём повторам.
  • Снимать метрики, по которым узкое место называется числом, а не догадкой (решение 9).
  • Записать и закоммитить гипотезы до первого прогона (решение 10).
  • Запускать каждую серию одной командой в фоне. Прерванную серию — продолжать без ручной уборки. Ни один вызов инструмента агента не длится 10 минут.
  • Подготовить «до/после» и уровень шума для scaling-improvement.

Non-Goals:

  • workers=N и контрольная конфигурация «1 × 4 workers». Правило run-modes.md: LB видит каждый процесс отдельной репликой со своим X-Instance-Id. Пользователь отклонил контроль 2026-10-10. В отчёте — одна фраза почему.
  • Само улучшение (пул, запись одним SQL, PgBouncer) — change scaling-improvement.
  • Правка кода приложения и рабочего стенда. Найденный дефект — в KNOWN_ISSUES.md (решение 10, H3).
  • Серия B больше 6 реплик и переподписка лимитов (решение 1).
  • Строка k6 на каждый запрос, как в failover. Для серий хватает итогов k6 по окнам.
  • Смена методики матрицы лаб 1–2, профилей failover и rollout. Их касаются только общие правки: состояние хоста, блокировка, max_connections = 100 в override.

Decisions

1. Ресурсы: бюджет конфигураций и почему серия B — до 6 реплик

Лимиты, одинаковые во всех сериях, без swap (memswap = memory):

Контейнер CPU Память Почему
PostgreSQL 2 1 ГиБ как рабочий стенд (docker-compose.yml)
HAProxy 1 256 МиБ как рабочий стенд, nbthread 1
Valkey 0,5 128 МиБ как рабочий стенд
k6 2 1 ГиБ решение 6
сэмплер 0,25 128 МиБ решение 7
итого без реплик 5,75 2,5 ГиБ

Реплики по конфигурациям:

Серия Конфигурации (реплик × CPU / память) Σ CPU с остальными Σ памяти Запас памяти ВМ
A — бюджет 4 CPU / 2 ГиБ 1 × 4 / 2 ГиБ, 2 × 2 / 1 ГиБ, 4 × 1 / 512 МиБ 9,75 4,5 ГиБ 3,25 ГиБ
B — рост k × 1 / 512 МиБ, k = 1…6 6,75…11,75 3,0…5,5 ГиБ ≥ 2,25 ГиБ
pool — граница пула 4 × 1 / 512 МиБ, max_connections 100 и 50 9,75 4,5 ГиБ 3,25 ГиБ
ab — «до/после» и A/A 1 × 1 и 6 × 1 / 512 МиБ (решение 11) 6,75 и 11,75 3,0 и 5,5 ГиБ ≥ 2,25 ГиБ

Правило. Сумма лимитов CPU конфигурации не больше числа CPU ВМ (12). Иначе run.py отказывает до стенда (код 2). По памяти — прежнее предупреждение vm_warnings о запасе 1,5 ГиБ, теперь с генератором и сэмплером. Таблица бюджета — в паспорте (meta.budget) и в ограничениях отчёта.

Почему так:

  • PostgreSQL 2 CPU / 1 ГиБ, а не 3 ГБ из плана.
    • Это лимиты рабочего стенда: трек отвечает, почему рост реплик перестаёт помогать именно этому стенду.
    • shared_buffers — 128 МБ образа, данные ячейки — десятки МБ, 1 ГиБ хватает.
    • С 3 ГБ серия B не помещается в память ВМ уже при k = 6: 3 ГиБ PostgreSQL + 3 ГиБ реплик + 1,5 ГиБ прочих = 7,5 ГиБ при 7,75 ГиБ ВМ и запасе 1,5 ГиБ.
  • Серия B до 6 реплик. При k = 7 сумма лимитов — 12,75 CPU, при k = 8 — 13,75 при 12 vCPU.
    • Лимит перестаёт быть гарантией: точка измеряла бы планировщик macOS, а не стенд.
    • На хосте 6 производительных ядер. Уже около k = 4 занято около 6 vCPU (4 реплики + ~0,8 PostgreSQL + LB + k6), дальше часть работы идёт на энергоэффективных ядрах.
    • Это ограничение называется в отчёте и измеряется (решение 9, признаки host и host_cost).
  • Граница пула при пуле 10 + 5 на реплику — k = 7 (105 > 100), она вне серии B. Её проверяет серия pool управляемым опытом:
    • 4 реплики при max_connections 100 (60 + 1 ≤ 100) и 50 (60 + 1 > 50);
    • «+1» — постоянное соединение сэмплера;
    • отличается одна настройка PostgreSQL, CPU тот же, порядок ячеек перемешан внутри одной метки.

Отвергнуто:

  • k = 7–8 с переподпиской и пометкой. Граница пула на дефолтах видна, но смешана с нехваткой CPU ВМ и энергоэффективными ядрами. Причину не отделить.
  • PostgreSQL 1 CPU и генератор 1 CPU, чтобы влезло 8. PostgreSQL стал бы узким местом искусственно, генератору на вершине серии не хватило бы запаса (решение 6).
  • Память реплики 384 МиБ. CPU всё равно не помещается, а 4 × 1 серии A и k = 4 серии B перестали бы совпадать.
  • Свернуть ВМ до 6 vCPU, чтобы остаться на производительных ядрах. Бюджет серии A (9,75) тогда не помещается.

max_connections задаётся переменной BENCH_DB_MAX_CONNECTIONS в команде PostgreSQL override (-c max_connections=…). Профили лаб 1–2, failover и rollout получают 100 — значение образа, паспорт тот же.

2. Профиль нагрузки и данные ячейки

Данные — свежие в каждой ячейке (решение 4). Подготовка — общий хелпер prepare_load() с новым параметром числа чатов записи:

  • пользователи: читатель и 10 участников (MEMBERS=10); регистрация с паролем и вход по Basic в prepare.js до первой ступени. Токены — только в .work/fixture.json;
  • читаемый чат — 10 000 сообщений: наполнение prefill.js по расписанию одного чата, затем VACUUM (ANALYZE) и CHECKPOINT;
  • 10 чатов записи (prepare.js, новый WRITE_CHATS): в каждом все пользователи. В фикстуре — writeChatIds, а writeChatId = первый из них: прежние сценарии не меняются;
  • пул из 1 000 курсоров (cursors.js); в пул входят позиции, после которых есть полная страница.

Смесь — новый сценарий k6/mixed.js. Три сценария k6 в одном запуске; доли выдерживаются в каждой ступени. Интенсивность сценария — round(уровень × доля), сумма может отличаться от уровня на ±1, в строку пишется фактическая.

Сценарий Доля Запрос Проверка
read 0,7 GET /chats/{читаемый}/messages?limit=50&cursor=… токеном читателя 200 и ровно 50 элементов; иначе — ошибка
write 0,2 POST /chats/{чат записи}/messages; messageHeaders(token) — новый Idempotency-Key, текст TEXT_LENGTH 201
me 0,1 GET /users/me 200

Подробности сценариев:

  • Кто пишет и куда. Отправитель записи n — memberIds[n % 10], чат — writeChatIds[⌊n / 10⌋ % 10]. GET /users/me — по кругу все 11 пользователей.
  • Курсоры. Генератор mulberry32(SEED + номер VU), SEED = зерно профиля + 1000 × повтор + номер ступени. Одинаковые ступени разных конфигураций читают одни и те же страницы.
  • Тела ответов. У записи и me тело не читается (responseType: "none"), у чтения разбирается число элементов.
  • Ожидаемые статусы. responseCallback с ожидаемым статусом сценария: http_req_failed и expected_response считают ошибки правильно.
  • Неполная страница. При статусе 200 она считается отдельным счётчиком short_pages, без двойного учёта.

Почему 10 чатов записи, а не один. Все вставки одного чата попадают в правый край одного листа индекса (chat_id, created_at, id). При сотнях вставок в секунду это даёт искусственную конкуренцию LWLock:BufferContent — горячую точку профиля, а не масштабирования. 10 чатов делят её на 10. Больше чатов не нужно: карточки в кэше, стоимость членства не зависит от числа чатов.

Рост таблиц. Каждая ячейка начинается со свежего стенда (down -v): одинаковые данные, пустые таблицы ключей и чатов записи. Внутри ячейки запись растёт с интенсивностью: при k = 6 — до ~150 тыс. строк messages и idempotency_keys за ячейку. Индекс ключей при этом меньше shared_buffers. Рост виден по ступеням (store_messages_start / _end).

Отвергнуто:

  • Очистка между ячейками через psql (TRUNCATE). Оркестратор не меняет данные, видимые приложению (bench.md, «Как писать»).
  • Один стенд на конфигурацию. Рост таблиц смешался бы с порядком повторов.

Сверка в конце ячейки (psql, только счётчики):

  • в читаемом чате 10 000 сообщений;
  • в чатах записи сообщений не меньше числа 201 и не больше числа отправок за все ступени, считая прогревы. Стенд запись не повторяет: при таймауте и 504 исход не определён.

Иначе — BenchError с ячейкой.

3. Ступени, SLO и поиск R*

Ступень — один запуск k6 (mixed.js), во всех сценариях executor ramping-arrival-rate:

startRate = уровень прежней ступени × доля, если она прошла;
            0 — у первой ступени ячейки и после паузы
stages    = [{target: уровень × доля, duration: прогрев},
             {target: уровень × доля, duration: замер}]
прогрев   = first_warmup_s у первой ступени и после паузы, иначе step_warmup_s

После нарушенной ступени и паузы стенд простаивал, поэтому следующая ступень начинается с нуля и с долгим прогревом, как первая. Подъём от нарушенного уровня вниз сразу перегрузил бы стенд.

Параметр (Profile) Значение Зачем
first_warmup_s 15 первая ступень ячейки: соединения LB и пулов, кэш карточек
step_warmup_s 5 подъём от прежнего уровня; в замер не входит
step_measure_s 20 окно замера: ≥ 5 000 запросов на 250/с — p95 устойчив
cooldown_s 10 пауза без нагрузки после нарушенной ступени, затем wait_ready (до 30 с)
request_timeout_s 15 больше timeout server LB (10 с): клиент видит 504 LB, а не свой таймаут
prevus_per_rps 0,05 заранее созданные VU: ceil(цель × 0,05) + 10 на сценарий
vus_per_rps 0,2 предел VU: ceil(цель × 0,2) + 20. Средняя задержка > 200 мс уже нарушила SLO; больше VU вердикт не изменят, только съедят память генератора

Окно. Ступень делится на прогрев и замер по времени отправки: Date.now() − exec.scenario.startTime < прогрев → тег window: warm, иначе hold. Тег ставится на каждый запрос (params.tags). Каждая итерация — ровно один запрос, поэтому http_reqs{window:hold, scenario:X} — начатые в окне итерации сценария X. Подметрики окна попадают в итог через пороги, которые всегда выполняются (как SUMMARY_THRESHOLDS):

  • http_req_duration{window:hold,expected_response:true} и то же по сценариям;
  • http_req_failed{window:hold} и по сценариям;
  • http_reqs{window:hold} по сценариям;
  • short_pages{window:hold};
  • instance_ok{window:hold,instance:<id>} для каждого X-Instance-Id из INSTANCES и - (решение 7).

setup() возвращает t0 = Date.now() (часы ВМ), итог содержит setup_data.t0. Окно замера на часах ВМ — `[t0 + прогрев, t0 + прогрев

  • замер]`. По нему режутся отсчёты сэмплера (решение 7).

SLO ступени (Profile.slo_p95_ms = 200, slo_error_ratio = 0,01). Ступень прошла, если в окне одновременно:

  • p95 успешных ≤ 200 мс;
  • (неуспешные + короткие страницы + недосланные) / запланированные ≤ 1 %.

Определения:

  • Запланированные — Σ цель_сценария × замер: интенсивность в окне постоянна.
  • Недосланные — max(0, запланированные − отправленные в окне). Пропуски на границе окна — до ±1 на сценарий.

Неотправленный запрос открытой модели — ошибка клиента, иначе вернулось бы coordinated omission. Метрика k6 dropped_iterations за всю ступень пишется отдельно: её нельзя разделить на прогрев и замер.

Досрочное прерывание — пороги k6 с abortOnFail и delayAbortEval = прогрев + 5 с на подметриках окна: ошибок больше 50 % или p95 больше 2 с. k6 выходит с кодом 99, итог пишется. run.py считает ступень нарушившей SLO с причиной abort, а не сбоем k6.

Порядок ступеней ячейки:

  1. Фиксированные уровни Profile.fixed_rps = (250, 500) — те же во всех сериях. Около 40 % и 80 % потолка одной реплики (Context): все конфигурации, кроме, возможно, k = 1 на 500, держат их. Это сравнение задержек при равной нагрузке и прогрев ячейки.

  2. Поиск по лестнице round(100 × 1,25^i): 100, 125, 156, 195, 244, 305, 381, 477, 596, 745, 931, 1164, 1455, 1819, 2274, 2842, 3553, 4441, 5551, …

    • Начало L0 — наименьшая ступенька ≥ max(300 × реплик, наибольший пройденный фиксированный уровень) и строго больше него. start_rps_per_replica = 300 — около половины ожидаемого потолка реплики. Примеры: 1 × 4 — 596, 2 × 2 — 745, 4 × 1 — 1455, k = 6 — 1819.
    • Подъём по ступенькам, пока SLO выполняется. Первая нарушившая — F, последняя прошедшая — P.
    • Спуск. Если L0 нарушена — вниз по ступенькам до первой прошедшей. Если спуск дошёл до пройденного фиксированного уровня, P = он, без повтора. Если не пройден ни один фиксированный уровень, спуск идёт от 250 до 100; не прошла и 100 — R* = 0, пометка floor.
    • Деление bisect_steps = 2 раза: M = round(√(P × F)); M прошла → P = M, иначе F = M.
    • R = P.* F / P ≤ 1,25^¼ ≈ 1,057 — разрешение лучше 6 %.
    • Предел — 12 ступеней поиска (max_steps), иначе пометка search_limit.

    Пример k = 6: 1819 → 2274 → 2842 (нарушена) → 2542 → 2404 или 2688. Обычно 4–6 ступеней поиска.

Чем это лучше одной долгой лестницы ramping-arrival-rate:

  • после первого нарушения поиск идёт вниз и делит промежуток, а не разгоняет стенд дальше;
  • метрики ступени (k6, сэмплер, LB, PostgreSQL) берутся из одного окна;
  • перегрузка не тянется в следующую ступень: после нарушения — пауза и проверка готовности.

Цена — перерыв в нагрузке 1–3 с между запусками k6 и новые соединения клиента в каждой ступени. Их покрывает прогрев.

Отвергнуто:

  • Одна лестница k6 до конца с тегом ступени. Нет адаптивного останова: перегрузка после нарушения идёт до конца лестницы и ломает стенд. Окна LB и PostgreSQL пришлось бы резать по времени внутри одного запуска.
  • Фиксированная лестница от 0,4 до 1,5 предсказанного потолка. Нужны предсказания, а при промахе насыщение не находится.
  • Закрытая модель (VU). Скрывает насыщение (PLAN.md).

Устойчивость проверяется окном 20 с. Превышение потолка на 3 % и больше даёт очередь ~0,6 с к концу окна при 2 000/с и ловится по p95. Превышение на ~1 % может пройти. Это меньше разрешения поиска; ограничение названо в отчёте.

4. Повторы, порядок и свежий стенд

  • Ячейка — конфигурация × повтор, 3 повтора (repeats = 3).
  • Свежий стенд в каждой ячейке: down -v в конце прежней, затем Stand.start() с лимитами конфигурации. Ячейки независимы, и порядок можно перемешивать.
  • Порядок блочный. Круг r = 1…3 — перестановка всех конфигураций генератором random.Random(order_seed + r) (order_seed = 20261011). Круги идут подряд. Если круг начинается с той же конфигурации, которой кончился прежний, она меняется местами со второй — повторы одной конфигурации не стоят рядом. Порядок записывается в meta.plan до первой ячейки.
  • Прогрев:
    • у ячейки — первая ступень (250/с) с прогревом 15 с;
    • после паузы за нарушенной ступенью — тоже 15 с с нуля;
    • у остальных ступеней — 5 с подъёма;
    • кэш карточек и пулы реплик прогреты наполнением и сбором курсоров.
  • В отчёт — медиана и разброс min–max повторов: R*, задержки на фиксированных уровнях, CPU на запрос. Запись «медиана (min–max)» — та же, что у матрицы (cell() в run.py).

Отвергнуто:

  • Полностью случайная перестановка ячеек: повторы одной конфигурации могут встать подряд, и дрейф хоста ляжет на одну конфигурацию.
  • Повторы подряд на одном стенде: рост таблиц (решение 2).

5. Длительность, фоновый запуск, продолжение и блокировка

Оценка ячейки:

Этап Время
стенд (хранилища, миграции, реплики, LB, k6, сэмплер) ~25 с
prepare.js ~10 с
наполнение 10 000 5–17 с
обслуживание и курсоры ~5 с
две фиксированные ступени ~70 с
поиск: 4–6 ступеней по ~30 с и паузы после нарушений ~2,5–3,5 мин
сверка и уборка ~10 с
ячейка ≈ 5–6 мин
Серия Ячеек Оценка
scaling_quick (самопроверка) 2 ~5 мин
A 9 ~50 мин
B 18 ~100 мин
pool 6 ~35 мин
ab (A/A) 6 ~35 мин

Итого около 3,7 ч замеров.

Фоновый запуск. Агент запускает серию отвязанно:

nohup make bench_scaling SERIES=a > <scratchpad>/scaling-bench/scaling-a.log 2>&1 &

Ожидание — Monitor с циклом until ! pgrep -f "bench/run.py" (до 30 мин на вызов, затем снова). Ход видно по tail журнала и progress.json. Ни один вызов инструмента не ждёт серию целиком. make bench_scaling_quick (~5 мин) тоже запускается в фоне.

Продолжение (RESUME=1 → run.py --resume):

  • Условия. Каталог метки есть, meta.status ≠ complete, профиль тот же, commit тот же (git_info()), дерево чистое. Иначе — код 2 до стенда с причиной.
  • Чистота дерева без своей метки. Незакоммиченный каталог самой метки — это её частичные результаты, а не изменение кода. Поэтому при продолжении чистота проверяется так: git status --porcelain -- . ':!evidence/bench/<метка>'. Так же считается git.dirty в meta.resumes. Остальные метки серий коммитятся до запуска следующей серии (tasks.md): иначе её паспорт получит dirty: true.
  • Что снимается. План берётся из meta.plan. Ячейка готова, если у неё есть строка в searches.csv. Прерванная ячейка снимается заново с попыткой +1 (наибольшая попытка ячейки в runs.csv + 1). Строки прежней попытки остаются в runs.csv и samples.csv, сводка и compare.py берут только попытку из searches.csv.
  • Паспорт. В meta.resumes дописывается время продолжения и состояние хоста.
  • Каталог. Results создаёт raw/ с exist_ok.

Блокировка — для всех профилей. fcntl.flock(LOCK_EX | LOCK_NB) на bench/.bench.lock (в .gitignore) в начале main(), держится до выхода процесса. ОС снимает её и при kill -9. Блокировка занята — код 2: «другой прогон стенда идёт».

Остатки стенда. Блокировка взята — значит, другого прогона нет, и остатки leftovers() устарели:

  • серии трека 1 удаляют их сами, печатая каждый удалённый объект: контейнеры проекта и mtusi-bench-k6, mtusi-bench-sampler, volume, сеть;
  • прочие профили по-прежнему отказывают и печатают команды уборки: поведение и правило bench.md для них не меняются.

Сигналы — как сейчас. SIGINT и SIGTERM → KeyboardInterrupt, затем уборка, meta.status incomplete, код 130. SIGHUP nohup игнорирует.

Отвергнуто:

  • Метка на каждую ячейку. 39 каталогов, сводка и сравнение — по меткам.
  • Продолжение без проверки commit. В одной метке смешался бы код.
  • Блокировка файлом с PID без flock. Остаётся после kill -9.

6. Генератор: лимит и брак

  • Лимит. Контейнер k6 в профилях трека 1 стартует с --cpus <generator_cpus> --memory <generator_memory> --memory-swap <то же>: Profile.generator_cpus = "2", generator_memory = "1g". Пустое значение — без лимита, как сейчас в профилях лаб 1–2. Лимиты k6 читаются у контейнера и пишутся в паспорт (limits.<конфигурация>.k6).
  • Запас. Оценка по калибровке — около 0,23 мс CPU k6 на запрос. На вершине серии B (~3 500–4 000/с) это ~0,9 ядра, около 45 % лимита.

В каждой ступени (решение 8): CPU k6 в окне, доля периодов троттлинга, пик памяти, vus_max, наибольшее число занятых VU (vus max), dropped_iterations.

Брак генератора — хотя бы одно:

  • CPU k6 в окне ≥ generator_cpu_limit = 1,8 ядра (90 % лимита; поле уже есть, у матрицы — 4,0);
  • троттлинг k6 ≥ 10 % периодов окна;
  • недосланные > 0 при vus max < vus_max: VU были свободны, а итерации не начались. Что vus у ramping-arrival-rate значит именно занятые VU, проверяет задача 3.2. Если нет — признак заменяется на «недосланные > 0 при CPU k6 ≥ 70 % лимита», и замена пишется в design.

Брак — не прошедшая и не нарушившая ступень:

  • поиск ячейки останавливается;
  • в searches.csv: status = generator_bound, R* — наибольший пройденный уровень, r_star_bound = lower;
  • пометка generator, сводка серии называет ячейку.

Такой R* не используется как точка насыщения. Лечение — поднять generator_cpus (смена методики) и переснять серию новой меткой.

Профилактика (самопроверка, задача 3.2):

  • CPU k6 на 1 000 запросов/с, пересчитанный на ожидаемую вершину серии B (6 × R*(1 × 1) из быстрой серии), — не больше 50 % лимита;
  • пик памяти k6 на VU × vus_max вершины — не больше 70 % лимита памяти.

Иначе лимит поднимается до первой серии, в пределах бюджета решения 1: память до 1,5 ГиБ. Решение пишется в design (раздел apply) и в bench.md.

Пропуски итераций, когда все VU ждут ответа, — не брак, а перегрузка стенда: они входят в ошибки SLO (решение 3).

7. Сэмплер и метрики

Сэмплер — контейнер mtusi-bench-sampler на образе PostgreSQL стенда: тот же пин из docker-compose.yml, образ берётся у mtusi-bench-postgres. Нового образа нет. Параметры запуска:

--cgroupns host --network mtusi-bench --cpus 0.25 --memory 128m --memory-swap 128m
--label com.docker.compose.project=mtusi-bench
--env POSTGRES_PASSWORD -e POSTGRES_USER=… -e POSTGRES_DB=…
-v bench/sampler.sh:/sampler.sh:ro -v <.work>:/work
--entrypoint bash <образ> /sampler.sh <интервал> <роль>=<полный id> …

Скрипт bench/sampler.sh (bash, работает внутри контейнера, не на хосте) пишет строки с меткой времени ВМ date +%s%N:

Строка Источник Что
cg <ns> <роль> <id12> … /sys/fs/cgroup/docker/<id>/ cpu.stat целиком, memory.current, total из cpu.pressure; нет каталога — строка missing
vm <ns> … /proc/stat (первая строка), /proc/pressure/cpu (some total) загрузка CPU ВМ и PSI
lb <ns> … GET /stats;csv на haproxy:8404 через bash /dev/tcp заголовок и строки api

Всё — в /work/samples.log. Параллельно в фоне работает psql "host=postgres …" -XAtq -F '|' с запросом и \watch 1 (пароль — PGPASSWORD из POSTGRES_PASSWORD). Строки — в /work/pg-samples.log:

Строка Источник Что
act pg_stat_activity backend_type = 'client backend', без своего pid. Группы: адрес клиента, state, coalesce(wait_event_type, 'CPU'), wait_event, число
db pg_stat_database своей базы xact_commit, xact_rollback, sessions, sessions_fatal, numbackends
wal pg_stat_wal wal_records, wal_fpi, wal_bytes
io pg_stat_io, object = 'wal' writes, fsyncs

Время строк PostgreSQL — clock_timestamp() в мс: те же часы ВМ.

Свойства сэмплера:

  • Соединение с PostgreSQL — одно, открыто до нагрузки и держится всю ячейку. Поэтому на границе max_connections сэмплер не теряет отсчёты, но занимает один слот. Граница — max_connections − 1.
  • Его CPU — в его собственной cgroup с лимитом 0,25 CPU (бюджет решения 1), а не в cgroup контейнеров стенда.
  • Время жизни. Запуск — после wait_ready, остановка — docker rm -f в конце ячейки и в Stand.stop(). leftovers() знает его по имени.
  • Проверка на старте (Stand.start_sampler): за 5 с должны появиться строки cg всех контейнеров, vm, lb и act/db. Строка missing или пусто — BenchError с причиной.

Отвергнуто:

  • docker exec в каждый контейнер раз в секунду. 8–12 запусков runc в секунду — заметный CPU ВМ при узком бюджете. Процесс cat ещё и попадает в cgroup реплики.
  • docker stats — нет троттлинга.
  • Опрос PostgreSQL новым psql каждую секунду: на границе max_connections он получил бы отказ ровно тогда, когда отсчёты нужнее всего.

k6 — итог ступени (решение 3):

  • отправлено, успешно и неуспешно в окне — всего и по сценариям;
  • p50/p95/p99/max успешных — всего и по сценариям;
  • короткие страницы;
  • dropped_iterations, vus (max), vus_max;
  • распределение по X-Instance-Id. Счётчик instance_ok с тегом instance (заголовок, без него -) на успешные ответы окна; подметрики заводятся по списку INSTANCES (короткие ID реплик). Сумма по ID ≠ успешным окна — BenchError: это неизвестная или пересозданная реплика.

Журнал PostgreSQL: docker logs -t --since <начало окна> --until <конец окна> mtusi-bench-postgres. Считаются строки sorry, too many clients already.

Окно в отсчётах. Из отсчётов сэмплера берутся первый и последний внутри окна замера. Счётчики — разность, делённая на их Δt (~18–20 с). Среднее и максимум — по всем отсчётам внутри окна. Посекундные значения — между соседними отсчётами.

Остальное в строке ступени:

  • RSS реплик (rss_start_mib, rss_end_mib) — прежний Stand.snapshot() до и после запуска k6. rss_max_mib — наибольший из двух. Пик памяти cgroup — отдельный столбец.
  • Сообщения в хранилище (store_messages_*) — SELECT count(*) FROM messages до и после ступени.
  • Сторож. Посекундный Watcher с docker exec в реплики в сериях заменён облегчённым: Watcher(..., rss=False) делает один docker inspect состояний реплик, PostgreSQL, Valkey и LB в секунду. Умер контейнер — k6 останавливается, ступень пишется с пометкой app_down / stand_down, серия останавливается (BenchError) — как в матрице. Продолжение — RESUME=1 после разбора.

8. Таблицы и файлы метки

Каталог evidence/bench/<метка>/:

Файл Что
meta.json паспорт, plan, budget, cells (по ячейке: попытка, лимиты, хост, итог), resumes, stand (без max_connections), limits по конфигурациям
runs.csv строка на ступень: RUN_FIELDS + новые столбцы в конце
searches.csv строка на ячейку
samples.csv посекундные значения в окнах замера
prefill.csv порции наполнения; в конце новые столбцы cell, attempt
summary.md сводка серии (scaling.render_summary)
p95-by-rate.svg, cpu-by-component.svg графики серии (решение 13)
raw/<ячейка>-a<попытка>-s<NN>.json итог k6 ступени
progress.json текущие ячейка и ступень, оценка времени

RUN_FIELDS дополняется для всех профилей; у строк матрицы новые столбцы пустые. Прежние столбцы у ступени:

  • scenario = mixed, size = 10 000, repeat — повтор ячейки;
  • concurrency — наибольшее число занятых VU;
  • duration_s — окно замера;
  • requests_ok / requests_failed — окно; неуспешные — с короткими страницами;
  • rps = успешные / окно, error_ratio — прежний смысл, без недосланных;
  • p50…max — успешные окна;
  • CPU — за окно по сэмплеру, generator_cpu_cores — тоже;
  • check_failed — проверки k6 окна;
  • flags: errors, slo, abort, generator, oom, app_down, stand_down, host_swap (выгрузка в swap или батарея), floor, search_limit.

Новые столбцы по порядку:

series, cell, attempt, config, replicas, replica_cpus, replica_memory,
db_max_connections, step, step_kind, target_rps, sent, missing,
dropped_iterations, slo_error_ratio, slo_pass, fail_reason,
read_p95_ms, write_p95_ms, me_p95_ms, read_errors, write_errors,
me_errors, short_pages, vus_max, generator_throttled_ratio,
generator_mem_peak_mib, app_cpu_replica_max, app_cpu_second_max,
app_throttled_ratio, app_throttled_ms, app_mem_peak_mib,
app_us_per_request, db_throttled_ratio, db_mem_peak_mib,
db_us_per_request, lb_cpu_cores, lb_throttled_ratio, cache_cpu_cores,
vm_busy_cores, vm_cpu_pressure, db_commits_per_s, db_rollbacks_per_s,
db_wal_mib_per_s, db_wal_fsyncs_per_s, db_sessions_new, db_conn_max,
db_conn_replica_max, db_aas_cpu, db_aas_wal, db_aas_lock,
db_aas_lwlock, db_aas_io, db_aas_other, db_idle_in_tx_mean,
pool_busy_share, db_too_many_clients, lb_qtime_ms, lb_ctime_ms,
lb_rtime_ms, lb_ttime_ms, lb_scur_max, lb_qcur_max, lb_retries,
lb_redispatches, lb_econ, lb_eresp, lb_chkdown, lb_5xx, instances,
instance_share_min, instance_share_max, host_swapouts, signs

Определения:

  • Виды ступеней step_kind: fixed, up, down, bisect.
  • Причины нарушения fail_reason: p95, errors, p95+errors, abort, generator.
  • CPU и троттлинг:
    • CPU — разность usage_usec на Δt;
    • доля троттлинга — Δnr_throttled / Δnr_periods;
    • время троттлинга — Δthrottled_usec;
    • CPU на запрос — CPU × 10⁶ / успешные в секунду.
  • ВМ: vm_busy_cores = Δ(всего − idle − iowait) / USER_HZ (100) / Δt; vm_cpu_pressure = Δsome total (мкс) / Δt — доля времени, когда в ВМ кто-то ждал CPU.
  • Классы ожидания db_aas_* — среднее по отсчётам число активных (state = 'active') соединений, классы не пересекаются:
    • cpu — wait_event_type NULL;
    • wal — wait_event содержит wal, без учёта регистра;
    • lock — Lock;
    • lwlock — LWLock без WAL;
    • io — IO без WAL;
    • other — остальное.
  • Пул: pool_busy_share — доля отсчётов окна, когда хотя бы у одной реплики не было ни одного соединения в state = 'idle'. db_conn_replica_max — наибольшее число соединений реплики. Реплика находится по адресу клиента (Stand.address).
  • LB — из отсчётов lb:
    • разность счётчиков бэкенда api: wretr, wredis, econ, eresp, chkdown (сумма слотов), hrsp_5xx;
    • наибольшие scur и qcur;
    • qtime, ctime, rtime, ttime строки BACKEND в последнем отсчёте окна — среднее HAProxy по последним 1 024 запросам.
  • Распределение: instances — id:число …; instance_share_min/max — доли реплик (при равномерном 1 / k).
  • Хост: host_swapouts — прирост Swapouts vm_stat за ступень.
  • Признаки: signs — сработавшие признаки решения 9 через пробел.

searches.csv:

series, cell, attempt, config, replicas, replica_cpus, replica_memory,
db_max_connections, repeat, round, order, started_at, finished_at,
status, r_star_rps, r_star_bound, first_fail_rps, first_fail_reason,
steps, resolution, fixed_rps_1, p50_fixed_1_ms, p95_fixed_1_ms,
p99_fixed_1_ms, pass_fixed_1, fixed_rps_2, p50_fixed_2_ms,
p95_fixed_2_ms, p99_fixed_2_ms, pass_fixed_2, app_us_per_request_fixed_2,
app_cpu_second_max, app_throttled_ratio_fixed_2, writes_ok, writes_sent,
write_chat_messages, read_chat_messages, host_power,
host_memory_free_percent, host_swapouts, other_containers, flags

status: complete, generator_bound. resolution = F / P.

samples.csv — только окна замера, иначе файл раздуется:

cell, attempt, step, t_s, role, instance, cpu_cores, throttled_ms, pressure_ms, mem_mib
  • role: api (несколько строк, instance — короткий ID), postgres, haproxy, valkey, k6, vm;
  • у строки vm: cpu_cores — занятые ядра ВМ, pressure_ms — PSI;
  • t_s — секунды от начала окна.

Около 4 тыс. строк на ячейку, серия B — ~3 МБ. Это исходные данные трека: в git.

Секретов в файлах нет:

  • в итоге k6 setup_data — только t0;
  • пароли хранилищ — только в окружении run.py и контейнеров;
  • fixture.json с токенами — в .work/, удаляется в конце.

9. Как называть узкое место по данным

Признаки считает scaling.py по строке ступени. Пороги заданы здесь, до прогонов, и лежат в scaling.THRESHOLDS:

Признак (signs) Узкое место Условие на ступени Столбцы
app CPU реплик среднее CPU реплики ≥ 0,9 ядра (в ядрах, а не в доле лимита: один процесс больше одного ядра не берёт, H1) или её троттлинг ≥ 10 % периодов app_cpu_cores / replicas, app_cpu_replica_max, app_throttled_ratio
db_cpu CPU PostgreSQL CPU ≥ 1,8 ядра (90 % лимита) или троттлинг ≥ 10 % db_cpu_cores, db_throttled_ratio, db_aas_cpu
db_wal WAL и commit db_aas_wal ≥ 30 % от всех активных db_aas_wal, db_commits_per_s, db_wal_fsyncs_per_s
db_lock блокировки (db_aas_lock + db_aas_lwlock) ≥ 30 % активных db_aas_lock, db_aas_lwlock
pool пул соединений pool_busy_share ≥ 50 % при среднем CPU реплики < 0,9; либо db_too_many_clients > 0 pool_busy_share, db_conn_replica_max, db_too_many_clients, db_idle_in_tx_mean
lb балансировщик CPU LB ≥ 0,9 ядра, троттлинг LB ≥ 10 %, lb_econ > 0 или lb_eresp > 0 lb_cpu_cores, lb_throttled_ratio, lb_econ, lb_eresp, lb_chkdown
host хост на ступени: vm_busy_cores ≥ 0,9 × CPU ВМ или vm_cpu_pressure ≥ 20 % vm_busy_cores, vm_cpu_pressure
host_cost хост: медленные ядра на конфигурации, в сводке серии: CPU реплики на запрос на втором фиксированном уровне (500/с) ≥ 1,2 × того же у 1 × 1 той же серии app_us_per_request, app_us_per_request_fixed_2
generator не стенд: брак решение 6 generator_*

Два признака хоста. host видит нехватку vCPU внутри ВМ: задачи ждут CPU. host_cost видит то, чего гость не замечает: vCPU на энергоэффективном ядре работает, но медленнее, и та же работа стоит больше микросекунд CPU. Второй признак требует опорной 1 × 1, поэтому считается в сводке серии и в plots.py, а не в строке ступени.

Как называется узкое место конфигурации. Смотрятся ступень R* и первая нарушившая — медиана по повторам.

  • Узкое место «реплики» значит линейный участок: добавить реплику помогает. Оно называется, только если не сработал ни один признак общего ресурса (db_*, pool, lb, host, host_cost).
  • Точка насыщения k_sat серии B — наименьшее k ≤ 5, при котором медиана R*(k + 1) < 1,1 × медианы R*(k): реплика добавила меньше 10 % (линейный рост дал бы ≥ +20 %). Нет такого k — насыщения в пределах 6 реплик нет.
  • Причина насыщения — признак общего ресурса, который сработал на k_sat + 1 и не срабатывал на k_sat − 1. Отчёт пишет его словами и числами: «рост реплик перестаёт помогать, потому что …».

Почему:

  • Признаки, а не один вердикт. Сводка показывает, что сработало; итоговый вывод делает отчёт, и его можно проверить по столбцам.
  • Порог 90 % для CPU. Квота CFS на 100 мс в среднем окна не доходит до 100 % из-за неравномерности запросов.
  • Порог 30 % для ожиданий. Меньше — фон работающей базы.
  • Признак host_cost по CPU на запрос. Энергоэффективное ядро делает ту же работу дольше. Рост мкс на запрос при той же нагрузке на реплику — прямое измерение этого эффекта.

10. Гипотезы — до прогонов

Записаны в этом design и входят в commit предложения. Перед первой серией apply переносит их в REPORT.md (задача 2.4). Числа калибровки — Context.

H1. Фиксированный бюджет (серия A, опорная точка из B).

  • Утверждение. При фиксированном бюджете приложения 4 CPU / 2 ГиБ одна реплика 1 × 4 использует около одного ядра:

    • это один процесс uvicorn с одним потоком event loop;
    • GIL не даёт распараллелить Python-код и в потоках executor;
    • сверх одного ядра — только время ядра ОС на сеть и редкие потоки executor (getaddrinfo при новом соединении пула).

    Поэтому R*(1 × 4) ≈ R*(1 × 1). Опорная точка R*(1 × 1) берётся из серии B (k = 1): в серии A конфигурации 1 × 1 нет. 2 × 2 и 4 × 1 растут почти пропорционально числу процессов, пока не упрёмся в PostgreSQL, LB или хост.

  • Проверка механизма, а не только R:*

    • CPU контейнера 1 × 4 по секундам на ступенях R* и выше — около 100–120 % (samples.csv, app_cpu_second_max);
    • троттлинг CFS у 1 × 4 — около 0: квоту 400 мс на период 100 мс один поток не выберет;
    • у 1 × 1 троттлинг измеряется (H1б).
  • Предсказание:

    • 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.
  • Подтвердит — всё вместе:

    • отношение 1 × 4 / 1 × 1 в [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 мс выбрать больше 100 мс. Троттлинг требует второго потока, работающего одновременно (executor, время ядра на сеть, учтённое в cgroup), либо работы у самой квоты. Вход по Basic (Argon2id в потоках) в замер не входит. Поэтому на фиксированных уровнях ожидаем троттлинг меньше 1 % периодов, а на ступени R* — заметный. Вероятный исход — H1б опровергнется на 250 и 500, но не на R*.
  • Подтвердит — на уровне 500/с троттлинг 1 × 1 ≥ 1 % периодов, и p99 1 × 1 > p99 1 × 4, разбросы не пересекаются.
  • Опровергнет — троттлинг < 1 % или разбросы p99 пересекаются. Тот же разбор — на ступени R*.

H2. Рост ресурсов (серия B).

  • Утверждение (PLAN.md). Реплик k = 1…6 по 1 CPU, PostgreSQL фиксирован (2 CPU / 1 ГиБ). R*(k) растёт почти линейно, пока каждая реплика упирается в свой CPU. Рост останавливается (k_sat, решение 9), когда PostgreSQL выходит на свой лимит CPU или на запись WAL и commit. Дальше реплики только увеличивают число соединений и p99.

  • Арифметика до прогона:

    • по калибровке PostgreSQL тратит 0,3–0,45 мс CPU на запрос — 2 ядра кончатся около 4 500–6 500/с, то есть при k ≈ 7–9, если цена запроса не растёт с числом соединений;
    • производительных ядер 6, а около k = 4 занятых vCPU уже ~6.

    Поэтому сильна конкурирующая гипотеза H2-хост: рост остановит хост раньше PostgreSQL. Признак — host_cost: CPU реплики на запрос растёт при той же нагрузке на реплику. Если vCPU не хватит и внутри ВМ — ещё и host.

  • Предсказание:

    • эффективность 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 ядра (70 %) и нет db_wal / db_lock. Тогда причину называет другой признак: host_cost, host, lb или pool, и отчёт так и пишет;
    • k_sat нет, и эффективность при k = 6 ≥ 0,8. Насыщения в пределах бюджета ВМ нет, отчёт приводит запас PostgreSQL при k = 6.

H3. Граница пула (серия pool; в серии B — нарастание).

  • Утверждение (PLAN.md). Когда k × (pool_size + max_overflow) превысит max_connections, под нагрузкой появятся отказы подключения. До этой границы растёт ожидание свободного соединения в пуле.
  • Уточнения до прогона:
    • пул 10 + 5 = 15 на реплику;
    • пользователь приложения — суперпользователь, резерв superuser_reserved_connections его не останавливает;
    • сэмплер держит 1 соединение;
    • на дефолтах граница — k = 7, вне серии B (решение 1). Опыт — 4 реплики при max_connections 100 (61 ≤ 100) и 50 (61 > 50).
  • Предсказание:
    • 100: отказов «too many clients» нет, ответов 5xx ниже R* нет. На ступени R* и выше pool_busy_share > 0, db_conn_replica_max доходит до 15. То же нарастание с k в серии B — «ожидание свободного соединения».
    • 50: когда пулы вместе вырастают за 49 соединений (около насыщения, пока растут задержки), в журнале PostgreSQL появляются «too many clients», клиенту — 5xx. R*(50) < R*(100), разбросы не пересекаются.
    • Код ответа на отказ. По коду — 500 internal, а не 503: SQLSTATE 53300 нет в UNAVAILABLE_SQLSTATES (src/infra/db/errors.py). План ждал 503, спек data-storage требует 503. Подтвердится — дефект в KNOWN_ISSUES.md: путь, требование спека и правка (добавить 53300 или класс 53 в UNAVAILABLE_SQLSTATES, проверка в make failure_checks). Здесь не чинится.
    • Готовность. Проверка /health/ready ждёт соединение пула не дольше 2 с. При исчерпанном пуле она может проваливаться, и LB исключит реплику (lb_chkdown > 0).
  • Подтвердит:
    • при 50 есть отказы (db_too_many_clients > 0) и ошибки ≥ 1 % на уровне, который при 100 проходит;
    • R*(50) < R*(100), разбросы не пересекаются;
    • при 100 отказов нет.
  • Опровергнет: при 50 отказов нет ни на одном уровне до нарушения SLO. Пулы не растут за 49 соединений: реплики упираются в CPU раньше, чем копятся соединения, и граница для этого профиля недостижима при 4 репликах.

Итог каждой гипотезы отчёт пишет так, как получилось, с числами (спек, «Гипотеза не подтвердилась»).

11. Подготовка scaling-improvement: сравнение, «до/после», A/A

compare.py, режим серий. Метка — серия, если в meta.profile.series не пусто. Серия и матрица — отказ: «разная методика: серия трека 1 и матрица».

  • Методика серий:

    • profile без name, series и configs;
    • образы генератора, PostgreSQL и Valkey;
    • stand.postgres.settings без max_connections;
    • maxmemory* Valkey, app_env;
    • limits.<конфигурация> для общих конфигураций (с k6 и max_connections).

    Различие — код 1 и параметр.

  • Ячейки сравнения — общие конфигурации. По каждой:

    • R* повторов: медиана, min–max, Δ медианы в процентах, пересечение разбросов;
    • p95 и p99 на фиксированных уровнях — медиана, «до → после»;
    • CPU приложения на запрос на втором фиксированном уровне;
    • CPU PostgreSQL на ступени R*.

    Конфигурации одной метки — в замечаниях как несравнённые. Ячейки с status = generator_bound в сравнение не входят и названы в замечаниях.

  • Шум (AA) — наибольшее по общим конфигурациям |Δ медианы R*| между AA и BEFORE. Вердикт — как у матрицы: эффект, только если разбросы не пересекаются и |Δ| больше шума.

  • Шапка, замечания, «сама с собой — 0» — как сейчас. Путь — evidence/compare/<до>__<после>.md.

ab.py --series <серия> (make bench_ab … SERIES=ab). Шаги 1 и 5 — make bench_scaling SERIES=<серия> SCALING_LABEL=<метка> вместо make bench, остальное прежнее. Проверки меток — тот же evidence/bench/. --dry-run печатает шаги.

Конфигурации A/B — решены до прогонов: 1 × 1 и 6 × 1 (по 1 CPU / 512 МиБ, max_connections 100, 3 повтора, остальная методика — как у B). Профиль scaling_ab входит в код change сразу.

Почему так:

  • 6 × 1 — глубже всего на плато в пределах бюджета. Снятие общего узкого места сильнее всего сдвигает R* там, где реплик больше всего. Пример: плато 2 400/с из-за PostgreSQL с k = 4, реплика держит ~650/с. Правка, удешевившая базу на 20 %, поднимет R*(6) до ~2 900 (+20 %), а R*(4) — только до min(4 × 650, 2 900) = 2 600 (+8 %), ближе к шуму.
  • 1 × 1 — контроль. Там узкое место — CPU самой реплики, и правка базы или пула его не сдвинет. Правка цены запроса в приложении сдвинет обе конфигурации — отчёт так и скажет.
  • Не зависит от k_sat. Профиль не меняется после серии B, A/A можно снять на коде change без отдельного коммита.

Если scaling-improvement понадобится конфигурация k_sat, он добавит её в свой профиль и снимет свою A/A: сравниваются только общие конфигурации, и у AA они должны быть те же.

Метка A/A scaling-aa (профиль scaling_ab) снимается после серии pool (задача 5.5). Она нужна для двух целей:

  • Шум между сессиями для этого change:
    • make bench_compare BEFORE=scaling-b AFTER=scaling-aa — общие конфигурации 1 × 1 и 6 × 1;
    • make bench_compare BEFORE=scaling-b AFTER=scaling-a — 4 × 1 серии A против k = 4 серии B, проверка согласованности серий.
  • AA для scaling-improvement: make bench_ab BEFORE=… AFTER=… REAPPLY=… SERIES=ab, затем make bench_compare … AA=scaling-aa. Что код приложения у scaling-aa и «до» одинаков, проверяется по git (bench.md).

Кандидаты улучшения — уточнение PLAN.md по фактам Context:

Кандидат Когда Чем A/B совместим
размер пула признак pool или db_lock, рост db_sessions_new (переполнение пула) дефолт src/config/settings.py — код, A/B допустим. Стенд пул не закрепляет окружением: иначе правка не дошла бы до «после»
запись одним SQL db_cpu, db_wal или CPU приложения на запись код
PgBouncer признак pool при max_connections новый компонент стенда, смена методики: своя пара меток и своя A/A
uvloop/httptools — уже включены (Context), не кандидат

12. Хост: проверка перед серией и выгрузка в swap

Перед каждой серией (A, B, pool, ab; быстрая самопроверка — без неё) агент по брифу проверяет:

  • pmset -g batt — AC Power;
  • memory_pressure | tail -1 — нет давления, свободной памяти хватает на ВМ до 7,75 GiB;
  • docker ps — посторонних нет, рабочий стенд остановлен (make stop);
  • docker info — 12 CPU и 7,75 GiB.

vm_stat | grep Swapouts снимается до и после серии, разница идёт в evidence. Плохо — Telegram «хост не готов к замеру …» и остановка (бриф).

В run.py:

  • host_state() — ещё поле swapouts из vm_stat (число после Swapouts:); прочие поля прежние.
  • Предупреждения. Порог SWAP_WARN_MIB удаляется вместе с предупреждением «swap used > 1024 MiB». Вместо него в конце прогона: swapouts в конце > в начале → «host swapped out N pages during the run: rerun». Батарея — как раньше. Это действует для всех профилей.
  • Серии. Состояние хоста — ещё и по ячейке (meta.cells[].host, столбцы searches.csv) и по ступени (host_swapouts). Прирост в ячейке или питание от батареи — пометка host_swap.
  • Паспорт (static_passport().host) — ещё performance_cores и efficiency_cores (sysctl -n hw.perflevel0.physicalcpu / hw.perflevel1.physicalcpu; нет ключа — null).
  • Сравнение меток. В строке хоста passport_rows compare.py — прирост выгрузок вместо одного занятого swap.

Правило bench.md («swap занят — перезагрузить») переписывается: занятый swap не помеха, помеха — выгрузка во время прогона и давление на память.

13. Графики

bench/plots.py (только stdlib, SVG как текст):

  • make bench_plots LABELS="scaling-a scaling-b" PLOTS=scaling → evidence/plots/<PLOTS>/. Каталог выводится из меток и пересоздаётся, как evidence/compare/. Пробные quick-* — в .gitignore.
  • Функции render_series(label_dir) и render_combined(labels, out). Первую вызывает run.py в конце серии: графики в каталоге метки.
Файл Что Как
rstar-by-replicas.svg R* от числа реплик B — линия с точками и усами min–max по k; A — отдельные точки на x = 1, 2, 4 с подписями 1 × 4, 2 × 2, 4 × 1; пунктир k × R*(1 × 1); отметка k_sat
p95-by-rate-<серия>.svg p95 от интенсивности линия на конфигурацию: медиана повторов по уровням лестницы и фиксированным, точки деления отдельными маркерами; горизонталь SLO 200 мс; ось y логарифмическая
cpu-by-component.svg CPU по компонентам столбики с накоплением на конфигурацию на ступени R* (медиана): реплики, PostgreSQL, HAProxy, Valkey, k6, остальное в ВМ (vm_busy_cores − сумма стенда); горизонтали 12 vCPU и 6 производительных ядер
summary.md сводная таблица R* по конфигурациям серий, эффективность R*(k) / (k × R*(1 × 1)), R*(1 × 4) / R*(1 × 1), k_sat по правилу решения 9 и признаки на k_sat ± 1

Числа отчёта берутся из summary.md графиков и сводок меток, руками не считаются (bench.md).

Оформление (apply загружает скилл dataviz до кода):

  • подписи осей с единицами, легенда, читаемые метки;
  • палитра, различимая и в оттенках серого;
  • viewBox, белый фон, без внешних шрифтов и скриптов.

Проверка — PNG через qlmanage -t -s 1000 и просмотр.

14. Устройство кода

Файл Что
bench/run.py см. ниже
bench/scaling.py (новый) чистые функции на stdlib, без docker: см. ниже
bench/plots.py (новый) решение 13; читает meta.json, searches.csv, runs.csv
bench/sampler.sh (новый) решение 7; запускается только внутри контейнера сэмплера
bench/k6/mixed.js (новый) решения 2–3; ключ — только messageHeaders(token) из lib.js
bench/k6/prepare.js WRITE_CHATS (по умолчанию 1), writeChatIds
bench/compare.py, bench/ab.py решение 11
bench/bench.compose.yml -c max_connections=${BENCH_DB_MAX_CONNECTIONS:?run make bench} в команде postgres
Makefile см. ниже
.gitignore bench/.bench.lock, evidence/plots/quick-*/

bench/run.py:

  • новые поля Profile (ниже) и свойство is_series;
  • хелпер scaling_profile(name, series, configs, **поля) — общие поля всех серий в одном месте, чтобы методика серий не расходилась;
  • профили scaling_a, scaling_b, scaling_pool, scaling_ab, scaling_quick;
  • compose_env — BENCH_DB_MAX_CONNECTIONS;
  • leftovers() и Stand.stop() — ещё mtusi-bench-sampler;
  • Stand.start() — лимиты k6;
  • новые Stand.start_sampler() и Stand.stop_sampler();
  • Stand.limits() — k6 и max_connections (сверка с конфигурацией);
  • хост и бюджет: host_state, host_warnings, static_passport, vm_warnings;
  • Bench.run_series(), run_cell(), run_step();
  • Results.add_step(), add_search(), add_samples() и ветка write_summary;
  • main(): --resume, блокировка, уборка остатков для серий;
  • parse_args: профили серий в choices.

bench/scaling.py:

  • SCALING_FIELDS, SEARCH_FIELDS, SAMPLE_FIELDS, THRESHOLDS;
  • лестница и автомат поиска: подъём, спуск, деление;
  • разбор итога k6 ступени;
  • разбор строк сэмплера (cg, vm, lb, act, db, wal, io);
  • окно и агрегаты, вердикт SLO и брака, признаки;
  • строки runs.csv / searches.csv / samples.csv;
  • render_summary().

Новые поля Profile (значения — у серий; у прочих профилей — пусто или 0, их поведение не меняется):

series: str = ""                        # a, b, pool, ab, quick
configs: tuple[tuple[int, str, str, int], ...] = ()   # (реплик, CPU, память, max_connections)
write_chats: int = 1
mix: tuple[tuple[str, float], ...] = () # (("read", 0.7), ("write", 0.2), ("me", 0.1))
fixed_rps: tuple[int, ...] = ()         # (250, 500)
ladder_base: int = 100
step_factor: float = 1.25
start_rps_per_replica: int = 300
bisect_steps: int = 2
max_steps: int = 12
first_warmup_s / step_warmup_s / step_measure_s / cooldown_s   # 15 / 5 / 20 / 10
slo_p95_ms: float = 200; slo_error_ratio: float = 0.01
abort_error_ratio: float = 0.5; abort_p95_ms: float = 2000
request_timeout_s: int = 15; prevus_per_rps: float = 0.05; vus_per_rps: float = 0.2
generator_cpus: str = ""; generator_memory: str = ""          # "2", "1g" у серий
sampler_cpus: str = "0.25"; sampler_memory: str = "128m"; sample_interval_s: float = 1.0
order_seed: int = 20261011

У серий: sizes = (10_000,), repeats = 3, members = 10, write_chats = 10, generator_cpu_limit = 1.8. Остальные лимиты — как в решении 1. cpus / memory / replicas уровня профиля нейтральны: их заменяет конфигурация ячейки (dataclasses.replace).

scaling_quick (решение 5, задачи 3.1–3.4):

  • конфигурации (1, "1", "512m", 100) и (2, "1", "512m", 50): две конфигурации, перемешивание и max_connections не по умолчанию;
  • 1 повтор, читаемый чат 2 000;
  • fixed_rps = (250,); прогрев первой ступени 8 с, остальных 3 с; замер 8 с;
  • bisect_steps = 1, max_steps = 6.

Makefile:

  • bench_scaling (SERIES обязателен, SCALING_LABEL ?= scaling-$(SERIES), RESUME=1 → --resume);
  • bench_scaling_quick (метка quick-scaling-<время>);
  • bench_plots (LABELS, PLOTS ?= scaling);
  • SERIES у bench_ab.

Все цели — под $(KEEP_AWAKE), как прочие bench*.

15. Evidence и отчёт

Файл Что
evidence/bench/scaling-a/, scaling-b/, scaling-pool/, scaling-aa/ метки серий с commit кода change; хост проверен
evidence/plots/scaling/ графики A + B и сводная таблица
evidence/compare/scaling-b__scaling-aa.md, scaling-b__scaling-a.md шум A/A между сессиями; согласованность 4 × 1 и k = 4
evidence/tests/scaling-bench-checks.md самопроверки: быстрая серия, продолжение после SIGTERM, блокировка, отказ сравнения серии с матрицей, ab.py --dry-run, графики; регрессия быстрых профилей; проверки хоста перед каждой серией и Swapouts до и после

REPORT.md:

  • Таблица доказательств. Строка «Выбранный трек 5» вместо TODO и строки «5»: серия A, серия B и точка насыщения, граница пула, графики, A/A.
  • «Эксперименты и отказы». Раздел «Цена масштабирования (трек 1)»:
    • гипотезы (из решения 10);
    • методика: стенд, бюджет (таблица решения 1), ядра хоста, профиль, ступени, SLO, правило R*, повторы и порядок;
    • результаты серий (таблицы из сводок) и графики;
    • узкое место по признакам, точка насыщения и почему рост реплик перестаёт помогать;
    • итог H1, H1б, H2, H3;
    • уровень шума;
    • ограничения.
  • Почему не workers — одна фраза: X-Instance-Id и hook отказа на уровне процесса, проверки LB видят процесс, пул на процесс.
  • «Ограничения»: один хост и ВМ, разнородные ядра, серия B до 6, граница пула на дефолтах показана управляемым опытом, генератор на том же хосте, окно 20 с, автоочистка и контрольные точки PostgreSQL внутри ячейки.
  • KNOWN_ISSUES.md — пункт про 500 на «too many clients», если H3 его подтвердит.

Найдено в apply

Правки методики до первой серии; самопроверки — пробный k6 в образе стенда и быстрая серия (evidence/tests/scaling-bench-checks.md).

  • vus k6 — выборка, а не максимум занятых VU. Метрика vus у ramping-arrival-rate снимается раз в секунду: в пробе со всеми занятыми VU (dropped_iterations 21) её максимум — 24 при vus_max 26. Признак брака «недосланные при свободных VU» по ней ложен. Заменён запасным вариантом решения 6: недосланные > 0 при CPU k6 ≥ 70 % лимита. vus max остаётся в столбце concurrency.
  • Код 99 k6 даёт любой нарушенный порог, не только с abortOnFail. Прочие пороги mixed.js всегда выполняются, поэтому 99 — досрочный выход; итог пишется (проверено). Тег окна по exec.scenario.startTime работает: в окне 3 с при 50/с — ровно 150 запросов.
  • Порог активных соединений для db_wal / db_lock. Доля ожиданий от активных бессмысленна на почти пустой базе: в самопроверке при 0,25 активного соединения одно ожидание WAL в отсчёте дало db_wal у 1 × 1. Признаки ожиданий — только при среднем ≥ 1 активного соединения (THRESHOLDS["db_active_min"]).
  • host_cost — по предельному CPU на запрос. CPU реплик на запрос на 500/с у k реплик включает постоянные расходы каждой реплики (проверки LB раз в секунду, простой event loop) и растёт с k без всякого хоста: в самопроверке 2 × 1 на 250/с — 1 941 мкс против 1 599 у 1 × 1 (+21 %, ложный признак). Признак считается по наклону CPU реплик от успешных запросов/с по ступеням ячейки, прошедшим SLO (marginal_us): постоянная часть уходит в свободный член. CPU на запрос на 500/с остаётся в сводке.
  • target_rps и уровень. Интенсивность сценария — Math.round в k6 (половина вверх), а round Python — к чётному: 745 × 0,1 = 74,5 дал бы расхождение плана на 1. В scaling.targets — половина вверх, как в k6. target_rps — сумма сценариев (может отличаться от уровня на ±1), уровень лестницы — новый столбец level в конце.
  • Коды ошибок и журналы 5xx (указание основной сессии 2026-10-11, H3): столбец error_codes (http_reqs{window:hold,status:…} по списку кодов) и raw/<ступень>-errors.log — строки PostgreSQL («too many clients», FATAL), API ("status": 5…, "level": "error") и LB окна, без строк со словом password, — когда в окне есть 5xx или отказы.
  • Сверка записей после досрочного выхода. Прерванные запросы k6 не считает, а сервер мог их выполнить: верхняя граница сверки — отправки плюс vus_max прерванных ступеней.
  • Ожидание серии. Цикл until ! pgrep -f "bench/run.py" находит сам себя (строка команды содержит шаблон) и не кончается; шаблон — "[b]ench/run.py".

Risks / Trade-offs

  • [Узким местом окажется хост, а не БД, LB или пул] → признаки host_cost и host показывают это числом. Насыщение пула показано отдельно серией pool, запас PostgreSQL — по db_cpu_cores и db_aas_*. Отчёт называет причину как есть: рубрика просит найти точку насыщения и объяснить её, а не подогнать её под БД.
  • [Энергоэффективные ядра делают «1 CPU» неравным] → неустранимо на этом хосте. Измеряется (vm_busy_cores, app_us_per_request), ядра хоста — в паспорте, ограничение — в отчёте.
  • [Окно 20 с не ловит превышение потолка на ~1 %] → разрешение поиска ~6 % грубее; ограничение названо (решение 3).
  • [Сэмплер сам нагружает ВМ] → один процесс с лимитом 0,25 CPU, его CPU в его cgroup. Одно соединение PostgreSQL учтено в границе пула.
  • [Подметрики k6 по тегам растут с числом реплик и уровней] → ~25 подметрик, Trend k6 хранит значения окна. Память k6 — в каждой строке, пик — порог профилактики решения 6.
  • [exec.scenario.startTime или пороги с abortOnFail ведут себя в k6 2.3.0 иначе] → быстрая самопроверка сверяет отправленные в окне с запланированными и досрочный выход с кодом 99. Запасной вариант: окно по t0 из setup() и ручной останов по dropped_iterations — записывается в design.
  • [Тег окна по часам VU на границе] → до ±1 запроса на сценарий на каждой границе. Это ≤ 0,1 % окна при 250/с, недосланные считаются с этим допуском.
  • [Автоочистка и контрольная точка PostgreSQL посреди ячейки] → одинаковы для всех конфигураций по времени ячейки, видны в db_us_per_request и db_wal_*. Принудительный CHECKPOINT между ступенями не делается: это работа без нагрузки, и её цена ляжет на следующую ступень.
  • [Серия B идёт ~100 мин, хост может уснуть или его нагрузят] → caffeinate -isu, slept_seconds в паспорте, продолжение ячейками, проверка хоста перед серией. Ячейки с выгрузкой в swap помечены host_swap.
  • [Длинный поиск у сильных конфигураций] → начало L0 от числа реплик, предел 12 ступеней, досрочное прерывание перегрузки.
  • [Рост runs.csv на ~70 столбцов] → прежние столбцы на месте, матрица не меняется. Широкая таблица проще, чем пять файлов с ключами.
  • [Дефект 500 на «too many clients» найдётся во время серии] → не чинится здесь (AGENTS.md); пункт KNOWN_ISSUES.md с путём и правкой, вопрос — основной сессии.

Migration Plan

Стенд bench/ — инструмент, рабочий стенд и приложение не меняются. Порядок — tasks.md:

  1. код;
  2. коммит кода и гипотез в REPORT.md;
  3. самопроверки и регрессия быстрых профилей;
  4. серии: A, B, pool, A/A;
  5. evidence, отчёт, AGENTS.md.

Откат — git revert коммита кода. Метки остаются в evidence/ как результат своего commit.

Open Questions

  • Хватит ли 1 ГиБ памяти генератору на вершине серии B. Решает самопроверка до первой серии (решение 6). Подход и задачи от ответа не меняются.
  • Сработает ли тег окна по exec.scenario.startTime в k6 2.3.0. Решает самопроверка; запасной вариант — Risks. Подход тот же.