Age of Mythology: Retold (PPSA18653)

[XatiX]

Existing thread

• I searched this category for the title ID and no thread exists for this title on any platform.

Title

Age of Mythology: Retold (PPSA18653)

Content version tested

01.043.000 (with DLC)

AnyPS5 commit

Updated 2026-11-04. A local stack on main 1e658521a0, made of these pull requests and one local copy of #7508, in this order:

Change	Pull request	Effect on this title
GPU-side indirect draw records copied when the packet is processed	#15327	removes the GPU hang (blocker 1)
APS5_FAIL_UNKNOWN_CLOCKS=1 makes clock ids 16 to 31 fail with EINVAL	#15656	removes the clock 20 abort (blocker 2)
image tables reused when some entries are storage-viewed	#15563 (first version)	speed
relocatable variant runs built from the reads	same change as #7508; a local copy was used	speed
a reused table keeps its cache entries while nothing was erased	#15659	speed
image-table entries filled with ones map to no record	#15611	removes the image-table faults on the title screen
unwritten image table snapshots read through a pointer are reused	#15655	speed

Plain main still hangs the GPU (blocker 1).

System tested

Windows 11 Pro 26300, Ryzen 7 9800X3D, NVIDIA GeForce RTX 5080 (driver 617.42), MinGW-w64 GCC, Release.

Furthest point

Title screen ("Press to continue"), with no input sent

What is shown

The title screen renders correctly at 3840x2160, with music, at about 0.48 FPS (2.1 s per frame). Earlier runs with only blockers 1 and 2 fixed reached the first-run preferences screen ("Welcome to Age of Mythology: Retold") with music, at about 0.14 FPS. At these speeds the first frame stays black for several seconds before the screen appears. Input, menus and play are not tested yet.

Current blocker

1. GPU hang, fixed by fix(agc): copy GPU-side indirect draw records when the packet is processed #15327 (open).

   • The hanging command is a vkCmdDrawIndirect. VK_LAYER_LUNARG_crash_diagnostic found it, and Nsight Aftermath reports the device as hung with no active warps.
   • AnyPS5 read GPU-side indirect draw records in place when the batch ran. The game's "begin command context" function (game.exe 0x2175070) resets the per-frame pool that holds the records, filling it with 0xEE. It does this after submitting the command buffer and before the GPU runs it, without waiting on a label, so the draw asked for 0xEEEEEEEE vertices and instances.
   • A probe that copied the frame slot and the record on the GPU at the draw showed the record already 0xEE while the frame's RELEASE_MEM label had not yet run, so the label path is not involved.
   • APS5_NO_HOST_IMPORT=1 or APS5_NO_GPU_INDIRECT_DRAW=1 also avoid the hang on main.

