Hello Neighbor (PPSA35154)

[HQasper]

Existing thread

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

Title

Hello Neighbor (PPSA35154)

Content version tested

01.001.000

AnyPS5 commit

main 153d5d4. Locally it also has my unmerged mouse-capture fix in MouseInput.cpp, which does not affect this title. The second run below adds the draw-input patch shown under "How it was run". v0.1.2 was also tested: see "Current blocker".

System tested

Windows 11 Pro, Ryzen 9 9950X3D, RTX 5090 32 GB (NVIDIA 617.42, Resizable BAR on), 64 GB RAM, WinLibs GCC 15.2.0

Furthest point

In game

What is shown

The menu works and save slots are found. New Game loads (slowly), and the title is playable in game: the level renders, the player can move, and the cutscenes play. Keyboard and mouse work in the menus and in game, and audio works.

Frame rate in game: 1 to 2 FPS. With APS5_PROFILE_DRAW=1 APS5_PROFILE_GPU=1:

• 1.8 FPS without the draw-input patch below. This run crashed in the second cutscene (see "Current blocker").
• 2.4 FPS with it. This run got past the second cutscene and was closed by hand.

No NotImplemented stop, no unresolved import, no missing function in any run.

Where the time goes (run with the patch, 10 s window in game, APS5_PROFILE_DRAW=1):

• Queue 0 is CPU-bound. Draw packets take 9.5 s of every 10 s: 49,474 draws at 193 µs each (295 µs without the patch). The GPU is about 10 % busy.
• readTarget takes 2.9 s per 10 s, over 89,216 resident target lookups (88,136 with a partial scissor, 1,080 full). 648 of these lookups take 1 ms or more, 1.6 s in total.
• lookup takes 3.4 s per 10 s. [rescache] shows 1,393 hits against 36,522 misses, of which 18,387 are "same key (not inserted or evicted)". [textures] stage A shows 1 fast hit against 298,729 full lookups.

The slow target lookups compare untracked memory byte by byte. At startup the log says [write-watch] Windows direct host imports use comparisons; separate shared aliases retain guest write tracking.

In the main menu without input, after about 80 s, the draw time is dominated by the same path: 1,872 lookups of 1 ms or more take 4.2 s of 7.8 s. A worker sample of that phase (APS5_SAMPLE_WORKER, steady-state difference of two snapshots) shows:

• 52.7 % self time in ucrtbase (memcmp and memcpy).
• StorageTexture::Refresh: 86 % inclusive. Inside it:
  • compareUntracked → GuestMemory::EqualsCommittedUnsynced: 27.5 %.
  • upload → captureGuestBytes → ReadCommittedUnsynced: 25 %.

The render targets appear to sit in host-imported memory, so every refresh in a new collect epoch compares the whole surface (about 33 MB for a 3840×2160 target, about 2 ms). When the GPU has written it back, the surface is also captured and uploaded again. The comparedGuestBytes memo only holds within one epoch unless the range is hinted, and the queue bumps the epoch about 40 times per frame here.

Experiments in the menu:

• APS5_NO_HOST_IMPORT=1 removes the compares (readTarget 71 ms), but the menu drops from about 10.7 to 1.5 presents/s.
• APS5_HOST_IMPORT_MIB=1024 aborts with an address-based build copies 891 MiB of 4627 registered ranges, past 64 MiB (APS5_ADDRESS_COPY_MAX_MIB).

Current blocker

