Minecraft Preview (PPSA19639)

[ddrsilva]

Minecraft Preview (PPSA19639)

Tested

• Title: Minecraft Preview 1.21.40.22 (PPSA19639), RenderDragon renderer
• Host: Windows 11 Pro (build 26200), Intel i9-9900K (8 cores / 16 threads), NVIDIA RTX 2080 Ti
• Build: main at d4c196c2 plus a local patch (below), WinLibs MinGW-w64 GCC 15.2, Ninja, Release

Status

• Boots to the title screen at 60 fps. Creating a world, loading a world, walking around, and Save & Quit all work, and the save shows up in the world list afterwards.
• In-world at the game's default render distance (36 chunks, gfx_viewdistance:576), the game issues 2,000–4,000 draws per frame.
  • On main: about 7 fps, because the queue worker spends 76–80 µs of CPU per draw.
  • With the patch: 31 fps (30.8–31.7 over two runs, ~3,970 draws per frame). Lower render distances reach the 60 fps cap.
• Keyboard input works. Audio works.

Stops on main, in the order they are hit

Each one is fixed or worked around in my patch. Some are stubs and not ready to merge as they are.

1. Network. sceHttp2SendRequestAsync must return 0 (the failure belongs at WaitAsync). With a synchronous ERROR_NETWORK, the game throws bad_weak_ptr on its "REST Thread".
2. NetCtl / NpManager callbacks. NetCtl must store the callback argument and deliver the state from sceNetCtlCheckCallback. NpManager must register the state callbacks and deliver SIGNED_OUT once from sceNpCheckCallback.
3. SaveData title search. sceSaveDataDirNameSearch with a title_id other than the running title (the game searches PPSA17221) must return 0 hits.
4. No end-of-pipe interrupt. Minecraft's streams never set INT_SEL. Its "Rendering Pool" thread waits on the graphics event queue (filter -14) for a submission to retire, and waits forever. The real driver ends every submission with an EOP interrupt, so the patch fires an implicit one after each submission whose stream had none, ordered after the recorded work.
5. sync() aborts. libkernel sync() throws on volumes that are not ready or not accessible (it needs admin otherwise). It should skip them.
6. Socket addresses. sockaddr parsing must ignore sa_len, as BSD does. RakNet leaves it at 0, every bind failed, and the RakNet server locator crashed on a null peer. setsockopt must also accept the BSD options Winsock lacks, plus SO_NBIO (0x1200).
7. Missing libraries. Stub libSceTextToSpeech2 and libSceNpAuthAuthorizedAppDialog. Stub the sceKernelAdd/DeleteRead/WriteEvent and WriteThrottlingStatus exports.
8. Thread stack size. pthread_attr_setstacksize below 16 KiB must return EINVAL.
9. Entering a world.
   • sceNpAuthCreateRequest / GetIdTokenV3 / WaitAsync were NotImplemented. They now return signed-out like their siblings.
   • sceImeOpen now returns an error instead of throwing.
   • sceSaveDataMount3 with an invalid directory name now returns SAVE_DATA_ERROR_PARAMETER instead of aborting.
   • EVENT_WRITE type 1 with 2 dwords (stream-out stats, no address) is accepted as a no-op. Before, it was an intermittent abort on the GPU thread.
10. "Out of storage space" dialogs and failed saves. The game calls sceSaveDataDirNameSearch(key = BLOCKS) and sums infos[i].blocks over all saves against a budget.
    • main never filled infos, and getMountInfo reported 32,768 blocks for every save.
    • The patch fills the 48-byte SaveDataSearchInfo records and remembers the allocation from mount3. It reports used blocks as the sum of file sizes in 32 KiB blocks.
11. sceKernelFsync on directories. It must return 0; LevelDB fsyncs directories.

