Files
MobileGL/docs/Disaggregated/notes/p5/p5-results/c1-review-v3.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

647 lines
39 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.
# c1-review-v3 — adversarial review of package c1, round 3 (`p5/c1` head `5682f429`)
Reviewer: same-family (Claude), the client role. Worktree `~/w7/p5-c1`, reverted and clean at the
end; `p5/c1` is still `5682f429` and `p5/v1` is still `ca92308b` — nothing was committed to either.
Every perturbation below was run in that worktree and reverted. The joint was measured on a scratch
branch `p5/c1rev3-joint` created in that worktree and left there; it touches no package ref.
Temp files `~/w7/p5-c1rev3-*`.
**Counts: 8 CLOSED, 6 PARTIAL, 1 NOT CLOSED. New findings: 0 blockers, 5 majors, 4 minors.**
Round 3's *code* is good: I could not break a single one of the runtime fixes, and the joint with
v1's round 2 is the number the phase has been waiting for (`integration-split` 21/21, inproc census
0 segfaults). What round 3 did **not** do is gate several of those fixes. Five of the fourteen
claimed items ship no control at all, and three ship a control that cannot observe the production
code it names — measured, not argued: I deleted the production wiring of M2, M3, M4 and B1 and the
2030-case unit lane stayed **100% green** in every case. R-16 §13 is explicit that a gate without an
executed "I made it red once" line counts as unverified, and c1-v3.md claims one for B1 that does
not exist.
---
## 1. The items
### 1. B1 — the five by-address delete sites — **PARTIAL** (code CLOSED, gate NOT CLOSED)
**The routing is fixed.** `git grep -n '&MGPipeApply' 5682f429 -- MobileGL/MG_Impl/` returns
**only two comment lines** (`PipeFill.cpp:1530`, `:1537`) and no code. The five sites are
`&MGPipeRouteDeleteSamplerView` (`:1562`), `&MGPipeRouteResourceDestroy` (`:1583`, `:1624`),
`&MGPipeRouteDeleteSamplerState` (`:1661`), `&MGPipeRouteDeleteShaderState` (`:1682`), and
`EmitDeleteIfPublished`'s parameter is renamed `route`. Round 2's corroborating symptom is gone:
`MGPipeRouteDeleteSamplerView` / `DeleteShaderState` / `DeleteSamplerState` now have callers.
**The grep gate does not exist.** c1-v3.md §1 B1 says "Gate: the red-check refuses any
`&MGPipeApply` under `MG_Impl/` (grep, now 0)", and `PipeFill.cpp:1537` repeats it in shipped
source. I read all 272 lines of `~/w7/p5-c1-r3-redcheck.py`:
```
$ grep -n 'MGPipeApply\|grep\|MG_Impl' ~/w7/p5-c1-r3-redcheck.py
31:FILL = "MobileGL/MG_Impl/Pipe/PipeFill.cpp"
```
That is the only hit — a path constant. There is no grep, no gate, and **no B1 case**: the
runner's nine cases are B3, codex4, M2, M3, codex6, ID49, ID47, M8, ID47b. Nor is the gate in
`scripts/`, `CMakeLists.txt`, or `.github/workflows/test.yml` (its two `MGPipeApply` mentions are
an unrelated `nm` check at `:868`).
**The claimed red-once line was never run, and nothing catches the revert.** c1-v3 says "Red once:
revert one site to `&MGPipeApplyResourceDestroy`". I ran exactly that:
```
=== B1 one delete site reverted to &MGPipeApplyResourceDestroy ===
ctest -L unit: 100% tests passed, 0 tests failed out of 2030
*** NO TEST NAMES IT -- the lane stays 100% green ***
```
So round 2's fix requirement #1 ("plus a grep gate for `&MGPipeApply` under `MG_Impl/`, because the
next one will be missed the same way") is **not met**, and B3's new test — which round 2 called "the
gate that would have caught B1" — does not catch it, because B1 is a direct call in `PipeFill` that
never goes through the table B3 observes. → **new finding N-1**.
### 2. B3 / codex 9 — the client arm is observed — **CLOSED**
`PipeRouting.TheInstalledClientArmIsWireAndNotMonolithAndEveryRoutedRowMoved` installs the CLIENT
tables and counts cells that differ from `MGPipeMonolithScreen()/Context()/Escapes()`: 33 generated
+ 4 escapes, and `MGPipeInstalledArm() == kClientWire`. It reads the pointers back rather than
constructing them, so a dropped assignment reads *equal* and is caught.
c1's red-check drops `gMGPipeContext.SetVertexBuffers` and reports RED. **My own perturbation took
the half c1's did not** — an escape row:
```
=== B3e one ESCAPE row dropped from InstallClientWireTables ===
(gMGPipeRouteEscapes.ResourceRespecify commented out)
ctest -L unit: 99% tests passed, 1 tests failed out of 2030
RED PipeRouting.TheInstalledClientArmIsWireAndNotMonolithAndEveryRoutedRowMoved
```
Red on its own message. The fork control
`AClientWireRowWithNoSessionRefusesByNameRatherThanApplying` adds the behavioural half
(`Fatal{NoClientSession, "ResourceDestroy"}`, which a monolith adapter would not produce).
*Scope note (minor N-6):* the case asserts a **count**, not per-row identity, so a dropped row
combined with an accidentally-overwritten unrouted row still reads 33.
### 3. M1 / ID-53 — `Fatal{BarrierViolation, "<slot>"}` — **CLOSED** (for c1's half)
The check is `ClientSession.cpp:707`, reads `g_applyThreadInsideApplier`, and reports through
`MGLOG_F`. On c1's own head it is inert — `git grep 'ScopedApplierEntry'` finds only the
definitions in `ClientSession.h:132-136`, zero call sites — and c1 says so rather than claiming
otherwise. That is the honest statement, and c1 correctly assigns the arm to v1's `ApplyOne`.
**It is armed by v1's bracket and it is readable.** On my joint scratch branch with the bracket
applied, one split entry run by hand with a private log:
```
$ MOBILEGL_IPC_VERB_BARRIER=0 MOBILEGL_LOG_FILE_PATH=~/w7/p5-c1rev3-m1-barrier.log \
./MobileGLIntegrationTest --gtest_filter='ClearThenReadPixelsScenario.ClearWithNoDrawIsVisibleToDefaultFramebufferReadPixels'
--- private log: size=6926 ---
BarrierViolation lines in the FILE: 1
[09:35:50] [Linux MobileGLIntegra/FATAL]: MGPipe: Fatal{BarrierViolation, "SetTextureParams"} -
the apply thread is inside the applier while the GL thread is emitting. R-1 makes at most one of
them runnable, which is what keeps one process-wide gPipeInputs legal
```
With the barrier ON the same entry passes and the file holds no Fatal. So c1's choice of `MGLOG_F`
is vindicated: ID-53's E1 can read the string from the private file once j0's lane plumbing lands.
**Not c1's, but the integrator must see it:** the violation fires in the forked **pre-flight
child**, so `ScenarioFixture.h:111` skips the entry and the whole lane reads green (§5 below).
That is ID-62's N-1, still live on this joint, and assigned to j0.
**Placement point (codex 7).** c1 left the check at emission and argues the second check at the
first `gPipeInputs` write belongs to p1's `MGPipeValidateForVerb`. The file is p1's, so the
assignment is right; c1 marks it a design argument rather than asserting it. Accept.
### 4. M2 / codex 11 — status and exact extent — **PARTIAL**
Production is right: `EmitAndWait` gained `Uint64* replySizeOut`, and both the fast and bounce paths
call `RequireReadbackReplyComplete(status, replySize, tight)` with a named Fatal per mode —
`Fatal{ReplyError,"ReadPixels"}`, `Fatal{ReadbackDeclined,"ReadPixels"}`,
`Fatal{ReadbackReplyShort,"ReadPixels <got> < <expected>"}`. The bounce path checks **before** the
scatter, so a short reply never reaches the application pointer.
**The control drives the predicate, not the wiring.**
`RemoteReadback.AReplyIsScatteredOnlyWhenItIsOkAndExactlyTheReadsExtent` calls
`ReadbackReplyIsComplete(...)` directly. I deleted **both** `RequireReadbackReplyComplete(...)` call
sites from `EmitReadPixels` — the entire production wiring:
```
=== M2a both RequireReadbackReplyComplete CALLS deleted (call-site wiring) ===
ctest -L unit: 100% tests passed, 0 tests failed out of 2030
*** NO TEST NAMES IT ***
```
The verifier's §11 perturbation (post Status=OK with `DstSize - oneRowBytes` from the server sink
and require a named refusal) was not re-run by c1 and is not in the runner. → **N-3**.
### 5. M3 / codex 10 — one tight-size function — **PARTIAL**
**10a, the shared body: closed.** `EmitReadPixels` now computes `const Uint64 tight =
TightReadbackBytes(width, height, format, type);` and the test-facing `TightReadbackByteCount`
forwards to the same function, so a `+16` inside `TightReadbackBytes` moves both (c1's red-check
perturbs exactly that and reports RED).
**But codex 10's own confirm recipe still passes.** codex 10 said: "Change only production
`info.DstSize = tight` to `tight + 16`: `DstSizeIsTheTightExtentAndNeverThePackedOne` still passes."
That test asserts only on `TightReadbackByteCount(...)`; it never reaches the emitter. I ran the
recipe:
```
=== M3a production info.DstSize = tight + 16 (codex 10's OWN recipe) ===
ctest -L unit: 100% tests passed, 0 tests failed out of 2030
*** NO TEST NAMES IT ***
```
So the number the emitter actually puts on the wire is still unobserved; only the helper is. → **N-3**.
**10b, the capacity half: closed.** `session.RequireReadPixelsReplyFits(...)` is called at
`EmitTables.cpp:368`, before emission, with the tight extent. c1's `ID47b` control multiplies the
tight extent by 100000, drives the split lane with the init patch and observes
`Fatal{ReplyTooLarge` at the CLIENT (rc=-6, baseline restored green) — an actual oversized emission
attempt, which is what codex 10 asked for. I did not independently re-run the "delete the call"
variant; c1's account (the abort moves to the server's `Post`, so the client-side assertion goes
absent) is consistent with `ReplySlot.h`'s structure.
### 6. M4 / codex 5 — ERROR is not a decline — **PARTIAL**
**Scope is right.** The reply-owning rows are the `kReplySlot` set in `generated/PipeWire.inc`:
`ResourceCreate(2)`, `ResourceRespecify(3)`, `MapPersistent(5)`, `SetTextureParams(47)`,
`ResourceSubData(48)`, `ResourceReadback(52)`, `ReadPixels(58)`. The two escapes that own a slot
(`ResourceRespecify`, `MapPersistent`) now abort `Fatal{ReplyError, "resource_respecify"}` /
`"map_persistent"` on `status == 2`; `ResourceFlushRange` and `CreateShaderState` own no slot and
pass `nullptr` for status, so "the two escapes" is the correct set.
`Wire_ResourceReadback` forwards status into `MGPipePostReply` and the mailbox aborts — also correct.
**`SessionWait::ShutDown`: resolved by making it DECLINED.** `ClientSession.cpp` now sets
`*statusOut = kStatusDeclined` on the dead-doorbell arm, so the "teardown legitimately reaches
here" comment is true for the acceptance rows rather than contradicted a frame later.
**The escape rule has no control.** `PipeRouting.AnErrorStatusIsNotFoldedIntoAcceptedOrRefused`
drives `MGPipeTakeReplyBool` over a hand-minted slot; it never invokes either escape. I deleted
**both** `if (status == 2)` blocks — the whole of M4's change:
```
############ (1) M4 escape half: delete both ERROR->Fatal blocks ############
ctest -L unit: 100% tests passed, 0 tests failed out of 2038
*** NO TEST NAMES IT -- the escape ERROR rule has no control ***
```
(2038 rather than 2030 because this ran on the joint branch, which adds v1's `ServerLoopTest`.)
→ **N-4**.
**New, from M4's own change (minor N-7):** because ShutDown now answers DECLINED, a teardown that
races a readback takes `RequireReadbackReplyComplete`'s decline arm and aborts
`Fatal{ReadbackDeclined, "ReadPixels"}`. M4 restored the comment's promise for the acceptance rows
and broke it for the readback row.
### 7. M5 — `Fatal{InitialBytesNotCarried}` role-aware — **CLOSED** (code), no control
Both split-only branches in `PipeFill.cpp` (`:757` respecify, `:877` flush follow-up) now also
require `!MG_Remote::Client::RunsAsTheServerRole()`. `RunsAsTheServerRole()` was moved out of
`WireTables.cpp`'s anonymous namespace and declared in `WireTables.h`, so `PipeFill` needs no server
header — and the non-disaggregated builds are unaffected (`build-linux`/`build-push`/`build-verify`
unit lanes 1816/1816 each, and G1 `.text +0`).
**The server never reaches it on the joint:** `Fatal{InitialBytesNotCarried}` appears **0 times** in
my joint inproc census (1149 entries), and the split lane is 21/21.
No red-once line and no control — see N-5.
### 8. M6 / codex 8 — the red-check runner — **CLOSED**
I executed all three perturbations the charter names, against a **stubbed copy**
(`~/w7/p5-c1rev3-probe-a.py`) whose `apply`/`restore`/`build`/`run` are overridden, so the real tree
was never touched. The runner's verdict is `went_red = expect in out` where `expect` is a
case-specific `[ FAILED ] Suite.Name` or a named `Fatal{...}`; `rc` is printed but not used.
| perturbation | required | measured |
|---|---|---|
| every case returns an UNRELATED failure (`"UNRELATED_FAILURE\nSegmentation fault"`, rc −11) | must NOT count as red | **9 × STILL-GREEN, 0 RED**, EXIT=1 |
| every case returns an ALL-GREEN gtest run (`[ PASSED ] 1 test.`, rc 0) | must exit non-zero | **9 × STILL-GREEN, 0 RED**, EXIT=1 |
| build fails after preflight | HARNESS failure, never a red | **9 × HARNESS-FAIL, 0 RED**, EXIT=1 |
Round 2's runner scored 20/20 RED and exit 0 on the first of those. All four of M6's sub-claims
hold: own string; build break is a harness failure; restore + rebuild + re-baseline covers the two
integration cases (`apply([(INIT, None, None)])` before the baseline run and restore after);
`sys.exit(1)` when `not_red or harness_failures`.
*The runner is still an untracked file outside the repo*, so none of this runs in CI — the same
structural point as N-1.
### 9. M7 — what arms the lane — **CLOSED**
`WireTables.h:62-70` now states the truth: the harness arms on the encoder's `EmitSeq`
(`Harness/SplitRuntimePeek.cpp:50`, `Harness/ScenarioFixture.h:85`), the counter is the routed
ordinal, and re-pointing the harness is t1's file. Verified by grep — the only readers of
`ClientWireRecordsEmitted()` are `PipeFill.cpp:766` and `:768` (its own `InitialBytesNotCarried`
self-check) plus the definition and declaration:
```
5682f429:MobileGL/MG_Impl/Pipe/PipeFill.cpp:766: const Uint64 before = MG_Remote::Client::ClientWireRecordsEmitted();
5682f429:MobileGL/MG_Impl/Pipe/PipeFill.cpp:768: if (MG_Remote::Client::ClientWireRecordsEmitted() == before) {
5682f429:MobileGL/MG_Remote/Client/WireTables.cpp:591: Uint64 ClientWireRecordsEmitted() { return g_emitted; }
5682f429:MobileGL/MG_Remote/Client/WireTables.h:70: Uint64 ClientWireRecordsEmitted();
```
Correcting a false claim in a header rather than asserting a fact c1 cannot make true is the right
call.
### 10. M8 / ID-57 / codex 2 — the pack-PBO destination — **CLOSED on behaviour, PARTIAL on the control**
**ID-57's own control passes.** The ruling names it exactly: "a bound 64-byte pack PBO and an
offset-16 read under inproc dies with that string". c1 did not run it — its red-check instead
replaces the probe with `if (true)`, which is R-16's "a probe may not be armed against a stub"
(§13). I wrote the real control (a temporary `TEST_F` in `ClearThenReadPixelsScenario.cpp`, since
reverted) binding a real 64-byte `GL_PIXEL_PACK_BUFFER` and reading 1×1 RGBA8 at offset 16:
```
############ inproc (SPLIT) ############
rc = -6 (SIGABRT)
[ RUN ] ClearThenReadPixelsScenario.ReviewerPackPboOffsetRead
[reviewer] PACK PBO bound (64 bytes); calling glReadPixels at offset 16
Fatal lines in the private log: 1
[09:39:08] [Linux MobileGLIntegra/FATAL]: MGPipe: Fatal{UnmigratedVerb, "ReadPixels+PACK_BUFFER"}
```
The `[reviewer] glReadPixels RETURNED` line never prints, so the refusal precedes the emission and
the offset is never dereferenced — codex 2's SIGSEGV at address 16 is gone.
**The monolith arm passes too** — the second half of ID-57's control ("the same call under monolith
reads back through the buffer as today"). Same probe, `MOBILEGL_TRANSPORT=monolith`, after a clear
to opaque green:
```
############ (2) ID-57 monolith arm ############
rc = 0
[ OK ] ClearThenReadPixelsScenario.ReviewerPackPboOffsetReadMonolith (1 ms)
[reviewer] monolith PBO bytes at offset 16: 0 255 0 255
```
(0,255,0,255) came back **through** the pack buffer at offset 16, so the monolith path is
untouched — as G1's `.text +0` and the split-only emit table already implied, now measured.
The residual gap is that c1's *shipped* control cannot distinguish "the probe expression is right"
from "the Fatal is reachable": if `GetBufferBindingSlot(BufferTarget::PixelPack).GetBoundObject()`
were wrong, `if (true)` would still be red. → **N-5 (grouped)**.
### 11. codex 6, codex 4, codex 12
**codex 6 — `PACK_SKIP_IMAGES` ignored for a 2-D read — CLOSED.** Both
`ReadbackPackStateIsTight` (the `SkipImages` term is gone) and
`ScatterTightReadbackIntoPackState` (the `SkipImages * imageRows * strideBytes` offset is gone)
stop consulting the image-level parameters, matching `honorPackImageParams=false` at
`DirectGLES.cpp:10905`. `RemoteReadback.PackSkipImagesIsIgnoredForATwoDimensionalRead` asserts a
4×3 RGBA8 read with `SKIP_IMAGES=1, IMAGE_HEIGHT=3` lands at bytes 0–47, that 48–95 keep the
`0xEE` sentinel, and that the fast path takes it. The runner's red-once re-adds the term and the
case goes RED.
**codex 4 — teardown refuses by name — CLOSED for the routed rows.** `UninstallClientWireTables()`
now raises `g_clientTablesUninstalled` instead of reinstalling the monolith adapters;
`RequireSession` reads it first and aborts `Fatal{ClientTablesUninstalled, "<row>"}` before any ring
access; `ReinstallMonolithAfterTeardown()` runs at the very end of **both** Stop paths (the
`!m_started` early return and the full path), which also closes minor m2.
`PipeRouting.ARoutedCallDuringTeardownRefusesByNameNotRunsTheApplier` drives it and the runner's
red-once reverts Uninstall to `MGPipeInstallMonolithTables()` → RED.
**But the five class-B verbs are not covered** → **N-2 (major)**, below.
**codex 12 — caps adopted on every make-current — NOT CLOSED as a gate.**
`BackendObject_Remote::MakeEGLCurrent` now pumps the control plane and calls
`RefreshFormatCapabilities()` after a successful non-release make-current, which is the right shape
and is correctly skipped for a release-current. But there is **no control anywhere**:
`git grep -l 'MakeEGLCurrent' 5682f429 -- MobileGL/MG_Test/ MobileGL/MG_IntegrationTest/` returns
**nothing**, the runner has no codex-12 case, and c1-v3.md §1 codex 12 ships **no "Red once" line** —
it only restates the verifier's before-measurement (`gen 3→3`). Under R-16 §13's fourth bullet that
is an unverified gate. → **N-5 (grouped)**.
### 12. The six minors, and m1 deferred
- **m2** — closed by codex 4 (above), including the failed-`Start` early-return path.
- **m6** — the `ImageHeight` half is closed by codex 6 (it is no longer consulted). The
`0 < ROW_LENGTH < width` overlap is now a written comment saying the client reproduces GL 8.4.4
verbatim rather than clamping, and noting the fast path rejects any `ROW_LENGTH != width`. That
is exactly the "say so" the round-2 review asked for. Accept.
- **m3, m4, m5** — left as documented debts with reasons. Accept; all three are coverage/ownership
statements, not code defects, and m5 (`gen_pipe.py` is c0's) is correctly outside R-17's grant.
- **m1 (the four escape-row generated thunks point at null members) — deferring it is a judgment
the integrator should accept.** What m1 is: `MGP_ResourceRespecify`, `MGP_MapPersistent`,
`MGP_ResourceFlushRange`, `MGP_CreateShaderState` in `generated/PipeThunks.inc` call through a
null `gMGPipeScreen`/`gMGPipeContext` member, and `PipeCatalogueTest` *pins* those rows null —
it pins the trap rather than closing it. The cost of the alternative is real and c1 states it
correctly: installing a `Fatal{RowIsAnEscape}` marker makes those cells non-null, which moves
`PipeCatalogueTest`'s 33/4/37 partition — a gate the integrator reads — for code that has **zero
callers** (the routes go through `gMGPipeRouteEscapes`, and the catalogue test pins
`escapesInstalled == 4`). Trading a read gate's arithmetic for a diagnostic on dead code is a bad
trade at the end of a phase. c1 marks it rather than refuting it and says precisely what would
close it. **Accept the deferral**; it belongs in the P6 generator pass with the catalogue-test
update, not in a fix round.
### 13. The `BlobMissing` classification — **CLOSED**
`set_dynamic_state` carries an OPTIONAL blob. `EmitRenderState` sends a version-only update with
`ChunkMask == 0` and zero bytes; the round-2 generic `MGP_WIRE_BLOB` wrapper staged it through
`StageRequired`, which Fatals on a zero count. `Wire_SetDynamicState` is now hand-written and uses
`StageOptional`, like the two sub-data rows; the decoder already took the `ChunkMask == 0` arm.
The classification c1 gives is correct: **it was a c1 round-2 regression** that turned a legal
header-only update into a blob-shape abort and **masked the honest class-C death**.
Confirmed on my joint census: `grep -c 'BlobMissing'` over all 1149 entries → **0**. And the probed
line, which is the answer to "because the slot dies as `Fatal{UnmigratedVerb}` (R-4)":
```
=== CrossFrameBufferScenario.*
rc=134 first Fatal: Fatal{UnmigratedVerb, "DrawElements"}
```
So the slot now dies at its honest R-4 death, not a blob-shape complaint. c1 is also right that this
is not unit-red-checkable without a session plus an empty-chunk draw; the census probe is the
appropriate evidence and c1 says so.
### 14. The joint numbers — measured, §5 below
### 15. G1 / G5 / generators / push lane — **CLOSED, every number exact**
- **G1**: `.text 10806611 -> 10806611 (+0, +0.000%)`, `.data/.bss/.rodata +0`, total
`17227007 -> 17227007 (+0)`, `27814 -> 27814 defined symbols: 0 added, 0 removed, 0 resized,
0 renamed`, rc 0. Corroboration: `nm --defined-only build-linux/libMobileGL.so | grep -ic
MG_Remote` → **0**, `PipeRoute` → **0**, `build-split` → **606**. Every round-3 change is
push/disaggregated-only.
- **G5**: `p3a_untouched_regions.sh ff2994d9 HEAD` rc 0 ("the 11 pool / deferred-release / ring /
flush-drain functions are byte-identical"); `p4a_untouched_regions.sh` rc 0 ("the 17 … regions are
byte-identical"). Both print the pre-existing ID-41 `FlushPendingRangesFrom` note, which is
explicitly "not a verdict in either direction". No worktree writes.
- **Generators**: `gen_pipe.py --check` rc 0 "generated files are up to date"; `--self-test` rc 0,
**9** negative-control trips + positive control; `gen_pipe_field_ownership.py --check` rc 0;
`check_include_closure.py` rc 0, **4** probes / **0** problems.
- **`ctest -L unit`** re-run by me on all five build dirs: `build-split` **2030/2030**,
`build-verify-split` **2030/2030**, `build-push` **1816/1816**, `build-verify` **1816/1816**,
`build-linux` **1816/1816**. 100% in every lane.
- **push `integration-gpu`**: `MOBILEGL_TRANSPORT=monolith ctest -L integration-gpu -j 8` on
`build-push` → **"100% tests passed, 0 tests failed out of 1128"**, name-for-name.
- **G2/G14 names**: baseline `~/w7/p5-before-ctest-names.txt` **2902**; push **2944**; split
**3179**; push-vs-baseline **0 removed / 42 added**; split-vs-push **0 removed / 235 added**, of
which **21** are `DirectGLES.Split.`. Exact.
*Methodology note (minor N-9):* the `ctest -N | grep -oP '(?<=: ).*'` recipe also matches ctest's
own `Total Tests: N` footer, injecting one spurious name per list (raw 2945/3180). c1's saved
lists have the same artefact; it cancels out of every delta, but the recipe should gain
`grep -v '^Total Tests'`.
---
## 2. New findings, most severe first
### N-1 — major — B1's fix ships no gate and no executed control, and both the report and the shipped source claim one that does not exist
**File:line.** `~/w7/p5-c1-r3-redcheck.py` (whole file, no `&MGPipeApply` grep and no B1 case);
`MobileGL/MG_Impl/Pipe/PipeFill.cpp:1537` ("the grep gate scripts/../p5-c1 redcheck refuses any
`&MGPipeApply` under MG_Impl/"); `c1-v3.md` §1 B1.
**Violates.** R-16 §13 bullet 4 (a gate with no executed red-once line is unverified); ID-58's fix
list item 1; R-17/R-4.
**Claim.** The routing fix is correct but ungated. Nothing in the repo or in the harness refuses
`&MGPipeApply` under `MG_Impl/`, and no test fails when a site is reverted.
**Failure scenario.** The next entry point taken by address — the same shape that produced B1 —
lands on the applier on the GL thread under split and on a silent no-op under spawn, and every lane
stays green exactly as it did in round 2. Measured: reverting the texture site to
`&MGPipeApplyResourceDestroy` leaves `ctest -L unit` at 2030/2030.
**How to confirm.** The perturbation above; and `grep -c 'MGPipeApply' ~/w7/p5-c1-r3-redcheck.py`.
**Fix.** Put the grep in the repo, not in an untracked script — a CMake/CTest case or a line in
`.github/workflows/test.yml` next to the existing `nm` check — and correct `PipeFill.cpp:1537`.
### N-2 — major — codex 4's teardown refusal does not cover the five class-B verbs, so the use-after-free window it was written for is still open on half the table
**File:line.** `MobileGL/MG_Remote/Client/EmitTables.cpp:119` (`RequireSession`, a *second*
function in a *different* TU); `MobileGL/MG_Remote/Client/WireTables.cpp:88`
(`g_clientTablesUninstalled`, in that file's anonymous namespace) and `:97` (the only check);
`MobileGL/MG_Remote/Client/ClientSession.cpp:578-668`.
**Violates.** R-4; CONTRACT §4 table 3's teardown order.
**Claim.** `EmitTables.cpp` has its own `RequireSession` that only checks
`ClientSession::Active() == nullptr`. It cannot see `g_clientTablesUninstalled`. `Stop()` clears
`g_active` only at the very end (`ClientSession.cpp:664`), after the drain, `Shutdown()`, the join,
and after `m_producer.Detach()` / `m_shm.Close()` / the transport resets have freed the rings.
**Failure scenario.** A `Clear`, `DrawArrays`, `BlitFramebuffer`, `ReadPixels` or `Present` arriving
during that window gets a live `ClientSession&` and proceeds into `EmitAndWait` on rings being
freed — a use-after-free, and precisely the window codex 4 named, left open on the class-B half
while the routed half now refuses by name.
**How to confirm.** Mirror `ARoutedCallDuringTeardownRefusesByNameNotRunsTheApplier` for a class-B
slot: install the tables, `UninstallClientWireTables()`, then drive the `Clear` emit slot; require
`Fatal{ClientTablesUninstalled, "Clear"}`. Today it will not abort.
**Fix.** Give the flag a single owner both TUs read (declare it beside `RunsAsTheServerRole()` in
`WireTables.h`, or move the check into a shared `RequireSession`).
### N-3 — major — M2's and M3's production wiring is unobserved; deleting it leaves the 2030-case lane 100% green
**File:line.** `MobileGL/MG_Remote/Client/EmitTables.cpp:391` and `:403`
(the two `RequireReadbackReplyComplete` calls); `:356` (`info.DstSize = tight`);
`MobileGL/MG_Test/Wire/RemoteClientTest.cpp` (`AReplyIsScatteredOnlyWhenItIsOkAndExactlyTheReadsExtent`,
`DstSizeIsTheTightExtentAndNeverThePackedOne`).
**Violates.** R-16 §13 bullets 1 and 4; ID-58's fix list item 4.
**Claim.** Both new readback rules are tested as **pure predicates**. Nothing observes that the
emitter calls them, or that the number it puts in `info.DstSize` is the tight extent.
**Failure scenario.** Measured, twice: deleting both `RequireReadbackReplyComplete(...)` calls →
2030/2030 green; `info.DstSize = tight + 16` (codex 10's own recipe) → 2030/2030 green. A future
edit that drops either is invisible, which is the exact shape codex 10 and 11 were written about.
**How to confirm.** The two perturbations above.
**Fix.** One integration control that drives a real `ReadPixels` under inproc and observes the
emitted `MGPReadbackInfo::DstSize`, plus the verifier's §11 short-reply perturbation at the server
sink requiring `Fatal{ReadbackReplyShort`.
### N-4 — major — M4's escape rule has no control
**File:line.** `MobileGL/MG_Remote/Client/WireTables.cpp:404` and `:451`;
`MobileGL/MG_Test/Wire/RemoteClientTest.cpp` (`AnErrorStatusIsNotFoldedIntoAcceptedOrRefused`).
**Violates.** R-16 §13 bullets 1 and 4; R-5.
**Claim.** The only ERROR control mints a reply slot by hand and drives `MGPipeTakeReplyBool` —
it never invokes `Wire_Escape_ResourceRespecify` or `Wire_Escape_MapPersistent`, which are the two
rows M4 actually changed. The runner has no M4 case.
**Failure scenario.** Measured: deleting both `if (status == 2)` blocks leaves `ctest -L unit` at
**2038/2038, 0 failed**. A future edit that folds ERROR back into `false`/`nullptr` — the exact
defect codex 5 found — is invisible, and a transport fault again reads as "the server said no".
**How to confirm.** The perturbation above.
**Fix.** A fork control per escape: post Status=2 on the escape's own sequence through the installed
route and require `Fatal{ReplyError, "resource_respecify"}` / `"map_persistent"`.
### N-5 — major — five of round 3's fourteen items ship no executed red-once line, and three more arm their control against a stub
**Violates.** R-16 §13 bullets 3 ("a probe may not be armed against a stub; symbol existing ≠
implementation existing") and 4 ("a gate without that line is treated as unverified").
**The audit**, item by item:
| item | control shipped | red-once executed |
|---|---|---|
| B1 | **none** | **no** (claimed, absent — N-1) |
| B3 | yes (count) + fork | yes |
| M1 | none (inert on c1's head, admitted) | n/a — armed only by v1's bracket |
| M2 | predicate only | yes, but not the wiring (N-3) |
| M3 | helper only | yes, but not `info.DstSize` (N-3) |
| M4 | **none for the escapes** | **no** (N-4) |
| M5 | **none** | **no** |
| M6 | meta | yes (I re-executed all three) |
| M7 | n/a (a corrected comment) | n/a |
| M8 | forced `if (true)` probe | yes, but against a stub |
| codex 4 | yes | yes |
| codex 6 | yes | yes |
| codex 12 | **none anywhere** | **no** |
| BlobMissing | census probe only | no (stated) |
M1, M5 and the `BlobMissing` classification are defensible — c1 gives an honest reason for each and
the owner of the arm is another package. **B1, M4 and codex 12 are not**: all three are c1-owned,
all three are one fork test away, and all three are reported as fixed without the line the brief
requires.
### N-6 — minor — B3's case asserts a count, not identity
33 differing cells + 4 differing escapes. A dropped routed row combined with an accidentally
overwritten unrouted row still sums to 33. Asserting the routed rows by name (or asserting the
complement is unchanged) closes it. Not urgent — the realistic defect is a dropped row, which is
caught.
### N-7 — minor — M4's ShutDown→DECLINED makes a teardown that races a readback abort by a new name
`RequireReadbackReplyComplete`'s decline arm is a `Fatal{ReadbackDeclined, "ReadPixels"}`, so the
"teardown legitimately reaches here" comment is now true for the acceptance rows and false for
`ReadPixels`. Arguably right (a readback has no pixels to return and must not hand back stale
bytes), but it should be *said*: the comment at the ShutDown arm claims teardown no longer aborts.
### N-8 — minor — the joint merge with v1 round 2 is not conflict-free
`git merge p5/v1` from `5682f429` conflicts in `MobileGL/MG_Test/Wire/CMakeLists.txt`: c1 refactored
the three per-suite blocks into one `foreach (wiretest IN ITEMS RemoteClientTest ServerLoopTest
SessionHandshakeTest)` loop, and v1 independently appended its own `ServerLoopTest` block. The
resolution is trivial — take c1's loop, which already registers v1's target with identical include
dirs, link libraries, MSVC option and `LABELS unit`, so nothing is lost — but ID-59 recorded the
previous joint as conflict-free and ID-61's `jm` package assumes a clean merge order. Worth one
line in the merge runbook. (c1's own comment in that file predicts exactly this conflict.)
### N-9 — minor — the G2/G14 name recipe counts ctest's own footer
See item 15. Cancels out of every delta; fix the recipe.
---
## 3. Claims in `c1-v3.md` the code does not support
1. **§1 B1: "Gate: the red-check refuses any `&MGPipeApply` under `MG_Impl/` (grep, now 0)."**
**False.** There is no such grep in `~/w7/p5-c1-r3-redcheck.py`, nor anywhere in the repo. The
same false statement is shipped in source at `PipeFill.cpp:1537`. (N-1)
2. **§1 B1: "Red once: revert one site to `&MGPipeApplyResourceDestroy` → …"** The runner has no B1
case, so this line was never executed; and when I execute it, no test names it. (N-1)
3. **§Intro: "every gate ships its red-once line."** Five items ship none (B1, M4's escape half, M5,
codex 12, and the `BlobMissing` classification, the last stated openly). (N-5)
4. **§1 M3: the implication that one shared body closes codex 10a.** It closes the helper half;
codex 10's own recipe (`info.DstSize = tight + 16`) still passes. (N-3)
5. **§1 M8 / §2: the M8 control.** It forces the probe to `if (true)`; it does not bind a pack PBO,
so it cannot show the probe expression detects a real binding. The behaviour is nevertheless
correct — I verified it with the control ID-57 actually specified. (N-5)
6. **§4: "Joint `integration-split` under inproc … 14 / 21."** This is c1's **own head** plus the
`Init.cpp` one-liner, not a joint with v1 at all (`git merge-base --is-ancestor c9d84e33
5682f429` → NO). Labelling it "joint" is misleading; the real joint is 21/21 (§5). The seven were
correctly attributed to v1's flush seam.
7. **§1 codex 12: no red-once line, and no test anywhere names `MakeEGLCurrent`.** The change looks
right; it is unverified. (N-5)
Everything else in `c1-v3.md` that I checked was accurate, including the three §3 report
corrections (the 1128/1149/19/7 tangle, "after an ATTEMPTED caps pump", and
`ClientWireRecordsEmitted`), the census triage, and all of §4's self-test numbers.
---
## 4. Verified as claimed — do not re-run
- The five address-of sites, and the three `MGPipeRoute*` delete functions now having callers.
- The `kReplySlot` row set, and that `ResourceFlushRange` / `CreateShaderState` own no slot.
- `RunsAsTheServerRole()` moved to `WireTables.h`; `PipeFill` includes no server header.
- `ReinstallMonolithAfterTeardown()` on **both** Stop paths (closes m2).
- All of §4's self-tests: G1 0/0/0/0, five unit lanes, push 1128/1128, G5, the four generator
checks, G2/G14 name deltas. Every number exact (item 15).
---
## 5. The joint with v1's round 2 — measured
Scratch branch `p5/c1rev3-joint` = `5682f429` + `git merge p5/v1` (`ca92308b`, which contains v1
round 2 `c9d84e33`; the only commits on top are `c3e736a3`/`39292958`, already in c1) + the two
merge-time hunks (`Init.cpp` direct construction; `ScopedApplierEntry` at the top of
`PipeApplier::ApplyOne`) + the one-file conflict resolution of N-8. Joint head `45dff8b9`. Build
rc 0.
| lane | result |
|---|---|
| `integration-split`, inproc | **21 / 21** — "100% tests passed, 0 tests failed out of 21" (19 run + 2 `PersistentMapArm` counting entries skipped) |
| `integration-split`, inproc + `MOBILEGL_IPC_AUDIT=1` | **21 / 21**, same two skips |
| `integration-split`, inproc + `MOBILEGL_IPC_VERB_BARRIER=0` | **"100% tests passed"** — but **all 21 SKIPPED**, 0 aborted, 0 failed, `BarrierViolation` 0 times in ctest output |
| inproc `integration-gpu` census (1149) | **426 passed / 185 skipped / 511 aborted / 27 failed / 0 segfault**; "53% tests passed, 538 tests failed out of 1149" |
**c1's flush-seam attribution is confirmed:** the seven `PersistentCoherentMapScenario` entries that
were red on c1's own head are green once v1's `05bcb734` is in. **The three segfaults c1 saw are
gone** (v1's neutral-pack `61d6cd8e`): `PixelStoreSweepScenario` now exits rc 0 with no Fatal.
**The barrier-off lane is a false green** — ID-62's N-1, live here. The Fatal *does* fire, in the
forked pre-flight child (item 3 above), so `ScenarioFixture.h:111` skips every entry and ctest
reports success. It is j0's control defect, not c1's, and c1's string is the thing that makes the
attribution possible at all.
**First failure per family, probed with a private `MOBILEGL_LOG_FILE_PATH`:**
| family | first diagnostic | attribution |
|---|---|---|
| `CrossFrameBufferScenario` | `Fatal{UnmigratedVerb, "DrawElements"}` | class-C by design (CONTRACT §7) |
| `P4aFinalFixScenario` (6) | `Fatal{UnmigratedVerb, "GenerateMipmap"}` | class-C by design |
| `CopyImagePacked16Scenario` (6) | `Fatal{UnmigratedVerb, "CopyImageSubData"}` | class-C by design |
| `DepthStencilReadbackMatrixScenario` (3) | `Fatal{UnmigratedVerb, "CopyTexImage2D"}` + assertion at `:530` | class-C + P4b/P7 debt |
| `LayeredAttachmentShapeScenario` (14) | no Fatal; assertion at `LayeredAttachmentShapeScenario.cpp:507` | P4b/P7 debt (wrong-but-non-fatal) |
| `PixelStoreSweepScenario` | rc 0, no Fatal — **passes** | was v1's ID-49 segfault; fixed |
| `HandleRecycleScenario` (5) | assertion failure, no Fatal | shared/P4b debt — these are the entries the `BlobMissing` fix let run past `set_dynamic_state` |
| `PrimitivesGeneratedNoXfbScenario` (3) | assertion failure | P4b/P7 debt |
| `TextureParamsWithoutASamplerViewScenario` (1) | assertion failure | P4b/P7 debt |
`BlobMissing` **0**; `InitialBytesNotCarried` **0**; `BarrierViolation` 0 outside the deliberate
barrier-off probe. **None of the 538 is c1's.**
---
## 6. Verdict
**MERGEABLE**, with N-1/N-2/N-4 booked as follow-ups — **not** a package split.
ID-58's contingency is "if round 3's reviews still find a **blocker**, the client package is split".
I found none. Every runtime fix in round 3 survives adversarial perturbation:
- B1's routing is complete and the split lane no longer reaches the applier on the GL thread;
- B3's gate is real and goes red on its own message, including the escape half c1's own control
did not exercise;
- M1's string is armed by v1's bracket and readable from a private log — the thing ID-53 needs;
- M8 refuses a **real** bound pack PBO before any dereference, which is ID-57's own control and
which c1 never ran;
- the readback rules, the escape ERROR rule, the role gate and the teardown refusal are all
correct where I could drive them;
- M6's runner, the one thing round 2 got structurally wrong, is now sound under all three
perturbations codex 8 specified;
- and the joint is the number the phase was waiting for: **`integration-split` 21/21**, audit
21/21, census **0 segfaults**, nothing in the tail attributable to c1.
What is wrong is the **gating**, and it is wrong in a way that is cheap to fix and expensive to
leave: N-1 (B1 ungated, and claimed gated in both the report and shipped source), N-2 (the class-B
half of the teardown window), N-3/N-4 (production wiring for M2/M3/M4 that deletes clean).
Under R-16 §13 those are unverified gates, not unverified behaviour — I verified the behaviour
myself. Splitting the package would not help: the two halves ID-58 names (routing/catalogue vs
readback/mailbox) each contain some of these, and every one of them is a test-side addition of a few
lines, not a redesign.
**Required before the joint merge is called done (all small, all c1's):**
1. **N-1** — move the `&MGPipeApply` grep into the repo (a CTest case or a `test.yml` step beside
the existing `nm` check), add the B1 case to the runner, and correct the false sentence at
`PipeFill.cpp:1537` and in `c1-v3.md` §1 B1.
2. **N-2** — one owner for `g_clientTablesUninstalled` that `EmitTables.cpp`'s `RequireSession`
also reads, plus the class-B mirror of the teardown control.
3. **N-4** — a fork control per escape for the Status=2 rule.
4. **N-3** — an integration control that observes the emitted `DstSize` and the short-reply refusal.
5. **codex 12** — any control at all, or say plainly in the report that it is unverified.
**Accepted as judgment calls:** m1's deferral (§1.12), M1's and M5's missing controls (the arm
belongs to another package and c1 says so), codex 7's placement point going to p1, and the
`BlobMissing` classification resting on the census probe.
**For the integrator, not c1:** N-8 (the one-file merge conflict) and ID-62's N-1 (the barrier-off
lane is a false green because the pre-flight child dies — j0's).