Files
MobileGL/docs/Disaggregated/notes/p5/p5-results/v1-v2.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

252 lines
20 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# v1-v2 — server role round 2: the confirmed set, the five codex findings, and the first 21/21 reduced-path lane
Branch `p5/v1`, round-2 range **`3fb97cc5..c9d84e33`** (base = round 1 `571cbabb` then `git merge feat/disaggregated`
→ `3fb97cc5`, head `7110cdb6` as the charter's step 0 named; nine single-line commits follow). Identity
`Swung0x48 <swung0x48@outlook.com>` on every one; no attribution trailer. Submodule links toggled per
PACKAGE-PREAMBLE around every git/build.
Commits, oldest first:
| sha | what |
|---|---|
| `e7fe3b97` | ServerLoop: C2 (m_running under m_controlMutex + re-check), M-7 (Fatal not app-thread fallback), M-4/codex-11 (effective affinity mask), C7/ID-54 (once-per-tuple make-current, release recorded not forwarded), m-3, m-4 |
| `0244fc4a` | Init.cpp: M-6 (ShutdownSplitRoles stops the apply thread on the early-Start-failure path), m-6 (re-assert consumer mask after step 4) |
| `0fde9535` | Managers.cpp: M-2 (server staged copy is the only base under split), M-3 (whole-store readers through RequireCoverage), m-5 (first cut) |
| `7a925b32` | DirectGLES C6: the seven format-capability reads use the server-private cache under split; #if-guarded so pull is byte-identical |
| `61d6cd8e` | PipeApplier: ID-49 (neutral-pack tight read), m-1 (present 1:1 is a convention), m-7 (reply ordering documented) |
| `05bcb734` | PipeApply.cpp: item-12 (resource_flush_range carries no bytes under split; consumer reads the staged shadow) |
| `a85aa954` | ServerLoopTest: M-1 production gate, C2/M-6/M-7/C6/C7 controls, C10 actual-park arming, M-4 explicit mask, m-2 SIGABRT death |
| `455b475c` | m-5 corrected: null a stale hostBytes only when its shadow is really gone (StagedShadowStore::HasShadow), not on a twin's first-ensure generation sync |
| `c9d84e33` | R-11 completion: a resource_subdata that finds no twin under split MINTS one, so its bytes reach the server shadow (the twin is otherwise lazy until draw, D-A2) |
Files: `MG_Remote/Server/{ServerLoop.{h,cpp},PipeApplier.cpp,StagedShadow.h}`, `MG_Backend/Init.cpp`,
`MG_Backend/DirectGLES/{Managers.cpp,Utils.{h,cpp},BackendObject_DirectGLES.cpp}`, `MG_Pipe/PipeApply.cpp`,
`MG_Test/Wire/ServerLoopTest.cpp`. PipeApply.cpp is p1's / Utils.cpp+BackendObject_DirectGLES.cpp are
DirectGLES: edited under the integrator's explicit C6/item-12 assignment (flagged §"ownership" below).
---
## The confirmed set (each item: what changed, the red-once line)
**ID-49 (codex 1, ReadPixels blocker), server half.** `ServerVerbSink::OnReadPixels` now reads with NEUTRAL
pack state (ROW_LENGTH 0, SKIP_ROWS/PIXELS/IMAGES 0, ALIGNMENT 1, restored after via
`MGPipeApplySetPixelPackState`) into a **tight `w*h*bytesPerPixel`** scratch that IS the reply payload;
`DstSize` is that tight size. **The DstSize formula both sides agree on: `w * h * bytesPerPixel`** (bpp from
`GetInputBytesPerPixel(ConvertGLEnumToTextureInputFormat(Format), …DataType(Type))`, the same helper c1's
`PackedReadbackBytes` uses). A non-default server-visible pack state can no longer change the reply's size or
bytes. **Red once:** the two `DepthReadbackHonoursThePackPixelStoreParameters` SEGFAULTs — round 1's census
omitted them — are the pre-fix state; the round-2 joint inproc census has **0 SEGFAULT** and that case now
**passes** (probe `p5-v1-probe-depthpack_ok`). End-to-end control is the joint, per the charter.
**M-1 / codex 8 — R-11 production gate.** New `StagedShadowProductionTest.SubDataThroughTheRealOpsTable…`
installs the real ops table (`BufferImpl::RegisterBufferBackendOps`), drives
`MGPipeGetResourceOps()->SubData` — the exact `Managers.cpp:2118` call site — mints the twin, then poisons the
source and reads `FindBufferResourceForHandle(res)->hostBytes`. **Red once (redcheck `m1-subdata-site-raw-offset`):**
restore `hostBytes = raw - offset` → `kept a pointer into SEG_STAGE`. `StagedShadowTest` stays the container
test; this is the gate.
**M-2 / codex 3 (item 3) — the audit becomes real.** `liveHostBase()` no longer falls back to the client
object's `MappedData()` under an active transport — the server's staged copy is the only base (R-2 / table 3).
This exposed and drove two further fixes (see §"the M-2 cascade" below). **Red once:** under
`MOBILEGL_IPC_AUDIT=1` the joint reduced-path lane is **21/21**; reverting M-2 makes the draw read `MappedData`
again (proven — reverting it turned the blue triangle green), so a corrupt staged upload could no longer be
seen. With M-2 the draw reads the shadow, and audit-green means no 0xDD reached a draw.
**M-3 / codex 4 — whole-store readers.** The pool-reuse upload (`Managers.cpp:~2993`) and the whole-store
respecify (`~3068`/`~3086`, `initialData != nullptr`) now call `MGL_SERVER_STAGED_REQUIRE(... "pool_reuse_whole_store"` /
`"respecify_whole_store")` before uploading. No-op for the legacy `MappedData()` arm and for a non-copying
store; a sparse shadow forced through storage recreation dies by name. **Red once:** the unit
`StagedShadowTest.ADrainOutsideTheStagedCoverageIsFatalByName` (now an `EXPECT_EXIT(…, KilledBySignal(SIGABRT), …)`
+ the `Fatal{StageSnapshotTooNarrow}` log grep) is RequireCoverage's own control; the production wiring is
exercised end-to-end on the joint. ID-41: no edit inside `FlushPendingRangesFrom`; both G5 scripts stay as
b1 re-pinned them (I touched no pinned body).
**m-5 / codex 5 — DropAll and the freed base.** `DropAll` frees shadows; a twin surviving context loss kept a
`hostBytes` into freed memory. Nulled in the generation-reset block — **but only when the shadow is really
gone**, keyed on the new `StagedShadowStore::HasShadow(key)`, because that block also runs on a twin's FIRST
ensure and an unguarded null dropped a base a subdata had just staged (this is what first broke the reduced
path — §"the M-2 cascade"). **Red once (unit `StagedShadowTest.HasShadowIsTrueAfterAdoptAndFalseAfterTheShadowIsDropped`):**
Adopt → HasShadow true; DropAll → false, both asserted.
**M-4 + codex 11 — affinity gate.** `ApplyAffinity` now returns the EFFECTIVE mask read back with
`sched_getaffinity`, and the log/`ResolvedAffinityMask()` report it, not the requested one. New
`TheExplicitAffinityMaskResolvesToItselfAndIsLogged` (`"0x3"` → `0x3`, log `RESOLVED mask 0x3`), and the `off`
case now also asserts `off` was a RECOGNISED string. **Red once (redcheck `resolved-mask-not-logged`):** rename
the log token → `did not log its resolved affinity mask`. Deleting `off`'s branch makes off unrecognised → the
`off` case's new assertion goes red.
**M-6 — teardown on early Start failure.** `ShutdownSplitRoles()` now calls `Server::ServerLoopInstance().Stop()`
itself after `ClientSession::Stop()`; Stop is idempotent (its `!joinable` arm drops a backend that never ran a
thread). **Red once (unit `StopWithoutAStartedThreadStillDropsThePrivateBackend`):** without Stop's reset a
second `CreateBackend` returns `INVALID_ARGUMENT`.
**M-7 + C2 (codex 2) — the mailbox race and the no-thread arm.** `m_running` is now cleared INSIDE the
`m_controlMutex` critical section in `ApplyThreadMain`'s exit, and `RunOnApplyThread` re-checks it under that
same lock before publishing (C2 — the verifier's latch harness proved the pre-fix hang, `CALLER_HUNG 30000 ms`
while `Stop()` returned in 0 ms). The `!m_running` arm returns `NOT_INITIALIZED` when the backend is gone and is
a named `Fatal{ApplyThreadNotRunning}` when a backend exists but no thread does (M-7 — never a silent
EGL-on-the-app-thread fallback). **Red once:** unit
`AForwarderCallAfterTheLoopStoppedReturnsNotInitializedAndDoesNotRunInline` (C2; redcheck `c2-inline-after-stop`
→ `did not return NOT_INITIALIZED`) and the `EXPECT_EXIT` death test
`AForwarderWithABackendButNoThreadIsFatalNotAnAppThreadFallback` (M-7).
**The minors.** m-1: the present↔swap 1:1 comment now says it is a convention c1 upholds (Present is reached
only from a present record; ServerSwapEGLBuffers never calls Present), not structural. m-2: the coverage death
test names the mode — `EXPECT_EXIT(…, KilledBySignal(SIGABRT), …)` + the exact Fatal grep (the log flush is
pinned by `Log.cpp`'s per-write fflush before abort). m-3: `ServerLoop::Start` resets m_drained/m_parks/the C7
counters. m-4: the doorbell claim in the header and `Fatal{ApplyThreadJoinTimeout}` corrected — a Notify
suffices for the stop case (m_stopRequested is in the predicate and published before the ring); Kill is
load-bearing only for a predicate with nothing to see. m-6: `AssertConsumerMaskIsHonest` re-runs after step 4.
m-7: OnReadPixels' reply is written mid-apply and that is safe because the client reaches a slot only through
`appliedSeq` (published after LeaveApplier + the bracket drop), never the slot stamp — documented against
ReplySlot.h rather than reordered across the decoder boundary.
**item 12 (integrator, mid-round) — the last blocker between 14/21 and 21/21.** `MGPipeApplyResourceFlushRange`
(`PipeApply.cpp:1873`) faulted `record.Size != 0 && bytes == nullptr` as corruption; under an active transport
that is the NORMAL case (R-13.2: the flush carries no bytes, the covering subdata already staged them into the
server shadow). Guarded the fault with `&& Transport == Monolith` (a constexpr `true` in a non-disaggregated
build, so monolith codegen is unchanged); a genuinely-missing subdata is now caught more precisely downstream
by R-11's `Fatal{StageSnapshotTooNarrow}`. **Red once (executed on the joint):** dropping the `&& Monolith`
guard turned `integration-split` 21→14 and `DirectGLES.Split.PersistentCoherentMapScenario.AWrite…` aborts
`Subprocess aborted` (the exact c1-v2 §6 Fatal); restored, back to 21/21.
---
## The five codex verifier findings (all CONFIRMED; `v1-codex-verify.md`) — all fixed this round
- **C2** — fixed with M-7 (above). Control: the deterministic post-Stop case; the verifier's latch harness is
cited as the race-closure evidence (the fix works by mutual exclusion, so a shipped latch cannot straddle
the pre/post-fix line — I ship the deterministic half and cite the harness).
- **C6** — `ActiveBackendFormatCaps()` (new, `#if MOBILEGL_BUILD_DISAGGREGATED`) returns the server's own
backend cache under split, the process global otherwise; the seven reads (Utils.cpp ×5,
ClampSamplesToBackendSupport ×2) route through it, each `#if`-guarded so the pull build is byte-identical
(G1 confirms). Control `TheServerFormatCapsAccessorReadsTheServersOwnBackendNotTheGlobal` (pointer identity:
the accessor returns `&server->GetFormatCapabilities()`, not the global's); redcheck `c6-accessor-reads-global`
→ `returned the process global's cache`. c1 owes nothing beyond routing through the forwarders it already
owes. The wrong *value* is joint-only (needs c1's BackendObject_Remote linked), as the verifier said.
- **C7 / ID-54** — `ServerMakeEGLCurrent` binds natively once per (dpy,draw,read,ctx) tuple, treats an
identical repeat as a no-op (and skips the R-12 republish), and RECORDS a client release-current without
forwarding it (the context is held for life). `NativeBindCount`/`ClientReleaseCount` diagnostics added. The
comment was NOT struck (charter §2 stands). Control: the pure decision
`MakeCurrentClassifiesRepeatAndReleaseWithoutRebinding`; the instrumented native-bind COUNT is a joint-lane
control (needs a real EGL context).
- **C9** — the redcheck runner now carries an `expected` regex per perturbation and accepts a control ONLY when
it went red AND that regex matched; a **C9 META-CONTROL** asserts the runner rejects a stubbed
`(8, "unrelated fixture failure")`. Run: META-CONTROL **PASS**, all **14** perturbations red for their own
reason, `P5_V1_REDCHECK_ALL_WENT_RED`.
- **C10** — the park tests arm on `RingControl::consumerParked` (set only inside the blocking Park), not
`ParkCount()`. New fixture `WaitUntilTrulyParked()`; the three park cases use it. Redcheck
`c10-wait-never-blocks` (replace the Wait with `true`) → `never entered the blocking park`.
---
## The M-2 cascade (why the milestone briefly regressed, and the two fixes it forced)
M-2 is correct and required, but it removed a crutch: with `liveHostBase()` reading the server shadow instead of
the client's `MappedData()`, the reduced-path VBO rendered a **shifted/empty** store (TriangleScenario's interior
came back blue, not green — `aColor` read one float early). Two real gaps that inproc-reading-`MappedData` had
masked, both now fixed:
1. **m-5's null was too broad** (`455b475c`): the generation-reset block runs on a twin's FIRST ensure
(generation starts mismatched), and my first m-5 cut nulled a `hostBytes` a subdata had *just* staged in the
same generation. `HasShadow` discriminates freed-on-context-loss from live-just-staged.
2. **the twin is lazy** (`c9d84e33`): `Ops_H_Create` is a no-op (D-A2), so a buffer's twin is minted at the
first DRAW — *after* its `resource_subdata`. Under monolith that is fine (`MappedData` is the source); under
split the subdata found no twin, returned early, and the bytes were lost. So under an active transport a
subdata that finds no twin now MINTS one (`GetOrCreateBufferResourceForHandle`) to stage into. Monolith keeps
the lazy twin.
Diagnosed by instrumentation, not assertion (`p5-v1-joint2-tri.log`: `Ops_H_SubData bytes=0x… (non-null)` then
`ensure hostBase=(nil) hasShadow=0`).
---
## M-5 triage — the joint inproc census, by family, one probe each
Census on the round-2 joint (`MOBILEGL_TRANSPORT=inproc ctest -L integration-gpu`, `p5-v1-joint2-inproc.log`):
**575 passed / 183 skipped / 551 subprocess-aborted / 23 failed / 0 SEGFAULT** (round 1 was
428/185/506/28/**2**). The 551 aborts are the class-C `Fatal{UnmigratedVerb}` slots the reduced path does not
serve (BRIEF §4). The 23 wrong-answer failures — none is v1's; the reduced-path lane is 21/21:
| family | count | probe (one line) | owner / class |
|---|---|---|---|
| `LayeredAttachmentShapeScenario` (3D / cubemap-array attachments) | 12 (6 GLES + 6 VK) | `…:507 Failure`, no Fatal — wrong pixels, ran the split path | reduced-path-by-design: layered framebuffer attachment is P4b/P7, not the six verbs. c1 emit + shared backend |
| `DepthStencilReadbackMatrixScenario.GetTexImageReadsAPackedDepthStencilTexture` | 3 | `…:530 Failure`, no Fatal — wrong equality | get_texture_image of a PACKED depth/stencil format; not the E2 tight-RGBA8 read. Shared backend readback conversion / c1 emit |
| `PrimitivesGeneratedNoXfbScenario` (+PrimGenReroute) | 3 | **passes standalone** (`p5-v1-probe-primgen` rc=0) | flaky under `-j 6` — an XFB/query scenario contended between concurrent inproc processes, not a deterministic split defect |
| `HandleRecycleScenario.AFramebufferAtARecycledAddress…` | 3 | **passes standalone** (`p5-v1-probe-handlerecyc` rc=0) | flaky under `-j 6` (same shape); the framebuffer handle-recycle family is c1/shared, not v1 |
| `TextureParamsWithoutASamplerViewScenario` (attachment-only swizzle) | 1 | `…:415 Failure`, no Fatal | set_texture_params swizzle; c1 emit + shared backend |
| `P4aFinalFixScenario` (renderbuffer+framebuffer deleted) | 1 | `…:420` draw-after-delete reads black, no Fatal | P4a framebuffer/renderbuffer deletion debt; c1/shared |
None aborts (no Fatal), so all ran the split path; the six-verb reduced path is not among them. §8's round-1
"what passes" list is corrected below.
---
## Report corrections (codex "claims not supported")
- The round-1 inproc census is **428 / 185 / 506 / 28 +2 SEGFAULT = 1149**; the two SEGFAULTs were
`DepthReadbackHonoursThePackPixelStoreParameters` (both backends) — ID-49's shape, now fixed (round-2 census
0 SEGFAULT).
- The 506 (round-1) aborts are attributed to class-C **by one probed example**, not per-abort; stated as such.
- The `VERB_BARRIER=0` / `STRICT_ERRORS=1` failure NAMES come from the MobileGL log FILES (`MGLOG_F` →
stdout + file, not ctest's gtest capture), cited as such; ctest logs hold no `Fatal{` lines.
- "No 0xDD reached a draw" is now ESTABLISHED (not inferred): M-2 makes the server shadow the draw's only base,
and the joint reduced-path lane is 21/21 under `MOBILEGL_IPC_AUDIT=1`.
- "The thread really PARKED first" now rests on `consumerParked` (set inside the blocking Park), not on
`ParkCount()` which increments before the wait (C10).
- §8's "what passes … HandleRecycle.*" was wrong; corrected in the M-5 table (HandleRecycle passes standalone,
flakes under -j).
---
## The four self-tests (final head `c9d84e33`, `p5-v1-gate.sh`, log `p5-v1-r2-gaterun2.log`)
| | pull | push | verify | split |
|---|---|---|---|---|
| build | rc=0 | rc=0 | rc=0 | rc=0 |
| `ctest -L unit` | **1814/1814** | **1814/1814** | **1814/1814** | **1994, 1 known red** (`PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot` = c1's ID-31) |
- **G1** (pull vs `p5-before-libMobileGL.so`, marker `4595163c`): `.text 10806611 → 10806611 (+0)`,
`27814 → 27814: 0 added, 0 removed, 0 resized, 0 renamed`. `nm pull MG_Remote = 0`, split = 431. C6's
`#if MOBILEGL_BUILD_DISAGGREGATED` guards are what kept the pull build byte-identical.
- **Integration:** push `integration-gpu` monolith **1128/1128**; split `integration-gpu` monolith
**1149/1149** (the 7 ID-42 PersistentCoherentMap reds retired by the merged b1/s1 round 2).
- **G2** pull-vs-push 0 diff lines; **G14** 0 removed (40 added pull/push = wave 1's; 201 split-only = wave-1 +
v1's two suites). **Flake sweep** v1's suite ×100 under `-j 8`: 100% (18 cases).
- **Red-check** (`p5-v1-redcheck.py`, C9-hardened, log `p5-v1-redcheck.log`): META-CONTROL PASS,
`P5_V1_REDCHECK_ALL_WENT_RED`, 14 perturbations each red for its own asserted string.
## The joint (`p5/v1-joint2` = `c9d84e33` + `p5/c1@41992649` merged, + the two merge-time hunks)
- `git merge p5/c1` was CONFLICT-FREE. **`integration-split` under `inproc`: 21/21** (19 pass + 2 design skips —
the persistent-map counting-lane gate). **The first IPC frame renders**, and so do the whole VBO-triangle and
persistent-map families — a strict superset of c1's 14/21. Under `MOBILEGL_IPC_AUDIT=1`: also **21/21**.
- The two hunks the integrator applies at the real merge (they need c1's headers, so they are NOT on `p5/v1`):
the direct `MakeUnique<BackendObject_Remote>()` in `Init.cpp` and the `ScopedApplierEntry` bracket at the top
of `PipeApplier::ApplyOne`. Applied and verified on the joint scratch (`p5-v1-joint2-hunks.py`). The weak
`CreateRemoteBackendObject` placeholder is deleted on the scratch (static-archive link); on `p5/v1` it stays.
## What c1 must provide
1. The two merge hunks above are the integrator's, not c1's — c1's round 2 supplied the headers they need.
2. Route `BackendObject_Remote`'s `MakeEGLCurrent`/`InitCapabilities` through v1's `ServerMakeEGLCurrent` /
`ServerInitCapabilities` forwarders (the R-12 republish); c1 already owes this.
3. Nothing else for the reduced path — it is complete at 21/21.
## Ownership note
`PipeApply.cpp` (p1's) and `Utils.cpp`+`BackendObject_DirectGLES.cpp` (DirectGLES) were edited under the
integrator's explicit assignment: item-12 (the flush-range consumer half is v1's, coordinator message) and C6
(ID-52 ruling, "you own the conversion of those seven reads"). Both are `#if`-guarded to keep the pull build
byte-identical (G1 confirms) and monolith codegen unchanged.
## Debts
- The 23 non-reduced-path inproc wrong-answers (M-5 table) are P4b/P7 + c1/shared-backend, and two families flake
under `-j`; owners named, none v1's.
- ReadPixels' client-side scatter is c1's (ID-49); v1 reads tight and neutral.
- `OnDrawVbo` declines instancing/multi-draw/indirect (P8); `OnBlit` uses the bound framebuffers; `OnReadPixels`
has no PBO destination (b1's).
- The C7 native-bind COUNT and the C6 wrong-value are joint-lane controls (need a real EGL context / c1's object).
- `rsp` is a floor for non-verb records (needs p1's "enter without stamping" entry point).