The performance work (the improvement I'd most like upstream)

At 36 chunks the bottleneck is the single queue-0 worker thread. The GPU is mostly idle. Chunk draws are thousands of nearly identical draws: between draws, only a few shader user-data words change (registers 0x24, 0x8c, 0x90, 0x92, pointers into a per-draw constant ring) plus the index range.

Single-thread work: 76–80 µs down to ~36 µs per draw

• A per-thread block allocator for the worker. On mingw, operator new/delete went through a locked heap at 80–100 ns per call, a few hundred times per draw. The operators must be excluded from the DLL exports, or libSceAgc.prx fails to load (error 127).
• Index and vertex buffers are bound straight from host imports instead of copied. That was 3.3 GB of copies every 10 s.
• The draw decode is memoized on register-state generations, with user-data registers treated as volatile.
• A "repeat draw" path: same register state and same compiled stages means the pipeline, framebuffer and resource template are reused.
• Adaptive bypass of lookups that never hit for this workload (the draw-entry cache and constant-snapshot reuse).

Parallel draw preparation ("draw runs"): 7 fps up to 31 fps

• After a repeat-eligible draw, the worker scans ahead over packets that only change volatile registers and turns each following draw into a job.
• Helper threads prepare the jobs: decode, shader capture/recompile, and descriptor sets with constant snapshots.
• The worker still executes every packet in order. At each draw it commits the prepared job under the GPU mutex, after re-checking everything the job relied on: the repeat token, imports, pending GPU writes, unit shadows, and attachments. Any job that can't be proved is drawn the normal way.

What made the helpers scale, measured on the scene above:

Change	Effect
Import-table snapshot per run (no mutex per lookup; the commit proves it unchanged without a lock)	helper −7 µs/draw
Constant snapshots bump-allocated from 1 MiB chunks instead of one pooled Buffer each	helper −3.7 µs/draw
Freed descriptor sets recycled per layout instead of vkFree + vkAllocate under one mutex	helper −2.8 µs/draw
Allocator returns blocks across threads in batches (helpers allocate, worker frees)	helper operator new was 21% of helper time
Recompile result memo skipped on helper threads when it never hits (0% hits for chunk draws)	helper −6 µs/draw
Lock-free (seqlock) fast paths for PendingStorageOverlaps and AnyShadowedOverlaps	worker commit 6.7 → 4.5 µs
5 helpers that sleep, instead of 6 that spin between runs (spinning took cores from the game's own threads)	28 → 31 fps

Final per-draw cost: helpers ~17–21 µs per job, worker ~2.5–3.3 µs per commit, ~8 µs wall time per draw.

A trap I hit: the result memo must not be bypassed on the worker or other threads. Later caches recognise a result by the identity of the memo's shared object, and with a fresh object every call, world loading crawled at 3–4 fps.

Open problems on main (not fixed in the patch)

1. The guest-allocation registry lock (libc GuestAllocations) stalls the GPU thread and the game. This is the most important one for normal play, because moving around streams chunks constantly.
   • Every GuestAllocationsAcquire copies the shared_ptr of every range (4,000–5,000 here) under the registry mutex, and pins every range until the lease is dropped.
   • Mutations hold the same mutex while mapping. While a world loads or chunks stream in, DoMapDirect held it for up to 50–60 ms at a time, and the registry was locked about 9 s out of every 10 s.
   • Results: random stretches of 3–4 fps lasting minutes, one 35 s freeze (the queue worker blocked in GuestAllocationsAcquire for the whole time), and the game's own sceKernelVirtualQuery calls waiting about 31 ms each.
   • The registry also grows without bound: about 9 ranges per second, ~4,000 → 5,000 in two minutes. Every mutation copies the whole map.
   • Directions: pin only the ranges a piece of work uses, publish immutable snapshots readers can take without the lock, and do the host mapping calls outside the lock.
2. sceKernelVirtualQuery builds a full lease for every call and then scans it linearly. A locked lookup by address would do.
3. Swapchain: minImageCount (2 on NVIDIA) in FIFO mode is double-buffered vsync. The patch uses minImageCount + 1 (APS5_SWAPCHAIN_IMAGES, plus an opt-in APS5_PRESENT_MODE).
4. One queue worker per queue is the ceiling for draw-heavy titles. Even after the single-thread work, ~36 µs per draw means about 7 fps at 4,000 draws. Some form of parallel draw preparation seems unavoidable.

Notes

• Every optimization has an off switch for A/B testing, for example APS5_NO_WORKER_ALLOCATOR, APS5_NO_DIRECT_DRAW_INPUTS, APS5_NO_DECODE_MEMO, APS5_NO_DRAW_REPEAT, APS5_DRAW_HELPERS=0, APS5_NO_SNAPSHOT_ARENA, APS5_NO_DESCRIPTOR_RECYCLE and APS5_NO_MEMO_BYPASS. APS5_PERF=1 prints draws per frame, fps, the worker's CPU share and per-draw cost every 10 s.
• How it was measured:
  • A saved world loaded on each run, with the camera turned to the horizon.
  • The world was set to Peaceful and noon with the daylight cycle frozen: zombies at night otherwise kill the player and the scene changes.
  • Run-to-run noise is about ±1 fps.
• The investigation and patch were done with AI assistance (Claude). The patch is one diff against d4c196c2, about 57 files. I can split it into PRs (network/savedata stubs, the EOP interrupt, the single-thread work, the parallel draw runs) if that helps.

Stack tried

main at d4c196c2 plus the local patch. No other branches.

Patch (applies to d4c196c2 with git apply): minecraft-overlay-latest.patch