Repository navigation
DSP HLE Research Evidence Archive
This archive preserves historical results from November 2–3, 2026. Results refer to the named experimental commits and do not establish the status of current builds. See the current overview first.
Show historical research and detailed evidence
Current experimental engine: The audio-engine branch uses a guarded native EP mixer, GP filter, meter and delay continuations when HLE is selected; other work falls back to the JIT. This is an interim hybrid, not complete DSP replacement. Deck run 20261103-064634533-a315cc0449714aacabf3f5d971051c62 reached its PGR2 scene checks. Its last periodic report counted 35,179 native EP frames (34,109 nonzero), 4,820 fallbacks and zero cursor mismatches. A private capture contained 196,608 stereo frames, with nonzero samples and no clipping; this is signal presence, not audio parity. The runner marked evidence incomplete because the expected audio-report path was incorrect. The single instrumented run measured median process CPU 200.27% of one core and peak sampled RSS 658.39 MiB; it is not a matched performance comparison. Audio parity, memory concurrency safety, XISO timings and game performance remain unqualified. Earlier direct-mix measurements below describe earlier branch versions.
Automatic GP filter selection: Commit e80250dd76 requests the existing guarded filter per HLE instance on supported JIT ABIs, including after interpreter-to-JIT transitions. Commit e8ad1f832f adds opt-in bounded counters, and 3ab8afa633 tests the actual per-instance request without the old environment switch. Sixteen private captured GP frames matched the recorded sliced-DSP results; 280 native slices processed 2,614 input samples. The emulator, instance tests, captured filter tests and replay tests built and passed. These captures do not establish game performance or hardware parity.
Deck PGR2 job audio-pgr2-hle-gp-auto-e8ad1f832f-v1, run 20261103-070216595-33ccdedddee2482b8fac3ea7776b82b3, timed out waiting for its scene; its final image showed the pre-race “Start Race” menu. No GP filter hit was reported, and the last periodic EP record had 49,999 unrecognized/fallback frames and zero native frames. The audio diagnostic was never reached, despite its report-path fix. The cause of the menu stall is unresolved; the run is correctness-failed, evidence-incomplete and comparison-ineligible. Its instrumented median process CPU was 204.48% of one core and peak sampled RSS 581.81 MiB over 558 samples, not a performance comparison. The executable SHA-256 was a53f0b76a5b0a6b583c2ce06e464ea3a70532023924a4f5537a5ae7b62ebe1f8. The later 3ab8afa633 change affects the replay test entry point, not the live audio path.
GP meter slice: Commit 6a8f4da232 projects the remainder of a recognized 32-sample meter loop at a DSP slice boundary. It verifies program identity, loop/stack/interrupt state, memory range and arithmetic domain; the full remainder must fit in the current budget. It restores the loop state and resumes the JIT with the remaining budget. Unsupported cases retain the DSP path. The production projection matched 34 captured complete-state transitions and 32 varied DSP-stepped synthetic transitions. Sixteen captured full frames matched with 34 meter completions, and 20 varied full frames matched with 40 completions. The emulator, meter test, captured GP replay, instance and replay tests passed; this is emulator-derived evidence, not hardware parity.
A balanced ABBA/BAAB replay, twice per mode across 16 frames on the Ryzen AI Max+ 395/Linux host, compared the candidate against identical source with meter dispatch disabled. Median process CPU was 46.594 → 46.068 ms, but the median paired per-frame improvement was −0.27%, ranging from −6.86% to +10.51%. Median peak RSS was 30,866 → 30,872 KiB. Executable SHA-256 values were a79bf548952a362f1e66a5b7ad69ccfafc79c09d7c095b6df5752e9fc4267295 and 472e96c3a1a9f60b84964fe35c9071be87f1222f5009201a1cf80dc4b9d6ebdf. Startup and JIT compilation are included; the result does not establish an isolated speedup or game performance. Full captures and per-frame measurements are private.
Deck job audio-pgr2-hle-gp-meter-recovery-6a8f4da232-v1, run 20261103-071828133-881120ac319f42f49dcf665ba386fdaf, added one A press to investigate the previous pre-race-menu timeout. It reached the declared scene checks, observed at least one native meter execution, and its last periodic counters recorded 2,120,000 native filter calls and 35,173 native EP frames, with 4,826 EP fallbacks and no reported EP cursor mismatch. A private capture contained 196,608 stereo frames with nonzero samples and no clipping; that establishes signal presence only. Median sampled CPU was 208.45% of one core and peak RSS was 650.5 MiB over 452 samples. The changed input and instrumented single run make it not comparable with the earlier failure or a performance baseline, regardless of the runner's own eligibility flag. The corrected audio artifact path was found. Executable SHA-256 was 3b11d7693536590fcfd0a598aafe07bb0f0223e97fffb33e0220f6634cf951e2; scene checks establish screenshot requirements, not complete gameplay or audio correctness.
GP delay continuation: Commit d6b38b85c4 projects the tail of a recognized delay-loop iteration and its remaining wet or dry iterations when the full continuation fits the current DSP slice. It validates program identity, loop/stack/interrupt state, linear and non-overlapping memory, and arithmetic bounds; unsupported states leave DSP execution authoritative. The production projection matched 34 captured complete-state transitions and 64 varied synthetic stepped transitions. Sixteen full captured frames matched with 24 native delay continuations; 20 varied full-frame replays matched with 20 continuations. The emulator, delay and meter unit tests, instance test and replay suite built and passed. These checks are emulator-derived, not hardware or audio-parity proof.
A balanced ABBA/BAAB comparison, twice per mode per 16 frames on the Ryzen AI Max+ 395/Linux host, compared the candidate with identical source and delay dispatch disabled. Median process CPU was 45.343 → 46.076 ms, with −1.06% median paired per-frame improvement (range −6.42% to +5.10%); median peak RSS was 30,892 → 30,858 KiB. Executable SHA-256 values were 48fe6a84bce1976b5c65b675336cb569a703c82064b5c8d727ec346dcd4a09ce and 564876dfea95444639ded5f0b96a97e84dfeb691a071b1d5b4d136164e3ff314. Startup and JIT compilation are included; this does not establish a speedup or game result. A follow-up early-budget preflight measured −2.13% median paired improvement (range −12.37% to +4.11%, 45.018 → 46.375 ms, median RSS 31,048 → 31,038 KiB) and was reverted as unproven. Its disabled/enabled executable hashes were 0c5437b20b5da08a1f389a0fc9566ea032bc0d785f83b1b70a9e14e67c2d4807 and ce9142bb5e96646585fac6dd7d2a3f8d45e3e0901252715bda4f39d2f83d635a. Current head bff66ee22f has the identical source tree to d6b38b85c4. Raw captures and per-frame results remain private.
Deck diagnostic audio-pgr2-hle-gp-delay-d6b38b85c4-v1, run 20261103-073216426-2d6f77f088ad42d6a24fedce43615165, used the same extra-A input-recovery plan as the preceding meter diagnostic. It reached the declared scene checks, logged at least one native delay and meter hit, and last reported 2,070,000 GP filter calls and 35,179 native EP frames with 4,820 fallbacks and zero reported cursor mismatches. The private signal capture contained 196,608 stereo frames with nonzero samples and no clipping. Median sampled process CPU was 204.435% of one core and peak RSS 653.99 MiB over 451 samples. This single instrumented run does not establish audio parity or performance, regardless of the runner's eligibility flag. The executable SHA-256 was fde944881e327669a4558883f97fdf64b31d04ab9d31b6ae52d8743a014e4b61; scene checks verify artifacts, not complete gameplay.
GP block-boundary experiment — HOLD: Commit a18d394de3 adds the explicit XEMU_GP_BLOCK_HLE=1 experiment. It runs the recognized GP program at provider block boundaries, dispatches guarded native operations when budget permits, and falls back to JIT blocks. Sixteen captured full frames matched with 702 block-native calls and 104,376 projected guest cycles, in addition to existing slice shortcuts; 20 varied frames matched with 960 calls and 154,620 projected cycles. Unknown-program fallback and the focused test suites passed. A balanced offline comparison against the existing HLE route measured median process CPU 45.843 → 45.424 ms and +2.00% median paired improvement, with a −8.35% to +8.01% range; median RSS was 30,856 → 31,006 KiB. The result includes startup and compilation and does not establish a speedup. Test executable SHA-256 d98c7e72fd96e3ee9b2d656f91ed137e82aa42203666a1cb8b3c73a28143223a.
Deck diagnostic audio-pgr2-hle-gp-block-a18d394de3-v1, run 20261103-075121100-db67437364d04e3da0d4af7b1cf47d41, became unresponsive and was stopped by the QMP watchdog after 88 seconds. It did not reach the scene or audio capture, and no block-HLE hit was reported. The hang bundle's backtrace was empty; the cause and whether the experiment triggered it remain unresolved. The last EP report counted 5,171 native frames, all with zero output, and 4,828 fallbacks. Whole-run median sampled CPU was 108.25% of one core and peak RSS 557.47 MiB across 151 samples; this failed run is comparison-ineligible. Executable SHA-256 07f0ef2b84299ccc3cd298926b856c896a7f70ca816f88815281684a9cf51ed3. Do not regard this experiment as ready for user testing.
The public fixture runner update adds explicit hybrid-fallback sentinel expectations. On Deck, an ABBA run of the asymmetric GP-only fixture passed tone and GP-sentinel checks in all four executions. JIT CPU was 120.40% and 121.80% of a core; HLE was 121.00% and 120.80%. Peak RSS was 688,632 and 632,536 KiB for JIT, 634,412 and 632,664 KiB for HLE. These short timer-paced runs do not establish a performance gain. The default sample comparison for the first pair failed (maximum differences 9,412 and 4,717 s16 units): its last accepted reference window contained a partial tone/silence transition consistent with shutdown. The second pair matched exactly. A separately selected steady interval (seconds 11–13) matched exactly over 48,000 compared stereo frames in each pair; the original mismatch remains a failed check. EP was disabled, so neither comparison exercises native EP. A two-DSP sentinel fixture confirmed both controlled programs executed, but its tone check failed with silence; those programs only write markers and halt without producing EP FIFO audio. Executable SHA-256 was 02dacba96de07e9d72459f16aed6531a610364f835b049195b7885fcf4d9aa37, asymmetric XISO SHA-256 83ce8cf958961d382c8cffcd08acb70e39a45dc00cb07998a4efdb147d17fe72. Raw captures and run reports remain private.
The public DSP test now runs native gain candidates alongside the original emulated DSP frame, compares their outputs, and records native/fallback coverage. On Steam Deck all three routes matched 192/192 words. A deliberately corrupted candidate produced one detected mismatch while the guest's GP and DMA checks still passed. OpenAL Soft loopback separately matched the same 192 outputs on both the Deck and cloud host.
This establishes a working development process for gradually testing HLE. The subsequent balanced performance campaign measures 81.11% lower native CPU cost for the fixed gain-output/export workload on Deck. The DSP still owns every live output and side effect. These synthetic gains are not measured expensive game routes, and no game HLE or performance qualification follows from this result.
Reviewed November 2, 2026. Experimental, ready-for-review branches, all HOLD:
| Layer | Review home | Candidate |
|---|---|---|
| Concurrent emulator shadow and fixed-work benchmark | xemu #386, depends on #385/#384 | b44c54e3bd07ba0dd0956eb626ab565553f0780f |
| Host validation, balanced performance and process resources | test #71, depends on #69 | 227bf60a2c715c96bda965d1d2c172a481ddee32 |
| Isolated OpenAL probe | test #70, depends on #69 | 5b26766b7c76e115048475deeb22241f51bce346 |
The owning emulator PR retains the consolidated campaign evidence. The earlier public XISO proof documents the guest, capture and 100 isolated replays. The capture/replay guide covers the underlying tools. These abilities are not merged or released.
BEFORE
real GP/EP frame → live DSP/DMA outputs → later isolated native comparison
AFTER
enabled GP + exact complete program + admitted entry state?
no → original GP/EP only
yes → copy 64 inputs → precreated worker → private selected gain outputs ─┐
original GP/EP once → authoritative live DSP/DMA outputs ──────────┤
join worker → compare 192 route words → counters and verdict
pause/idle → snapshot → host independently validates coverage
This diagram describes shadow mode: it commits no native result. A separate, guarded live EP experiment is described below; it is not a complete HLE engine.
Full-image identity covers all 4096 program words. Admission also checks GP enabled, PC zero and unset completion marker; the known program initializes its arithmetic mode. Unknown programs/states continue through DSP execution. The worker uses copied inputs and private outputs, calls no APU/DMA APIs, and is joined before the owner compares results. Scheduling determines actual overlap; this does not prove simultaneous execution on separate CPU cores.
Mask bits select candidate gain routes. A disabled candidate records one fallback per admitted job while the original DSP still computes the live result. This is shadow selection, not switching live authority between engines. Each eligible frame has three 64-word routes: +1/2, -1/2 and +1/4, with Q23 floor rounding. Zero native comparisons cannot be reported as success.
Steam Deck AMD Custom APU 0405, SteamOS, OpenGL, full DSP/JIT, dummy audio. The unchanged public XISO validates preserved inputs, all 192 GP output words, and all 192 external scratch-DMA words. Monitor PCM is silent: these tests validate arithmetic memory/DMA results, not audible output or A/V sync.
| Mode | Half match/compare | Inverted half | Quarter | Fallback calls | Guest | Host result |
|---|---|---|---|---|---|---|
| Full mask 7 | 64/64 | 64/64 | 64/64 | 0 | PASS | PASS |
| Partial mask 5 | 64/64 | 0/0 | 64/64 | 1 | PASS | PASS |
| Fault word 65 | 64/64 | 63/64 | 64/64 | 0 | PASS | MISMATCH; exit 1 |
| Mask 0 | 0/0 | 0/0 | 0/0 | 3 | PASS | NO_COMPARISONS; exit 1 |
| Shadow off | N/A | N/A | N/A | N/A | PASS | PASS |
Each shadow run admitted one job. The injected difference was inverted-half
sample 1: DSP ffffff, candidate fffffe. All shadow records report
authoritative=dsp and live_native_commits=0.
The full run recorded native leaf wall times of 990, 970 and 950 ns; the original whole GP/EP frame recorded 26,304,325 ns. These scopes differ, include first-use effects, and lack balanced repetitions: do not divide them into a speedup. Those original single-frame clocks are NOT COMPARABLE. The separate fixed-work campaign below establishes comparable route-projection costs. Game cadence, frame tails, audio and representative resource tests remain required before integration.
Fresh focused checks: 11/11 emulator DSP targets; 32 replay/DMA subtests, including four shadow cases; 6/6 host/native tests; 3/3 benchmark tests with the linked worker; 3/3 actual resource-process tests; 2/2 OpenAL tests without skips. Independent review found no blocking worker/lifetime/OpenAL defect. It identified host fault-observation and inherited-environment gaps; both were repaired and rechecked. All retained raw shadow records pass the final host parser. The first live candidate lacked stats because QMP quit did not unrealize the device; that run remains INCOMPLETE. Reporting now occurs at a paused, idle APU boundary, with final validated snapshots used by the host.
The headless benchmark links the production DSP block JIT and the exact native gain kernel used by the shadow worker. On Deck/CPU3/powersave, fixed ABBA/BAAB order gives 32 samples per mode, 50,000 blocks each, and 100 warmups. Each mode completes 1.6 million blocks and checks 307.2 million GP words plus 307.2 million export words. Every block computes 192 gain results and exports 768 bytes. Startup/warmup are excluded from these clocks; input transport, materialization, modeled export and verification are included.
| Metric, median unless stated | DSP | Native | Improvement |
|---|---|---|---|
| CPU per block | 7.673µs | 1.449µs | 81.11% lower cost |
| Wall per block | 7.714µs | 1.458µs | 81.10% lower cost |
| p95 batch wall/block | 11.217µs | 2.113µs | 81.16% lower cost |
| p99 batch wall/block | 11.270µs | 2.117µs | 81.22% lower cost |
| Executable peak RSS | 28,624KiB | 21,258KiB | 7.19MiB /25.73% lower |
| Emulated instructions/block | 588 | 0 | Native computes192 gain results |
An untimed trace counts 193 DSP instructions in each gain region; timed runs use the block JIT. Both busy workers use about 99.45% of one core: CPU time per equal work reveals efficiency. Balanced-group CPU improvements range77.88–82.14%. p95/p99 describe batch-average cost/block, not individual block/frame tails.
Separate balanced hardware counters, 4 processes/mode × 50,000 blocks, show median 3,713,928,445→352,704,230.5 retired user-mode host instructions (90.50% fewer). These include loading, JIT/setup, trace and warmup; they are not kernel-only counts. Semantic gains and emulated instructions are different from these measured host hardware instructions.
The original program must first match the real XISO answers. Warm repetition
then changes only its post-halt backedge at P:1238 from 1235 to 0; the gain
instructions remain identical. Repeat-image SHA256:
add7adf2c77268439bbdabb048848bcf86ef6c8f95940847f530326fa13f3d88.
Benchmark ELF: 610347fc3be7f12d730d6cb429e93193190d90520086f2e5dfb5174bf263f4da.
Native uses a modeled export, not full DSP register/IRQ/DMA emulation. This
is a measured output/export-projection improvement, not full-state HLE qualification.
Primary memory comes from executable Linux VmRSS/VmHWM. Review reproduced pre-exec launcher contamination in ru_maxrss; that older metric is retained separately, and the corrected campaign keeps the original workload/order. The 7.19 MiB difference concerns separate workers that can avoid a DSP context. Live HLE retaining DSP for fallback has no demonstrated RAM saving.
Build dsp-gain-bench from xemu branch test/dsp-gain-shadow; use
bench_gain.py from test branch test/dsp-shadow-runner:
python3 bench_gain.py --worker /absolute/path/to/dsp-gain-bench \
--guest-report /path/to/passing/report.json --program-header program.h \
--output /path/to/new-performance --iterations 50000 --warmup 100 \
--pairs 16 --cpu 3A loader wrapper requires --worker-binary /path/to/actual/ELF. Reports retain
every sample, both program identities, executable/input/runner hashes, cold
setup cost, checked words, exports, operations and CPU/memory data. Exact work
and counters must match requested iterations before campaign completion.
run_guest.py --resources separately records child-only CPU and samples
executable VmHWM every 50 ms. Compare with/without --shadow in fixed balanced
order. Current Deck/OpenGL/JIT/dummy-audio results, 4 runs per condition:
| Launch-through-quit median | Off | On | Interpretation |
|---|---|---|---|
| CPU seconds | 18.448685 | 18.542938 | +0.51% observed cost; inconclusive |
| Wall seconds | 11.089476 | 11.089378 | Essentially unchanged at this resolution |
| Sampled peak RSS,KiB | 633,564 | 630,956 | No memory-saving claim |
| One-core-scale CPU usage | 167.24% | 166.30% | Multithreaded process |
All guest GP/DMA checks pass; on runs compare 192 native words with DSP still authoritative. CPU ranges overlap: off 18.221–19.532 s; on 18.244–20.614 s. Boot, polling and 50 ms exit observation dominate this test. Row 5 was interrupted by a full Deck filesystem during private HDD copying; five rows/failure were retained, generated task-owned HDD copies removed, then remaining rows resumed unchanged. Original user HDD stayed untouched. The interruption and variation prevent a conclusive observer-overhead estimate; no net live emulator speedup is established. Whole-game FPS/audio/state/tail qualification remains open.
Build xemu branch test/dsp-gain-shadow with -Dxemu_dsp_capture=true.
Use test branch test/dsp-shadow-runner; build the existing public fixture
using the fixture README.
cd xemu-perf-tests/tools/dsp-io-proof
python3 test_native.py
python3 run_guest.py --emulator /path/to/shadow-xemu \
--iso "$PWD/dsp-io-proof.iso" --program-header "$PWD/program.h" \
--config /path/to/xemu.toml --output /path/to/new-full --shadowRepeat with distinct output directories and --shadow-routes 5,
--shadow-fault 65, or --shadow-routes 0. The latter two deliberately return
nonzero. Omit --shadow for the off control. The runner clears inherited
experiment controls before applying CLI options. Optional --capture uses
the exact-program recorder trigger from #385.
report.json retains guest_status separately from the final campaign
status, full input/output arrays, program identity, executable hash and
shadow counters. Every snapshot must be internally consistent and coverage
must never decrease. A selected injected fault must mismatch every admitted
job; merely echoing the configured index is insufficient.
Historical XISO SHA-256: 9353253e7c466b5fa830bdef8cfaa50e457a10230efcb713c8bb275db005bf10.
Program: 41a14ad0eff5ce00e45fb73c81f497d1d1056bf1ffc6301b91b1d78d5663778a.
Tested emulator ELF: d60f224695e5b09c1d47eaa2a0e063541bfd2a0d82ade9a44896ee0698d99099.
It was built after the source fix before recording commit c127c00d; runtime
source matches that commit, with generated version metadata from the prior
head/local changes. The live runner was 63b0f09; final ba7fb5e adds parser
tests and the reviewed admission/environment repairs, with retained records
revalidated. Rebuilding ISO/ELF files can change hashes; record actual artifacts.
The unreleased audio-engine branch adds an Advanced audio engine selection: Default follows the existing DSP settings, JIT runs the existing DSP JIT, and experimental HLE skips GP and EP frame execution and routes the voice processor's front-left and front-right mixbins to the host output. Restart xemu after changing the setting. This is a prototype, not a replacement for general Xbox DSP programs: effects, EP encoding, additional output bins, DSP side effects and game compatibility are not implemented or qualified. DSP devices and their initialization remain.
The public test fixture and capture tools
generate known guest audio, capture an isolated host audio stream and record
process CPU and memory. On a Steam Deck, the two-DSP sentinel fixture executed
both marker programs under Default and neither under HLE on the current
81ba023f4203b65a766d1c5ec16e4f878bb3f6a7 candidate. A separate
asymmetric PCM fixture ran an active GP passthrough under JIT and compared its
audio with the HLE output: after one shared phase alignment, all 48,000 stereo
frames differed by at most one signed 16-bit unit. Both channels passed tone,
gain, clipping and duration checks; the fixture also detected the old
equal-gain monitor behavior as a negative control.
A constant-predictor stereo Xbox ADPCM fixture also passed its expected positive left and negative right signal checks under both JIT and HLE; this is one compressed-audio case, not general ADPCM or game-audio qualification. A PGR2 HLE run did not reach its expected scene: the last captured image was a loading screen and the scene fingerprint timed out. The planned audio capture did not run. One matching JIT control reached the scene and produced movement screenshots, making the engine choice a plausible cause; this single comparison does not identify the missing behavior. The JIT diagnostic recorded nonzero stereo signal, but its evidence assessment was incomplete because the declared artifact path did not match the runner's timestamped diagnostic directory. There is no HLE game-audio capture or parity result.
A separate diagnostic build isolated the two processors. Public sentinel tests
verified both switches. On one PGR2 attempt each, suppressing only GP frames
reproduced the loading-screen timeout, while suppressing only EP frames passed
the scene check and produced movement screenshots. The automated checks verify
the screenshots exist, not correct vehicle motion. This identifies GP-associated
behavior as the immediate concern; the EP-disabled run did not qualify audio.
A prior captured PGR2 GP frame made 32 scratch reads (2,008 bytes) and 25
scratch writes (4,320 bytes); six writes changed data read earlier at the same
address and length. Those results do not identify a particular required write.
Six 128-byte writes in that captured frame were spaced 2,048 bytes apart;
four nonzero payloads matched post-frame mixbuf blocks, not any pre-frame
mixbuf block. The other two writes were silent and do not identify a channel.
Across the same capture, all 19 nonzero scratch-write payloads matched post-frame XRAM; 18 had unique matches and one had multiple matches. The other six writes were all zero. A subsequent Deck diagnostic, audio-pgr2-gp-followup-frame-sequence-20261103-v1, captured 16 consecutive GP frames and all replayed. Across them, all 304 nonzero scratch-write payloads matched post-frame XRAM: 288 had unique matches and 16 had multiple matches. The captures also included 96 all-zero writes. The ordered XRAM source-match pattern was the same in all 16 frames, while scratch destinations varied in 18 of 19 nonzero-write positions and often advanced or wrapped. These are correlations from one short game sequence, not a general routing, loading-stall, or audio-parity proof.
Across a separate instrumented PGR2 JIT run, including boot, the GP performed 8,794,798 scratch reads and 7,099,035 scratch writes. The counting build passed the public fixture's known 768-byte write check and the game scene check. These are total callback counts from an instrumented run, not stage-exclusive costs, representative game performance, or a comparison against HLE.
The public GP arithmetic and DMA fixture
now accepts the experimental HLE engine. On the Deck, Default/JIT passed all
192 computed output words and the 192-word DMA comparison; HLE failed all 192
outputs and the DMA comparison. The same expected program, input and guest
readiness were observed in both runs. A deliberately wrong guest verdict failed
under JIT even with correct DMA output. The fixture ISO SHA-256 was
9113027e234ba4784732ee4a2d16495ad14ae8a2f3d18039cc96e5cace337a4a.
This correctness gate has no CPU or memory performance measurement.
The GP fixture runner removes its own temporary writable HDD copy on exit,
including launch failure; it leaves the source disk and existing output
directories untouched. That cleanup is available in
test branch commit 6c71fca.
The circular DMA fixture also checks a 192-word transfer that wraps a 1,024-byte ring and the descriptor's updated offset. On the Deck, Default/JIT matched all 192 words and wrote offset 544; the experimental HLE path matched none and left offset 800. A separate intentionally corrupted-offset fixture made the host check fail even when the data matched. These checks establish a missing HLE side effect, not performance; bare Xbox hardware has not been tested.
The experimental audio-engine branch
contains a read-only shadow comparison for four decimation routes of one
identified GP program. Set XEMU_GP_DECIMATE_SHADOW=1 and use the JIT engine.
For supported states it predicts private samples, observes actual scratch DMA
writes, and compares the samples, descriptor offsets, and next phases after
the real DSP has run. Unknown programs and unsupported states are skipped;
no predicted output is used for playback or written to guest memory. Counts
are printed periodically to standard error.
On the Deck, a PGR2 run with candidate a7768f87e8, executable SHA-256
8bf8c7c223789287600bc1a71076c16076bf73bfc4244c7fdad648a2cf293ede,
and runner job audio-pgr2-gp-decimate-shadow-report-20261103-v1 reached its
declared screenshot checks. The last periodic record showed 361,788 matching
route comparisons and zero mismatches, from 90,447 eligible frames. It also
showed 180,895 recognized frames skipped, 38,657 frames with other program
identities, and no invalidated frames. Screenshot checks establish capture
presence, not motion or audio correctness. The early candidate supported only
the six-output phase; the subsequent e421efc967 adds five-output phases and
20-byte DMA checks. A second Deck run with that commit and executable SHA-256
f7aa4f31bc6a6fdc7d698137db9369e9e063c227ad07a8de9df0840cf5b991cb
reported 1,085,624 matching routes, zero mismatches, and no skipped frames
among 271,406 recognized frames at its last periodic record. Its runner job
was audio-pgr2-gp-decimate-allphases-20261103-v1; 38,593 earlier frames used
other program identities. Its screenshot checks likewise establish capture
presence only. That candidate also matched 320 route comparisons across 80
locally mutated replays, plus 160 comparisons in the earlier six-output corpus.
Both corpora derive from captured emulator frames with fixed recorded scratch
reads. The game assets and raw recordings are private, and neither those
checks nor this single instrumented game run show hardware parity, complete
audio, or a speedup. A third Deck run with commit 1b2e3f3975 and executable
SHA-256 f9773c5e35f87af2a32c98c7d0112b51b3563e7f396d54f0d3c7449af7e0b3c9
added a nonzero-route counter. At the last report, it showed 1,085,816
matches and zero mismatches, but zero matched routes with nonzero output.
Consequently the live comparisons establish only silent-route parity for
this workload. Signal-bearing arithmetic was exercised by the varied-input
replays, not demonstrated by these game runs. The third job was
audio-pgr2-gp-decimate-nonzero-20261103-v1.
Branch commits be6f8909f3 and 76eaf26b19 extend the decimation observer to compare two ordered scratch writes that cross a ring boundary. Synthetic tests cover splits within a sample, bad or missing chunks, duplicates, reordered chunks, overlapping routes and address overflow. Deck job audio-pgr2-gp-decimate-wrap-shadow-20261103-v1 completed with 1,085,592 matching routes and zero mismatches at its last report, but zero nonzero routes and zero split routes. It therefore does not establish live split or nonzero coverage. The earlier 16-frame private capture also contained no split decimation transfers. The instrumented run measured median process CPU 202.1135% of one core over 438 samples and peak sampled RSS 656.344 MiB; without a matched baseline it does not establish a speedup.
In that private sequence, execution-time DMA descriptors reproduced the destination and length of all 400 recorded scratch writes. After resolving the mix-buffer alias, their payloads matched the recorded post-frame XRAM; only 96 also matched entry XRAM. None of the 304 nonzero write payloads exactly matched any recorded scratch-read payload, while the four decimation positions were silent in all 16 frames. These observations show which outputs need further native computation; using the recorded post-state as an oracle is not an implementation or a hardware test.
The branch also contains a bounded 16-sample GP feedback helper. A private instruction-stepped replay of 16 PGR2 frames produced 176 calls with nonzero output: the production helper matched all 2,816 samples and final feedback states. Replay I/O and serialized post-state fields matched apart from cycle budget, which instruction stepping does not model. Twelve additional synthetic input/coefficient variants matched the JIT; a synthetic vector is checked into the unit test. The helper rejects saturation and invalid inputs, is not connected to live execution, and does not establish game-audio parity, hardware accuracy, or a speedup. Raw game-derived state remains private. Follow-up tracing found that 144 of the 176 calls targeted nine observed scratch-write blocks. Their inputs were not present at frame entry: 48 matched a recorded scratch-read segment and the others require preceding GP processing. Only one of 695 captured JIT slices began at this routine's entry; a slice-entry shortcut alone would provide little coverage. Commit da39ceb4ab adds a second synthetic JIT-derived unit vector with negative feedback gain.
Commit fe10aa4ab0 adds an offline feedback-state projection and build/test-xbox-mcpx-apu-dsp-replay --replay-gp-feedback <capture>. For the exact recognized GP program, replay steps DSP instructions and substitutes the native feedback stage with its projected registers, stack, memory and 137-cycle count; unsupported states use DSP instructions. It checks the recorded ordered I/O and final serialized state except the run-loop cycle budget, which stepping does not model. Across 16 private PGR2 captures, 176 native calls replaced DSP work and all 913 recorded transactions and checked final states matched. Changed program memory, transaction address and post-state each failed negative controls. This is an offline, one-program result, not live GP bypass, hardware validation, game-audio parity or a speedup.
Commit 3d5308bebd adds a second guarded native GP stage: a 16-sample, two-output mixer with convergent rounding and a stepped CPU/memory projection. Use --replay-gp-step <capture> for a stepped-DSP control and --replay-gp-hle <capture> for both native stages; the earlier --replay-gp-feedback name is now an alias. The two routes matched recorded I/O and checked final state in 16 private PGR2 frames, excluding the run-loop cycle budget. The DSP control executed 433,356 steps; the native route executed 406,972 steps, 176 feedback calls and 32 mixer calls, projecting 34,736 emulated DSP cycles. These are emulator-work counts, not CPU cycles or game FPS.
On the local Ryzen AI Max+ 395/Linux host, a balanced ABBA/BAAB comparison of the same 16 frames (two runs per route per frame) measured median process CPU time of 48.716 ms for stepping and 49.536 ms with native substitutions. The median paired per-frame improvement was −1.71%, with changes ranging from −10.69% to +4.07%; median peak RSS per process was 30,688 and 30,224 KiB respectively. The executable SHA-256 was 6843c15c3daab2fba35c122fdc057edd32c8dfb081097c265df1fb3cee52a643. A prior pre-counter build showed 48.685 versus 50.247 ms and −2.26% median paired improvement. This offline measurement includes process startup, full-state snapshots, JIT compilation and cache invalidation. It does not establish a live game speedup or memory saving; the native stages remain offline only.
Commits 31774ac490 and b3d2292483 add a third native replay stage, a guarded 16-sample addition loop, and preserve compiled DSP code when restoring state without changing program memory. Across 16 private PGR2 frames, all three replay modes matched 913 recorded transactions and checked final state; stepping excludes the run-loop cycle budget. The control executed 433,356 DSP steps; native replay executed 384,092 steps, 176 feedback calls, 32 mixer calls and 352 addition calls, projecting 59,024 emulated DSP cycles. Those are emulator-work counts, not host CPU cycles.
An initial cache-clearing build measured 47.283 ms median process CPU for stepped DSP versus 50.493 ms for native replay (−4.43% median paired improvement). On the local Ryzen AI Max+ 395/Linux host, the exact-head cache-retaining build, using the same balanced ABBA/BAAB procedure and 16 frames, measured 48.709 → 46.487 ms median process CPU versus stepped DSP, with +6.17% median paired improvement (individual changes −3.67% to +11.20%). Forcing cache clearance versus retaining it measured 52.797 → 46.501 ms, +11.31% median paired improvement (range +7.39% to +12.54%). Median peak RSS per process was 30,818 → 30,728 KiB for DSP versus retained-cache native, and 30,276 → 30,662 KiB for cleared versus retained-cache native. The executable SHA-256 was 3255800d738d77f2434610d9045e7693f798de910870468d1020d1feee881c77. These measurements include process startup, snapshots, JIT compilation and state restores; they do not establish game performance or a memory saving. The native GP path is still offline only.
Commit 73c261a7c8 adds a fourth guarded GP replay stage: a four-input accumulation over 16 samples, including its nested-loop stack and stepped CPU state. Across 16 private PGR2 captures, all three replay modes matched the 913 recorded I/O transactions and checked final states, excluding the run-loop cycle budget. The DSP control executed 433,356 instruction steps; the native route executed 365,596 DSP steps plus 176 feedback calls, 32 mixer calls, 352 addition calls and 64 accumulation calls, projecting 81,872 emulated DSP cycles. Altered program memory, transaction address and post-state each failed a negative control. The production accumulation projection also matched 16 synthetic variants. These are emulator-work counts, not host CPU cycles.
A balanced ABBA/BAAB offline comparison on the local Ryzen AI Max+ 395/Linux host measured median process CPU 50.834 → 47.231 ms for stepped DSP versus four-stage native replay. The median paired per-frame improvement was +6.11%, with individual changes from −3.66% to +13.06%; median per-process peak RSS was 30,690 versus 30,520 KiB. Each route ran twice per frame using executable SHA-256 eee0d867f57679fe64a579d7a80409a4d02d7e17f63b9b5981e04304bb180cbd. Process startup, state snapshots, JIT compilation and restores are included. This is not evidence of a live game speedup or memory saving, and the native GP stages remain offline only.
Commit cc05ca7fc9 adds a fifth native GP replay stage, a guarded 32-sample peak/level meter. Across 16 private PGR2 captures, stepped DSP and both native replay modes matched all 913 recorded transactions and checked final state, excluding the run-loop cycle budget. The DSP route executed 433,356 instruction steps; native replay executed 331,708 DSP steps plus 176 feedback, 32 mixer, 352 addition, 64 accumulation and 96 meter calls, projecting 116,144 emulated DSP cycles. The meter projection matched 16 synthetic input variants; a first proposed level formula failed on nonzero synthetic input before its fixed-point scaling was corrected. These are emulator-work counts, not host CPU cycles.
On a local Ryzen AI Max+ 395/Linux host, balanced ABBA/BAAB offline replay measured median process CPU 50.126 → 44.566 ms for stepped DSP versus the five native stages. Median paired per-frame improvement was +10.57% (range +5.31% to +16.81%), and median per-process peak RSS was 30,872 versus 30,482 KiB. Each route ran twice per frame with executable SHA-256 ceb37737eb673c2fc59e85dc18a18493b252920d5909b6553b7c5c76c7ec968a. Startup, snapshots, JIT compilation and restores are included. This is not live game-performance or audio evidence; the native GP stages are offline only.
Commit 025f828cd3 extends the guarded filter to matching four-word address steps and adds it as a sixth stage to offline GP replay. Across 16 private PGR2 captures, stepped DSP and both native modes matched 913 I/O transactions and checked final state, excluding the run-loop cycle budget. The control executed 433,356 DSP steps; native replay executed 245,308 steps and projected 270,224 emulated cycles. The filter ran 144 times in six frames (54 calls observed nonzero output); ten frames fell back to DSP for that stage. Ten additional synthetic variants changed inputs, coefficients and history and matched the JIT-generated transactions and final state; all 240 filter calls had nonzero output. Six captured-frame tests exercised the optional live JIT helper; the other ten did not reach its entry and therefore did not validate it. The emulator and focused suites passed: 34 filter tests plus one private-capture skip, 19 replay tests and seven snapshot tests. The filter guard also affects the opt-in XEMU_GP_FILTER_HLE=1 path; broad live audio, game and XISO qualification is still missing.
A balanced ABBA/BAAB offline replay on the local Ryzen AI Max+ 395/Linux host measured median process CPU 46.581 → 41.715 ms for stepped DSP versus native replay, with +11.93% median paired per-frame improvement (range −0.43% to +26.34%). The six frames using the filter had a +22.06% median paired improvement; the ten fallback frames had +7.54%. Median peak RSS was 30,736 versus 30,580 KiB. Each route ran twice per frame using executable SHA-256 9d336d726b879f306002e335f0a934d3896e5bbdb8e67caa30deb03011becbc6; process startup, snapshots, JIT compilation and restores are included. This compares all six native stages against stepped DSP, not the incremental benefit of the filter alone; captures and per-frame results are private. It is not a game FPS or audio result. Full GP/EP bypass, run-loop budget semantics and real game/XISO audio and performance qualification remain open.
A diagnostic Steam Deck run of commit 025f828cd3 with JIT audio and XEMU_GP_FILTER_HLE=1 completed its declared scene checks (run 20261103-051757852-fd8304d11d714bd58341b92c7aa6e279, executable SHA-256 0a26586e80656e195bb38e11320bcfc76da8b1b5d457ad1d0ed189886af52f84). Screenshots show the PGR2 race scene. A separate short capture from the running emulator reported 196,608 stereo frames at 48 kHz, with 196,535/196,541 nonzero samples, RMS 1047/1111 on a signed 16-bit scale, and zero clipped samples; PCM was discarded. The capture was diagnostic and moved the playback stream temporarily, so this run is not a performance comparison. The runner checks scene artifacts, not audio equivalence or native-filter activation. A separate trace run (20261103-052213917-97166383a797447ea2b45ab0b56790ed) timed out at the loading screen before the expected scene, so it failed its scene checks and is ineligible for comparison. Its trace was empty even when a separate DSP-frame event was enabled for a short control interval; it therefore cannot establish whether the native filter executed. The cause of the scene timeout and lack of control events is unresolved. These results do not demonstrate full HLE or correct game audio.
A private slice-boundary prototype tested a possible bridge to the normal GP scheduler. For the 16 captured PGR2 frames it replaced six calls at the beginning of a 1,000-cycle JIT slice (one feedback, one meter and four additions), debited their known DSP cycles, then returned the remaining budget to the JIT. It matched the recorded I/O and every serialized post-state field, including cycle budget; ten varied input/coefficient/history cases also matched with one feedback substitution each. Only six calls in the original 16 frames reached these boundaries, so coverage is small. This private proof lacks a production program-identity guard and has not been integrated or tested as a live path; it does not establish complete DSP bypass, audio parity or performance improvement.
A private profile of the six-stage replay identified a repeated 16-sample multiply-accumulate loop at GP program counters 0x49b–0x49e: 192 executions across the same 16 PGR2 frames account for 12,288 remaining DSP instruction steps. A standalone model using signed 24-bit inputs, fractional multiplication and convergent rounding matched all 3,072 output words against captured before/after DSP states; no captured case clipped or overlapped. The model checks sample output only. It does not yet reproduce CPU registers, loop/stack state, cycle budget, saturation, DMA or other side effects, and it is not integrated into the emulator. The inputs and oracle come from one private game-program sequence, not hardware; no performance improvement or complete audio behavior is established.
Commit cd399fca31 adds the 16-sample multiply-accumulate projection to offline GP replay. It checks loop and stack state, linear memory and the identified program at the caller, rejecting overlap, mix-buffer alias crossings and unsupported saturation. A synthetic DSP-JIT-derived fixture checks samples and control state; additional checks reject unsupported input transactionally. Across the 16 private PGR2 frames, DSP stepping and both native replay modes matched all 913 recorded transactions and checked final state, excluding the run-loop cycle budget. Native replay executed 233,020 DSP steps, 192 multiply-accumulate calls and the six earlier native stages, projecting 282,512 emulated cycles; the all-DSP control executed 433,356 steps. The production projection matched 192 captured complete-state transitions plus 32 JIT-derived synthetic transitions (16 with carry set). Those synthetic generators intentionally stop after the transition, so their whole-frame replay reports incomplete. The emulator, focused MAC test, 19 replay tests and seven snapshot tests built and passed. The stage is offline only; this is not full GP bypass or audio parity.
On the local Ryzen AI Max+ 395/Linux host, balanced ABBA/BAAB offline replay, twice per mode per frame, measured median process CPU 47.883 → 41.255 ms for DSP stepping versus all seven native stages; median paired per-frame improvement was +11.97%, range +5.12% to +28.85%. Median peak RSS was 30,734 versus 30,560 KiB. Exact-head replay executable SHA-256 d9fef7da420522dd5ef3595a5ef317615c44b342e03a1823eedea84ab4442ebe. Startup, snapshots, JIT compilation and restores are included; this is not an isolated MAC-stage comparison, game performance or audio evidence. Captures and per-frame measurements remain private.
Commit 5e1c14b91f allows equal filter offset registers from 0 through 10 in the identified program. This changes the existing opt-in XEMU_GP_FILTER_HLE=1 JIT helper as well as offline replay; unmatched offsets remain on the DSP path. Sixteen private PGR2 captures and 20 varied-input/coefficient/history captures matched the recorded I/O and complete final state in normal JIT replay, with the native filter exercised in every test. In stepped replay, both native cache modes matched all 913 transactions and checked final state for the original 16 captures; run-loop cycle budget remains excluded from this stepped comparison. Filter calls rose from 144 to 384, including 144 calls with nonzero projected output, and native replay executed 89,020 DSP steps versus 433,356 for stepped DSP. Projected native cycles were 539,312 emulated cycles. The emulator and focused tests passed (36 filter cases plus one private-fixture skip, and 19 replay cases). No hardware or complete-audio validation is implied.
A balanced ABBA/BAAB normal JIT offline replay comparison, two runs per mode per frame with the filter opt-in enabled, compared parent cd399fca31 filter code linked with the candidate's common objects against the 5e1c14b91f candidate. On the local Ryzen AI Max+ 395/Linux host median process CPU was 46.047 → 45.218 ms; the median paired per-frame improvement was −0.09% (range −8.79% to +9.92%). Median peak RSS was 30,612 versus 30,762 KiB. The result does not establish an efficiency improvement for this guard change. Parent/candidate executable SHA-256 values were 077e2f716038875e99ef10b5ae3fb88436eb2e4348e04f34b75e32b199bcc9c1 and c7e4d067ab20b03491aa1b060d39c9c81d9e4e2438eceb354259057c82114577; startup and JIT compilation are included. Captures and per-frame reports remain private.
A separate balanced diagnostic with the candidate compared stepped DSP with all seven offline native stages: median process CPU 51.090 → 38.588 ms, median paired improvement +25.87% (range +17.67% to +31.79%), and peak RSS 30,582 versus 30,614 KiB. This measures the combined offline replay route, including snapshot and startup overhead, not the guard's isolated effect or live game performance. Full GP/EP bypass, game-audio parity, representative workload and XISO qualification remain open; the previous Deck trace failed before its scene and cannot establish filter activation.
The next major GP fallback is a 32-sample delay and mixing routine (0x944–0x96c). A private prototype models the two delay histories, 11-position ring, wet/dry selection and output accumulation. It matched the complete recorded DSP state for 32 calls across the 16 private PGR2 frames; all 2,048 stereo output words were nonzero and changed, and no observed case clipped. It also matched 22 synthetic JIT transitions covering each of the 11 ring phases in both dry and wet modes, with varied inputs, histories and coefficients. The synthetic generator intentionally stops after the transition, so it is not a complete-frame replay. The prototype does not yet enforce production memory, interrupt, program-identity and arithmetic guards, is not integrated into live execution, and has no host performance measurement. The captures are one emulator program, not hardware or complete-audio proof.
A diagnostic Steam Deck run of commit 5e1c14b91f with JIT audio and the optional filter enabled reached the PGR2 race scene and completed the runner's declared scene checks (run 20261103-054159971-68afd9a238b24601bb87e14e23ebf699, executable SHA-256 79dd82b5fa99192cfd8090b5bd0816f7db57fae33adf0fa2bc3390efb76951e0). It did not collect audio or native-filter-call telemetry, so it establishes neither sound parity nor filter activation and is not a game performance comparison. The prior trace run's loading-screen timeout remains recorded.
Commit 91ab32e566 adds a guarded 32-sample delay/mixing projection as an eighth offline GP replay stage. It models the two delay histories, 11-position ring, wet/dry selection, accumulated outputs, registers, loop stack and observed emulated cycles. It rejects unsupported program state, interrupts, non-linear or overlapping memory, invalid words and unqualified saturation; the caller checks the exact program identity. The production projection matched all 32 captured complete-state transitions and 22 synthetic JIT-derived transitions covering every ring phase in both modes. Twenty varied complete-frame replays also matched, executing 40 native delay calls. The synthetic transition generator intentionally stops before frame completion.
Across the original 16 private PGR2 frames, stepped DSP and both native replay modes matched 913 recorded I/O transactions and checked final state; instruction stepping excludes run-loop cycle budget. Native replay executed 57,152 DSP steps, 32 native delay calls and the seven earlier stages, projecting 587,692 emulated cycles; stepped DSP executed 433,356 steps. The emulator, delay fixture, 19 replay tests and seven snapshot tests built and passed. This is offline only and does not establish complete DSP bypass, hardware correctness or game-audio parity.
On the local Ryzen AI Max+ 395/Linux host, balanced ABBA/BAAB offline replay, twice per mode per frame, measured median process CPU 49.066 → 35.134 ms for stepped DSP versus all eight native stages. The median paired per-frame improvement was +27.84% (range +24.81% to +30.15%); median per-process peak RSS was 30,802 versus 30,450 KiB. Executable SHA-256 4c0704ef488713c63ac949df53e82bfe3c010bebff62d8b0edcadf1fe413a960. Startup, snapshots, JIT compilation and state restores are included. This is not an isolated delay-stage measurement, a game or XISO performance result, or evidence of correct live audio. Captures and per-frame measurements remain private.
Commit 50ff9711fc adds guarded state projection for the identified 32-sample GP decimation loops to offline replay. It handles the in-place output used by the captures, rejects writes that could overtake unread input, and projects the nested loop stack, registers, status and observed emulated cycles. The caller checks the exact program identity; following DMA operations still use DSP execution. A JIT-derived synthetic fixture covers separate and in-place buffers and rejects unsafe overlap and unsupported threshold.
Across 16 private PGR2 captures, all three replay modes matched 913 transactions and checked final state, excluding the stepped run-loop cycle budget. Native replay replaced 64 decimation calls, executed 43,796 DSP steps and projected 610,856 emulated cycles; stepped DSP executed 433,356 steps. The production projection matched 64 captured complete-state transitions and 30 negative-gain synthetic transitions across all six phases, including 12 in-place cases. Twenty varied full-frame replays matched and executed 80 decimation calls. The synthetic transition generator deliberately stops before frame completion. An earlier private projection failed nine synthetic cases because it modeled the nested loop's saved status as a constant; the corrected status calculation matched those cases. An initial dispatch wiring error also produced zero native calls and was fixed before the reported replay. The emulator, focused decimation test, 19 replay tests and seven snapshot tests passed. These are emulator-derived checks for one GP program, not hardware or game-audio proof.
Balanced ABBA/BAAB offline replay on the local Ryzen AI Max+ 395/Linux host, twice per mode per frame, measured median process CPU 49.208 → 34.238 ms for stepped DSP versus all nine native stages. Median paired per-frame improvement was +30.52% (range +27.08% to +34.27%); median peak RSS was 30,626 versus 30,440 KiB. Executable SHA-256 5a89921873ae608ddb33b9809650d2cacab29ec660dd3ff17d69774de0cbb85e. Startup, snapshots, JIT compilation and restores are included. This is neither an isolated decimation measurement nor a live game or XISO result. Captures and per-frame evidence remain private. Full GP/EP bypass, run-loop budget semantics, audio parity and representative game qualification remain open.
Commit 27ab5c8aff adds guarded projection of the identified 16-sample fractional gain loop as a tenth offline GP replay stage. It includes the observed DSP registers, status, loop stack and emulated cycles; unsupported state, memory ranges and saturation fall back to DSP. The caller verifies the exact program identity. The production projection matched 80 captured complete-state transitions and 20 synthetic JIT-derived positive/negative-gain transitions; synthetic generators stop after the transition and are not full-frame runs. Twenty varied full-frame replays matched and executed 100 native gain calls. The emulator, focused gain test, 19 replay tests and seven snapshot tests built and passed.
Across the original 16 private PGR2 frames, stepped DSP and both native replay modes matched 913 recorded transactions and checked final state, excluding the stepped run-loop cycle budget. Native replay executed 39,876 DSP steps, 80 native gain calls and nine earlier stages, projecting 615,096 emulated cycles; stepped DSP executed 433,356 steps. DMA and other control paths still execute DSP instructions, so this is not full GP bypass or validated live audio.
A balanced ABBA/BAAB offline replay on the local Ryzen AI Max+ 395/Linux host, twice per mode per frame, measured median process CPU 48.317 → 32.796 ms for stepped DSP versus all ten native stages. Median paired per-frame improvement was +31.98% (range +25.33% to +38.23%); median process peak RSS was 30,864 versus 30,422 KiB. Executable SHA-256 e83a51224d2d5910c4da1a0c9898bda65da5c224639f861b6dd49d05a9d9f76a. Startup, snapshots, JIT compilation and restores are included. This is neither an isolated gain-stage measurement nor a game or XISO performance result. Captures and per-frame evidence remain private. Full GP/EP bypass, live audio parity and representative game qualification remain open.
Commit 2509f0063c adds an offline-only bridge for six identified GP DMA-start instruction sites. After verifying the exact program, instruction encoding and supported interrupt/loop state, replay invokes the existing DMA peripheral, reads back its updated state and memory, then advances the CPU state by the observed instruction cost. The cache-clearing replay mode still clears the JIT cache. This uses xemu's existing DMA emulation and does not implement a new hardware DMA model. Unsupported states fall back to DSP; failure after a transfer has begun is reported, not rolled back.
Across 16 private PGR2 captures, all 144 recorded DMA starts were routed through the bridge, producing all 913 recorded scratch transfers in order. Stepped DSP and both native replay modes matched checked final state, including DMA registers, except the run-loop cycle budget, which single stepping does not model. Native replay executed 39,732 DSP steps and projected 615,528 emulated cycles; the stepped control executed 433,356 steps. Twenty varied full-frame replays also matched, with 180 native starts and 1,140 transfers. An altered recorded transaction was rejected. An independently assembled synthetic DSP test compared native and DSP execution for scratch read/write, FIFO output and post-transfer DMA/CPU/memory state; opcode, interrupt and loop-boundary guards also reject without side effects. The emulator, 20 replay tests and seven snapshot tests built and passed. The bridge is not used in live gameplay, and the remaining control instructions still run on the DSP.
Two balanced ABBA/BAAB offline comparisons of this exact candidate against the same source with native DMA dispatch disabled were run inadvertently after a tool-output error. Both used two runs per mode per frame on the local Ryzen AI Max+ 395/Linux host, including startup, snapshots, JIT compilation and restores. The first measured median process CPU 33.681 → 32.995 ms, with +3.30% median paired per-frame improvement (range −4.31% to +8.30%). The second measured 33.312 → 33.137 ms, with +0.13% median paired improvement (range −8.42% to +5.87%). The first raw per-frame report was overwritten by the second run; its aggregate was recovered from the original session output. These results do not establish an isolated speedup. Disabled/enabled executable SHA-256 values: 1584dff959589ac07ec4b4767650d6239e89e0f108b14b8ab50551b5f3438960 and 164b23ee4134f54e6577a7697ba032f835c9fedd53493167b7959f9a492dc4d6. The second per-frame report and captures are private. This is not a game or XISO performance result; full GP/EP bypass, audio parity and representative game qualification remain open.
Commit 352a77b025 extends offline GP replay from individual DMA starts to six verified unfreeze/poll/start/poll sequences. The bridge uses the existing DMA peripheral and checks instruction words, program identity, CPU interrupt and loop state, and the observed stopped/frozen controller state. Unsupported states fall back to DSP. After a transfer it verifies that the polling instructions were not rewritten before committing CPU state; if they were rewritten, it reports failure after the transfer, without rollback. This does not replace the existing DMA hardware model or execute in live gameplay.
Across 16 private PGR2 captures, all 144 sequences ran through the bridge and produced 913 recorded transfers. Stepped DSP and both native replay modes matched the checked final state, including DMA fields, except the stepped run-loop cycle budget. The native route executed 39,300 DSP steps and projected 617,400 emulated cycles; stepped DSP executed 433,356 steps. Twenty varied full-frame replays matched with 180 native sequences and 1,140 transfers. An independently assembled DSP control matched scratch reads and writes, FIFO output, CPU/memory state and DMA state. Tests also verify rejection of altered opcodes, pending interrupts, a loop boundary and unsupported controller state; a self-modifying transfer is detected after its side effect. The emulator, 22 replay tests and seven snapshot tests built and passed. The prior altered-transaction control was rejected. These are emulator-derived checks, not hardware or live audio proof.
A balanced ABBA/BAAB offline replay on the local Ryzen AI Max+ 395/Linux host, twice per mode per frame, compared the exact candidate with the same source built with native sequence dispatch disabled; the earlier individual-start bridge remained enabled in the control. Median process CPU was 31.387 → 31.461 ms, with a +0.30% median paired per-frame improvement (range −8.79% to +10.21%). Median process peak RSS was 30,496 versus 30,430 KiB. Control/candidate executable SHA-256 values were 811f2497ef5635f91fda8cdda097839ddc89d69d9af28d40b74f8b303211d6ad and bb0cb79bd228ba1dd3bcabfcffb11f1f27d7e2b70b15c74f4f8bc6df1c9e6de3. Startup, snapshots, JIT compilation and restores are included. This does not establish an isolated speedup, and is not a game or XISO performance result. Captures and per-frame evidence remain private. Full GP/EP bypass, live audio parity and representative game qualification remain open.
Commit e188375b86 adds guarded offline replay of the identified GP DMA stop/poll/freeze/poll sequences using the existing DMA peripheral. It checks instruction words, exact program identity at the caller, interrupt and loop state, and the observed running controller state. Stop clears RUNNING before DMA execution, and the subsequent freeze leaves the controller stopped, so the bridge does not initiate a transfer. Unsupported states fall back to DSP. It is not connected to live gameplay.
Across 16 private PGR2 captures, the bridge handled all 144 observed stop/freeze sequences; the following native start sequences produced all 913 recorded transfers. DSP stepping and both native replay modes matched the checked final state, including DMA fields, except the stepped run-loop cycle budget. Native replay executed 38,724 DSP steps and projected 619,704 emulated cycles; stepped DSP executed 433,356 steps. Twenty varied full-frame replays matched, with 180 stop/freeze sequences, 180 start sequences and 1,140 transfers. An independently assembled DSP control matched the post-sequence CPU, memory and DMA state; altered opcode, pending interrupt, loop boundary and unsupported controller state were rejected without a transfer. An altered transaction was also rejected. The emulator, 23 replay tests and seven snapshot tests built and passed. These are emulator-derived checks, not hardware or live audio proof.
A balanced ABBA/BAAB offline replay on the local Ryzen AI Max+ 395/Linux host, twice per mode per frame, compared the exact candidate with the same source built with native stop/freeze dispatch disabled; the earlier start-sequence bridge remained enabled. Median process CPU was 32.722 → 32.674 ms, with +0.05% median paired per-frame improvement (range −5.62% to +6.98%). Median peak RSS was 30,538 versus 30,336 KiB. Control/candidate executable SHA-256 values were 2194ac5e69fbb8e8ddbf23331da431d2732563464d3958555812491a3dcfe28b and 7b575018adcb8cf78684b46fca6dc380a8484954fe131cfc67c0a7be05190304. Startup, snapshots, JIT compilation and restores are included. This does not establish an isolated speedup or game/XISO performance. Captures and per-frame evidence remain private. Full GP/EP bypass, live audio parity and representative game qualification remain open.
Final GP filter iteration: Commit 60b0e61a2a projects the final filter body and DO-loop stack restoration in offline replay after checking the exact GP program and loop state. The existing opt-in live JIT slice still leaves the final iteration to the DSP. Sixteen private PGR2 frames matched all 913 recorded transfers and checked final state (excluding run-loop cycle budget) in stepped and both native replay modes; 128 final iterations ran natively. Stepped versus native-assisted replay executed 433,356 versus 31,044 DSP steps. Twenty input/coefficient/history-varied full frames also matched, with 160 final iterations projected. Focused tests check an independent identity fixture and reject an inconsistent stack without modifying state. The emulator and 39 filter tests (one private-capture test skipped), plus 23 replay tests, built and passed.
A balanced ABBA/BAAB comparison, two runs per route for each of 16 frames on Ryzen AI Max+ 395/Linux, measured median process CPU 49.468 → 32.448 ms, with +33.63% median paired improvement (range +29.66% to +38.09%) and median peak RSS 30,858 → 30,458 KiB. Both modes use executable SHA-256 04ab0da26d2b8b8a932d8427c52a8fcadf552e9b743a9bfc388b8041a849a88e. This compares all available native replay stages with stepped DSP and includes process startup, snapshot handling, JIT compilation and state restoration; it is not an isolated filter-stage measurement or gameplay result. Raw captures and detailed measurements are private. Full GP/EP bypass and live game-audio correctness and performance remain unproven.
The same experimental branch also has an opt-in eight-channel filter-frame
shadow. Set XEMU_GP_FILTER_FRAME_SHADOW=1 with the JIT engine to compare
private 32-sample outputs, eight history words, and the last-input temporary
for each guarded channel with the actual DSP after a frame. It rejects
unsupported program identities, descriptors and arithmetic domains, counts
nonzero matched channels, and does not feed audio or update guest memory.
The candidate
matched 10,240 samples and 2,560 history words across 40 private varied-input
replays; half also varied coefficients and initial history. They derive from
one captured emulator frame with fixed recorded scratch reads. The source
includes a synthetic nontrivial JIT-derived test vector. These are development
checks, not a hardware, complete-audio or performance qualification.
A PGR2 Deck run of commit f7c2c8513a with both shadow diagnostics enabled
reported 2,091,120 matched filter-channel frames, including 300,276 with
nonzero output, and zero mismatches at its final periodic report. It had
261,390 eligible recognized frames and no skipped or invalidated recognized
frames; 38,609 earlier frames had different program identities. The runner
passed its declared screenshot-presence checks, which do not validate motion
or audio. Across the whole instrumented run, including boot, the median of
437 process CPU samples was 202.292% of one core and peak sampled working
set was 660.352 MiB. This is a single diagnostic run with both native and DSP
paths executing; it is not a matched comparison and establishes no speedup.
The job was audio-pgr2-gp-filter-frame-shadow-20261103-v1, and the tested
executable SHA-256 was
6893428c860a0f272d85817f53f6c5a0a32fd8dd05c562f6642e875d4323e6a0.
The DSP replay recorder
now accepts XEMU_EP_REPLAY_PATH and XEMU_EP_REPLAY_DELAY_MS, and preserves
GP/EP identity in the recording. It retains existing GP-format compatibility.
Recordings contain program, state and potentially audio data, so keep them
private. In one PGR2 Deck capture, the EP JIT replay matched its native state
and seven ordered transactions across nine calls: six scratch reads and one
1,024-byte FIFO write. The FIFO payload had 980 nonzero bytes. This is one
emulator frame, not Xbox-hardware or full-game audio validation.
The public EP fixture also runs the existing known-input arithmetic/DMA program on EP. On the Deck, both linear and circular variants passed in JIT with all 192 outputs and DMA words matching; the circular descriptor advanced to 544. HLE failed all 192 outputs and the circular offset remained at 800. The test is a correctness gate; neither variant has been run on physical Xbox hardware.
An experimental EP mixer candidate
predicts stereo samples from five inputs for one identified program and loaded
overlay. It includes fixed-point rounding and saturation. Across 40 privately
derived replay cases with synthetic inputs, its C implementation matched all
20,480 samples; 2,454 full-range test samples required saturation. Those
cases reuse one captured overlay and do not validate EP control state, DMA,
interrupts, or other programs. XEMU_EP_MIX_SHADOW=1 enables an opt-in live
comparison that guards program and overlay identities and the observed I/O
sequence. The first Deck run of ac20449bdf had zero eligible frames;
its match count therefore gives no live validation. A follow-up adds guarded
rejection diagnostics and compares the input and mixed 24-bit XRAM buffers
as well as FIFO bytes. In synthetic exact-tie probes, the original model's
rounding differed from the DSP in 258 of 512 intermediate words, even though
the 16-bit FIFO output matched. Commit fc0cb74015 corrects the model to
round ties to even; 10,240 further synthetic tie samples match the JIT in
private replay tests. The shadow comparison also checks five input buffers,
two 24-bit mix buffers, and four peak/RMS meter words. Sixty synthetic replay
cases matched all 30,720 FIFO samples and 107,760 checked XRAM words; these
still share the single captured overlay.
In a subsequent PGR2 Deck run of 03f790cfcd, the last periodic report showed
20,980 matching EP frames, 20,057 with nonzero output, and zero mismatches:
10,741,760 FIFO samples and 37,680,080 XRAM words matched. The diagnostic
identity masks eight P-memory words observed changing within the capture; it
still requires the exact overlay and I/O sequence. It skipped 4,196 recognized
frames with different scratch activity and 4,823 unknown-program frames.
This is a non-serving comparison, not a safe general program-dispatch guard.
Screenshot checks established capture presence only. Across the entire
instrumented run, including boot, median process CPU was 202.621% of one core
over 437 samples and peak sampled working set was 656.434 MiB; this single
run is not a matched performance comparison. The job was
audio-pgr2-ep-mix-masked-shadow-20261103-v1, and the executable SHA-256 was
9f5607eae1e9d58311eb104c78eafb8e628ba4d2550fe5e800bf928f69e598c6.
The candidate does not send predicted audio to the user or establish a
speedup. Full EP control state, DMA, interrupts, other programs and HLE game
audio remain unqualified.
The recorder can capture up to 64 consecutive frames with
XEMU_EP_REPLAY_COUNT. A PGR2 Deck run with recorder commit 2024d02a03
produced 64 private captures and every frame replayed independently. Fifty-three
frames had seven transactions; eleven had an additional 96-byte scratch
read before the usual mixer overlay. The sequence exposed a six-frame program
counter and a two-slot buffer toggle; the earlier single-frame assumption
about those fields was wrong for 53 frames. Candidate 936646a5d0 accounts
for these transitions and checks all eight observed mutable P-memory words.
Its actual native shadow code matched all 32,768 FIFO samples, 114,944 XRAM
words and 512 checked P-memory words across the 64 offline captures. All 64
FIFO frames contained nonzero output. This is one short captured game sequence,
not a general EP implementation or proof of hardware parity. The recorder job
was audio-pgr2-ep-frame-sequence-20261103-v1 and its executable SHA-256 was
65fbd2c1ea6bbe859c28b6a57aaa8a2274cd72d9e27f49ffd02186e90e36d1b5.
The subsequent Deck PGR2 job audio-pgr2-ep-mix-sequence-shadow-20261103-v1 with this candidate reported 25,141 matched frames at its last periodic report, including 24,060 with nonzero output. It matched 12,872,192 FIFO samples, 45,153,236 checked XRAM words and 201,128 checked P-memory words with zero mismatches, while skipping 4,858 unknown-program frames. The DSP remained authoritative. Synthetic cases also showed changes to the DSP status-register limit flag. A hypothesis that any output clipping sets the flag failed in 3 of 60 synthetic replays. A narrower negative-clipping rule matched those 60 synthetic replays, 64 captured game frames, and three controlled silence, positive-only and negative-only clipping cases. These share one identified program and do not establish the instruction semantics. Additional controlled cases varied the incoming low status bits: those bits were recomputed, while an already-set limit bit remained set. Branch commit e7ece21609 adds an opt-in shadow comparison for the predicted status. Deck PGR2 job audio-pgr2-ep-mix-status-shadow-20261103-v1 reported 25,165 matching status predictions and zero mismatches at the last periodic report, with 4,834 unknown-program frames skipped. Of the eligible frames, 24,029 had nonzero output; audio, XRAM, and checked program words also matched. The executable SHA-256 was 2b204d0a1e912d838c4a32db387226185916ca86b7c8819fde9b54caa7c3a2ab. A follow-up comparison of 136 replay snapshots found stack changes in 94, including 22 of the 64 consecutive game frames. The checked interrupt fields, DMA state, other registers, YRAM, and XRAM/PRAM outside the previously identified ranges were unchanged in this sample. The consecutive game sequence changed one saved status-stack word at the phase-5 and phase-0 boundaries; synthetic negative clipping changed additional saved status words. A follow-up varied initial stack values and found five overwritten entries in each stack bank; the other entries remained unchanged in those cases. A prediction matched all entries in 144 replays including six phases and varied starting stacks. Commit 90be25e995 compares that prediction in the opt-in shadow. Deck job audio-pgr2-ep-mix-stack-shadow-20261103-v1 reached a race scene but recorded zero eligible frames: all 29,999 attempted frames at the last report had an unknown program identity. It therefore does not validate the stack prediction. Commit 4d596bbc6b adds a full register shadow projection, including stack-top mirrors; its prediction matched all 64 registers in 144 offline replay cases, after eight varied-stack cases exposed and corrected the mirror-register omission. The actual C projection was subsequently checked against the same 144 replay states with zero register mismatches. A separate Deck capture job audio-pgr2-ep-unknown-program-capture-20261103-v1 did not reproduce the earlier all-unknown session: its last periodic report had 25,177 matching eligible frames, including 24,065 with nonzero output, and zero status, full-register, stack, audio, or checked-memory mismatches. It skipped 4,822 unknown-program frames. All 16 privately captured frames replayed successfully. The earlier all-unknown identity remains unexplained. A private native frame projection now bypasses DSP execution during replay and compares every recorded snapshot field and FIFO payload. It initially failed five of 160 cases: an all-negative-saturated frame produced zero RMS in the JIT but a nonzero native meter. Branch commit cbd85a698c corrects that boundary and adds a regression test. The revised prototype matched all 160 cases and one near-saturation control. The prototype now derives slice counts and timing from initial state rather than using recorded call counts. A naive calculation failed around a slice boundary; the corrected model accounts for the final two-cycle instruction. The actual C helper in commit a360fae7a8 matched all recorded post-state fields in 231 replays, including 70 varied-budget cases. Commit 9cafdf8af5 adds a callback-based input preparation helper for this identified program. It stages scratch reads, verifies overlays through a caller-supplied checker and publishes input only after all reads succeed. In the private replay prototype, a callback adapter consumed the recorded ordered I/O and matched all 231 post-state comparisons. Unit tests cover read failures, bad overlays, invalid words, and unchanged outputs on failure. Commit 8408a4b00c moves the native projection into the in-tree offline replay verifier, accessible with build/test-xbox-mcpx-apu-dsp-replay --replay-native-ep <capture>. It compares the FIFO, the derived slice count, and every captured post-state field without executing DSP instructions. It matched the same 231 private cases; altered program memory, transaction address, call count and post-state were each rejected in negative controls. The positive captures are private game-derived data. Commit 8d6823e31a extracts the frame state and FIFO calculation from the replay reader into a staged projection function. It preserves outputs on invalid input and the refactored replay verifier again matched all 231 cases; 15 replay unit tests passed. Program identity and overlay checks remain separate requirements. Commit e50edbcc47 adds a bounded scatter-gather reader for staged EP scratch input. Synthetic tests cover page crossings, invalid descriptors, address overflow, failed reads and the input preparation path, preserving output on failure. The physical-read callback must enforce ordinary RAM and side-effect-free reads. Commit d322c5d783 adds a RAM-only address-space adapter and an opt-in pre-read comparison. QEMU memory tests reject MMIO, aliases, unmapped and partially mapped ranges without invoking MMIO reads; all 19 sample-memory cases passed after correcting the new test's asynchronous cleanup. Deck job audio-pgr2-ep-live-preinput-shadow-20261103-v1 reported 25,162 eligible pre-reads matched and zero mismatches or preparation skips, with 4,837 unknown-program frames skipped at the last periodic report. Its executable SHA-256 was 4cdfcbba677e5ccb07f0781f8a4d621c1d49b038300644f134a11e92f08a4341. This single instrumented run measured median process CPU 203.727% of one core across 437 samples and peak sampled RSS 651.566 MiB; it is not a matched performance comparison. Commit b7df5b1bf5 extends this shadow to compute the complete native frame from the live pre-read, then compare every captured snapshot field, FIFO bytes and actual DSP slice count. Deck job audio-pgr2-ep-live-full-shadow-20261103-v1 reported 25,176 matching eligible projections, including 24,041 with nonzero output, and zero mismatches at its last periodic report; 4,823 unknown-program frames were skipped. Its executable SHA-256 was 05e1c98cea606a971ff94cd6ea10a8f8b3b215f22c32ef5d08c272cb4d76f32c. This single instrumented run measured median process CPU 205.798% of one core over 439 samples and peak sampled RSS 652.301 MiB, not a matched performance comparison. Commit 3622fece9c adds a non-writing FIFO destination preflight and cursor prediction. The Deck job audio-pgr2-ep-live-fifo-preflight-20261103-v1 reported 25,179 eligible preflights and matching FIFO cursors with zero mismatches or preflight skips; 4,820 unknown-program frames were skipped. The instrumented run had median process CPU 200.616% of one core over 437 samples and peak sampled RSS 650.352 MiB; it is not a matched comparison. Commit 83b9abcf62 adds a conservative entry-state guard. It accepted 80 captured game frames and rejected mutated unit-test states, but Deck job audio-pgr2-ep-live-entry-guard-20261103-v1 had zero eligible frames because all 29,999 reported attempts had an unknown program identity; the guard was not exercised live. Commit 7b24bb079e lets a diagnostic EP recorder exclude a specified masked program digest until the first different frame, then capture a consecutive sequence. The Deck job audio-pgr2-ep-filtered-unknown-capture-20261103-v1 captured 16 frames from the previously unrecognized session; all replayed. They differed from the known program at one additional P-memory word, and all 16 matched complete native output and state in a private comparison and passed the entry-state filter. Commit 9b44122a9c recognizes the second exact masked digest for shadow and replay comparison without masking that word. The in-tree native verifier passed 247 private replay cases including the new frames. Deck job audio-pgr2-ep-live-alternate-shadow-20261103-v1 with executable SHA-256 8767ad784508313e20869112b8f9b75c66b9f55a3b38e1180caff63d6f501a0e reported 25,179 matching full projections and FIFO cursors, with all 25,179 entry guards accepted and 4,820 unknown-program frames skipped at its last report. The last reported digest was the original mixer, so this run does not establish live coverage of the alternate identity. Median process CPU was 202.111% of one core over 439 samples and peak sampled RSS 657.375 MiB; it is not a matched performance comparison. Those shadow results alone do not establish that either digest is safe for live execution; program identity and FIFO safety remain separate from the guard. In those runs the DSP still served audio. These recorded-I/O and shadow checks are not general scheduler, hardware, or game-speed qualifications.
The public Xemu Symphony fork describes a native reverb mode, but its implementation still executes GP code for handshakes and can execute EP code. It does not demonstrate complete DSP bypass. Its compatibility and performance claims have not been independently qualified here; no code was copied from it.
In a balanced eight-run comparison of that same fixed, timer-paced fixture,
median whole-emulator CPU was 120.90% of one core with JIT and 117.70% with
HLE (four runs each); median peak RSS was 633,508 and 628,146 KiB respectively.
Multiple threads can exceed 100%. This synthetic result is not game FPS,
overall game performance, or proof of a memory saving. It does not establish
correct playback for games or effect-heavy workloads. The asymmetric fixture's
tested source was 81ba023f4203b65a766d1c5ec16e4f878bb3f6a7; its emulator ELF SHA-256 was
0f19946ad29b887d07e584755addb5b3f98fcf48ec7333e03fdc3b6196ecc547.
OpenAL Soft's loopback API renders a caller-chosen number of samples into memory without sending them to an audio device. That fits a private-buffer candidate for this comparison process. It does not define arbitrary MCPX program, register or I/O semantics.
The independently written probe and instructions use 48 kHz stereo float32, direct channels, disabled limiter and HRTF where available. Actual format/processing state and API errors are checked. Fresh contexts render each 64-word route; the right channel stays zero. The inverted route explicitly negates input before applying OpenAL's nonnegative gain. Float output is floored back to Q23 for exact comparison.
| Host/library | Half | Inverted-half wrapper | Quarter | Right-channel nonzero |
|---|---|---|---|---|
| Cloud/OpenAL Soft 1.24.2 | 64/64 | 64/64 | 64/64 | 0 |
| Deck/OpenAL Soft 1.24.3 | 64/64 | 64/64 | 64/64 | 0 |
Deck render-call wall times were 15,460 / 12,250 / 10,580 ns, single calls with no balanced timing comparison. They are diagnostics, not speedup evidence. The probe records loaded library hashes in the campaign manifest. It opens no playback device, and xemu's existing SDL output path is unchanged.
# From test/openal-loopback-probe, against a passing public guest report:
python3 openal_loopback_probe.py --guest-report /path/to/new-full/report.json
python3 test_openal_loopback.pyThe next useful OpenAL experiment needs a specific real effect contract and stateful test vectors. Xbox coefficients, saturation/rounding, reverb tails, resampling and external side effects are unqualified. OpenAL's resamplers are implementation-defined; generic API support cannot establish Xbox numeric parity. The limiter and HRTF specifications explain controls that must be pinned during comparison.
For gradual adoption: profile a real route, define its exact identity and state/I/O contract, compare it in private shadow storage, prove unsupported fallback and continuation, then qualify audio and overall game/resource cost. Only a separately reviewed serving path may commit native outputs. Existing filter prototypes #379/#380 are not qualified by this different public gain program. Broader test-kit closure remains #383, and A/V synchronization remains #382.
Experimental live EP serving (not general HLE): Branch commit d980e54728 adds XEMU_EP_NATIVE_EXPERIMENT=1 for a guarded JIT-mode experiment. For two exact masked program identities, it checks entry state, overlay and staged scratch inputs, preflights the FIFO destination, projects native state and PCM, then uses the existing FIFO path. Unknown programs and failed guards fall back to DSP. GP still runs on DSP; the Advanced HLE setting remains an incomplete separate bypass. This switch is for development and is not ready for user testing.
Deck PGR2 job audio-pgr2-ep-native-experiment-20261103-v1 (run 20261103-035630239-15d3c6715ac640e9b44a19af39d035ce, executable SHA-256 d3adfa6a77bc862906d4036c8709c552a9afd4385893fa24ace8460082b3f794) completed. Its last periodic report counted 35,185 native-served frames, 34,088 with nonzero PCM, 4,814 fallback frames, and zero predicted FIFO cursor mismatches. These are periodic counts, not final totals. A private 48 kHz capture had 196,608 stereo frames and nonzero signal in both channels with no clipped samples; signal presence does not prove audio parity. Screenshot checks prove the files exist, not correct movement. The single instrumented run had median process CPU 200.381% of one core across 450 samples and peak sampled working set 658.562 MiB. There is no matched baseline, so this is not a performance comparison. Captures remain private.
The entry guard is inferred from observed frames, and guest-memory/SGE changes between preflight and FIFO use need concurrency review. Exact program recognition is not hardware proof; unknown DSP programs, GP side effects and general DSP compatibility, matched audio comparisons, XISO timing and representative game performance remain unqualified.
These historical campaign measurements are combined test costs and not comparative playback benchmarks. They are retained from the fixes page.
The setup also restores the loop and return stack. 13 captured and 3,328 varied states matched four stepped DSP instructions. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed replay still needed 9,241 DSP steps. The combined offline campaign used 2.622 s CPU, 2.668 s wall, and 31,156 KiB maximum child RSS. This is test cost, not a speed comparison.
The matrix add returns matched 13,312/13,312 varied states across 13 saved starts and four phases. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames still needed 9,017 DSP steps. The combined test used 3.913 s CPU, 3.970 s wall, and 31,124 KiB maximum child RSS. This is test cost, not a speed comparison.
The matrix-to-feedback setup matched 3,328/3,328 varied states from 13 saved starts. A varied accumulator exposed a mismatch, so the guard rejects unverified accumulator values. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames still needed 8,905 DSP steps. The combined test used 4.784 s CPU, 4.842 s wall, and 31,096 KiB maximum child RSS. This is test cost, not a speed comparison.
The matrix feedback returns matched 13,312/13,312 varied states across 13 saved starts and four phases. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames still needed 8,681 DSP steps. The combined test used 6.150 s CPU, 6.210 s wall, and 31,200 KiB maximum child RSS. This is test cost, not a speed comparison.
The matrix-to-copy setup matched 3,328/3,328 varied states from 13 starts. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 8,617 DSP steps. The combined test used 6.773 s CPU, 6.833 s wall, and 31,104 KiB maximum child RSS. An initial strict assertion expected two copy calls; the newly reached copy makes three, and the assertion was updated. This is test cost, not a speed comparison.
The matrix sample-copy return matched 3,328/3,328 varied states from 13 starts. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 8,537 DSP steps. The combined test used 7.197 s CPU, 7.256 s wall, and 31,136 KiB maximum child RSS. This is test cost, not a speed comparison.
The matrix mixer dispatch matched 3,328/3,328 varied states from 13 starts. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 8,393 DSP steps. The combined test used 8.068 s CPU, 8.136 s wall, and 30,936 KiB maximum child RSS. This is test cost, not a speed comparison.
The matrix mixer continuation matched 3,328/3,328 varied states from 13 starts. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 8,169 DSP steps. The combined test used 9.411 s CPU, 9.475 s wall, and 31,136 KiB maximum child RSS. This is test cost, not a speed comparison.
The second mixer-to-copy setup matched 3,328/3,328 varied states from 13 starts. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 8,025 DSP steps. The combined test used 10.432 s CPU, 10.521 s wall, and 31,216 KiB maximum child RSS. This is test cost, not a speed comparison.
The duplicate-sample copy matched 3,328/3,328 varied states from 13 starts, including overlapping buffers. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 4,953 DSP steps, down from 8,025 for the preceding replay. The combined test used 10.559 s CPU, 10.637 s wall, and 31,196 KiB maximum child RSS. This is test cost, not a speed comparison.
The duplicate-copy return matched 3,328/3,328 varied states from 13 starts. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 4,825 DSP steps. The combined test used 11.229 s CPU, 11.310 s wall, and 31,312 KiB maximum child RSS. This is test cost, not a speed comparison.
The post-duplicate add returns matched 6,656/6,656 varied states across 13 starts and two phases. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 4,649 DSP steps. The combined test used 12.545 s CPU, 12.631 s wall, and 31,680 KiB maximum child RSS. This is test cost, not a speed comparison.
The second duplicate-copy return matched 3,328/3,328 varied states from 13 starts. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 4,521 DSP steps. The combined test used 13.074 s CPU, 13.166 s wall, and 31,408 KiB maximum child RSS. This is test cost, not a speed comparison.
The second set of post-duplicate add returns matched 6,656/6,656 varied states across 13 starts and two phases. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 4,345 DSP steps. The combined test used 14.340 s CPU, 14.434 s wall, and 31,384 KiB maximum child RSS. This is test cost, not a speed comparison.
The third duplicate-copy return matched 3,328/3,328 varied states from 13 starts. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 4,217 DSP steps. The combined test used 14.903 s CPU, 14.985 s wall, and 31,480 KiB maximum child RSS. This is test cost, not a speed comparison.
The third set of post-duplicate add returns matched 6,656/6,656 varied states across 13 starts and two phases. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 4,041 DSP steps. The combined test used 16.045 s CPU, 16.128 s wall, and 31,408 KiB maximum child RSS. This is test cost, not a speed comparison.
The fourth duplicate-copy return matched 3,328/3,328 varied states from 13 starts. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 3,913 DSP steps. The combined test used 16.732 s CPU, 16.823 s wall, and 31,148 KiB maximum child RSS. This is test cost, not a speed comparison.
The final post-duplicate add returns matched 6,656/6,656 varied states across 13 starts and two phases. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 3,785 DSP steps. The combined test used 17.512 s CPU, 17.584 s wall, and 31,356 KiB maximum child RSS. This is test cost, not a speed comparison.
The later DMA return matched 3,328/3,328 varied states from 13 starts, including peripheral state. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 3,721 DSP steps. The combined test used 18.056 s CPU, 18.158 s wall, and 31,336 KiB maximum child RSS. This is test cost, not a speed comparison.
The late DMA wait entry matched 3,328/3,328 varied states from 13 saved entries. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 3,689 DSP steps. The combined test used 18.345 s CPU, 18.437 s wall, and 31,556 KiB maximum child RSS. This is test cost, not a speed comparison.
The late DMA completion matched 3,328/3,328 varied states from 13 saved entries. A not-yet-complete transfer was rejected and remained in the DSP wait. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 3,593 DSP steps. The combined test used 18.527 s CPU, 18.619 s wall, and 31,480 KiB maximum child RSS. This is test cost, not a speed comparison.
The post-DMA audio entry matched 3,328/3,328 varied states from 13 saved entries. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 3,385 DSP steps. The combined test used 19.257 s CPU, 19.346 s wall, and 31,620 KiB maximum child RSS. This is test cost, not a speed comparison.
The post-DMA delay setup matched 3,328/3,328 varied states from 13 saved entries. Fuzzing exposed a status-flag mismatch that was fixed. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 3,145 DSP steps. The combined test used 20.416 s CPU, 20.515 s wall, and 31,640 KiB maximum child RSS. This is test cost, not a speed comparison.
The first post-DMA delay return matched 3,328/3,328 varied states from 13 saved entries. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 2,857 DSP steps. The combined test used 22.013 s CPU, 22.114 s wall, and 31,672 KiB maximum child RSS. This is test cost, not a speed comparison.
The final post-DMA delay return matched 3,328/3,328 varied states from 13 saved entries. 16/16 JIT-free partial and 16/16 mixed full frames matched; mixed frames needed 2,697 DSP steps. The combined test used 22.510 s CPU, 22.611 s wall, and 31,352 KiB maximum child RSS. This is test cost, not a speed comparison.
The captured GP frame-entry comparison matched 16/16 entries against four DSP steps and 16/16 mixed native/stepped full frames. Those full frames still required 30,980 DSP steps total; the combined test used 0.719 s CPU, 0.736 s wall and peak process RSS of 31,056 KiB. This is not a game or speed comparison.
The later counter projection matched 16/16 full-state cases, including nonzero destinations, and 16/16 mixed full frames with 16 native counter calls. Those frames still required 30,948 DSP steps; combined test cost was 0.745 s CPU, 0.768 s wall and 30,836 KiB peak process RSS. It is offline-only, with no physical-hardware or speedup proof.
After a nonzero-accumulator test exposed and fixed A0/A2 clearing, the DMA setup projection matched 16/16 full-state cases with nonzero A0/A2 and 16/16 mixed full frames, which still required 30,884 DSP steps. At that stage strict replay stopped at 0x112 with zero DSP steps. The rerun's 48-process combined campaign used 0.961 s CPU, 1.068 s wall and 150,276 KiB maximum child peak RSS reported by the resource API; this is not a performance comparison.
The DMA handoff matched 16/16 state cases and 16/16 mixed full frames, with 30,820 DSP steps still required across those frames. At that stage strict replay executed 16 native DMA sequences with 16 recorded transactions and zero DSP steps, then stopped at 0x120. The combined 48-process check used 0.958 s CPU, 1.059 s wall and 150,520 KiB maximum child peak RSS. This is not speed or physical-hardware proof; JIT remains in use for test state and remaining operations.
The DMA completion projection matched 16/16 full-state pairs and 16/16 mixed frames against the JIT reference. Those frames still needed 30,740 DSP steps total. At that stage strict replay used zero DSP steps and stopped at 0x12c. Its 48-process campaign used 0.938 s CPU, 1.034 s wall and 150,588 KiB maximum child peak RSS; this is not a performance comparison.
The earlier zero-path frame-return test matched 16/16 full-state pairs and 16/16 mixed frames. Those frames still needed 30,644 DSP steps total; strict replay uses zero DSP steps to this point and stops at 0x33. Its 48-process test used 0.927 s CPU, 1.019 s wall and 150,344 KiB maximum child peak RSS.
The expanded projection also matched 16,512/16,512 nonzero synthetic states against the stepped DSP: 1,032 inputs for each of 16 saved states, including positive/negative boundaries and deterministic random values. Zero saved paths and mixed full frames still matched 16/16. The 48-process campaign used 2.951 s CPU, 3.064 s wall and 150,248 KiB maximum child peak RSS. This is not hardware or speedup proof.
The 33-cycle filter-entry handoff matched 16/16 captured states, 4,096/4,096 synthetic control/address states and 16/16 mixed full frames. At that stage strict replay reached 0x185 with zero DSP steps but the filter helper rejected the initial state. Mixed frames still needed 30,484 DSP steps; the 48-process test used 2.310 s CPU, 2.410 s wall and 150,476 KiB maximum child peak RSS.
The first-filter bridge matched 16/16 captured states and 2,048/2,048 synthetic audio/history/accumulator cases at each of its start and tail boundaries. All 16/16 mixed full frames matched and still needed 29,524 DSP steps total. At that stage strict replay completed the first 32-sample filter with zero DSP steps and stopped at 0x1c4. The 64-process test used 3.598 s CPU, 3.717 s wall and 150,232 KiB maximum child peak RSS.
The eight-channel run matched 112/112 transitions, 112/112 first-sample states and 112/112 tail states; 128 synthetic variants per check produced 43,008 full-state matches. At that stage strict replay completed eight filters and seven transitions per frame across 16 frames with zero DSP steps, then stopped at 0x417. It recorded 288 filter calls with nonzero output—not 288 channels or frames. All 16/16 mixed frames matched, with 21,684 DSP steps still needed. The combined test used 27.168 s CPU, 27.501 s wall and 150,892 KiB maximum child peak RSS.
The later meter-entry projection matched 16/16 captured and 4,096/4,096 synthetic control/count/address/accumulator states, including odd and even paths; 16/16 mixed frames matched. Strict replay completed eight filters and one native meter per frame with zero DSP steps, then stopped at 0x43e; mixed frames still needed 21,444 DSP steps. The combined test used 2.773 s CPU, 2.878 s wall and 150,888 KiB maximum child peak RSS. JIT remains the offline state/reference backend; this is not hardware or speedup proof.
The meter channel transition matched 80/80 private captured pairs and 20,480/20,480 varied states against six stepped DSP JIT instructions per case. The 80-process test used 5.650 s CPU, 5.682 s wall and 30,596 KiB maximum child peak RSS. At that stage a strict partial-frame test passed assertions on 16/16 saved frames, then stopped at final meter exit 0x43e.
The final-exit projection matched 16/16 saved pairs and 4,096/4,096 varied states against four stepped DSP JIT instructions. At that stage strict partial frames passed 16/16 with zero DSP steps, then stopped at 0x422. 16/16 mixed full frames matched with 20,900 DSP steps remaining. The 48-process campaign used 1.395 s CPU, 1.422 s wall and 31,116 KiB maximum child peak RSS.
The post-meter dispatch matched 16/16 saved states and 4,096/4,096 varied states against 13 stepped DSP JIT instructions. 16/16 mixed frames matched with 20,692 DSP steps remaining. At that stage all 16 strict partial frames reached the second native DMA stop/freeze with zero DSP instructions, then stopped at 0x8d9. The 48-process campaign used 2.146 s CPU, 2.170 s wall and 31,216 KiB maximum child peak RSS.
The later DMA return matched 16/16 saved pairs and 4,096/4,096 varied states against four stepped DSP JIT instructions. All 16/16 mixed frames matched with 20,628 DSP steps remaining. Strict partial frames executed the return and second native DMA sequence—32–33 sequence transactions per frame—with zero DSP steps, then stopped at 0x8e7. The guard rejects nonzero accumulator upper bits, changed instructions and DMA not stopped/frozen; fuzz exposed the accumulator pointer mismatch. The 48-process campaign used 1.426 s CPU, 1.451 s wall and 31,276 KiB maximum child peak RSS. Live HLE remains JIT-backed; no hardware or speedup proof.
The newer native-state replay candidate constructs no DSP JIT. Against a separate JIT-backed reference, 16/16 saved partial-frame snapshots, errors, statistics and ordered DMA I/O matched; both stop at 0x8e7, with zero candidate DSP steps. The first test incorrectly required 32 transactions for every frame and failed on a frame with 33; after correction, all 16 passed. The final campaign included 16 dual-path tests and 16 separate JIT strict checks: 0.427 s CPU, 0.438 s wall and 27,608 KiB maximum child peak RSS. These are partial frames and combined test costs, not playback or a performance comparison.
The DMA-to-gain projection matched 16/16 saved and 4,096/4,096 varied states against 12 stepped JIT instructions. 16/16 native-state partial-frame comparisons matched without a candidate JIT; at that stage strict replay executed the first gain then stopped at 0x498. 16/16 mixed full frames matched with 20,436 DSP steps remaining. The 80-process campaign used 2.189 s CPU, 2.226 s wall and 30,988 KiB maximum child peak RSS.
The first gain-return projection matched 16/16 captured and 4,096/4,096 varied states against two stepped JIT instructions. 16/16 JIT-free candidate partial-frame comparisons matched the JIT-backed strict reference: each executed two native 16-sample gain blocks and zero candidate DSP steps, then stopped at the then-unsupported second return site 0x498. 16/16 mixed full frames matched with 20,404 DSP steps remaining. The 80-process campaign used 1.619 s CPU, 1.663 s wall and 31,032 KiB maximum child peak RSS.
The gain-to-feedback projection matched 16/16 captured and 4,096/4,096 varied states against six stepped JIT instructions. 16/16 JIT-free candidate partial frames matched the JIT-backed strict reference; at that stage they executed one native feedback operation after two gain blocks, then stopped at 0x792. 16/16 mixed full frames matched with 20,308 DSP steps remaining. The 80-process campaign used 2.165 s CPU, 2.203 s wall and 31,100 KiB maximum child peak RSS.
The first feedback-return projection matched 16/16 captured and 4,096/4,096 varied states against two stepped JIT instructions. 16/16 JIT-free candidate partial frames matched the JIT-backed reference, executing two native gain and two feedback blocks with zero candidate DSP steps before stopping at the then-unsupported second return site 0x792. 16/16 mixed full frames matched with 20,276 DSP steps remaining. The 80-process campaign used 1.649 s CPU, 1.687 s wall and 31,092 KiB maximum child peak RSS.
The feedback-to-copy handoff and stride copy each matched 16/16 captured states and 4,096/4,096 varied states against 11 and 32 JIT steps respectively; copy cases included boundary addresses. 16/16 native-state partial frames matched without candidate JIT, then stopped at 0x60a. 16/16 mixed full frames matched with 19,588 DSP steps remaining. The 96-process campaign used 3.091 s CPU, 3.147 s wall and 31,068 KiB maximum child peak RSS.
The copy acknowledgement and mix setup each matched 16/16 saved pairs and 4,096/4,096 variants against four and 15 stepped DSP instructions, respectively. 16/16 native-state partial comparisons matched without candidate DSP steps, stopping at 0x5a9; 16/16 mixed full frames matched with 19,284 DSP steps remaining. An initial mix guard accepted only one frame; after 15 safe rejections were inspected, the guard was widened to the observed control range and all passed. The 96-process campaign used 4.189 s CPU, 4.247 s wall and 31,088 KiB maximum child peak RSS.
The mix-loop projection matched 16/16 captured pairs and 4,096/4,096 bounded signed-sample variants against 42 stepped JIT instructions. An extra extreme case passed and one unqualified difference was rejected. 16/16 JIT-free candidate partial comparisons matched the JIT-backed strict reference and stopped at 0x5b1; 16/16 mixed full frames matched with 18,612 DSP steps remaining. The 80-process campaign used 2.438 s CPU, 2.485 s wall and 30,924 KiB maximum child peak RSS.
The mix-end dispatch matched 16/16 captured and 4,096/4,096 synthetic states against eight stepped JIT instructions, including both control branches; synthetic validation exposed and fixed a carry-flag mismatch. 16/16 JIT-free partial comparisons matched the reference: 15 stopped at 0x4e2, one at 0x501. 16/16 mixed full frames matched with 18,484 DSP steps remaining. The 80-process campaign used 2.239 s CPU, 2.275 s wall and 30,864 KiB maximum child peak RSS.
The ramp setup and loop each matched 13/13 captured and 3,328/3,328 varied states against the stepped JIT. They cover signed samples and tested increasing/decreasing ±0x10000 ramps. An initial guard admitted only 5/13 captured entries; trace inspection led to broader tested guards and all 13 then matched. At that stage 16/16 JIT-free partial comparisons matched: 13 stopped after the ramp at 0x4f9, two at 0x4e2 on other controls and one at 0x501. 16/16 mixed full frames matched with 17,247 DSP steps remaining. The 90-process campaign used 3.189 s CPU, 3.237 s wall and 31,276 KiB maximum child peak RSS.
The ramp-to-add handoff matched 13/13 captured and 3,328/3,328 varied states against 10 stepped JIT operations. At that stage 16/16 JIT-free partial comparisons matched: 13 executed the handoff and one native add before stopping at 0x4a6; two stopped at 0x4e2 and one at 0x501. 16/16 mixed full frames matched with 17,097 DSP steps remaining. The 77-process campaign used 2.536 s CPU, 2.577 s wall and 31,016 KiB maximum child peak RSS.
The add continuation and final-add-to-MAC projections each matched 13/13 saved pairs and 3,328/3,328 varied states against stepped JIT. 16/16 native-versus-JIT partial and mixed full-frame comparisons matched; the partial run recorded 52 adds, 39 add continuations and 13 MAC operations. Thirteen frames stopped at 0x49f, two at 0x4e2, one at 0x501; mixed frames still needed 16,729 DSP steps total. Combined test cost was 3.540 s CPU, 3.599 s wall and 31,116 KiB maximum child peak RSS.
The MAC continuation matched 3,328/3,328 varied states across 13 captured starts. 16/16 native-versus-JIT partial and mixed full frames matched; at that stage strict runs recorded 39 continuations and 52 MAC operations, then stopped 13× at the final 0x49f exit, 2× at 0x4e2 and 1× at 0x501. Mixed frames still needed 16,489 DSP steps. Combined test cost was 1.941 s CPU, 1.983 s wall and 30,976 KiB maximum child peak RSS.
The MAC final exit matched 3,328/3,328 varied states from 13 saved starts against two stepped JIT instructions. 16/16 native-versus-JIT partial and mixed full frames matched, with 13 final calls and 16,457 DSP steps remaining. At that stage stops were 13×0x625, 2×0x4e2, 1×0x501. Combined test cost was 1.388 s CPU, 1.430 s wall and 31,108 KiB maximum child peak RSS.
The second MAC setup matched 3,328/3,328 varied states from 13 saved starts against 11 stepped JIT instructions. 16/16 JIT-free partial and mixed full frames matched; strict frames recorded 13 setups and 65 MAC calls, then stopped 13× at next return 0x49f, 2× at 0x4e2 and 1× at 0x501. Mixed frames needed 16,281 DSP steps. Combined test cost was 2.828 s CPU, 2.870 s wall and 31,124 KiB maximum child peak RSS.
The nested MAC continuation matched 3,328/3,328 varied states from 13 saved starts against six stepped JIT instructions. 16/16 JIT-free partial and mixed full frames matched; strict frames recorded 13 nested returns and 78 MAC calls, then stopped 13× at the next nested exit 0x49f, 2× at 0x4e2 and 1× at 0x501. Mixed frames needed 15,897 DSP steps. Combined test cost was 1.964 s CPU, 2.002 s wall and 31,040 KiB maximum child peak RSS.
The outer MAC continuation matched 3,328/3,328 varied states from 13 saved starts against eight stepped JIT instructions. Fuzz exposed an incorrect pointer assumption that was corrected. 16/16 JIT-free partial and mixed full frames matched; strict frames recorded 39 outer returns, 52 nested returns and 156 MAC calls, then stopped 13× at the final outer exit 0x49f, 2× at 0x4e2 and 1× at 0x501. Mixed frames needed 15,513 DSP steps. Combined test cost was 2.369 s CPU, 2.407 s wall and 31,064 KiB maximum child peak RSS.
The outer MAC final exit matched 3,328/3,328 varied states from 13 saved starts against three stepped DSP instructions. 16/16 JIT-free partial and mixed full frames matched; strict frames recorded 13 final exits and 156 MAC calls, then stopped 13× at 0x637, 2× at 0x4e2 and 1× at 0x501. Mixed frames needed 15,465 DSP steps. Combined test cost was 1.515 s CPU, 1.556 s wall and 31,092 KiB maximum child peak RSS.
The three-pointer mix setup and loop each matched 3,328/3,328 varied states from 13 saved starts against five and 64 stepped DSP instructions. 16/16 native-versus-JIT partial and mixed full frames matched; at that stage strict frames recorded 13 setup and 13 loop calls, then stopped 13× at 0x4ad, 2× at 0x4e2 and 1× at 0x501. Mixed frames needed 12,313 DSP steps. Combined test cost was 2.666 s CPU, 2.716 s wall and 30,956 KiB maximum child peak RSS. A follow-up test-only assertion update and rebuild verified 13 varied mixer tests and strict frames; production code was unchanged.
The mix-return handoffs each matched 3,328/3,328 varied states from 13 saved starts against four stepped JIT instructions. 16/16 JIT-free partial and mixed full-frame comparisons matched; at that stage strict runs recorded 13 of each handoff, 26 native mix blocks and 65 add blocks, then stopped 13× at 0x4a6, 2× at 0x4e2 and 1× at 0x501. Mixed frames needed 12,185 DSP steps. Combined test cost was 2.521 s CPU, 2.568 s wall and 31,152 KiB maximum child peak RSS.
The post-mix add returns matched 9,984/9,984 varied states across 13 saved starts and three phases against two, four and three stepped JIT instructions, respectively. 16/16 JIT-free partial and mixed full-frame comparisons matched; strict totals were 39 post-mix returns and 104 add blocks. Stops were 13× next 0x4a6, 2× 0x4e2, 1× 0x501; mixed frames needed 12,041 DSP steps. Combined test cost was 2.201 s CPU, 2.241 s wall and 30,968 KiB maximum child peak RSS.
The add-to-mix handoff matched 3,328/3,328 varied states from 13 saved starts against six stepped JIT instructions. 16/16 JIT-free partial and mixed full-frame comparisons matched; at that stage strict totals were 13 handoffs and 39 native mix blocks. Stops were 13× 0x4ad, 2× 0x4e2, 1× 0x501; mixed frames needed 11,945 DSP steps. Combined test cost was 2.018 s CPU, 2.058 s wall and 31,232 KiB maximum child peak RSS.
The mix-to-gain handoff matched 3,328/3,328 varied states from 13 saved starts against four stepped DSP instructions. 16/16 JIT-free partial and mixed full frames matched; at that stage strict totals were 13 handoffs and 45 gain calls. Stops were 13× 0x498, 2× 0x4e2, 1× 0x501; mixed frames needed 11,881 DSP steps. Combined test cost was 1.626 s CPU, 1.672 s wall and 31,356 KiB maximum child peak RSS.
The post-mix gain returns matched 6,656/6,656 varied states across 13 saved starts and two phases against four and two stepped JIT instructions. 16/16 JIT-free partial and mixed full frames matched; strict totals were 26 return calls and 71 gain blocks. At that stage stops were 13× next 0x498, 2× 0x4e2, 1× 0x501; mixed frames needed 11,785 DSP steps. Combined test cost was 1.830 s CPU, 1.866 s wall and 31,092 KiB maximum child peak RSS.
The post-gain add handoffs matched 6,656/6,656 varied states across 13 starts and two phases against four and two stepped JIT instructions. 16/16 JIT-free partial and mixed full frames matched; strict totals were 26 handoffs and 130 add blocks. At that stage stops were 13× next 0x4a6, 2× 0x4e2, 1× 0x501; mixed frames needed 11,689 DSP steps. Combined test cost was 1.906 s CPU, 1.953 s wall and 30,836 KiB maximum child peak RSS.
The post-gain copy setup and loop each matched 3,328/3,328 varied cases from 13 saved starts against five and 32 stepped DSP instructions. Loop variants included overlap, self-copy and aliases. 16/16 JIT-free partial and mixed full frames matched; at that stage strict totals were 13 setups and 13 copies. Stops were 13× 0x492, 2× 0x4e2, 1× 0x501; mixed frames needed 10,073 DSP steps. Combined test cost was 2.219 s CPU, 2.261 s wall and 31,276 KiB maximum child peak RSS.
The post-gain copy continuation matched 3,328/3,328 varied cases from 13 saved starts against three stepped DSP instructions. 16/16 JIT-free partial and mixed full frames matched; at that stage strict totals were 13 handoffs and 26 copies. Stops were 13× next 0x492, 2× 0x4e2, 1× 0x501; mixed frames needed 10,025 DSP steps. Combined test cost was 1.760 s CPU, 1.799 s wall and 31,128 KiB maximum child peak RSS.
The copy-to-feedback handoff matched 3,328/3,328 varied cases from 13 saved starts against six stepped DSP instructions. 16/16 JIT-free partial and mixed full frames matched; strict totals were 13 handoffs and 45 native feedback calls. At that stage stops were 13× next 0x792, 2× 0x4e2, 1× 0x501; mixed frames needed 9,929 DSP steps. Combined test cost was 1.833 s CPU, 1.871 s wall and 31,152 KiB maximum child peak RSS.
The post-copy feedback returns matched 6,656/6,656 varied states across 13 saved starts and two phases against five and nine stepped DSP instructions. 16/16 JIT-free partial and mixed full frames matched; at that stage strict totals were 26 handoffs and 71 feedback calls. Stops were 13× next 0x792, 2× 0x4e2, 1× 0x501; mixed frames needed 9,705 DSP steps. Combined test cost was 2.798 s CPU, 2.846 s wall and 31,072 KiB maximum child peak RSS.
The feedback loop returns matched 9,984/9,984 varied states across 13 saved starts and three phases against four, four and three stepped DSP instructions. 16/16 JIT-free partial and mixed full frames matched; strict totals were 39 loop returns and 97 feedback calls. At that stage stops were 13× 0x697, 2× 0x4e2, 1× 0x501; mixed frames needed 9,529 DSP steps. Combined test cost was 2.540 s CPU, 2.576 s wall and 31,132 KiB maximum child peak RSS.
The feedback-to-matrix handoff matched 3,328/3,328 varied states from 13 saved starts against seven stepped DSP instructions. 16/16 JIT-free partial and mixed full frames matched; at that stage strict totals were 13 handoffs and 13 native matrix calls. Stops were 13× 0x6ae, 2× 0x4e2, 1× 0x501; mixed frames needed 9,417 DSP steps. Combined test cost was 2.055 s CPU, 2.092 s wall and 31,104 KiB maximum child peak RSS.
The later matrix loop returns matched 13,312/13,312 varied states across 13 starts and four phases against two, two, two and one stepped DSP instructions. 16/16 JIT-free partial and mixed full frames matched; strict totals were 52 loop returns and 52 matrix calls. Stops were 13× 0x6af, 2× 0x4e2, 1× 0x501; mixed frames needed 9,305 DSP steps. Combined test cost was 1.996 s CPU, 2.036 s wall and 31,028 KiB maximum child peak RSS. These costs are not a comparative benchmark; live HLE remains JIT-backed.
DSP tooling guide and navigation updated November 2, 2026 for experimental PR #384, source 8f51d237. Capture/replay usage and limits.
The earlier wiki-wide review was published November 1, 2026. Emulator source: b7140848. Reviewed wiki content: 1d2b671. Current status · Release availability · Publication process.
- Home
- Current status
- Stable versus main
- Implemented mechanisms
- Controls and defaults
- Measured results and limits
- Complete change register
- System
- CPU and vCPU
- Memory and DMA
- Graphics / NV2A
- APU and audio
- Timing and timers
- Platform and I/O
- Hardware observations
- Fidelity boundaries
- Methodology
- PGR2 routes
- Debugging lag / hot paths
- Tools and commands
- DSP capture, replay and fuzzing
- HLE readiness and public XISO proof
- Concurrent DSP shadow and OpenAL proof
- DSP HLE operation inventory
- DSP HLE fix examples and testing
- Development
- Upstream shortlist
- Wiki maintenance
- Research / retired work
- Optimization catalog
- Hot-path shortcuts
- Researched experiments
- Unproven proposal directory
- PR lessons
- September26 snapshot
Repository · PRs · Issues