mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-17 23:13:22 +09:00
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.
113 lines
5.9 KiB
Markdown
113 lines
5.9 KiB
Markdown
# 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.
|