[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.
This commit is contained in:
2026-09-18 23:31:39 -04:00
parent edd0fef5cd
commit aba329cc53
420 changed files with 131235 additions and 6 deletions
@@ -0,0 +1,42 @@
# Brief: p5c-audit — where the `inproc` split still reads the other role's memory
You are auditing the MobileGL disaggregation branch (`feat/disaggregated`, head `a79a0af6`), working tree = the current directory (`C:\Users\geekerwan\AndroidStudioProjects\FoldCraftLauncher\MobileGL-disagg`). **This is a READ-ONLY audit**: do not edit any repository file, do not run builds or tests, do not touch git (no commit/checkout/stash), do not touch any adb device, do not fetch git LFS. You may write scratch files only under `C:/Users/GEEKER~1/AppData/Local/Temp/claude/C--Users-geekerwan-AndroidStudioProjects-FoldCraftLauncher-MobileGL-disagg/0614b2e9-9ce2-49e4-a44c-6d023a133184/scratchpad/`. If you need Linux tooling, run it as `wsl.exe -d Arch -- bash -lc "<cmd>"`; the same tree is checked out at `~/w7/pipe` inside that distro (also at `a79a0af6`), and the notes/evidence directories are `~/w7/notes/` — read-only for you as well.
## The question
MGPipe splits the GL frontend (client role, the application's GL thread) from the backend (server role, the `mgl-srv-apply` thread). Under `MOBILEGL_TRANSPORT=inproc` (build flavour `-DMOBILEGL_PIPE_PUSH=ON -DMOBILEGL_BUILD_DISAGGREGATED=ON -DMOBILEGL_BUILD_DISAGGREGATED_INPROC=ON`) the two roles are two threads of one process. The intended design is that **everything crosses as wire**: records in the `SEG_CMD` ring, bulk bytes in `SEG_STAGE` blobs, answers in `SEG_REPLY` slots, the caps snapshot, and the one-slot control mailbox for rare EGL operations. The next phase (P6, `spawn`) puts the server in another process, where any read of the other role's memory that is not one of those carriers simply cannot work.
**Find every place where, today, one role reads (or writes) the other role's memory directly instead of going through a carrier.** Both directions, and the shared process globals that only work because the address space is shared. The verb barrier (`ClientSession::EmitAndWait` waits for `appliedSeq == emitSeq` on every class-B verb, `MOBILEGL_IPC_VERB_BARRIER=1`) is what makes these reads "safe" today — so anything that is only correct because of the barrier belongs in your inventory too.
## Where to start (read these first, they already name most of the debt)
- `MobileGL/MG_Remote/CONTRACT-P5.md` §3 (field ownership: RECORD-SUPPLIED / APPLIER-DERIVED / BARRIER-PULLED / FATAL; the sticky forwards; "two sets with no field ids") and §4 (role and thread ownership of every process global).
- `MobileGL/MG_Remote/CONTRACT-P5B.md` §3–§4 and §6.
- `docs/Disaggregated/ARCHITECTURE.md` §17 (P5/P5b landed shape) and `docs/Disaggregated/CURRENT_STAGE_PROGRESS.md` §5 (open items: the three "inproc dependencies" P5b left — named blit's scoped client-shadow binding, the mip descriptor's barrier-held registry lookup, FBO death's inproc mailbox).
- Generated tables: `MobileGL/MG_Pipe/generated/PipeFieldOwnership.inc` (36 rows are `kBarrierPulled`), `PipeFilled.inc`, `MobileGL/MG_Pipe/FieldOwnership.def`, `Coverage.def`, `FillPoints.def`.
Then the code:
- Client role: `MobileGL/MG_Remote/Client/*` (`EmitTables.cpp` — the A/B/C slot partition and the pre-verb hooks; `ClientSession.cpp`; `BackendObject_Remote.cpp`; `CapsMirror.cpp`; `PersistentMapTracker.cpp`; `GpuWritePending.cpp`), `MobileGL/MG_Impl/Pipe/PipeFill.cpp` (the residual fill of `gPipeInputs`), `MobileGL/MG_Pipe/PipeRoute.{h,cpp}`.
- Server role: `MobileGL/MG_Remote/Server/*` (`PipeApplier.cpp` incl. `ServerVerbSink`, `ServerLoop.cpp`, `ServerSession.cpp`, `StagedShadow.h`), `MobileGL/MG_Remote/Wire/PipeWireCodec.cpp` (`WireVerbSink`, the segment resolver, `MGHostSpan` decoding), `MobileGL/MG_Pipe/PipeApply.cpp`, `MobileGL/MG_Backend/MGPipe/PipeInputs.{h,cpp}`.
- Backends' handle arms: `MobileGL/MG_Backend/DirectGLES/{Managers.cpp,DirectGLES.cpp,Utils.cpp,BackendObject_DirectGLES.cpp}` and `MobileGL/MG_Backend/DirectVulkan/*` — look for `MGB_CTX->`, `MappedData(`, `GetStorage(`, `MipmapStorage`, `SharedPtr<`, `ProgramObject`, `TextureObject`, `BufferObject`, `pActiveBackendObject`, `pDefaultFramebufferInfo`, `MGPipeUnmigratedEmulation`, `liveHostBase`, `RequireStagedCoverageForPendingRanges`, `Fatal{StageSnapshotTooNarrow`, `Fatal{UncarriedInitialBytes`, `Fatal{InitialBytesNotCarried`, `Fatal{UnmigratedEmulation`, registry lookups keyed by frontend identity.
- Callbacks: `MobileGL/MG_Pipe/MGPipeCallbacks.h` and wherever the split build installs them — under `inproc`, does the apply thread call `OnGlError` / `OnGpuWritten` / `OnBufferWriteback` / `OnTextureWriteback` / `OnMipLevelsGenerated` / `OnSurfaceChanged` / `OnCapsInvalidated` / `OnLog` / `OnXfbScatterReady` / `OnTexturePullRequest` straight into client-owned `MG_State` objects? (`SEG_EVENT` exists in `Transport/EventRing.h`; is it used?)
- Program artifacts: `MobileGL/MG_Pipe/ProgramArtifactsCodec.{h,cpp}` — under split, does `CreateShaderState` carry the archive as a blob, or does the server read the frontend `ProgramObject`'s `LinkArtifacts` directly? (`Fatal{ArtefactsMissing}` / `Fatal{ArchiveEmpty}` exist somewhere.)
- Caps: `MobileGL/MG_Remote/CapsCodec.cpp` and `Client/CapsMirror.cpp` — the format-capability table and the renderer string ("the two `GetCaps` blobrefs") — carried in the snapshot, or read from the shared `pActiveBackendObject`? Also `BackendObject_DirectGLES.cpp` / `Utils.cpp` format-capability lookups that CONTRACT-P5 §4 says are backend-internal reads of `pActiveBackendObject`.
- Textures: how `ResourceSubData` bytes reach Espryt under split (blob in `SEG_STAGE` → `StagedShadowStore`? or a pointer into the client's `MipmapStorage`?); the mip-generation path (`GenerateMipmap`, "GLES mip storage descriptor"), `CopyImageSubData`'s shadow mirror, `GetTexImage`, `CopyTexImage2D`/`CopyTexSubImage2D`.
- Buffers: `Ops_H_*` in `Managers.cpp`, `EnsureBufferResourceForHandle` (its "frontend object held" arm), `HasDefinedContent()`, persistent maps (`PersistentMapTracker`, `MOBILEGL_IPC_ADOPT_TIER=2` emulated tier), `SyncGpuWrites` / `MarkGpuWritten`, XFB capture / scatter.
- Process globals under inproc: everything in CONTRACT-P5 §4's table plus anything it missed (e.g. `MGPipeSlots()` and the other `MG_Impl/Pipe` singletons — does any server-side code read them? `g_syncedRenderStateParameters`? Espryt twins that still hold a frontend pointer? `g_rawDepthFetchSamplerState`?).
- Client reads of server memory: any `MG_Impl` / `MG_Remote/Client` read of `g_applier` / `MGPipeApplierState` / `MGPipeGetResourceOps()` / backend twins / `pActiveBackendObject` (beyond the caps mirror) under split; `MG_IntegrationTest/Harness/Pipe*Peek` are test-only — list them separately.
Use grep aggressively (ripgrep is available on Windows as `rg`, or `grep -rn`); then open each hit and decide. Do not trust the contracts' line numbers — they are from older heads; re-resolve every site on `a79a0af6` and cite `file:line` exactly (the repo has `scripts/check_doc_citations.py` which checks `path:line` citations against HEAD; your citations must resolve).
## What to write: `p5c-audit-v1.md` in the scratchpad directory named above (write it FIRST, before your final message)
1. **Inventory table**, one row per site or per tightly-coupled family (aim for completeness over brevity; 30–60 rows is plausible). Columns: `#` · direction (`S→C read` = server reads client memory, `C→S read`, `S→C write`, `C→S write`, `shared global`) · what memory (object/field) · reader/writer site (`file:line`, function) · owner of that memory · when it happens (verb class / call / frequency: per draw, per upload, once) · why it works today (barrier / same address space / single writer) · what breaks under `spawn` · current guard (`Fatal{...}` name, `MOBILEGL_IPC_STRICT_ERRORS`, `MOBILEGL_IPC_AUDIT`, `rsp` counter, none) · the natural carrier (a new/extended record field, a `SEG_STAGE` blob, a reply slot, a `SEG_EVENT` event, the caps snapshot, the control mailbox, or "server-derived — no carrier needed") · suggested phase (P5c now / P6 / P7 / P8 / P9 / P10) — with one line of reasoning.
2. **Summary counts** by direction and by carrier, and the top 10 by frequency (per-draw first).
3. **Already wire-clean**: a short list of the paths you checked that DO go through a carrier (buffers via `StagedShadowStore`, ReadPixels reply, DrawVbo user indices, fence handles, …), so the plan is bounded by evidence, not assumption.
4. **Surprises / disagreements** with what the contracts and `ARCHITECTURE.md` §17 claim (e.g. a field the tables call RECORD-SUPPLIED that the backend still pulls; a callback delivered directly; a `gMGPipeSegmentResolver` or `MGHostSpan::Ptr` short-cut).
5. **Existing numbers** you found without running anything: any `rsp=` values in `~/w7/notes/p5b/p5b-results/*.md`, `~/w7/notes/p5/p5-results/*.md` or `~/w7/p5b-final-census-348d22a4/` logs (cite the file), so the plan can size the debt.
Keep prose minimal; tables over paragraphs. Be precise: if you are not sure a site is reached under `inproc` (e.g. it is inside `#if !MOBILEGL_BUILD_DISAGGREGATED` or behind a class-C refusal), say so in the row rather than dropping it. Cite the git head you read (`git rev-parse HEAD`).
When the report file is written, reply with at most 150 words: the row count, the top three findings, and anything you could not resolve.
@@ -0,0 +1,204 @@
# p5c-audit-v1 — where the `inproc` split still reads the other role's memory
Read-only static audit of `feat/disaggregated` @ `a79a0af69de8c6c53ef985dd23be7eab8cd17641`
(`git rev-parse HEAD`, 2026-09-17). No builds, no tests, no git mutation, no adb. Every
`file:line` below was re-resolved on this head (the contracts' line numbers are from older
heads and drifted; §5 lists the drift found while auditing).
Direction legend: **S→C read** = server/apply-thread reads client memory · **S→C write** ·
**C→S read** · **C→S write** · **shared** = process global both roles touch.
Frequency shorthand: *draw* = per draw/dispatch, *upload* = per upload/respecify, *verb* =
per emitted record, *rare* = per EGL call / make-current / bring-up, *once*.
Phases: P5c = worth fixing now, inproc, before P6 · P6 = spawn transport must replace it ·
P7/P8/P9/P10 = the phase the field tables / ROADMAP already assign.
---
## 1. Inventory
### 1a. Textures and texture sync — the largest un-instrumented family
| # | dir | what memory | site (function) | owner | when | why it works today | breaks under spawn | guard | natural carrier | phase |
|---|---|---|---|---|---|---|---|---|---|---|
| 1 | S→C read | client `MipmapStorage` texel bytes | `MG_Backend/DirectGLES/Managers.cpp:7315` (`BackendTextureObject::SyncMipmapsToBackend`), also `:6940`, `:7129`, `:7198` — `textureMipmapObject->MapMipmapData(...)` | client `TextureObjectMipmap` | per level needing upload, per validate/draw | verb barrier parks GL thread; same address space | pointer into other process; staged SEG_STAGE bytes exist but are dropped | **none** — not in `FieldOwnership.def`, invisible to `rsp`/strict | the already-staged `resource_subdata` SEG_STAGE run, adopted into a server-owned level shadow (mirror of buffer `StagedShadowStore`) | **P5c now** — the bytes already cross; `ApplyTextureUpload` just has to keep them. Biggest single finding |
| 2 | S→C read | frontend texture-object shape/state (`GetMipmapTexelSize`, `GetTarget`, `GetFormat`, `GetMipmapByteSize`, `GetUploadTargets`) | `Managers.cpp:7314`, `:7332`, `:6878-6880` (same fn); `DirectGLES.cpp:8528-8529`, `:8502-8507` (mip gen) | client `ITextureObject` | per upload / per mip gen | barrier | method calls on a dead pointer | none (only the `MGB_STORAGE_*` macros are descriptor-routed, `Managers.cpp:6643-6661`) | applier `MGPipeResourceRecord::Desc` (already server-side) | P5c — same fix as #1: the descriptor + staged bytes answer all of these |
| 3 | S→C read | client dirty-region set | `Managers.cpp:7360`, `:7371` (`GetStorageDirtyRegion`, legacy arm when no `pendingUpload`) | client | per level upload | barrier | dead pointer | none | `PendingUpload::UnionBox`/regions already on the wire (`PipeApply.cpp:824-849`) | P5c — falls out of #1 |
| 4 | S→C read | client slot allocator + frontend `GetLifetimeId()` (mip-descriptor registry lookup, **named inproc dependency #2**) | `DirectGLES.cpp:8087` (`EnsureGenerateMipmapStorageAllocated` re-derived arm) → `SlotTables.h:392-400` `HandleOf` → `MGPipeSlots().FindByLifetimeId`; also `Managers.cpp:5627`, `DirectGLES.cpp:8185`, `:8564`, `:8659`, `:6706` | client `MGPipeSlots()` | per `GenerateMipmap` / CopyTex / re-mint | barrier; Find-not-mint so no allocator mutation | client allocator does not exist server-side | none (`MEASUREMENTS.md:378` calls it barrier debt) | `MGPMipPlan::Res` / `MGPCopyFromFramebuffer::Dst` handles already on the records → `GetOrCreate(MGPipeHandle)` (`SlotTables.h:278`) | **P5c now** — handle is already on the record; the lookup is redundant even inproc |
| 5 | S→C write | client level shadows re-dirtied so server can re-read texels it never held | `Managers.cpp:5638-5645` (`RequireImageBindableStorage`, `MarkStorageDirty(...,true)`) then `Fatal` at `:5650` | client `MipmapStorage` | per texture re-mint (`texture-remint-pull`) | barrier | dead pointer, then the Fatal anyway | `Fatal{UnmigratedEmulation,"texture-remint-pull"}` (`PipeApply.cpp:2947`) — **reached**: iris-photon/derivative/create-indirect first blocker | server-owned level shadow (#1) removes the need to re-pull | P8 per ROADMAP; unblocked by #1 |
| 6 | S→C read | every live frontend FBO's attachment list | `DirectGLES.cpp:8177-8256` (`ScopedDetachedTextureFramebufferAttachments`: `ForEachLive` → `stateFBO->GetAllAttachmentObjects()` `:8207-8243`) | client `FramebufferObject`s | per `GenerateMipmap`/`Blit`/`CopyTexImage2D/SubImage2D` | barrier | walk over another process's objects | none | server-side FBO twin attachment table (P3b/P4b) | P3b/P4b — keyed on the twin tables, not a wire question |
| 7 | S→C read | client texture-unit array walk + `GetBoundObject()` | `DirectGLES.cpp:2204-2215` (`SyncNeccessaryTextures`); keys from `CaptureDrawTextureSyncKeys` `:2021-2040` | client `GLContext` units | per draw on memo miss | barrier | dead pointer | `rsp`-counted only for the `MGB_CTX` accessor half (`GetMaxTouchedTextureUnit` etc.) | server-side binding table from `set_sampler_views`/`set_texture_bindings` (P3b/P4b) | P3b/P4b per `FieldOwnership.def` |
| 8 | shared | raw pointers into client slot arrays held across calls | `DirectGLES.cpp:1958-1987` (`g_unitTextureSyncList`/`g_fboTextureSyncList`/`g_readFboTextureSyncList`: `const SharedPtr<ITextureObject>* slot`) | client arrays, server-held | persistent, read per draw (`:2119-2128`, `:2183-2193`, `:2270-2279`) | barrier + `PairingsIntact` memo keys | stored cross-process pointers | memo keys only | lifetime-id keyed entries (the handle-arm shape already used by `UnitBindingsSnapshot`) | P3b/P4b (ROADMAP.md:30 names the re-keying) |
| 9 | S→C read | client read/draw FBO binding slots during named blit (**named inproc dependency #1**) | client: `MG_Remote/Client/EmitTables.cpp:741-762` (`ScopedBlitBindings`), emit `:764-786`; server: `DirectGLES.cpp:7782-7785` (`BlitFramebuffer` → `GetFramebufferBindingSlot(...).GetBoundObject()`) via sink `PipeApplier.cpp:228-244` | client `GLContext` binding slots | per `BlitNamedFramebuffer` | client rebinds its own shadow, barrier holds it, RAII restores | server reads a binding that was never told to it | `rsp` (`GetFramebufferBindingSlot`, BARRIER_PULLED); strict knob | `MGPBlit.ReadFbo/DrawFbo` handles already on the record → server handle-keyed FBO resolution | **P6 must** (docs say so); P5c can already switch the sink to the handles since they cross today |
| 10 | S→C read | client bound texture via binding slot (CopyTex paths) | `DirectGLES.cpp:8561-8563`, `:8656-8658` (`CopyTexImage2D`/`CopyTexSubImage2D` → `GetTextureUnitObject(...).GetBindingSlot(...).GetBoundObject()`) | client unit array | per CopyTex call | barrier | dead pointer | `rsp` (BARRIER_PULLED `GetTextureUnitObject`) | `MGPCopyFromFramebuffer::Dst` handle on the record | P5c — same shape as #9, handle already crosses |
| 11 | — | CopyTex-copied texels land only in the ES driver; client shadow left allocated-but-empty | `DirectGLES.cpp:8590`, `:8621`, `:8681`; frontend `GL_Texture.cpp:4542` (`TexImage2D_State(..., nullptr)`) | — | per CopyTex | — | wrong readback data later | bounded by `GetTexImage`/`texture-remint-pull` Fatals (22 of the 27 inproc wrong answers are this class, CURRENT_STAGE_PROGRESS §5) | server→client texture writeback (P9) | P9 |
| 12 | — | `copy-image-shadow-mirror` skipped under split; destination client shadow goes stale | `DirectGLES.cpp:9042` (early return) — `:9050` Fatal is unreachable under transport; body `:9053-9099` is monolith-only | — | per CopyImageSubData with CPU shadows | — | — | by design (CONTRACT-P5B §6.8), bounded by two Fatals | client-side mirror (ROADMAP P8) | P8 |
| 13 | S→C read | `get-tex-image-shadow` body reads client shadow | `DirectGLES.cpp:10676`, `:10684` | client | **not reached under split** — client refuses first: `EmitTables.cpp:1581-1582`, `:1614-1615` `Fatal{UnmigratedVerb,"GetTexImage"}` | — | — | named refusal | `ResourceReadback`/readback carrier | P9 |
| 14 | S→C write | Magma mip-gen writes client texture level storage directly | `DirectVulkan/Renderer/VulkanRenderer.cpp:1562-1590`, called `:11317` | client level shadows | per `glGenerateMipmap` on Magma server | barrier | dead pointer | **none** (DirectGLES twin is the re-derived #4 arm; Magma has no equivalent) | `OnMipLevelsGenerated` (declared, never installed) or server-derived levels from `Desc.Levels` | P5c — Magma half of the GLES fix that already landed |
| 15 | S→C read | Magma texture-object lookups via sticky forward / registry | `DirectVulkan/Renderer/VkTextureManager.cpp:810`, `UniformManager.cpp:1190`, `:2014`, `VulkanRenderer.cpp:11527`; `DirectVulkan.cpp:271`, `:274` | client objects | per draw/dispatch on Magma | barrier | dead pointer | `rsp` sticky-forward counting | server-side texture handle table | P7 per `FieldOwnership.def` |
| 16 | — | `OnTexturePullRequest` declared, never installed/called; `ResourceSubDataComplete` terminator unimplemented | `MG_Pipe/MGPipeCallbacks.h:34-38`; install sites only cover 2 of 10 callbacks (`ResourceTracker.h:606-613`); thunk `generated/PipeThunks.inc:216` | — | never | — | the pull protocol does not exist | none | itself — it is the designed carrier | P8/P9 (ROADMAP.md:33,63) |
| 17 | S→C write | `Fatal{UnmigratedEmulation,"generate-mipmap-cpu-fallback"}` body would filter/re-dirty client level shadows | `DirectGLES.cpp:8734` (Fatal), body `:8736-8789` | client | per RGB16F/RGB32F mip gen — **reached** (open item, CURRENT_STAGE_PROGRESS:59) | — | — | named Fatal | needs `OnTextureWriteback` (P8/P9) | P8/P9 |
### 1b. Buffers, persistent maps, XFB
| # | dir | what memory | site (function) | owner | when | why it works today | breaks under spawn | guard | natural carrier | phase |
|---|---|---|---|---|---|---|---|---|---|---|
| 18 | S→C read | frontend `BufferObject::HasDefinedContent()` | `Managers.cpp:3147-3148` (`EnsureBufferResourceForHandle`) | client `BufferObject` | **every draw** that ensures a buffer | barrier | dead pointer | **none** — declared debt at `:3141-3146` | live-content bit beside `MGPResourceDesc` ("client publishes a live content flag") | **P5c now** — cheapest per-draw kill on the list |
| 19 | S→C read | frontend `GetLifetimeId()` per ensure | `Managers.cpp:2705-2716` (`HandleOfBuffer`) → `SlotTables.h:392-397` | client object | per ensure / VAO memo rebuild / SSBO mark | barrier; memoised | dead pointer + client allocator | none | handles on the records | P3b/P4b |
| 20 | shared | raw `BufferObject*` held in server per-VAO memo | `Managers.h:1185` (`ResolvedDrawBuffers::Entry::frontend`), written `DirectGLES.cpp:716` | client object, server-held | stored once per VAO config; read on memo hit | client `SharedPtr` pins it | stored cross-process pointer | only reader under split is monolith-gated (`IsBufferDrawCleanByHandle` → `IsMapped()`, `Managers.cpp:2914-2916`) | handle-keyed memo entry | P3b/P4b |
| 21 | shared | `SharedPtr<BufferObject>` held by server for a whole XFB span | `DirectGLES.cpp:950` (`XfbCaptureTarget::buffer`), pushed `:1260`, read `:1060`,`:1077`,`:1172`,`:1185` | client object, server-held | per XFB span | GL forbids rebinding mid-span; barrier | strong ref into another process | none | server buffer twin handle | P9 (XFB scatter) |
| 22 | S→C write | client buffer shadow written at XFB end | `DirectGLES.cpp:1077` (`ReadbackCapturedRanges` → `WritebackFromBackend`), epoch bump `:1081` | client `BufferObject` | per `EndTransformFeedback` | barrier | dead pointer | none | `OnBufferWriteback`-style event / readback carrier | P9 |
| 23 | S→C read+write | client shadow read-modify-write in XFB scatter | `DirectGLES.cpp:1172` (`ScatterCapturedRecords`: `target.buffer->MappedData() + target.start`), `:1185` | client `BufferObject` | per XFB scatter | barrier | dead pointer | **none — no transport guard at all** | `OnXfbScatterReady` (declared `MGPipeCallbacks.h:50`, **never implemented**) | P9 |
| 24 | S→C read | XFB six fields (`GetTransformFeedbackProgram` → client `ProgramObject` dereferenced `:1248-1340`; binding points `:1250`; counters `:1135`) | `DirectGLES.cpp:1224-1343` (`StartPendingTransformFeedback`, from `PrepareForDraw` `:4545`) | client | **every draw** | barrier | dead pointers | `rsp` BARRIER_PULLED (6 rows, `FieldOwnership.def:119-130`) | server-side XFB span state | P3b/P4b, P7 per table |
| 25 | — | `MGPDrawInfo::XfbCpuCapturedVertices` / `kDrawHasXfbCount` | written 0 at `EmitTables.cpp:402`, `:1873`; **read by nobody** | — | — | — | — | dead field | was meant to carry the accounting (CONTRACT-P5B:163-164) | P9 or delete |
| 26 | S→C read | legacy buffer arm reads client freely (`MappedData()`, `IsMapped()`, `GetChangeSerial()`) | `Managers.cpp:1012-1022`, `:1119-1121`, `:1901`, `:2944-2949`, `:3281-3327`, `:5239`, `:5274`, `:1740-1917` | client | reachable in a split build whenever `MOBILEGL_PIPE_PUSH` bit 7 is clear | same process | everything | **none — only an `MGLOG_D` names the arm** (`Managers.cpp:2588-2619`) | n/a — arm should be refused under split like `Fatal{PipeLegacyMemosDisabled}` | P5c — one transport check at the arm resolver |
| 27 | — | `hostBytes` rule-C violation — **fixed on this head**: server-owned copy under split | `Managers.cpp:2165` (`Ops_H_SubData`), `:2225` (`Ops_H_FlushRange`), store `StagedShadow.h:66-82` | server | per upload/flush | — | — | `Fatal{StageSnapshotTooNarrow}` six named sites + `0xDD` audit | wire-clean | done |
### 1c. Reverse channel: callbacks, SEG_EVENT, error/surface/caps writes
| # | dir | what memory | site (function) | owner | when | why it works today | breaks under spawn | guard | natural carrier | phase |
|---|---|---|---|---|---|---|---|---|---|---|
| 28 | S→C write | client buffer CPU shadow bytes, via a **raw host pointer** | producer `Managers.cpp:2339-2343` (`Ops_H_Readback`: `MGPBlobRef{(Uint64)mapped, size, kMGHostSpanSegNone, 0}`); consumer `MG_Impl/Pipe/ResourceTracker.h:553-572` (`MGPipeClientOnBufferWriteback` casts `Offset` back to a pointer `:569`) → `BufferObject.cpp:492-511` | client `BufferObject` | per blocking `SyncGpuWrites`/readback | same address space + barrier | dangling foreign pointer; and the consumer **rejects any real segment** (`:560-564`) | none on the pointer | `SEG_EVENT` `kEventBufferWriteback` — consumer half exists (`ClientSession.cpp:188-213`), **no producer anywhere** | **P5c now** — wire the producer; fix the consumer's segment arm in the same commit |
| 29 | S→C write | client `m_hasDefinedContent`/`m_gpuWritePending` via direct callback into client tracker | producer `Managers.cpp:2729-2752` (`MarkBufferGpuWritten`); consumer `ResourceTracker.h:579-601` → `BufferObject::MarkGpuWritten` `:514-517`; backend feeders `DirectGLES.cpp:568`, `:616`, `:2601` | client `BufferObject` | per draw binding SSBO/atomic/writable-image | same address space | call into the other process | `MGLOG_E_ONCE` only (`:2729-2739`, `:596`) | `SEG_EVENT` `kEventGpuWritten` — consumer exists (`ClientSession.cpp:227-236`), no producer | **P5c now** — same producer wiring as #28 |
| 30 | S→C write | Magma `MarkGpuWritten` writes client objects **directly**, bypassing the callback | `DirectVulkan/Renderer/UniformManager.cpp:1075`, `:1231`; `VulkanRenderer.cpp:11618` | client `BufferObject` | per Magma draw with SSBO/texel-buffer/XFB | same address space | direct foreign write | none (Magma registers no `MGPipeResourceOps`, so it is outside the handle arm) | same `kEventGpuWritten` | P5c — route through the same callback/event as Espryt |
| 31 | S→C write | client `GLContext` error queue | `MG_Impl/Pipe/PipeFill.cpp:1764-1772` (`PipeInputs::RecordError` sticky forward → `ctx->RecordError`); producers `DirectGLES.cpp:8155`, `Managers.cpp:13128`, `DirectVulkan.cpp:717`, `VulkanRenderer.cpp:1339`,`:1343`,`:1399` | client `GLContext` | per backend-detected GL error | barrier + sticky-forward accounting | write into the other process | `MGP_STICKY_FORWARD_PULL` → `rsp`; Fatal under `MOBILEGL_IPC_STRICT_ERRORS` | `OnGlError` event (declared, never installed); ordering is P9's | P9 per table |
| 32 | S→C write | client compile env / advertised extensions | `PipeFill.cpp:1753-1756` (`InvalidateCompileEnv` forward); producers `DirectVulkan/BackendObject_DirectVulkan.cpp:390`, `:788` (Magma only) | client `GLContext` | per backend caps re-run | barrier; **no-op outside a stamped verb** (`PipeInputs.h:265-278`) — silent outside it | write into the other process | sticky pull counting | R-12 re-arriving caps snapshot — client half already landed (`CapsMirror.cpp:78-80`) | P5c — delete the forward; the snapshot already does the job on the client |
| 33 | S→C write | client default-framebuffer attachments (`pDefaultFramebufferInfo` depth/stencil/colour) | `DirectGLES.cpp:11519-11620` (`PublishDefaultFramebufferDepthStencilFormat`, from surface creation `:11885`, `:11902`); Magma twin `DirectVulkan/Renderer/SwapchainObject.cpp:276-335` | client `MG_Impl` placeholder | per surface/swapchain (re)create | barrier; rare | write into the other process | **none** | `SEG_EVENT` `kEventSurfaceChanged` — consumer stub exists (`ClientSession.cpp:242-253`), no producer, no handler installed | P6 — surface events must cross anyway; P5c can add the producer |
| 34 | S→C write | server's apply-thread-inside flag lives in **client** TU statics | `PipeApplier.cpp:934` (`ScopedApplierEntry`) → `ClientSession.cpp:884-889` writes `g_applyThreadInsideApplier` (`:113`); read by client `ClientSession.cpp:748` (`Fatal{BarrierViolation}`) | client statics, server-written | per applied record | same process | write into the other process | none (it is the handshake) | session-local flag under spawn; fine to keep inproc | P6 |
| 35 | — | SEG_EVENT ring: created, mapped, announced, consumer drained after every reply verb — **zero producers** | segments `ServerSession.cpp:285-301`; consumer `ClientSession.cpp:176-267`, called `:836`; producer API `ServerSession::PublishEvents` `:484-492` has no callers | — | — | — | the ring exists but carries nothing | overflow latch + `eventDropped` counter built, unused | itself | P5c — rows 28/29/33 are its first three producers |
### 1d. Caps, format tables, program artifacts
| # | dir | what memory | site (function) | owner | when | why it works today | breaks under spawn | guard | natural carrier | phase |
|---|---|---|---|---|---|---|---|---|---|---|
| 36 | S→C read | client caps mirror's `FormatCapabilityCache` | `MG_Backend/DirectGLES/Utils.cpp:50` (`ActiveBackendFormatCaps` fallback arm when `ServerLoopInstance().Backend()` is null — bring-up/teardown window); main arm `:46-48` is server-routed | client `BackendObject_Remote` | rare (server backend null) | values are a copy of the server's own caps | read of client mirror | null test only | server's own `Backend()->GetFormatCapabilities()`; refuse when null | P5c — one-line arm tightening; pinned by `ServerLoopTest.cpp:848-868` |
| 37 | S→C read | client mirror's `DynamicBackendParameters` copy, **four Magma sites, unrouted** | `DirectVulkan/DirectVulkan.cpp:713-715` (`MaxShaderStorageBufferBindings`); `VulkanRenderer.cpp:667-676` (line-width range, per state change); `VertexInputStateFactory.cpp:249-250`, `:502-503` (`SupportsFloat64VertexAttributes`, per pipeline build) | client `BackendObject_Remote` | per draw/pipeline build on Magma | mirror holds a copy of the snapshot | read of client mirror | **none** — no `#if`, no Fatal, no `ServerLoopInstance()` consult | server's own backend `GetDynamicParameters()` (same values, same process role) | **P5c now** — mechanical re-pointing; Espryt already shows the shape |
| 38 | — | `GetCaps` record's two blobrefs — record is dead; the snapshot carries the data instead | decoder declines `PipeWireCodec.cpp:1493-1506`; no client emitter exists; snapshot path `ServerSession.cpp:366-408` → `ClientSession.cpp:275-330` → `CapsMirror.cpp:55-87` (blobrefs cleared `:63-64`) | — | — | — | — | open item (`ROADMAP.md:58`) | the `CapsSnapshot` control frame (already the carrier) | P6 (delete or wire the record) |
| 39 | — | CreateShaderState program archive — **wire-clean**: one SEG_STAGE blob, server decodes into apply-locals | emit `MG_Remote/Client/WireTables.cpp:470-502` (`Fatal{ArtefactsMissing}` `:478-485`, `Fatal{ArchiveEmpty}` `:491-495`, six `Spirv[]` refs zeroed `:496-497`); decode `PipeWireCodec.cpp:1676-1714`; applier stores descriptor only (`PipeApply.cpp:2780-2784`) | — | per program link | — | — | both Fatals are client-side pre-emission | SEG_STAGE (in use) | done |
### 1e. Process globals and cross-role control
| # | dir | what memory | site (function) | owner | when | why it works today | breaks under spawn | guard | natural carrier | phase |
|---|---|---|---|---|---|---|---|---|---|---|
| 40 | shared | `gPipeInputs` (~20 KB, 63 fields + 7 sticky forwards): client residual fill writes, applier mirrors write, server BARRIER-PULLED reads (36 rows) | definition `MG_Backend/MGPipe/PipeInputs.h:806`; fill `PipeFill.cpp:2798` (`MGPipeValidateForVerb`); applier writes `PipeApply.cpp:1415-1560`; server stamp `PipeInputs.cpp:103-132`; `rsp` increment `PipeInputs.cpp:72` | co-owned under the barrier | every verb | **only the verb barrier** makes one writer at a time | the whole block | `rsp` + `MOBILEGL_IPC_STRICT_ERRORS` Fatal (`PipeInputs.cpp:61-77`) + poison (`generated/PipeFilled.inc:408-422`) | per-field rows: P3b/P4b (12), P7/P8 (objects), P9 (writes) — `FieldOwnership.def` | per table |
| 41 | C→S write | server `g_applier` wholesale reset from the GL thread | `PipeFill.cpp:2654-2656` (`MGPipeValidateForVerb` `FreshlyPrimed` arm → `MGPipeApplierReset()`, body `PipeApply.cpp:1202-1299`) | server | per freshly-primed context / make-current edge | barrier post-condition: nothing in flight at a validate; reset advances serials | GL thread writes server state; no record names it | **none** — no role check, no barrier check | a reset control record / mailbox frame at the make-current edge (R-12 edge already exists) | **P6 must**; P5c can add the control record |
| 42 | S→C read+write | client slot allocator `MGPipeSlots()` driven from the server backend: `Acquire` (mint!), `FindByLifetimeId`, `Free` | `MG_Backend/DirectGLES/SlotTables.h:232` (`GetOrCreate`), `:397` (`HandleOf`), `:418`, `:428` (`OnFrontendObjectDestroyed`); call sites `Managers.cpp:2708`, `:4293` | client allocator | per twin creation/death/probe | barrier | server minting into a client allocator | none (`MOBILEGL_ASSERT` at `:233` inert at INFO); self-declared at `SlotTables.h:70-77` | `GetOrCreate(MGPipeHandle)` overload (`SlotTables.h:278`) — the handle already arrives in verb payloads | P3b/P4b, P7 |
| 43 | shared | eight Espryt twin registries keyed by frontend object address, holding weak/raw refs | `Managers.h:309-377` (`StateBackendObjectRegistry`), `SlotTables.h:138-161` (`BackendSlotTable`), eight globals `Managers.h:858`,`:1385`,`:1780`,`:1897`,`:2494`,`:2632`,`:2718`,`:2773`; legacy memos `DirectGLES.cpp:95-140` | client-keyed | per object lookup | barrier; weak refs expire cleanly | keys are foreign addresses | arm resolver `Fatal{PipeLegacyMemosDisabled}` only when bit 5 clear AND LEGACY_MEMOS=0 | lifetime-id/handle keying (handle arm already the default) | P3b/P4b |
| 44 | shared | `pDefaultFramebufferInfo` — frontend default-FBO placeholder, read and mutated by the server | storage `MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp:3457`; server readers `DirectGLES.cpp:2846`,`:3137`,`:4370`,`:4414`; writer `:11520`; Magma `SwapchainObject.cpp:276` | client `MG_Impl` | per FBO compare / surface event | barrier | dead pointer | none | reserved default-FBO handle `{0,1}` + `IsDefault` bit (D-C1, `DirectGLES.cpp:2838-2849`) | P3b/P4b (D-C1) |
| 45 | shared | `g_rawDepthFetchSamplerState` — server constructs, owns and mutates a frontend `SamplerObject` | `DirectGLES.cpp:61-62`, created `:269-274`, used `:277` | server-held frontend-type object | per raw depth fetch | same process | a client-type object server-side | none; self-declared "largest surviving MG_State-type usage under MG_Backend" | sampler CSO record fields the applier already reads | P3b/P4b (comment assigns it) |
| 46 | shared | `ScopedDefaultUnpackState::s_synced` + six value shadows, never reset on context death | `Managers.cpp:5806-5812`, writes `:5773`,`:5790-5795`; callers `:6925`,`:7120`,`:7183`,`:7287` | server-private memo | per texture upload | server-private **today** (client runs no GL) | latent: a server re-attaching to a moved context skips an owed `glPixelStorei` | none | reset keyed on the context-generation edge | P6 — register it now (CONTRACT-P5 table 3 already says so) |
| 47 | — | `g_syncedRenderStateParameters` — server-private driver-state memo | `DirectGLES.cpp:3185`, writes `:3274-3878`, reads `:6895`,`:7061`,`:7630`,`:7946` | server | per render-state sync | server-exclusive | not context-generation keyed (latent, same class as #46) | none | — | P6 housekeeping |
| 48 | — | `gBackendFunctionsTable` — client = emit table, server holds its own table privately | client install `MG_Backend/Init.cpp:63` via `BackendObject_Remote::GetBackendFunctions()` (`BackendObject_Remote.cpp:162`); server `PipeApplier.cpp:58-72` | — | — | — | — | re-emission loop documented `PipeApplier.h:94-98` | wire-clean | done |
| 49 | — | `gMGPipeSegmentResolver` — server installs, client never resolves; only production resolve is the user-index span | install `PipeWireCodec.cpp:425-437` (Fatal on double install), `ServerSession.cpp:336`; resolve `PipeApplier.cpp:559`; client writes `Ptr=nullptr` `EmitTables.cpp:503`; honesty gate `PipeWireCodec.cpp:521-536` | — | per user-index draw | — | — | `Fatal{ProtocolCorruption}` four arms | wire-clean | done |
| 50 | C→S read | `ServerLoop::m_running`/`m_applyThreadId` read per routed record | `MG_Remote/Client/WireTables.cpp:71` (`RunsAsTheServerRole`), `PersistentMapTracker.cpp:38`, `BufferObject.cpp:385`,`:410`,`:440`, `PipeFill.cpp:757`,`:877` | server singleton | **per verb** (hottest C→S read) | same-process atomics | singleton absent in the client process | none | a client-local role flag set at session start | P6 — trivially local; no carrier needed |
| 51 | C→S ctrl | twelve `Server*` EGL forwarders → server's private backend via the one-slot control mailbox; payload is a **raw fn-ptr + `void*` to a caller stack local** | callers `BackendObject_Remote.cpp:125-264`; mailbox `ServerLoop.h:216-226`; mechanism `ServerLoop.cpp:543-598` | server backend | rare (per EGL call) | blocking; same address space | unserializable by construction | `Fatal{ApplyThreadNotRunning}` (`ServerLoop.cpp:568`) | transport control messages (P6 `SocketTransport` control plane) | **P6 must** |
| 52 | C→S write | FBO/object death posted as a stack struct host pointer into the mailbox (**named inproc dependency #3**) | `Managers.cpp:206-221` (`OnFrontendStateObjectDestroyed` split arm) → apply-thread `DestroyByLifetimeId` `:223-228` | server twins | per frontend object death (6 kinds) | blocking; same address space | no framebuffer delete opcode exists ("Death notices have no framebuffer wire opcode", `:209`) | none on the carrier | a `framebuffer_destroy`/object-death wire record | **P6 must**; P5c can add the record |
| 53 | C→S read | `ServerLoop::Backend()` read on the app thread at bring-up (`kCapBackendOwnsXfbCapture` derivation, `SetBackend`) | `MG_Backend/Init.cpp:164-170` | server backend | once | same process | direct read | `#if MOBILEGL_BUILD_DISAGGREGATED` | the caps snapshot already carries the answer (cap bits) | P6 — read it from the snapshot |
| 54 | C→S read | `MGPipeGetResourceOps()` at bootstrap honesty checks | `MG_Backend/Init.cpp:100`,`:145`,`:247` (`AssertConsumerMaskIsHonest`, `Fatal{ConsumerMaskLie}`) | server-registered table | once ×3 | same process | — | honesty check only | consumer bits in `CallMask` (already the wire form) | P6 — keep as a check against the snapshot |
| 55 | C→S read | Windows inproc attach **aliases the server's `ShmSegment` objects** (`m_owns=false`); client ring/reply/event views are the server's members | `MG_Remote/Transport/ShmSegment.cpp:352-359`; client reads `ClientSession.cpp:454`,`:459`,`:477`,`:502-506` | server mappings | once | same process | — | none (POSIX does a real dup+Map) | SCM_RIGHTS/fd adopt (P6) | P6 by design; note the Windows lane never exercises the POSIX attach path |
| 56 | — | barrier client-half assertion gap: `InBarrierWait()` has **zero call sites**; only `ApplyThreadIsInsideApplier` is enforced (at emit) | declaration `ClientSession.h:128`, definition `ClientSession.cpp:880`; enforced half `:748-753` | — | — | — | client `gPipeInputs` writes outside a barrier are unchecked (CONTRACT-P5 §4 claims the check exists) | — | finish the assertion or delete the claim | P5c — cheap, catches #40-class regressions |
### 1f. Test-only cross-role access (listed separately, per the brief)
| # | dir | what | site |
|---|---|---|---|
| 57 | C→S read | `MGPipeApplier()` (server `g_applier`) records/windows | `MG_IntegrationTest/Harness/PipeApplyPeek.cpp:79`,`:176`; `P4aSeamPeek.cpp:52`,`:63`; `P4aFinalFixPeek.cpp:30` |
| 58 | C→S write | `ServerLoopInstance().SetBeforeRetireHookForTesting(...)` | `MG_IntegrationTest/Harness/SplitRuntimePeek.cpp:31` |
| 59 | client-local | `pActiveBackendObject` (client mirror), `MGPipeSlots()`, `PersistentMapTracker` | `BackendCapsPeek.cpp:29`, `PipeSlotPeek.cpp`, `PersistentMapPeek.cpp:62`,`:76` — no cross-role read |
---
## 2. Summary counts
By direction (58 inventory rows, #57–59 counted once as test-only):
| direction | rows | the weight |
|---|---:|---|
| S→C read | 19 | texture sync (#1–#8, #10, #15, #19), XFB pulls (#24), legacy arm (#26), caps mirrors (#36, #37), slot allocator probes (#42, #43) |
| S→C write | 12 | reverse channel (#28–#34), re-dirty (#5), XFB writebacks (#22, #23), Magma mip (#14), surface (#33, #44-adjacent) |
| C→S read | 6 | role flags (#50), bring-up (#53, #54), shm alias (#55) |
| C→S write | 3 | applier reset (#41), death mailbox (#52), test hook (#58) |
| C→S ctrl | 1 | EGL forwarders (#51) |
| shared global | 8 | `gPipeInputs` (#40), twin registries (#43), memo pointers (#8, #20, #21), `pDefaultFramebufferInfo` (#44), depth-fetch sampler (#45), unpack shadows (#46) |
| wire-clean / dead / latent confirmations | 9 | #11, #12, #13, #16, #25, #27, #38, #39, #47, #48, #49 |
By natural carrier:
| carrier | rows |
|---|---:|
| server-owned level shadow / adopt the already-staged SEG_STAGE run (texture) | #1, #2, #3, #5 |
| SEG_EVENT (producer exists in shape; consumer live) | #28, #29, #30, #31, #33 (and #16, #23 designed-for) |
| handles already on the record → server-side resolution | #4, #9, #10, #19, #20, #42, #43, #44 |
| server's own backend / caps snapshot (no new carrier) | #32, #36, #37, #53, #54 |
| new/extended control record (reset, death, EGL control plane) | #41, #51, #52 |
| applier descriptor / server-derived — no carrier | #6, #7, #24, #45 |
| client-local role fact — no carrier | #50 |
| P3b/P4b twin-table re-keying (not a wire question) | #8, #20, #21, #43 |
Top 10 by frequency (per-draw first):
| rank | row | site | frequency |
|---|---|---|---|
| 1 | #40 | `gPipeInputs` BARRIER-PULLED reads (`GetBoundVertexArray` `DirectGLES.cpp:4486`, `GetProgramForDraw` `:4497` unconditional per draw) | per draw |
| 2 | #24 | XFB six pulls in `StartPendingTransformFeedback` (`DirectGLES.cpp:1224-1343`) | per draw |
| 3 | #18 | `HasDefinedContent()` (`Managers.cpp:3148`) | per draw that ensures a buffer |
| 4 | #29 | `OnGpuWritten` direct callback (`Managers.cpp:2752`) | per draw with SSBO/atomic/writable image |
| 5 | #50 | `RunsAsTheServerRole()` (`WireTables.cpp:71`) | per routed record |
| 6 | #1 | client `MipmapStorage` texel reads (`Managers.cpp:7315` etc.) | per uploaded level, per validate |
| 7 | #7/#8 | texture-unit sync walk + sync-list replay (`DirectGLES.cpp:2204-2215`, `:2119-2279`) | per draw on memo miss / per draw |
| 8 | #19 | `HandleOfBuffer` → `GetLifetimeId()` (`Managers.cpp:2705-2716`) | per ensure / memo rebuild |
| 9 | #37 | Magma `SupportsFloat64VertexAttributes` (`VertexInputStateFactory.cpp:249`,`:502`) | per pipeline build |
| 10 | #6 | FBO attachment walk (`DirectGLES.cpp:8177-8256`) | per blit/mip/copy |
---
## 3. Already wire-clean (verified on this head)
- **Buffers, whole family**: all ten `Ops_H_*` handlers take handle + record + SEG_STAGE bytes only; `StagedShadowStore::Adopt` copies on apply (`Managers.cpp:2165`, `:2225`); `Fatal{StageSnapshotTooNarrow}` six named sites (`StagedShadow.h:106`); `hostBytes` is server-owned under split (rule C's one named violation is fixed). `resource_subdata` declares a real size, cross-checked (`PipeApply.cpp:715`). `resource_flush_range` carries no bytes, transport-gated (`PipeApply.cpp:1885-1888`). `buffer_subdata_resident` copies, never retains (`Managers.cpp:2199-2207`).
- **resource_respecify**: `initialBytes == nullptr` under split; `Fatal{UncarriedInitialBytes}` (`WireTables.cpp:367-374`) / `Fatal{InitialBytesNotCarried}` (`PipeFill.cpp:768-775`) guard both directions.
- **Persistent maps**: tier-2 emulated push goes block-wise through SEG_STAGE (`PersistentMapTracker.cpp:76-127` → `BufferObject.cpp:404-434` → `WireTables.cpp:314-330`); `Fatal{RoleViolation}` bars the apply thread from the producer; tiers 0/1 are named Fatals; `liveHostBase()` cannot fall back to `MappedData()` under a transport (`Managers.cpp:2986-2988`, ID-50/52).
- **CreateShaderState**: archive crosses as one SEG_STAGE blob; server decodes into apply-locals; six `Spirv[]` refs zeroed and Fatal if declared (#39).
- **Caps**: `FormatCapabilities` + `RendererInfo` cross as serialized blobs in the `CapsSnapshot` control frame (`ServerSession.cpp:366-408` → `CapsMirror.cpp:55-87`); DirectGLES format-cap lookups are routed to the server's backend (`Utils.cpp:40-51` main arm, `BackendObject_DirectGLES.cpp:866-874`).
- **ReadPixels**: tight wire form, neutral pack server-side, scatter client-side; oversized reads refused at the client before emission (`ReplySlot.h:191-207`); PACK-PBO destination named-refused (ID-57).
- **DrawVbo user indices**: staged into SEG_STAGE, `Ptr=nullptr`, four honesty arms, sink resolves via `MGPipeHostBytes` (`PipeApplier.cpp:559`, `PipeWireCodec.cpp:521-536`).
- **Fence/sync family**: client mints `{slot,gen}`, only the handle crosses; native fences live on the apply thread (wave-3, CONTRACT-P5B §9).
- **Persistent-map / XFB counters**: `MGPDrawInfo::XfbCpuCapturedVertices` has no reader, so its deadness leaks nothing.
- **Roles**: `gMGPipeSegmentResolver` server-only with double-install Fatal; `gBackendFunctionsTable` split correctly; the three `MGPipeGetResourceOps()` liveness reads in `PipeFill.cpp:642/655/1069` short-circuit to `CapsMirror::ServerConsumes` under a transport; no `MG_Remote/Server` or `MG_Pipe` TU reads any `MG_Impl/Pipe` singleton except the `SlotTables.h` backend arm (#42).
---
## 4. Surprises / disagreements with the contracts and ARCHITECTURE.md §17
1. **The texture texel path is the real rule-C violation, and no table names it.** CONTRACT-P5 §0 calls `hostBytes` "the tree's exactly one violation" — fixed on this head. But texture uploads stage the level into SEG_STAGE and `ApplyTextureUpload` then **drops the pointer** ("DISPATCHES TO NOBODY", `PipeApply.cpp:989-1008`); Espryt re-reads the texels from the client `MipmapStorage` (`Managers.cpp:7315`). Every texture-object method the server calls on a client object has **no row in `FieldOwnership.def`**, so the whole family is invisible to `rsp` and to `MOBILEGL_IPC_STRICT_ERRORS`, and `MOBILEGL_IPC_AUDIT=1`'s `0xDD` fill cannot observe it (textures never adopt staged bytes). `rsp` is a lower bound by a wide margin — exactly as `r2-v1.md:79` warned, but the unnamed set is larger than "sticky/non-verb forwards": it is the texture hot path.
2. **SEG_EVENT is fully plumbed and silent.** Segments created, mapped, announced in Welcome, consumer drained after every reply verb (`ClientSession.cpp:836`) — and zero producers repo-wide. Worse: the one live writeback producer bypasses the ring with a raw host pointer (`Managers.cpp:2339-2343`), and the installed consumer would **reject** the ring's own blobref convention (`ResourceTracker.h:560-564` rejects any real `Seg`). A producer added tomorrow would be dropped, not delivered.
3. **8 of 10 `MGPipeCallbacks` are never installed** — only `OnBufferWriteback`/`OnGpuWritten` have assignment sites (`ResourceTracker.h:606-613`), and both are invoked **in-line on the apply thread** straight into client `MG_State`. `OnGlError`, `OnSurfaceChanged`, `OnCapsInvalidated`, `OnMipLevelsGenerated`, `OnXfbScatterReady`, `OnTexturePullRequest`, `OnTextureWriteback`, `OnLog` are declaration-only.
4. **`MGPDrawInfo::XfbCpuCapturedVertices` / `kDrawHasXfbCount` ride nothing.** CONTRACT-P5B:163-164 says the field "rides when the client's XFB accounting has a value"; on this head it is written 0 (`EmitTables.cpp:402`, `:1873`) and read by nobody.
5. **The barrier's client-half assertion is half-implemented.** CONTRACT-P5 §4 says "the client checks [`InBarrierWait`] when it touches `gPipeInputs` outside a barrier" — the function has zero call sites (`ClientSession.cpp:880`). Only `ApplyThreadIsInsideApplier` is enforced, and only at emit (`ClientSession.cpp:748`). The two client writes that run outside the barrier (`PipeFill.cpp:2798` into `gPipeInputs`, `:2656` into `g_applier`) are covered by the barrier's post-condition, not by the advertised check.
6. **`GetCaps`'s two blobrefs are answered by the snapshot, not the record.** The `GetCaps` wire record is dead (decoder declines, no emitter); ARCHITECTURE §17's "GetCaps 两个 blobref 的载体" open item is in practice the `CapsSnapshot` frame, which is wire-clean. The open item is record hygiene, not a missing carrier.
7. **Magma was left out of three fixes Espryt got.** `pActiveBackendObject` routing (#37 vs `Utils.cpp`), mip-level re-derivation (#14 vs `DirectGLES.cpp:8080-8111`), and the `MarkGpuWritten` callback (#30) all have a DirectGLES arm and an untouched DirectVulkan twin. CURRENT_STAGE_PROGRESS §5's "Magma split compute/image: 82 of 89 wrong answers" is consistent with this.
8. **Windows inproc does not exercise the POSIX attach path.** `AttachInProcess` aliases the server's `ShmSegment` objects on `_WIN32` (`ShmSegment.cpp:352-359`); the dup+`Adopt`+`Map` arm that P6 generalises is POSIX-only. Windows-lane green says nothing about segment lifetime discipline.
9. **Stale doc/code citations found while auditing** (all content still true, only the numbers drifted): `StagedShadow.h:11-14` and `PipeApplier.h:33-37` repeat CONTRACT-P5's `Managers.cpp:1980-1983/:2035/:2000/...` (now `:2165`,`:2225`,`:2183`,`:2271`,`:2279`,`:2315`,`:3179`,`:5393-5396`); `PipeWireCodec.cpp:1872` cites `PipeApply.cpp:702` for the subdata length check (now `:715`); CONTRACT-P5 table 3: `PipeInputs.h:706`→`:806`, `PipeApply.cpp:396/402`→`:409/:415`, `Managers.cpp:5490-5496`→`:5806-5812`, `Init.cpp:44`→`:63`, `Managers.cpp:2594`→`:2769`; `EmitTables.cpp:21-22` header comment says B=11/C=58 while its own `static_assert`s pin B=54/C=15 (`:1643-1667`).
10. **`EmitBlitNamedFramebuffer` already carries the two FBO handles** (`EmitTables.cpp:776-777`) — the "scoped client binding" inproc dependency #1 is therefore removable inproc (P5c), not only at P6: the sink can resolve `ReadFbo`/`DrawFbo` server-side today. Same for the mip registry lookup (#4, `MGPMipPlan::Res` already crosses).
---
## 5. Existing numbers (no runs performed; cited from notes)
- `rsp=35` for Triangle and PersistentCoherentMap entries (pinned table, `~/w7/notes/p5/p5-results/joint-v1.md:271`, log lines `:1482-1493`; reproduced `x2-v1.md:137`). **`rsp=2690` for OpenRA over a 5-frame window** (`x2-v1.md:138`).
- `rsp=35` is repeatedly stated to be a **lower bound**, not a census: `~/w7/notes/p5b/p5b-results/r2-v1.md:64`, `:79`; `p5-close-codex-review.md:220`; `docs-codex-v1.md:11`. This audit confirms the bound is low by at least the whole texture family (§4.1).
- **`rsp` per Minecraft frame is unmeasured** — stated at `~/w7/notes/p5b/p5b-results/c0b-v1.md:263`; no P5b-close `rsp` sum exists in the notes. The only numeric `rsp=` in the whole p5b notes tree is the forwarded 35.
- P5b final census lane logs (`~/w7/p5b-final-census-348d22a4/lane-stage32/`, 17 logs, 51 stats lines): `rsp` histogram — `0`×29, `260`×4, `271`×3, `80`/`133`×2, `50/110/131/138/139/143/150/167/171/185/2472`×1 (e.g. `…StorageBufferRegrowScenario…log:580` `rsp=2472`; `…TextureUploadShape…log:580` `rsp=150` with `maxrec=1360`).
- `maxrec=784` (`SetVertexAttribDefaults`) dominates 979 of 1206 lane logs; cap 4 MiB of an 8 MiB SEG_CMD (`x2-v1.md:118-125` table; SmallRing ledger `x2m-v1.md:55`). Largest observed `maxrec=4632`.
- Class-C first-blocker census (`~/w7/notes/p6/census-classC.md`): `BindImageTexture` 138, `BeginTransformFeedback` 95, `DrawElements` 56, `DispatchCompute` 49, `PatchParameteri` 43, `CopyImageSubData` 30, `MemoryBarrier` 18, `MultiDrawElementsBaseVertex` 18, `ClearBufferiv` 12, `ClearBufferuiv` 8 — all now migrated; 505 `UnmigratedVerb` + 6 `StageSnapshotTooNarrow` aborts in the baseline.
- Device A/B lanes (`p5-results/ab-v1.md`, 193 `rsp=` lines): all `rsp=0`/`rsp=None` — the stats line is not published on Android device runs, so no device-side `rsp` exists.
## 6. What this sizes for P5c (suggested, one line each)
1. **Adopt staged texture bytes server-side** (#1–#3): the bytes already cross; add the texture half of `StagedShadowStore` and route `SyncMipmapsToBackend` to it. Retires the largest un-instrumented family and makes `MOBILEGL_IPC_AUDIT` meaningful for textures.
2. **Wire three SEG_EVENT producers** (#28, #29, #33) and fix the writeback consumer's segment arm: the ring, consumer and counters already exist.
3. **Resolve records by their carried handles** (#4, #9, #10): named blit, mip descriptor, CopyTex — all three already carry the handle the lookup re-derives.
4. **Re-point Magma's four mirror reads + Espryt's fallback** (#36, #37) at the server's own backend.
5. **Kill the unguarded per-draw read** (#18) with a descriptor live-content bit.
6. **Transport-refuse the legacy buffer arm** (#26); implement or delete `InBarrierWait` (#56).
7. Leave #41/#51/#52/#55 to P6 (they are its stated job), but #41 and #52 can get their control records in P5c since the mailbox already serialises the call shape.