swung0x48/MobileGL
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGL synced 2026-11-07 01:53:24 +09:00
Code Issues Packages Projects Releases Wiki Activity
Files
96037fc502698ceb312de1be269e4ac71b415029
MobileGL/docs/Disaggregated/notes/perf-p15/HANDOFF.md
T

56 KiB
Raw Blame History

P15 handoff (living document)

The plan and its measurements are in PLAN-P15.md; the audit is in PARITY-AUDIT.md.

Target (PLAN §0.1, revised by the user 2026-10-08):

  • CPU scenes: FCL presenting-thread CPU at or below dev monolith (Magma <= 1.79, Espryt <= 2.14 ms/frame), dev measured in the same session, ~5 % noise.
  • GPU scene (Iris + BSL): fps within ~5 % of MobileGlues on both backends.

RESUME HERE (2026-10-09 evening, end of the long P15 run)

Rules from the user (2026-10-09):

  • A fresh agent per clear task boundary.
  • Mechanical jobs (bench A/Bs that follow the existing scripts, builds, log/profile parsing, CI watching) go to sonnet/haiku subagents. Design and implementation stay on opus.
  • No minSdk raise for the shipped build: API 29 is a SEPARATE artifact (its own library, plugin APK and FCL-embedded copy).
  • No record bypass: monolith = record arm.
  • TLS (superseded 2026-10-09): API 29 did not remove the TLS cost (native TLSDESC in a dlopen'ed library costs about the same as emulated TLS), so portable hot-path TLS elimination is approved for all API levels. No TLS-model attributes or API-level gates as the mechanism.
  • No new Android API usage. Keep MobileGL platform-agnostic unless a platform path is measured and has no portable alternative.
  • ASurfaceControl, frame-rate hints and ADPF are deferred.
  • Optimization is driven by Perfetto traces (2026-10-09). Results are reported as a per-frame timeline: phases in order with offsets within a typical frame, the waits, and the critical path. Do not report them as ms tables. simpleperf is for function-level zoom-in inside a phase.

Where the code is (worktree .claude/worktrees/p15, branch p15impl):

  • origin/feat/disaggregated = db346f28 plus the pushes listed in SCOREBOARD.
  • Local on p15impl, not pushed:
    • 14d63881, docs.
    • 8d548d5b, window-scoped freqcheck.
    • ca0a3b74, a cherry-pick of the coordinator's LTO commit 190580f2 on build-opt. The coordinator pushes 190580f2, so drop ca0a3b74 when rebasing.
    • a0015bad, Magma 2a + 2b. Its message carries the m2ab result, or says it is pending.
  • wip/espryt-depthcopy-measured (the two Espryt BSL GPU items rebased onto origin 9f610167, with the device numbers in its message; the old wip/espryt-depthcopy eb7572ff is the unmeasured original). Measured 2026-10-09 on device, NOT landed: no gain on BSL. x = with both items, b = without, both LTO builds of origin 9f610167; gpuhunt, 3 VALID reps each, one arm per cooldown:
    • BSL: x 51.4 fps (0.921 of MobileGlues 55.8), b 51.9 (0.930); GPU 100 % busy in all runs, GPU 19.45 vs 19.29 ms/frame (MobileGlues 17.88). The target of 0.95 is not reached; the items are neutral.
    • Vanilla cpuhunt check (Espryt monolith): x 248.5 fps / 2.87 ms GL CPU, b 254.0 / 2.83 (-2.2 % fps, within noise; no CPU regression worth the name, but no gain).
    • Engaged: the simpleperf profile of the BSL render thread shows BlitDepthTexture2D 0.100 ms/frame in b and gone in x; FramebufferImpl::SyncToBackendByHandle 0.178 -> 0.162. The saved CPU is hidden by the GPU-bound frame, and the GPU time per frame did not move, so the Espryt BSL gap is not in these items. See SCOREBOARD (ebbsl). Original description:
    • (1) Depth glCopyImageSubData goes to the driver (ES 3.2 / EXT/OES_copy_image), with the scratch-FBO depth blit as fallback. Knob MOBILEGL_ESPRYT_NATIVE_DEPTH_COPY.
    • (2) A per-point attachment shadow on the Espryt FBO twin skips an attach call for a point that already holds the same surface. It is keyed on the surface handle {slot, gen} plus driver id, level, layer, call and re-mint generation; texture-side syncs still run. Knob MOBILEGL_ESPRYT_ATTACHMENT_SHADOW.
    • Tests: DepthCopyImageScenario (2 cases) and AttachmentReattachScenario (4 cases), both registered on the split arms. Red-once: a shifted native copy fails all DepthCopyImage cases on DirectGLES; dropping Level from the shadow key fails the level case; keying on the driver id alone fails the recycled-name case.
    • Host suites: 1672 DirectGLES ctest entries (monolith + Split) pass serially in WSL (362 skipped by design), including DepthCopyImage, AttachmentReattach, PassOrder and every blit case.
  • wip/api29-switch (42922d21, on p15impl): -Pmobilegl.androidApi=29 in build.gradle and the plugin's build.gradle.kts.
    • It sets minSdk 29 and therefore ANDROID_PLATFORM android-29; the plugin gets the .api29 id suffix and -api29 version suffix. The CMake API-guard comment is updated. Default stays 26.
    • Verified: the API 29 lib has 95 R_AARCH64_TLSDESC relocs and a TLS segment. __emutls remains only for 3 libc++abi variables.
    • No A/B yet. The next agent runs the H2 A/B: API 26 vs 29, monolith + inproc, both backends, MobileGlues control.
    • Nothing in the tree needs a compile-time API gate yet, so none was added.
    • The FCL-embedded 29 copy needs a matching FCL-side switch (FCL's own minSdk).

The m2ab device job was still running at hand-off. Do not interrupt it.

  • What it is:

    • Started as a background chain: bash p15/m2ab_job.sh > p15/runs/m2ab_job.out; bash p15/espg_job.sh.
    • espg_job.sh is parked: it only echoes "espg parked". The real Espryt BSL job is espg_job.sh.next.
    • m2ab_job waits for the device lock, cools to battery ≤ 33.0 °C, then runs PROFILE=cpuhunt devjob2.sh p15/runs/m2ab.log bash p15/m2ab_session.sh.

  • Arms: cpuhunt H2, 3 interleaved reps, PF=1. Both libs are LTO builds of the same tree:

    • n = libs/p15en, without 2a/2b; monolith with sp=1, plus inproc;
    • e = libs/p15e, with 2a/2b (it also carries the Espryt items, which do nothing on Magma); monolith with sp=1, plus inproc;
    • MobileGlues.

  • Results:

    • per run in p15/runs/m2ab/<arm>-r<N>/ (fps.txt, valid.txt, perf.data on sp=1 runs);
    • the summary is appended to p15/runs/m2ab.log (look for the n= lines).

  • Device restore: the session script runs fcl_scene.sh restore and fcl_p14.sh restore, and devjob2's exit trap stops the bench session and releases the lock.

  • Interim at hand-off (GL CPU ms/frame):

    arm n (without 2a/2b) e (with 2a/2b)
    monolith r1 / r2 2.39 / 2.48 2.29 / 2.45
    inproc GL thread 1.20 / 1.20 1.17
    inproc fps 343.5 / 371.6 363.8

  • When it ends:

    1. Summarize with fclsum.py runs/m2ab. Judge 2a/2b on monolith GL CPU and on the inproc apply thread (threads.txt mgl-srv-apply).
    2. Build the profile caches offline: prof_prep_offline.sh <run> p15e|p15en runs/c1c2/x-DirectVulkan-r1. Compare RenameBusyWireStore, VkBufferObject::Create, SweepDeferredWireReleases and IsSubmitIndexComplete.
    3. If neutral-or-better: amend a0015bad's message with the numbers. Push the p15impl commits WITHOUT ca0a3b74, i.e. cherry-pick onto origin after the coordinator pushes 190580f2. Then CI.

  • Host suites for 2a/2b: done and at baseline (92 environment unit failures, 2 ColdStart).

    • The one extra unit failure seen once, CompositorRecovery.ACompositorOnTheServerWindowRecovers..., is a pre-existing load flake: under full CPU load it fails 6/20 without the change and 2/20 with it.

Hot-path TLS cut (2026-10-09 night, worktree .claude/worktrees/tlshoist, branch tlshoist on origin e70925d3, local, not pushed):

  • c0a9b2cd pGLContext and gPipeInputs become constant-initialized pointer slots (no TLS init wrapper or guard; the owning SharedPtr lives in a second thread_local, released before the slot is cleared at thread exit). 36f55af8 the applier lookup cache is one block. 6191cbf2 Magma session read and built-slot lookup inline. abb22eef Espryt bound serial and per-context cache share one block (epoch bump closes ABA). d4a00835 owner release order + SanityTest fix.
  • Host: unit 92 failures, the same set as the baseline; integration 2 (Spawn.ColdStart.ClearThenReadPixels on both backends), as the baseline. Split-OFF NDK arm64 and the plugin LTO build compile.
  • Device (SCOREBOARD tls): Magma +6.3 % fps, GL CPU -0.14 ms; Espryt +0.9 %, -0.05 ms. TLS resolver 0.058 -> 0.034 (Magma), 0.049 -> 0.035 (Espryt) ms/frame.
  • Remaining emutls per frame (~3-4k): pGLContext ~2.3k, gPipeInputs 0.6-1.1k, Magma session 0.6k (GetActiveRenderPass), ResolveAttributeFromBinding note bumps, SetupWireDraw. Each further cut is ~0.002 ms; not done.
  • Perfetto traces of a second A/B (tlspf) are in runs/tlspf/*/p15.pftrace for the present-wait work.

LTO and the server check (coordinator):

  • libMobileGLServer.so is built and packaged by the LTO-ON assemblePluginRelease. Its only libMobileGL import, mobilegl_server_main, is exported by the LTO lib.
  • The spawn-transport smoke was NOT run. It needs the LTO-ON plugin APK (libs/p15lto/plugin.apk) installed, because the FCL mgdebug install has no libMobileGLServer.so.

Open items, in order:

  1. CI fix: the reds of Test run 37925410578 on db346f28 (integration-split-strict, the two DirectVulkan retrace reds, skip census). Then push the LTO commit (190580f2 on build-opt) and the local p15impl commits (without ca0a3b74), and confirm CI is green.
  2. userguide/ at the repo root, an end-user guide for every setup: which setup to use, how to build, integrate and run it. Covers:
    • Android FCL-embedded;
    • the plugin APK (inproc, spawn with MOBILEGL_IPC_SURFACE=server, TCP);
    • the API 26 and API 29 artifacts;
    • Linux/anland;
    • the Windows WGL drop-in;
    • build options, user-facing knobs and troubleshooting.
  3. DONE 2026-10-09: Espryt BSL GPU items (wip/espryt-depthcopy-measured): device A/B measured, no gain, not landed (see above and SCOREBOARD ebbsl). The Espryt BSL gap to MobileGlues (0.92) is still open; the next lead is the GPU side (render-stage trace of Espryt vs MobileGlues passes), not driver calls.
  4. Small CPU batch: ValidateForVerb residue, Tracker::Update (0.018, mostly inherent), EmitGlobalConstants (0.026). Expected ≤0.03 ms in total.
    • DONE on host, branch cpubatch (2026-10-09). Measured on device 2026-10-09 (SCOREBOARD egc): EmitGlobalConstants 0.022 -> 0.014 ms/frame on both backends, consistent over 3 reps; whole-frame fps inside noise. Line-level profile of fbm2 h-r1..r3 (both backends, p15h syms) and m2ab e-DirectVulkan r1..r3 (LTO).
    • EmitGlobalConstants, cut: the (ShaderCso, Version) key is per handle (the applier keeps one block per record), so switching back to a program whose uniforms did not move sends nothing, and a moved one sends a span against its own held image instead of the whole block. The span is the range the frontend wrote (ProgramObject::MarkUBOContentDirtyRange / TakeUBODirtyRange), so the client shadow and its two-ended diff scan are gone. The scan plus shadow copies were ~0.0065 ms/frame; with the skipped switch-back sends, expect ~0.007-0.010 ms/frame.
    • Tracker::Update: inherent, skipped. ~30 ns per verb over ~25 frontend counters; the only real cut is the epoch skip (PLAN stage 1), which is not a small item.
    • ValidateForVerb residue: skipped. The largest named piece (~0.008 ms/frame) is the MOBILEGL_PIPE_POISON stamp walk, armed by MOBILEGL_BUILD_DISAGGREGATED. The bench libraries are the plugin build (split ON); the FCL-embedded build (split OFF, INFO) compiles it out. The rest (prologue, singleton guards, gates) is spread below 0.002 each.
  5. DONE 2026-10-09: API 29 build plus its A/B (wip/api29-switch, 42922d21). Result in SCOREBOARD (api29):
    • cpuhunt vanilla, 3 interleaved reps, 27 of 27 VALID. fps api29/api26: Magma monolith 1.041, Magma inproc 1.044, Espryt monolith 1.008, Espryt inproc 1.015; GL-thread CPU -3 % / -7 % / -0.6 % / -3.4 %.
    • The gain is not TLS: simpleperf puts tlsdesc_resolver_dynamic (api29) at the same 0.05 ms/frame, about 2 % of the render thread, as __emutls_get_address (api26), because a dlopen'ed library takes the dynamic resolver.
    • Open: whether a static TLS model (initial-exec) on the hot variables can remove the 0.05 ms in a dlopen'ed lib on bionic; and what actually makes the api29 Magma build faster (not isolated).
    • The shipped build stays API 26. The FCL-embedded 29 copy still needs FCL's own minSdk switch. 5b. DONE 2026-10-09 (offline), see PRESENT-WAIT.md. Cause: the display buffer release (~every other frame renders into the buffer just handed back) gates the whole single-batch frame, then ~0.8 ms GPU start latency + 0.5 ms execution; the next queueBuffer throttles on it. MobileGL CPU is not on that path. Options: more Magma swapchain images, gate only the window pass, present off the GL thread. Original scope: present-wait timeline from the existing P15 traces (fbm, c4, c1c2: sched, kgsl submit/retire, gfx atrace, SF frametimeline). Confirm against the TLS agent's base-vs-change Perfetto traces on e70925d3.
    • Finding (egc profiles, e70925d3, cpuhunt, monolith): render-thread on-CPU + off-CPU = frame time.
      Espryt Magma
      on-CPU ms/frame 3.08 2.63
      off-CPU ms/frame 0.89 1.09
      of which in Present 0.82 1.03
    • The blocked stack is the same on both backends: queueBuffer's producer throttle (Fence::waitForever) on the previous frame's GPU-completion fence.
    • So frame time = CPU + present wait. CPU cuts reach fps only if the wait does not absorb them.
    • The GPU is only ~17 % busy at cpuhunt, so the fence signals late rather than the GPU running long. Candidates:
      • work submitted only at swap (~1 batch/frame);
      • the GPU waiting on the compositor's buffer release.
    • Trace (both backends, monolith + inproc, MobileGlues control):
      • MobileGL submit/flush points;
      • kgsl GPU busy spans and frequency;
      • fence create/signal times;
      • SurfaceFlinger latch/release.
    • Decide whether earlier submission (or another portable change) shrinks the wait. 5c. QUEUED 2026-10-10, after the quick before/after fps run:
    • Capture: one Perfetto run per arm (Espryt monolith base vs pwgate+pmflush; Magma monolith base vs pwgate+pmflush+extra 2), traces in scratchpad p15/runs/pwlat.
    • Derive offline: a rough per-frame timeline, and the input-to-present latency from the SF frametimeline.
    • Write it up in docs/Disaggregated/pwait/: what the levers do, the effect on fps and latency, the knob, and the FIFO caveat (extra images add latency only with vsync on).
  6. Smaller follow-ups:

    • DONE 2026-10-09: bench_session.sh stop now runs pin_clocks.sh restore first (verified over a 17-session run: max clocks back to stock after every session, daemons running, no session file). The scratchpad devjob2.sh / fcl_bench.sh hard-code the p15 worktree's copy of the harness; point them at a tree that has this commit.

    • The Fatal{UnmigratedSurface, "AndroidNativeWindow@P12"} text and the tests asserting on it still point at P12. The rule is permanent: a client window cannot cross processes, so windowed spawn uses MOBILEGL_IPC_SURFACE=server. Reword the message to say that.

    • DONE 2026-10-09: the windowed out-of-process smoke of the LTO plugin APK passes on both backends. The plugin is debug-signed and replaced the installed one, with the user's OK. Setup:

      • server: the plugin's MobileGLDisplayActivity, i.e. the :mglwin in-process server on tcp://127.0.0.1:40613;
      • client: FCL with MOBILEGL_TRANSPORT=spawn, MOBILEGL_IPC_CONTROL=tcp://127.0.0.1:40613 and MOBILEGL_IPC_SURFACE=server. ServerOwned 1280x800 window, Espryt and Magma both in-world.

      A plain spawned child has no display (NoServerDisplay). Evidence is in the coordinator scratchpad, p15/runs/spawn_smoke2/.

    • Open from that run: every run logs MG_Remote server: shared image 1 could not be sent on the aux socket (rc=3). Rendering continues, apparently on the non-zero-copy fallback. Find out why the loopback-TCP aux-socket send fails.

Harness rules (all in scratchpad p15/; the tools live in tools/device_bench/disagg/):

  • H2 = fcl_bench.sh, driven by fclab2.sh for interleaved arms; summaries come from fclsum.py.

  • Every session goes through devjob2.sh (device lock, bench session, restore on exit). Profiles:

    • PROFILE=cpuhunt for CPU work (CPU 1.5/1.25 GHz, GPU 903);
    • PROFILE=gpuhunt for BSL (CPU 2.4/1.8, GPU 578).

  • BSL: one arm per cooldown (battery ≤ 33.0 °C between runs), arms interleaved across cooldowns. At gpuhunt the scene hits thermal limits by the second back-to-back rep.

  • Validity: freqcheck.py judges clocks over the measurement windows only (measure_raw.txt spans) and thermal over the whole run.

  • Stop a session on thr>0, a thermal_pwrlevel below the pin, or "max capped". Discard INVALID runs and go on. Never stop on tpl alone: it is 6 by construction at gpuhunt.

  • Build simpleperf binary caches only after a session, or offline with prof_prep_offline.sh (donor cache plus the build-id entry in build_id_list). Never adb-pull during a session.

  • Never edit a bash script that a running job will still read (bash reads scripts incrementally).

  • TaskStop does not reliably kill child bash processes on this host: kill the PIDs, and only the inner session processes, so devjob's cleanup runs.

  • Libraries live in scratchpad/p15/libs/<tag>/lib/arm64-v8a/libMobileGL.so, with symbols in syms/<tag>/ and runs in runs/<session>/. Tags:

    tag contents
    p15e LTO + 2a/2b + Espryt items
    p15en p15e without 2a/2b
    p15lto / p15off LTO ON / OFF, both with 2a/2b
    p15a29 API 29
    p15h the pipe batch
    p15y 1c
    p15t before 1c

  • Profile tools: topinc.py, callers.py, callees.py, layerfns.py, layerdiff.py, diffprof.py, appside.py, pftstate.py (Perfetto SQL), threadstate.py.

Device state at hand-off:

  • At hand-off the m2ab session was still running; it restores FCL, the scene and the bench session itself.
  • The device lock is released by devjob2 when m2ab ends.
  • The plugin installs top.mobilegl.plugin.*.trace from earlier phases are still on the device.

Open: Espryt small-store write rename (branch pmflush, 2026-10-09, host-verified, needs device)

Not a p15 regression. MONOLITH-DIFF's top Espryt row (FlushPendingRangesFrom driver 0.091 + libc 0.025, "dev 0") is the rename the doc's own caveat lists: dev's FlushPendingRangesNow costs 0.086 + 0.019 in the same profiles. Both are the same three-tier ladder, unchanged since dev f973008c. Inclusive: dev 0.066 / p15 0.078 (feat-esp-1), 0.106 on the newer api29ab e26 run. So the drain is real cost that dev pays too.

What the drain is. Under it, 0.080 of 0.106 ms/frame is one Adreno driver routine reached from glCopyBufferSubData (dispatch slot 0x670 -> 0x3250c0 -> 0x2ee9d0, with heap allocations inside). So it is the upload-ring tier: one GPU copy job per queued partial range. The 1.21.5 in-world trace (5998912 calls, last 252 frames) shows the shape: 162 glBufferSubData a frame. 122 of them are partial writes from offset 0, mostly 96 or 192 bytes into 288-byte vertex stores, and ~3 KB into 6.7 KB ones. That is Minecraft's per-format immediate vertex buffer. Magma already renames these stores (RenameBusyWireStore, S0 M4); WriteWireBuffer costs 0.031 ms/frame there, so Magma needs nothing.

Change. RenameSmallStoreForDrain (Managers.cpp) runs before the draw-time drain. For a store <= 64 KiB whose unwritten bytes are <= 8 KiB, it replaces the queue with [0, store). The pinned ladder then takes its tier 1, the whole-buffer orphan-map: no copy job, and recorded draws keep the old storage. It refuses when the store holds bytes the host copy does not have: serverGpuWritten, queued resident writes, persistent/immutable/imported stores, or split staged coverage short of the whole store. On the trace this renames 108 of 122 partial writes a frame, at +101 KiB of host memcpy a frame; a plain 64 KiB bound would cost +811 KiB, because of 128-byte writes into a 53 KiB index store. The ladder bodies and the G5 pins are untouched.

Tests. EsprytFlushLadder has 3 new unit cases. There are 2 new scenarios, one per backend on every arm: AtomicCounterScenario.APartialSubDataBetweenDispatchesKeepsTheShaderWrittenNeighbour and CrossFrameBufferScenario.APartialSubDataBetweenTwoDrawsOfOneFrameKeepsTheFirstDrawsBytes. The skip census mirrors their siblings' skipped lanes. Red-once: dropping the serverGpuWritten refusal reds the atomic case on DirectGLES.Spawn, which reads back 16 instead of 32; monolith and inproc pass because the frontend reads GPU writes back before a partial CPU write.

Suite results. WSL archlinux, clang Release, lavapipe, env MOBILEGL_ITEST_REQUIRE_GPU=1, suites run one at a time:

  • unit 2907/2907;
  • integration 5300/5300 on the labels gpu, split, magma-all-split, magma-full-split, monolith-control, cold-start, cpu-mip-split, clientarrays-split and remint-fallback-split;
  • 354/354 spawn+TCP buffer, SSBO, atomic, persistent, XFB and index scenarios;
  • 18/18 Espryt retraces (OpenRA, 1.21.4-in-world, 1.21.11-main-menu, sodium, create-instancing, Iris BSL; each monolith, SPLIT and SPAWN);
  • both Android arm64 shapes compile (disaggregated ON and OFF, android-26).

A first run with the dozen ICD (REQUIRE_GPU=ON in the cache) failed 1488 DirectVulkan cases. That is the ICD, not this change: there were 0 DirectGLES failures.

Host blocker for retrace evidence (pre-existing). Espryt on llvmpipe segfaults in the 1.21.5 fixture at call 75682 (a glDrawElements right after vertex buffer 8 is deleted and recreated). This happens on the base tree too. Magma completes (SSIM 0.985 on dozen). So Espryt cannot be checked for SSIM on this trace on the host.

Device ask (Perfetto first, per the 2026-10-09 rule). FCL MC 1.21.5 vanilla bench scene, monolith, cpuhunt pinned, base = origin e70925d3 vs pmflush, same LTO settings. Run Espryt (the arm under test) and Magma (control, expected identical). Capture a Perfetto trace per arm with:

  • sched_switch/wakeup, cpu_frequency;
  • atrace gfx/view/hal;
  • kgsl gpu_frequency and GPU busy/slices;
  • dma-fence signals;
  • SurfaceFlinger frame timeline.

Report one typical frame as a timeline: render thread runnable/running/blocked, queueBuffer/dequeueBuffer waits, the GPU slice and its end against the next frame's throttle wait. The question is whether removing ~100 copy jobs a frame shortens the GPU slice and with it the ~0.8-1.0 ms queueBuffer wait (a shorter frame), or only cuts CPU (a longer wait, the same frame). simpleperf zoom: FlushPendingRangesFrom inclusive and its callees, expected to drop from ~0.106 towards ~0.03 ms/frame (the orphan-map plus the extra memcpy). Also check the driver's map path (slot 0x550 -> 0x1db8a0) does not grow into new allocations per rename. Correctness: SSIM/golden on the device retrace of minecraft-1.21.5-vanilla-fcl plus the Iris/BSL cases, Espryt.

Present-wait levers A + B (branch pwgate, worktree .claude/worktrees/pwgate, 2026-10-09)

Built on origin/feat/disaggregated a759b4b7. Host-only so far; the device plan is below. Mechanism: PRESENT-WAIT.md (p15/pwait): every other frame renders into the buffer the display just released, and the whole frame batch was gated behind that buffer's release fence.

Commits (local, not pushed):

  • 168451bc Magma: submit a frame's off-screen work ahead of the swapchain acquire wait.
  • 66adc7aa Espryt: flush once per frame ahead of the window buffer's first use.
  • dd3e608a Tests: WindowPassGateScenario covers frames split around the window pass.
  • cdd2160f Magma: MOBILEGL_MAGMA_EXTRA_SWAPCHAIN_IMAGES asks for swapchain images beyond the surface minimum.

Lever A, Magma (no knob).

  • FrameData::acquiredImageReferenced means the open recording uses the acquired swapchain image. It is reset at every acquire (WaitAndAcquireNextImage, AcquireNextImageInCurrentSlot).
  • SubmitPendingCommandBuffer waits on imageAvailableSemaphore only when the recording references the image, or when the caller forces the wait (ParkActiveTarget's wait-out). It marks the semaphore consumed only when it waited. Present's own submission still waits whenever the semaphore is unconsumed.
  • SubmitAheadOfAcquiredImage() runs before the frame's first use of the acquired image. It flushes what is recorded so far without the wait, then marks the image referenced. It is called from:
    • SetupDraw when the draw framebuffer is the default one, next to SplitOversizedRecording, before anything of the draw is recorded. Splitting later in setup lands after the draw's descriptor bind, because the attachment pre-resolve reads the default framebuffer's read index. That was measured as VUID-vkCmdDraw-None-08600 plus an llvmpipe segfault.
    • ClearWireFramebuffer for the default framebuffer.
    • ResolveWireImage for the acquired colour image. This is the net under blits, copies, readbacks and shared-image presents.
    • Present. A frame that never touched the window submits its work unwaited, and the present's own submission carries the wait, possibly with no command buffer.
    • Inside a draw's preparation (m_wirePreparationDepth != 0) it only marks the image; it never submits.
  • Wait stage: every acquire wait now uses FrameContext::kAcquireWaitStages (COLOR_ATTACHMENT_OUTPUT | TRANSFER). Before, mid-frame flushes waited at ALL_COMMANDS and the present submit at TOP_OF_PIPE, which waits for nothing.
  • TransitionWireImage adds those stages to the source scope when a default colour image leaves PRESENT_SRC_KHR or UNDEFINED.
  • Engagement proof: one latched log line, DirectVulkan: a frame's off-screen work goes to the queue ahead of its window pass ....
  • Acquire timing is unchanged: the next image is still acquired at the end of Present.
    • Acquiring later cannot move the gate. The buffer queue's free list is FIFO, so a later dequeue gets the same buffer, or a more recently released one, with the same release time R.
    • It would also break the buffer-age contract: CurrentDrawBufferAge answers for the image acquired at the previous present.
    • So no device A/B was spent on it.

Sync-correctness argument (Magma).

  • One wait per signal. Each acquire signals imageAvailableSemaphore once. Exactly one submission waits on it: the first whose recording references the image, or the present's, or the park wait-out. All three check and set imageAvailableSemaphoreConsumed. The next acquire on the slot comes after the slot's fence wait, so by then the semaphore is unsignaled with no pending wait.
  • Recordings that never reference the acquired image carry no wait. That is correct because none of their commands access it.
    • Reads of m_defaultFramebufferImageIndex that name the previously presented image touch a different image.
    • The old code did not order those reads against an acquire either.
  • Every first access of an acquired image is a layout transition out of PRESENT_SRC_KHR or UNDEFINED:
    • TransitionWireImage, whose source scope includes kAcquireWaitStages;
    • TransitionToPresent, whose source scope is ALL_COMMANDS.
  • The semaphore wait's second scope covers kAcquireWaitStages in its own batch and in every later batch. So the transition is ordered after the presentation engine's release, even when the use is in a later submission than the wait. Through the transition's ALL_COMMANDS destination, everything after it is ordered too.
  • renderFinished is signaled by the present submission. That is last in submission order, so its first scope covers the off-screen submissions too.
  • Unchanged by this work:
    • Frames in flight: split submissions take pooled fences and advance lastSubmitIndex, and the present's slot wait covers them.
    • Wire render-pass guard: FlushPendingCommands ends the open pass.
    • Pass-barrier coalescing: barriers order across submissions.
    • Deferred clears: the default framebuffer never defers.
  • Not machine-checked. lavapipe syncval does not flag a broken acquire chain.
    • Positive control: removing the source-stage fix while keeping the narrowed wait still gave 0 hazards.
    • It never flagged the old present submit's TOP_OF_PIPE either.
    • The argument above rests on the spec.

Lever A, Espryt (no knob).

  • FlushAheadOfWindowBufferUse() issues one glFlush per frame, just before BindCurrentFBO or SyncAndBindFramebufferByHandle moves the driver's binding to framebuffer 0. A thread-local flag limits it to once per frame and is reset at the present's swap.
  • Window surfaces only: a pbuffer has no lazy dequeue.
  • Not issued on MobileGL's own scoped binding restores, or when the binding is already 0. A frame that renders straight into framebuffer 0 has nothing to flush ahead.
  • No wait and no glFinish. Adreno dequeues lazily at the first default-framebuffer use.
  • Host coverage is pixels only, because the harness has no window surface.

Lever B (knob, default 0).

  • MOBILEGL_MAGMA_EXTRA_SWAPCHAIN_IMAGES (0-16) requests max(frames-in-flight hint, surface minImageCount + extra) images, clamped to maxImageCount.
  • Logged as Set minImageCount = N (surface min M, max X, extra K).
  • Documented in userguide/configuration.md and the README knob table.
  • Cost per extra image at 2560x1600: one RGBA colour buffer (~16 MB) plus the default framebuffer's same-size depth/stencil image.
  • Vulkan only. Espryt's EGL buffer count needs a platform API, so it is deferred.

Host verification. Setup: WSL archlinux, clang, CMake 3.31.10, ~/mgl-pwgate-ci31, lavapipe, suites run serially.

Check Result Baseline
Unit 2904 tests, 92 failed (ServerSpawn / PeerLatch / FuzzArm2) same 92, environmental
Integration: integration-gpu, -magma-all-split, -magma-full-split, minus spawn and tcp, MOBILEGL_ITEST_REQUIRE_GPU=1 3883 tests, 2 failed (both Spawn.ColdStart ClearThenReadPixels) same 2
Syncval (submit-time, shader heuristic): WindowPassGate + CrossFrameBuffer + DefaultFramebufferAcrossSwap.ADraw*, monolith and inproc 0 hazards, 0 VUIDs; also clean with EXTRA_SWAPCHAIN_IMAGES=2 and FRAMES_IN_FLIGHT=2 —
CI gates magma_runahead_checks.py negative, validation, magma_cache_checks.py rc 0 —
EXTRA_SWAPCHAIN_IMAGES=2 85 present-shaped Magma entries pass; minImageCount 4+2 = 6 on the headless surface —
Android arm64 plugin release (assemblePluginRelease), API 26 and API 29 both rc 0 —
  • The integration run includes WindowPassGateScenario on DirectGLES and DirectVulkan (monolith, Split, Split.Full), plus the DirectVulkan.WindowPassGate. arming entry.
  • Verb tables are unchanged, so split_coverage was not needed.
  • The spawn and tcp lanes fail on this host for every scenario: TcpServer.Start fails, and spawn bring-up aborts with CapsBeforeFirstSnapshot.
  • Pre-existing, not from this work: DefaultFramebufferAcrossSwap.AReadbackAfterASwap reads an image already handed to presentation, which syncval reports as WRITE_AFTER_PRESENT. That is why the new scenario reads back before its swaps.

Device plan (not run; another agent has the phone).

  • Libs: both are API 26 default plugin builds.
    • base: origin/feat/disaggregated a759b4b7.
    • A: pwgate cdd2160f.
  • Setup: same FCL, MC 1.21.5 vanilla frozen world, cpuhunt clocks, FCL pinned to cpu2-6.
  • Validity rules: fcl_bench.sh VALID, freq and thermal sampled every 1-2 s, throttled runs dropped.
  • Perfetto (PF=1): p15_perfetto.cfg with every kgsl/* ftrace event removed (not on this kernel). Keep:
    • sched (switch, waking, wakeup, blocked_reason), cpu_frequency and cpu_idle;
    • atrace gfx + view for the FCL package and surfaceflinger (gfx is what creates the GPU completion / HWC release FenceMonitor threads);
    • process_stats and android.surfaceflinger.frametimeline;
    • 5 s duration.
  • Arms, 3 interleaved reps each:
    1. Espryt monolith: base, A.
    2. Espryt inproc: base, A.
    3. Magma monolith: base, A, A+MOBILEGL_MAGMA_EXTRA_SWAPCHAIN_IMAGES=1, A+=2.
    4. Magma inproc: base, A, A+1, A+2.
  • Engagement proof:
    • Magma A: logcat has the latched "goes to the queue ahead of its window pass" line, and the trace shows QueueSubmit per frame rising from ~1.33 to ~2.3 (one submit just before the blit's draw, one at present).
    • Extra images: logcat shows Set minImageCount = 6/7 (surface min 5 ...).
    • Espryt A has no marker. Take one extra gpu.renderstages capture per Espryt arm (it works on this device); it should show A's off-screen stages running before R.
  • Analysis, with the scratchpad p15/pwait/ scripts:
    • cycle.py <label> <runs...>
    • pairs.py
    • gexec.py
    • sim.py <label> <start> <exec> <runs...>
  • Report per-frame timelines, not ms tables.
  • Expected for lever A (PRESENT-WAIT, "What a fresh trace should confirm"):
    • Gated frames stay at ~50 %.
    • For gated frames, E - R falls from ~1.35 to ~0.9 ms: start latency plus the window pass only.
    • Back-to-back execution is unchanged at ~0.5 ms.
    • sim's throttle, ms/frame: Espryt mono 0.62 -> 0.49, Magma mono 0.72 -> 0.54, Magma inproc 1.31 -> 1.09, Espryt inproc 1.09 -> 0.91.
    • If E - R does not fall, either the driver gates the off-screen submission too, or the split is not engaged. Check the submit count, and when the GPU work starts relative to R.
  • Expected for lever B:
    • HWC release fence N has signaled at >= 85 % of AcquireNextImageKHR.
    • Gated frames < 20 %.
    • Throttle < 0.2 ms/frame on monolith.
    • inproc may need +2 (sim: 23 % still gated at k=2).
    • The user picks lever B's default from these curves.

Earlier (2026-10-09): cuts 1b + 1c, cut 4, pipe-record pieces

  • Landed locally (pushed after the BSL gpuhunt check):
    • 66e3b2c1 (rebased as 65d4b808): Espryt surface-size memo, GL CPU 3.18 -> 3.05.
    • 533a2564: Magma deferred clears (1c) plus coalesced pass-begin barriers (1b).
      • Per frame: passes 11.5 -> 4.3 (dev 4.1), barriers 15.5 -> 9.0 (dev 3.4).
      • Inproc +5.0 % fps, apply thread -0.17 ms; monolith GL CPU -0.09 ms.
  • Landed 2026-10-09 afternoon:
    • 485dff14: pipe client batch, i.e. the per-framebuffer FB-state memo (MOBILEGL_PIPE_FRAMEBUFFER_STATE_MEMO), handle hints, per-buffer handle reuse and the per-verb gate cache.
    • c85c9439: Magma hash TLS hoist.
    • Effect: H2 GL CPU Magma 2.68 -> 2.62, Espryt 3.03 -> 3.00. The profile is in SCOREBOARD (fbm2).
    • 9eed5a27 / 9ff97c2e: CI branch fixes. The E1 control follows ApplierReset, and ScenarioIsolation is listed as unarmed in verify-split.
  • Small-cut policy: pieces below about 0.03 ms are verified by their own before/after function profile plus a red-once, and get one H2 A/B per batch.
  • Order (coordinator, 2026-10-09): FB-state memo, then handle cache on objects, vertex input, program, samplers, accessor/TLS hoist, the ValidateForVerb dirty walk, Tracker.
    • No record-bypass design change until the user decides.
  • Parked: the Espryt attrib-format split (MONOLITH-DIFF.md).
  • Remaining Magma barriers: CPU ceiling ≤0.02 ms. Revisit only if BSL shows a Magma GPU gap.
  • Harness gotchas found today:
    • tpl in the freq sampler is kgsl thermal_pwrlevel. Under gpuhunt it is 6 by construction (the 578 MHz pin); freqcheck already maps it. Stop a session on INVALID or thr > 0, never on tpl > 0.
    • Never run binary_cache_builder (adb pulls) while a session is measuring. Build binary caches after the session ends.
    • FCL sometimes dies at bootstrap with signal 34 (seen on every build including MobileGlues); fclab2 retries, and a run that never reaches the world is lost.
  • Monolith floor estimate (MONOLITH-DIFF.md, structural):
    • Pipe record: 0.35 -> about 0.10-0.13 if every local piece lands.
    • Whole Magma GL thread: about 2.35-2.40 ms (native TLS: about 2.30), against dev 2.00.

Earlier (2026-10-08 late): harness H2, dev reference, scoreboard

  • Every FCL vanilla number now goes in SCOREBOARD.md. It has one row per session, as fps ratio to MobileGlues plus CPU ms/frame. It also holds the fixed dev reference, so "vs dev" no longer needs dev in every session. The per-function dev baseline is in MONOLITH-DIFF.md.
  • The old probe's variance was core placement. The scheduler gave MobileGL's monolith render thread the X4 core 72-90 % of the time and MobileGlues' 47-60 %. MobileGlues' fps tracked its X4 share (fifi: 60 % -> 378, 47 % -> 344).
  • Harness H2 (scratchpad p15/fcl_bench.sh, fclab2.sh, benchwin.py): the same for every arm.
    • After world entry, taskset -a -p 7c pins FCL to cpu2-6 (A720).
    • fps comes from the SurfaceView BLAST layer frame= in dumpsys SurfaceFlinger. It agrees with the MobileGL fps log over the same span (252.1 vs ~253).
    • Warmup: 20 s, then 5 s windows until two consecutive ones agree within 3 %.
    • Measurement: two 5 s windows with no tracer; CPU from schedstat.
    • atrace, then the optional simpleperf (sp=1), run only after the windows.
  • Frozen bench saves (1.21.5 and 1.21.4-Fabric, scratchpad p15/freeze_world.py):
    • Rules: no daylight, weather or mob-spawn cycle, randomTickSpeed 0, no fire tick.
    • DayTime 6000, clear weather.
    • Before this, the vanilla save's day cycle was running.
    • The originals are on the device as level.dat.p15-orig.
  • Spread over 3 interleaved reps, (max - min) / mean:
    • Old probe: Espryt 9.3 %, Magma 5.6 %, MobileGlues 1.3 %; MobileGlues spanned 322-376 across sessions.
    • H2: Espryt 1.2 %, Magma 2.9 %, MobileGlues 2.0 %, dev 6-7 %.
  • Dev reference (H2, safter, all VALID): MobileGlues 321.5 fps / 1.70 ms. dev Magma is 0.950 of that (2.01 ms) and dev Espryt 0.887 (2.38 ms).
  • On A720 the monolith gap is larger than the X4 hid: p15s Magma is 0.768 of MobileGlues (0.81 of dev, 2.91 ms) and Espryt 0.746 (0.84 of dev, 3.18 ms). That is +0.90 / +0.80 ms/frame of CPU over dev.
  • Inproc p15s Magma on H2: 327.7 fps against MobileGlues ~321.
  • Emulated TLS: __emutls_get_address costs ~0.06 ms/frame of self time on the p15 monolith render thread, spread over many callers. dev shows almost none. The structural fix is native TLS (minSdk), which is the user's call.

Earlier (2026-10-08, after S0)

Every number below carries its profile and passed the validity check (state.txt). cpuhunt = CPU about 1.5/1.25 GHz, GPU 903 MHz (cleanly CPU-bound); interval 0, anland off, daemons stopped.

  • The S0 milestone's absolute numbers are superseded. The perf stack's msm_performance caps (787 / 1286 / 1075 / 1248 MHz) were clamping the CPU under the pin for some of that session. Only same-session deltas from it stand. Measurement now uses bench_session.sh and the sampler (PLAN §1), and the probe reports only clean fps windows taken before any tracing (P15PROBE trace-start marker, 25 s settle).

  • FCL vanilla 1.21.5, cpuhunt, presenting-thread CPU ms/frame:

    build Espryt Magma
    dev 1.76 1.60
    p15k (S0 + VAO shadow) 2.10 2.03
    p15l (+ vertex-elements dedup) 2.10 2.08

    MobileGlues: 1.58 in an earlier cpuhunt session (needs a same-session re-run with clean windows). Floor gap: Espryt +0.34, Magma +0.43 ms.

  • Driver-call redundancy:

    • Measured with a diagnostic build that counts every host GLES/EGL call and redundant re-sets (p15diag worktree, never committed; HostCount.inl and VkCount.cpp).
    • Espryt sent 3717 host calls/frame against MC's ~874: 2118 glDisableVertexAttribArray, 378 enable, 378 divisor, all re-sets.
    • Two fixes, each independently removes the walk churn:
      • b4e209e1: a shadow of each driver VAO (850 calls/frame);
      • c8a5abe5: the client no longer re-creates an identical vertex-elements record on every glBindVertexBuffer. With the shadow off it takes 3724 down to 1228.
    • CPU gain is small (about 0.1 ms): the calls were cheap in the driver.
    • Magma issues about 380 Vulkan calls/frame with essentially none redundant.

  • Where Espryt's gap to dev is now: the driver time equals dev's (0.50 vs 0.48). The excess is libMobileGL itself, 0.75 vs 0.32: client half 0.51, backend 0.24, applier 0.02. The client half is spread thin (validate, tracker, emitters, residual copy): S1's draw-delta.

  • Inproc (cpuhunt):

    • Espryt reaches 306 fps vs MobileGlues about 319; GL thread 1.68 ms, apply thread 1.83 ms of a 3.27 ms frame.
    • Neither thread is saturated. The apply thread waits in queueBuffer on a GPU fence (present pacing), and the GL thread waits on the apply thread.
    • MOBILEGL_IPC_PRESENT_CREDIT=2 changes nothing (300 fps).
    • Beating MobileGlues on inproc needs a present-path change (stage P territory, dropped by the user), not CPU work.

  • S0b: the fixture minecraft-1.21.5-vanilla-fcl-in-world is landed (4e27342e) and is in the SSIM gate as fcl (32/32 on p15j).

  • Knobs on FCL: adb shell setprop debug.mobilegl.env "MOBILEGL_A=1;MOBILEGL_B=0" (49c6394d); fclab.sh takes a 6th field K=V,K=V.

  • MC's AFK frame limit: inactivityFpsLimit:"afk" (MC 1.21.2+) made later probe windows and profiles spin in System.nanoTime. fcl_scene.sh now sets "minimized" for bench scenes and restores the original options files (/data/local/tmp/p15-opts-121{5,4}.txt). Profiles taken before this are partly AFK-polluted.

  • BSL at gpuhunt (CPU 2380/1689 MHz, GPU 578 MHz, all 100 % GPU busy):

    • MobileGlues 53.4 fps;
    • dev Magma 53.2;
    • p15l Magma 51.8 (3 reps, -3.0 % vs MobileGlues: target met, -2.6 % vs dev to bisect);
    • Espryt dev and p15l 48.3 (-9.6 %): the GPU gap, inherited from dev.

  • Same-session cpuhunt, apply thread:

    build fps apply ms/frame
    MobileGlues 329 CPU 1.55
    Magma inproc p15m 300 1.6
    Espryt inproc 296 1.65-1.8
    • Inproc beats MobileGlues only when the apply thread's CPU is below MobileGlues' (both pay the same queueBuffer wait). About 0.3 ms per frame beyond the apply CPU is still unexplained.
    • 500b63ea: per-store reuse of renamed-away wire buffers (Magma apply -0.13 ms).
    • ONE_TIME_SUBMIT: no effect (A/B'd, knob dropped).
    • Magma's driver work is about 2x dev's: vkResetCommandBuffer 0.09 + vkEndCommandBuffer 0.11 ms/frame.

  • Inproc serialization found (2026-10-08, p15l cpuhunt profiles): every blit reached the client as BlitNamedFramebuffer, a verb with no MGP_VERB_OP_LIST row, so ClientVerbIsBarriered answered barriered and the GL thread quiesced the applier once per frame (1.65 ms/frame parked in WaitForApplyToCatchUp, plus 0.11 from the following glBindTexture). The apply thread then idled 0.24 ms parked plus 0.2 ms spinning in Doorbell::Wait. e00db8e6 replaces the inverse and its barriered fallback with a verb -> record-op table (MG_Pipe/VerbRecordOps.h, one row per verb by static_assert; no knob, user decision).

    • Same-session blab (cpuhunt): Magma inproc 319.6 -> 334.9 fps (+4.8 %), Espryt inproc 324.4 -> 338.1 (+4.2 %).
    • Wait census (MOBILEGL_IPC_WAIT_STATS=1, 7acf3ea8): FCL vanilla inproc waits only on the present credit (1.00/frame). BSL waits 7 times per frame on three kWaitApplied rows plus 22 follow-on quiesces; see WAIT-AUDIT.md. User decision applied in 2fbcc224: fire-and-forget rows async, inproc creates and PBO readbacks no longer wait, and the dual block (MOBILEGL_IPC_ROLE_SPLIT_STATE, now default on) lets a barriered verb cost one wait. BSL census after it still owed (gpuhunt only; FCL's 1.21.4-Fabric profile exited with signal 34 at JVM start on both backends in the last attempt).
    • db915f76: a client parked on the present credit is rung only by the credit (apply-thread futex wakes 0.056 ms/frame before).
    • Frames in flight (0b96a3ef): MOBILEGL_FRAMES_IN_FLIGHT (default 3) drives Magma's frame contexts, Espryt's post-present fence wait and the split present credit max(1, N-2); the Magma name is an alias. Default latency unchanged; the FIF A/B is the user's input for the default.
    • Present credit 2 (cens, cpuhunt, all VALID): Magma 309.0 -> 319.9, Espryt 299.1 -> 319.1 fps vs MobileGlues 321.9 in the same session; apply CPU 1.40-1.43 vs MobileGlues' GL thread 1.57. Credit 2 costs a frame of latency: user decision. The remaining inproc gap is the queueBuffer fence wait (GPU-side), not CPU.
    • BSL at cpuhunt (GPU 903 MHz) reaches GPU 95 C and kgsl thermal_pwrlevel 1 (834 MHz cap): the census run was INVALID twice and the job was stopped. Run BSL only at gpuhunt.
    • Apply-thread frame (Magma inproc): on-CPU 1.75 (0.2 of it spin), queueBuffer fence wait 1.45, parked 0.24 ms.
    • Magma apply on-CPU by verb: draws 0.55 (SetupWireDraw 0.40, of it descriptor binding 0.13), present 0.37 (End CB 0.10, queueBuffer CPU 0.08, submit 0.07, wire-store sweep 0.035), clear 0.19 (the frame's recording begin 0.09 + pass begin 0.05), buffer writes 0.09, blit 0.06 (two image views and a VkFramebuffer created and retired per blit).

  • Device contention, root cause (2026-10-08): the anland app was relaunched by fclab.sh's own end-of-run monkey (launchedFromUid=0); its activity takes the foreground back whenever paused, so FCL launched over it never reaches the world (RenderDoc job: 0 of 4 worlds). c41dfdda: bench_session.sh start force-stops it and stop relaunches it only if it ran before.

  • Open user decision: Espryt's apply thread spends 0.06 ms/frame in LatchIfGuiltyBeforeApply (glGetGraphicsResetStatus is a kgsl ioctl, queried on every wake). Rate-limiting it to 2 ms breaks ServerLoopEglLatchTest.AGuiltyResetEndsTheSessionBeforeItsNextRecord..., the designed promptness guarantee, so it was reverted. Trading that guarantee for 0.06 ms is the user's call.

  • CI: 4a8ecf9a green. 49c6394d: one job failed on a hosted runner's apt-get update timeout (45 min, infrastructure); the failed job is re-run.

  • Next:

    • RenderDoc (rdc GLES layer, remote server stopped): Espryt vs MobileGlues BSL pass structure;
    • S1 (client validate 0.25 ms) and S3 (backend by-handle syncs, descriptor resolve) for the CPU floor and the inproc apply thread.

Status (2026-10-08)

Branch: p15impl (worktree .claude/worktrees/p15, short path W:/p15), pushed to feat/disaggregated.

S0.1 parity audit: written.

S0.2, Magma wire non-draw ports:

  • M1a, clears become part of the draw pass (ClearWireFramebufferInPass; PrepareWireDrawPass split out of SetupWireDraw):
    • A whole-area clear that begins the pass begins it with a LOAD_OP_CLEAR variant of the pass's render pass (RenderPassEntry::clearVariants, compatible with the framebuffer).
    • Any other clear (into the open pass, or scissored) is vkCmdClearAttachments in the pass. A forced pass restart for depth clears (an LRZ hypothesis) was tried and reverted: it cost CPU and fixed nothing.
    • Kill switches: MOBILEGL_MAGMA_INPASS_CLEAR=0; MOBILEGL_MAGMA_INPASS_CLEAR_DEFAULT=1 puts default-framebuffer clears in the pass too (off by default, see the open item).
  • Open item: default-framebuffer clears stay standalone. With them in the pass, the openra retrace on Adreno 750 loses its palette-sampled sprites (SSIM 0.956378, deterministic). What was measured:
    • Both vkCmdClearAttachments and LOAD_OP_CLEAR fail; so does splitting the clear calls.
    • Colour-only or depth-only in the pass, with the other part standalone, passes.
    • Event traces: the first draw flushes the recording (the palette glTexImage2D's upload flush, FlushPendingCommands) right after the clear. Command order otherwise matches the standalone path.
    • Not explained yet. Lavapipe and the InPassClear scenarios on FBOs are clean.
    • Ruled out by reading: a missing ordering edge. Default-framebuffer images get the same pass-begin barrier as FBO images (a full ALL_COMMANDS memory barrier, or their transition), with their layout tracked per swapchain index through the swapchain object.
    • Still open: the in-pass path commits the freshly acquired swapchain image (DefaultFramebufferWriteIndex(true) in PrepareWireDrawPass) at the clear; check whether the standalone path's clear and the in-pass clear address the same index on the trace route.
    • Cost of leaving it: small for FCL (MC renders into its own FBO and blits to the default one).
  • M2, draw-pass cache across frames: one cache, entries pruned when their image epochs move, destroyed after their last submit. Kill switch: MOBILEGL_MAGMA_PASS_CACHE=0.
  • M3, blit descriptor sets: one pool per frame slot.
  • M9, converted vertex streams (wrongly marked "have" in the first audit). The wire arm re-converted the whole remaining stream on every draw: Sodium's multi-draws over one arena cost 49 ms/frame of CPU on BSL (19.5 fps against dev's 64.7).
    • Now one conversion per (store content serial, layout), kept across frames in VkBufferManager (LookupConvertedStream / StoreConvertedStream).
    • Each entry owns a vertex buffer. Bounded at 192 MB (least recently used first); entries idle for 256 frames go. A replaced buffer is released when its frame slot comes round.
    • The content serial is process-wide monotonic and moves on every host write, respecify, GPU-write mark, shader-writable bind and donation.
    • Kill switch: MOBILEGL_MAGMA_VERTEX_CONVERSION_CACHE=0.
  • M4, write renaming. A busy glBufferSubData used to take a staged copy, which ended the render pass with two full barriers (FCL: ~5.6 per frame, all on one 288-byte store). Now:
    • A store of 64 KB or less keeps a host shadow (64 MB budget), from respecify on.
    • A busy write into a shadowed store gives it a fresh VkBuffer filled from the shadow and releases the old one like a glBufferData orphan. No copy is recorded and the pass stays open.
    • GPU-written marks, shader-writable binds, donation and import drop the shadow.
    • ReadWireBuffer serves shadowed stores from the shadow, so no host wait.
    • Kill switch: MOBILEGL_MAGMA_WRITE_RENAME=0.
  • Tests:
    • InPassClearScenario: 4 cases, monolith and split, both backends.
    • ConvertedVertexStreamScenario: 3 cases (reuse, same-frame sub-data, cross-frame sub-data). Red-once: a lookup that ignores the content serial turns both sub-data cases red.
    • WriteRenameScenario: 4 cases (order and carry, one-byte writes, uniform and index buffers, multi-frame). Red-once: a rename that skips the shadow fill turns all 4 red, which also proves the rename engages.
    • Red-once checks: the colour index and the scissor (2 cases red); the depth clear-load bit (depth/stencil case red).
    • Syncval gates green (cache 7/7, run-ahead 14/14), plus the InPassClear cases under syncval.
  • Gates:
    • SSIM 24/24 (openra, rd12, bsl × 4 arms × 2 backends) on p15e.
    • Host unit and integration-gpu green, apart from the known environmental ServerSpawn / FuzzArm2 / PeerLatch / spawn ColdStart failures.
    • CompositorRecovery flakes under -j16 and passes alone 3/3.

S0 milestone (one device session, FCL, interval 0, 2 reps; runs/ms-s0i):

scene build Magma CPU ms/frame Magma fps Espryt CPU ms/frame Espryt fps GPU busy
vanilla 1.21.5 (CPU) fin 3.27 170 2.81 190 12-15 %
p15h (S0 without M4) 2.59 191 - - 15 %
p15i (S0) 2.56 190 2.77 193 13-15 %
dev 1.79 (n=1) 234 2.14 218 14 %
MobileGlues 1.59 256 15 %
BSL (GPU) p15i 7.26 77.2 7.61 70.6 99 %
dev 13.85 66.1 7.17 70.5 85-100 %
MobileGlues 6.25 78.2 98-100 %

(BSL before the converted-stream cache: Magma 19.5 fps at 26 % GPU busy, 49 ms CPU/frame.)

  • Espryt's base lib (p15plan, unchanged) read 2.84 in the same session: the earlier "p15e Espryt regression" was session variance. S0 does not touch Espryt.
  • Target status. Magma BSL is met (within 1.3 % of MobileGlues, GPU-bound). Espryt BSL is GPU-bound at 99 % and 10 % below MobileGlues, same as dev: a GPU-side gap still to explain (the load/store and clear audit of PLAN §0.1). CPU scene: Magma 2.56 vs MobileGlues 1.59, Espryt 2.77.
  • Where Magma's CPU goes now (p15i profile, runs/prof-hi, ms/frame inclusive): VerbChannel::Port 0.85, OnDrawVbo 0.62, SetupWireDraw 0.46, Present 0.32, MGPipeValidateForVerb 0.27, in-pass clears 0.18. The draw path is S1-S3's; S0's non-draw ports are done. Proof that M4 engages: StagedWireRangeCopy 0.067 is gone and RenameBusyWireStore costs 0.048 (a VMA allocation per rename; a recycle pool could take most of it).

Stage P: dropped for the target.

Harness

purpose where
FCL probes and reducers tools/device_bench/disagg/ (README "P15 FCL probes")
FCL vanilla A/B, H2 (pinned, SF frame source, stability warmup, sp=1 profiles after the windows) scratchpad p15/fclab2.sh "<name>:<lib>:<backend>[:sp[:transport[:K=V,...]]] ..." <reps> -> fcl_bench.sh; fclsum.py, residency.py, diffprof.py, prof_prep.sh
FCL milestone (CPU + BSL scenes, fin / new / dev / MobileGlues) scratchpad p15/fcl_milestone.sh, fcl_scene.sh, fclab.sh, fclsum.py
SSIM gate (openra, rd12, bsl × 4 arms × 2 backends) scratchpad p15/ssim_gate.sh; matrix_p14.sh now takes PREP_WLS and a bsl workload
host CI-shaped build (WSL archlinux) ~/mgl-p15-ci31, scratchpad p15/wsl_ci.sh, w_suite.sh, w_syncval.sh, w_sv_one.sh, w_one.sh
trace APK builds scratchpad build_trace.sh W:/p15 .<tag> (rerun once on the IncrementalSplitterRunnable failure)

Host-build trap: editing a header while ninja is compiling leaves objects newer than the header but built from its old text. This happened once and gave a bad_alloc in every scenario. Never edit sources during a build; touch the edited headers if in doubt.

Device facts:

  • Clocks: CPU 2035.2 MHz on policies 2/5/7 and 1574.4 MHz on policy0, GPU 680 MHz (new default since 2026-10-08, pending the soak). Pinned per session by bench_session.sh, which every devjob.sh job runs.
  • Frequency daemons are stopped only inside a bench session: thermal-engine, perf2-hal-1-0, vendor.perfservice, performance and hyperschedule_hal_service. Their prior state is in /data/local/tmp/p15-bench-session while a session is open, and they are restarted and verified on exit. If that file exists with no job running, a session was left open: run bench_session.sh stop.
  • The perf stack's game-mode caps in /sys/kernel/msm_performance/parameters/cpu_max_freq survive its services and silently override the pin. The session releases them.
  • FCL's original lib md5 is 00c09f0a….
  • MC 1.21.5 options md5 is 93b3f708…; it is backed up at /data/local/tmp/p15-options.txt.
  • Iris properties are backed up at /data/local/tmp/p15-iris.properties.
  • fcl_scene.sh restore restores Iris; fcl_p14.sh restore restores the lib and config.json.
  • The anland desktop is stopped during runs and restarted afterwards.

pwab: device A/B of the present-wait levers (2026-10-10)

Result table, engagement evidence and the failed lever-B expectations are in SCOREBOARD.md (section pwab). Summary: before a759b4b7, after pwgate cdd2160f + pmflush eec5e6e8 (+ MOBILEGL_MAGMA_EXTRA_SWAPCHAIN_IMAGES=2 on Magma). fps after/before: Magma inproc 1.32 (1.495 of MobileGlues), Magma mono 1.34 (1.176), Espryt inproc 1.09 (1.102), Espryt mono 1.12 on reps 1+3 (0.896; before rep 2 NO WORLD, not re-run).

  • Libs: p15/libs/{pwbase,pwA,pwF,pwAF}, symbols in p15/syms/. Worktrees .claude/worktrees/{pwbase,pwF,pwAF} hold the builds (pwF/pwAF are detached HEADs with eec5e6e8 cherry-picked, not pushed). The 3rdparty copy also needs include/ska (a gitlink) copied into a fresh worktree.
  • Harness: p15/pw/dev/ (chain.sh, session.sh, fcl_bench.sh with the post-Perfetto atrace stage made opt-in, devjob.sh), run data in p15/runs/pwab, Perfetto in p15/runs/pwlat.
  • Not done: the per-arm timeline analysis (cycle.py/pairs.py/gexec.py) and the separate lever A / F / extra=1 arms, both cut by the user. Next: derive the timelines from runs/pwlat and find why the Magma gain exceeds the lever-B model.
  • Harness note: a launch can fail with NO WORLD after four 240 s attempts (b-DirectGLES-r2); fclab2.sh only retries INVALID runs, not NO WORLD.
Reference in New Issue View Git Blame Copy Permalink