92c058f606
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>
723 lines
34 KiB
Python
723 lines
34 KiB
Python
#!/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()
|