Fr0zkaandClaude Opus 5.5
9d9504ae4e
The 50-90 ms UWorld::Tick spikes were the TG_EndPhysics barrier waiting for physics-scene completion while all 8 TaskGraph workers ran BackgroundHigh tile tasks. Near and horizon tile generation now run at ETaskPriority::BackgroundLow (helper lanes background); queue depth and the 8 workers are kept. FI: near set 2.11 s (10 runs), max UWorld::Tick 21 ms, max EndPhysics->PostPhysics gap 16 ms; SW: 1.32 s, 11 ms. A hard 7-task cap removed spikes but doubled settle time. World unchanged. Fast tier PASS; Linux UE host builds. R44 notes (exact passage restructuring: only a full-composer z-column SIMD kernel could plausibly reach 3x; smaller exact pieces ~1.1-1.2x each) attached. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1
424 lines
26 KiB
Python
424 lines
26 KiB
Python
#!/usr/bin/env python3
|
|
"""Run one pinned null-RHI SW/FI arrival for Linux 97."""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
from collections import Counter
|
|
import json
|
|
import re
|
|
import subprocess
|
|
import time
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parents[4]
|
|
HOST = Path("/home/jahni/VFHost")
|
|
HOST_PLUGIN_SAVED = HOST / "Plugins/VoxelForge/Saved/Linux/l97"
|
|
HOST_SAVED = HOST / "Saved/Linux/l97"
|
|
EDITOR = Path("/home/jahni/UnrealEngine/Engine/Binaries/Linux/UnrealEditor-Cmd")
|
|
OUT = ROOT / "Saved/Linux/l97/unreal-arrival"
|
|
SPAWNS_M = {
|
|
"FI": (25.8369140625, 3.19921875, -737.0),
|
|
"SW": (25.8369140625, 3.19921875, -200.0),
|
|
}
|
|
MOVE_START_S = 20.0
|
|
MOVE_DURATION_S = 12.0
|
|
EXIT_S = MOVE_START_S + MOVE_DURATION_S + 5.0
|
|
|
|
|
|
def read_events(path: Path) -> list[dict]:
|
|
events = []
|
|
if path.is_file():
|
|
for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
|
|
if line.startswith("{"):
|
|
try:
|
|
events.append(json.loads(line))
|
|
except json.JSONDecodeError:
|
|
pass
|
|
return events
|
|
|
|
|
|
def percentile(values: list[float], fraction: float) -> float | None:
|
|
if not values:
|
|
return None
|
|
ordered = sorted(values)
|
|
return ordered[min(len(ordered) - 1, int(round((len(ordered) - 1) * fraction)))]
|
|
|
|
|
|
def run(stratum: str, repeat: int, phase: str, ready_depth: int,
|
|
background_cap: int, worker_reserve: int, helper_background: int,
|
|
tile_background_low: int, tile_background_normal: int, startup_boost: int,
|
|
tick_logs: bool, insights: bool) -> dict:
|
|
label = (f"{phase}-{stratum.lower()}-rd{ready_depth}-bg{background_cap}"
|
|
f"-reserve{worker_reserve}-helperbg{helper_background}"
|
|
f"-tilelow{tile_background_low}-tilenormal{tile_background_normal}"
|
|
f"-ticklog{int(tick_logs)}"
|
|
f"-boost{startup_boost}-{repeat}")
|
|
trace = OUT / f"{label}.trace.jsonl"
|
|
utrace = OUT / f"{label}.utrace"
|
|
abslog = OUT / f"{label}.log"
|
|
stdout = OUT / f"{label}.stdout.log"
|
|
output = HOST_PLUGIN_SAVED / "output" / label
|
|
userdir = HOST_SAVED / "user" / label
|
|
zendata = HOST_SAVED / "zen" / label
|
|
ddc = HOST_SAVED / "DDC"
|
|
for directory in (OUT, output, userdir, zendata, ddc):
|
|
directory.mkdir(parents=True, exist_ok=True)
|
|
trace.unlink(missing_ok=True)
|
|
utrace.unlink(missing_ok=True)
|
|
spawn_cm = ",".join(f"{value * 100.0:.3f}" for value in SPAWNS_M[stratum])
|
|
command = [
|
|
str(EDITOR), str(HOST / "VFHost.uproject"), "-nullrhi", "-unattended",
|
|
"-nop4", "-nosplash", "-NoSound", "-corelimit=12", "-NoZenAutoLaunch",
|
|
"-notraceserver", "-nocrashreports", "-DisablePlugins=AndroidFileServer",
|
|
"-ddc=NoZenLocalFallback", f"-userdir={userdir}", f"-ZenDataPath={zendata}",
|
|
f"-LocalDataCachePath={ddc}", "-run=VoxelForgeExplore", "-seed=0",
|
|
"-archetype=TunnelNetwork", f"-slot={1 if stratum == 'FI' else 0}",
|
|
"-modes=export", "-gameconfig=1", "-coreworldtest=1",
|
|
"-ownerfourstrateplan=1", "-corevoxelsizecm=25", "-coreislandtest=0",
|
|
"-corefallbacktest=0", "-coreofftest=0", "-coreplantest=0",
|
|
"-settingsref=/Game/VoxelForge/DA_Settings.DA_Settings", "-corehybridmesher=0",
|
|
f"-out={output}", "-voxel.StreamingCoarseFirst=1",
|
|
"-voxel.StreamingDynamicNearReserve=1",
|
|
"-voxel.StreamingLegacyPendingResultCap=0",
|
|
"-voxel.CoreRegionConcurrentAdmission=1",
|
|
"-voxel.StreamingResultBacklogCap=256",
|
|
f"-voxel.StreamingReadyQueueDepth={ready_depth}",
|
|
f"-voxel.StreamingBackgroundWorkerCap={background_cap}",
|
|
f"-voxel.StreamingBackgroundWorkerReserve={worker_reserve}",
|
|
f"-voxel.CoreParallelForBackgroundPriority={helper_background}",
|
|
f"-voxel.StreamingTileBackgroundLow={tile_background_low}",
|
|
f"-voxel.StreamingTileBackgroundNormal={tile_background_normal}",
|
|
f"-voxel.TestLogTickFunctions={int(tick_logs)}",
|
|
"-voxel.CoreColumnCacheDirectMapped=0", "-voxel.CoreMCGradientMemoization=1",
|
|
"-voxel.StreamingCollisionLookahead=1",
|
|
f"-voxel.StreamingStartupApplyBoost={startup_boost}",
|
|
"-voxel.TestMove=1", "-voxel.TestMoveSpeedCmPerSecond=140.0",
|
|
f"-voxel.TestMoveStartSeconds={MOVE_START_S:.1f}",
|
|
f"-voxel.TestMoveDurationSeconds={MOVE_DURATION_S:.1f}",
|
|
f"-voxel.TestExitSeconds={EXIT_S:.1f}", "-voxel.TestMoveDirection=1,0,0",
|
|
"-voxel.StreamingSchedulerPolicy=3", "-voxel.TestExitOnSteady=0",
|
|
"-coreworldstreamtrace=1", f"-voxel.StartupTraceSpawnCm={spawn_cm}",
|
|
"-voxel.StartupTraceUntilEndPlay=1", "-voxel.StartupTraceThroughCrossing=1",
|
|
"-voxel.StartupTraceMaxTiles=16384", f"-voxel.StartupTraceFile={trace}",
|
|
f"-abslog={abslog}",
|
|
]
|
|
if insights:
|
|
command += ["-trace=cpu,task,frame", "-statnamedevents",
|
|
f"-tracefile={utrace}", "-tracefiletrunc"]
|
|
wrapped = ["taskset", "-c", "0-11", "timeout", "1740s", *command]
|
|
started = time.monotonic()
|
|
with stdout.open("w", encoding="utf-8") as stream:
|
|
result = subprocess.run(wrapped, cwd=ROOT, stdout=stream,
|
|
stderr=subprocess.STDOUT, check=False, timeout=1740)
|
|
|
|
events = read_events(trace)
|
|
worker_backend_config = next(
|
|
(e for e in events if e.get("type") == "worker_backend_config"), {})
|
|
worker_cap_readback = next(
|
|
(e for e in events if e.get("type") == "streaming_worker_cap_readback"), {})
|
|
samples = [e for e in events if e.get("type") == "streaming_sample"]
|
|
arrival = [e for e in samples if float(e.get("t_s", 0.0)) < MOVE_START_S]
|
|
full = next((e for e in arrival
|
|
if sum(e.get("desired_by_lod", [0] * 9)[:3]) > 0
|
|
and sum(e.get("settled_by_lod", [0] * 9)[:3])
|
|
>= sum(e.get("desired_by_lod", [0] * 9)[:3])), None)
|
|
first_admission = next((e for e in events if e.get("type") == "scheduler_admission"
|
|
and e.get("desired_rebuilt") == 1), None)
|
|
request_events = [e for e in events if e.get("type") == "request"]
|
|
initial_request_events = [e for e in request_events if e.get("epoch") == 0]
|
|
tile_by_ordinal = {e.get("request_ordinal"): e for e in events
|
|
if e.get("type") == "tile"}
|
|
collision_count = sum(1 for e in events if e.get("type") == "collision_ready"
|
|
and e.get("level", 9) <= 2
|
|
and full and e.get("t_s", 1e30) <= full["t_s"])
|
|
initial_tiles = [tile_by_ordinal[r.get("request_ordinal")] for r in initial_request_events
|
|
if full and r.get("t_s", 1e30) <= full["t_s"]
|
|
and r.get("request_ordinal") in tile_by_ordinal
|
|
and tile_by_ordinal[r["request_ordinal"]].get("level", 9) <= 2]
|
|
burst_start_s = float(first_admission["t_s"]) if first_admission else -1.0
|
|
burst_end_s = float(full["t_s"]) if full else -1.0
|
|
work_by_frame = {int(e.get("frame", -1)): e for e in events
|
|
if e.get("type") == "game_thread_work_frame"}
|
|
work_values = [e for e in work_by_frame.values()
|
|
if burst_start_s <= float(e.get("t_s", -1.0)) <= burst_end_s]
|
|
arrival_frame_ids = {int(e.get("frame", -1)) for e in work_values}
|
|
scheduler_by_frame = {int(e.get("frame", -1)): e for e in events
|
|
if e.get("type") == "scheduler_admission"}
|
|
scheduler_values = [e for e in events if e.get("type") == "scheduler_admission"
|
|
and burst_start_s <= float(e.get("t_s", -1.0)) <= burst_end_s]
|
|
apply_by_frame = {int(e.get("frame", -1)): e for e in events
|
|
if e.get("type") == "apply_frame"}
|
|
commandlet_tick_by_frame = {int(e.get("frame", -1)): e for e in events
|
|
if e.get("type") == "commandlet_world_tick_frame"}
|
|
garbage_collect_by_frame = {int(e.get("frame", -1)): e for e in events
|
|
if e.get("type") == "garbage_collect"}
|
|
# apply_frame N+1 records the interval containing AVoxelWorld::Tick N. Its apply_ms
|
|
# belongs to Tick N+1, so use apply_by_frame[N] for the same-tick apply breakdown.
|
|
near_intervals = [apply_by_frame[frame + 1] for frame in arrival_frame_ids
|
|
if frame + 1 in apply_by_frame]
|
|
rmc_by_frame: dict[int, dict[str, float]] = {}
|
|
for event in events:
|
|
frame = int(event.get("frame", -1))
|
|
if event.get("type") != "rmc_submit" or frame not in arrival_frame_ids:
|
|
continue
|
|
values = rmc_by_frame.setdefault(frame, {
|
|
"component_acquire_ms": 0.0,
|
|
"create_section_group_ms": 0.0,
|
|
"create_sections_ms": 0.0,
|
|
"collision_handoff_ms": 0.0,
|
|
})
|
|
for key in values:
|
|
values[key] += float(event.get(key, 0.0))
|
|
collision_completion_by_frame: dict[int, float] = {}
|
|
for event in events:
|
|
frame = int(event.get("frame", -1))
|
|
if event.get("type") == "collision_completion" and frame in arrival_frame_ids:
|
|
collision_completion_by_frame[frame] = collision_completion_by_frame.get(frame, 0.0) \
|
|
+ float(event.get("handler_ms", 0.0))
|
|
near_requests = [r for r in request_events if full and r.get("t_s", 1e30) <= full["t_s"]
|
|
and r.get("level", 9) <= 2]
|
|
initial_lod0_counts = Counter(
|
|
tuple(r.get("tile", ())) for r in near_requests if r.get("level") == 0)
|
|
repeated_lod0_keys = [
|
|
{"tile": list(tile), "requests": count}
|
|
for tile, count in sorted(initial_lod0_counts.items()) if count > 1]
|
|
initial_scheduler_frames = [e for e in events
|
|
if e.get("type") == "scheduler_admission" and full
|
|
and e.get("t_s", 1e30) <= full["t_s"]]
|
|
worst_interval = max(near_intervals, key=lambda e: float(e.get("frame_ms", 0.0)), default=None)
|
|
worst_interval_frame_id = int(worst_interval.get("frame", -1)) if worst_interval else -1
|
|
worst_work_frame_id = worst_interval_frame_id - 1
|
|
worst_work = work_by_frame.get(worst_work_frame_id, {})
|
|
worst_apply = apply_by_frame.get(worst_work_frame_id, {})
|
|
worst_scheduler = scheduler_by_frame.get(worst_work_frame_id, {})
|
|
worst_rmc = rmc_by_frame.get(worst_work_frame_id, {})
|
|
worst_collision_completion_ms = collision_completion_by_frame.get(worst_work_frame_id, 0.0)
|
|
rmc_values = [rmc_by_frame.get(frame, {}) for frame in arrival_frame_ids]
|
|
apply_values = [apply_by_frame[frame] for frame in arrival_frame_ids
|
|
if frame in apply_by_frame]
|
|
commandlet_tick_values = [commandlet_tick_by_frame[frame] for frame in arrival_frame_ids
|
|
if frame in commandlet_tick_by_frame]
|
|
garbage_collect_values = [garbage_collect_by_frame[frame] for frame in arrival_frame_ids
|
|
if frame in garbage_collect_by_frame]
|
|
|
|
def work_stat(name: str, fraction: float | None = None) -> float | None:
|
|
values = [float(e.get(name, 0.0)) for e in work_values]
|
|
return percentile(values, fraction) if fraction is not None else max(values, default=0.0)
|
|
|
|
def scheduler_stat(name: str, fraction: float | None = None) -> float | None:
|
|
values = [float(e.get(name, 0.0)) for e in scheduler_values]
|
|
return percentile(values, fraction) if fraction is not None else max(values, default=0.0)
|
|
|
|
def rmc_stat(name: str, fraction: float | None = None) -> float | None:
|
|
values = [float(e.get(name, 0.0)) for e in rmc_values]
|
|
return percentile(values, fraction) if fraction is not None else max(values, default=0.0)
|
|
|
|
def commandlet_stat(name: str, fraction: float | None = None) -> float | None:
|
|
values = [float(e.get(name, 0.0)) for e in commandlet_tick_values]
|
|
return percentile(values, fraction) if fraction is not None else max(values, default=0.0)
|
|
|
|
row = {
|
|
"label": label, "stratum": stratum, "repeat": repeat, "phase": phase,
|
|
"ready_queue_depth": ready_depth,
|
|
"requested_background_worker_cap": background_cap,
|
|
"background_worker_cap": worker_cap_readback.get(
|
|
"streaming_background_worker_cap", background_cap),
|
|
"requested_background_worker_reserve": worker_reserve,
|
|
"background_worker_reserve": worker_backend_config.get(
|
|
"streaming_background_worker_reserve", worker_cap_readback.get(
|
|
"background_worker_reserve", worker_reserve)),
|
|
"requested_core_parallel_for_background_priority": helper_background,
|
|
"core_parallel_for_background_priority": worker_backend_config.get(
|
|
"core_parallel_for_background_priority", helper_background),
|
|
"requested_streaming_tile_background_low": tile_background_low,
|
|
"streaming_tile_background_low": worker_backend_config.get(
|
|
"streaming_tile_background_low", tile_background_low),
|
|
"requested_streaming_tile_background_normal": tile_background_normal,
|
|
"streaming_tile_background_normal": worker_backend_config.get(
|
|
"streaming_tile_background_normal", tile_background_normal),
|
|
"effective_tile_slots": worker_backend_config.get("effective_tile_slots"),
|
|
"background_worker_threads": worker_backend_config.get("taskgraph_background_threads"),
|
|
"startup_apply_boost": startup_boost, "insights": insights,
|
|
"engine_tick_logs": tick_logs,
|
|
"exit_code": result.returncode,
|
|
"wall_s": round(time.monotonic() - started, 3),
|
|
"desired_t_s": next((e.get("t_s") for e in events if e.get("type") == "desired_set"), None),
|
|
"first_admission_t_s": first_admission.get("t_s") if first_admission else None,
|
|
"lod02_full_settled_t_s": full.get("t_s") if full else None,
|
|
"near_settle_from_first_admission_s": round(
|
|
float(full["t_s"]) - float(first_admission["t_s"]), 4)
|
|
if full and first_admission else None,
|
|
"desired_by_lod": full.get("desired_by_lod", [])[:3] if full else None,
|
|
"settled_by_lod": full.get("settled_by_lod", [])[:3] if full else None,
|
|
"near_admitted_tiles": len(near_requests),
|
|
"initial_lod0_admissions": sum(initial_lod0_counts.values()),
|
|
"repeated_lod0_request_keys_before_settle": repeated_lod0_keys,
|
|
"peak_result_backlog_before_settle": max(
|
|
(int(e.get("result_backlog", 0)) for e in initial_scheduler_frames), default=0),
|
|
"last_admission_t_s": max((e.get("t_s", 0.0) for e in near_requests), default=None),
|
|
"near_tile_events": len(initial_tiles),
|
|
"near_worker_seconds": round(sum(e.get("worker_task_s", 0.0) for e in initial_tiles), 4),
|
|
"near_core_seconds": round(sum(e.get("core_generate_s", 0.0) for e in initial_tiles), 4),
|
|
"collision_ready_by_settle": collision_count,
|
|
"burst_frame_count": len(near_intervals),
|
|
"burst_frame_ms_p95": round(sorted(e.get("frame_ms", 0.0) for e in near_intervals)[
|
|
min(len(near_intervals) - 1, int(.95 * (len(near_intervals) - 1)))], 3)
|
|
if near_intervals else None,
|
|
"burst_frame_ms_max": round(max((e.get("frame_ms", 0.0) for e in near_intervals), default=0.0), 3),
|
|
"burst_full_world_tick_ms_p99": round(commandlet_stat("world_tick_ms", .99) or 0.0, 3),
|
|
"burst_full_world_tick_ms_max": round(commandlet_stat("world_tick_ms") or 0.0, 3),
|
|
"burst_world_pre_actor_ms_p99": round(commandlet_stat("world_pre_actor_ms", .99) or 0.0, 3),
|
|
"burst_world_pre_actor_ms_max": round(commandlet_stat("world_pre_actor_ms") or 0.0, 3),
|
|
"burst_world_actor_phase_ms_p99": round(commandlet_stat("world_actor_phase_ms", .99) or 0.0, 3),
|
|
"burst_world_actor_phase_ms_max": round(commandlet_stat("world_actor_phase_ms") or 0.0, 3),
|
|
"burst_world_post_actor_ms_p99": round(commandlet_stat("world_post_actor_ms", .99) or 0.0, 3),
|
|
"burst_world_post_actor_ms_max": round(commandlet_stat("world_post_actor_ms") or 0.0, 3),
|
|
"burst_commandlet_readiness_check_ms_max": round(
|
|
commandlet_stat("readiness_check_ms") or 0.0, 3),
|
|
"burst_commandlet_sleep_ms_p99": round(commandlet_stat("sleep_ms", .99) or 0.0, 3),
|
|
"burst_commandlet_sleep_ms_max": round(commandlet_stat("sleep_ms") or 0.0, 3),
|
|
"burst_commandlet_loop_ms_max": round(commandlet_stat("loop_ms") or 0.0, 3),
|
|
"burst_gc_count": len(garbage_collect_values),
|
|
"burst_gc_duration_ms_max": round(max(
|
|
(float(e.get("duration_ms", 0.0)) for e in garbage_collect_values), default=0.0), 3),
|
|
"burst_max_meshes_per_frame": max((e.get("meshes_applied", 0) for e in apply_values), default=0),
|
|
"burst_max_apply_ms": round(max((e.get("apply_ms", 0.0) for e in apply_values), default=0.0), 3),
|
|
"burst_max_admit_per_frame": max((sum(e.get("submitted_by_lod", [0] * 9)[:3])
|
|
for e in scheduler_values), default=0),
|
|
"burst_frame_timing_count": len(work_values),
|
|
"burst_active_generation_workers_p95": round(work_stat("active_generation_workers", .95) or 0.0, 3),
|
|
"burst_active_generation_workers_max": round(work_stat("active_generation_workers") or 0.0, 3),
|
|
"burst_active_tile_tasks_max": round(work_stat("active_tile_tasks") or 0.0, 3),
|
|
"burst_world_tick_ms_p99": round(work_stat("tick_ms", .99) or 0.0, 3),
|
|
"burst_world_tick_ms_max": round(work_stat("tick_ms") or 0.0, 3),
|
|
"burst_update_chunks_ms_p99": round(work_stat("update_chunks_ms", .99) or 0.0, 3),
|
|
"burst_update_chunks_ms_max": round(work_stat("update_chunks_ms") or 0.0, 3),
|
|
"burst_pending_drain_ms_p99": round(work_stat("pending_drain_ms", .99) or 0.0, 3),
|
|
"burst_pending_drain_ms_max": round(work_stat("pending_drain_ms") or 0.0, 3),
|
|
"burst_post_apply_callbacks_ms_p99": round(work_stat("post_apply_callbacks_ms", .99) or 0.0, 3),
|
|
"burst_post_apply_callbacks_ms_max": round(work_stat("post_apply_callbacks_ms") or 0.0, 3),
|
|
"burst_visibility_reconcile_ms_p99": round(work_stat("visibility_reconcile_ms", .99) or 0.0, 3),
|
|
"burst_visibility_reconcile_ms_max": round(work_stat("visibility_reconcile_ms") or 0.0, 3),
|
|
"burst_collision_probe_ms_max": round(work_stat("collision_probe_ms") or 0.0, 3),
|
|
"burst_visible_apply_probe_ms_max": round(work_stat("visible_apply_probe_ms") or 0.0, 3),
|
|
"burst_lod0_ready_ms_max": round(work_stat("lod0_ready_ms") or 0.0, 3),
|
|
"burst_steady_trace_ms_max": round(work_stat("steady_trace_ms") or 0.0, 3),
|
|
"burst_modification_ms_max": round(work_stat("modification_ms") or 0.0, 3),
|
|
"burst_lifecycle_audit_ms_p99": round(work_stat("lifecycle_audit_ms", .99) or 0.0, 3),
|
|
"burst_lifecycle_audit_ms_max": round(work_stat("lifecycle_audit_ms") or 0.0, 3),
|
|
"burst_collision_gate_ms_p99": round(work_stat("collision_gate_ms", .99) or 0.0, 3),
|
|
"burst_collision_gate_ms_max": round(work_stat("collision_gate_ms") or 0.0, 3),
|
|
"burst_unload_ms_p99": round(work_stat("unload_ms", .99) or 0.0, 3),
|
|
"burst_unload_ms_max": round(work_stat("unload_ms") or 0.0, 3),
|
|
"burst_trace_json_ms_p99": round(work_stat("trace_json_ms", .99) or 0.0, 3),
|
|
"burst_trace_json_ms_max": round(work_stat("trace_json_ms") or 0.0, 3),
|
|
"burst_desired_rebuild_ms_max": round(scheduler_stat("desired_rebuild_ms") or 0.0, 3),
|
|
"burst_rmc_create_group_ms_p99": round(rmc_stat("create_section_group_ms", .99) or 0.0, 3),
|
|
"burst_rmc_create_group_ms_max": round(rmc_stat("create_section_group_ms") or 0.0, 3),
|
|
"burst_rmc_collision_handoff_ms_max": round(rmc_stat("collision_handoff_ms") or 0.0, 3),
|
|
"burst_collision_completion_ms_max": round(max(
|
|
collision_completion_by_frame.values(), default=0.0), 3),
|
|
"worst_frame_breakdown": {
|
|
"frame": worst_work_frame_id,
|
|
"world_tick_frame": worst_work_frame_id,
|
|
"frame_interval_end_frame": worst_interval_frame_id,
|
|
"frame_interval_ms": round(float(worst_interval.get("frame_ms", 0.0)), 3)
|
|
if worst_interval else None,
|
|
"apply_ms": round(float(worst_apply.get("apply_ms", 0.0)), 3)
|
|
if worst_apply else None,
|
|
"result_drain_ms": round(float(worst_apply.get("drain_ms", 0.0)), 3)
|
|
if worst_apply else None,
|
|
"outside_world_tick_ms": round(max(0.0, float(worst_interval.get("frame_ms", 0.0))
|
|
- float(worst_work.get("tick_ms", 0.0))), 3)
|
|
if worst_interval else None,
|
|
"outside_full_world_tick_ms": round(max(0.0, float(worst_interval.get("frame_ms", 0.0))
|
|
- float(commandlet_tick_by_frame.get(worst_work_frame_id, {}).get("world_tick_ms", 0.0))), 3)
|
|
if worst_interval else None,
|
|
"full_world_tick_ms": round(float(commandlet_tick_by_frame.get(
|
|
worst_work_frame_id, {}).get("world_tick_ms", 0.0)), 3),
|
|
"world_pre_actor_ms": round(float(commandlet_tick_by_frame.get(
|
|
worst_work_frame_id, {}).get("world_pre_actor_ms", 0.0)), 3),
|
|
"world_actor_phase_ms": round(float(commandlet_tick_by_frame.get(
|
|
worst_work_frame_id, {}).get("world_actor_phase_ms", 0.0)), 3),
|
|
"world_post_actor_ms": round(float(commandlet_tick_by_frame.get(
|
|
worst_work_frame_id, {}).get("world_post_actor_ms", 0.0)), 3),
|
|
"commandlet_readiness_check_ms": round(float(commandlet_tick_by_frame.get(
|
|
worst_work_frame_id, {}).get("readiness_check_ms", 0.0)), 3),
|
|
"commandlet_sleep_ms": round(float(commandlet_tick_by_frame.get(
|
|
worst_work_frame_id, {}).get("sleep_ms", 0.0)), 3),
|
|
"commandlet_loop_ms": round(float(commandlet_tick_by_frame.get(
|
|
worst_work_frame_id, {}).get("loop_ms", 0.0)), 3),
|
|
"gc_duration_ms": round(float(garbage_collect_by_frame.get(
|
|
worst_work_frame_id, {}).get("duration_ms", 0.0)), 3),
|
|
"world_tick_ms": round(float(worst_work.get("tick_ms", 0.0)), 3),
|
|
"active_generation_workers": int(worst_work.get("active_generation_workers", 0)),
|
|
"active_tile_tasks": int(worst_work.get("active_tile_tasks", 0)),
|
|
"collision_gate_ms": round(float(worst_work.get("collision_gate_ms", 0.0)), 3),
|
|
"update_chunks_ms": round(float(worst_work.get("update_chunks_ms", 0.0)), 3),
|
|
"desired_rebuild_ms": round(float(worst_scheduler.get("desired_rebuild_ms", 0.0)), 3),
|
|
"pending_drain_ms": round(float(worst_work.get("pending_drain_ms", 0.0)), 3),
|
|
"post_apply_callbacks_ms": round(float(worst_work.get("post_apply_callbacks_ms", 0.0)), 3),
|
|
"collision_probe_ms": round(float(worst_work.get("collision_probe_ms", 0.0)), 3),
|
|
"visibility_reconcile_ms": round(float(worst_work.get("visibility_reconcile_ms", 0.0)), 3),
|
|
"visible_apply_probe_ms": round(float(worst_work.get("visible_apply_probe_ms", 0.0)), 3),
|
|
"lod0_ready_ms": round(float(worst_work.get("lod0_ready_ms", 0.0)), 3),
|
|
"unload_ms": round(float(worst_work.get("unload_ms", 0.0)), 3),
|
|
"steady_trace_ms": round(float(worst_work.get("steady_trace_ms", 0.0)), 3),
|
|
"modification_ms": round(float(worst_work.get("modification_ms", 0.0)), 3),
|
|
"lifecycle_audit_ms": round(float(worst_work.get("lifecycle_audit_ms", 0.0)), 3),
|
|
"trace_json_ms": round(float(worst_work.get("trace_json_ms", 0.0)), 3),
|
|
"trace_archive_serialize_ms": round(float(
|
|
worst_work.get("trace_archive_serialize_ms", 0.0)), 3),
|
|
"collision_completion_ms": round(worst_collision_completion_ms, 3),
|
|
**{key: round(float(worst_rmc.get(key, 0.0)), 3)
|
|
for key in ("component_acquire_ms", "create_section_group_ms",
|
|
"create_sections_ms", "collision_handoff_ms")},
|
|
},
|
|
"trace": str(trace.relative_to(ROOT)), "utrace": str(utrace.relative_to(ROOT)),
|
|
"abslog": str(abslog.relative_to(ROOT)), "stdout": str(stdout.relative_to(ROOT)),
|
|
}
|
|
stdout_text = stdout.read_text(encoding="utf-8", errors="replace")
|
|
failure = re.search(r"\[VoxelForgeCoreWorldTest\] failed: ([^\r\n]+)", stdout_text)
|
|
if failure:
|
|
row["world_test_failure"] = failure.group(1)
|
|
with (OUT / "runs.jsonl").open("a", encoding="utf-8") as stream:
|
|
stream.write(json.dumps(row, sort_keys=True) + "\n")
|
|
(OUT / f"{label}.summary.json").write_text(json.dumps(row, indent=2) + "\n",
|
|
encoding="utf-8")
|
|
print("[L97UnrealArrival] " + json.dumps(row, sort_keys=True), flush=True)
|
|
if result.returncode:
|
|
raise SystemExit(f"Unreal commandlet failed: {stdout}; exit={result.returncode}")
|
|
if not full or len(arrival) < 8:
|
|
raise SystemExit(f"Unreal arrival trace incomplete: {stdout}; exit={result.returncode}")
|
|
if insights and (not utrace.is_file() or utrace.stat().st_size < 1024):
|
|
raise SystemExit(f"Unreal Insights trace missing or empty: {utrace}")
|
|
return row
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--stratum", choices=("FI", "SW"), required=True)
|
|
parser.add_argument("--repeat", type=int, default=1)
|
|
parser.add_argument("--phase", choices=("probe", "before", "after", "snapshot"), default="probe")
|
|
parser.add_argument("--ready-depth", type=int, default=64)
|
|
parser.add_argument("--background-cap", type=int, choices=(0, 1), default=1)
|
|
parser.add_argument("--worker-reserve", type=int, choices=(0, 1, 2, 3), default=0)
|
|
parser.add_argument("--helper-background", type=int, choices=(0, 1), default=1)
|
|
parser.add_argument("--tile-background-low", type=int, choices=(0, 1), default=1)
|
|
parser.add_argument("--tile-background-normal", type=int, choices=(0, 1), default=0)
|
|
parser.add_argument("--startup-boost", type=int, choices=(0, 1), default=1)
|
|
parser.add_argument("--tick-logs", action="store_true")
|
|
parser.add_argument("--insights", action="store_true")
|
|
args = parser.parse_args()
|
|
if not EDITOR.is_file():
|
|
raise SystemExit(f"missing Unreal commandlet executable: {EDITOR}")
|
|
run(args.stratum, args.repeat, args.phase, args.ready_depth,
|
|
args.background_cap, args.worker_reserve, args.helper_background,
|
|
args.tile_background_low, args.tile_background_normal, args.startup_boost,
|
|
args.tick_logs, args.insights)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|