2. clock_gettime: unsupported clock_id 20, then abort() at about 50 s, fixed with APS5_FAIL_UNKNOWN_CLOCKS=1 (feat(libkernel): fail unknown clock ids 16 to 31 with EINVAL on request #15656, open).

   • The caller is Party.prx (PlayFab Party) at 0x29be26. It builds a timestamp from clock 20 and falls back to gettimeofday, then time(0), when the call fails; a sibling function uses clock 0.
   • No public source names id 20, so by default it keeps throwing. What a PS5 returns for ids 16 to 20 is not measured.

3. Speed: the title runs on one CPU-bound worker thread. The title screen issues about 650 draws per frame, and each binds a bindless image table of about 14,200 entries that the game rewrites in part once per frame.

   Before perf(agc): reuse image tables that hold storage-viewed entries #15563, every draw resolved every table entry: 5.3 s per frame in Resources.Complete, of which worker sampling put 56 % in ShaderResources::resolveImageTables and 35 % in the per-entry texture lookup. The existing table reuse never applied (0 reused), because about 1.6 % of each table's entries (about 229) are surfaces in host-imported memory, sampled as views of their storage images, and one such entry kept the whole table from being reused. The welcome screen then had about 730 draws per frame, with the GPU busy about 330 ms per frame.

   Median frame time on the title or welcome screen, idle, from traces with APS5_TRACE_SECONDS=20:60 (one run each, measured in this order):

Stack	Frame p50
Blockers 1 and 2 fixed	7965 ms
+ #15563	3178 ms
+ relocatable variant runs (#7508)	2543 ms
+ #15659 (and #15611, which does not change speed)	2321 ms
+ #15655	2101 ms

Where a frame goes now:

• CPU, about 2.6 ms per draw:

  • resource build (Graphics::Draw) about 1.5 ms;
  • shader result recompile about 0.5 ms (about 0.8 ms with the default APS5_RESULT_MEMO_MB=256; 1024 helps about 7%);
  • key lookup and validation about 0.4 ms;
  • memory capture about 0.15 ms.

• GPU, about 225 ms per frame (APS5_PROFILE_GPU). Two small pixel shaders take about 120 ms of it:

  • 0x3f8610600: 61 instructions, 1 sample, about 135 draws per frame at about 0.48 ms each;
  • 0x3f8648000: 120 instructions, 3 samples, about 73 draws per frame at about 0.74 ms each.

  Both sample through the table with a waterfall loop over a per-pixel index. Uploads and copies are a few ms.

• The draw cache never hits:

  • Each entry holds the table capture, about 2 MB, so 256 MiB keeps only about 130 entries.
  • With 4 GiB, entries are found but still miss. The vertex stage's captured table pages differ between frames, and per-frame buffer V# bases move (the case perf(agc): reuse cached draw stages when only buffer base addresses moved #5609 targets).

4. Image-table faults on the title screen (deferred write-back failed ... words ffffffff ... invalid format, 60 to 78 lines per run), fixed by fix(shader): map image-table entries filled with ones to no record #15611. Three or four pixel shaders select table entries filled with 0xFFFFFFFF, and the picture is the same with and without the fix.

Next steps

• 30 FPS needs about 33 ms per frame, so a draw whose table did not change has to cost close to nothing on the CPU and the GPU.
• On the CPU, the next targets are resource building over the reused table and draw-cache entries that share the table capture instead of copying it.
• On the GPU, the cost is the per-sample table lookup. perf(agc): GPU descriptor heap on VK_EXT_descriptor_heap (APS5_GPU_HEAP) #9508 with feat(agc): look up table images at run time through a device image table on the GPU heap (APS5_GPU_PATH) #7642 (GPU descriptor heap with device table lookup) and perf(agc): put the shader data, image table maps and BDA tables in resizable BAR memory #15570 (table maps in faster memory) aim there. They are not tested on this title yet, because perf(agc): GPU descriptor heap on VK_EXT_descriptor_heap (APS5_GPU_HEAP) #9508 needs newer Vulkan headers than the repository's.
• Get past the title screen and measure play.

How it was run

The dump's contents go into app0\. eboot.bin, sce_module\*.prx (5) and ext_module\*.prx (6: Party, PlayFabCore.PS, PlayFabServices.PS, libHttpClient, libfmod, libfmodstudio) are unwrapped with tools/unwrap_self.py. The backport's fakelib\libSceAgc.sprx is left out.

relinker.exe app0\eboot.bin game.exe --windows --registry --sce-module-path app0 --module-dir ext_module

tools/import_audit.py --libs libs --modules app0/ext_module --modules app0/sce_module *.registry.json is clean. APS5_FAIL_UNKNOWN_CLOCKS=1 is needed with #15656 to get past blocker 2.

Tools that helped: APS5_PROFILE_DRAW, APS5_PROFILE_GPU with APS5_PROFILE_GPU_DRAWS, APS5_SAMPLE_WORKER with tools/symbolize_samples.py, and APS5_DUMP_SHADERS with APS5_DUMP_PREPARE_INPUTS and agc_shader_replay --asm to disassemble a shader. For the hang: VK_LAYER_LUNARG_crash_diagnostic (its dump goes to %USERPROFILE%\cdl), Nsight Aftermath (nv-aftermath-control --mode Global elevated, nv-aftermath-monitor, nv-aftermath-format -j), APS5_TRACE_INDIRECT_DRAWS, APS5_CHECK_INDIRECT_ARGS, APS5_HANG_DUMP_SECS, and APS5_TRACE_CALLS=all (needs a conversion with --trace-imports).

AI-assisted testing and report: yes (Claude Code).