Files
airdef/tools/raid_bench.py
T
chexit 92c058f606 Sim::step phase timing and the CPU-profile bench driver (#147 step 3.1)
Mod side: Sim::step times plan_step, adapt, step_drones, step_moves,
update_sight, step_sams and record, plus the whole step and its untimed
remainder, through sim::profile. The simulation stays SDK-independent (also
built as airdef-core): the adapter installs the host monotonic clock
(game.monotonic-nanos) in init, native tests use std::time::Instant. The
counters are fixed-size, per-thread, read no randomness and change no
decision; /airdef stats reports them as PROFILE chat lines, reset per world.

Driver: raid_bench gains --scheduler in-frame|server-thread (the two
single-player paths, measured separately), HORIZON_MOD_CPU_PROFILE=1, the
per-tick mod-path spans joined to the frame trace (per-frame totals, >25/33 ms
counts, what the worst CPU frames carry), and the mod phase profile read at
idle and battle end with the battle delta. report.json carries mod_cpu,
mod_cpu_ticks, mod_phases_* and the derived correlation. Tests for the new
helpers.

Engine gitlink: mod-path CPU spans + game.monotonic-nanos (API level 32).

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 12:29:22 +03:00

723 lines
34 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/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+)")
# The mod's per-phase CPU profile lines (#147 step 3.1): `PROFILE key=value ...`.
PROFILE_RE = re.compile(r"(\w+)=(-?\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 parse_profile(lines):
"""Merge the mod's `PROFILE key=value` chat lines into one dict (#147 3.1)."""
out = {}
for line in lines:
if "PROFILE" not in line:
continue
for key, val in PROFILE_RE.findall(line):
out[key] = float(val) if "." in val else int(val)
return out
def profile_delta(base, battle):
"""Battle phase work = cumulative-at-battle-end minus cumulative-at-idle.
Totals and the step count subtract; per-step maxima are kept from the battle
reading (the peak almost always falls in the battle, not the idle warm-up).
"""
if not base or not battle:
return None
out = {}
for key, val in battle.items():
if key.endswith("_max_ms"):
out[key] = val
elif key in base:
out[key] = round(val - base[key], 3) if isinstance(val, float) else val - base[key]
else:
out[key] = val
return out
# The mod-path spans, in the order the engine records them per tick.
MOD_SPANS = ("ground_ms", "world_ms", "snapshot_ms", "wasm_ms", "models_ms", "output_ms", "total_ms")
def mod_cpu_frames(window):
"""Join the per-tick mod-path spans to the frame trace (#147 step 3.1).
A frame may run several game ticks; their spans sum into that frame's index
(`frame` in each record is the index into the raw frame arrays). Returns the
per-frame mod-path total's percentiles, the >25/33 ms frame counts, and what
the worst CPU frames carry — so the mod peaks can be checked against the
frame-time peaks. None when no spans were recorded.
"""
ticks = window.get("mod_cpu_ticks") or []
frames = window.get("frame_ms") or []
if not ticks or not frames:
return None
n = len(frames)
per = [[0.0] * len(MOD_SPANS) for _ in range(n)]
seen = set()
for t in ticks:
f = int(t.get("frame", 0))
if 0 <= f < n:
seen.add(f)
for j, key in enumerate(MOD_SPANS):
per[f][j] += t.get(key, 0.0)
total = [row[MOD_SPANS.index("total_ms")] for row in per]
wasm = [row[MOD_SPANS.index("wasm_ms")] for row in per]
world = [row[MOD_SPANS.index("world_ms")] for row in per]
models = [row[MOD_SPANS.index("models_ms")] for row in per]
out = {
"ticks": len(ticks),
"frames_with_ticks": len(seen),
"per_frame_total_ms": {
"p50_ms": percentile(total, 0.5),
"p95_ms": percentile(total, 0.95),
"p99_ms": percentile(total, 0.99),
"max_ms": max(total),
},
"frames_mod_over_25ms": sum(1 for v in total if v > 25.0),
"frames_mod_over_33ms": sum(1 for v in total if v > 33.0),
}
cpu = window.get("cpu_ms") or []
if cpu:
# The worst 1% of frames by CPU time: how much mod-path work they carry.
order = sorted(range(len(cpu)), key=lambda i: cpu[i], reverse=True)
worst = order[:max(1, len(order) // 100)]
m = len(worst)
out["worst_cpu_frames"] = {
"count": m,
"avg_cpu_ms": sum(cpu[i] for i in worst) / m,
"avg_mod_total_ms": sum(total[i] for i in worst if i < n) / m,
"avg_wasm_ms": sum(wasm[i] for i in worst if i < n) / m,
"avg_world_ms": sum(world[i] for i in worst if i < n) / m,
"avg_models_ms": sum(models[i] for i in worst if i < n) / m,
"with_mod_tick": sum(1 for i in worst if i in seen),
}
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,
scheduler="in-frame"):
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
# #147 step 3.1: the two single-player schedulers, measured separately.
self.scheduler = scheduler
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_MOD_CPU_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",
"--width", str(self.width), "--height", str(self.height),
"--game", str(self.game), "--resources", str(self.resources)]
# in-frame: the window ticks the world itself; server-thread (the default
# players run): the integrated server on its own thread, the window a client.
if self.scheduler == "in-frame":
cmd.append("--in-frame")
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 mod_profile(self):
"""The mod's cumulative per-phase CPU profile (`/airdef stats` chat lines)."""
self.chat("/airdef stats")
time.sleep(0.3)
return parse_profile(self.chat_log(20))
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,
scheduler=args.scheduler)
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,
scheduler=args.scheduler)
d.prepare()
d.launch()
report = {
"issue": 147,
"step": "3.1",
"scheduler": args.scheduler,
"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"),
}
# Cumulative mod phase profile before the battle (the idle baseline).
report["mod_phases_idle"] = d.mod_profile()
# Бой по фиксированным тикам; окно замера в середине боя (в потоке).
fingerprints = d.battle(report)
report["battle_fingerprints"] = fingerprints
# Cumulative mod phase profile after the battle; the delta isolates it.
report["mod_phases_battle"] = d.mod_profile()
report["mod_phases_battle_delta"] = profile_delta(
report["mod_phases_idle"], report["mod_phases_battle"])
# Та же запись в обоих путях, один процесс: бой записан один раз, 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)
window["derived"]["mod_cpu_frames"] = mod_cpu_frames(window)
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("--scheduler", choices=("in-frame", "server-thread"), default="in-frame",
help="single-player scheduler: in-frame (window ticks the world) или "
"server-thread (интегрированный сервер на своём потоке, путь по умолчанию)")
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()