1. v0.1.2: after New Game → Yes, the load stops with AGC graphics: storing storage image results pending over memory outside the write watch without the guest bytes saved before them is not implemented. This is agc: a second write-back of a storage image over unwatched memory throws ("without the guest bytes saved before them") #5711, fixed by fix(agc): save the bytes a GPU-side store writes outside the write watch #5760. Main 153d5d4 gets in game.
2. Main: one run crashed in the second cutscene with FATAL: unhandled exception 0xc0000005 on the title's main thread, rip hello-neighbor.exe+0x3418666 (the relinked eboot), read of 0x1fc3087a8c, rbx = rcx = 0. The second run, with the draw-input patch, got past that cutscene. That is one run each, so it is not shown whether the patch is related.
3. Performance: 1 to 2 FPS. The largest part is the untracked whole-surface comparison of render targets in host-imported memory on Windows, described above. I have not changed that code, since the Windows write-tracking work (fix(libc): track writes to singly mapped direct memory without faults on Windows #637, fix(libc): track writes to singly mapped direct memory without faults on Windows #5596) is in progress.

Also seen once on v0.1.2: queue 0x20 WAIT_REG_MEM at 0x1020f337a0 timed out after 1000ms (function 3 ref 0x1 ...). It was not seen on main.

How it was run

• Source: a fake package of my own copy. Extracted with PS5PKGTool's engine (SonyPackageExtraction.ExtractAsync).
• Unwrapping: eboot.bin and the 5 modules in sce_module (libc, libScePfs, libSceFontGsm, libSceJobManager, libSceNpCppWebApi) are fSELF. Unwrapped with tools/unwrap_self.py.
• Relink: relinker --windows source/eboot.bin hello-neighbor.exe. Layout as in USAGE.md, with libs/ built from the same commit.
• Settings: none needed. For the second run:

 // core/libs/prx/libSceAgcDriver/Graphics/src/Draw.cpp
+static VkMemoryPropertyFlags DrawInputMemory() {
+    static const VkMemoryPropertyFlags flags = std::getenv("APS5_DRAW_INPUT_DEVICE") != nullptr
+        ? VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
+        : VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    return flags;
+}

That function is used for the draw-input copies in CopyDrawInput and CopyZeroPaddedDrawInput. APS5_NO_INPLACE_DRAW_INPUT=1 makes InPlaceDrawInput return nothing, and with device memory the index scan reads the guest bytes instead of the copy. The same patch measured +30 % on Astro Bot at Crash Site; it is described in the Astro Bot thread #357.

Tested with AI assistance (Claude Code). I played and measured the runs on my own machine.

[HQasper]

Update: main 47a266c, after #6060

The slowness under "Current blocker" 3 was the import-compare cost tracked in #5692, which #6060 fixes. On main 47a266c (2026-10-17), the startup log now says [write-watch] host imports of write-watched memory keep the write watch: yes, and no target lookup takes 1 ms or more.

Same machine and settings as above (APS5_PROFILE_DRAW=1 APS5_PROFILE_GPU=1 APS5_GPU_TIME_BY_PASS=1). FPS is the steady-state average of the [present] lines:

Build	Main menu	In game
153d5d4	10.9 FPS	1.4 FPS
153d5d4 + draw-input patch	10.5 FPS	2.4 FPS
47a266c	23.6 FPS	3.4 FPS
47a266c + draw-input patch	30.6 FPS	5.1 FPS

• In game, old runs: New Game, walking around after the intro.
• In game, new runs: Continue, standing still on the street in front of the house at the start of Act 1, 140–150 s each.
• Input: the new runs were driven with APS5_PAD_INPUT_FILE and tools/pad_input.py.
• Crashes: neither new run crashed. The second-cutscene crash was not retested, because Continue starts after it.

Where the time goes now, in game with the patch (10 s window):

• Queue 0: 130,701 draws at 65 µs each, against 49,474 at 193 µs on 153d5d4.
• GPU: 0.83 s busy per 10 s.
• Draw time: readTarget 2.8 s (351,269 resident lookups, nearly all with a partial scissor, 13.1M pages walked), lookup 2.2 s, record 1.3 s, vertex 1.0 s.

Without the patch, prepare takes 3.0 s per 10 s; with it, 0.17 s.

Draw-input patch against 47a266c

InPlaceDrawInput gained a behindGpuWrite parameter since 153d5d4, so the patch was redone. The index scan also no longer reads guest bytes after the zero-fetch clamp has replaced the copy.

diff --git a/core/libs/prx/libSceAgcDriver/Graphics/src/Draw.cpp b/core/libs/prx/libSceAgcDriver/Graphics/src/Draw.cpp
index 5993201d6..30204cf3e 100644
--- a/core/libs/prx/libSceAgcDriver/Graphics/src/Draw.cpp
+++ b/core/libs/prx/libSceAgcDriver/Graphics/src/Draw.cpp
@@ -899,6 +899,13 @@ void reportDrawEnd(const State& state, const DrawTimer& timer, const ShaderResou
 
 }
 
+static VkMemoryPropertyFlags DrawInputMemory() {
+    static const VkMemoryPropertyFlags flags = std::getenv("APS5_DRAW_INPUT_DEVICE") != nullptr
+        ? VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
+        : VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    return flags;
+}
+
 DrawInputCopy CopyDrawInput(const Context& context, Recorder* recorder, std::uint64_t address, std::size_t bytes, std::size_t alignment, Recorder::SnapshotUse use) {
     Require(use != Recorder::SnapshotUse::Storage, "a draw input is a vertex or index buffer");
     DrawInputCopy copy;
@@ -912,7 +919,7 @@ DrawInputCopy CopyDrawInput(const Context& context, Recorder* recorder, std::uin
             return copy;
         }
     }
-    copy.buffer = std::make_shared<Buffer>(context, bytes, use == Recorder::SnapshotUse::Vertex ? VK_BUFFER_USAGE_VERTEX_BUFFER_BIT : VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
+    copy.buffer = std::make_shared<Buffer>(context, bytes, use == Recorder::SnapshotUse::Vertex ? VK_BUFFER_USAGE_VERTEX_BUFFER_BIT : VK_BUFFER_USAGE_INDEX_BUFFER_BIT, DrawInputMemory());
     GuestMemory::Read(address, copy.buffer->Bytes(), alignment);
     return copy;
 }
@@ -921,7 +928,7 @@ DrawInputCopy CopyZeroPaddedDrawInput(const Context& context, std::uint64_t addr
     Require(validBytes <= bytes, "the valid bytes of a vertex fetch exceed the fetch");
     GuestMemory::FlushGpuWrites(address, bytes);
     DrawInputCopy copy;
-    copy.buffer = std::make_shared<Buffer>(context, bytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
+    copy.buffer = std::make_shared<Buffer>(context, bytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, DrawInputMemory());
     const auto span = copy.buffer->Bytes();
     GuestMemory::Read(address, span.subspan(0, validBytes), 1);
     std::fill(span.begin() + static_cast<std::ptrdiff_t>(validBytes), span.end(), std::byte{0});
@@ -935,7 +942,8 @@ void KeepDrawInput(Recorder* recorder, std::uint64_t address, const DrawInputCop
 
 const HostImport* InPlaceDrawInput(const Context& context, std::uint64_t address, std::size_t bytes, std::size_t alignment, bool* behindGpuWrite) {
     auto* recorder = context.recorder;
-    if (recorder == nullptr || bytes == 0) return nullptr;
+    static const bool noInPlace = std::getenv("APS5_NO_INPLACE_DRAW_INPUT") != nullptr;
+    if (recorder == nullptr || bytes == 0 || noInPlace) return nullptr;
     bool behind = false;
     if (behindGpuWrite == nullptr) {
         GuestMemory::FlushGpuWrites(address, bytes);
@@ -1091,10 +1099,12 @@ DrawInputs prepareDrawInputs(const Context& context, const State& state, const P
         if (import == nullptr) copy = CopyDrawInput(context, context.recorder, draw.indexAddress, static_cast<std::size_t>(indexBytes), draw.indexSize, use);
         else GuestMemory::CheckRange(reinterpret_cast<const void*>(draw.indexAddress), static_cast<std::size_t>(indexBytes), draw.indexSize);
         std::optional<std::uint32_t> highest;
+        bool indicesInGuest = (DrawInputMemory() & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0;
         if (import != nullptr) {
             highest = InPlaceIndexRange(*context.recorder, draw.indexAddress, static_cast<std::size_t>(indexBytes), draw.indexSize, skipRestart).highest;
         } else if (!copy.reused) {
-            highest = HighestDrawIndex(copy.buffer->Bytes().first(static_cast<std::size_t>(indexBytes)), draw.indexSize, skipRestart);
+            const auto bytes = indicesInGuest ? std::span<const std::byte>(reinterpret_cast<const std::byte*>(draw.indexAddress), static_cast<std::size_t>(indexBytes)) : copy.buffer->Bytes().first(static_cast<std::size_t>(indexBytes));
+            highest = HighestDrawIndex(bytes, draw.indexSize, skipRestart);
             KeepDrawInput(context.recorder, draw.indexAddress, copy, use, skipRestart ? (highest ? *highest + 1u : 0u) : highest.value_or(0u));
         } else if (!skipRestart) {
             highest = copy.derived;
@@ -1115,6 +1125,7 @@ DrawInputs prepareDrawInputs(const Context& context, const State& state, const P
                 GuestMemory::Read(draw.indexAddress, bytes, draw.indexSize);
                 highest = ClampDrawIndices(bytes, draw.indexSize, skipRestart, limit);
                 import = nullptr;
+                indicesInGuest = false;
                 copy = DrawInputCopy{};
                 copy.buffer = std::move(clamped);
                 if (!highest) {
@@ -1127,7 +1138,7 @@ DrawInputs prepareDrawInputs(const Context& context, const State& state, const P
         Require(!fanGeometry || !state.primitiveRestart || *highest != (draw.indexSize == 2 ? 0xffffu : 0xffffffffu), "primitive restart in a triangle fan geometry draw is unsupported");
         inputs.maxIndex = *highest;
         if (skipRestart && state.stages.mesh && state.stages.mesh->inputPrimitive == 6) {
-            const auto indexSpan = import != nullptr ? std::span<const std::byte>(reinterpret_cast<const std::byte*>(draw.indexAddress), static_cast<std::size_t>(indexBytes)) : copy.buffer->Bytes().first(static_cast<std::size_t>(indexBytes));
+            const auto indexSpan = import != nullptr || indicesInGuest ? std::span<const std::byte>(reinterpret_cast<const std::byte*>(draw.indexAddress), static_cast<std::size_t>(indexBytes)) : copy.buffer->Bytes().first(static_cast<std::size_t>(indexBytes));
             inputs.restartTable = MeshRestartTable(indexSpan, draw.indexSize);
         }
         if (import != nullptr) {

Done with AI assistance. The runs ran on my own machine.

[HQasper]

Update 2: imports under 1 MiB and #6678

Method:

• Same machine as above, no profiler.
• Continue to the street in front of the house at the start of Act 1, driven with APS5_PAD_INPUT_FILE.
• 60 s of frames from the window-title counter, starting 120 s after Continue.

main 47a266c	In game
as is	3.6 FPS
+ draw-input patch	5.8 FPS
+ #6455 + #6678	8.1 FPS
+ #6455 + #6678 + draw-input patch	9.3 FPS

What #6678 fixes here:

• After perf(agc): keep Windows host imports of write-watched private memory watched #6060, Windows imports under 1 MiB stay compared.
• This title's DCC key ranges are among those imports, so no DCC key proof could be reused. Every draw scanned the keys again: about 570,000 scans (78 GiB) per 10 s.
• perf(agc): settle Windows imports under 1 MiB without waiting #6678 settles those imports without waiting. I posted the details there.

Missing functions:

• tools/import_audit.py on 47a266c found 0 absent imports and 53 stubs.
• The stubs are mostly AGC markers, capture and shader instrumentation, plus VoiceQoS, AudioIn, GameLiveStreaming, WebBrowserDialog, select and sceCoredumpSetUserDataType.
• None of the stubs were called in these runs.

Where the time goes now (sampled on main with the settle floor lowered to 64 KiB locally, which gives the same proofs as #6678, plus the draw-input patch; 9.8 FPS while sampled):

• The draw committer thread waits for work about 15 % of the time.
• The rest is spread out: recordDraw 33 %, ShaderResources::PrepareDrawBindings 22 %, write-watch collects (GetWriteWatch) 13 %, prepareDrawInputs 12 %.
• No single step dominates any more.

Done with AI assistance. The runs ran on my own machine.