diff --git a/CHANGELOG.md b/CHANGELOG.md
index 01533cc4..523985d3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,6 +25,10 @@
- Проверки: async-aware custom tests, негативный случай 42 MP (413), evidence
для smoke, отказов, persistence и failover.
- `scripts/restart.sh` перезапускает RabbitMQ и worker с сохранением volumes.
+- `scripts/track1_experiment.py` и `make track1` — трек 1: матрица
+ `serial/balanced/eager` × `small_many`/`huge_few`, throughput, queue lag,
+ p95 time-to-ready, RSS и отдельный backpressure/recovery прогон;
+ self-contained HTML-дашборд с inline SVG.
- Документация: README с запуском и архитектурой, отчёт с таблицей критериев,
CHANGELOG.
@@ -55,4 +59,4 @@
- `evidence/lab5-smoke.txt`, `evidence/lab5-negative-cases.txt`,
`evidence/lab5-grade4.{json,md}`, `evidence/lab5-persistence.{txt}`,
`evidence/lab5-persistence-containers.txt`, `evidence/lab5-failover.txt`,
- `evidence/reconcile.txt`.
+ `evidence/reconcile.txt`, `evidence/track1.{json,html,md}`.
diff --git a/Makefile b/Makefile
index 5d86d171..f1ccbd1c 100644
--- a/Makefile
+++ b/Makefile
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
-.PHONY: help check validate test load test-persistence test-failover
+.PHONY: help check validate test load test-persistence test-failover track1
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -28,3 +28,6 @@ test-persistence:
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
+
+track1:
+ $(PYTHON) scripts/track1_experiment.py --base-url "$(BASE_URL)"
diff --git a/README.md b/README.md
index d02bda57..bc3f00c6 100644
--- a/README.md
+++ b/README.md
@@ -136,8 +136,9 @@ byte-for-byte и сохраняет исходный SHA-256. Метаданны
make check
make test BASE_URL=http://localhost:8080 # публичный smoke
python3 tests/custom/attachments.py --base-url ... # 413/415/404/400, без 5xx
-python3 tests/custom/attachment_flow.py --base-url ... # сквозной upload/download
python3 tests/custom/concurrent_uploads.py --base-url ... # конкурентные upload
+# attachment_flow.py — двухшаговый helper для verify-attachment-failover.sh,
+# а не самостоятельный тест: ему нужны --action upload|download и --state.
python3 scripts/lab5_resilience.py --base-url ... # 6 сценариев уровня 4
python3 scripts/track1_experiment.py # трек 1 уровня 5
@@ -151,8 +152,33 @@ python3 scripts/track1_experiment.py # трек 1 уров
Трек 1 запускает матрицу профилей `serial/balanced/eager` на маленьких и
больших изображениях, измеряет throughput, queue lag, p95 time-to-ready и RSS,
-затем отдельно показывает backpressure и восстановление. Результаты и графики
-описаны в [REPORT.md](REPORT.md).
+затем отдельно показывает backpressure и восстановление. Результаты и графики —
+`evidence/track1.{json,html,md}`, разбор — в [REPORT.md](REPORT.md).
+
+```sh
+# Полный прогон: 30 small + 12 huge на каждый профиль, затем backpressure.
+make track1 BASE_URL=http://localhost:8080
+
+# То же без make.
+python3 scripts/track1_experiment.py --base-url http://localhost:8080
+
+# Быстрая проверка механики и/или свои лимиты worker-а.
+python3 scripts/track1_experiment.py --small-jobs 5 --huge-jobs 3 --skip-backpressure
+TRACK1_WORKER_CPU_LIMIT=2.0 TRACK1_WORKER_MEM_LIMIT=3G \
+ python3 scripts/track1_experiment.py --base-url http://localhost:8080
+```
+
+Эксперимент пересоздаёт worker с `WORKER_CONCURRENCY`/`WORKER_PREFETCH`,
+поднимает memory limit до 2 GiB (чтобы `eager` не падал по OOM на больших
+изображениях), а в `finally` возвращает конфигурацию из `.env`. Он управляет
+только локальным Compose-стендом и не предназначен для production.
+
+Кратко: на 192×128 eager дал 13.86 jobs/s против 6.88 у serial (2×) при RSS
+28→33 MiB. На 2400×1800 все профили дали ~0.45 jobs/s (worker ограничен 1 CPU),
+но RSS вырос 205→1122 MiB, а queue lag p95 упал 23.3→17.5 s: concurrency меняет
+latency/ресурсы, а не throughput CPU-bound задач. При `MAX_PENDING_JOBS=3`
+четвёртый upload получил `503` + `Retry-After: 5`; после старта worker три
+принятых задания стали ready за 7.6 s.
## Ограничения
diff --git a/REPORT.md b/REPORT.md
index 13041c3a..ed8d1404 100644
--- a/REPORT.md
+++ b/REPORT.md
@@ -115,7 +115,7 @@ backoff ±50% jitter до `JOB_MAX_ATTEMPTS`. После исчерпания
| Очистка staging после фиксации | сценарии `worker_stopped`, `crash_after_effect` | `staging_cleared: true`; reconciler удаляет только брошенное | `evidence/lab5-grade4.json`, `evidence/reconcile.txt` |
| Негативные случаи и лимиты | `python3 tests/custom/attachments.py` | 413 по bytes и по 42 MP, 415 corrupt/spoof, 404/400, нет 5xx | `evidence/lab5-negative-cases.txt` |
| Failover API | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | 118 успешных записей, 1 переходная ошибка, восстановление 2.659 s; остановлена именно `api-2` | `evidence/lab5-failover.txt` |
-| Трек 1, уровень 5 | `python3 scripts/track1_experiment.py` | см. раздел «Эксперимент трека 1» ниже | `evidence/track1.json`, `evidence/track1.html` |
+| Трек 1, уровень 5 | `python3 scripts/track1_experiment.py` | 3 профиля × 2 размера; eager/small 13.86 jobs/s против serial 6.88; huge_few ~0.45 jobs/s у всех, RSS 205→1122 MiB; cap=3 дал 503 + Retry-After 5 и восстановление за 7.596 s | `evidence/track1.json`, `evidence/track1.html` |
## Эксперименты и отказы
@@ -141,10 +141,108 @@ HAProxy; отказ БД или брокера в этом сценарии не
## Эксперимент трека 1 (уровень 5)
-Будет заполнено после запуска `scripts/track1_experiment.py`: гипотеза, профили,
-размеры изображений, throughput, queue lag, p95 time-to-ready, RSS,
-backpressure и восстановление. Сырые данные — `evidence/track1.json`, графики —
-`evidence/track1.html`.
+### Гипотеза
+
+Маленькие изображения, которые не требуют масштабирования, дешевле на задание:
+выше throughput и ниже RSS. Большие изображения (2400×1800) требуют декодирования
+и downscale до 1280×960, поэтому очередь растёт, p95 time-to-ready увеличивается,
+а память сильнее зависит от concurrency. Дополнительно проверялся компромисс
+«latency против ресурсов»: больше concurrency/prefetch должно снижать queue lag,
+но повышать RSS.
+
+### Методика
+
+- Профили: `serial` 1/1, `balanced` 4/4, `eager` 8/32
+ (concurrency/prefetch).
+- Сценарии: `small_many` — 30 PNG 192×128 (941 B, варианты не масштабируются);
+ `huge_few` — 12 PNG 2400×1800 (53 135 B, 4.32 MP, optimized уменьшается до
+ 1280×960).
+- Для каждой из 6 ячеек worker пересоздавался с профилем, поэтому RSS не
+ переносился из предыдущего прогона. Изображения загружались параллельно
+ (до 8 HTTP-клиентов). Все задания дожидались терминального состояния.
+- Метрики берутся из PostgreSQL по `attachment_jobs`: queue lag =
+ `processing_started_at - created_at`, time-to-ready =
+ `finished_at - created_at`, processing = `finished_at - processing_started_at`.
+ Throughput = число ready / (последний `finished_at` − первый `created_at`).
+- RSS — `VmRSS` процесса worker из `/proc/1/status`, сэмпл примерно каждые
+ 100 мс; baseline снимался до загрузки.
+- Worker ограничен **1 CPU**. На время эксперимента memory limit поднят до
+ **2 GiB** (в `.env` по умолчанию 1 GiB), иначе `eager/huge_few` упирался бы в
+ OOM, а не в измеряемый компромисс. Это зафиксировано в JSON.
+- Backpressure: API пересоздан с `MAX_PENDING_JOBS=3`, worker остановлен,
+ upload-ы идут последовательно до первого `503`; затем worker запускается и
+ проверяется восстановление принятых заданий и новый probe upload.
+
+Команда:
+
+```sh
+make track1 BASE_URL=http://localhost:8080
+# или
+python3 scripts/track1_experiment.py --base-url http://localhost:8080
+```
+
+Сырые данные: `evidence/track1.json`; графики: `evidence/track1.html`;
+краткая таблица: `evidence/track1.md`.
+
+### Результаты
+
+| Профиль | Сценарий | Jobs/s | Queue lag p95, ms | Ready p95, ms | Processing p95, ms | RSS peak, MiB | Max parallel |
+| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| serial | small_many | 6.875 | 3 194 | 3 284 | 113 | 28.2 | 1 |
+| serial | huge_few | 0.443 | 23 333 | 25 521 | 2 308 | 204.7 | 1 |
+| balanced | small_many | 11.590 | 1 624 | 1 736 | 209 | 30.6 | 4 |
+| balanced | huge_few | 0.454 | 17 716 | 25 785 | 25 374 | 728.7 | 4 |
+| eager | small_many | 13.858 | 898 | 1 158 | 284 | 32.7 | 8 |
+| eager | huge_few | 0.459 | 17 538 | 25 699 | 24 979 | 1 122.1 | 8 |
+
+Backpressure: cap `3`; первые 3 upload-а получили `202`, четвёртый — `503` с
+`Retry-After: 5` и `error_code=unavailable`. После старта worker три принятых
+задания стали `ready` за **7.596 s** (включая запуск контейнера и healthcheck),
+после чего probe upload получил `202` и дошёл до `ready`.
+
+### Выводы
+
+1. **Размер изображения важнее числа заданий.** При `balanced` маленькие файлы
+ дают 11.59 jobs/s, большие — 0.454 jobs/s (в 25.5× меньше); p95 time-to-ready
+ растёт с 1 736 до 25 785 ms (в 14.9×). Processing p50 для huge — 8 460 ms
+ против 211 ms для small: доминирует декодирование/масштабирование, а не
+ ожидание в очереди.
+2. **Eager хорошо работает на маленьких заданиях.** 13.86 jobs/s против 6.88 у
+ serial (2.0×), queue lag p95 падает с 3 194 до 898 ms, RSS растёт всего с
+ 28.2 до 32.7 MiB. Это ожидаемый выигрыш от перекрытия лёгких задач.
+3. **На huge_few concurrency не даёт throughput.** Все три профиля дают
+ ~0.44–0.46 jobs/s: worker упирается в 1 CPU, а декодирование и WebP-кодирование
+ уже насыщают его. Queue lag p95 снижается (23.3 → 17.5 s), но p95
+ time-to-ready остаётся ~25.5 s: последние задания всё равно ждут своей доли
+ CPU. При этом RSS растёт с 205 MiB (serial) до 729 MiB (balanced) и
+ 1 122 MiB (eager). **Больше concurrency здесь — не бесплатное ускорение, а
+ рост памяти при том же throughput.**
+4. **Backpressure ограничивает принятую работу.** При cap=3 API перестал
+ принимать новые файлы до чтения тела и вернул retryable `503`; уже
+ подтверждённые задания не потерялись и завершились после возврата worker.
+ Это и есть требуемое «bounded acceptance + recovery».
+5. **Практический выбор.** Для лёгких изображений разумен `balanced`/`eager`;
+ для тяжёлых при одном CPU лучше `balanced` (или `serial`, если важна память):
+ throughput тот же, а RSS в 1.5–5.5× ниже, чем у eager. `prefetch` больше
+ `concurrency` лишь держит сообщения у worker-а и не увеличивает параллельную
+ обработку.
+
+### Ограничения эксперимента
+
+- Один worker, один RabbitMQ, один PostgreSQL; это сравнение настроек, не HA и
+ не горизонтальное масштабирование.
+- Worker ограничен 1 CPU и 2 GiB; на другом железе абсолютные числа и точка
+ насыщения будут другими. Относительный вывод «CPU-bound huge не ускоряется
+ concurrency» получен именно для этого лимита.
+- PNG-фикстуры синтетические и хорошо сжимаются; доминирует стоимость
+ декодирования/масштабирования, а не сеть. Размеры в байтах и SHA-256 есть в
+ JSON.
+- Один прогон на ячейку, без длительного прогрева и повторений; p95 по 12
+ заданиям чувствителен к выбросу. Это учебная оценка, не SLA.
+- `MAX_PENDING_JOBS` проверяется приблизительно и не одной транзакцией с
+ вставкой; при нескольких API-репликах возможен небольшой перебор.
+- Время восстановления backpressure включает `docker compose start` и
+ healthcheck, поэтому это верхняя оценка, а не время чистой обработки.
## Ограничения и следующие шаги
diff --git a/evidence/track1.html b/evidence/track1.html
new file mode 100644
index 00000000..53e7638b
--- /dev/null
+++ b/evidence/track1.html
@@ -0,0 +1,276 @@
+
+
+
+
+
+Lab5 track 1 — очередь под перегрузкой
+
+
+
+
+
+
+
+Гипотеза. Маленькие изображения, которые почти не требуют
+масштабирования, должны давать высокий throughput и низкий RSS на задание.
+Большие изображения требуют декодирования и downscale, поэтому каждое задание
+дороже: при том же числе worker-ов очередь растёт, p95 time-to-ready
+увеличивается, а пиковый RSS зависит от concurrency сильнее, чем у маленьких
+файлов. Одновременно проверяем компромисс: eager уменьшает ожидание,
+но повышает потребление памяти; serial экономит память, но ограничивает
+throughput.
+
+
+
+
Профили и сценарии
+
+
Профиль
Concurrency
Prefetch
Смысл
+
+
serial
1
1
one job at a time; minimum memory, maximum queueing
Сценарии:
+small_many — 192×128, 30 jobs, many small images; variants fit or crop without large scaling; huge_few — 2400×1800, 12 jobs, few 4.32 MP images; optimized variant must scale down to 1280.
+
+
+
+
Ключевые числа
+
+
6
прогонов матрицы
+
1122 MiB
максимальный RSS worker
+
3
принято до первого 503
+
7.6 s
восстановление после backpressure
+
+
+
+
+
+
+
+
+
+
Полная матрица
+
+
Профиль
Сценарий
Jobs
Jobs/s
Queue lag p95, ms
Ready p95, ms
Processing p95, ms
RSS peak, MiB
Max parallel
Max backlog
+
serial
small_many
30
6.88
3194
3284
152
28
1
27
serial
huge_few
12
0.44
23333
25521
2311
205
1
12
balanced
small_many
30
11.59
1624
1736
336
31
4
26
balanced
huge_few
12
0.45
17716
25785
8710
729
4
12
eager
small_many
30
13.86
898
1158
566
33
8
26
eager
huge_few
12
0.46
17538
25699
17320
1122
8
12
+
+
Queue lag = processing_started_at - created_at.
+Time-to-ready = finished_at - created_at. Processing = finished_at - processing_started_at.
+RSS — VmRSS процесса worker, сэмплирование примерно каждые 100 мс.
+Max parallel — максимум одновременно обрабатываемых заданий; max backlog —
+максимум принятых, но ещё не готовых заданий.
+
+
+
+
Backpressure и восстановление
+
Перед этим прогоном API пересоздан с MAX_PENDING_JOBS=3, worker
+остановлен. Последовательные upload-ы показывают, где заканчивается принятая
+работа. Затем worker запускается, принятые задания должны дойти до ready.
+
+
#
HTTP
Latency, ms
Retry-After
Error code
+
1
202
18.2
—
—
2
202
17.4
—
—
3
202
10.8
—
—
4
503
3.9
5
unavailable
+
+
Recovery: 3 принятых заданий
+стали ready за 7.60 с после старта worker.
+Финальный probe upload: HTTP 202 → ready.
+
+
+
+
Что это значит
+
small_many: eager быстрее serial в 2.0× по throughput.
small_many: пиковый RSS eager относится к serial как 1.2×.
huge_few: throughput eager и serial практически одинаков.
huge_few: пиковый RSS eager относится к serial как 5.5×.
При balanced p95 time-to-ready для huge_few в 14.9× больше, чем для small_many: размер изображения меняет стоимость задания, а не только число заданий.
На huge_few eager почти не поднял throughput (1.04×): worker ограничен 1.0 CPU, а декодирование и масштабирование упираются в CPU. Concurrency снижает queue lag, но при этом растёт RSS; это и есть компромисс latency/ресурсы, а не бесплатное ускорение.
serial ограничивает одновременно обрабатываемые задания одним, поэтому queue lag растёт, но RSS остаётся минимальным. eager держит больше заданий в работе и в prefetch-окне брокера.
Backpressure: при MAX_PENDING_JOBS=3 API принял 3 задания, затем вернул 503 с Retry-After=5; после старта worker очередь восстановилась за 7.6 с.
+
+
+
+
Ограничения
+
+
Один worker, один RabbitMQ и один PostgreSQL: это сравнение настроек, а не
+HA-кластер. Числа зависят от CPU/диска конкретной машины.
+
PNG-фикстуры синтетические и хорошо сжимаются; доминирует стоимость декодирования
+и масштабирования, а не передача по сети. Размер в байтах указан в JSON.
+
RSS сэмплируется из /proc/1/status; короткий прогон не заменяет
+длительный memory profile и p99.
+
Backpressure cap приблизительный: каждая API-реплика считает pending-задания
+по общей БД, но проверка и вставка не являются одной транзакцией.
"
+ )
+
+ # Beginner-friendly observations computed from the actual numbers.
+ observations = []
+ for scenario in scenarios:
+ serial = lookup.get(("serial", scenario))
+ eager = lookup.get(("eager", scenario))
+ if serial and eager and serial["throughput_jobs_per_s"]:
+ speedup = eager["throughput_jobs_per_s"] / serial["throughput_jobs_per_s"]
+ if speedup >= 1.05:
+ comparison = f"eager быстрее serial в {speedup:.1f}× по throughput"
+ elif speedup <= 0.95:
+ comparison = f"eager медленнее serial ({speedup:.2f}×) по throughput"
+ else:
+ comparison = "throughput eager и serial практически одинаков"
+ observations.append(f"{scenario}: {comparison}.")
+ if serial["rss_peak_mib"] and eager["rss_peak_mib"]:
+ ratio = eager["rss_peak_mib"] / serial["rss_peak_mib"]
+ observations.append(
+ f"{scenario}: пиковый RSS eager относится к serial как {ratio:.1f}×."
+ )
+ balanced = lookup.get(("balanced", "small_many"))
+ huge = lookup.get(("balanced", "huge_few"))
+ if balanced and huge and balanced["time_to_ready_p95_ms"] and huge["time_to_ready_p95_ms"]:
+ observations.append(
+ "При balanced p95 time-to-ready для huge_few в "
+ f"{huge['time_to_ready_p95_ms'] / balanced['time_to_ready_p95_ms']:.1f}× "
+ "больше, чем для small_many: размер изображения меняет стоимость задания, "
+ "а не только число заданий."
+ )
+ huge_serial = lookup.get(("serial", "huge_few"))
+ huge_eager = lookup.get(("eager", "huge_few"))
+ if huge_serial and huge_eager and huge_serial["throughput_jobs_per_s"]:
+ speedup = huge_eager["throughput_jobs_per_s"] / huge_serial["throughput_jobs_per_s"]
+ if speedup < 1.2:
+ observations.append(
+ "На huge_few eager почти не поднял throughput "
+ f"({speedup:.2f}×): worker ограничен "
+ f"{html.escape(str(evidence['environment']['worker_cpu_limit']))} CPU, "
+ "а декодирование и масштабирование упираются в CPU. Concurrency "
+ "снижает queue lag, но при этом растёт RSS; это и есть компромисс "
+ "latency/ресурсы, а не бесплатное ускорение."
+ )
+ else:
+ observations.append(
+ f"На huge_few eager поднял throughput в {speedup:.2f}× относительно "
+ "serial, потому что несколько тяжёлых заданий перекрываются."
+ )
+ observations.append(
+ "serial ограничивает одновременно обрабатываемые задания одним, поэтому "
+ "queue lag растёт, но RSS остаётся минимальным. eager держит больше "
+ "заданий в работе и в prefetch-окне брокера."
+ )
+ observations.append(
+ "Backpressure: при MAX_PENDING_JOBS=3 API принял "
+ f"{evidence['backpressure']['accepted_before_503']} задания, затем вернул 503 "
+ f"с Retry-After={evidence['backpressure']['blocked_retry_after']}; после старта "
+ f"worker очередь восстановилась за {evidence['backpressure']['recovery_seconds']:.1f} с."
+ )
+
+ backpressure_rows = "".join(
+ "
"
+ f"
{item['index'] + 1}
"
+ f"
{item['status']}
"
+ f"
{fmt(item['elapsed_ms'], 1)}
"
+ f"
{html.escape(str(item['retry_after'] or '—'))}
"
+ f"
{html.escape(str(item['error_code'] or '—'))}
"
+ "
"
+ for item in evidence["backpressure"]["attempts"]
+ )
+
+ observations_html = "".join(f"
{html.escape(text)}
" for text in observations)
+ chart_html = "\n".join(f'{chart}' for chart in charts)
+
+ return f"""
+
+
+
+
+Lab5 track 1 — очередь под перегрузкой
+
+
+
+
+
+
+
+Гипотеза. Маленькие изображения, которые почти не требуют
+масштабирования, должны давать высокий throughput и низкий RSS на задание.
+Большие изображения требуют декодирования и downscale, поэтому каждое задание
+дороже: при том же числе worker-ов очередь растёт, p95 time-to-ready
+увеличивается, а пиковый RSS зависит от concurrency сильнее, чем у маленьких
+файлов. Одновременно проверяем компромисс: eager уменьшает ожидание,
+но повышает потребление памяти; serial экономит память, но ограничивает
+throughput.
+
+
+
+
Профили и сценарии
+
+
Профиль
Concurrency
Prefetch
Смысл
+
+{''.join(f"
{html.escape(p['name'])}
{p['concurrency']}
{p['prefetch']}
{html.escape(p['note'])}
" for p in evidence['profiles'])}
+
+
+
Сценарии:
+{'; '.join(f"{html.escape(s['name'])} — {s['width']}×{s['height']}, {s['count']} jobs, {s['description']}" for s in evidence['scenarios'])}.
+
+
+
+
Ключевые числа
+
+
{len(runs)}
прогонов матрицы
+
{max(run['rss_peak_mib'] or 0 for run in runs):.0f} MiB
максимальный RSS worker
+
{evidence['backpressure']['accepted_before_503']}
принято до первого 503
+
{evidence['backpressure']['recovery_seconds']:.1f} s
восстановление после backpressure
+
+
+
+{chart_html}
+
+
+
Полная матрица
+
+
Профиль
Сценарий
Jobs
Jobs/s
Queue lag p95, ms
Ready p95, ms
Processing p95, ms
RSS peak, MiB
Max parallel
Max backlog
+{''.join(table_rows)}
+
+
Queue lag = processing_started_at - created_at.
+Time-to-ready = finished_at - created_at. Processing = finished_at - processing_started_at.
+RSS — VmRSS процесса worker, сэмплирование примерно каждые 100 мс.
+Max parallel — максимум одновременно обрабатываемых заданий; max backlog —
+максимум принятых, но ещё не готовых заданий.
+
+
+
+
Backpressure и восстановление
+
Перед этим прогоном API пересоздан с MAX_PENDING_JOBS=3, worker
+остановлен. Последовательные upload-ы показывают, где заканчивается принятая
+работа. Затем worker запускается, принятые задания должны дойти до ready.
+
+
#
HTTP
Latency, ms
Retry-After
Error code
+{backpressure_rows}
+
+
Recovery: {evidence['backpressure']['recovered_jobs']} принятых заданий
+стали ready за {evidence['backpressure']['recovery_seconds']:.2f} с после старта worker.
+Финальный probe upload: HTTP {evidence['backpressure']['probe_status']} → ready.
+
+
+
+
Что это значит
+
{observations_html}
+
+
+
+
Ограничения
+
+
Один worker, один RabbitMQ и один PostgreSQL: это сравнение настроек, а не
+HA-кластер. Числа зависят от CPU/диска конкретной машины.
+
PNG-фикстуры синтетические и хорошо сжимаются; доминирует стоимость декодирования
+и масштабирования, а не передача по сети. Размер в байтах указан в JSON.
+
RSS сэмплируется из /proc/1/status; короткий прогон не заменяет
+длительный memory profile и p99.
+
Backpressure cap приблизительный: каждая API-реплика считает pending-задания
+по общей БД, но проверка и вставка не являются одной транзакцией.
+
+
+
+
+
+"""
+
+
+def write_markdown(evidence, path):
+ lines = [
+ "# Lab5 track 1 — queue under load",
+ "",
+ f"Generated: `{evidence['generated_at']}`",
+ "",
+ "Synthetic images; no tokens or credentials are stored.",
+ "",
+ "| Profile | Scenario | Jobs | Jobs/s | Queue lag p95, ms | Ready p95, ms | RSS peak, MiB |",
+ "| --- | --- | ---: | ---: | ---: | ---: | ---: |",
+ ]
+ for run in evidence["runs"]:
+ lines.append(
+ f"| {run['profile']} | {run['scenario']} | {run['jobs']} | "
+ f"{run['throughput_jobs_per_s']:.2f} | {run['queue_lag_p95_ms']:.0f} | "
+ f"{run['time_to_ready_p95_ms']:.0f} | {run['rss_peak_mib']:.0f} |"
+ )
+ bp = evidence["backpressure"]
+ lines.extend(
+ [
+ "",
+ f"Backpressure: cap={bp['cap']}, accepted={bp['accepted_before_503']}, "
+ f"first 503 Retry-After={bp['blocked_retry_after']}, "
+ f"recovery={bp['recovery_seconds']:.2f}s, probe HTTP {bp['probe_status']}.",
+ "",
+ ]
+ )
+ path.write_text("\n".join(lines))
+
+
+# ---------------------------------------------------------------------------
+# Main
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--base-url", default=os.environ.get("BASE_URL", "http://localhost:8080"))
+ parser.add_argument("--small-jobs", type=int, default=30)
+ parser.add_argument("--huge-jobs", type=int, default=12)
+ parser.add_argument(
+ "--worker-cpu-limit",
+ default=os.environ.get("TRACK1_WORKER_CPU_LIMIT", "1.0"),
+ help="Compose CPU quota applied to every experimental worker (default 1.0)",
+ )
+ parser.add_argument(
+ "--worker-mem-limit",
+ default=os.environ.get("TRACK1_WORKER_MEM_LIMIT", "2G"),
+ help="Compose memory limit applied to every experimental worker (default 2G)",
+ )
+ parser.add_argument("--out", default=str(ROOT / "evidence" / "track1.json"))
+ parser.add_argument("--html-out", default=str(ROOT / "evidence" / "track1.html"))
+ parser.add_argument("--md-out", default=str(ROOT / "evidence" / "track1.md"))
+ parser.add_argument(
+ "--skip-backpressure",
+ action="store_true",
+ help="only run the profile x scenario matrix",
+ )
+ args = parser.parse_args()
+
+ base_url = args.base_url.rstrip("/")
+ out = Path(args.out)
+ html_out = Path(args.html_out)
+ md_out = Path(args.md_out)
+ out.parent.mkdir(parents=True, exist_ok=True)
+ html_out.parent.mkdir(parents=True, exist_ok=True)
+
+ print(f"== bootstrap {base_url}", flush=True)
+ client = Client(base_url, timeout=60)
+ alice, _bob, _eve, chat = client.bootstrap()
+
+ scenarios = []
+ for item in SCENARIOS:
+ count = args.small_jobs if item["name"] == "small_many" else args.huge_jobs
+ data = make_png(item["width"], item["height"])
+ scenarios.append({**item, "count": count, "bytes": len(data)})
+
+ try:
+ wait_drained()
+ runs = []
+ for profile in PROFILES:
+ for scenario in scenarios:
+ data = make_png(scenario["width"], scenario["height"])
+ if len(data) != scenario["bytes"]:
+ raise Failure("fixture generation is not deterministic")
+ digest = hashlib.sha256(data).hexdigest()
+ print(
+ f"== run {profile['name']}/{scenario['name']} "
+ f"({scenario['count']} jobs, {scenario['width']}x{scenario['height']})",
+ flush=True,
+ )
+ result = measure_run(
+ base_url,
+ alice,
+ chat["id"],
+ profile,
+ scenario,
+ scenario["count"],
+ data,
+ digest,
+ cpu_limit=args.worker_cpu_limit,
+ mem_limit=args.worker_mem_limit,
+ )
+ runs.append(result)
+ print(
+ f" throughput={result['throughput_jobs_per_s']} jobs/s "
+ f"queue_p95={result['queue_lag_p95_ms']} ms "
+ f"ready_p95={result['time_to_ready_p95_ms']} ms "
+ f"rss_peak={result['rss_peak_mib']} MiB",
+ flush=True,
+ )
+
+ backpressure = None
+ if not args.skip_backpressure:
+ print("== backpressure (cap=3, worker stopped)", flush=True)
+ small = scenarios[0]
+ backpressure = measure_backpressure(
+ base_url,
+ alice,
+ chat["id"],
+ make_png(small["width"], small["height"]),
+ hashlib.sha256(make_png(small["width"], small["height"])).hexdigest(),
+ )
+ print(
+ f" accepted={backpressure['accepted_before_503']} "
+ f"503_retry_after={backpressure['blocked_retry_after']} "
+ f"recovery={backpressure['recovery_seconds']}s",
+ flush=True,
+ )
+ finally:
+ # Restore the stand even if a measurement raised.
+ try:
+ restore_worker()
+ except Exception as exc: # noqa: BLE001 - best effort in cleanup
+ print(f"warning: worker restore failed: {exc}", flush=True)
+ try:
+ restore_api()
+ except Exception as exc: # noqa: BLE001 - best effort in cleanup
+ print(f"warning: API restore failed: {exc}", flush=True)
+
+ if backpressure is None:
+ backpressure = {
+ "cap": 3,
+ "attempts": [],
+ "accepted_before_503": 0,
+ "blocked_status": None,
+ "blocked_retry_after": None,
+ "recovery_seconds": 0.0,
+ "recovered_jobs": 0,
+ "probe_status": None,
+ "probe_ready": False,
+ }
+
+ docker_version = compose_capture("version", "--short").strip()
+ evidence = {
+ "generated_at": datetime.now(timezone.utc).isoformat(),
+ "environment": {
+ "base_url": base_url,
+ "host": platform.node(),
+ "platform": platform.platform(),
+ "cpu_count": os.cpu_count(),
+ "python": platform.python_version(),
+ "docker_version": docker_version,
+ "compose_project": "mtusi2026lab",
+ "worker_container": worker_container(),
+ "worker_cpu_limit": args.worker_cpu_limit,
+ "worker_mem_limit": args.worker_mem_limit,
+ "worker_cpu_limit_default": "1.0",
+ "worker_mem_limit_default": "1G",
+ "note": (
+ "Experimental workers use a larger memory limit than .env so the "
+ "eager huge-image run can hold decoded images without OOM; CPU is "
+ "still limited so throughput is not a host-CPU artifact."
+ ),
+ },
+ "hypothesis": (
+ "Small images that fit the variants without large scaling should be cheaper "
+ "per job; huge images force decode+downscale, so each job costs more memory "
+ "and time. More concurrency should raise throughput and RSS but reduce queue lag."
+ ),
+ "profiles": PROFILES,
+ "scenarios": scenarios,
+ "runs": runs,
+ "backpressure": backpressure,
+ }
+
+ out.write_text(json.dumps(evidence, indent=2) + "\n")
+ html_out.write_text(build_html(evidence))
+ write_markdown(evidence, md_out)
+ print(json.dumps({"ok": True, "json": str(out), "html": str(html_out), "md": str(md_out)}))
+
+
+if __name__ == "__main__":
+ try:
+ main()
+ except (Failure, RuntimeError, subprocess.TimeoutExpired) as exc:
+ print("FAIL:", exc)
+ raise SystemExit(1)