Reproducible raid/replay render bench and #147 instancing measurements
build / mod (push) Failing after 32s
build / mod (push) Failing after 32s
tools/raid_bench.py (+ tests): the #147 step-0 driver replaces the #126 scratch script. One battle at fixed ticks (waves inside resident terrain — far waves stall at the unknown-chunk edge and no fight happens), fingerprint chat lines at control ticks, then the raid's own recording replayed. Both render paths are benched on the SAME recording in ONE process via the engine's diagnostic `model-instancing off|on` toggle (cross-process battles diverge in event timing: 16 vs 32 kills at one control tick), pairs in alternating order; idle cold/warm, mid-battle window, reload (F3+T), replay seek, away-camera checks, and static off/on stills for pixel parity (hd_bench motion-mask methodology). report.json carries gitlinks, device, mod_models counters, CPU/GPU p50/p95/p99/max, raw frame times, >25/33 ms frame counts, guest fuel and streaming queues. Engine gitlink: one mass mod-model group GPU-instanced (retained mesh per pack generation, current/previous pose/id/light instance stream shared by main, motion and shadow passes, per-vertex fallback to parity, runtime diagnostic toggle, stats raw + guest fuel reporting). Measurements: docs/measurements/issue-147-instancing/ (M5/Metal, 2560x1440; RTX 3060 pending). docs/REPO-MAP.md and docs/ENGINE.md pin updated. Co-Authored-By: Kimi Code <noreply@moonshot.ai>
This commit is contained in:
+5
-2
@@ -63,8 +63,11 @@ runtime закреплённого движка. Используется вре
|
||||
|
||||
## Акустика и владение захватом (API 27)
|
||||
|
||||
Текущий pin: `2bcce642362ab5d3f04de193e390d8293cd1bf30` (API 31; `render.project` — проекция
|
||||
мировых точек через камеру последнего отрисованного кадра, #132; ниже — staging, cascades,
|
||||
Текущий pin: `3428a571bda382c9c5b388710efd1baf92ed8d9c` (API 31; GPU-instancing одной
|
||||
массовой группы моделей мода с fallback до паритета и диагностическим toggle
|
||||
`model-instancing`, #147; ниже — decode motion buffer по history grid в TAA/TAAU #143,
|
||||
порядок DLSS-кадра #137, `render.project` — проекция мировых точек через камеру
|
||||
последнего отрисованного кадра, #132; ниже — staging, cascades,
|
||||
previous-frame motion и feature-gated DLSS SR backend #124, API 30). Акустические
|
||||
`render.acoustics-status` и `render.capture-owner-status` возвращают поколение,
|
||||
`available`, `enabled`, `request-accepted`, `prepared` и причину. В игре всё это показывает
|
||||
|
||||
+1
-1
@@ -16,7 +16,7 @@
|
||||
| `horizon/`, `.gitmodules` | Закреплённый сабмодуль отдельного форка Horizon |
|
||||
| `tools/airdef.py` | Сборка мода и установка в папку игры |
|
||||
| `tools/gen_models.py`, `tools/gen_tex.py`, `tools/gen_sounds.py` | Генераторы контента (см. ниже) |
|
||||
| `tools/acoustics_check.py`, `tools/hd_bench.py` | Проверочные скрипты |
|
||||
| `tools/acoustics_check.py`, `tools/hd_bench.py`, `tools/raid_bench.py` | Проверочные скрипты (`raid_bench` — воспроизводимый бой+replay замер рендера, #147) |
|
||||
| `docs/` | Документация (этот файл, `INSTALL.md`, `ACOUSTICS.md`, `HD-RENDERER.md`) |
|
||||
| `install.sh`, `play.sh`, `dist/` | Установка и запуск |
|
||||
| `run-home/`, `run-home-bench/`, `run-home-smoke/` | Тестовые игровые папки, не часть мода |
|
||||
|
||||
@@ -0,0 +1,228 @@
|
||||
# Issue #147, шаг 1: GPU-instancing одной массовой группы моделей мода — замеры
|
||||
|
||||
> Основа: engine `3428a571b` (instancing #147 поверх `8e711f969` — decode motion
|
||||
> buffer по history grid #143 и порядок DLSS-кадра #137), AirDef `32748b116`
|
||||
> (#145/#149). Замеры ниже сняты на этой основе; контракт motion buffer #143
|
||||
> (current-to-previous в jittered render pixels) instanced-путь наследует без
|
||||
> изменений — decode исправлен на стороне TAA/TAAU и применяется к обоим путям.
|
||||
|
||||
После retained-геометрии #126 (`a861c1ed2`) кадр всё ещё собирал и загружал вершины
|
||||
каждой модели каждый кадр (~3,1 МБ vertex + ~4,0 МБ motion на кадр в замере #126).
|
||||
Этот этап убирает поток повторных вершин для **одной массовой группы** одинаковых
|
||||
моделей: меш группы резолвится против атласа и загружается на GPU один раз на
|
||||
generation пака, кадр пишет только instance records (current/previous pose, ID, свет),
|
||||
и один и тот же instance stream рисует main, motion и тени. Остальные модели и весь
|
||||
кадр при выключенном instancing идут прежним покадровым путём — fallback до паритета
|
||||
(вершины бит-в-бит, тест `retained_emit_matches_the_per_frame_bake` #126 не менялся).
|
||||
|
||||
## Что изменилось (engine)
|
||||
|
||||
- `crates/horizon-client/src/model_instance.rs` — `ModelMeshVertex` (40 Б: model-space
|
||||
pos/normal, atlas UV, material, emission) и `ModelInstance` (80 Б: current/previous
|
||||
pose+quat, light, id, flags), минимум группы 8 моделей.
|
||||
- `entity.wgsl` — `vs_model_instance` / `vs_model_instance_motion`: тот же трансформ
|
||||
(quat о центре единичного куба), квантование нормалей trunc×127 как CPU `as i8`,
|
||||
упаковка light/emission/glow как `emit_mod_mesh`; motion через previous pose того же
|
||||
record. Неподвижная модель несёт идентичные pose → нулевая object velocity (#143).
|
||||
- `gfx.rs` — retained GPU-меши по состояниям (`upload_model_mesh`/`forget_model_meshes`),
|
||||
instance buffer, 4 пайплайна (HD gbuffer, HD motion, HD тени, classic/main+mod-камеры)
|
||||
с общим слотом меша и слотом записей; draws во всех пассах, где рисуется entity stream,
|
||||
включая камеры мода и каскады теней (модели за main camera рисуются там же).
|
||||
- `game/mod_models.rs` — выбор группы (больше всего моделей одного state, тай-брейк по
|
||||
меньшему state id), подготовка pose/light на модель (не на вершину), instance records
|
||||
для группы, прежний CPU-путь для остальных; счётчики `instanced_models/instanced_quads/
|
||||
instance_bytes/gpu_mesh_builds`; инвалидация GPU-мешей на reload/unload вместе с #126.
|
||||
- Fallback: `HORIZON_MODEL_INSTANCING=0` (стартовое значение) или runtime-toggle
|
||||
`model-instancing off|on` (control-команда, диагностика), группа < 8, shader pack
|
||||
рисует entities, нет renderer — весь кадр прежним путём. История drawn pose общая
|
||||
для обоих путей, поэтому переключение не размазывает motion.
|
||||
- Драйвер-поддержка: `stats raw` (сырые frame/cpu/gpu времена), `HORIZON_MOD_FUEL_PROFILE=1`
|
||||
→ `stats` отдаёт `mod_fuel` (calls/max_used/budget/failures по callback) и `mod_cost_ms`.
|
||||
|
||||
## Стенд
|
||||
|
||||
- Apple M5 (10 ядер), macOS, Metal. **Ryzen 5600X / RTX 3060 не профилировались** —
|
||||
приёмка на целевом железе pending (как в #126).
|
||||
- 2560×1440 offscreen (окно 1280×720 @2x), HD (`/airdef shader hd`), `HORIZON_HD_SCALE=1`,
|
||||
in-frame, `HORIZON_NO_AUDIO=1`, `HORIZON_SPIKES=0`, `HORIZON_MOD_FUEL_PROFILE=1`.
|
||||
- Мир `Polygon` (копия `run-home/saves/Polygon`), свежий `HORIZON_HOME` на прогон.
|
||||
Камера `tp @s 40 76 40 135 25`, `time set 6000`, `advance_time/advance_weather false`,
|
||||
`weather clear`, creative, HUD скрыт — сцена замера #126.
|
||||
- Один и тот же `airdef.hmod` во всех окнах (собран один раз, не пересобирался).
|
||||
- A/B — один бинарник, один процесс, одна запись боя: `model-instancing off`
|
||||
(fallback, вершины бит-в-бит равны до-правочному пути) против `on` (instancing),
|
||||
toggle переключается между окнами без перезапуска.
|
||||
|
||||
## Драйвер (шаг 0): `tools/raid_bench.py`
|
||||
|
||||
Воспроизводимый драйвер вместо scratch-скрипта #126. Один бой по фиксированным тикам
|
||||
(расписание в `BATTLE_SCHEDULE`: 14 батарей, волны shahed 40/160, kh101 16/180,
|
||||
mix 24/140), отпечаток боя — строки `airdef stats` на контрольных тиках; затем прогон
|
||||
**той же записи** (`airdef replay full`): призраки летят по записанным трекам.
|
||||
|
||||
**Оба пути замеряются на одной записи в одном процессе.** Драйвер переключает
|
||||
`model-instancing off|on` (диагностический toggle движка, #147) и проигрывает запись
|
||||
заново каждым путём: окна `replay_before`/`replay_after` и вторая пара в обратном
|
||||
порядке (проверка прогрева/очередей). Межпроцессные бои расходятся по таймингу
|
||||
событий (стриминг/акустика): первый вариант драйвера (A/B двумя прогонами) дал
|
||||
16 против 32 сбитых на одном контрольном тике и разные записи — такое сравнение
|
||||
не изолирует рендер, поэтому оставлен только как кросс-проверка (`--compare` двух
|
||||
отчётов честно показывает несовпадение отпечатков).
|
||||
|
||||
Окна: idle_cold 4 с (сразу после загрузки), idle_warm 6 с (после 500 тиков
|
||||
сходимости LOD), battle 10 с (середина боя, в потоке, чтобы расписание тиков не
|
||||
плыло), replay 12 с на путь. Проверки: reload (F3+T), seek (стрелки ±5 с в replay),
|
||||
камера в сторону от боя (тени/чужая камера), статичные кадры off/on после reload
|
||||
для пиксельного паритета (`--stills`, методика hd_bench: движущиеся пиксели
|
||||
маскируются по размаху между кадрами одного пути). Отчёт `report.json`: gitlink'и,
|
||||
устройство, счётчики `mod_models`, CPU/GPU p50/p95/p99/max, сырые frame time,
|
||||
кадры >25/33 мс, fuel гостей (`HORIZON_MOD_FUEL_PROFILE=1`), очереди стриминга.
|
||||
|
||||
Дальности волн — в пределах резидентного террейна (render distance 12 = 192 блока):
|
||||
на дальностях #126 (700–1400) дроны ждут ответа земли на краю неизвестных чанков
|
||||
(`sim/terrain.rs`, #61) и бой не состоится — первый прогон драйвера это показал
|
||||
(8 дронов висят на краю, 0 пусков, запись без событий). В пределах резидентного
|
||||
террейна бой идёт по тикам детерминированно.
|
||||
|
||||
```sh
|
||||
python3 tools/raid_bench.py --label m5 --out run-home-bench/out/147-m5
|
||||
python3 tools/raid_bench.py --compare run-home-bench/out/147-m5/report.json
|
||||
python3 tools/raid_bench.py --stills run-home-bench/out/147-m5
|
||||
```
|
||||
|
||||
## Результаты (M5/Metal, 2560×1440, один процесс, одна запись; основа #137/#143)
|
||||
|
||||
Прогон: `report.json` рядом с этим README (сырые frame time включены; рабочий каталог
|
||||
прогона — `run-home-bench/out/147-m5`, gitignore). Чистый паритет — `static-parity.json`
|
||||
(прогон `run-home-bench/out/147-static`). Отчёт снят на дереве `8835e5f04` (engine
|
||||
`3428a571b`); последующие amend'ы коммита меняли только docs/JSON, код драйвера,
|
||||
мода и движка идентичны финальному коммиту.
|
||||
|
||||
Бой на новой основе (#145/#149): 14 батарей, волны на тиках 60/140/220; отпечаток —
|
||||
43 сбитых к тику 800, 76 к тику 1200, ракеты в воздухе; конец боя тик 1594. Группа
|
||||
instancing — самая массовая state летящих моделей (~24 одинаковых дроона/кадр из
|
||||
~113 моделей записи); крупные модели батарей (штучные) остаются на CPU-пути.
|
||||
|
||||
### Replay, одна запись, пары off→on (порядок пар чередуется)
|
||||
|
||||
| Метрика | before (off) | after (on) | B/A |
|
||||
|---|---|---|---|
|
||||
| моделей/кадр | 112.7 | 113.3 | 1.005 |
|
||||
| instanced/кадр | 0 | 24.6 | — |
|
||||
| vertex байт/кадр | 1 919 038 | 1 864 573 | 0.972 |
|
||||
| motion байт/кадр | 2 442 411 | 2 373 093 | 0.972 |
|
||||
| instance байт/кадр | 0 | 1 969 | — |
|
||||
| CPU avg, мс | 27.2 | 26.1 | 0.961 |
|
||||
| CPU p50 / p95 / p99, мс | 26.7 / 41.6 / 46.9 | 24.6 / 44.7 / 50.3 | 0.92 / 1.07 / 1.07 |
|
||||
| фаза prepare avg, мс | 1.89 | 1.73 | 0.92 |
|
||||
| фаза render avg, мс | 15.22 | 14.49 | 0.95 |
|
||||
| frame p95 / p99, мс | 141.7 / 153.5 | 135.2 / 253.6 | 0.95 / 1.65 |
|
||||
| GPU p95 / p99, мс | 143.8 / 175.7 | 127.3 / 154.6 | 0.89 / 0.88 |
|
||||
|
||||
Вторая пара (on→off→on→off): vertex/motion ×0.967, instance 1 909 Б/кадр,
|
||||
CPU avg 23.1→24.9 (×1.08), p95 ×1.03, p99 ×1.10; prepare 1.72→1.69, render
|
||||
14.08→14.05; frame/GPU p95 ×1.13/1.24. Кадров в окнах 122–143, моделей/кадр
|
||||
112.4–113.7 — одна и та же запись.
|
||||
|
||||
**Байты — устойчивый выигрыш**: группа ~24 моделей × ~2.3 КБ vertex + ~2.9 КБ motion
|
||||
≈ 123 КБ/кадр заменены на ~1.9 КБ записей (~65× для группы); суммарный upload кадра
|
||||
−2.8…3.3% в обеих парах, потому что группа — мелкие летящие модели (24 из 113),
|
||||
а крупные батарейные остаются на CPU-пути (следующие этапы #147).
|
||||
|
||||
**CPU prepare/render — мал, но в ту же сторону в обеих парах** (prepare −8%/−2%,
|
||||
render −5%/−0.2%). Перцентили CPU/frame в окнах гуляют ±10% между парами: их
|
||||
доминируют не-рендерные фазы (tick/update/стриминг) и дрейф сессии (окна идут
|
||||
подряд, первые несут остаточную нагрузку после боя; в до-ребейзном прогоне первая
|
||||
пара давала CPU p99 ×0.61, вторая ×0.95 — тот же порядок-эффект). На M5 в этой
|
||||
сцене кадр GPU-bound (~95 мс HD освещение/дым на 1440p), почти все кадры >33 мс;
|
||||
хвост frame p99 в первой паре хуже (253 мс — одиночный GPU-спайк), во второй
|
||||
×1.08. Устойчивого улучшения худших кадров на M5 instancing одной группы не даёт —
|
||||
критерий #147 по худшим кадрам требует GPU-работы (шаги 2–3) и/или CPU-bound
|
||||
железа (5600X/3060, pending), где снятие prepare должно быть виднее.
|
||||
|
||||
### Бой (live, instancing on) и idle
|
||||
|
||||
- battle: 131 модель/кадр, 27.5 instanced, vertex 2.08 МБ/кадр, motion 2.64 МБ/кадр,
|
||||
instance 2.2 КБ/кадр; CPU p95 118 / p99 130 мс (max 1023 — catch-up спайк),
|
||||
frame p99 131 мс; фазы: render 32.7, update 22.5, tick 15.6 мс.
|
||||
- idle_cold: CPU p95 22.2 / p99 41.3 мс; idle_warm: p95 16.2 / p99 16.9 мс (моделей нет).
|
||||
- reload_warm (после F3+T, instancing on): 48 моделей/кадр, 12 instanced,
|
||||
CPU p95 20.1 / p99 21.9 мс, frame p99 26.8 мс.
|
||||
|
||||
### Проверки
|
||||
|
||||
- **Reload (F3+T)**: `atlas_scans` 0→1, `mesh_builds` 0→17, `gpu_mesh_builds` 0→1 —
|
||||
GPU-меши пересозданы против нового атласа, модели рисуются (74 720 за окно после).
|
||||
- **Seek (стрелки ±5 с в replay)**: модели рисуются до и после (22 863 → 24 771,
|
||||
instanced 808 → 1 073); переключение пути не размазывает motion (общая история
|
||||
drawn pose).
|
||||
- **Камера в сторону от боя**: 27 085 моделей / 1 516 instanced подготовлены, пока
|
||||
main camera смотрит в другую сторону — тени и чужая камера их рисуют; сам
|
||||
`replay full` снимает через камеру мода.
|
||||
- **Fuel гостей** (`HORIZON_MOD_FUEL_PROFILE=1`): tick max_used 12.73M при бюджете
|
||||
300M, frame 1 927/10M, command 551 395/1G, failures 0.
|
||||
- **Стриминг/очереди**: после settle `pending_chunks` 0.
|
||||
|
||||
### Пиксельный паритет fallback ↔ instancing
|
||||
|
||||
Чистый прогон `--static-parity` (`static-parity.json`, рабочий каталог
|
||||
`run-home-bench/out/147-static`): батареи, без боя,
|
||||
`HORIZON_HD_TAA=0 HORIZON_HD_WIND=0 HORIZON_HD_CLOUDS=0 HORIZON_HD_VOLFOG=0`
|
||||
(методика #126), settle 2×500 тиков, `pauseOnLostFocus:false`, по 3 кадра на путь:
|
||||
|
||||
- **off ↔ on: 0.0005% статичных пикселей с разницей >20/255** (проверено 93.5% кадра,
|
||||
~2 пикселя из 3.4 млн), mean abs diff 0.717; движущиеся пиксели (вода, 6.5%)
|
||||
маскируются по размаху.
|
||||
- Шум пола: off↔off 0.000% (mean 0.686), on↔on 0.000% (mean 3.135) — паритет на
|
||||
уровне пола; fallback бит-в-бит равен до-правочному
|
||||
(`retained_emit_matches_the_per_frame_bake`, #126, не менялся).
|
||||
- На до-ребейзном прогоне паритет был 0.103% (TAA-история после переключения пути
|
||||
не сошлась); с #143 (decode по history grid) и выключенным TAA в чистом прогоне —
|
||||
0.0005%.
|
||||
|
||||
### Методика: почему одна запись в одном процессе
|
||||
|
||||
Первый вариант драйвера (A/B двумя прогонами, `HORIZON_MODEL_INSTANCING=0` против
|
||||
включённого) дал расходящиеся бои: 16 против 32 сбитых на контрольном тике 400 —
|
||||
тайминг событий зависит от стриминга/акустики, записи разные, сравнение не изолирует
|
||||
рендер. Также волны на дальностях #126 (700–1400) не состоялись: дроны висят на краю
|
||||
неизвестных чанков (0 пусков). Итог: волны в резидентном террейне, бой один,
|
||||
оба пути на его записи через runtime-toggle, пары чередуются. Кросс-прогонные
|
||||
отчёты первого варианта лежат в `run-home-bench/out/147-before|after` (не коммитятся).
|
||||
|
||||
## Тесты
|
||||
|
||||
```sh
|
||||
cd horizon
|
||||
cargo test -p horizon-client --features mods --lib --bins model_instance # 2: раскладки буферов
|
||||
cargo test -p horizon-client --features mods --bin horizon-client mod_models::tests # 6
|
||||
cargo test -p horizon-client --features mods --lib entity_shader_validates # WGSL (naga)
|
||||
python3 tools/test_raid_bench.py # 7: драйвер
|
||||
```
|
||||
|
||||
- `retained_emit_matches_the_per_frame_bake` (#126, не менялся) — fallback путь бит-в-бит.
|
||||
- `instance_group_picks_the_most_models_deterministically` — выбор группы и тай-брейк.
|
||||
- `gpu_mesh_vertices_match_the_retained_faces` — GPU-меш = те же грани/UV/материалы.
|
||||
- `instanced_shader_math_matches_the_cpu_bake` — трансформ шейдера против CPU-матрицы
|
||||
(f32-округление, <1e-5 относительной ошибки) и квантование нормалей (≤1 шага i8).
|
||||
- `static_instance_keeps_zero_object_velocity` — неподвижная модель: identical poses,
|
||||
нулевая object velocity (#143), moved model несёт последний drawn pose.
|
||||
- `model_instance_attributes_follow_their_structs`, `records_are_tightly_packed_for_the_vertex_layout`
|
||||
— раскладки буферов против struct offset'ов.
|
||||
- `entity_shader_validates_with_its_overlay_constants` — WGSL валиден (naga).
|
||||
|
||||
На основе #137/#143 также прогнаны: `dlss_submission_orders_consumers_after_ngx`
|
||||
(#137) — ok; `airdef-core` cargo test — 326+8 passed, 0 failed (8 ignored);
|
||||
`airdef-mod` cargo test — 113+1+2+5 passed, 0 failed (включая saturation #145 и
|
||||
smart #149); смок-запуск ребейзнутого бинарника с toggle off/on — ok.
|
||||
|
||||
## Ограничения и что дальше
|
||||
|
||||
- Замеры только на M5/Metal; 5600X/3060 — pending acceptance.
|
||||
- GPU-трансформ отличается от CPU в последних ulp f32 (порядок округления), поэтому
|
||||
паритет instanced-пути — визуальный (пиксельный A/B), не бит-в-бит; бит-в-бит паритет
|
||||
гарантирован fallback-пути.
|
||||
- HD smoke (направление B) и worker rewrite не тронуты (шаги 2–3 #147 отдельно).
|
||||
- Координатный контракт motion buffer #143 (jitter native TAAU) не менялся: instanced
|
||||
motion пишет тот же контракт (jittered prev_view_proj + camera_delta), что и CPU-путь;
|
||||
decode по history grid из #143 применяется к обоим путям одинаково.
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"mean": 0.7174437030100996,
|
||||
"pct": 0.0005154079861111111,
|
||||
"animated_pct": 6.484049479166667,
|
||||
"animated_mean": 8.184034227510306,
|
||||
"static_pct": 93.51595052083333,
|
||||
"new_animated_pct": 0.8565266927083334,
|
||||
"cur_animated_pct": 4.932156032986111,
|
||||
"size": [
|
||||
2560,
|
||||
1440
|
||||
]
|
||||
}
|
||||
+1
-1
Submodule horizon updated: 8e711f9692...3428a571bd
@@ -0,0 +1,602 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Воспроизводимый драйвер замера рендера AirDef (#147, шаг 0): один бой по
|
||||
фиксированным тикам и прогон той же записи (replay) для изоляции рендера, плюс idle.
|
||||
|
||||
python3 tools/raid_bench.py --label m5 --out run-home-bench/out/147-m5
|
||||
python3 tools/raid_bench.py --compare run-home-bench/out/147-m5/report.json
|
||||
python3 tools/raid_bench.py --stills run-home-bench/out/147-m5
|
||||
|
||||
Каждый прогон: свежий HORIZON_HOME в папке вывода, копия мира Polygon из run-home/saves,
|
||||
собранный airdef.hmod, игра офскрин на своём сокете (чужой игре run-home/ctl.sock не
|
||||
мешаем). Сцена фиксирована: tp, полдень, время и погода заморожены, HD, HUD скрыт.
|
||||
Бой выдаётся по тикам (не по стене): батареи, затем волны на указанных тиках;
|
||||
отпечаток боя — строки `airdef stats` на контрольных тиках.
|
||||
|
||||
После боя играется его собственная запись (`airdef replay full`): призраки летят по
|
||||
записанным трекам. Оба пути рендера замеряются на ОДНОЙ записи в ОДНОМ процессе:
|
||||
драйвер переключает `model-instancing off|on` (диагностический toggle движка) и
|
||||
проигрывает запись заново каждым путём; пары чередуются по порядку (проверка
|
||||
прогрева). Межпроцессные бои расходятся по таймингу событий (стриминг/акустика),
|
||||
поэтому сравнение разных записей не было бы сравнением рендера — первый вариант
|
||||
драйвера это показал (16 против 32 сбитых на одном контрольном тике).
|
||||
Окна: idle cold (сразу после загрузки), idle warm (после сходимости LOD), бой,
|
||||
replay_before/replay_after (+ вторая пара). Проверки: reload (F3+T), seek (стрелки
|
||||
в replay), камера в сторону от моделей (тени и чужая камера обязаны их рисовать),
|
||||
статичные кадры off/on для пиксельного паритета (--stills, методика hd_bench).
|
||||
Отчёт: report.json с gitlink'ами, устройством, счётчиками mod_models, CPU/GPU
|
||||
p50/p95/p99/max и сырыми frame time, плюс скриншоты.
|
||||
|
||||
Только стандартная библиотека. Коды выхода: 0 — прогон снят; 2 — ошибка запуска/аргументов.
|
||||
"""
|
||||
import argparse
|
||||
import datetime
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
import platform
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parent.parent
|
||||
SAVES = ROOT / "run-home" / "saves"
|
||||
CTL = ROOT / "horizon" / "target" / "fast" / "horizon-ctl"
|
||||
HMOD_CANDIDATES = (
|
||||
ROOT / "airdef-mod" / "target" / "horizon-mod" / "airdef.hmod",
|
||||
ROOT / "airdef.hmod",
|
||||
)
|
||||
# Поза и свет как в замере #126 (docs/measurements/issue-126-first-stage/README.md).
|
||||
POSE = (40, 76, 40, 135, 25)
|
||||
DAY_TIME = 6000
|
||||
# Расписание боя: (тик от T0, команда). T0 — тик начала боя после прогрева сцены.
|
||||
# Дальности волн — в пределах резидентного террейна (render distance 12 = 192 блока):
|
||||
# дальше дроны ждут ответа земли на краю неизвестных чанков и бой не состоится
|
||||
# (sim/terrain.rs, #61); в пределах — бой детерминирован по тикам.
|
||||
BATTLE_SCHEDULE = (
|
||||
(20, "airdef deploy s400"), (20, "airdef deploy s400"),
|
||||
(22, "airdef deploy patriot"), (22, "airdef deploy patriot"),
|
||||
(24, "airdef deploy pantsir"), (24, "airdef deploy pantsir"),
|
||||
(26, "airdef deploy gepard"), (26, "airdef deploy gepard"),
|
||||
(28, "airdef deploy nasams"), (28, "airdef deploy nasams"),
|
||||
(30, "airdef deploy irist"), (30, "airdef deploy irist"),
|
||||
(32, "airdef deploy tor"), (32, "airdef deploy tor"),
|
||||
(60, "airdef wave shahed 40 160"),
|
||||
(140, "airdef wave kh101 16 180"),
|
||||
(220, "airdef wave mix 24 140"),
|
||||
)
|
||||
# Контрольные тики отпечатка боя (от T0) и конец боя.
|
||||
FINGERPRINT_TICKS = (400, 800, 1200)
|
||||
BATTLE_END = 1400
|
||||
# Окна замера, секунд (bench N): idle cold/warm, бой, replay.
|
||||
BENCH_SECONDS = {"idle_cold": 4, "idle_warm": 6, "battle": 10, "replay": 12}
|
||||
SETTLE_TICKS = 500 # 25 с: LOD сходится, как в методике #126
|
||||
REPLAY_WARM_TICKS = 100 # 5 с записи до окна замера
|
||||
STATS_RE = re.compile(r"В воздухе: (\d+), ракет: (\d+), ПВО: (\d+), сбито: (\d+), поражений: (\d+)")
|
||||
|
||||
|
||||
class BenchError(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
def die(msg):
|
||||
raise BenchError(msg)
|
||||
|
||||
|
||||
def percentile(values, p):
|
||||
"""Перцентиль как в FrameStats::summary (ceil-индекс, 1-based)."""
|
||||
if not values:
|
||||
return None
|
||||
s = sorted(values)
|
||||
i = max(1, min(len(s), math.ceil(len(s) * p)))
|
||||
return s[i - 1]
|
||||
|
||||
|
||||
def frame_summary(raw):
|
||||
"""p50/p95/p99/max и счётчики худших кадров по сырым временам, мс."""
|
||||
out = {}
|
||||
for key in ("frame_ms", "cpu_ms", "gpu_ms"):
|
||||
v = raw.get(key) or []
|
||||
out[key] = {
|
||||
"n": len(v),
|
||||
"avg_ms": sum(v) / len(v) if v else None,
|
||||
"p50_ms": percentile(v, 0.5),
|
||||
"p95_ms": percentile(v, 0.95),
|
||||
"p99_ms": percentile(v, 0.99),
|
||||
"max_ms": max(v) if v else None,
|
||||
}
|
||||
frames = raw.get("frame_ms") or []
|
||||
out["frames_over_25ms"] = sum(1 for f in frames if f > 25.0)
|
||||
out["frames_over_33ms"] = sum(1 for f in frames if f > 33.0)
|
||||
return out
|
||||
|
||||
|
||||
def git_sha(cwd):
|
||||
r = subprocess.run(["git", "rev-parse", "HEAD"], cwd=cwd, capture_output=True, text=True)
|
||||
return r.stdout.strip() if r.returncode == 0 else None
|
||||
|
||||
|
||||
def git_branch(cwd):
|
||||
r = subprocess.run(["git", "branch", "--show-current"], cwd=cwd, capture_output=True, text=True)
|
||||
return r.stdout.strip() or None
|
||||
|
||||
|
||||
class Driver:
|
||||
"""Одна игра на своём сокете; команды horizon-ctl и ожидание по тикам."""
|
||||
|
||||
def __init__(self, out, game, resources, mod, extra_env, width, height):
|
||||
self.out = Path(out).resolve()
|
||||
self.home = self.out / "home"
|
||||
self.sock = self.out / "c.sock"
|
||||
self.log = self.out / "c.log"
|
||||
self.game = Path(game).resolve()
|
||||
self.resources = Path(resources).resolve()
|
||||
self.mod = Path(mod).resolve()
|
||||
self.extra_env = dict(extra_env)
|
||||
self.width, self.height = width, height
|
||||
self.t0 = None
|
||||
|
||||
# --- запуск ---
|
||||
def prepare(self):
|
||||
if self.home.exists():
|
||||
shutil.rmtree(self.home)
|
||||
(self.home / "saves").mkdir(parents=True)
|
||||
src = SAVES / "Polygon"
|
||||
if not src.is_dir():
|
||||
die(f"нет мира {src}")
|
||||
shutil.copytree(src, self.home / "saves" / "Polygon",
|
||||
ignore=shutil.ignore_patterns("session.lock", "*.lock"))
|
||||
mods = self.home / "horizon-mods"
|
||||
mods.mkdir(parents=True, exist_ok=True)
|
||||
shutil.copyfile(self.mod, mods / "airdef.hmod")
|
||||
(self.home / "horizon-mods.txt").write_text("mod.airdef:true\n")
|
||||
# Фоновая потеря фокуса не должна ставить игру на паузу посреди замера.
|
||||
(self.home / "options.txt").write_text("pauseOnLostFocus:false\n")
|
||||
|
||||
def env(self):
|
||||
env = dict(os.environ)
|
||||
env.update({
|
||||
"HORIZON_HOME": str(self.home),
|
||||
"HORIZON_NO_AUDIO": "1",
|
||||
"HORIZON_LAUNCHER_NO_SELF_UPDATE": "1",
|
||||
"HORIZON_MOD_FUEL_PROFILE": "1",
|
||||
"HORIZON_HD_SCALE": "1",
|
||||
"HORIZON_SPIKES": "0",
|
||||
})
|
||||
env.update(self.extra_env)
|
||||
return env
|
||||
|
||||
def launch(self):
|
||||
if self.sock.exists():
|
||||
self.sock.unlink()
|
||||
cmd = [str(CTL), "--socket", str(self.sock), "launch",
|
||||
"--world", "Polygon", "--creative", "--offscreen", "--wait",
|
||||
"--in-frame", "--width", str(self.width), "--height", str(self.height),
|
||||
"--game", str(self.game), "--resources", str(self.resources)]
|
||||
with open(self.log, "w") as log:
|
||||
r = subprocess.run(cmd, text=True, env=self.env(),
|
||||
cwd=self.home, timeout=600, stdout=log, stderr=subprocess.STDOUT)
|
||||
if r.returncode != 0:
|
||||
die(f"launch: {self.log.read_text()[-400:]}")
|
||||
|
||||
def ctl(self, *args, timeout=60.0):
|
||||
cmd = [str(CTL), "--socket", str(self.sock), "--timeout", f"{timeout:g}", *map(str, args)]
|
||||
try:
|
||||
r = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout + 60)
|
||||
except subprocess.TimeoutExpired as e:
|
||||
die(f"horizon-ctl {' '.join(map(str, args))}: таймаут")
|
||||
if r.returncode != 0:
|
||||
die(f"horizon-ctl {' '.join(map(str, args))}: {(r.stdout or r.stderr).strip()[:300]}")
|
||||
return r.stdout.strip()
|
||||
|
||||
def ctl_json(self, *args, timeout=60.0):
|
||||
text = self.ctl(*args, timeout=timeout)
|
||||
try:
|
||||
return json.loads(text)
|
||||
except json.JSONDecodeError:
|
||||
return {"_raw": text}
|
||||
|
||||
def status(self):
|
||||
return self.ctl_json("status")
|
||||
|
||||
def ticks(self):
|
||||
return int(self.status()["ticks"])
|
||||
|
||||
def wait_ticks(self, n, timeout=240.0):
|
||||
"""Ждать n тиков игры (20 Гц), не стены."""
|
||||
start = self.ticks()
|
||||
deadline = time.monotonic() + timeout
|
||||
while self.ticks() < start + n:
|
||||
if time.monotonic() > deadline:
|
||||
die(f"тики не идут: {start} -> {self.ticks()} за {timeout:g} с")
|
||||
time.sleep(0.1)
|
||||
|
||||
def at_tick(self, target, *args):
|
||||
deadline = time.monotonic() + 240.0
|
||||
while self.ticks() < target:
|
||||
if time.monotonic() > deadline:
|
||||
die(f"тик {target} не достигнут")
|
||||
time.sleep(0.05)
|
||||
return self.ctl(*args)
|
||||
|
||||
def chat(self, line):
|
||||
return self.ctl_json("chat", line)
|
||||
|
||||
def chat_log(self, n=12):
|
||||
return self.ctl_json("chat-log", str(n)).get("chat", [])
|
||||
|
||||
def stats(self, raw=True):
|
||||
return self.ctl_json("stats", "raw" if raw else "", timeout=120.0)
|
||||
|
||||
def bench(self, seconds):
|
||||
"""bench N: сброс счётчиков, окно N секунд, summary + сырые времена."""
|
||||
self.ctl("bench", str(seconds), timeout=seconds + 120.0)
|
||||
return self.stats(raw=True)
|
||||
|
||||
def screenshot(self, name):
|
||||
path = self.out / f"{name}.png"
|
||||
self.ctl("screenshot", str(path), timeout=120.0)
|
||||
return path.name
|
||||
|
||||
def stop(self):
|
||||
try:
|
||||
self.ctl("quit", timeout=30.0)
|
||||
except BenchError:
|
||||
pass
|
||||
|
||||
# --- сцена и бой ---
|
||||
def scene(self):
|
||||
self.ctl("command", "gamemode creative")
|
||||
self.chat("/airdef shader hd")
|
||||
self.ctl("key", "f1", "tap") # HUD скрыт
|
||||
self.ctl("command", f"tp @s {' '.join(map(str, POSE))}")
|
||||
self.ctl("command", f"time set {DAY_TIME}")
|
||||
self.ctl("command", "gamerule advance_time false")
|
||||
self.ctl("command", "gamerule advance_weather false")
|
||||
self.ctl("command", "weather clear")
|
||||
|
||||
def battle(self, report):
|
||||
self.t0 = self.ticks() + 40
|
||||
fingerprints = {}
|
||||
for tick, cmd in BATTLE_SCHEDULE:
|
||||
self.at_tick(self.t0 + tick, "chat", f"/{cmd}")
|
||||
# Окно замера в середине боя — отдельным потоком, чтобы расписание
|
||||
# контрольных тиков не плыло за блокирующим bench.
|
||||
battle_window = {}
|
||||
|
||||
def mid_battle():
|
||||
self.at_tick(self.t0 + 500, "bench", str(BENCH_SECONDS["battle"]))
|
||||
battle_window.update(self.stats(raw=True))
|
||||
|
||||
thread = threading.Thread(target=mid_battle)
|
||||
thread.start()
|
||||
self.at_tick(self.t0 + 550, "screenshot", str(self.out / "battle.png"))
|
||||
for tick in FINGERPRINT_TICKS:
|
||||
self.at_tick(self.t0 + tick, "chat", "/airdef stats")
|
||||
time.sleep(0.3)
|
||||
line = next((l for l in reversed(self.chat_log(20)) if "В воздухе:" in l), None)
|
||||
fingerprints[str(tick)] = line
|
||||
self.at_tick(self.t0 + BATTLE_END, "chat", "/airdef stats")
|
||||
time.sleep(0.3)
|
||||
fingerprints[str(BATTLE_END)] = next(
|
||||
(l for l in reversed(self.chat_log(20)) if "В воздухе:" in l), None)
|
||||
thread.join()
|
||||
report["windows"]["battle"] = battle_window
|
||||
report["screenshots"].append("battle.png")
|
||||
# Запись завершается, когда небо чисто 5 с (sim/record.rs): ждём конца
|
||||
# боя по тикам, не по стене, затем паузу на финализацию записи.
|
||||
end_deadline = self.t0 + BATTLE_END + 800
|
||||
while self.ticks() < end_deadline:
|
||||
self.ctl("chat", "/airdef stats")
|
||||
time.sleep(0.3)
|
||||
line = next((l for l in reversed(self.chat_log(20)) if "В воздухе:" in l), "")
|
||||
m = STATS_RE.search(line)
|
||||
if m and m.group(1) == "0" and m.group(2) == "0":
|
||||
break
|
||||
self.wait_ticks(20)
|
||||
report["raid_end_tick"] = self.ticks() - self.t0
|
||||
self.wait_ticks(120)
|
||||
return fingerprints
|
||||
|
||||
def replay_seek(self, steps):
|
||||
"""Seek записи: стрелка влево/вправо = ±5 с (replay::control)."""
|
||||
key = "left" if steps < 0 else "right"
|
||||
for _ in range(abs(steps)):
|
||||
self.ctl("key", key, "tap")
|
||||
time.sleep(0.15)
|
||||
|
||||
|
||||
def static_parity(args):
|
||||
"""Чистый пиксельный паритет off/on: статичная сцена (батареи), без боя,
|
||||
TAA/ветер/облака/туман выключены (методика #126), долгий settle."""
|
||||
env = dict(kv.split("=", 1) for kv in args.env)
|
||||
env.update({"HORIZON_HD_TAA": "0", "HORIZON_HD_WIND": "0",
|
||||
"HORIZON_HD_CLOUDS": "0", "HORIZON_HD_VOLFOG": "0"})
|
||||
d = Driver(args.out, args.game, args.resources, args.mod, env, args.width, args.height)
|
||||
d.prepare()
|
||||
d.launch()
|
||||
out = Path(args.out).resolve()
|
||||
try:
|
||||
d.scene()
|
||||
for kind in ("s400", "patriot", "pantsir", "gepard", "nasams", "irist", "tor"):
|
||||
d.chat(f"/airdef deploy {kind}")
|
||||
d.chat(f"/airdef deploy {kind}")
|
||||
d.wait_ticks(SETTLE_TICKS)
|
||||
d.bench(4) # прогрев счётчиков/кэшей
|
||||
d.wait_ticks(SETTLE_TICKS)
|
||||
for mode in ("off", "on"):
|
||||
d.ctl("model-instancing", mode)
|
||||
d.wait_ticks(100)
|
||||
for i in range(3):
|
||||
d.screenshot(f"stills_{mode}_{i}")
|
||||
d.wait_ticks(10)
|
||||
m = d.stats(raw=False).get("mod_models") or {}
|
||||
print(f"модели: {m.get('models')} за {m.get('frames')} кадров, "
|
||||
f"instanced={m.get('instanced_models')}, gpu_mesh_builds={m.get('gpu_mesh_builds')}")
|
||||
finally:
|
||||
d.stop()
|
||||
res = stills_compare(out)
|
||||
(out / "static_parity.json").write_text(json.dumps(res, indent=1))
|
||||
return res
|
||||
|
||||
|
||||
def run(args):
|
||||
d = Driver(args.out, args.game, args.resources, args.mod,
|
||||
dict(kv.split("=", 1) for kv in args.env), args.width, args.height)
|
||||
d.prepare()
|
||||
d.launch()
|
||||
report = {
|
||||
"issue": 147,
|
||||
"label": args.label,
|
||||
"timestamp": datetime.datetime.now().isoformat(timespec="seconds"),
|
||||
"git": {
|
||||
"airdef": git_sha(ROOT),
|
||||
"airdef_branch": git_branch(ROOT),
|
||||
"horizon": git_sha(ROOT / "horizon"),
|
||||
},
|
||||
"platform": {"system": platform.system(), "machine": platform.machine(),
|
||||
"mac_ver": platform.mac_ver()[0]},
|
||||
"env": d.env(),
|
||||
"battle_schedule": [[t, c] for t, c in BATTLE_SCHEDULE],
|
||||
"windows": {},
|
||||
"checks": {},
|
||||
"screenshots": [],
|
||||
}
|
||||
try:
|
||||
d.scene()
|
||||
status = d.status()
|
||||
report["device"] = status.get("renderer")
|
||||
report["display"] = status.get("display")
|
||||
size = (status.get("renderer") or {}).get("size")
|
||||
print(f"устройство: {report['device']}, кадр {size}")
|
||||
|
||||
# Idle cold: первые кадры после загрузки мира (холодные меши/атлас).
|
||||
report["windows"]["idle_cold"] = d.bench(BENCH_SECONDS["idle_cold"])
|
||||
# Прогрев: LOD и стриминг сходятся по тикам, не по стене.
|
||||
d.wait_ticks(SETTLE_TICKS)
|
||||
report["windows"]["idle_warm"] = d.bench(BENCH_SECONDS["idle_warm"])
|
||||
report["checks"]["settle"] = {
|
||||
"pending_chunks": d.status().get("pending_chunks"),
|
||||
"lod": d.status().get("lod"),
|
||||
}
|
||||
|
||||
# Бой по фиксированным тикам; окно замера в середине боя (в потоке).
|
||||
fingerprints = d.battle(report)
|
||||
report["battle_fingerprints"] = fingerprints
|
||||
|
||||
# Та же запись в обоих путях, один процесс: бой записан один раз, replay
|
||||
# проигрывает его идентично в каждом окне. Межпроцессные бои расходятся
|
||||
# по таймингу событий (стриминг/акустика), поэтому A/B на разных записях
|
||||
# не был бы сравнением рендера. Порядок пар чередуется (проверка прогрева).
|
||||
def replay_window(tag):
|
||||
d.chat("/airdef replay full")
|
||||
d.wait_ticks(REPLAY_WARM_TICKS)
|
||||
w = d.bench(BENCH_SECONDS["replay"])
|
||||
report["screenshots"].append(d.screenshot(tag))
|
||||
d.chat("/airdef replay stop")
|
||||
d.wait_ticks(20)
|
||||
return w
|
||||
|
||||
d.ctl("model-instancing", "off")
|
||||
report["windows"]["replay_before"] = replay_window("replay_before")
|
||||
d.ctl("model-instancing", "on")
|
||||
report["windows"]["replay_after"] = replay_window("replay_after")
|
||||
report["windows"]["replay_after2"] = replay_window("replay_after2")
|
||||
d.ctl("model-instancing", "off")
|
||||
report["windows"]["replay_before2"] = replay_window("replay_before2")
|
||||
d.ctl("model-instancing", "on")
|
||||
|
||||
# Seek и камера в сторону — на той же записи, instancing включён.
|
||||
d.chat("/airdef replay full")
|
||||
d.wait_ticks(REPLAY_WARM_TICKS)
|
||||
# Seek: перемотка на ±5 с, кадр после seek (движение не должно размазать модели).
|
||||
before = d.stats(raw=False).get("mod_models")
|
||||
d.replay_seek(-4)
|
||||
d.wait_ticks(10)
|
||||
report["screenshots"].append(d.screenshot("replay_seek"))
|
||||
report["checks"]["seek"] = {"before": before,
|
||||
"after": d.stats(raw=False).get("mod_models")}
|
||||
d.replay_seek(4)
|
||||
|
||||
# Камера в сторону от боя: модели за main camera обязаны рисовать тени и чужую камеру.
|
||||
d.ctl("look", str(POSE[3] + 180.0), str(POSE[4]))
|
||||
d.wait_ticks(10)
|
||||
away = d.stats(raw=False).get("mod_models")
|
||||
report["screenshots"].append(d.screenshot("replay_away"))
|
||||
report["checks"]["away_camera"] = away
|
||||
d.ctl("look", str(POSE[3]), str(POSE[4]))
|
||||
|
||||
# Reload (F3+T): атлас и меши перестраиваются, модели рисуются снова.
|
||||
d.chat("/airdef replay stop")
|
||||
d.wait_ticks(20)
|
||||
pre = d.stats(raw=False).get("mod_models")
|
||||
report["screenshots"].append(d.screenshot("pre_reload"))
|
||||
d.ctl("key", "f3", "down")
|
||||
d.ctl("key", "t", "tap")
|
||||
d.ctl("key", "f3", "up")
|
||||
d.wait_ticks(SETTLE_TICKS)
|
||||
post = d.stats(raw=False).get("mod_models")
|
||||
report["screenshots"].append(d.screenshot("post_reload"))
|
||||
report["checks"]["reload"] = {"before": pre, "after": post}
|
||||
report["windows"]["reload_warm"] = d.bench(BENCH_SECONDS["idle_warm"])
|
||||
# Статичные кадры для пиксельного паритета обоих путей (методика hd_bench:
|
||||
# движущиеся пиксели маскируются по размаху между кадрами одного прогона).
|
||||
for mode in ("off", "on"):
|
||||
d.ctl("model-instancing", mode)
|
||||
d.wait_ticks(40) # TAA сходится на статичной сцене
|
||||
for i in range(3):
|
||||
report["screenshots"].append(d.screenshot(f"stills_{mode}_{i}"))
|
||||
d.wait_ticks(5)
|
||||
finally:
|
||||
d.stop()
|
||||
# Сырые времена и счётчики худших кадров по каждому окну.
|
||||
for name, window in report["windows"].items():
|
||||
raw = {k: window.get(k) for k in ("frame_ms", "cpu_ms", "gpu_ms")}
|
||||
window["derived"] = frame_summary(raw)
|
||||
print(f"{name}: frames={window.get('frames')} "
|
||||
f"cpu p95={window['derived']['cpu_ms']['p95_ms']} "
|
||||
f"p99={window['derived']['cpu_ms']['p99_ms']}")
|
||||
out = Path(args.out).resolve()
|
||||
(out / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=1))
|
||||
print(f"отчёт: {out / 'report.json'}")
|
||||
return report
|
||||
|
||||
|
||||
def pair_rows(wa, wb):
|
||||
fa_, fb_ = wa.get("frames") or 1, wb.get("frames") or 1
|
||||
ma, mb = wa.get("mod_models") or {}, wb.get("mod_models") or {}
|
||||
rows = [
|
||||
("models/кадр", ma.get("models", 0) / fa_, mb.get("models", 0) / fb_),
|
||||
("instanced/кадр", ma.get("instanced_models", 0) / fa_, mb.get("instanced_models", 0) / fb_),
|
||||
("vertex_bytes/кадр", ma.get("vertex_bytes", 0) / fa_, mb.get("vertex_bytes", 0) / fb_),
|
||||
("motion_bytes/кадр", ma.get("motion_bytes", 0) / fa_, mb.get("motion_bytes", 0) / fb_),
|
||||
("instance_bytes/кадр", ma.get("instance_bytes", 0) / fa_, mb.get("instance_bytes", 0) / fb_),
|
||||
]
|
||||
for key in ("cpu_ms", "frame_ms", "gpu_ms"):
|
||||
for p in ("avg_ms", "p50_ms", "p95_ms", "p99_ms", "max_ms"):
|
||||
va = (wa.get("derived") or {}).get(key, {}).get(p)
|
||||
vb = (wb.get("derived") or {}).get(key, {}).get(p)
|
||||
if va is not None and vb is not None:
|
||||
rows.append((f"{key} {p}", va, vb))
|
||||
da, db = wa.get("derived") or {}, wb.get("derived") or {}
|
||||
rows.append(("кадров >25мс", da.get("frames_over_25ms", 0), db.get("frames_over_25ms", 0)))
|
||||
rows.append(("кадров >33мс", da.get("frames_over_33ms", 0), db.get("frames_over_33ms", 0)))
|
||||
return rows
|
||||
|
||||
|
||||
def print_pair(title, wa, wb):
|
||||
print(f"\n{title}")
|
||||
print(f"{'метрика':<26}{'A':>14}{'B':>14}{'B/A':>9}")
|
||||
for label, va, vb in pair_rows(wa, wb):
|
||||
ratio = f"{vb / va:.3f}" if va else "—"
|
||||
print(f"{label:<26}{va:>14.1f}{vb:>14.1f}{ratio:>9}")
|
||||
|
||||
|
||||
def compare(paths):
|
||||
reports = [json.loads(Path(p).read_text()) for p in paths]
|
||||
if len(reports) == 1:
|
||||
# Один прогон: fallback и instancing на одной и той же записи.
|
||||
r = reports[0]
|
||||
print(f"прогон {r['label']} (engine {r['git']['horizon'][:9]}): "
|
||||
f"пары окон на одной записи, один процесс")
|
||||
for before, after in (("replay_before", "replay_after"),
|
||||
("replay_before2", "replay_after2")):
|
||||
wa, wb = r["windows"].get(before), r["windows"].get(after)
|
||||
if wa and wb:
|
||||
print_pair(f"{before} (off) -> {after} (on)", wa, wb)
|
||||
return 0
|
||||
a, b = reports
|
||||
print(f"A: {a['label']} ({a['git']['horizon'][:9]}) B: {b['label']} ({b['git']['horizon'][:9]})")
|
||||
fa, fb = a.get("battle_fingerprints", {}), b.get("battle_fingerprints", {})
|
||||
match = fa == fb
|
||||
print(f"отпечаток боя: {'совпал' if match else 'НЕ совпал (фазы боя разные, как в #126)'}")
|
||||
for tick in sorted(set(fa) | set(fb), key=int):
|
||||
if fa.get(tick) != fb.get(tick):
|
||||
print(f" тик {tick}:\n A: {fa.get(tick)}\n B: {fb.get(tick)}")
|
||||
for name in a["windows"]:
|
||||
if name in b["windows"]:
|
||||
print_pair(name, a["windows"][name], b["windows"][name])
|
||||
return 0 if match else 1
|
||||
|
||||
|
||||
def stills_compare(folder):
|
||||
"""Пиксельный паритет fallback (off) и instancing (on) на статичной сцене
|
||||
одного прогона (после reload): маскировка движения по размаху кадров
|
||||
одного пути, методика tools/hd_bench.py."""
|
||||
import hd_bench as hb
|
||||
folder = Path(folder)
|
||||
a = [hb.read_png_rgb(folder / f"stills_off_{i}.png") for i in range(3)]
|
||||
b = [hb.read_png_rgb(folder / f"stills_on_{i}.png") for i in range(3)]
|
||||
w, h, _ = a[0]
|
||||
if any(x[:2] != (w, h) for x in a + b):
|
||||
die("stills: размеры кадров не совпадают")
|
||||
fa, fb = [x[2] for x in a], [x[2] for x in b]
|
||||
ra, rb = hb.motion_range(fa), hb.motion_range(fb)
|
||||
res = hb.compare_runs(fb, rb, fa, ra, w, h, hb.MOTION_LEVEL,
|
||||
diff_out=str(folder / "stills_diff.png"),
|
||||
motion_out=str(folder / "stills_motion.png"))
|
||||
print(f"статичный паритет off/on: {json.dumps(res)}")
|
||||
print(f"порог: статичных пикселей с разницей >{hb.DIFF_LEVEL}/255 — {res['pct']:.4f}% "
|
||||
f"(проверено {res['static_pct']:.1f}% кадра), mean abs diff {res['mean']:.3f}")
|
||||
return res
|
||||
|
||||
|
||||
def main():
|
||||
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
p.add_argument("--out", help="папка прогона (home, лог, скриншоты, report.json)")
|
||||
p.add_argument("--label", default="run", help="метка прогона в отчёте (before/after)")
|
||||
p.add_argument("--game", default=str(ROOT / "horizon" / "target" / "fast" / "horizon-client"),
|
||||
help="бинарник игры")
|
||||
p.add_argument("--resources", default=os.environ.get("HORIZON_RESOURCES"),
|
||||
help="подготовленные ресурсы 26.3 (или HORIZON_RESOURCES)")
|
||||
p.add_argument("--mod", help="собранный airdef.hmod (один и тот же в A/B)")
|
||||
p.add_argument("--env", action="append", default=[], metavar="КЛЮЧ=ЗНАЧЕНИЕ")
|
||||
p.add_argument("--width", type=int, default=1280)
|
||||
p.add_argument("--height", type=int, default=720)
|
||||
p.add_argument("--compare", nargs="+", metavar="REPORT",
|
||||
help="один report.json: пары off/on на одной записи; два: кросс-прогон")
|
||||
p.add_argument("--stills", metavar="DIR", help="пиксельный паритет off/on stills прогона")
|
||||
p.add_argument("--static-parity", action="store_true",
|
||||
help="чистый паритет: батареи, без боя, TAA/ветер/облака выключены")
|
||||
args = p.parse_args()
|
||||
if args.stills:
|
||||
stills_compare(args.stills)
|
||||
sys.exit(0)
|
||||
if args.compare:
|
||||
sys.exit(compare(args.compare))
|
||||
if not args.out:
|
||||
p.error("--out обязателен (или --compare)")
|
||||
if not args.resources:
|
||||
# Лаунчер готовит ресурсы сюда (macOS и Linux).
|
||||
data = (Path.home() / "Library" / "Application Support" if platform.system() == "Darwin"
|
||||
else Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share")))
|
||||
found = sorted(data.glob("horizon-launcher/versions/*/.local/horizon-client/26.3"))
|
||||
local = ROOT / "horizon" / ".local" / "horizon-client" / "26.3"
|
||||
if local.exists():
|
||||
found.append(local)
|
||||
if not found:
|
||||
die("нет ресурсов 26.3: установи Horizon лаунчером или задай --resources")
|
||||
args.resources = str(found[-1])
|
||||
if not args.mod:
|
||||
args.mod = next((str(c) for c in HMOD_CANDIDATES if c.exists()), None)
|
||||
if not args.mod:
|
||||
die("нет собранного airdef.hmod: python3 tools/airdef.py build-mod")
|
||||
if not Path(args.game).exists():
|
||||
die(f"нет бинарника {args.game}: cargo build --profile fast -p horizon-client --features mods")
|
||||
if not CTL.exists():
|
||||
die(f"нет {CTL}: cargo build --profile fast -p horizon-client --features mods")
|
||||
try:
|
||||
if args.static_parity:
|
||||
static_parity(args)
|
||||
else:
|
||||
run(args)
|
||||
except BenchError as e:
|
||||
print(f"ошибка: {e}", file=sys.stderr)
|
||||
sys.exit(2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,67 @@
|
||||
"""Тесты драйвера raid_bench (#147): перцентили как в FrameStats, худшие кадры,
|
||||
расписание боя и разбор отпечатка. Запуск: python3 -m unittest tools/test_raid_bench.py."""
|
||||
import sys
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||||
import raid_bench as rb # noqa: E402
|
||||
|
||||
|
||||
class Percentiles(unittest.TestCase):
|
||||
def test_ceil_index_like_frame_stats(self):
|
||||
# FrameStats::summary: sorted[ceil(n*p).clamp(1, n) - 1].
|
||||
v = [float(i) for i in range(1, 101)] # 1..100
|
||||
self.assertEqual(rb.percentile(v, 0.5), 50.0)
|
||||
self.assertEqual(rb.percentile(v, 0.95), 95.0)
|
||||
self.assertEqual(rb.percentile(v, 0.99), 99.0)
|
||||
self.assertEqual(rb.percentile(v, 1.0), 100.0)
|
||||
|
||||
def test_small_and_empty(self):
|
||||
self.assertIsNone(rb.percentile([], 0.95))
|
||||
self.assertEqual(rb.percentile([7.0], 0.99), 7.0)
|
||||
self.assertEqual(rb.percentile([3.0, 1.0, 2.0], 0.5), 2.0)
|
||||
# ceil(2*0.95)=2 -> второй из двух.
|
||||
self.assertEqual(rb.percentile([1.0, 9.0], 0.95), 9.0)
|
||||
|
||||
def test_unsorted_input(self):
|
||||
self.assertEqual(rb.percentile([9.0, 1.0, 5.0], 0.5), 5.0)
|
||||
|
||||
|
||||
class FrameSummary(unittest.TestCase):
|
||||
def test_worst_frame_counts(self):
|
||||
raw = {"frame_ms": [10.0, 25.0, 25.1, 33.0, 33.4, 100.0],
|
||||
"cpu_ms": [5.0, 20.0], "gpu_ms": []}
|
||||
s = rb.frame_summary(raw)
|
||||
self.assertEqual(s["frames_over_25ms"], 4) # строго больше 25
|
||||
self.assertEqual(s["frames_over_33ms"], 2) # строго больше 33
|
||||
self.assertEqual(s["frame_ms"]["max_ms"], 100.0)
|
||||
self.assertEqual(s["frame_ms"]["p99_ms"], 100.0)
|
||||
self.assertEqual(s["gpu_ms"]["n"], 0)
|
||||
self.assertIsNone(s["gpu_ms"]["p95_ms"])
|
||||
|
||||
def test_empty(self):
|
||||
s = rb.frame_summary({})
|
||||
self.assertEqual(s["frames_over_25ms"], 0)
|
||||
self.assertIsNone(s["cpu_ms"]["avg_ms"])
|
||||
|
||||
|
||||
class Battle(unittest.TestCase):
|
||||
def test_schedule_is_ordered_and_early(self):
|
||||
ticks = [t for t, _ in rb.BATTLE_SCHEDULE]
|
||||
self.assertEqual(ticks, sorted(ticks))
|
||||
self.assertLess(ticks[-1], rb.FINGERPRINT_TICKS[0])
|
||||
self.assertLess(rb.FINGERPRINT_TICKS[-1], rb.BATTLE_END)
|
||||
|
||||
def test_fingerprint_regex_reads_the_stats_line(self):
|
||||
line = ("В воздухе: 40, ракет: 12, ПВО: 14, сбито: 3, поражений: 1, "
|
||||
"разбились о препятствия: 0; удары по ПУ: пущено 0, уничтожено 0, "
|
||||
"подавлено 0, промахов 0, сбито ПВО 0; мир: Polygon")
|
||||
m = rb.STATS_RE.search(line)
|
||||
self.assertIsNotNone(m)
|
||||
self.assertEqual(m.groups(), ("40", "12", "14", "3", "1"))
|
||||
self.assertIsNone(rb.STATS_RE.search("ВОЗДУШНАЯ ТРЕВОГА"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user