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

746 lines
44 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-review-v2 — adversarial review of package v1, round 2 (`p5/v1` `3fb97cc5..c9d84e33`)
Reviewer: Claude (Opus 5). Perturbations executed and reverted in `~/w7/p5-v1` and in v1's joint
scratch `~/w7/p5-v1-joint` (branch `p5/v1-joint2`, `ba0dcdb9` = `c9d84e33` + `p5/c1@f280baf2`, which
is `41992649` plus the docs-only merge `c3e736a3` — code-identical to the head v1 reports). Submodule
links toggled `off` before every git command and `on` before every build. Both worktrees are clean at
the end: `p5-v1` at `c9d84e33` with an empty `git status`, `p5-v1-joint` at `ba0dcdb9` with exactly the
three merge-time hunks it carried when I started (`Init.cpp` 19, `PipeApplier.cpp` 5, `ServerLoop.cpp` 26
lines, byte-identical diffstat before and after). Nothing committed. `~/w7/pipe/build-*`, `~/w7/p5-c1`
and every other `~/w7/p5-*` worktree were never written to.
**Counts over the 16 charter items: 7 CLOSED (1, 3, 8, 11, 12, 13, 16), 7 PARTIAL (2, 5, 6, 7, 9, 10, 14), 1 NOT CLOSED (4 - M-3 has no gate anywhere; ID-41 inside it is closed); item 15 is a measurement, reported below. Two sub-items inside a PARTIAL are themselves NOT CLOSED: M-6 (item 7) and the round-2 census correction (item 14). Plus 9 new findings - 5 major, 4 minor.**
Temp files kept because they are cited:
`~/w7/p5-v1rev2-{reprobe,probe4,census,failnames,c7-run,revert-r2-dgles,restore-joint}.sh`,
`~/w7/p5-v1rev2-{myperturb,jointperturb,c2-latch,c2-prefix,c9-pipeline,c7-instr,c7-tuple,item12,patcher}.py`,
and the logs `~/w7/p5-v1rev2-{gaterun,redcheck,myperturb,jointperturb,joint-inproc,joint-isplit,joint-isplit-audit,joint-isplit-barrier0,barrier0-direct}.log`,
`~/w7/p5-v1rev2-c7-*.out`, `~/w7/p5-v1rev2-probe-*.out`.
---
## The scoreboard
| # | item | verdict |
|---|---|---|
| 1 | ID-49 server half | **CLOSED** (the size half is ungated — see N-5) |
| 2 | M-1 / codex 8, the R-11 production gate | **PARTIAL** — the copy half is gated end-to-end, the coverage half is gated nowhere |
| 3 | M-2 / codex 3, the audit becomes real | **CLOSED** — and proved by a real red, which round 1 could not get |
| 4 | M-3 / codex 4, the whole-store readers | **NOT CLOSED as a gate** (code correct, nothing fails when it is deleted); ID-41 **CLOSED** |
| 5 | m-5 / codex 5, `DropAll` and the freed base | **PARTIAL** — container control only; no ASan-shaped control exists |
| 6 | M-4 + codex 11, the affinity gate | **PARTIAL** — `off` is now a real control; codex 11's own fix has none |
| 7 | M-6 / M-7 | M-7 **CLOSED**; M-6 **NOT CLOSED as a gate** |
| 8 | C2, the post-cancellation hang | **CLOSED**, two-directionally |
| 9 | C6, the seven capability reads | **PARTIAL** — the accessor is gated, the seven call sites are not |
| 10 | C7 / ID-54 | **PARTIAL** — "never unbind" measured true; "bind once per tuple" not demonstrated |
| 11 | C9, the red-check runner | **CLOSED** |
| 12 | C10, the park tests | **CLOSED** |
| 13 | item 12 / ID-55, `resource_flush_range` | **CLOSED** |
| 14 | the minors and the report corrections | minors CLOSED; **the census correction is wrong again** |
| 15 | the joint numbers | measured; one new major (N-1) and one refuted triage row (N-2) |
| 16 | G1 | **CLOSED** |
---
## Item by item
### 1. ID-49, the server half — CLOSED
`ServerVerbSink::OnReadPixels` (`PipeApplier.cpp:174`, the ID-49 block at `:205-267`) computes
`tight = w * h * GetInputBytesPerPixel(...)` (`:216`), forces neutral pack state through
`MGPipeApplySetPixelPackState` (`:248`), reads into the tight scratch, restores the saved state and
posts `tight` bytes (`:265`). `MGPPixelPackState` has exactly one member (`MGPipeTypes.h:944-947`), so
the save/restore round-trip is complete — not a partial restore.
**Executed, v1's own line:** the three `DepthReadbackHonoursThePackPixelStoreParameters` entries on the
joint under inproc — round 1 had two of them SEGFAULT —
```
$ cd ~/w7/p5-v1-joint/build-split && MOBILEGL_TRANSPORT=inproc ctest -R DepthReadbackHonoursThePackPixelStoreParameters
100% tests passed, 0 tests failed out of 3
```
and the full inproc census has **0 SEGFAULT** (`~/w7/p5-v1rev2-joint-inproc.log`).
**My perturbation (`~/w7/p5-v1rev2-jointperturb.py id49-neutral-pack-not-forced`, on the joint):** delete
the `MGPipeApplySetPixelPackState(neutralPack)` line only.
```
integration-split: 100% tests passed, 0 tests failed out of 21
depthpack: 0% tests passed, 3 tests failed out of 3 ; SEGFAULT lines=2
DirectGLES.DepthStencilReadbackMatrixScenario.DepthReadbackHonoursThePackPixelStoreParameters (SEGFAULT)
DirectVulkan.DepthStencilReadbackMatrixScenario... (Failed)
DirectGLES.ForcedDepthStencilEmulation...DepthReadbackHonours... (SEGFAULT)
```
That is a genuine, executed red-once for the neutral-read half, end to end, reproducing exactly the
pre-fix shape. ID-49's server half is closed.
*But* (feeding N-5): the **tight-size** half has no control anywhere. Both
`id49-reply-uses-dstsize` (post `info.DstSize` instead of `tight`) and `id49-scratch-sized-by-dstsize`
(size the scratch from `info.DstSize`) leave the joint at 21/21, the depthpack family green, and v1's
19 unit cases green. That is not surprising — c1's `PackedReadbackBytes` is already the tight size, so
`tight == info.DstSize` on this head — but it means the `MGLOG_E_ONCE` mismatch branch (`:225`) and the
`bytesPerPixel == 0 → trust DstSize` fallback (`:216-219`) are unexercised dead paths, and a future c1
regression to a packed `DstSize` would be caught by nothing on v1's side.
### 2. M-1 / codex 8 — PARTIAL
**Half one, the copy, is now gated twice over.** The redcheck entry `m1-subdata-site-raw-offset` restores
`resource->hostBytes = static_cast<const Uint8*>(bytes) - offset;` at `Managers.cpp:2131-2133`:
```
=== m1-subdata-site-raw-offset (the exact rule-C violation R-11 exists to fix, at its production call site)
RED for its own reason (rc=8): kept a pointer into SEG_STAGE
```
and — this is new, and stronger than anything v1 claims — the **same perturbation takes the joint's
reduced-path lane from 21/21 to 11/21** (`~/w7/p5-v1rev2-jointperturb.log`):
```
integration-split: 52% tests passed, 10 tests failed out of 21
DirectGLES.Split.ClearThenReadPixelsScenario.ClearWithNoDrawIsVisibleToDefaultFramebufferReadPixels (Failed)
... TriangleScenario.AVboBackedTriangleReachesReadPixels (Failed) [and 8 more]
```
So R-11's copy is load-bearing in production, not only in a container test. This is the measurement
round 1 said would settle M-1/M-2 and it comes out in v1's favour.
**Half two, the coverage clamp, is gated nowhere.** The charter's second perturbation —
neuter `RequireStagedCoverageForPendingRanges` (`Managers.cpp:1053-1065`, loop body → `continue`) —
```
$ python3 ~/w7/p5-v1rev2-myperturb.py require-pending-coverage-neutered
=== require-pending-coverage-neutered (anchor count=1 in Managers.cpp)
ctest rc=0
*** NOTHING WENT RED ***
```
(over `ServerLoopTest|StagedShadowTest|StagedShadowProductionTest`, 19 cases), and on the joint
(`~/w7/p5-v1rev2-jointperturb.log`):
```
=== require-pending-coverage-neutered
integration-split: 100% tests passed, 0 tests failed out of 21
depthpack: 100% tests passed, 0 tests failed out of 3 ; SEGFAULT lines=0
```
**Answer to the charter's question:** restoring `hostBytes = raw - offset` goes red on
`StagedShadowProductionTest.SubDataThroughTheRealOpsTable…` with the string
`kept a pointer into SEG_STAGE`; neutering `RequireStagedCoverageForPendingRanges` goes red on
**nothing at all**, in the unit lane or on the joint. Round 1's M-1 is half closed.
### 3. M-2 / codex 3 — CLOSED
`liveHostBase()` (`Managers.cpp:2941-2960`) returns `resource->hostBytes` unconditionally under an
active transport; the `MappedData()` arm is `#if MOBILEGL_BUILD_DISAGGREGATED` + transport-guarded, so
monolith is untouched. **The audit is real, and I have the direct evidence round 1 lacked**: the
production copy's removal (item 2 above) turns the joint reduced-path lane red in 10 places. That is
exactly "the draw reads the shadow"; before M-2 the same perturbation was invisible (round 1's review
deleted the copy and all 1985 split unit cases stayed green).
Both gaps M-2 exposed are fixed and both are visible in the diff: `StagedShadowStore::HasShadow`
(`StagedShadow.h:136-146`) discriminating freed-on-context-loss from live-just-staged, and the lazy
twin minted at subdata (`Managers.cpp:2096-2110`, transport-guarded).
Monolith byte-identical, re-measured (`~/w7/p5-v1rev2-gaterun.log`):
`G2 pull-vs-push name diff lines: 0`; `G14 pull removed 0 / added 40`, `push removed 0 / added 40`;
`push integration-gpu: 100% tests passed, 0 tests failed out of 1128`;
`split/monolith integration-gpu: 100% tests passed, 0 tests failed out of 1149`.
### 4. M-3 / codex 4 — NOT CLOSED as a gate (the code is right; nothing can notice it going away)
Both whole-store readers do now go through the refusal: `Managers.cpp:3028-3029`
(`"pool_reuse_whole_store"`, before the whole-store `glBufferSubData`) and `:3104-3113`
(`"respecify_whole_store"`, called from both `RespecifyStorageWith` arms).
**My perturbation:** delete each one, then both.
```
=== m3-poolreuse-require-deleted ctest rc=0 *** NOTHING WENT RED ***
=== m3-respecify-require-deleted ctest rc=0 *** NOTHING WENT RED ***
=== m3-both-requires-deleted (joint)
integration-split: 100% tests passed, 0 tests failed out of 21
depthpack: 100% tests passed, 0 tests failed out of 3 ; SEGFAULT lines=0
```
v1-v2.md says "the production wiring is exercised end-to-end on the joint". It is not: the joint does
not move. The only red-once v1 offers for M-3 is `StagedShadowTest.ADrainOutsideTheStagedCoverageIsFatalByName`,
which perturbs `StagedShadowStore::RequireCoverage` — the class the case constructs. This is round 1's
M-1 shape recurring one level out.
**ID-41 — CLOSED.** Both G5 scripts pass in the worktree and `FlushPendingRangesFrom` hashes to the pin:
```
$ bash scripts/p3a_untouched_regions.sh ff2994d9 HEAD
172b022273db01b16e772d15b269ffcd797fe38c767f7354d83ce113a66040d0 FlushPendingRangesFrom
[p3a-untouched] the 11 pool / deferred-release / ring / flush-drain functions are byte-identical
$ bash scripts/p4a_untouched_regions.sh ff2994d9 HEAD
[p4a-untouched] the 17 ... regions are byte-identical between ff2994d9 and HEAD
```
Worth naming: `ShouldUseCaveatTextureFormat` is in p4a's pinned set and `Utils.cpp` is a file C6 edited
— the hash still matches, so C6 did not touch a pinned body.
### 5. m-5 / codex 5 — PARTIAL
`StagedShadowTest.HasShadowIsTrueAfterAdoptAndFalseAfterTheShadowIsDropped` asserts both directions and
is a real control for the *discriminator*. The **fix** — `if (!ServerStaged().HasShadow(resource)) resource->hostBytes = nullptr;`
at `Managers.cpp:2983-2985` — is gated by nothing:
```
=== m5-production-null-deleted ctest rc=0 *** NOTHING WENT RED *** (unit, 19 cases)
=== m5-production-null-deleted integration-split: 100% ... out of 21 (joint)
```
The charter asks for "the ASan-shaped control". There is none: no ASan build, no context-loss case, and
the shipped control cannot reach the freed base. codex 5 is fixed in source and unverified in behaviour.
### 6. M-4 + codex 11 — PARTIAL
**The `off` half is now a real control.** Deleting `if (std::strcmp(raw, "off") == 0) return 0;`
(`ServerLoop.cpp:86`) — the exact perturbation that stayed green in round 1 —
```
=== affinity-off-branch-deleted
ctest rc=8
RED: ServerLoopTest.TheAffinityStringResolvesToAMaskAndTheMaskIsLogged (Failed)
| ../MobileGL/MG_Test/Wire/ServerLoopTest.cpp:362: Failure
```
(`:362` is the new `EXPECT_EQ(log.find("is not `auto`, `off` or a number"), npos)`.) The explicit-mask
case passes and logs `RESOLVED mask 0x3`. Redcheck `resolved-mask-not-logged` is still red for its
own reason.
**codex 11's own fix is gated by nothing.** Replacing the `sched_getaffinity` read-back
(`ServerLoop.cpp:126-136`) with `return requested;`:
```
=== affinity-reports-requested ctest rc=0 *** NOTHING WENT RED ***
```
`ServerLoopTest.cpp:373` says *"Red once by making ApplyAffinity return `requested`"*. That is false on
any box whose cpuset is not trimmed — which is every box the suite runs on — and the comment's next
clause admits as much. This is the R-16 clause about a red-once line that was never executed.
### 7. M-6 and M-7
**M-7 — CLOSED.** Making the `!m_running && backendAlive` arm an inline fallback again:
```
=== m7-fatal-becomes-fallback
ctest rc=8
RED: ServerLoopTest.AForwarderWithABackendButNoThreadIsFatalNotAnAppThreadFallback (Failed)
| Expected: (log.find("Fatal{ApplyThreadNotRunning")) != (std::string::npos)
```
Which test dies: `AForwarderWithABackendButNoThreadIsFatalNotAnAppThreadFallback`, on the missing
`Fatal{ApplyThreadNotRunning` line in the log file (plus the `EXPECT_EXIT` signal assertion at `:774`).
**M-6 — NOT CLOSED as a gate.** The fix is the new `MG_Remote::Server::ServerLoopInstance().Stop();`
at `MG_Backend/Init.cpp:194`. Delete exactly that line:
```
=== m6-shutdown-stop-deleted (anchor count=1 in Init.cpp)
ctest rc=0
*** NOTHING WENT RED ***
```
`ServerLoopTest.StopWithoutAStartedThreadStillDropsThePrivateBackend` (`:786`) gates
`ServerLoop::Stop()`'s `!joinable` arm — which round 1 already had (the diff does not touch it) — not
the new call. `ShutdownSplitRoles` still has no test of any kind.
### 8. C2 — CLOSED, two-directionally
The shipped deterministic case plus redcheck `c2-inline-after-stop` (red on
`did not return NOT_INITIALIZED`). Beyond that I **replayed the verifier's latch harness** on the fixed
tree (`~/w7/p5-v1rev2-c2-latch.py`, latch at the same program point: after the `OnApplyThread()` test,
before any lock):
```
[ RUN ] ServerLoopVerifyC2.AControlRequestPostedAfterTheFinalCancellationPassReturnsNotInitialized
C2_ARM: the caller is past the running check and held
C2_STOP: Stop() returned in 0 ms; Running()=0
C2_RESULT: CALLER_RETURNED rc=1 (NOT_INITIALIZED=1)
[ OK ] ... (3 ms)
```
and the 19 shipped cases stay green with the latch compiled in but unarmed. Then, to prove the harness
is not vacuous, I restored the pre-fix shape (`~/w7/p5-v1rev2-c2-prefix.py`: the `m_running` check back
outside `m_controlMutex`, the clear back outside the cancellation-pass critical section) and ran the
same case:
```
C2_RESULT: CALLER_HUNG - no answer 30000 ms after the loop was joined
[ FAILED ] ServerLoopVerifyC2.... (30002 ms)
```
Both directions executed; both trees reverted. v1's own reasoning for shipping only the deterministic
half (the fix works by mutual exclusion, so a latch cannot sit inside the new critical section without
starving the apply thread's exit) is correct — a latch at the *fixed* check point would deadlock
`Stop()` into `Fatal{ApplyThreadJoinTimeout}`. The harness above is the honest replacement and it is
not shipped; v1 should take it or its shape.
### 9. C6 — PARTIAL
The seven reads are converted through `ActiveBackendFormatCaps()` (`Utils.h:15-27`, `Utils.cpp:39-51`),
each `#if MOBILEGL_BUILD_DISAGGREGATED`-guarded; the pull build never sees the symbol:
```
$ nm --defined-only ~/w7/p5-v1/build-linux/libMobileGL.so | grep -c ActiveBackendFormatCaps
0
```
The two-object control passes and redcheck `c6-accessor-reads-global` is red on
`returned the process global's cache`.
**But the routing is ungated.** Reverting ONE of the seven (the `HasCachedFormatCapability` pair,
`Utils.cpp:89-112`) back to `pActiveBackendObject`:
```
=== c6-one-callsite-reverted ctest rc=0 *** NOTHING WENT RED ***
```
The control gates the accessor, not the seven reads the ruling is about. That is codex 8's shape again,
transplanted: a test that would not notice the conversion being undone one site at a time. Mitigation:
G1 (`0 added / 0 removed`) and the `#else` arms make an accidental revert loud in review, not in CI.
C6 is also **not** the cause of any of the 23 inproc wrong answers — see item 15.
### 10. C7 / ID-54 — PARTIAL
`ClassifyEglMakeCurrent`'s release test is character-for-character `IsReleaseCurrentRequest`'s
(`BackendObject_DirectGLES.cpp:30-33`); the unit case
`MakeCurrentClassifiesRepeatAndReleaseWithoutRebinding` (`:829`) asserts all four arms of the pure
decision.
**The instrumented counts, measured (`~/w7/p5-v1rev2-c7-instr.py` + `c7-run.sh`, then reverted).** One
counter immediately before each native `eglMakeCurrent` (`DirectGLES.cpp:11925`, `:11964`) and one line
per `ApplyMakeCurrent` classification, same scenario, same binary:
| | monolith | inproc (split) |
|---|---|---|
| native `eglMakeCurrent` binds, per process | **2** | **2** |
| native `eglMakeCurrent(NO_CONTEXT)` releases | **1** | **0** |
| `ApplyMakeCurrent` actions | n/a | 1 × `NativeBind`, 1 × `ClientRelease`, **0 × `RepeatNoOp`** |
```
C7_ACTION pid=46515 0 tuple dpy=0x1 draw=0x1 read=0x1 ctx=0x1 | held=0 ...
C7_ACTION pid=46516 0 tuple dpy=0x1 draw=0x1 read=0x1 ctx=0x1 | held=0 ... <- the pre-flight fork
C7_ACTION pid=46515 2 tuple dpy=0x1 draw=(nil) read=(nil) ctx=(nil) | held=1 ...
2 C7_NATIVE_BIND pid=46515 ; 2 C7_NATIVE_BIND pid=46516 ; 0 C7_NATIVE_RELEASE
```
- **"Never unbind on a client release" — CONFIRMED.** The client's release-current is recorded and not
forwarded: 1 native release under monolith, 0 under split, with a `ClientRelease` classified.
- **"Bind once per tuple" — NOT DEMONSTRATED.** The native bind count per process is **unchanged** (2
under both transports). Only one of the two reaches `ServerMakeEGLCurrent`; the other comes from
`DirectGLES`'s own internal `MakeCurrent()` calls (`DirectGLES.cpp:11829`, `:11847`), which the
forwarder-level dedup cannot see. `RepeatNoOp` is classified **zero** times on the whole reduced-path
lane, in all three scenario families. So the verifier's C7 count ("two binds in one process →
`NATIVE_BIND #1`, `#2`") is still true at the DirectGLES layer after the fix, and ServerLoop.h:33-40's
"makes DirectGLES.cpp's six cache invalidations a one-off startup cost" is not established.
- ID-54 names three controls ("2 identical binds → 1 native bind"; "release → 0 native releases";
"bind after release, same tuple → 0 native binds"). **None of the three is shipped**, on `p5/v1` or
on the joint, and `NativeBindCount()`/`ClientReleaseCount()` have zero readers anywhere (N-6).
- The production wiring is ungated: making `ApplyMakeCurrent` ignore the classification entirely
(`c7-applymakecurrent-always-binds`) leaves all 19 cases green.
- See **N-3**: the cached tuple is never invalidated when the context or surface it names is destroyed.
### 11. C9 — CLOSED
Re-ran the shipped runner (`~/w7/p5-v1rev2-redcheck.log`): `C9 META-CONTROL … PASS`, **14 of 14**
perturbations `RED for its own reason`, `P5_V1_REDCHECK_ALL_WENT_RED`, exit 0.
The charter asks for the pipeline, not just `classify()`. `~/w7/p5-v1rev2-c9-pipeline.py` loads the
shipped runner as a module and stubs `build()`/`ctest()` so the real `main()` drives the real
patch/classify/report path:
```
A: every perturbed run returns an UNRELATED non-zero failure
main() returned 2, perturbed ctest calls=14
ALL_WENT_RED printed: False
=== FINDINGS
- stamp-removed: red, but not for its own reason (expected /StampVerbBoundary did not run/)
... [all 14]
B: every perturbed run stays GREEN
main() returned 2 ; ALL_WENT_RED printed: False ; [all 14] "stayed GREEN with the implementation broken"
worktree after the two scenarios (empty == clean): (clean)
```
Both halves of the charter's question answered: an unrelated failure does **not** count as red, and an
all-green sweep exits non-zero. Minor caveat in N-9.
### 12. C10 — CLOSED
`ServerFixture::WaitUntilTrulyParked()` polls `RingControl::consumerParked`, the flag `Doorbell::Wait`
sets inside its blocking section (`Doorbell.h:142`), and the three park-dependent cases plus the two new
ones use it. Redcheck `c10-wait-never-blocks` (the `:269` wait replaced by `true`):
```
=== c10-wait-never-blocks
RED for its own reason (rc=8): never entered the blocking park
```
### 13. item 12 / ID-55 — CLOSED
**Executed red-once, precisely the one the charter names** (`~/w7/p5-v1rev2-item12.py`: drop the
`&& MG_Config::Transport == Monolith` guard at `PipeApply.cpp:1885-1886`, nothing else):
```
integration-split with the guard dropped: 67% tests passed, 7 tests failed out of 21
DirectGLES.Split.PersistentCoherentMapScenario.TwoWritesThroughTheCoherentPointerEachReachTheirOwnDraw (Subprocess aborted)
... [all seven PersistentCoherentMapScenario entries, both lanes]
restored: build rc=0 ; 100% tests passed, 0 tests failed out of 21
```
21 → 14 → 21, and the seven are exactly the seven v1 names. Under monolith the guard is
`MG_Config::Transport == Monolith` with `Transport` an `inline constexpr TransportMode::Monolith`
(`Config.h:514`), so the expression folds to `&& true`; G1 reports `.text +0` and
`0 added / 0 removed / 0 resized / 0 renamed`, G2 reports 0 pull-vs-push name diff lines, and push
`integration-gpu` under monolith is 1128/1128. `MGPipeApplyResourceFlushRange` is unchanged under
monolith.
### 14. The minors and the report corrections
| | verdict |
|---|---|
| m-1 (present↔swap is a convention) | CLOSED — `PipeApplier.cpp:156-165` says so, and `Presents()` is exposed (`PipeApplier.h:128`) |
| m-2 (the death test names its mode) | CLOSED — `EXPECT_EXIT(..., KilledBySignal(SIGABRT), ".*")` + the exact Fatal grep; passes |
| m-3 (`Start` resets its diagnostics) | CLOSED — `./ServerLoopTest` with **no filter** is now `19 tests from 3 test suites ran. [ PASSED ] 19` (round 1 gave `DrainedRecords … 9 vs 8`) |
| m-4 (the doorbell Fatal text) | CLOSED — `ServerLoop.cpp:604-612` now says Notify suffices and Kill is the belt |
| m-6 (`AssertConsumerMaskIsHonest` re-runs) | present at `Init.cpp:224`, but see **N-8** — it cannot detect the thing its comment claims |
| m-7 (reply ordering documented) | CLOSED — documented against `ReplySlot.h:36` ("ORDERING") |
**Report corrections:**
* Round-1 census `428/185/506/28 + 2 SEGFAULT = 1149` — **correct**, re-derived from
`~/w7/p5-v1-joint-inproc.log` (428 Passed, 185 Skipped, 508 `***Exception` of which 2 SEGFAULT, 28 Failed).
* "The 506 are class-C by one probed example, not per-abort" — correctly restated.
* "The `VERB_BARRIER=0` / `STRICT_ERRORS=1` failure NAMES come from the MobileGL log FILES" — **correct
and reproduced**: with `MOBILEGL_LOG_FILE_PATH` set I read
`[Linux MobileGLIntegra/FATAL]: MGPipe: Fatal{BarrierViolation, "SetTextureParams"}` verbatim
(`~/w7/p5-v1rev2-barrier0-direct.log:78`). The `DirectGLES.Split.*` ctest entries still set no log
path, so on the lane itself it remains unattributed (ID-53's plumbing, assigned to the joint-merge
package by ID-56). See **N-1** for the much worse thing that has happened to that lane.
* "No 0xDD reached a draw is now ESTABLISHED" — **accepted**, and on better evidence than v1 gives: the
claim rests on M-2 making the shadow the only base, and that is now a *measured* fact (removing the
copy turns the lane red in 10 places), not an inference from a green lane.
* "The thread really PARKED first now rests on `consumerParked`" — correct (item 12).
* §8's `HandleRecycle.*` correction — the old sentence was indeed wrong, but the **replacement is also
wrong**: see **N-2**.
* The round-2 census — **wrong, and in the flattering direction**: see **N-4**.
### 15. The joint numbers I measured
Joint = `p5/v1-joint2` `ba0dcdb9` (`c9d84e33` + `p5/c1@41992649`(+docs) + the two merge hunks), rebuilt
here, `BUILD_RC=0`.
| lane | result |
|---|---|
| `ctest -L integration-split` (inproc) | **21/21** — 19 pass + the 2 `TheMapLandsInTheArmItsLaneDeclares` design skips |
| `MOBILEGL_IPC_AUDIT=1 ctest -L integration-split` | **21/21** |
| `MOBILEGL_IPC_STRICT_ERRORS=1` | **19 of 21 red** (2 design skips) — the negative control still works |
| `MOBILEGL_IPC_VERB_BARRIER=0` | **21/21 "passed", ctest exit 0 — the negative control is GREEN.** See N-1 |
| inproc `ctest -L integration-gpu` census | **392 passed / 183 skipped / 551 subprocess-aborted / 23 failed / 0 SEGFAULT** (= 1149) |
`Fatal{BarrierViolation}` is readable — but only from a MobileGL log file the operator sets by hand.
**The 23, by family, with attribution I tested rather than assumed.** All 23 names match v1's table and
its per-family counts (12 Layered / 3 packed-depth GetTexImage / 3 PrimGen / 3 HandleRecycle / 1 swizzle
/ 1 P4aFinal).
Two ownership experiments, on the joint:
1. **C6 is not the cause.** Disabling `ActiveBackendFormatCaps`'s server arm (the obvious v1-shaped
suspect for format/attachment answers) and rebuilding (`BUILD_RC=0`): all six probed entries still
fail, identically. Reverted.
2. **v1's round 2 as a whole is not the cause.** I reverted *every* round-2 hunk in
`Managers.cpp`, `Utils.{h,cpp}`, `BackendObject_DirectGLES.cpp` and `PipeApply.cpp` to their
`3fb97cc5` text on the joint (`~/w7/p5-v1rev2-revert-r2-dgles.sh`), rebuilt (`BUILD_RC=0`) and re-ran:
all six still fail identically under inproc, all six pass under monolith. (The same revert drops
`integration-split` to 14/21, which independently confirms that v1's round 2 is what produced 21/21.)
So **v1's claim that none of the 23 is v1's holds** for the two families the charter asked me to test
(`P4aFinalFixScenario`, `HandleRecycle.Legacy`) and for four more besides. Their classification,
however, does not — see N-2. Against c1's own measured baseline on the same c1 head
(ID-56: 386/180/558/23/**2**), v1's round 2 is **+6 passed, −7 aborted, −2 segfault** — a small,
genuine improvement.
### 16. G1 — CLOSED
```
$ python3 scripts/symbol_report.py --before ~/w7/p5-before-libMobileGL.so \
--after ~/w7/p5-v1/build-linux/libMobileGL.so --threshold 0
symbol-report: .text 10806611 -> 10806611 (+0, +0.000%)
symbol-report: 27814 -> 27814 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
```
`nm` pull `MG_Remote` = 0, split = 431, split `ServerLoop` = 27, pull `ActiveBackendFormatCaps` = 0.
Run after a fresh `cmake --build build-linux` (rc=0) inside the gate, so it is not a stale binary.
The other three self-tests re-measured in the same run (`~/w7/p5-v1rev2-gaterun.log`): unit
**1814/1814** in each of pull/push/verify; split **1994 with one red**
(`PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot`, c1's ID-31); flake sweep
`ctest -R 'ServerLoopTest|StagedShadowTest' -j 8 --repeat until-fail:100` → `100% tests passed, 0 tests
failed out of 18`; generators `--check` up to date; include-closure 0 problems.
---
## New findings, most severe first
### N-1 — major — `MOBILEGL_IPC_VERB_BARRIER=0`, R-1's negative control, is GREEN on the joint head: all 21 entries SKIP and ctest exits 0
**File:line:** `MobileGL/MG_IntegrationTest/CMakeLists.txt:1854-1857` (`MGL_ITEST_GLES_SPLIT_ENVIRONMENT`)
+ the harness's forked pre-flight EGL child (`Scenarios/../Harness/ScenarioFixture.h:111`).
**Claim:** with the barrier off, the pre-flight child now dies of
`Fatal{BarrierViolation, "SetTextureParams"}`; the harness reads a pre-flight child that died on
signal 6 as *"the EGL bring-up ABORTS on this platform"* and SKIPS every scenario; the entries carry
`SKIP_REGULAR_EXPRESSION`, so ctest records 21 skips and prints `100% tests passed`.
**Failure scenario:** exit gate E1 (`Fatal{BarrierViolation}` must be red under barrier-off) is retired
silently. Round 1's joint gave 19 of 21 red here. Anyone reading the lane sees a pass.
**How to confirm (executed):**
```
$ cd ~/w7/p5-v1-joint/build-split && MOBILEGL_IPC_VERB_BARRIER=0 ctest -L integration-split -j 4
100% tests passed, 0 tests failed out of 21 # every entry ***Skipped
$ MOBILEGL_IPC_VERB_BARRIER=0 MOBILEGL_ITEST_REQUIRE_GPU=1 ctest -L integration-split -j 4
0% tests passed, 21 tests failed out of 21 # red, but for "no usable GPU", not per-entry
$ ... MOBILEGL_LOG_FILE_PATH=... ./MobileGLIntegrationTest --gtest_filter=TriangleScenario.*
~/w7/p5-v1rev2-barrier0-direct.log:78: Fatal{BarrierViolation, "SetTextureParams"}
```
`MOBILEGL_IPC_STRICT_ERRORS=1` is unaffected (19 of 21 red) because it aborts *inside* the scenario,
after the pre-flight has succeeded.
**Owner:** not v1's code — the abort moved into the pre-flight because c1's round-2 R-17 routes
`SetTextureParams` through the wire. It belongs with ID-53's lane plumbing in the joint-merge package
(ID-56 already assigned the missing `MOBILEGL_LOG_FILE_PATH` there). Fix shape: the split lanes must set
`MOBILEGL_ITEST_REQUIRE_GPU=1` (or the pre-flight must not run the transport), and E1 must assert
`Fatal{BarrierViolation, "<slot>"}` from a per-entry log file.
**Severity:** major. It is a phase exit gate that currently cannot fail.
### N-2 — major — two of v1's six M-5 triage rows call a deterministic split defect a `-j` flake, on probes that ran zero tests
**File:line:** `~/w7/p5-v1-probe.sh:4-6` and its `primgen` / `handlerecyc` entries; v1-v2.md §"M-5 triage"
rows 3 and 4.
**Claim:** the probe exports `MOBILEGL_BACKEND_TYPE=DirectGLES` and an unprefixed gtest filter, so it
ran the plain `DirectGLES.PrimitivesGeneratedNoXfbScenario.*` and `DirectGLES.HandleRecycleScenario.*`
entries — which are **SKIPPED**, not passing. gtest exits 0 when everything skips, so `rc=0` was read as
"passes standalone". The entries that actually fail are `DirectVulkan.*`,
`DirectVulkan.PrimGenReroute.*`, `DirectGLES.HandleRecycle.Legacy.*`,
`DirectVulkan.HandleRecycle.{Legacy,AbaControl}.*` — different backends and different ctest lanes.
**How to confirm (executed):**
```
$ bash ~/w7/p5-v1rev2-reprobe.sh # v1's own probe parameters
===== primgen rc=0 ===== [ SKIPPED ] ... ; [ PASSED ] 0 tests.
===== handlerecyc rc=0 ===== [ SKIPPED ] ... ; [ PASSED ] 0 tests.
$ bash ~/w7/p5-v1rev2-probe4.sh ~/w7/p5-v1-joint/build-split inproc # the entries that DO fail
DirectGLES.HandleRecycle.Legacy...AFramebufferAtARecycledAddress... [inproc] 0% tests passed, 1 failed
DirectVulkan.PrimGenReroute...CountsADrawMadeWithNoCaptureSpan [inproc] 0% tests passed, 1 failed
$ bash ~/w7/p5-v1rev2-probe4.sh ~/w7/p5-v1-joint/build-split monolith
... all six: 100% tests passed
```
Six of the 23 (3 PrimGen + 3 HandleRecycle) are **deterministic, reproducible standalone under inproc,
green under monolith** — not flakes. The census log agrees: the DirectGLES entries v1 probed are
`***Skipped` in it.
**Consequence:** six wrong answers on the split path currently have no owner, because they were filed as
scheduling noise. This is R-16's third clause ("一条探针不得对着桩武装") applied to a triage probe.
**Severity:** major (as a report/triage defect; the underlying six are still not v1's — see item 15).
### N-3 — major — the C7 tuple cache is never invalidated when the context or surface it names is destroyed
**File:line:** `ServerLoop.h:195-202` (`m_haveCurrentTuple` at `:198`, `m_curDpy/Draw/Read/Ctx` at `:199-202`);
`ServerLoop.cpp:216` (the only clear, in `Start()`); `ServerLoop.cpp:798-813` (`ServerReleaseEGLResources`,
which runs `backend->ReleaseEGLResources()` → `DestroyEGLContext` and clears nothing);
`ServerLoop.cpp:264-290` (`ApplyMakeCurrent`).
**Claim:** `ApplyMakeCurrent` keys "already bound" on the *client's* `(dpy, draw, read, ctx)` handle
values and keeps that key across context and surface destruction.
**Failure scenario:** client binds (D,S,S,C) → `NativeBind`, tuple cached. Client destroys the context
and/or surface (`ServerReleaseEGLResources` / `ServerReleaseEGLSurface`) without the session being
restarted, then creates new ones. EGL handle values are routinely recycled — on this host every one of
them is literally `0x1` (`~/w7/p5-v1rev2-c7-clear.out`) — so the next make-current compares equal,
classifies `RepeatNoOp`, performs **no** native `eglMakeCurrent` and **skips the R-12 caps republish**.
Every later GL call on the apply thread then runs with no context current, silently, and
`ServerMakeEGLCurrent` returns `true`.
**How to confirm:** add `m_haveCurrentTuple = false` clearing to `ServerReleaseEGLResources` and to
`ServerReleaseEGLSurface` (when the surface matches `m_curDraw`/`m_curRead`), and to the backend-destroy
path in `ApplyThreadMain`; write a case that binds, releases resources, rebinds the same handle values
and asserts `NativeBindCount() == 2`. Today that case would read 1. Not reachable on the P5 reduced-path
lane (measured: exactly one make-current per process, item 10), so it is a latent hazard for the exit-gate
traces, OpenRA and P6 rather than a live P5 red.
**Severity:** major (silent wrong context, no diagnostic).
### N-4 — major — the round-2 inproc census in v1-v2.md is arithmetically impossible and overstates the result
**File:line:** `v1-v2.md` §"M-5 triage", first paragraph.
**Claim:** "575 passed / 183 skipped / 551 subprocess-aborted / 23 failed / 0 SEGFAULT" sums to **1332**,
not 1149. 575 is ctest's `passed + skipped` figure (1149 − 574), so the 183 skips are counted twice.
**How to confirm (executed, on v1's own log and on my re-run, byte-identical at 3071 lines):**
```
$ bash ~/w7/p5-v1rev2-census.sh ~/w7/p5-v1-joint2-inproc.log
Passed: 392 ; Skipped: 183 ; Aborted(***Exception): 551 ; Failed: 23 ; SEGFAULT: 0 (= 1149)
```
**Consequence:** the report presents "round 1 was 428/185/506/28/2" beside "575", i.e. as a jump of +147
passing tests. The honest comparison is **428 → 392: 36 fewer tests pass on the round-2 joint than on
the round-1 joint**, with aborts up 506 → 551. That delta is c1's R-17 routing (against c1's own
baseline on the same c1 head, 386 passed, v1 is +6), but it is the opposite sign from what the report
tells the integrator, and it is the second round in which this census has been mis-stated.
**Severity:** major as a report defect; the underlying tree is fine.
### N-5 — major — seven of the round's own fixes have no control that fails when the production wiring is removed
R-16's fourth clause ("每条门在报告里都要带一行'我把它弄红过一次,方式是 X'") — each of these ships a
red-once line that either names a container test or names a perturbation that does not go red here.
All executed with `~/w7/p5-v1rev2-myperturb.py` / `jointperturb.py`; each left the 19-case unit surface
AND the joint's 21/21 untouched:
| fix | file:line deleted | what went red |
|---|---|---|
| M-1's coverage half | `Managers.cpp:1058-1063` (loop body → `continue`) | nothing |
| M-3 pool-reuse | `Managers.cpp:3028-3029` | nothing |
| M-3 respecify | `Managers.cpp:3104-3113` | nothing |
| m-5's null | `Managers.cpp:2983-2985` | nothing |
| M-6's call | `Init.cpp:194` | nothing |
| codex 11's read-back | `ServerLoop.cpp:126-136` → `return requested;` | nothing |
| C7's classification | `ServerLoop.cpp:264` → always `NativeBind` | nothing |
| C6's routing (1 of 7 sites) | `Utils.cpp:89-112` | nothing |
| ID-49's tight size | `PipeApplier.cpp:216`/`:265` → `info.DstSize` | nothing (unit **and** joint) |
**Fix shape:** the ones that are cheap to gate today are M-6 (a case that calls `ShutdownSplitRoles`
after a forced `ClientSession::Start` failure and asserts `ServerLoop::Backend() == nullptr`), C7 (assert
`NativeBindCount()`/`ClientReleaseCount()` through the forwarders — the counters already exist and have
no readers), and C6 (assert each of the seven helpers' answer with two objects installed, not just the
accessor's address). M-3, m-5 and codex 11 need a sparse-shadow case, an ASan context-loss case and a
cpuset-restricted child respectively, and should be booked with owners rather than claimed.
**Severity:** major in aggregate — three of the round's charter items (M-3, m-5, M-6) rest on nothing
executable, and the report states red-once lines for two of them that do not hold.
### N-6 — minor — `NativeBindCount()` / `ClientReleaseCount()` have zero readers in the whole tree
`ServerLoop.h:133-138` says they are "read by the C7 control"; `rg NativeBindCount|ClientReleaseCount`
over `p5/v1` and over the joint returns only the declaration, the definition and the comments. The
shipped C7 control reads neither.
### N-7 — minor — m-5's null is `#if MOBILEGL_BUILD_DISAGGREGATED` but not transport-guarded
`Managers.cpp:2983-2985` runs in a disaggregated build under **monolith** transport too. There
`StagedShadowStore::m_copies` is false, so `Adopt` never sets `m_any`, `HasShadow` always answers false,
and `resource->hostBytes` is nulled on every twin's first ensure. Harmless today (split-under-monolith
`integration-gpu` is 1149/1149, and `liveHostBase()` prefers `MappedData()` there), but "Under monolith
nothing changes" — the comment two lines above it and the report's §"M-2 cascade" — is not exactly true,
and the two other round-2 Managers.cpp hunks *are* transport-guarded. Make it consistent.
### N-8 — minor — m-6's second `AssertConsumerMaskIsHonest` cannot detect what its comment says it closes
`Init.cpp:216-224`. The check only fires on `claimsResources && !hasResourceOps`. A client object that
*registers* into `MGPipeSetResourceOps` (the case the comment names — "a client-registered
`g_resourceOps` would flip the answer under the applier's feet") makes `hasResourceOps` **true**, which
the check treats as correct. The re-run can only newly fire if the table was *removed* between step 2
and step 5. Either re-word the comment or compare the pointer against the one step 2 saw.
### N-9 — minor — two red-check `expected` regexes carry almost no information
`~/w7/p5-v1-redcheck.py`: `drained-tally-removed` expects `/DrainedRecords/` — an identifier the case
prints in several assertions — and `park-predicate-loses-control` expects `/Timeout/`, which any ctest
timeout satisfies, including an unrelated hang. They are better than the round-1 `rc != 0`, but they are
the two entries round 1 called tautological and they are still the two weakest.
---
## Claims in `v1-v2.md` the code does not support
1. **"the round-2 joint inproc census … 575 passed / 183 skipped / 551 … / 23 failed / 0 SEGFAULT"** —
sums to 1332, not 1149; v1's own log says 392 passed (N-4).
2. **"`PrimitivesGeneratedNoXfbScenario` … passes standalone (`p5-v1-probe-primgen` rc=0) … flaky under
`-j 6`"** and **"`HandleRecycleScenario…` passes standalone … flaky under `-j`"** — both probes ran a
different backend/lane from the failing entries and SKIPPED every test (`[ PASSED ] 0 tests`); the
failing entries fail deterministically standalone (N-2).
3. **M-3: "the production wiring is exercised end-to-end on the joint"** — deleting both
`MGL_SERVER_STAGED_REQUIRE` whole-store calls leaves the joint at 21/21 and the unit lane at 19/19
(item 4).
4. **M-6: "Red once (unit `StopWithoutAStartedThreadStillDropsThePrivateBackend`)"** — that case gates
`ServerLoop::Stop()`'s pre-existing `!joinable` arm, which round 2 did not change. Deleting M-6's
actual fix (`Init.cpp:194`) goes red on nothing (item 7).
5. **m-5: "Red once (unit `StagedShadowTest.HasShadowIsTrueAfterAdoptAndFalse…`)"** — that gates the
discriminator, not the fix. Deleting the fix goes red on nothing (item 5).
6. **`ServerLoopTest.cpp:373`: "Red once by making ApplyAffinity return `requested`"** — executed; the
suite stays green. The effective-mask read-back has no control on an unrestricted box (item 6).
7. **C7: "the instrumented native-bind COUNT is a joint-lane control"** and `ServerLoop.h:133-138`'s
"read by the C7 control" — no such control exists on `p5/v1` or on the joint; the counters have zero
readers (N-6). Measured, the native bind count per process is unchanged at 2 and `RepeatNoOp` is
classified zero times on the whole lane (item 10).
8. **"the R-12 republish decision" on an identical repeat** — ID-54 says a repeat is "a no-op apart from
the R-12 republish decision"; the code skips the republish entirely on a repeat
(`ServerLoop.cpp:733`, `if (!ok || !outcome.boundNatively) return MOBILEGL_OK;`). Harmless on this head only
because c1's `BackendObject_Remote::InitCapabilities` asks the server directly
(`BackendObject_Remote.cpp:118-125`), which the report does not say. Worth an integrator sentence.
9. **"201 split-only = wave-1 + v1's two suites"** — v1 now ships **three** suites on split
(`ServerLoopTest`, `StagedShadowTest`, `StagedShadowProductionTest`); the gate's own line prints
"split-only names that are NOT v1s suites: 183" because its grep does not know about the third.
Cosmetic.
---
## What I could not verify, and why
* **Whether the audit poison itself is armed on the joint lane.** I established the stronger thing it
exists to support (the draw's only base is the server shadow, provably), but I did not instrument
`PipeWireCodec`'s 0xDD fill on the joint to count the runs it poisons.
* **N-3 as a live reproduction.** The reduced-path lane performs exactly one make-current per process,
so the recycled-handle window cannot be reached without a scenario that destroys and recreates an EGL
context — none exists in the tree today.
* **codex 11 under a real cpuset.** Confirming the effective-mask read-back needs a cgroup-restricted
child; I did not create one.
* **ASan anything.** No ASan build exists in this worktree set and configuring one was out of budget;
m-5 and codex 5 remain source-level only.
* **DirectVulkan under split on a device, OpenRA/SPLIT, adb** — out of scope and out of reach.
* **Whether the 23 are c1's specifically.** I established they are not v1's round 2 (two independent
reverts) and that they are split-path-only. Naming the owning package needs c1's emit table, which is
c1's round 3 and currently in flight in `~/w7/p5-c1`.
---
## Verdict
**Mergeable after one small fix round, and the fix round is about gates and the report, not about the
code.** Every behavioural item the charter names is either correct-and-proved (ID-49 server half, M-2,
M-7, C2, C9, C10, item 12, G1) or correct-in-source with the control missing (M-3, m-5, M-6, codex 11,
C7's bind half, C6's routing). The two blockers of round 1 are genuinely closed, and M-2 is closed with
the exact measurement round 1 said would settle it — the reduced-path lane now goes red when R-11's copy
is deleted, which it did not before.
What the fix round must close, in this order:
1. **N-4** — correct the census in `v1-v2.md` to 392/183/551/23/0 and state the 428 → 392 direction
plainly, with the c1-baseline delta (+6/−7/−2) beside it. This is the second round with the same
error and it currently reads as a large improvement where there is a small one.
2. **N-2** — withdraw the "flaky under `-j`" classification for `PrimitivesGeneratedNoXfbScenario` and
`HandleRecycleScenario`; both are deterministic split-path wrong answers. Re-probe with the failing
entries' own backend and lane environment, and give those six an owner.
3. **N-5, the three that are cheap** — a real gate for M-6 (`ShutdownSplitRoles` after a forced early
`Start` failure), for C7 (`NativeBindCount`/`ClientReleaseCount` through the forwarders; the counters
exist and nothing reads them), and for C6 (assert the seven helpers, not the accessor's address).
Strike the red-once lines for M-6 and m-5, and the `ApplyAffinity` one at `ServerLoopTest.cpp:373`,
or make them true.
4. **N-3** — clear `m_haveCurrentTuple` in `ServerReleaseEGLResources`, in `ServerReleaseEGLSurface` for
a matching surface, and on backend destruction. One line each; the failure mode is a silent
no-context-current.
5. **Item 10's prose** — ServerLoop.h:33-40 and v1-v2.md must stop claiming that the six DirectGLES
cache invalidations became a one-off startup cost. Measured, the native bind count per process is
unchanged; what ID-54 actually bought is the release half (1 → 0 native releases), which is real and
worth saying on its own.
Track as follow-ups with owners rather than blocking: M-3's and m-5's missing controls (they need a
sparse-shadow case and an ASan context-loss case), codex 11's cpuset control, ID-49's tight-size half,
N-7, N-8, N-9.
**Not v1's, but it must not merge unnoticed:** **N-1**. `MOBILEGL_IPC_VERB_BARRIER=0` is E1's exit gate
and on the joint head it exits 0 with every entry skipped. It belongs with ID-53's lane plumbing in the
joint-merge package and it should be fixed before the joint merge is called green, not after.