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>
91 KiB
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(проект composemtusi-bench),Bench. Профили:- матрица лаб 1–2:
full,quick,restore*— закрытая модель, фиксированное число клиентов k6; failover*,rollout*— постоянная интенсивность (constant-arrival-rate), две реплики с лимитами рабочего стенда.
- матрица лаб 1–2:
-
Stand.start()поднимает свежий стенд:- PostgreSQL и Valkey;
- миграции
run --rm migrate; - реплики
apiиhaproxy(container_name: mtusi-bench-haproxy); - контейнер 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). SQLSTATE53300(«too many clients») вUNAVAILABLE_SQLSTATESнет — по коду такой отказ даст 500. Спекdata-storage(«Недоступность PostgreSQL», «Ограниченный пул») требует 503. Это предсказание гипотезы H3 (решение 10), а не правка этого change. - uvloop и httptools уже работают:
fastapi[all]ставитuvicorn[standard], вuv.lock—uvloop0.22.1 иhttptools0.8.0, аuvicorn.runбезloop=выбирает их сам. Кандидат №3PLAN.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_connections100 (60 + 1 ≤ 100) и 50 (60 + 1 > 50); - «+1» — постоянное соединение сэмплера;
- отличается одна настройка PostgreSQL, CPU тот же, порядок ячеек перемешан внутри одной метки.
- 4 реплики при
Отвергнуто:
- 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.
Порядок ступеней ячейки:
-
Фиксированные уровни
Profile.fixed_rps= (250, 500) — те же во всех сериях. Около 40 % и 80 % потолка одной реплики (Context): все конфигурации, кроме, возможно, k = 1 на 500, держат их. Это сравнение задержек при равной нагрузке и прогрев ячейки. -
Поиск по лестнице
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 ступеней поиска.
- Начало L0 — наименьшая ступенька ≥ max(300 × реплик,
наибольший пройденный фиксированный уровень) и строго больше
него.
Чем это лучше одной долгой лестницы 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 при
vusmax <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⁶ / успешные в секунду.
- CPU — разность
- ВМ:
vm_busy_cores= Δ(всего −idle−iowait) /USER_HZ(100) / Δt;vm_cpu_pressure= Δsome total(мкс) / Δt — доля времени, когда в ВМ кто-то ждал CPU. - Классы ожидания
db_aas_*— среднее по отсчётам число активных (state = 'active') соединений, классы не пересекаются:cpu—wait_event_typeNULL;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— приростSwapoutsvm_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б).
- CPU контейнера 1 × 4 по секундам на ступенях R* и выше — около
100–120 % (
-
Предсказание:
- 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) без признака общего ресурса.
- R*(1 × 4) ≥ 1,25 × R*(1 × 1) или CPU 1 × 4 ≥ 1,5 ядра на перегрузке:
процесс параллелится, и
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.
- на k_sat + 1 CPU PostgreSQL < 1,4 ядра (70 %) и нет
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_connections100 (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: SQLSTATE53300нет в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).
- 100: отказов «too many clients» нет, ответов 5xx ниже R* нет. На
ступени R* и выше
- Подтвердит:
- при 50 есть отказы (
db_too_many_clients> 0) и ошибки ≥ 1 % на уровне, который при 100 проходит; - R*(50) < R*(100), разбросы не пересекаются;
- при 100 отказов нет.
- при 50 есть отказы (
- Опровергнет: при 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_rowscompare.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).
vusk6 — выборка, а не максимум занятых VU. Метрикаvusуramping-arrival-rateснимается раз в секунду: в пробе со всеми занятыми VU (dropped_iterations21) её максимум — 24 приvus_max26. Признак брака «недосланные при свободных VU» по ней ложен. Заменён запасным вариантом решения 6: недосланные > 0 при CPU k6 ≥ 70 % лимита.vusmax остаётся в столбце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 (половина вверх), аroundPython — к чётному: 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:
- код;
- коммит кода и гипотез в
REPORT.md; - самопроверки и регрессия быстрых профилей;
- серии: A, B, pool, A/A;
- evidence, отчёт,
AGENTS.md.
Откат — git revert коммита кода. Метки остаются в evidence/ как
результат своего commit.
Open Questions
- Хватит ли 1 ГиБ памяти генератору на вершине серии B. Решает самопроверка до первой серии (решение 6). Подход и задачи от ответа не меняются.
- Сработает ли тег окна по
exec.scenario.startTimeв k6 2.3.0. Решает самопроверка; запасной вариант — Risks. Подход тот же.