631 Commits

All Branches

Search

Author	SHA1	Message	Date
Mathias	b307b2f8fd	fix(json): iterate sce::Json::Array values (#1087)	2026-10-12 19:32:19 +03:00
Foued Attar	28c922c7a5	Fix/des render thread regression (#1086) ... * perf(images): download dropped images through the tiler ring PublishBeforeDrop moves an image's GPU contents into guest memory before an overlap drops it. Demon's Souls drops a few full-screen targets every frame, and each tiled download allocated a pooled scratch the size of the image; past the pool budget the completion callback freed it again. Creating and freeing those buffers took about 11 % of the render thread. The download now takes its linear copy from the same ring the uploads use, with the copy regions moved to the ring offset. A download that needs the BGRA16 swap keeps its own scratch, so the swap output from the ring cannot wrap onto it. Ring downloads hold no pooled scratch, so a collection under pressure no longer has to end the tick to bound them; the pressure test now checks that instead. * revert(gpu): remove unified guest buffers and mapped readbacks #1058 placed guest buffers in device-local, host-visible memory and read them back through the mapping; its author reverted it the same day in #1065, and #926 brought it back. The memory-type check also matches a discrete GPU with resizable BAR, where the CPU reads that memory uncached across the bus: on an RTX 5070 Demon's Souls' render thread went from 0.036 ms to 0.33 ms per readback and from 11.6 ms to 19.4 ms of work per frame, and a Ryzen 7 5800X3D dropped to 25-30 FPS. Guest buffers are device-local again and every readback copies, as before #1058. SHARPEMU_UNIFIED_BUFFERS and SHARPEMU_MAPPED_READBACK_KB are gone, with the two mapped-readback tests and the two shared-page tests that only ran on mapped buffers. Shared page shadows still adopt pages from downloads; pulling shader bytes from a GPU copy needs a mapping and no longer happens.	2026-10-12 19:28:37 +03:00
Mathias	ae406fc049	Run and pack ZArchive (.zar) game archives (#1085) ... * feat: run and pack ZArchive (.zar) game archives * feat(gui): optionally delete the game folder after packing a .zar * feat(gui): name a packed .zar after the game version * feat(gui): explain packing in the .zar dialog * feat(gui): name a packed .zar by title id and version	2026-10-12 19:26:51 +03:00
Heazer13	61697fa461	[GUI] French: add missing Library.View strings and polish translation (#1056) ... * [GUI] French: add missing Library.View strings and polish translation - Add Library.View.Grid / Library.View.Carousel (were missing in fr.json) - Translate Bink playback options Host/Guest and make the description match the displayed option names - Use infinitive form for RenderDoc and crash dump descriptions, like the other options - Use typographic apostrophes consistently * [GUI] French: reword the Bink Ignorer description Ignorer permet de passer les vidéos Bink reads more naturally than Ignorer saute les vidéos Bink. --------- Co-authored-by: foufouadi <attar.foued@gmail.com>	2026-10-12 15:39:31 +02:00
Foued Attar	c7bbb09311	Ghost of Yōtei and Tsushima in game: rendering, GPU/CPU memory coherence, tessellation ... * [ShaderCompiler] Pass guest LDS size to SPIR-V compilation * [SpirvTranslator] Synchronize wave64 half masks through LDS exchange * [Fiber] Avoid formatting unused names and disabled traces * [Shader] Build materialization cache ranges without temporary copies * [ShaderCompiler] Intern scalar graphs without string keys or hit allocations * [Media] Vectorize movie YUV conversion without changing pixels * [Shader] Reuse scratch storage for resource read recording * [Tests] Initialize presenter state for GPU binding validation * [Vulkan] Keep temporary descriptor writes off the managed heap * [GPU] Reuse bounded descriptor preparation scratch arrays * [ShaderCompiler] Persist versioned scalar analysis across launches * [GPU] Remove duplicated image layouts from texture bindings * [ShaderCompiler] Bind cached graph payloads to their input keys * [Vulkan] Load content-addressed driver cache shards on demand * [Tests] Keep presenter allocation fixture independent of diagnostics * WIP: Yotei runtime descriptors, compile-cost fixes and Codex memory work before PR #1000 Snapshot before merging upstream PR #1000: runtime image descriptors (global table), format-store and fault-flush compile fixes, runtime buffer strides, stencil plane fixes, Codex's image memory, D16 and residency work. Tests: all pass except the two known failures (DescriptorReloadedInsideLoop_SharesOneSampler, RuntimeFormattedLoad_ReadsItsElementThroughThePageTable). * [Cpu] Claim guest thread stack and TLS regions atomically TryMapGuestThreadRegion looked for a free slot and mapped it in two steps, and Map reuses a region that already exists. Two host threads claiming a nested-callback stack at the same time therefore got the same stack, and Map zeroed the first one's frames. In Ghost of Yotei two render threads ran the AGC command-buffer-full callback on that shared stack at once: one returned through the other's entry stub onto the other thread's host stack, abandoning managed frames. The runtime then failed fast with "attempted to call a UnmanagedCallersOnly method from managed code" or an access violation, one to four minutes after the intro. The slot search and the mapping now run under one lock shared by the stack and TLS claims. * [Gpu] Preserve downloaded buffers and batch resource descriptor reads * [Vulkan] Forget driver cache identities of destroyed shader modules The remaining change of the updated #1006 head (e6659681) that the integration branch did not carry. * [Vk] Measure GPU busy time from per-submission timestamps Per-draw timestamps are written only with SHARPEMU_PROFILE_GPU_DRAWS=1; by default each submission gets two timestamps and the overlapping intervals are merged into a [PERF][GPU_BUSY] line with the busy share and the longest submission. * [HLE] Reserve a host core for the render thread On Windows hosts with 8 to 64 logical processors the render thread gets the last physical core of the fastest efficiency class at the highest priority, and guest threads are kept off that core so spinning job workers cannot take the renderer's SMT sibling. SHARPEMU_RENDER_CORE=0 turns it off. * [Vk] Spin briefly before blocking on a GPU wait A GPU wait polls the timeline for SHARPEMU_GPU_WAIT_SPIN_US microseconds (150 by default) before it sleeps, which saves the wake-up latency when the work completes soon. * [GpuMemory] Answer CPU-dirty range queries without the tracker lock MayHaveCpuDirtyPages reads the per-block summary and the region masks without taking the region lock; a true answer still goes through the locked path. Regions also bump a CPU-dirty epoch whenever a page becomes CPU-dirty. * [Gpu] Skip the device-address sweep while no page became CPU-dirty PrepareBda remembers the CPU-dirty epoch and the mapping it swept last and skips the full sweep of mapped memory until either changes. * [GpuMemory] Scan possibly CPU-dirty blocks 64 at a time ForEachPossiblyCpuDirtyRange combined a region lookup and a summary read for every 4 MiB block of mapped memory on each device-address sweep. A bitset of blocks that have a region and the dirty summary words are now scanned a word at a time, with the same runs as before. * [Gpu] Skip syncing a written buffer range that is already GPU-owned SynchronizeBuffer returns early when a written range lies entirely in the GPU-modified ranges, uses the lock-free CPU-dirty query for reads, and the render profile splits buffer sync time into written, texel and upload parts. * [Gpu] Version the GPU-modified buffer ranges A written range bumps GpuModifiedVersion only when it adds bytes to the GPU-modified set, so readers can cache a clean verdict for a page until the GPU writes something new. * [Gpu] Track the extent of DCC metadata and answer overlap queries A color target records the size of its DCC metadata, and the image cache can tell whether a guest range overlaps registered DCC metadata. * [Diagnostics] Trace the GPU writers of DCC metadata and of a chosen address SHARPEMU_TRACE_DCC_WRITERS=1 writes the shader program and a call stack for GPU buffer writes that overlap DCC metadata; SHARPEMU_TRACE_WRITER_ADDRESS does the same for writes that cover one guest address. * [Gpu] Fill DCC metadata on the GPU and in guest memory at once A fill that targets DCC metadata which no GPU write owns is recorded as a GPU fill and also written to the guest backing directly, so the range never becomes GPU-dirty and later CPU reads need no readback. Ranges the GPU still owns or that overlap an image keep the plain buffer fill. * [Gpu] Turn AGC fill compute shaders into buffer fills BoundedFillDetector recognizes the AGC range-fill and pattern-fill compute programs, including thread-dimension dispatches, and a dispatch of one that targets DCC metadata becomes a DCC fill instead of a compute dispatch. Refused conversions are reported by the DCC writer trace. * [HLE] Resolve backing aliases for readers that hold an access window SharedBackingViews publishes its view snapshot as an alias identity, and a reader can enter an alias access window once and resolve guest pages to their backing alias without the views lock until the snapshot changes. * [Diagnostics] Trace shader resource reads that wait for GPU-written memory SHARPEMU_TRACE_GPU_READS=1 writes the shader, stage, address and table phase of a resource read that has to synchronize GPU-written memory, once per shader and page. * [ShaderCompiler] Keep recent materialization variants per draw key A cache key now holds up to four materializations in most-recently-used order, so alternating descriptor contents reuse their earlier result instead of re-materializing. The cache report counts stale and unreadable entries and table refreshes, and ReadingTable tells a reader when the flattened table is being evaluated. * [VideoOut] Read resource words through cached clean pages and the backing alias TryReadGuestWord and TryReadResidentGuestBytes remember the last 64 pages found free of GPU-dirty bytes, keyed by the GPU-modified version, and read them through the backing alias inside the alias access window that each command stream slice now holds. GPU-dirty checks are byte-precise, and a resident read refuses unreadable ranges before it asks the page tracker. * [Gpu] Read GPU-written guest memory back asynchronously and ahead of time VulkanAsyncReadback keeps eight slots: slot zero serves synchronous reads and the others carry asynchronous downloads. A guest thread that reads GPU-written memory lets the render thread start the copy and waits for it on its own thread, then the render thread applies it if the range is unchanged; a foreign read keeps the source buffer alive until it completes. Windows the render thread had to read synchronously become hot. When a batch writes into a hot window, the window is downloaded right after the batch is submitted, and the next read uses that copy if it is still current. A pending write to a hot window ends the open batch early. SHARPEMU_ASYNC_GUEST_READBACK=0 keeps the synchronous path; [PERF][ASYNC_READBACK] reports the counts. * [ShaderCompiler] Prefetch contiguous resource words in one resident read Resource materialization read every descriptor and flattened-table word through its own guarded TryReadGuestWord call, about 2.6 million per five seconds in Demon's Souls. The raw reads of each plan are grouped once; at run time their addresses are resolved, sorted and read as contiguous runs through the resident guest reader, and the values seed the evaluator cache. A run the GPU may still own, or one out of bounds or through a null base, falls back to the word reads. The cache recorder records the prefetched words, and SHARPEMU_RESOURCE_PREFETCH=0 turns the prefetch off. * [Gpu] Reuse image lookups that found the same backing FindImage remembers, in a 256-slot table, each request that resolved to an image with the same backing, keyed by the request bytes and a generation that every index registration or removal advances. A repeated request touches the image and returns the remembered result without walking the page owner index. SHARPEMU_IMAGE_LOOKUP_MEMO=0 turns it off; [PERF][IMAGE_LOOKUP] reports hits and misses. * [ShaderCompiler] Look up fused programs without the registry lock Every shader header lookup and decode asked the fused-program registry under its lock. The registry now publishes an immutable dictionary that readers take with a volatile read, and a registration copies it under the lock. * [ShaderCompiler] Decode fused programs whose halves are far apart The fused decoder joined the continuation at its address distance from the entry and refused halves more than 4 GiB apart or in the wrong order, which Poppy Playtime now hits for a vertex shader (invalid-fused-layout). Such a continuation is placed right after the entry instead, and each of its instructions keeps its real offset from the program address in AddressOffset; S_GETPC_B64 in the scalar graph, the SPIR-V and the MSL translators uses that offset, and the persisted scalar analysis key includes it. * [Gpu] Collect an image only once it is old enough in frames Since images age by frame, clamping the age to the current frame made every image of the first frame collectable during the first 16 frames, and a submission that ended no frame could delete a texture the frame still used. Without memory pressure nothing is collected until the full age has passed; under pressure the clamp still lets collection relieve memory early. * [Tests] Cover the deferred global barrier of an attachment-only scope A global barrier still ends a scope whose draws store to memory. In a scope whose draws only write attachments it waits for the scope to end, and a later memory-writing draw ends the scope and records it. * [Agc] Make the number of suspend points in flight configurable CommandStreamQueue takes the number of frame boundaries that may wait behind the graphics commands. The default stays one, so the guest CPU can run one frame ahead, and SHARPEMU_SUSPEND_POINTS_IN_FLIGHT=0 makes a suspend point wait until its own boundary is processed, for diagnosis. Tests cover both modes, including a label that the CPU rewrites after the suspend point. * [Gpu] Throttle the device-address fault and 3D slice range logs Little Nightmares wrote 195 thousand "Accessed non-GPU cached memory" lines in one session and Silent Hill 6800 slice range lines. Both now print the first occurrences and then only at power-of-two counts, with the count. * [Docs] Document the new environment variables Adds SHARPEMU_ASYNC_GUEST_READBACK, SHARPEMU_GPU_WAIT_SPIN_US, SHARPEMU_IMAGE_LOOKUP_MEMO, SHARPEMU_RESOURCE_PREFETCH, SHARPEMU_SUSPEND_POINTS_IN_FLIGHT, SHARPEMU_RENDER_CORE, SHARPEMU_TRACE_DCC_WRITERS, SHARPEMU_TRACE_GPU_READS, SHARPEMU_TRACE_WRITER_ADDRESS and SHARPEMU_PROFILE_GPU_DRAWS, and corrects the group counts to the rows the tables hold. * [GpuCommands] Write the 64-bit label of a compute-done release with an interrupt RELEASE_MEM with event 0x2F and a 64-bit data selection was accepted only without an interrupt. It is now handled like the other end-of-pipe events: the label is written and the interrupt is raised after it. * [GpuCommands] Let a wait see its own queue's preceding label store A memory wait that directly follows a 4- or 8-byte store of its queue to the same address, with only waits or inert NOPs and markers between them, compares against the stored value when guest memory no longer holds it. Dead Cells writes a label and waits for it while the CPU already rewrites it for the next frame. The forwarded value lives only within one slice, and any draw, dispatch or transfer in between drops it. * [ShaderCompiler] Key fused programs by the underlying guest memory Each native guest thread wraps the guest memory in its own tracking wrapper, so a fused program registered while one thread created the shader was not found by the render context. The registry now unwraps ICpuMemoryWrapper before it looks up the per-memory table. * [Agc] Implement the legacy sceAgcFuseShaderHalves export The older NID (nApJjpKNBl4) shares the fusing path but keeps the front half's user data pointer, takes the larger value of the resource allocation fields of both halves, takes the user SGPR count and the ES component flag from the front half, and copies the checksum register of the matching stage. * [ShaderCompiler] Decode S_CMOV_B64 as a conditional select S_CMOV_B64 is decoded as S_CSELECT_B64 with the old destination pair as the false source, so it reuses the SCC, register-pair and EXEC handling of the translators and of the scalar value graph. * [Gpu] Merge the stencil replacement references of a face Vulkan has one stencil reference per face for the comparison and every replace operation. Replacements with the test value and with the operation value are now merged into that reference over the written bits, and refused only when they conflict on bits the comparison also reads. A replacement with an operation value of zero over the written bits becomes a zero operation, which ASTRO's PLAYROOM uses to clear one stencil bit. * [Json] Add the sce::Json::Value copy constructor and keep shadow values on copies The copy constructor (fSb2oQTNrgA) shares the assignment path. Assignment and reads now carry the value a constructor or setter recorded in the object heap, so a copy keeps it after the source is destroyed. * [Font] Implement sceFontTextSourceInit Fills the 0x60-byte text source with the text range, the cursor, the parser callback and its object, and the text size, and leaves the memory after it untouched. * [AudioIn] Answer sceAudioInGetSilentState without an input backend No AudioIn port can be opened until an input backend exists, so the export returns an AudioIn error code (0x80260101) instead of being an unresolved import. * [PhtreadSpecificSemanticsTests] Fixes for computed shaders * [Gpu] Return idle buffer memory and bound retired memory under pressure - Small-buffer slab chunks track their live blocks; completely idle chunks go back to Vulkan under memory pressure instead of staying allocated until device teardown. - Buffers removed from lookup still hold GPU memory until their retirement completes. The cache now counts them, collects on registered plus retired bytes, and waits for completion once retired memory passes 256 MiB. - The tiler's pooled scratch buffers are released under pressure, and image collection waits for completion when outstanding scratch is over budget. * fix(shader): preserve wave64 ballot masks on Vulkan * test(shader): cover subgroup lane bits in wave mask predicates * [Pad] Give each new touchpad contact its own touch id The pad assigns a new id (1 to 127, then back to 1) to every finger contact and keeps it while the finger stays down. SharpEmu reported the finger slot instead, so lifting the finger and touching elsewhere read as one contact jumping across the pad. Games that tell strokes apart by the id (Ghost of Yotei's name drawing) never saw a new stroke. * [Gpu] Stop device-address faults from churning the buffer cache Shaders reach guest memory through pointers, and a page they touch outside the cache faults and is registered afterwards. In Ghost of Yotei that path re-created tens of thousands of buffers every few minutes: - Faulted ranges outside the GPU mappings were never touched again, so they aged out while still in use and faulted again. They are now kept and touched each tick, and forgotten once their guest mapping is gone. - A fault inside a guest mapping now brings in its aligned 2 MiB window, clipped to the mapping, instead of one 16 KiB page. - Faults on memory the guest never mapped (bad pointers) no longer create buffers: the shader reads zeros there, as on the console. They were 98% of the faults and about 2.6 GiB of junk buffers; the cache now holds ~0.5 GiB in the same scene. - The per-fault log line is gone; it wrote hundreds of thousands of lines per session. * [Vulkan] Save and load driver pipeline caches past 2 GiB Ghost of Yotei's driver cache grows past 2 GiB. Saving went through a .NET array, so every save failed and new pipelines were lost at the next launch; loading had the same limit. Both now stream the unchanged file format from and to native memory in chunks, so existing caches still load. * [Np] Treat NO_ENTITLEMENT for unowned add-on content as an expected result sceNpEntitlementAccessGetAddcontEntitlementInfo returns NO_ENTITLEMENT when the user does not own the add-on, as on the console. The import log reported it as a warning. * [Vulkan] Log only slow pipeline creations Every pipeline creation was logged, cache hits included, which wrote thousands of 0.0 ms lines per session. Only creations of 500 ms or more are logged now. * [Shader] Treat a phi that merges one value as that value when planning table reads * [Test] Read the formatted-load V# from GPU memory so the load goes through the page table * [Repo] Add license headers to new files and build pipebench with central package versions * [Test] Add the missing copyright line to the large dispatcher tests * [Repo] Remove game-specific RenderDoc capture scripts * [Repo] Remove the pipebench tool * [Kernel] Implement sceKernelAioPollRequest * [ShaderCompiler] Return the entry header address of a registered fused program An overload of TryGetFusedProgramParts also gives the entry header, so a caller can register the same fused program on another memory. * [Vulkan] Keep saving a pipeline cache that outgrows its limit A driver cache over 256 MiB was refused on every save, so it was never written again and every launch compiled the same pipelines. Such a cache is now written as an empty file once, and the next launch starts a fresh one. A save is skipped when the driver reports the size that was loaded or last saved, and a failed or deferred save waits for the next interval instead of running again on every new pipeline. * [Vulkan] Write only the cache shards that gained pipelines A shard remembers the driver size it was loaded or saved with and is not written again while that size holds. Shard saves are logged as one summary line, and a shard load only when it is slow. * [Vulkan] Remove the single-file cache once the shard mode takes over The shard mode never reads the single cache file of the default path, so it is deleted instead of staying on disk. * [Gpu] Record compiled compute programs in a shader prewarm list When the pipeline host gives a list, each compute permutation the game compiles is appended at once to shader-prewarm.bin: the guest code the decoder read (once per program), the fused parts, the compute input, the system registers, the resource specialization and the push data start. Records carry a checksum, so a cut tail is dropped at the next open. TryCompilePrewarm rebuilds the compile request from a record through the same layout and request code as the runtime, so it produces the same SPIR-V. * [Vulkan] Prewarm the recorded compute pipelines after a translator or driver change A first run after a translator change compiled every compute pipeline one at a time while the render thread waited (Demon's Souls: 282 pipelines, 144 s). When the translator assemblies or the driver differ from shader-prewarm.stamp, background threads at below-normal priority translate the listed programs again and create their pipelines, so the driver has them before the game asks. With the same build and driver the launch does no prewarm work. The log reports the prewarm result and how many runtime compute modules it produced. * [Vulkan] Keep the pipeline cache in memory on Windows The GPU driver keeps its own shader cache on disk, and the shader prewarm list rebuilds it after an update, so Windows no longer writes the driver cache file by default. SHARPEMU_VK_PIPELINE_CACHE=file keeps one; Linux keeps the file and macOS keeps its shards. * [Docs] Document the pipeline cache modes and the shader prewarm list Adds SHARPEMU_SHADER_PREWARM, SHARPEMU_VK_PIPELINE_CACHE_SHARDS and SHARPEMU_VK_PIPELINE_CACHE_LEGACY_SHARDS, and describes the new cache file default. * [DeS] Fixes for page faults and stack bounds issues in the emulator and audio fixes * [ShaderPrewarm] Hold the game until the prewarm finishes and resume interrupted runs The prewarm compiled thousands of compute pipelines on background threads while the now faster boot ran beside it, so logos, Bink movies and the first scenes raced the compile and dropped frames. - Hold the guest at its first splash hide, GPU submission or CPU flip until the prewarm is decided and done; the render thread keeps presenting the splash. SHARPEMU_SHADER_PREWARM_WAIT=0 opts out. - Stamp only the shader translators, the compiler type and the driver, so a Libs-only build no longer triggers a full prewarm. - Record finished pipelines in shader-prewarm.progress so an interrupted prewarm resumes with the remaining ones. * [AudioOut2] Block a blocking push only until a queue slot frees A blocking sceAudioOut2ContextPush waited only when the host stream hit its 128 KiB cap, so a title rendering faster than real time kept about 680 ms queued and every sound played that far behind (GTA V: queue=2 context, queued_ms avg=678). The push now waits until the device holds the cushion plus QueueDepth-1 grains, the level GetQueueLevel already reports as full; the host cap stays as the limit for non-blocking bursts. GTA V now holds about 41 ms with no underruns. * [ShaderCompiler] Share the device-address formatted load decoder per component count Every BUFFER_LOAD_FORMAT through a device address inlined the whole page-table walk, format conversion and bounds check. Shaders with many such loads grew to several megabytes of SPIR-V; 128 D16 loads added about 4600 words each. Emit one DontInline function per component count, taking the address, size, offset, descriptor and caller PC. Fault recording, formats, swizzles, EXEC and out-of-range values are unchanged. Offline A/B on three extracted shaders (RTX 5070, driver cache disabled): 18.6 s -> 2.9 s, 12.9 s -> 2.8 s, 15.9 s -> 3.2 s. * [Gpu] Never copy a linear image readback past its guest range The readback storage is sized from the guest range, but the copy follows the linear layout computed for the format, whose padded rows can need more bytes. A 513x513 R8 image declared as 0x40401 bytes was copied with 768-byte rows (0x60201 bytes): the copy wrote past its slot in the download ring, and at the end of the ring into freed memory, which lost the device. Plan the readback only when the copy fits the guest range (and the partial-level readback only when it fits its covered bytes), with one warning naming the image. A linear download that would still exceed its destination now fails explicitly instead of corrupting GPU memory. * [Gpu] Draw merged LS/HS tessellation through a native tessellator The guest hull runs unchanged in a cooperative wave64 compute workgroup and computes its own control points and tessellation factors. A generated control stage feeds those factors to Vulkan's tessellator, and the guest domain shader is translated to a tessellation evaluation stage that reads the guest control-point ring. - VGT_TF_PARAM gives the domain, spacing and winding; VGT_LS_HS_CONFIG gives the patches per group and the control-point counts. - Factors are clamped by the guest's minimum and maximum levels; zero or NaN outer factors still cull the patch. Isoline factors are swapped into Vulkan's order. - The SPI_SHADER_USER_DATA_ADDR_HS pair is carried separately from the LS scalars and moved to s0:s1 before the guest code runs. - Patches are drawn one hull group at a time, because the guest rings are reused by relative patch id. - A configuration the bridge cannot express (power-of-two partitioning, an undefined domain, an empty hull group) skips the draw with one warning instead of stopping the emulator. * [VideoOut] Verify a guest page once for clean resource reads Resource materialization reads a few hundred guest words per draw through the clean readers, and each read re-checked the whole GPU ownership of its bytes: GPU-dirty pages and bytes, then the image cache, which built a new list (twice per word) under its lock. In Ghost of Yotei that was about 550 million reads and 90 GB of allocations per minute in game. - The image cache answers whether an unsynchronized GPU image covers the bytes without building the list; the list is built only when one does. - The clean-page memo, already used by plain reads, now serves clean reads too. A page is verified clean once (no GPU-dirty bytes or pages, no GPU-modified image) and trusted until a buffer or an image is written by the GPU, which advances the buffer cache's or the images' write version. GPU-dirty pages are still checked on every read. Measured in game: one materialization went from 0.33 ms to 0.17 ms. * [Gpu] Keep the guest's face culling on tessellated patches A patch list stands for legacy rectangle lists, which are never culled, so every patch-list draw dropped its culling. Tessellated draws use the patch topology too, and their output rasterizes as ordinary triangles: back faces were drawn. Only a patch list without tessellation stages is a rectangle list now. * [ShaderCompiler] Give the domain shader its patch ID in v8 The ES ABI passes u, v, the patch within its hull group and the patch ID in v5..v8. v8 was never written. Each native draw covers one hull group, so the patch ID is the group's first patch plus the native primitive ID. * [Gpu] Run tessellation hull groups together in their own off-chip slots The hardware gives each hull threadgroup in flight its own off-chip buffer and its own run of the factor ring, so groups run together and one draw consumes them. Every group used slot zero instead, which serialized the draw into one dispatch, one draw and full barriers per group. - sceAgcDriverSetHsOffchipParam (VGT_HS_OFFCHIP_PARAM) is kept: buffer count and granularity. Ghost of Yotei sets 256 buffers of 8K dwords. - Hull workgroup k runs group k: its first patch, its patch count, s2 at slot k and s4 at group k's run of the factor ring. - The domain shader finds its group from the native primitive ID: the off-chip slot in s4, the patch within the group in v7, the patch ID in v8. - One dispatch and one draw cover as many groups as the off-chip buffers and the factor ring hold. Without the guest's configuration, one group runs at a time as before. * [Tests] Restore two upstream tests the branch dropped without a behaviour change DepthState_PlayroomReplacementClearsOnlyTheWrittenBit and FormattedUntypedLoad_SpecializesOnTheDescriptorFormat were removed by earlier branch work although the code still behaves as they expect; both pass unchanged. * [Tests] Check the AudioOut2 port volume and reserved bytes again The layout change dropped the checks of the -1 volume at +4 and the zeroed bytes at +8, which the export still writes. * [Repo] Remove the branch's debugging switches The capture-after-seconds RenderDoc request, the crash-capture directory and first-chance fault traces, the unsupported shader dump, the AGC allocation failure traces and the control-flow trace served earlier investigations only. The configuration switches (direct memory size, image cache budget, forcing the shader dispatcher) stay. * [PlayGo] Do not reject chunk IDs the playgo.pgm numbering only assumes playgo.pgm is read for its chunk count only; the IDs 0..count-1 are derived, yet they were marked authoritative and any other ID returned BAD_CHUNK_ID. The list is still reported, but like other metadata that is not understood, it no longer rejects an ID outside it. * [Vulkan] Bound the bindless sampler binding by the device's sampler limits The persistent heap always declared 4096 update-after-bind samplers and left them out of the pool-wide descriptor budget it split between sampled and storage images. On a device with fewer samplers per stage, or a tight update-after-bind total (MoltenVK, some Intel drivers), creating the heap could fail. The sampler binding now takes the smallest of the device's per-stage and per-set sampler limits (at most 4096), and its share comes out of the total before the images split the rest. * [Gpu] Copy linear render targets with the guest's own pitch A linear render target's builder lays it out with the guest's pitch, which need not be aligned like a texture's: a 513x513 R8 target is 513 bytes per row. Transfers recomputed the texture's aligned linear layout (768-byte rows), so its uploads read shifted rows and its readbacks did not fit the guest range and were skipped. A single-level, non-volume linear image whose description holds a consistent slice layout now transfers with that layout. Textures, which carry no layout of their own, keep the format's linear layout, and the readback guard still refuses a copy that does not fit. * [Gpu] Free images and retry once when an image allocation runs out of memory The image budget comes from the device's reported memory, so an allocation can still fail when the driver or another process holds more than expected. That was fatal. Running out of device or host memory while allocating an image's backing is now recoverable: the cache retires every image collection allows, waits for the retired ones to be destroyed, returns unused pool memory and tries once more. A second failure stays fatal. Tests make an allocation fail through an internal hook on GpuDeviceInfo. * [Vulkan] Size descriptor pools for the sets that need them The branch had raised every descriptor pool to 65536 storage buffers, 262144 sampled images and 8192 storage images so the largest shader's set would fit, and every pool paid for that on every device. Pools are back to upstream's ordinary size (8192/8192/1024/1024). When a set does not fit one, the next pool is sized for four sets of its kind, and a retired pool is reused only if it can hold the set. MaxImages stays the planner's bound on distinct image descriptors per shader. * [Vulkan] Blend with a second source from the MRT1 export Blend factors 15-18 (SRC1 color and alpha) were mapped to Vulkan's Src1 factors without enabling dualSrcBlend or giving the fragment shader a second output, so the blend read an undefined value and validation reported every such pipeline. When the device supports dualSrcBlend, it is enabled, and a draw whose target 0 blends with an SRC1 factor (and binds no other target, as on the hardware) gets a second fragment output fed by the MRT1 export, declared at location 0 with index 1. The translator accepts that one extra output and keys the compiled program by it. * [Tests] Skip device tests without a Vulkan device, as upstream does The branch had turned the device gates into assertions, so every device test failed on runners without a GPU. SHARPEMU_TEST_REQUIRE_DEVICE=1 still makes a missing device a failure. * [Gpu] Wait for pending image readbacks before uploading over them A tiled image retired under pressure publishes its contents only when its readback tick completes. Found again before then, it was rebuilt from the guest bytes it supersedes. Uploads now wait for the readbacks into their range. * [Shader] Unpack compressed 16-bit pixel exports by their export format Compressed exports were always unpacked as half floats. UNORM16, SNORM16, UINT16 and SINT16 exports (G-buffer normals among them) now follow the SPI_SHADER_COL_FORMAT of their target, which also keys the compiled program. * [Agc] Emit direct draws for every draw modifier sceAgcDcbDrawIndex and sceAgcDcbDrawIndexAuto returned without writing the draw for any modifier other than 0x40000000, so whole passes vanished without a trace. * [Agc] Emit addressed occlusion counter events sceAgcDcbEventWrite refused every event with an address, so the 0x38/0x39 counter events never reached the command stream. Their results are now published through the ordered buffer fill path instead of CPU memory only. * [Gpu] Execute target-less draws whose pixel shader writes memory A draw without color or depth targets was dropped before compilation even when its pixel shader stores to buffers or images. Yotei fills its visibility buffer this way; the dropped pass left most of the scene black. * [Shader] Keep EXEC guards after V_CMPX with a legacy scalar destination GFX10 V_CMPX in VOP3 or SDWA form changes EXEC and ignores its scalar destination. The EXEC-full analysis took it as a write of that destination, kept EXEC full and elided the guards of the following vector writes. Ported from voidborn-astra/sharperemu 8499b905. * [Vulkan] Use unsigned operations for scalar pair bit instructions Ported from voidborn-astra/sharperemu c0cff157. * [Gpu] Invalidate image copies for raw buffer writes Ported from voidborn-astra/sharperemu caa4149d. * [Gpu] Retain GPU image contents during collection A GPU-written image whose readback a dirty buffer overlap blocks was cleared and deleted, losing its contents. It is kept instead; same-page CPU writes are resolved by hash before deciding. Ported from voidborn-astra/sharperemu 3b5eb2f3. * [Shader] Read the selected lane for V_READLANE in graphics stages Graphics stages took the reading lane's own value instead of the selected lane. A graphics wave is one group of up to 32 host lanes; the selected lane of that group is now read with a subgroup shuffle. * [Tests] Cover Yotei's wave64 march and waterfall loop shapes A step counter compared into EXEC with lanes leaving through VCC, and a waterfall over an SDWA compare into an SGPR pair. Both already end every lane in both halves of the wave. * [Vulkan] Make depth bounds dynamic pipeline state The depth bounds were part of the graphics pipeline key. Ghost of Yotei moves them per draw, so every value created a new pipeline: about 80 per frame and thousands kept for the session. They are now set with vkCmdSetDepthBounds per draw; the key bytes they used stay reserved. * [Shader] Read absent graphics lanes as the reading lane A host subgroup of a graphics stage can be partly empty, where a PS5 wave still has dead lanes. DPP, V_READLANE and V_PERMLANE reads of an absent lane returned undefined values: Ghost of Yotei's wave minimum then never reached its exit and its pixel shaders ran until the step guard. An absent lane now reads the calling lane's value, which keeps min/max/and/or reductions exact. * [Memory] Skip the ownership transition for pages already CPU-dirty A CPU write to pages that are all CPU-dirty re-ran ChangeState, which scans the whole 4 MiB region and republishes the same summary, for every managed guest store. CPU and GPU dirty states are exclusive, so nothing can change there. * [GPU] Keep the previous frame's images through mid-frame collection Collection runs before every draw while image memory is under pressure. It evicted every image not used yet in the current frame, which the rest of the frame samples again, so Ghost of Yotei recreated and uploaded about 7000 images per frame. Below the critical level the mid-frame pass now leaves them alone; frame-end collection and allocation-time reclaim are unchanged. * [GPU] Copy the newer GPU contents between same-layout image aliases One surface read through two formats of the same layout is two cache images over the same guest bytes. Before one is used as a texture, storage image or target, it copies the newest GPU contents of its same-layout aliases on the GPU, ordered by write sequence, as unified memory shows them. Depth keeps its reinterpretation path. * fix(kernel): provide read-only entropy device descriptors (cherry picked from commit 2ad0eca819ba8456b42177d4e682915d99fb7639) * fix(net): track epoll descriptor creation and destruction (cherry picked from commit e1c5658ed5f9579756111c89943b136fb995182b) * fix(pthread): implement relative timed mutex acquisition (cherry picked from commit c75f28f489a7fa3f78d6baae533e49c33dc10cb7) * fix(net): implement level-triggered socket epoll waits (cherry picked from commit 2f27f0078888007861f71afc5615e5c9a7246532) * fix(kernel): release timed-out event flag waiters (cherry picked from commit 4daa8a34e4c0534d3a0ebcc79f7a15597aaed330) * fix(system-service): report empty event polls (cherry picked from commit 65fb9aae7a7ee994ce8ab5b70f8fb00df2f7c742) * fix(videoout): preserve decoded frame presentation order (cherry picked from commit 66526f0eedc4da4253a6650b5563c257ff5c278d) * fix(ajm): decode ATRAC9 jobs from split buffers (cherry picked from commit e8c9925d86eb886d8734913a0ba7c10c125cc209) * fix(videodec): finish queued frames before decoder deletion (cherry picked from commit eae19e7c170998af3f4cf865759536fb33886e28) * fix(net): confirm socket errors before reporting epoll error readiness (cherry picked from commit 95128f67d446b4f659692584d241bdc85a5a9af7) * fix(net): format guest Ethernet addresses (cherry picked from commit 08cca779b5c000b46322ce16eb75b9739f312175) * fix(net): keep one sceNetEtherNtostr export Both branches added sceNetEtherNtostr. Keep the version that reports an unreadable source address as a fault, the errno a guest read fault gives. * fix(net): distinguish pending accepts from socket hangups (cherry picked from commit 28ad0c0a9d989ad8f368d471354ede295ce9acf7) * fix(net): avoid querying payload bytes on listening sockets (cherry picked from commit 2aac142b2fb58b4b398bb1f2dfdf96cd94a388f1) * fix(audio): avoid pacing empty nonblocking context pushes A nonblocking push returns at once. The grain it claims still counts in the queue level when no host backend is attached; only a blocking push waits for its slot. (cherry picked from commit 9b2db6d814f89b44cf46da11c3f8ced474ace063, adapted to keep the queued grain accounted) * chore(net): remove an investigation trace call (network part of 8d0bd2fc; its PlayGo trace only exists in the skipped d342dd1c) * fix(videodec2): preserve the picture-info size prefix Without a picture only the ready flag at offset 8 is cleared; the caller's size prefix and the other fields are preserved. A decoded picture still fills the whole output info, pitch included. (cherry picked from commit 050e9c824ad4a1ac2d9a40a6d6dd9ba1f63fd4fb, adapted to keep the complete output info for decoded pictures) * fix(videodec): preserve adjacent picture-info fields Width and height are 32-bit fields with the pitch between them. (cherry picked from commit 88a79715; the complete output info this branch writes for a decoded picture already used 32-bit fields, so only the dimensions helper and its test are added) * fix(shader): report descriptor accesses that fall back to the null descriptor A control-dependent image or sampler descriptor with no plan-time source reads the null descriptor, so its texels read as zero. The plan records each such access and the host warns once per shader with its PC, so the loss is visible instead of silent. * fix(shader): read control-dependent descriptors at run time before the null fallback A sampled float access whose image or sampler descriptor has no plan-time source read the null descriptor even when the runtime descriptor table could serve it, because the null fallback ran before the runtime path was tried. Such an access now reads its descriptors at run time, as the hardware reads them from memory; the null fallback stays for accesses the table cannot serve yet. * fix(gpu): keep invalid runtime image descriptors on the null texture A shader reading its descriptors at run time reports every image it does not find. One with a null base or a format without a host equivalent stopped the emulator when the host tried to create it. It now stays out of the table, so the shader keeps reading the null texture, as the hardware does for such a descriptor. * fix(gpu): translate equivalent stencil replacement states (cherry picked from commit a6e7922dbede9548fe5ef8795d29387de98b1bf8) * fix(gpu): accept GFX10 image resource-level bit (cherry picked from commit 1cbafc0a52e44592e34c5ae708d98573f6d2e9d6) * fix(gpu): preserve addressed texture view alignment (cherry picked from commit 936d873f70922337b7e9557cf4e579f4ed73d471) * test: keep only the tests that 1cbafc0a and 936d873f add Resolving their test conflicts kept test blocks from later #1057 commits that depend on code not merged yet; only each commit's own test remains. * fix(gpu): read disjoint descriptor bytes through backing aliases GPU ownership is tracked in bytes but page protection covers whole pages: CPU-owned bytes on a page that also holds GPU-owned bytes are read through the backing alias, without bringing the neighbouring GPU bytes back. (cherry picked from commit 7c8f0b97; this branch's clean word reader, which first synchronises GPU-owned words, is kept, and the test keeps the resident-range assertions) * fix(gpu): read indirect tessellation draw arguments on the CPU Non-indexed indirect draws now leave their arguments to the GPU (#1036), but the merged tessellation path counts patches from the vertex count on the CPU: an indirect tessellation draw arrived with the placeholder count of one and drew no patch. * fix(gpu): write a replaced stencil plane back before dropping its proxy A depth buffer whose stencil plane has another size at the same address drops the other buffer's stencil proxy. When the GPU had written that plane, deleting the proxy stopped the emulator (Ghost of Tsushima). The plane now reaches guest memory first, as when a depth buffer changes planes, and stencil write-backs register as publishing downloads so an upload of the range waits for them. * feat(shader): read image-load descriptors at run time An ImageLoad whose descriptor has no plan-time source looks its words up in the runtime descriptor table instead of reading the null descriptor. The key carries the numeric class the descriptor format selects, so the shader fetches through the uint, sint or float heap array the host view matches. - Only active lanes record misses; an inactive lane may hold anything. - A missed descriptor over unbacked memory stays out of the table, and an entry whose memory the title freed leaves it when its image is retired. - An entry keeps the texture it resolved to until the cache retires its image, so a draw no longer looks every entry up again; each draw still acquires its views. - A plan that reads descriptors at run time on a host without the bindless heap is a rejected plan, not a fatal layout error. * fix(shader): resolve descriptors from empty scalar buffers Descriptor words read from an empty scalar buffer are zero whatever the offset, so the access reads the null descriptor; materialization rechecks that the buffer is still empty. Ghost of Tsushima's pixel shaders read image descriptors this way. (cherry picked from commit 5d03a71aacdead6adfbc9f46b5eeb777168e759a; on this branch an access the runtime descriptor table can read keeps that path, which also serves a buffer that is not empty, so the proof applies to the other accesses only. Its tests use a depth-compare sample accordingly, the indirect-image case stays a runtime read, and the planning-dump fixture adds one to its descriptor as f73663e8 does upstream) * fix(shader): preserve scalar sources in immediate comparisons (cherry picked from commit 9f4e325df34d9c075d9625da9994ecccfa9d1ac3) * fix(shader): count unsigned leading bits in scalar instructions (cherry picked from commit 09e9e1de7a8de12d92de39d51eed744ff4416fa6) * fix(shader): bind signed integer storage images (cherry picked from commit 1c134311d66ea6690a4549dff933017e1e478c5a) * fix(shader): view only 32-bit signed storage writes as unsigned A write-only signed storage image went through an unsigned view for every signed format while no signed storage binding existed. With signed bindings (1c134311), only the 32-bit format keeps that view, where the bits are the same; a 16-bit signed image stores through its own signed view again. * feat(shader): read adjusted-sample descriptors at run time The IMAGE_SAMPLE_*_A forms carry their adjustment in the sampler's reserved dword-3 bits. Their descriptors without a plan-time source now go through the runtime table like a plain sample, with those bits masked out of the sampler key so each adjustment does not register a sampler of its own. A Ghost of Tsushima pixel shader reads the image of such a sample from a material record that the plan cannot prove. * fix(shader): qualify single-mode sample interpolants (cherry picked from commit 3026bb288124f001f828f550755a2e4117c67ec0) * fix(gpu): preserve sample masks and decode signed locations (cherry picked from commit 3ab11b99d98482694037365c4e3865839544d891) * fix(gpu): distinguish attachment sample counts in pipeline keys (cherry picked from commit 51dd915d42f2ec877df970b66e0f7d2fc57b1300) * fix(gpu): preserve EQAA depth and overrasterization controls (cherry picked from commit 1087b9fba3914d3afda21041897c223dda3f324d) * fix(gpu): retain scan mode control for sample iteration (cherry picked from commit c8614eae54bc66d18ee60ac594280b9659b1fdd4) * test(gpu): verify captured mixed-sample register decoding (cherry picked from commit 943fc08e17f11dbe0995849813900a666781d42c) * feat(shader): support explicit pixel interpolation samples (cherry picked from commit fa66d55425a6108760f5dc1f7d6d5e9f62c2b8d9) * fix(shader): honor eligible early depth testing in Vulkan (cherry picked from commit 9b34fa404eaca555170e9c5fb18622a907b70179) * fix(vulkan): preserve pixel sample-mask exports (cherry picked from commit 5fbe6a3b38c1724c8c66fcbb6eb37aacdde4a981) * fix(vulkan): preserve pixel depth exports (cherry picked from commit bad8e123e566cf0a1a835fd5fa8736625ffa9581) * fix(gpu): separate pixel iteration rate from interpolation inputs (cherry picked from commit 9e0bdd4cea8105243347772328ec69a0a77e7b11) * fix(vulkan): interpolate fixed custom samples with explicit offsets (cherry picked from commit 8e7796636bed4fad5d5c65ce04a35b970fc369be) * fix(vulkan): gate fragment execution with post-depth sample coverage (cherry picked from commit 4c981e8edfae91b0a9ecdc336a2813ec841941f6) * fix(gpu): apply sample exclusion to early fragment execution (cherry picked from commit 0f5b5a71c54983db73d5d461088f3285cf13641a) * fix(vulkan): preserve per-sample custom interpolation coordinates (cherry picked from commit bfb5d7618b7ec994f2197c8f50d8b717f3c6bca6) * fix(gpu): preserve late depth updates for shader coverage changes (cherry picked from commit 4f8bcb6d142a7352a58d02328d798b390f244ee5) * fix(gpu): key shader programs by custom sample positions (cherry picked from commit dd36fcea9b83fd90ac1aea5af770cfdebbe5f987) * fix(vulkan): preserve two-sample depth with single-sample color (cherry picked from commit 042e5c4d19c5b104f0c20b0a38d87cb349d9241d) * fix(gpu): reject unrepresented two-sample coverage masks (cherry picked from commit b8fe958ac343b049295392a61c99419115020e63) * fix(gpu): preserve forced shader depth ordering (cherry picked from commit 58a4b282c89b2f35d04fe46a3f702c990f5164f0) * fix(gpu): use late depth for unforced shader depth exports (cherry picked from commit 29fe184bf1d241af6e8bfa521020d38d2eaba589) * fix(shader): reject unsupported multisample sampling modules (cherry picked from commit e77451e273d12e9c11355004654d592235e6aa63) * fix(gpu): keep runtime descriptors that describe no view out of the table A T# read at run time holds whatever the lane computed; the hardware reads one that describes no valid view as the null texture. Ghost of Tsushima samples through such a descriptor (image type 0, base level past the last level) before choosing another one. The runtime path now asks for the texture without stopping on it: the T# checks of the texture builder go through one rejection, fatal on the planned path as before and a failure for the runtime one, which keeps that descriptor out of the table. * perf(loader): sample repeated unresolved import warnings (cherry picked from commit 842c3eea5228f017f26941e2f5ad9f69e678c002) * perf(shader): read buffer-table descriptors at run time when the access allows it A descriptor read from a table in a buffer, indexed by a lane value, was planned as a dense table: materialization takes every record the buffer holds and each draw finds, refreshes and binds all of them. A Ghost of Tsushima material table made that about 2000 images per draw, nearly all of the render thread's time. An access the runtime descriptor table can read now takes that path and binds only the records the shader reads; a storage, compare or cube access keeps the dense table. * fix(shader): read sample 0 for samples of a multisample image Vulkan cannot sample a multisample image, and e77451e2 stopped such a module from compiling, which stopped the emulator at a Ghost of Tsushima gameplay pixel shader. A sample instruction on a 2D multisample image now fetches sample 0 of the texel its normalized coordinate falls in, as shadPS4 lowers it, and the image is bound without a sampler. A gather or an arrayed multisample sample is still refused. * fix(gpu): free images and retry once when a buffer allocation runs out of memory Images already retried after freeing what can go; a buffer allocation that found every memory type full stopped the emulator (Ghost of Tsushima gameplay). The buffer allocation now reports the failure, the buffer cache asks the image cache to free its images and wait for retired ones, and tries once more before stopping. * fix(vulkan): initialize format buffer scratch for runtime resources * fix(shader): invalidate stale prewarm resource plans * chore(sync): carry upstream Unity compatibility fixes Apply upstream/main's post-revert Unity compatibility changes while preserving the Yotei-specific AudioOut2 state layout. The upstream rendering reversion is intentionally not imported because this branch still depends on those rendering changes. * fix(shader): bind incompatible-only indirect image tables as typed nulls An indirect image table whose candidates all have a dimension the MIMG instruction cannot address (Demon's Souls 0x9D1D8F5B7F200DE7: every candidate 2D, instruction MSAA) failed with "no typed candidate". Keep the instruction's declared image type and bind every candidate as a typed null instead. * debug(gpu): dump the whole command buffer on an unknown packet Temporary diagnostic for a tester's Yōtei crash ("packet opcode is unknown", header 0x00000000). The old dump showed only 24 dwords around the bad packet, too few to re-parse the stream and find which earlier packet is misaligned. Dump from the start of the buffer instead. * perf(gpu): copy CPU-write-hot pages once per memory visibility point Every draw with a read-only device-address range re-copied the range's CPU-write-hot pages: they stay writable, so they read as dirty forever. In Ghost of Yotei that was ~47% of the render thread (thousands of draws per frame re-copying the same pages, each copy ending the render pass behind a full barrier). The guest only guarantees CPU writes are visible at memory visibility points (a submission slice, a satisfied wait), the rule the PrepareBda sweep already follows. Each buffer now remembers the range whose hot pages it copied in the current visibility generation and skips them there; pages that fault dirty are still copied on every draw. A command-processor write invalidates only the buffers holding the written bytes instead of starting a new generation. SHARPEMU_BDA_RESYNC_HOT_EVERY_DRAW=1 restores the previous behaviour. [PERF][BDA_SYNC] reports visibility points, processor writes and how many syncs skipped hot pages. * perf(vulkan): stop retaining per-draw texture bindings until GPU completion Ghost of Yotei binds ~300 images per draw, and each one allocated a TextureResource of ~1.3 KB that stayed referenced until its submission retired. At under one frame per second every binding outlived gen0, so nearly every GC was a gen1 collection (299 gen1 vs 35 gen0 in 15 s). - Drop TextureResource.Resolution: it was written in one place and never read, and duplicated the ImageRequest (about half the object). - Keep only the host movie planes, which own a staging buffer recycled at completion; the other bindings die with the draw. Measured in game: gen1 collections fell to 9 per 15 s. * perf(images): widen the image lookup memo to 4096 slots The direct-mapped memo had 256 slots, while a Yotei draw binds ~300 images and a frame thousands, so slots evicted each other and only 42% of lookups hit. With 4096 slots (about 2.5 MB) 90% hit. * fix(agc): allocate command buffer space atomically Guest threads run HLE exports concurrently. Two exports appending to one command buffer both read its cursor before either stored it back, so the second packet overwrote the first. A tester's Yotei DCB showed a PopMarker NOP written over the first two dwords of a SET_SH_REG 0x228 packet; the stream then hit its trailing zero dword ("packet opcode is unknown, header 0x00000000") about 20 s into the game. The cursor update is now atomic per buffer through striped locks; the lock is released around the guest's buffer-full callback. A one-time "[AGC][WARN] Two threads append to one command buffer" line reports the race when the same buffer is contended. * fix(gpu): stop executing queued GPU work once guest memory is torn down Closing the window raced the runtime teardown: the runtime detached the guest GPU memory registry while the presenter's shutdown drain was still executing queued draws, so the first device-address draw died with "A device-address program needs the guest GPU memory registry" and the end-of-run reports were lost. The drain now drops the remaining work once the registry is gone. Also report the audio backend a port actually opened instead of a hardcoded "coreaudio" in the AudioOut output trace. * fix(runtime): release guest GPU memory only after the presenter's caches Runtime teardown disposed the guest GPU memory while the presenter was still shutting down on its own thread: its image and buffer caches still held page watches, so PageGuard.Dispose failed fast with "Cannot release the page guard while page state is active". Wait (bounded) until the presenter detaches its stores, and keep the memory mapped if it does not. * perf(buffers): stop read-aheads of windows the GPU keeps rewriting Eager readbacks copied a 512 KiB window after every batch that wrote a hot window. In Yōtei's loading phase and cinematic the GPU rewrites those windows before the CPU reads them: of ~2,900 read-aheads per 10 s, 3 were used and ~2,800 were discarded as stale. Count consecutive wasted read-aheads per window, skip a window after two, and give every window a new chance every 256 batches. * perf(buffers): read only the requested pages from mapped device memory A guest read of GPU-written memory served from a unified (ReBAR) buffer copied the whole 512 KiB readback window out of device-local memory, which the CPU reads uncached across the bus. In Yōtei's loading phase that memmove was 30% of the render thread. Mapped reads now copy a 16 KiB window around the request; copy-command readbacks keep the large window. Loading phase, same 10 s window: QueueRelay 2447 -> 947 ms, frames 205 -> 252. * diag(gpu): report how tessellated draws split into batches Adds [PERF][TESSELLATION] to the render profile: draws, instances, patches, batches per draw and the off-chip buffer count. Each batch prepares and binds every stage again, so batches per draw is the multiplier on tessellation cost. * perf(gpu): run all instances of a tessellated draw in shared batches DrawTessellation looped over instances on the CPU: every instance took its own hull dispatch, a full binding preparation of the hull, domain and pixel stages, and its own draw. Yōtei's cinematic issues up to ~1,900 instances per tessellated draw, ~15,000 iterations per 10 s, and tessellation was half of the render thread. Number patches across all instances instead and batch that numbering by the factor-ring and off-chip capacity, as the hardware distributes the patches of an instanced draw. A new tessellation data word carries the patches per instance; each hull thread derives its instance ID (v5), its patch ID (v0) and its index-buffer vertex, and the domain stage its patch ID (v8), from the shared number. Zero patches per instance keeps the old values exactly. Yōtei: one batch per tessellated draw, cinematic 0.6-0.7 -> 1.1-1.3 FPS. * perf(memory): let CPU-write-hot pages cool down once per frame A page the CPU rewrites right after three uploads turns hot: it stays writable and dirty and every sync copies it whole. Nothing ever cooled a page down, so a ring the game fills a little each frame ended up hot in full. In Yōtei's cinematic two 28-32 MiB buffers were copied whole at every device-address sync, ~60 GB per 10 s. Once per presented frame, hot pages now lose their heat: the next sync copies them once more and protects them again, and only pages the CPU keeps rewriting within a frame turn hot again. SHARPEMU_KEEP_CPU_WRITE_HEAT=1 restores the old behaviour. Yōtei cinematic: uploads ~60 GB -> ~0.6 GB per 10 s, 1.1 -> 1.5-1.6 FPS. * diag(images): trace lost GPU image contents and name guest passes SHARPEMU_TRACE_IMAGE_DROPS=1 reports every time an image loses GPU-written contents that never reached guest memory: the code site, the image, the range of a buffer write that caused it and how much of the image it covers, the image's dirty flags, and the guest render pass decoded from its push markers (one stack per queue). Evictions report whether they published the contents first. A renderdoc.capture file next to the executable now requests a RenderDoc capture at the next guest flip, for unattended runs. * fix(images): keep an image being resolved out of collection ResolveOverlap can allocate a replacement (GrowImage, a depth overlap copy), and an allocation under memory pressure collects images that were not used this tick. The image being resolved is the copy source of that replacement: when it was collected, the copy read a freed slot and the process failed fast with "The slot is not allocated" (seen twice in Yōtei with a 4 GB image cache budget). Touch it before resolving. * fix(images): publish GPU-only image contents before an overlap drops them Memory keeps its bytes when another image or a buffer write reuses part of it. When an overlapping image request or a partial buffer write dropped an image whose GPU contents had never reached guest memory, the contents were simply lost; a later image over those bytes started from stale guest memory. Yōtei's cloud tables alias a 2048x2048 RG16F and a 512x512 RGBA16F at one address, and several post-process targets are partly overwritten by compute buffer writes (7-82 % coverage). Before such a drop, copy the image into the buffer over its range on the GPU (the existing image-to-buffer path) and let the buffer own the bytes, as after any GPU write. Full overwrites still drop directly. SHARPEMU_IMAGE_DROP_WITHOUT_PUBLISH=1 restores the old behaviour. * perf(gpu): poll the timeline at most every 0.5 ms in per-draw housekeeping The completed-submission collection before every draw read the timeline semaphore twice per draw (vkGetSemaphoreCounterValue), about 12 % of the command thread in Ghost of Yotei. The per-draw path now polls at most once per interval and uses the last value otherwise; real waits still read the timeline at once. SHARPEMU_TIMELINE_POLL_US overrides the interval. * perf(gpu): look up known samplers without taking the store lock Every sampler of every draw took the store lock, and the async compute queue contended for it (3.7 % of the command thread in Monitor slow paths). Hits now read a concurrent dictionary; only a miss locks to create. * perf(buffers): read one tracker page per mapped readback Mapped readbacks copy uncached device-local memory at about 300 MB/s, and most want a descriptor word or a packet dword. The window drops from 16 KiB to one 4 KiB tracker page. SHARPEMU_MAPPED_READBACK_KB overrides it. * perf(images): reuse per-thread level scratch when resolving color targets Every draw resolved its color targets with two fresh 16-entry arrays that are only copied into the image description; they were about 10 % of the managed allocation volume in Ghost of Yotei. One cleared pair per thread replaces them. * fix(agc): leave the command buffer alone in Push/PopMarker Ghost of Yotei 1.512 calls the marker exports from a second guest thread on a DCB that the main thread fills with inline-written packets. Appending a marker NOP read a stale cursor and overwrote the game's packets: a tester's dump shows a PopMarker NOP over the first two dwords of a SET_SH_REG, whose stray value dword then failed as an unknown packet (header 0x00000000). Markers are tool-only NOPs on PS5, so by default they now return the current cursor without writing. SHARPEMU_AGC_MARKERS=1 restores the packets for the pass names that traces decode. * diag(shader): say why resource materialization failed Two testers of Ghost of Yotei 1.512 stop on 'could not be materialized ... reason=Other' for one pixel shader, and Other named no step. Each failure site now records what failed and the values it saw (the source and dword that could not be evaluated, the guest address that could not be read, the bad count, stride or descriptor words); the fatal message appends it as detail=. Return values and the fatal/reject policy are unchanged. * fix(agc): preserve marker reservations for the DCB writer Restore packet reservation and capacity callbacks for markers. Suppress markers from another known guest writer under the allocation gate so they cannot overwrite unpublished inline packets. Scope writer identities to canonical memory across native thread wrappers. * fix(gpu): preserve partial images before capturing buffer bindings * fix(audio): report the channel count in AudioOut2 port state * Revert "debug(gpu): dump the whole command buffer on an unknown packet" The full dump identified the tester's crash: a PopMarker from a second guest thread overwrote a SET_SH_REG (fixed by the marker reservation change). Back to the short dump around the bad packet. * fix(shader): probe record-aligned material offsets past the indirect image cap Ghost of Yotei 1.512 stops on 'indirect image 0x494: 72559 unbounded selector probes exceed 65536' for a 2502-record material table with a 116-byte stride. Without a proven selector set every multiple of gcd(stride, 2^32) is probed, because selector * stride + offset wraps modulo 2^32; reaching an offset that is not a record start needs a selector of at least 2^32 / stride. Tables under the cap keep the exhaustive enumeration; past it, the record-aligned offsets are probed and a warning names the image once. * fix(gpu): track guest pages written through device addresses Shaders that store to memory through a runtime V# or a flat/global pointer reach guest memory through the device-address page table, not through a bound buffer. The buffer cache only learned about GPU writes from bound writable bindings, so these stores were invisible to it: the page stayed "clean", the host never downloaded the GPU copy, and the next CPU upload or eviction silently overwrote the GPU result with stale guest bytes (or the CPU kept reading stale bytes). Ghost of Yotei's GPU-driven passes (producer computes filling per-object data and V# tables) write almost exclusively this way. The translator now reports the page of every device-address store and atomic in a second bitmap that follows the fault bitmap in the fault buffer. Non-pixel invocations merge bits of one bitmap word and publish it when the word changes or the invocation ends; pixel invocations, which a discard can end early, publish at once. The fault processor compacts that bitmap with the same pass as the fault bitmap and, once the scan completes, GuestBufferCache.NoteDeviceAddressWrites marks the pages GPU-written exactly as a written binding would: GPU-dirty in the page tracker, recorded in the GPU-modified ranges, the owning buffer's write tick bumped, and overlapping image memory copies invalidated. A page the CPU dirtied before the write is reported cannot be owned by both sides; it stays CPU-owned and the conflict is logged once per power of two. On Yotei these conflicts remain (dozens per run, mostly the producer input pages at 0x50CB...), so mixed CPU/GPU pages can still lose bytes; resolving them needs a byte-level merge and is left for a follow-up. Diagnostics added alongside: - SHARPEMU_TRACE_COHERENCE=1 checks, every fourth presented frame with the GPU idle, that pages the tracker calls clean hold the same bytes in guest memory and in the mapped buffer, and reports each divergence (SHARPEMU_TRACE_COHERENCE_MB sets the slice checked per pass). With SHARPEMU_TRACE_GPU_MEMORY_ADDRESS=coherence the first diverging page is traced. On Yotei the detector went from hundreds of divergences to zero with this fix. - Guest buffers are named "guest 0x<address>+0x<size>" when Vulkan debug labels are enabled, so RenderDoc captures show which guest range a binding is. * fix(gpu): merge shader and CPU writes that share a guest page On the console the CPU and the GPU write one memory, so a 4 KiB page can hold bytes from both. The page tracker gives each page a single owner. When a shader stored through a device address into a page the CPU had dirtied before the store was reported, the page stayed CPU-owned and the next upload copied the whole guest page, stale where the shader wrote, over the GPU copy. The guest never saw those shader bytes either. Ghost of Yotei hits this dozens of times per run (producer input pages at 0x50CB..., per-draw rings at 0x2002...). SharedPageShadows keeps, per such page, the bytes both copies last agreed on and does a three-way merge: - Uploads of a shadowed page copy only the byte runs the CPU changed since the shadow; the shader's bytes in the buffer stay. - When a device-address write is reported on a CPU-dirty shadowed page (once every upload staged for it has executed), the bytes the GPU changed since the shadow are written into guest memory where the CPU left them alone. A byte both changed keeps the CPU value, which the next upload carries to the GPU. - Downloads refresh the shadow, since both copies agree afterwards. A shader-written page gets its shadow when the CPU first touches it: that access downloads the page, so guest memory matches the GPU copy and no extra read of uncached mapped memory is needed. Pages only the GPU uses cost one dictionary entry. A page the CPU dirtied before its first shader write was reported is shadowed from the mapped GPU copy; shader bytes an upload already overwrote there are lost once, and the log says so. At most 16384 pages (64 MiB) are shadowed. On Yotei: 0 unresolved conflicts (8 one-time losses), 0 coherence divergences, no throughput loss in an A/B run (about 5.6k vs 6.2k draws/s over the same cinematic window). The in-game darkening is unchanged, so these lost writes were not its cause. * fix(gpu): expose the partial last word of byte-addressed buffers Storage buffers are declared to shaders as uint[], and Vulkan's runtime array length counts only whole words. A buffer whose size is not a multiple of four therefore hid its last one to three bytes: byte, short and formatted loads there read zero, and stores were dropped. Ghost of Yotei's occluder producer reads a one-byte-per-instance state buffer of 95 bytes. The last three instances were the ones to produce, so the shader saw them as inactive, wrote no matrices, and the depth prepass drew the object with the previous frame's stale matrices: exploding vertices that cover the scene with black bands and holes. Byte-addressed and formatted bindings now get a view rounded up to the next word. The number of padding bytes travels in the two spare bits of the runtime stride entry (strides use 14 bits), and the shader keeps the guest byte bound for those bindings: byte assembly may read the padded word, but an element is loaded or stored only when all its bytes are inside the guest range, and whole-word accesses keep the old bound. The padded view must stay inside the cache buffer, which spans whole pages, so this never reaches past its VkBuffer. The device test reads and stores the tail of 41- to 102-byte buffers, aligned and unaligned, formatted and byte loads, with and without the zero-out-of-bounds read path, and checks that bytes past the guest range stay hidden and untouched; 13 of its 17 cases fail without the padding. * fix(gpu): only wait for shared page uploads that copy bytes A shadowed page's merge waits until every upload staged for it has executed, since until then the GPU copy lacks the staged CPU bytes. The staged tick was advanced for every upload that visited the page, also when filtering removed all of its bytes because the CPU changed none. Such an upload copies nothing, yet merges waited for its tick, and a page re-staged every frame could keep shader writes out of guest memory indefinitely. The tick now advances only for runs that survive filtering and for a whole-page copy into a new owner. The tests cover an eliminated upload followed by a merge and a real pending upload that still blocks it. * fix(gpu): keep shared page shadows when a buffer grows When a request outgrows a cached buffer, the cache creates a larger one and copies the old buffer's GPU contents into it. Shadows of shared pages still named the old buffer as owner, so the next upload into the replacement treated the page as unknown and copied the whole guest page: stale where shaders had written and not yet been reported, it overwrote those bytes in the GPU copy. The shadows (and the pages waiting for their first CPU access) now follow the copy to the replacement, and a merge waits for the copy's tick, since the replacement holds the old bytes only once it executes. The device test grows a buffer between an unreported shader store and the next upload and checks that both shader writes and the CPU write survive. * diag(gpu): watch guest ranges per frame and force full barriers Two opt-in diagnostics used to trace Ghost of Yotei's stale occluder matrices back to the producer that never wrote them: - SHARPEMU_WATCH_BLOCKS=addr:len[,addr:len...] logs, after every presented frame, each watched range whose bytes changed in guest memory or in the GPU copy (both contents, dirty state, submitted and completed ticks), and every cache event touching a watched range: device-address write reports, uploads, writable bindings, CPU write faults, host DMA writes, fills and copies. - SHARPEMU_DIAG_BARRIER_EVERY_CALL=1 records a full memory barrier before every draw and dispatch, to rule missing guest barriers in or out. It is very slow. Both are off by default and cost one branch when off. * fix(gpu): read and write whole words that start inside a buffer range The previous fix padded only byte-addressed and formatted bindings and kept the floor word count as the bound for whole-word accesses. The hardware range-checks a buffer access by its first byte (stride 0 or swizzle off: offset >= num_records is out of range), so a dword load or store that starts inside a range ending mid-word is performed whole. A dword-addressed buffer of 95 bytes therefore returned zero for its last word, bytes 92..94 included, where the console returns the data; whether the read got zero depended on the driver's robust access granularity, not on the guest descriptor. Every runtime-stride view is now padded to whole words, and a word is in range when it is inside the padded view, which is exactly the hardware bound. Byte and formatted elements keep the exact byte limit carried in the runtime stride entry. The new device test loads dwords from 93- to 96-byte buffers with both read paths; three of its five cases fail without the change. * fix(shader): track both words of binary64 vector results (cherry picked from commit 2e339ac4143061e76bfefb4e065b04eba4647f77) * fix(shader): lower half-word logical shifts on Metal (cherry picked from commit fa9776ec2b71a30c6a833562d8e342f5718a612f) * feat(gpu): pack narrow color channels without changing encoded bytes (cherry picked from commit e98fe0b4e68cd5e070124c97d583911561f5fd00) * feat(gpu): transfer narrow sRGB images through expanded backing (cherry picked from commit 9a5f4e08aaf101ebd68ca18d43efac17ec94112c) * fix(gpu): retain explicit pitch for linear color target transfers (cherry picked from commit 88695316e2119b18cb095ae7ad00e1c17ea1f6fb) * fix(shader): decode explicit-LOD comparison gathers (cherry picked from commit a629cc3949cba63b52cfbdc0b41199a3fc1cba79) * fix(gpu): decode narrow sRGB color target outputs (cherry picked from commit 66aa64a01fc4ad984d53fa248b742481d3b54e61) * fix(agc): accept the shader register Ghost of Yotei 2.002 writes at 0x192 Ghost of Yotei Complete Edition 2.002 applies a shader register table at startup that writes 1 to SH offset 0x192 (0x2D92), just past the LS block. gfx10 documents no register there and no shader state depends on it, but the table writer had no entry for it and stopped the emulator right after the splash screen. Ignore it like the other pace and control registers. * diag(agc): log the values written to the undocumented shader register 0x192 The register is still not applied, but the first value and every change are logged, so a rendering difference in Ghost of Yotei 2.002 can be traced back to what the title wrote there. * perf(shader): look runtime descriptors up through one shared function Reading buffer-table descriptors at run time (90e35ba8) inlined the hash and the eight probes of the runtime descriptor table at every image and sampler access. A Ghost of Yotei pixel shader with 56 such accesses grew from 419 KB to 2,051 KB of SPIR-V and took about 6.5 s to compile instead of 0.5 s. The image and sampler lookups are now one DontInline function each, called with the key and the lane's EXEC state, as the device buffer format decoder already is; the same shader is 507 KB and still binds only the records it reads. * fix(shader): read format bytes in a buffer's last partial dword on the device A format load through a device-side V# assembled each component byte from its aligned dword, and that dword read zero unless all four of its bytes were below num_records. The hardware range-checks the element, so the last one to three elements of a byte buffer whose size is not a multiple of four read 0 instead of memory. Ghost of Yotei's culling updater reads each object's 8_SINT visibility state, skips the store when the new state equals the one it read, and counts the element. Its 19-byte state buffers read 0 for elements 16..18, so the store was skipped while the element was counted: counts[] exceeded the instance slots the producer wrote, and the extra instances drew as black blocks. The dword is now read when any of its bytes is inside the buffer; the existing per-component check still zeroes a component past num_records. * fix(loader): prove jump table bounds and tables over the control-flow graph The red-zone patcher refused every short faultable site of a function whose jump tables it could not resolve. The resolver only accepted a lea-only window between a 32-bit compare and the table load, so Ghost of Tsushima's render thread kept unprotected accesses in a leaf function that holds a pointer in the red zone, and a host exception dispatch clobbered it. Resolve each table by walking the function's control-flow graph backwards from the load: every path must pass the fallthrough of ja after an unsigned compare of the selector, reaching the load through register moves and zero-extensions only, and must define the table register with lea of the same RIP-relative table. The graph includes the resolved table edges, and resolution repeats until a round reproduces its own targets. Tsushima's indirect-branch refusals drop from 55 to 8. * fix(agc): accept the user-config register Ghost of Yotei 2.002 writes at 0x191 The 2.002 build writes 0 to user-config offset 0x191 from a register table, right after shader register 0x192. No gfx10-12 register lives there. Accept it and log value changes, like 0x192. * fix(images): keep a mapped mip chain whole when a texture starts past mip 0 A sampled texture whose descriptor starts past mip 0 was always made an image of only the levels from there, for streamed textures whose larger mips are not mapped. A pass that samples a lower mip of an image the GPU rendered (Demon's Souls' fog and bloom chains) then got a separate image of the same memory, filled from stale guest bytes and traded with the render target every frame: white blocks across the fog and 0.2 fps. The image cache now keeps the resident-levels form only when the chain is not fully mapped; otherwise the texture is the whole chain viewed from its base level, the same image as every other view of that memory. * fix(np): report the package's real trophies from sceNpTrophy2GetTrophyInfoArray b5b3d691 treated rdx as the first trophy id and always returned the requested limit as the count. The call is (context, handle, offset, limit, details[], data[], *count): offset indexes into the package and the count is how many trophies exist from there, capped by limit. Hades asks for 50 and then walked past its own on-stack arrays, crashing in a job thread before the first frame. Read sce_sys/trophy2/trophy00.ucp (unencrypted container with tropconf.json and tropmeta_*.json) and fill SceNpTrophy2Details (1312 bytes) and SceNpTrophy2Data (32 bytes) for the trophies that really exist, all locked. Layouts and the package format follow KytyPS5's NpTrophy2 implementation. Co-authored-by: Felipe <54341095+Pipe530@users.noreply.github.com> Co-authored-by: nmzik <Nmzik@mail.ru> * chore(audio): mark the YoteiPC-derived ATRAC9 code as GPL-2.0-only The multichannel block ordering in Atrac9DecodeState follows YoteiPC's at9_api.c, which its author publishes under GPL-2.0 (no "or later" grant). The file now says GPL-2.0-only with the source and author named, and the license text is added for REUSE. LibAtrac9 itself stays MIT. --------- Co-authored-by: ParantezTech <12572227+par274@users.noreply.github.com> Co-authored-by: kuba <xnetcat.dev@gmail.com> Co-authored-by: MathiasYG <06mathias6@gmail.com> Co-authored-by: voidborn_astra <41128975+voidborn-astra@users.noreply.github.com> Co-authored-by: Felipe <54341095+Pipe530@users.noreply.github.com> Co-authored-by: nmzik <Nmzik@mail.ru>	2026-10-12 15:26:47 +02:00
ParantezTech	a298369293	[Demo] remove bg music from bundled demo	2026-10-10 16:40:10 +03:00
T	4d5697892e	[HLE] Savedata and np fixes (#1080) ... * [SaveData] Read the dialog mode and user data at their offsets in the open parameters * [SaveData] Report each slot's own block count instead of the fixed maximum * [Np] Report the offline profile as signed out from sceNpCheckNpReachability	2026-10-10 15:44:13 +03:00
Usif	46a7d3a446	[Kernel] Keep oversized reservations at the guest's hint and sign-extend user event ids (#1073) ... * [Kernel] Keep an oversized reservation at the guest's hint instead of failing A 768 GB sceKernelReserveVirtualRange with a hint at 0x1000000000 cannot use the sparse aperture (it starts at 256 GB, and 256 GB plus 768 GB passes the 1008 GB user limit), so it needed one contiguous host placeholder. When a host allocation made before the startup reservation sits inside that window, the call fails with 0x8002000C and the guest stops at boot. Reserve such a range at the guest's own hint as a guest-only sparse range, as smaller large reservations already are. * [Kernel] Sign-extend the int id of user events into the event ident sceKernelAddUserEvent, sceKernelAddUserEventEdge, sceKernelDeleteUserEvent and sceKernelTriggerUserEvent take an int id, which the kernel stores in the uintptr_t ident of the event. A negative id such as -1 therefore reads back from sceKernelGetEventId as 0xFFFFFFFFFFFFFFFF. The exports used the zero-extended register (0x00000000FFFFFFFF), so a guest that treats a negative id as a wake-up event took its normal event path instead and never went back to wait. Use the sign-extended id in all four exports.	2026-10-10 03:39:51 +03:00
Berk	f32266834c	[SharpEmu] Add bundled demo game (#1072)	2026-10-09 17:41:17 +03:00
ParantezTech	0af8dce081	[GUI] improve library tile collection and acceleration fixes	2026-10-09 14:55:12 +03:00
qwe1qwe	289f090b50	[GPU] Align linear color target pitch like linear textures (#1063)	2026-10-09 14:07:12 +03:00
Berk	47d4c07a8d	chore: bump version to 0.0.5-nexus-release.2 (#1070)	2026-10-09 01:53:47 +03:00
Berk	1811cef944	Ports another set of compatibility and GPU fixes from PR #1016 (#1069) ... * [Cpu] Prefer LLE for libc FILE-object exports * [Libc] Add file-lock compatibility exports * [Kernel] Expose the process argument count and vector Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [AppContent] Report missing add-on content entitlements Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Videodec2] Decode guest access units into pitched NV12 frames Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Network] Add the RUDP context lifecycle Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [SharePlay] Report inactive share-play state Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Np] Complete offline authentication requests as signed out * [Kernel] Warn when APR cannot resolve a resource path * [GPU] Skip piece hashing for stencil association proxies * [VideoOut] Add deduplicated volume texture binding traces * [SpirvTranslator] Match guest F32 denormal and trigonometric semantics Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Network] Add socket epoll registration and readiness waits Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Network] Close POSIX socket descriptors through sceNetSocketClose Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Network] Add Ethernet address string conversion Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Json] Track the global special-float handler Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Json] Add the special-float format setter Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Pad] Add the n3kSX62fgNo compatibility export * [Pad] Trace input state changes when requested * [PlayGo] Keep unknown chunk lists empty Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [PlayGo] Keep chunk metadata parsing in the metadata loader Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [PlayGo] Expose runtime state reset Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [PlayGo] Add install and optional chunk queries Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Loader] Preserve switch targets while patching guest red-zone accesses Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Loader] Report patching progress for large executables * [SpirvTranslator] Preserve F32 signed zero, infinity and NaN when supported Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [GPU] Use Gen5 render-target tile equations on the CPU and GPU Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [GPU] Decode DCC fixed and register clear values Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [GPU] Track DCC metadata coverage for color targets and volume textures Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [GPU] Materialize DCC slice clears from guest metadata Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Tests] Cover Gen5 tiling, DCC clears and offline authentication Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Tests] Match red-zone coverage to forward-only patching * [Pad] Track independent standard, special and remote port handles Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [UserService] Add user number and termination exports Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [NP] Expose the game trials flag * [Kernel] Allow renaming and unlinking open guest files Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Tests] Cover controller ports, user exports, trials and open-file renames Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Kernel] Clear the outputs and report no space when no direct memory span is free Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Kernel] Return POSIX results from _open and keep sceKernelOpen raw Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Kernel] Open /dev/random and /dev/urandom as host RNG descriptors Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Kernel] Read random device descriptors from the host RNG Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Kernel] Close random device descriptors Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Kernel] Report random device descriptors in fstat Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Cpu] Place the guest exception mcontext at the start of the context Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Cpu] Report the flags and Sony stack alias in guest exception contexts Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Cpu] Expose the guest exception context writer to tests Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [NP] Keep Universal Data System handles across repeated initialization Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [NP] Create Universal Data System contexts before explicit initialization Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [NP] Reset Universal Data System state with the runtime Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Pad] Write the device class extended information at its guest size Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Pad] Add scePadDeviceClassParseData Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Tests] Cover random devices, POSIX open, UDS initialization, pad class data and exception contexts Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [SaveData] Write the mount info structure at its 48-byte guest size * [Stubs] Add sceTextToSpeech2Cancel and sceTextToSpeech2GetSpeechStatus Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Kernel] Add sceKernelSync Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com> * [Loader] Patch red-zone sites from the previous instruction when every indirect branch is resolved * [Tests] Cover backward red-zone spans, direct memory no-space results and the mount info size --------- Co-authored-by: Sekai <140012992+SekaixX@users.noreply.github.com>	2026-10-09 01:44:45 +03:00
Berk	b02c06181a	Unity fixes 1016p2 (#1062) ... * [Audio] Snapshot AudioOut2 PCM when the guest submits it Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Audio] Drop the ports of a destroyed AudioOut2 context Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Audio] Accept sceAudioOut2MasteringSetParam Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Audio] Resolve AudioOut2 out-buffers from either ABI slot Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Audio] Report the AudioOut2 context memory size through its out pointer Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Audio] Keep the AudioOut2 queue level and availability pointers apart Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Audio] Report full volume in the AudioOut2 port state Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Audio] Trace AudioOut2 port, attribute and bed calls Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Audio] Let tests replace the AudioOut2 host streams Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Audio] Add the AudioOut2 vibration port type Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [SaveData] Lay out save data events with their title ID Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [SaveData] Add sceSaveDataBackup Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [SaveData] Add sceSaveDataDirNameSearch2 Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Network] Track Http2 template and request options Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Network] Add Http2 option, cookie and request exports Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [CommonDialog] Add the web browser dialog lifecycle Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Json] Add the InitParameter2 base constructor Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Json] Add InitParameterRtti2::setAllocatorRtti Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [AvPlayer] Accept available bandwidth hints Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Tests] Cover the AudioOut2, save data, Http2 and dialog exports Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> --------- Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com>	2026-10-07 18:47:42 +03:00
kuba	e1edda7772	Revert the 18 Silent Hill rendering and performance merges (#1065) ... Restore review-only delivery at the user request. Reverts #1024, #1025, #1031, #1032, #1033, #1034, #1035, #1036, #1037, #1038, #1039, #1040, #1041, #1051, #1054, #1055, #1058, and #1059. The resulting tree matches 3e2ad633 exactly.	2026-10-07 12:15:45 +02:00
kuba	775141d58c	[GPU] Sweep CPU writes at memory visibility points instead of before every device-address program (#1033) ... * [GPU] Sweep CPU writes for device-address programs at memory visibility points A device-address program may read any mapped page, so before each such draw or dispatch the buffer cache uploaded every CPU-dirty page whenever the global CPU-dirty epoch had moved. A guest that streams its per-draw ring while the command stream is being translated moves the epoch between almost every pair of draws, and each upload ended the rendering scope and drained the GPU with an ALL_COMMANDS barrier pair - about 670 times per frame in Silent Hill: The Short Message's menu. CPU writes only need to be visible at memory visibility points: when a submission slice starts, when a wait packet is satisfied, and after a command-processor memory write (later commands may read those bytes through device addresses). The sweep now runs at the first device-address program after such a point, and its uploads share one barrier pair instead of one per buffer. SHARPEMU_BDA_SWEEP_EVERY_DRAW=1 restores the per-draw sweep. Menu GPU time drops from about 435 to 290 ms per frame. (cherry picked from commit fafe92b71271cf750dd89251891bac20fb87f1ff) * [GPU] Let command-processor DMA writes turn pages CPU-dirty instead of copying A DMA fill or copy into memory without GPU-written bytes is executed on the CPU, and the bytes were then pushed into every overlapping cache buffer through a staging copy and a barrier pair, which ends the rendering scope (~60 per frame in Silent Hill: The Short Message's menu). When no GPU-written byte shares the written pages, the pages now simply turn CPU-dirty: every later GPU reader synchronizes CPU-dirty pages before reading (bound buffers on obtain, device-address programs at the next memory visibility point, which the write now raises), so the bytes still arrive in command order. Pages that hold GPU-written bytes keep the staging copy. SHARPEMU_DEFER_HOST_WRITES=0 restores the copy. (cherry picked from commit 3fe21faa3821551fa99b9398064f0652e45d2e84) * [GPU] Keep hot CPU-written pages writable across device-address sweeps A page the guest rewrites every frame turns hot after two upload/write cycles, and the bound-buffer path then serves it from the stream ring so the page stays writable. The device-address sweep and the range synchronization still re-protected hot pages after every upload, so the guest's next write to each ring page took a protection fault - about 5,000 faults per second on Silent Hill: The Short Message's render thread, each a signal round trip under Rosetta plus page-guard lock traffic shared with the command worker. Both sweeps now preserve hot pages: they stay dirty and writable and are copied again on the next sweep, a few hundred KiB of ring memory per sweep. Faults drop to a third and the menu goes from 3.8 to 4.2 FPS. SHARPEMU_BDA_SWEEP_REPROTECT_HOT=1 restores the re-protection. (cherry picked from commit 65d2b55ddc07644d52e5ad3112cbe323a2421abd) * [GPU] Refresh writable hot pages at every BDA visibility point	2026-10-07 11:52:12 +02:00
kuba	38f7196470	[GPU] Add internal render resolution scaling (#1038) ... * [VideoOut] Add an internal render resolution scale option Adds the host-side setting an internal-resolution implementation needs: --render-scale on the command line, SHARPEMU_RENDER_SCALE for scripted runs, and a global and per-game choice in the GUI. The value is a host resolution multiplier of the guest render targets, normalized to a hundredth in [0.25, 2] so the command line, the GUI and the environment agree bit for bit; the renderer compares scales when it decides whether two views of the same guest memory match. RenderScalePolicy holds the decision rule. It is a pure function of the guest image description, so every view, alias, copy and descriptor of one guest range reaches the same answer without consulting the cache. Only screen-class, single-level, single-sample, uncompressed 2D render and depth targets scale; block grids, multisample footprints, HTile and DCC coverage, mip chains, cube and array faces, asset tilings and small surfaces (shadow maps, lookup tables, eye-adaptation readbacks) keep their guest resolution. The environment variable wins over the stored setting so test runs do not depend on the user's configuration. No renderer consumes the scale yet; a scale of one is the current behaviour everywhere. * [GPU] Hold scalable guest images at a host render resolution The backing of an image the scaling rules accept is created at ceil(guest * scale) while its ImageDescription keeps the guest geometry, so the cache, the overlap rules and the page tracker go on reasoning in guest bytes. Everything that moves guest bytes now goes through a guest-resolution twin of the scaled image: an upload fills the twin from the copy regions the tiler built and blits into the backing, a download blits the backing into the twin and copies out of it. A copy whose two images disagree on host resolution runs at guest resolution the same way, so callers keep describing rectangles in guest pixels; the destination seeds its twin first because a partial copy is blitted back whole. The multisample depth conversion takes a guest-sized source for the same reason, and the resolve region crosses into the destination's resolution instead of silently resolving the top-left corner. Two fallbacks keep correctness ahead of the saving. A format that cannot blit keeps its guest resolution, since the twin could never reach it. A storage image drops back to guest resolution the first time a compute shader binds it: the dispatch grid does not shrink with the host image, so the shader would write it with holes above 1.0 and redundantly below. The guest range is remembered, so every later image over that memory is created unscaled too. * [GPU] Scale the render area, viewport and scissor with the attachments A resolved target now reports the host extent of its attachment beside the guest one, and the three places that size rasterization follow it: the dynamic rendering area, which also bounds every load-op clear; the guest viewport transform; and the guest scissor, whose edges round outward so no guest pixel the game asked for loses host coverage. All attachments of a pass share one rule, so the first bound target decides the factor. The clip-disable path needs care because the vertex program bakes the viewport transform against a reference extent. Dividing that reference by an upscale keeps the host viewport (reference x scale) inside the device limit while the baked transform stays scale independent, so the same program maps guest pixels onto host positions at either resolution. At a scale of one the reference is the device limit, exactly as before. * [SpirvTranslator] Translate pixel positions and image coordinates across the render scale A program expresses its pixel position, its integer image coordinates and the sizes it queries in guest pixels, but the host may hold the image behind any of them at another size. Which images are scaled is a per-draw fact, so the factors travel in shader data rather than in a permutation: the coordinate factor, its reciprocal, a 64-bit mask of scaled image resources and the factor the pixel position is divided by. With that: - gl_FragCoord is divided by the attachments' factor as it is loaded, so POS_X/POS_Y, POS_FIXED_PT and everything derived from them - screen UVs above all - stay in guest pixels. - An integer image coordinate is mapped onto host texels through the bound image's factor. Only the two scaled axes move; an array layer or a volume slice is not a pixel. - A resource-info query reports the guest size, because the program derives coordinates and loop bounds from it. A select against the mask makes an unscaled binding cost one instruction, and the layout only carries the dwords when the scale is not one, so nothing changes at native resolution. * [GPU] Keep one host resolution across the attachments of a pass A rendering scope has one render area, one viewport and one scissor, so its attachments have to agree on a host resolution. They disagree when one of them cannot be scaled at all - a depth target with a stencil plane next to a scalable colour target, say - and the pass then renders a fraction of its area. The draw now drops every scaled attachment back to guest resolution and resolves its targets again; the guest ranges are remembered, so the decision converges after one draw and cannot oscillate. That fallback only works if the executor knows what the cache actually gave it, which is not what the scaling rules would answer: a demoted range still looks scalable to them. The resolved targets therefore carry the image's own factor, and the render area, viewport, scissor and the depth/stencil copy extent read it from there. Two rules change with it. DCC only describes guest bytes the host never stores, so a colour target that carries it can still be scaled; HTile encodes guest depth blocks the renderer reads back as clear state and stays native. And a storage image only drops back when the program actually writes it, since a read-only load is mapped correctly. Scaling now also requires a backend that installed the format predicate - the Vulkan device - so the Metal host is unaffected. * [Docs] Describe internal resolution scaling and its limits Replaces the note saying arbitrary internal resolution scaling is not implemented: it is, for screen-class render and depth targets. Records what the renderer translates (rasterization, shader coordinates, guest transfers, presentation), the exact rule for what scales, every case that falls back to guest resolution, the artefacts measured on Silent Hill, and the per-scope GPU times at 50, 100 and 200 percent. * [SpirvTranslator] Preserve guest texel offsets at scaled resolutions	2026-10-07 11:47:58 +02:00
kuba	8acc081205	[GPU/HLE] Cut per-draw and per-call managed allocations on hot paths (#1054) ... * [GPU/HLE] Cut per-draw and per-call allocations on hot paths * [HLE] Keep nested tracker uploads from sharing rollback scratch	2026-10-07 11:36:27 +02:00
kuba	98f223ce69	[GPU] Restore scene visibility and half-wave shuffles (#1025) ... * [Agc] Emit addressed draw events for occlusion query counters * [Gpu] Keep fallback occlusion results coherent and conservatively visible * [Gpu] Honor disabled color buffers during depth-only draws * [Gpu] Upload complete unchecked constant vertex attributes * [Agc] Emit direct draws for every draw modifier sceAgcDcbDrawIndex and sceAgcDcbDrawIndexAuto returned without writing a packet unless the modifier was exactly 0x40000000. The modifier names the shader stage and user registers of the bound pipeline, so any other pipeline lost its draws without a trace. Unreal bakes its color-grading LUT through a geometry-stage pipeline, which left the LUT unwritten and tinted every 3D frame of Poppy Playtime blue. Both draws now emit their packets for any modifier. Modifiers other than the vertex-stage default are logged once each. (cherry picked from commit 8d46a6068b7d1a999662eeac1ee17f9e6d87c2eb) * [VideoOut] Separate guest display mode from presentation buffer dimensions * [GPU] Map half-wave shuffle lanes into the host subgroup * [Docs] Explain display modes and internal resolution limitations * [GUI] Translate guest display mode settings in all supported languages	2026-10-07 11:21:15 +02:00
kuba	8b631d3b03	[GPU] Avoid command-worker readbacks for clean bytes on GPU-dirty pages (#1059) ... * [GPU] Read clean command bytes without faulting on neighbouring GPU data * [Tests] Enable portable Vulkan devices and release fixture slabs	2026-10-07 11:21:09 +02:00
kuba	a9356eb8d2	[GPU] Read guest buffers back from unified memory without a copy (#1058) ... A CPU read of GPU-written guest memory recorded a copy at the tail of the current command buffer and waited for it, so it also waited for every draw recorded after the writer. In Silent Hill's title menu most of those reads targeted buffers whose writer had retired long before, and UE's render thread spent a third of its time in them. On a device with device-local, host-visible, coherent memory (Apple GPUs), guest buffers are now allocated there. A readback whose writers retired copies straight out of the buffer's mapping; one whose writer is submitted but still running waits for that submission alone and then copies; the command worker submits a writer that is still recording and reads after it. A guest-thread wait also marks its window hot, so the next GPU write there is submitted right after its command. SHARPEMU_UNIFIED_BUFFERS=0 keeps device-local buffers.	2026-10-07 11:02:22 +02:00
kuba	a73e424a27	[macOS] Fix the Rosetta GC wedge, a CPU-flip buffer-wait deadlock and frozen host movies (#1051) ... * [CLI] Restart under Rosetta with a 64 MiB gen0 GC budget Every collection suspends the runtime through FlushProcessWriteBuffers, which Rosetta 2 services by parking each thread in its runtime (notify_thread_waiters). A signal that reaches a parked thread trips Rosetta's "expected saved LR to be in translated code" assertion and wedges the process; Demon's Souls hit it in about half of its 3-5 minute runs while collecting almost twice a second. The gen0 budget is only read from the environment, so the process re-executes itself once with DOTNET_GCgen0size set (same pid). With 64 MiB, Demon's Souls collects about once every 6 seconds, gen0 and gen1 only, 0.26 s of pauses in 110 s. A 512 MiB budget made every collection a blocking gen1/gen2 pass of about a second. SHARPEMU_ROSETTA_GC_BUDGET=0 opts out. * [VideoOut] Let a buffer wait ignore CPU flips the graphics queue has not reached sceVideoOutSubmitFlip reserves its flip request, may sleep for pacing, and only then queues the flip preparation on the graphics queue. A command buffer submitted before it that starts with sceAgcDcbWaitUntilSafeForRendering on the same display buffer saw the reserved request as pending and waited for a preparation queued behind itself: the graphics queue never advanced and every compute queue waiting on its labels stalled with it. Demon's Souls hung this way on the boot splash in about one run in three. A CPU flip now counts for the wait only once the graphics queue runs its preparation; GPU flips are ordered from their packet. (cherry picked from commit 8915df35abad5fe8b15cc6418f1e563785d6e008) * [Media] Expire a host movie only once its playback stops advancing Host playback follows the guest's own Bink decode and audio clock, so on a slow host a movie plays slower than real time. The watchdog fired at the movie's duration plus a minute regardless, marked the file timed out and forced EOF on the guest's reads while its decoder was still mid-stream: Demon's Souls' 171 s attract movie froze on its last host frame for good. The watchdog now re-arms while frames keep advancing and expires a movie only after a minute without progress. (cherry picked from commit daad0f097d0c6369097aeef32b55c9f2d171110a) * [CLI] Preserve the managed entry point when restarting under Rosetta	2026-10-07 11:02:17 +02:00
kuba	a0fd9dcb83	[GPU] Restore half-float arithmetic and image readback state (#1024) ... * [Gpu] Cover the whole tile plan when a buffer reads back an image TrySynchronizeBufferFromImage sized the copy from the mip layout, but the tile plan of a fully fitting image can extend past it; Silent Hill hit a 128x128 slice planned at the exact end of the mip chain and the tiler aborted the process. Grow the copy to the plan's tiled end when the buffer holds it, otherwise keep the guest bytes. * [SpirvTranslator] Read half-selected V_FMA_MIX literals as f16 op_sel_hi marks a V_FMA_MIX operand as f16 for literals too, but literals were always read as f32 bit patterns. Silent Hill's deferred lighting weights a luminance with the f16 literals 0x34CD/0x38B8/0x2F0A (0.30, 0.59, 0.11); as f32 denormals they made the luminance zero, the shader clamped it to 1e-4 and divided by it, and the title-menu scene came out thousands of times too bright, which auto exposure then turned black. * [Gpu] Materialize every fixed DCC clear code on a sampled image A DCC fast clear stays pending until the surface binds as a colour target; when a shader samples the surface first, only the clear-to-zero code was materialized. The other fixed codes (alpha 1, rgb 1, rgba 1) carry their own colour too. Silent Hill fast-clears UE's separate-translucency target to (0,0,0,1) and only samples it, so the post composite read stale zeros and the whole title-menu scene came out black. * [SpirvTranslator] Keep wave64 LDS phase barriers when a half-mask plan applies The half-mask plan's barriers order its own mask exchanges, not the program's shared-memory traffic, yet planning a program switched the LDS phase ordering off. UE's FFT bloom (wave64, 512 threads, LDS butterflies) then read half-written rows: Silent Hill's convolution output collapsed into a flat haze (max 56 for a scene peaking above 1500) and the histogram fed by it never adapted exposure. * [Gpu] Publish linear GPU-written images to guest memory by default Unreal reads its eye-adaptation result back on the CPU through a linear staging texture (FRHIGPUTextureReadback) and derives View.PreExposure from it. The image cache was built with linear readback disabled, so the CPU always read zeros, PreExposure stayed 1.0 and the scene rendered without pre-exposure. FFT bloom's bright-pixel prefilter, which works in pre-exposed space, then flattened every pixel to its max luma and the Silent Hill title menu came out nearly black. SHARPEMU_READBACK_LINEAR_IMAGES=0 restores the old behaviour. * [Tests] Enable MoltenVK portability devices in headless harness * [SpirvTranslator] Saturate V_CVT_PKRTZ_F16_F32 at 65504 instead of overflowing to infinity Rounding toward zero never produces infinity from a finite value: past the f16 range the result is +-65504. We truncated the mantissa and let packHalf2x16 round, so large values became infinite. Silent Hill's deferred lighting packs title-menu values past 65504; its height fog then multiplies scene color by a tiny transmittance, which keeps 65504 finite but leaves an infinity infinite, a later pass turns it into NaN and the whole 3D menu background renders black. Subnormal results now also keep whole 2^-24 steps. A MoltenVK device test covers overflow, truncation, subnormals, NaN and inf. * [Tests] Wait for the blocked worker before publishing its signal	2026-10-07 10:59:57 +02:00
kuba	4e6d1e0d9a	[HLE/Cpu] Remove host lock contention from POSIX memory queries, thread resumes and timed waits (#1031) ... * [HLE] Answer POSIX host memory queries without the mapping lock Every HLE import that reads stack arguments queries the guest stack's protection first. On POSIX the query took the same lock Protect holds across its mprotect call, and GPU write tracking protects pages constantly, so each query waited tens of microseconds; Silent Hill: The Short Message spent up to a second of every five seconds in queries. Regions are now also published as an immutable snapshot (replaced under the lock when a region is added or removed), and a query of untracked memory or of a region without per-page overrides is answered from it without the lock. Regions with overrides keep the locked path, which now finds where a protection run ends through an ordered set of overridden pages instead of visiting every override (write tracking leaves tens of thousands), and the next region by binary search. Query time drops from 200-1000 ms to 5-50 ms per 5 s. This is the POSIX counterpart of replacing page-by-page VirtualQuery scans on Windows. (cherry picked from commit b6ffe31f28fa93842726b71315c7731f97b5fda8) * [Cpu] Sleep through nanosleep, resumed on EINTR, in the POSIX Sleep stub The POSIX stand-in for kernel32!Sleep (which the native sceKernelUsleep intrinsic calls with milliseconds) converted to microseconds and called usleep. macOS rejects usleep(>= 1 s) with EINVAL and returns at once, so every guest sleep of a second or more came back immediately; and a signal (the runtime's thread activations, for one) ended any sleep early through an error the stub never looked at. The stub now builds a timespec and calls nanosleep, and when nanosleep returns EINTR it resumes with the remaining time. A test exercises the stub with the Win64 argument register for both a 1.2 s and a 20 ms sleep. (cherry picked from commit 43b770f86b5e3aa2332121f1bc2ddf2acc9d2968) * [HLE] Query POSIX view regions from a lock-free snapshot Every HLE import first queries the guest stack's protection, and the view-region query took the same gate the GPU write tracker holds across its mprotect calls, so each import waited on page-protection traffic from other threads (the main guest thread spent ~2% of its time in that wait at Silent Hill: The Short Message's menu). The region list is now also published as an array snapshot whenever it changes, and queries read the snapshot without the gate. Per-page protections already changed in place and were read racily; nothing changes there. (cherry picked from commit d7e72cb4974388883696516420b2e9d462778715) * [Cpu] Skip the scheduler gate when a host thread re-registers the same guest context scePthreadSelf on a guest thread the scheduler does not own registers the thread's context on every call, and that took the scheduler-wide gate each time - tens of thousands of times a second on Silent Hill: The Short Message's main thread, contending with the dispatcher and every blocked-thread wake. Each host thread remembers the handle and context it registered last; a repeat registration only refreshes the external-handle hint and returns. New or changed registrations still take the gate. (cherry picked from commit d1991b2b75261cd1f1ccb4e005b10805f0da24c1) * [Cpu] Keep each thread's guest continuation stub instead of mapping one per resume Every resume of a blocked guest thread allocated a 512-byte executable stub page and a host-RSP slot, and released both when the thread blocked again: an mmap/munmap pair plus two acquisitions of the host-memory gate per resume, which the GPU write tracker holds across its own protection changes. Contended on that gate, resumes were 62% of all lock waiting in Silent Hill: The Short Message's menu. Each host thread now keeps a stub page and slot per nesting depth for its lifetime; a resume reopens the page for writing with mprotect directly (the page is emulator-private, so it bypasses the tracked host-memory layer), re-emits the stub and seals it again. Lock waiting across threads halves (13.6 s to 6.5 s per 30 s). (cherry picked from commit 2c2293abdd5d19dd1be3d6941dcedf9b482c6420) * [Kernel] Round host condvar waits up to whole milliseconds Monitor.Wait truncates its timeout to milliseconds, so a timed wait with less than 1 ms left became a zero timeout and spun until the deadline. UE's game thread waits for the render fence in 1 ms slices, which kept a host core busy for the whole wait and contended the condvar lock with the signaling threads. Timed waits may wake late, so round up instead. SH menu 4.29 -> 4.64 fps together with the readback retry change. (cherry picked from commit 66eaa0095fe594ff8e285cbf31c32bd84274ac85) * [Tests] Run the POSIX Sleep stub test only in x64 processes The stub is x86-64 machine code; a native arm64 test host cannot map or run it, so the macOS arm64 CI runner failed to allocate the stub page.	2026-10-07 10:56:03 +02:00
kuba	d809f84491	[SpirvTranslator] Share one EXEC test across a run of vector ALU writes (#1040) ... A vector register write is modelled as select(EXEC, result, old value), so the old value of every register the shader writes stays live across the write. That guard is the translator's largest per-instruction cost: dropping it altogether (wrong results) takes Silent Hill's volumetric-fog compute from 13.43 to 10.64 ms, and the exec-full analysis can only prove 194 of its 875 instructions run with every lane set. A run of instructions whose only effect is their vector destination can instead run inside one if (EXEC). The masked-off lanes skip the whole run, which is what the hardware does to them anyway, and only the join needs the old values. A run stops at anything the wave runs even where this lane is masked off: SALU is not EXEC masked and every invocation keeps its own copy of the scalar registers, a compare writes VCC or EXEC (GFX10 keeps that destination in the instruction's control, not in its destination list), a cross-lane read needs its neighbours to have run, and LDS, memory and the DPP encodings reach outside the register. Six instructions is where the branch starts paying for itself. Compute only: the same grouping made the deferred lighting pixel program 28% slower (11.03 -> 14.11 ms per scope), where a wave already runs with helper lanes. SHARPEMU_EXEC_RUN=0 turns it off, SHARPEMU_EXEC_RUN_MIN sets the length. Silent Hill title menu, same build, SHARPEMU_EXEC_RUN=0 vs on: offline replay min ms fog D5DF9DC46C4E35EA 13.42 -> 12.21 (-9.0%) FFT 674E5A7163897BC9 16.37..17.38 -> 17.06 (flat) NGG B482CD3A01A37F0F 0.494 -> 0.492 (unchanged) in-game ms per dispatch fog D5DF9DC46C4E35EA 16.59 -> 15.34 (-7.5%) FFT 674E5A7163897BC9 13.81 -> 13.77 2BFB24830D8FCFAA 4.78 -> 4.58 (-4%) in-game ms per scope 848AFAD7/9D180B8A 11.03 -> 11.36 (unchanged SPIR-V) F987C1A4/379BE850 1.90 -> 1.72 (unchanged SPIR-V) spirv-val passes on the fog, FFT and NGG modules; the menu image is unchanged with Anita present.	2026-10-07 10:52:01 +02:00
kuba	da0953845b	[SpirvTranslator/Vk] Cheaper guest buffer loads and f16 conversion, gated on device probes (#1035) ... * [SpirvTranslator] Load dword-aligned 32-bit formatted buffer components as words A formatted untyped buffer load decodes the descriptor format at run time, reading every component byte by byte through the generic layout select chain. For dword-aligned 32-bit data formats (32, 32_32, 32_32_32, 32_32_32_32) with a raw-bit number format (UINT, SINT, FLOAT) a component is one buffer word; that branch loads it directly and applies the same swizzle and bounds rules. The descriptor is uniform, so the branch does not diverge. UE GPU-skinning vertex shaders fetch bone data this way; Silent Hill: The Short Message's menu goes from 1.3 to 2.0 FPS. (cherry picked from commit 20540cd153855964d817daf065de3e243fd547bd) * [SpirvTranslator] Convert f16 with the native pack/unpack when the host measured it exact Every packed-f16 (VOP3P) lane widens its operands to f32 and rounds the result back, and both conversions were the branchless integer sequences in EmitHalfToFloat / EmitFloatToHalf: about twenty scalar ops each, because GLSL UnpackHalf2x16 / PackHalf2x16 have no guaranteed rounding or subnormal behaviour without float-controls execution modes. A device capability bit does not settle it either - MoltenVK on Apple silicon reports shaderRoundingModeRTEFloat16 and shaderSignedZeroInfNanPreserveFloat16 yet not shaderDenormPreserveFloat16 - so only a measurement can. ShaderCompileRequest.NativeHalfConversionExact, which the host sets only after measuring the two ext instructions against these sequences on the running device, swaps both helpers for the single ext instruction the driver lowers to one hardware convert. It defaults to false, so an unmeasured device keeps the exact emulation. Silent Hill f2 volumetric fog dispatch: 30.7 -> 21.9 ms per dispatch in replay, output unchanged. (cherry picked from commit 10f76eeac0d4306172e41ecff86b737f6a3c9634) (cherry picked from commit 7f18cc96ae58ac5fd47da6562c4ba3abe22ccb4a) (cherry picked from commit 972f658033f8339effe42c5d305af87bcbab93f0) * [Vk] Probe f16 conversion at device setup and report the verdict A one-time compute pass at device setup measures the device's GLSL UnpackHalf2x16 / PackHalf2x16 against the translator's own f16 conversion before any guest shader is compiled, and only a clean measurement lets the translator use them (ShaderCompileRequest.NativeHalfConversionExact). The vectors cover all 65536 f16 bit patterns, every f16 value widened to f32, the midpoint between adjacent f16 values and that midpoint one f32 ulp either way, the overflow edge, signed zeroes, infinities, NaNs and f32 subnormals, and each is measured in both directions: 643200 comparisons. Every finite value, zero and infinity must be bit-exact, sign included. A NaN only has to stay a NaN, because neither side defines its payload: the emulation picks sign | 0x7C00 | 0x200 narrowing and carries the f16 payload widening, while the measured hardware convert canonicalizes to a positive quiet NaN. On an Apple M4 that is the only disagreement - 2314 of 643200, every one a negative NaN whose sign the hardware cleared - and f16 subnormals convert exactly despite shaderDenormPreserveFloat16 being false. The probe never fails device setup: any error leaves the exact emulation in place and says so on the reported line. SHARPEMU_NATIVE_HALF=0 forces the emulation, =1 takes native without measuring. The result is one line: [VK][F16] native half conversion exact=True mismatches=0 tested=643200 The flag reaches the translator through IShaderPipelineHost, so it is process-constant and cannot mix two translations of one program; the saved driver pipeline cache keys its entries by the module it was given, and the Metal host does not probe and keeps the emulation. Offline replays run the same probe, so a case translates the way the game would. (cherry picked from commit 6a343683d890b4c6d123c84fdacb41e718ec4c19) (cherry picked from commit 65ca663aa2bfb1fcc69709c73ab6189b07ead3c1) (cherry picked from commit 003b1216bd311e5c5fb1d48ca01a66efa3fc51de) * [SpirvTranslator] Read an unaligned buffer word as a funnel shift of two words The byte-wise decode of a formatted buffer load read each byte of a component from its own bounds-checked word load: four loads, four range tests and a byte assembly for a value that spans at most two words. One funnel shift of those two words is the same value, including out of range, where a word reads zero on both paths and so contributes zero bytes. Every sub-dword buffer load goes through the same helper. The decode is the branch a formatted load takes when its address is not dword aligned, so its size also sets the register pressure of the aligned branch next to it. Silent Hill: The Short Message's volumetric fog dispatch (0xD5DF9DC46C4E35EA, 8 formatted loads in its light loop) goes from 8.68 to 7.28 ms in offline replay, and the module from 394 to 360 KiB. An experiment that dropped the byte-wise branch entirely measured 7.35 ms, so the funnel shift is worth all of what the branch cost. (cherry picked from commit 0c996ffab38144d795517e68cb2ca9d8d48e8988) * [SpirvTranslator] Load a guest buffer word unchecked where the device zeroes out-of-range reads Every guest buffer word is read through a range test, an address clamp and a zero select: three operations whose only purpose is to produce the zero the hardware returns past the end of a V#. A device with robustBufferAccess2 that honours it returns that zero itself, so the three are pure overhead there - dropping them measured about 12% of Silent Hill's volumetric fog dispatch, 482 checked words in one program. ShaderCompileRequest.ZeroOutOfBoundsBufferReads turns them off and defaults to false: an out-of-range read is undefined without the promise, so only a host that measured the device may set it. It is set from a device probe, never from a capability bit, because MoltenVK runs on Metal, which has no hardware bounds checking. (cherry picked from commit 2ba626a0ac7157f93f348cfe7573ff1092762d8c) * [Vk] Probe out-of-range buffer reads at device setup and report the verdict A one-time compute pass binds 1 KiB of a 4 KiB allocation that carries a sentinel everywhere and reads all 4 KiB back through the descriptor: the words inside the range must still read their sentinel and the words past it must read zero. Only a clean measurement lets the translator drop the range test, address clamp and zero select it puts around every guest buffer word (ShaderCompileRequest.ZeroOutOfBoundsBufferReads). The probe only runs where the device enabled robustBufferAccess2, because an out-of-range read is undefined without it and can fault the device; everywhere else it reports the reason and the checks stay. On this Apple M4 through MoltenVK the feature is not supported at all, so nothing changes: [VK][OOB] out-of-range buffer reads zero=False mismatches=unprobed tested=0 note=robustBufferAccess2 is not enabled on this device SHARPEMU_ZERO_OOB_READS=0 keeps the checks, =1 drops them without measuring. The flag reaches the translator through IShaderPipelineHost, so it is process-constant and cannot mix two translations of one program. (cherry picked from commit e81d924349042acc1122a66d4c767268bd6ef2a4)	2026-10-07 10:51:57 +02:00
kuba	db32c9d882	[SpirvTranslator] Cut emulated-wave64 and private-LDS overhead in translated shaders (#1034) ... * [SpirvTranslator] Keep pure scalar lane spills in private slots under emulated wave64 A wave64 program run as a 64-thread workgroup on a 32-lane host emulates v_readlane with an LDS exchange and a workgroup barrier. Compilers use constant-lane v_writelane/v_readlane pairs on a VGPR as SGPR spill slots; when that VGPR is written only by constant-lane writelanes and read only by constant-lane readlanes, each (vgpr, lane) pair is a private scalar, so the readlane loads the slot instead of exchanging through LDS. This halves the heaviest compute dispatch in Silent Hill: The Short Message's menu. (cherry picked from commit 9915b88e68b6b69d6b74ea931a22eb0589c56f1a) * [SpirvTranslator] Zero private LDS lazily through a written-dword bitmap Graphics stages model LDS as a per-invocation private array that must read zero where the invocation has not written. The array carried a zero initializer, but Metal keeps a dynamically indexed private array in stack memory, so every invocation cleared all of it: an NGG vertex shader (the PS5 default, with in-shader culling through LDS) cleared 8 KiB per vertex. The array is now uninitialized and a zero-initialized bitmap of written dwords (1/32 of the size) records which slots were addressed; LdsPointer zeroes a slot the first time it is addressed, so loads, stores and atomics keep the zero-read semantics. Compute LDS stays workgroup memory. Silent Hill: The Short Message's menu, dominated by ~45M shadow-pass vertices per frame, goes from about 2.0 to 3.1 FPS. (cherry picked from commit 5738b8574397cf2be08cd4e1518b33057c8867b5) * [SpirvTranslator] Test the lane's mask bit in one register under emulated wave64 VCC and EXEC keep a per-lane boolean that every mask write refreshes, and the refresh composed the 64-bit mask from its two registers, built a 64-bit lane bit and masked them. A host without 64-bit integer arithmetic (Apple GPUs through MoltenVK) emulates each of those with a pair of 32-bit operations. The bit lives in exactly one of the two registers, so selecting that register and shifting inside it is the same test in 32-bit arithmetic. Only the emulated-wave64 path changes; wave32 already tested one register, and a native wave64 host keeps the existing form, which also clears the bit for lanes outside the guest wave. (cherry picked from commit 1b2651047fdf232304142c82168e487244dda4ef) * [SpirvTranslator] Let s_barrier publish only what the guest waited for Every compute s_barrier became an OpControlBarrier with AcquireRelease over uniform, workgroup and image memory, on the assumption that the guest had drained vector memory first. s_barrier only orders execution; what it publishes is whatever the preceding s_waitcnt drained. A barrier that follows an LDS-only wait (lgkmcnt(0)) publishes LDS, and ordering device memory there costs a cache flush the guest never asked for: UE's FFT bloom convolution barriers 48 times per group, all LDS-only. The translator now tracks, per block, whether any wait drained vector memory - SOPP vmcnt(0), or the GFX10 SOPK vscnt(0)/vmcnt(0) forms, since stores are counted by vscnt there - and a barrier after an LDS-only wait carries workgroup memory only. A drained counter stays drained for the rest of the block, and a barrier with no wait in its block keeps the full semantics (the wait may be in a block this one cannot be ordered against). (cherry picked from commit 1f81df59bc07d05f2baa6283da95f4901dada444)	2026-10-07 10:51:52 +02:00
kuba	30321142cb	[GPU/Vk] Keep guest readbacks of GPU-written memory off the command worker (#1032) ... * [Vk] Run async readbacks on a second general queue family when no dedicated one exists The async readback queue was only taken from a family without graphics, so drivers that expose several general families (each its own hardware queue) kept every guest readback on the main queue and the command worker. Any other family with transfer support now qualifies after the dedicated transfer and compute families. (cherry picked from commit 7b04d6185dfc1711f0fbdf5c75c842a065acd1fa) * [GPU] Let guest reads of GPU-written memory wait on the main queue off the worker A guest thread reading memory the GPU wrote hands the download to the command worker, which recorded the copies, submitted and then waited for the whole GPU before handing the bytes back - unless a dedicated readback queue existed, where the download ran asynchronously and only the guest thread waited. MoltenVK exposes one queue family in-process, so on macOS every such read idled the worker for tens of milliseconds, several times per frame in Silent Hill: The Short Message's menu (a quarter of the worker's time). Without a readback queue the worker now copies the pieces into a buffer of their own, submits without waiting and returns a pending download carrying the submission tick; the guest thread waits for that tick on the timeline (safe from any thread) and completes the read back on the worker, as the readback-queue path does. The worker's GPU wait time drops to zero; SHARPEMU_MAIN_QUEUE_PENDING_READS=0 restores the synchronous path. (cherry picked from commit 6c9ad44bcea7f9396a7564621fcbda3841834052) * [GPU] Re-issue a stale pending readback instead of reading synchronously on the worker A guest read of GPU-written memory records a copy and waits for its tick off the queue. When another GPU write lands first, the completion fell back to a synchronous read on the command worker, which stalled it until the GPU drained (up to half of SH's readbacks). The guest thread now re-issues the pending read and waits again; only the fourth attempt falls back to the synchronous read. (cherry picked from commit 17bf5bb958ebfd4dd980dbf241cbe9e77fffd938)	2026-10-07 10:51:48 +02:00
kuba	1e784a035f	[SpirvTranslator] Keep the packed-half vector registers in one variable per register (#1041) ... The f16 fast path shadowed the whole vector register file with a 512-entry private array of vec2 and zero-initialised it, even though every access uses a constant register number. That is the array shape Metal keeps in thread memory instead of registers - the same trap V_MOVREL's dynamically indexed register file hit (Octopath's instanced vertex shader, 112 -> 6.4 ms/draw) - and it also left AMD with an unused 4 KiB .bss global that broke two-stage links. One private variable per register, declared on first use, removes it. 308 of the 1019 shaders Silent Hill's title menu translates used the array, including the two hottest pixel programs. The generated Metal for the volumetric-fog compute D5DF9DC46C4E35EA drops from 282 KB to 269 KB and no longer declares a 4 KiB thread array. Measured GPU time on the menu is unchanged within run-to-run noise (fog 18.2/19.9 -> 20.1 ms per dispatch, pixel 934F121D8F666572 0.048/0.061 -> 0.041 ms per scope), so this is a code-shape fix that removes the spill risk rather than a measured win.	2026-10-07 10:49:01 +02:00
kuba	7ab6de1b93	[GPU] Cut per-draw command-worker cost in resource materialization and pixel input setup (#1039) ... * [ShaderCompiler] Materialize directly for plans whose cached inputs never repeat The materialization cache records every guest word a draw reads and keys the result on the draw's user data. Most Silent Hill draws point their user data at per-draw constants, so only 8% of lookups hit and every miss still paid for recording the reads and storing an entry. A plan now counts its lookups and hits; after 64 lookups with fewer than one hit in eight it walks its resources directly and probes the cache again on every 64th draw. On the SH title menu the command worker's busy time per draw fell from ~125 to ~111 us (cache hit rate of the remaining lookups 70%). * [GPU] Scan a pixel program's interpolated attributes once per decoded program Every draw scanned all instructions of its pixel program twice, once through a LINQ chain with Distinct/Order/ToArray, to count interpolated attributes and the vertex outputs they read. The sorted attribute set is a property of the decoded program, so it is computed once and kept beside it. Pixel input resolution on the SH menu dropped from ~14 us to a few us per draw.	2026-10-07 10:48:57 +02:00
kuba	70dcbe4e05	[GPU] Keep sampled depth attachments in one rendering scope (#1037) ... Draws that sample the depth attachment need its read-only layout; every other draw got the writable layout, even one that only tests depth. A run of depth-sampling particles between test-only draws flipped the layout on every draw, and each flip ended the rendering scope. Image state tracking also recorded a barrier whenever the access changed, even from one read to another in the same layout. A draw that neither samples nor writes the attachment now keeps the read-only layout it is already in, and reads after reads in one layout record no barrier: the tracked state accumulates every reader, so the next writer still waits for all of them. Depth-transition scope breaks in Silent Hill: The Short Message's menu drop from ~1250 to ~820 per 5 s. (cherry picked from commit 5563417d72fadefb115b300291b1e019b3171466)	2026-10-07 10:48:52 +02:00
kuba	0aa611e317	[GPU] Draw non-indexed indirect draws from their arguments on the GPU (#1036) ... Indexed indirect draws already let vkCmdDrawIndexedIndirect read their counts, but a non-indexed DRAW_INDIRECT read its four arguments on the CPU. When a compute pass had just written them (UE writes rectangle-list draw arguments this way every frame), the read downloaded the buffer and waited for the whole GPU: about one 20-50 ms stall per frame in Silent Hill: The Short Message's menu. The interpreter now hands the argument address to the host when it draws non-indexed indirect draws on the GPU (deferring the instance count read as the indexed path does), and the executor records vkCmdDrawIndirect. The guest layout (vertexCount, instanceCount, firstVertex, firstInstance) is VkDrawIndirectCommand. Rectangle lists use the general rectangle-list variant, since the count is unknown; fans, polygons, legacy lists and targetless draws (which may be retained and replayed) still read the arguments on the CPU. SHARPEMU_CPU_INDIRECT_DRAW=1 keeps the CPU path. (cherry picked from commit f2b91befb7dd27d65a35546f1e57dc88f04a5c82)	2026-10-07 10:48:47 +02:00
kuba	435bbd4844	[Cpu] Copy page-sized guest memcpys on the managed path (#1055) ... The native memcpy fast path copies with rep movsb straight into guest memory. Pages the GPU reads are write-protected so CPU writes can be tracked, so a copy into them takes one protection fault per page, and under Rosetta each fault is a signal round trip of about 0.2 ms. The managed memcpy marks the whole destination written before it copies and takes no faults. Copies of at least 4 KiB now leave the stub for the managed export; smaller ones keep the native copy, where one import transition would cost more than the copy. SHARPEMU_MEMCPY_MANAGED_MIN overrides the threshold. Demon's Souls, 230 s through the PlayStation Studios intro: 536k write-tracking faults become 71k, and the intro presents about a fifth more frames.	2026-10-07 10:48:00 +02:00
ParantezTech	3e2ad63303	[readme] New screenshots v2	2026-10-06 19:07:24 +03:00
ParantezTech	ac8608449f	[readme] New screenshots	2026-10-06 19:07:06 +03:00
Berk	2df6f5b0a0	Unity fixes 1016p1 (#1043) ... * [HLE] Let schedulers report guest thread stack bounds Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Core] Report the mapped stack of each guest thread Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Validate pthread stack bounds before reporting them Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Report every guest thread's stack in pthread attributes Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Publish semaphore handles as 64-bit values Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Accept zero-count semaphore signals Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Route semaphore waits through one core Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Poll host semaphore waits and deliver guest exceptions Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Add scePthreadSemTimedwait Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Remove every pending copy of a deleted event Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Block timed event queue waits in the guest scheduler Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Refresh pending user data when an event is re-added Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Keep every end-of-pipe interrupt event Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Track deadlines and POSIX results on sync waiters Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Poll host sync waits in bounded slices Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Share the sync-on-address wait and wake cores Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Kernel] Add _umtx_op wait and wake Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Np] Track WebApi2 user contexts and push filters Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Np] Add sceNpWebApi2PushEventDeleteHandle Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Np] Add sceNpWebApi2PushEventRegisterCallback Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Tests] Cover kernel sync, pthread stack bounds and NpWebApi2 Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [GPU] Accept HTile-backed compressed stencil targets Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Tests] Cover HTile-backed compressed stencil targets Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [GPU] Accept stencil targets with or without HTile backing * [Tests] Cover stencil compression with and without HTile * [ShaderCompiler] Treat V_CMPX as an EXEC write in every encoding * [Tests] Cover SDWA V_CMPX in the EXEC-full analysis * [GPU] Give images first found without metadata the DCC metadata of a texture request Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Tests] Cover DCC metadata adopted from a texture request Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [GPU] Number command stream submissions in admission order Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [GPU] Queue control barriers behind accepted command streams Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [GPU] Cancel pending control barriers when the command stream fails Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [GPU] Cancel pending control barriers when the command stream is discarded Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [GPU] Run relay work after accepted command streams Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [VideoOut] Order relay work behind the presenter command stream Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [GPU] Let backends run work after pending command streams Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [VideoOut] Run state changes after pending command streams Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Metal] Run state changes after pending command streams Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [VideoOut] Close ports after pending command streams Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [VideoOut] Unregister buffers after pending command streams Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> * [Tests] Cover ordered video-out state changes Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com> --------- Co-authored-by: Sekai <140012992+igettingit@users.noreply.github.com>	2026-10-06 18:43:21 +03:00
Berk	a17aaca533	Astro playroom shaders (#1030) ... * [Vulkan] Enable shader clip and cull distances * [Vulkan] Track shader clip distance support * [ShaderCompiler] Add a clip distance support flag to compile requests * [GPU] Expose host clip distance support to pipelines * [GPU] Pass clip distance support to shader compilation * [ShaderCompiler] Reserve a clip plane for position exports * [ShaderCompiler] Cull primitives with a zero position * [GPU] Bind vertex buffers with their guest descriptor sizes * [GPU] Accept B10G11R11 float vertex attributes * [GPU] Spill oversized image readbacks to a temporary buffer * [GPU] Carry DCC metadata on compressed textures * [GPU] Mark sampled DCC clears through the metadata fill path * [Tests] Cover vertex descriptor bounds and oversized image readbacks * [GPU] Revert binding vertex buffers with their guest descriptor sizes * [GPU] Carry DCC metadata only on single-layer 2D textures * [Tests] Cover DCC metadata on 2D, 3D and array textures	2026-10-06 01:32:13 +03:00
ParantezTech	83abe47b6e	[readme] re-order	2026-10-05 16:29:03 +03:00
ParantezTech	d6c4778218	[readme] added warning for not official sites, donations etc.	2026-10-05 16:27:41 +03:00
ParantezTech	5965b07c7b	[Logging] Skip "tbb_thead" without LogThreadMode	2026-10-05 16:18:27 +03:00
ParantezTech	4a822aedb9	Merge branch 'main' of https://github.com/sharpemu/sharpemu	2026-10-05 15:36:18 +03:00
ParantezTech	22bbcb1415	[readme] update screenshot	2026-10-05 15:36:01 +03:00
T	9e99769ce5	[GPU] Report mip statistics for sampled textures so streamed textures reach full detail (#1029)	2026-10-05 14:39:40 +03:00
Berk	41a1912cd9	[SRT] Compile shader resource plans in the background (#1028) ... Each shader resource plan is compiled once to a DynamicMethod that evaluates its resource table graph with plan-local value slots instead of the interpreter's hashed cache. ASTRO's PLAYROOM goes from about 20 to 60 fps. Compilation runs on a low-priority "SRT compiler" thread; until a plan is ready, the interpreter evaluates it, so a new shader no longer stalls the render thread while its plan is JIT-compiled. A plan whose compilation fails stays on the interpreter. SHARPEMU_SRT_NATIVE=0 turns the compiled path off; it is also off when the runtime does not support dynamic code.	2026-10-05 01:19:33 +03:00
Berk	0163750e7e	Page fixes (#1023) ... * [DeS] Fixes for page faults and stack bounds issues in the emulator and audio fixes * [ShaderPrewarm] Hold the game until the prewarm finishes and resume interrupted runs The prewarm compiled thousands of compute pipelines on background threads while the now faster boot ran beside it, so logos, Bink movies and the first scenes raced the compile and dropped frames. - Hold the guest at its first splash hide, GPU submission or CPU flip until the prewarm is decided and done; the render thread keeps presenting the splash. SHARPEMU_SHADER_PREWARM_WAIT=0 opts out. - Stamp only the shader translators, the compiler type and the driver, so a Libs-only build no longer triggers a full prewarm. - Record finished pipelines in shader-prewarm.progress so an interrupted prewarm resumes with the remaining ones. * [AudioOut2] Block a blocking push only until a queue slot frees A blocking sceAudioOut2ContextPush waited only when the host stream hit its 128 KiB cap, so a title rendering faster than real time kept about 680 ms queued and every sound played that far behind (GTA V: queue=2 context, queued_ms avg=678). The push now waits until the device holds the cushion plus QueueDepth-1 grains, the level GetQueueLevel already reports as full; the host cap stays as the limit for non-blocking bursts. GTA V now holds about 41 ms with no underruns. * [GPU] Run bounded modulo copies of plain words on the host Demon's Souls copies its per-frame constant and descriptor tables with a compute kernel (dst[i] = src[i % N] for i < count). Run on the GPU, the destinations stay GPU-dirty, and every draw whose resource tables read them waits for a readback: about 19% of the render thread in the title scene, for values that never changed. The kernel is now recognized by its instruction sequence. When both descriptors are plain 32-bit words of the same format and neither range is GPU-dirty or GPU image memory, the copy is written to guest memory through the host DMA path and the dispatch is skipped; anything else still runs on the GPU. SHARPEMU_HOST_BOUNDED_COPY=0 turns it off. Title scene with profiling: 7.4-8.6 -> 11.8-15.9 fps. * [Diagnostics] Summarize synchronized table reads and trace several writer addresses SHARPEMU_TRACE_GPU_READS=1 now also reports, every five seconds, the guest words resource planning read through a GPU synchronization: read count, how often the value changed, and the first and last value. SHARPEMU_TRACE_WRITER_ADDRESS accepts a comma-separated list.	2026-10-04 19:07:37 +03:00
Berk	57e0da2150	Revert "[DeS] Fixes for page faults and stack bounds issues in the emulator a…" (#1022) ... This reverts commit ec0198f2d0.	2026-10-04 05:57:24 +03:00
kuba	cb42e849d7	[VideoOut] Keep guests on SDR output under Auto HDR on macOS (#1020) ... Upstream e7a4f0a0 started reporting HDR to the guest whenever the display has HDR enabled. On an HDR Mac, Silent Hill switches its output to HDR, a guest pipeline then fails to compile in MoltenVK (ushort4 output to a BGRA8 attachment) and the process crashes inside MoltenVK on every run. Auto now stays SDR on macOS; --hdr=on still opts in.	2026-10-04 05:39:24 +03:00
Berk	ec0198f2d0	[DeS] Fixes for page faults and stack bounds issues in the emulator and audio fixes (#1021)	2026-10-04 05:38:49 +03:00
ParantezTech	8903e3760b	[readme] update screenshot	2026-10-04 04:28:03 +03:00
T	d4891229e9	[SpirvTranslator] Shader fixes (#1019) ... * [ShaderCompiler] Fix packed 10 and 11 bit buffer format layouts * [SpirvTranslator] Pass W as the pixel position input instead of its reciprocal * [SpirvTranslator] Keep lane spills in per invocation slots for all 64 lanes * [SpirvTranslator] Match the hardware float conversion and NaN rules * [SpirvTranslator] Apply VOP3 sign modifiers to conditional mask sources * [GPU] Download guest DCC metadata before a known target is sampled * [ShaderCompiler] End bit scan image tables at a sampler loaded from the same base * [ShaderCompiler] Treat image table candidates with unsupported formats as null	2026-10-04 01:17:02 +03:00