Files
MobileGL/docs/Disaggregated/notes/p5e/PERF-BASELINE-7c6f6886.md
T
swung0x48 aba329cc53 [Docs] (Disaggregated): P6's plan and contract draft; the working notes move from a local directory into the repository
Two things land together: the plan and contract draft P6 needs before it starts, and the
working notes that until now existed on exactly one machine.

1. P6's plan and contract draft (neither started; not one line of code)

     docs/Disaggregated/P6-SPAWN-PLAN.md      the package plan
     docs/Disaggregated/P6-CONTRACT-DRAFT.md  the contract draft (moves to
                                              MG_Remote/CONTRACT-P6.md when c6 lands)

   The three findings that mattered, all written into the documents:

   a. P6 is SMALLER than its roadmap cell suggests. The transport primitives are already in
      the tree and already tested: SocketDoorbell including hangup detection and the two
      lost-wakeup fences (Doorbell.cpp:211-360, four cases in FdPassingTest), SCM_RIGHTS fd
      passing, ShmSegment::Adopt, and the SurfaceOp / WindowKind schema already defined in
      protocol.fbs. inproc uses a real second shm mapping rather than an alias, and
      SessionRings.h:22-28 says that was done so today is not the first time it runs. P6 is
      assembly plus a control plane plus a process, not "write a socket transport".

   b. The evidence for "P6 is only a transport swap" has EXPIRED. It was bought by P5c, whose
      audit found 59 direct memory accesses in a tree that already looked clean. P5e changed
      the tree again. So the first package, a6, is a read-only audit that writes no code, and
      every contract row that depends on it is marked PENDING a6 rather than decided in
      advance.

   c. P6 does not get a game running on the phone. ANativeWindow* is meaningless in the child,
      and protocol.fbs:186-196's own comment says Android transfers the window out of band -
      that band is P12. P6 lands pbuffer / surfaceless / offscreen, which is what HeadlessGL,
      the split-equivalent lane and trace replay need, and which is exactly what P6's own exit
      gate measures. A real window reaching the server is a named refusal. This gets its own
      section because "P6 is done" would otherwise read as "the game runs now".

   The contract adds rule G: a role may not name a process-local handle. It extends P5c's
   rule E (a role may not name the other role's memory) from memory to identity - EGLDisplay /
   EGLSurface / EGLContext / ANativeWindow* / fd number / pid / mapped address either cross as
   a token this contract defines or they do not cross, and a descriptor crosses only through
   SCM_RIGHTS, where the kernel renumbers it.

   What P5e left for P6 gets its own section. The latch semantics are already designed
   (ARCHITECTURE.md:504) and are copied unchanged. What is new is that after run-ahead the
   client no longer waits while the peer process can DIE: the client holds records that were
   published and will never be applied, and Android's freezer suspends the child without
   closing anything. So slow and dead must be distinguishable WITHOUT a timeout threshold.
   That is P6's only new design; everything else is carriage. It shares a predicate with E1's
   outstanding re-specification (ID-122), and the two should be designed together.

   Two gates carried over from P5e's lessons: G2 requires integration-spawn's test-name set to
   match integration-split's name for name, because a differing set means the lane is quietly
   running less; and the arm-proof gate requires every entry to record the child pid and
   transport=spawn in its OWN private log - ID-124 established that this kind of false green
   really happens, and a spawn lane that actually ran monolith would pass every other gate.
   S2's shape must be settled before it is written, and the document says why: E1 is the
   cautionary case.

2. The working notes move into the repository (docs/Disaggregated/notes/, 415 .md files)

   ROADMAP / CURRENT_STAGE_PROGRESS / MEASUREMENTS cite ruling numbers, audit line numbers and
   the provenance of gate figures from ~/w7/notes/, a directory that exists on one machine and
   is under no version control. A record cited hundreds of times that lives only locally is not
   a record, so it moves in whole, with its directory structure intact.

   Only .md moves. Scripts, run logs, census and gate result JSON, patches, APKs and nm dumps
   stay where they are: they are evidence DATA rather than documents - large, regenerated per
   run, and mostly carrying absolute paths and device serials that mean something only on the
   machine that produced them. The mapping and this split are written in
   docs/Disaggregated/notes/README.md.

   Two exceptions are recorded there too: P6's BRIEF has been promoted to a first-class
   document and keeps no copy under notes/, so the two cannot drift apart; and recovered/ holds
   material salvaged from failed workflow runs, which may duplicate the like-named phase
   directories and is kept because a few of those were the only complete version at the time.

   CI's citation lint takes docs/Disaggregated/*.md only (non-recursive), and notes/ is
   deliberately outside it: those notes' file:line citations were written against their own
   code heads, and resolving them against today's HEAD would fail wholesale - which is not an
   error, it is their correct state as a historical record. To check one, use the revision it
   declares (--rev).

3. Inconsistencies fixed in passing

   - README.md's status line still said P5e was in progress while the stage table already said
     closed.
   - CURRENT_STAGE_PROGRESS's next-step item 1 still listed the exit gate as pending, though
     (a) and (b) were run in the previous commit; rewritten to closed plus the one item that
     actually remains (E1).
   - ROADMAP's P6 row still had the pre-phase plan in three of its cells; it now carries the
     package order, the scope boundary and the two new gates.

Checked with check_doc_citations.py: 125 citations across docs/Disaggregated/*.md, 0 problems.
2026-09-18 23:31:39 -04:00

5.9 KiB
Raw Blame History

inproc vs monolith at 7c6f6886 — measured, and why

Redmi 2f7cbe2e, FCL fordebug + Minecraft 26.3-rc-3, world test, VD12, DirectGLES, ~848 draws per frame. GPU pinned (min_pwrlevel = max_pwrlevel = 0, re-asserted per arm because the pin is lost across app restarts), fan on, 30 s window taken 20 s after the world settles. Arms interleaved so thermal drift shows in both. Harness: ~/w7/notes/tools/p5d_bench_fcl4.sh (P5d's, unchanged).

1 The answer: yes, inproc is still slower

arm fps (window) fps p50 client GL thread ms/frame apply thread ms/frame
mono1 254.9 267.9 3.898 —
inproc1 161.7 166.4 6.098 5.305
mono2 201.3 195.1 4.781 —
inproc2 141.8 143.5 6.958 5.653
mono3 192.4 254.2 4.694 —

Thermal drift is real (monolith's own GL thread moved 3.898 → 4.781 across the session), so read the PAIRED ratios, not the absolute numbers:

  • fps: inproc is 0.62 – 0.74× monolith.
  • client thread CPU per frame: inproc's client is 1.46 – 1.56× monolith's single thread.
  • total CPU per frame: inproc 11.4 – 12.6 ms across two threads, monolith 3.9 – 4.8 ms on one. The split arm spends roughly 2.6× the total CPU.

Monolith is cleanly single-thread CPU-bound: its GL thread reports 993.7 ms of CPU per second of wall clock, i.e. 99.4% of one core. inproc is bound by its client thread, which is also ~99%.

So parity means max(client, apply) <= monolith's single-thread ms/frame — about 3.9 – 4.7 ms. It does NOT require the split arm to spend less total CPU than monolith; it requires neither thread to exceed what monolith's one thread spends. That is a question of balance and overhead.

2 Where the extra CPU goes: a rendezvous per draw

The renderer's own stats line counts entries into Doorbell::Wait as srv / cli and actual futex parks as srvpark / clipark (MG_Util/Metrics/PipeStats.cpp:537). A 60 s inproc sample (8,280 frames):

counter total per frame
cli (client enters the wait) 7,588,093 916
clipark (client actually parks) 13,025 1.6
srv 15,836,497 1,913
srvpark 37,456 4.5
rsp (residual pulls) 102,408 per 120-frame window 853, i.e. one per draw

Against ~848 draws per frame, the client blocks about once per draw and 99.8% of those blocks resolve by spinning rather than parking. The monolith arm reports rsp=0 and wait[srv=0 srvpark=0 cli=0 clipark=0] — it has no rendezvous at all.

rsp equalling the draw count is the same fact the strict lane reports as GetProgramForDraw@DrawArrays: one barrier-pulled field read per draw. A record that reads client memory cannot be unbarriered, so the draw path stays in lockstep and the client waits.

3 The spin is the cheap version of the rendezvous, not the problem

Control arm MOBILEGL_IPC_SPIN_US=0 (park immediately instead of spinning up to 50 µs):

arm fps p50 client ms/frame apply ms/frame clipark / cli
inproc (default, 50 µs) 143.5 – 166.4 6.098 – 6.958 5.305 – 5.653 0.2%
inproc SPIN_US=0 20.9 20.167 14.681 99.6%

Making every rendezvous a futex park costs about 14 ms/frame more on the client and collapses the frame rate by 7×. So the 50 µs spin is not waste to be tuned away — it is what keeps the current design viable. The cost is the rendezvous itself, and the fix is to stop having one per draw, not to make each one cheaper. Tuning SPIN_US is a dead end in both directions.

4 The barrier-off control cannot answer the performance question

MOBILEGL_IPC_VERB_BARRIER=0 aborts a few seconds into the run:

F/MobileGL: MGPipe: Fatal{UnmigratedPipeInput, "IsCapabilityEnabled@ClientWaitSync"}

which is exactly what Config.h documents it to do ("EXPECTED to be red, because 31 of the 63 PipeInputs fields are still pulled from a live GLContext by the client's residual fill"). It is a correctness control and gives no usable CPU number. The ceiling that run-ahead buys therefore cannot be measured before run-ahead lands; §5 is an estimate, and it is labelled as one.

5 What run-ahead should buy, and what it will not

Let F be the client's frontend work, B the backend GL work, E the record encode, D the decode plus resolve, and S the rendezvous cost on each side. Then

  • monolith ≈ F + B = 3.9 – 4.8 ms/frame (measured)
  • inproc client = F + E + S_c = 6.1 – 7.0 ms/frame (measured)
  • inproc apply = D + B + S_a = 5.3 – 5.7 ms/frame (measured)

so E + D + S_c + S_a ≈ 7 ms/frame. Run-ahead removes S_c and S_a for unbarriered records and nothing else: the encode and decode stay. The acceptance signal is therefore not fps first but the counters:

  • rsp must go to 0 on unbarriered records (BRIEF §3.3 already pins this),
  • cli must fall from ~916 per frame to the handful of records that stay barriered by ruling ID-84 (readback, XFB, CopyTex, set_storage_block_binding), which in this workload is a few per frame, not hundreds.

If after that the arm is still short of parity, the remaining gap is E and D and it is an encode/decode problem, to be attributed by symbolized call graph and not by self-percent — the trap P5d recorded after mis-diagnosing an idle poll as backend lock contention.

6 Measurement discipline for the next round

  • Interleave arms in one session; report the paired ratio. A single-arm fps number drifted 27% in this very session.
  • Per-thread CPU ms/frame is the primary metric, fps the secondary — fps alone confounds vsync capping (this panel is 120 Hz and a capped monolith run reads 115) and thermal state.
  • Re-assert the GPU pin per arm; it is lost across app restarts.
  • Confirm the library under test by symbol probe on the APK's lib/arm64-v8a/libMobileGL.so, never by the in-game GIT@ stamp, which is stale under incremental builds.