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

554 lines
29 KiB
Markdown

# b1 — round 2: ID-41 (G5's eleventh row) and ID-42 (the membership assertion)
Branch `p5/b1`, worktree `~/w7/p5-b1`. Base: `git merge --no-edit feat/disaggregated` was a
**fast-forward** to `5e5bf7b9` — wave 1 already contains `505b5084`, so there was nothing to
resolve and no merge commit exists. `git var GIT_COMMITTER_IDENT` printed
`Swung0x48 <swung0x48@outlook.com>` before the first command (ID-40's standing rule).
Two commits, **`5e5bf7b9..6cabc6b0`**:
```
f63c9483 [Fix] (scripts): compare G5's eleventh row against its pin ALWAYS and re-pin it on the
reviewed P5 body, with a negative control that the pin itself can fail ID-41
6cabc6b0 [Fix, Test] (MG_IntegrationTest, MG_Test): make the persistent-map membership expectation
a function of the arm the map landed in, and pin the arm-independent half on
IsLivePersistentMap where both answers can be produced ID-42
```
Item 3 is not a repo change: it is one edit to `~/w7/notes/tools/wsl_p5_gate.sh`, argued in §3.
`MobileGL/MG_Backend/DirectGLES/Managers.cpp` is **untouched** (ID-41 says so in as many words,
and v1 owns that file this round).
---
## 1. ID-41 — the eleventh row is isolated and re-pinned
### 1.1 What the two scripts did, and what they do now
`scripts/p3a_untouched_regions.sh:40` has always claimed that the push arm "is compared against a
sha pinned at the commit where it was reviewed". The implementation consulted
`PINNED_SHA_FlushPendingRangesFrom` **only as a fallback**, after a strict extraction of all eleven
at `<ref-a>` had failed — i.e. only when `<ref-a>` did not define the function at all. At P3a's own
base ref it does not, so the two readings agreed and nobody noticed. From `ff2994d9` onward it
does, the fallback stopped firing, and the row silently reverted to ref-a-vs-ref-b. That is why
both scripts went red on the integration head.
The p4a twin had already found this and fixed it on its own side (its `DEVIATIONS D-N/2`), so this
round only re-pins it there and brings the parent into line. **After ID-41 the two scripts agree
and D-N/2 is no longer a deviation between them** — the note is kept as the record of which one got
there first.
**(a) always pinned.** `p3a`'s `extract_baseline` now extracts the **ten** strictly and then applies
the pin unconditionally. This *removed* a code path rather than adding one: the all-eleven strict
attempt is gone and the "ten strictly" spelling — which already existed as the fallback — is now the
only one. So the prompt's escape hatch ("if the extractor cannot express 'always pin' without
re-spelling the ten-row path") was not needed. The substitution itself is one function,
`apply_pinned_shas`, in **both** scripts, and both `extract_baseline` and `--self-test`'s new
controls call it — a control that re-implemented the substitution would only prove the copy agrees
with itself.
**(b) the pin is the reviewed P5 body**, with the commit and the decision beside it, in a table both
scripts carry identically:
```
# 3e298c9a 37fc94ff... ID-15, P3a: the two-arm shape, reviewed and accepted
# 3dadd4c1 172b0222... ID-41, P5 (b1): [Fix] (DirectGLES): make the extent hostBase is good
# for a parameter of the flush ladder ... <- CURRENT
PINNED_BASELINE_REF=3dadd4c1
PINNED_BASELINE_DECISION=ID-41
PINNED_SHA_FlushPendingRangesFrom=172b022273db01b16e772d15b269ffcd797fe38c767f7354d83ce113a66040d0
```
`3dadd4c1` was found, not assumed: walking `git rev-list --reverse ff2994d9..HEAD -- Managers.cpp`
and hashing the body at each commit gives exactly two movers —
```
02b3b5a0... 142bf921 [Fix] (DirectGLES): retire the probe's last frontend read under split ...
172b0222... 3dadd4c1 [Fix] (DirectGLES): make the extent hostBase is good for a parameter ...
```
— and `3dadd4c1` is where the current body appears. (`~/w7/p5-b1-r2-walk.sh`.)
**The admission is checkable, not asserted.** The same walk prints the PULL arm at both ends:
`FlushPendingRangesNow` hashes `c6557002...` at `ff2994d9` **and** at `HEAD`. It did not move. With
G1 at `.text +0` and 0/0/0/0 on the pull build (§4.1), the change is confined to the arm that
ships, which is what makes "re-pin" rather than "revert" the right answer.
**(c)** The other ten p3a rows and all seventeen p4a regions are untouched and stay
ref-a-vs-ref-b. Only `PINNED_FUNCTIONS` is consulted through the pin, and it has one member.
**(d) the pinned row has its own two controls, and its own message.** `compare_lists` in both
scripts now emits a distinct paragraph when the row that moved is a pinned one ("`... IS A PINNED
ROW (ID-41): its baseline is ALWAYS the sha PINNED in this script ... and never the body at
'<ref-a>'`"), because the two kinds of failure are fixed differently and a reader who gets only the
generic paragraph goes looking for a diff against `<ref-a>` that does not exist. `--self-test`
gained:
- **pin precedence (positive)** — a baseline carrying a *different* sha for the pinned row (which
is the shape of every `<ref-a>` CI passes today) must come out of `apply_pinned_shas` carrying the
pin. This is the control that would have caught the ID-41 defect itself.
- **a ONE-TOKEN edit to the pinned ladder (negative), AGAINST THE PIN** — a single `;` inserted at
the head of the body (a new `perturb-token` / `token` mode; the perturbed copy is only ever
hashed, never compiled, so an empty statement is legal there). The comparison must go red, must
name `FlushPendingRangesFrom`, **and** must carry the "IS A PINNED ROW" line. All three are
asserted separately, so a red for the wrong reason fails the control (R-16).
A third, non-fatal note fires when the working tree's ladder does not hash the pin. It is
deliberately **not** a failure: `--self-test` runs on the working tree and is about whether the
comparison works, while the two-ref gate is what fails when the *committed* ladder has left the pin.
**(e) green on both refs.** CI's `<ref-a>` is `BASELINE: "37da3c3a"` (`.github/workflows/test.yml:2228`),
used by `test.yml:2345` and `:2378` as `bash scripts/<n>_untouched_regions.sh "${BASELINE}" HEAD`,
with `--self-test` at `:2349` and `:2382`.
```
p3a --self-test rc=0 8 controls (3 positive, 3 perturbation, pin precedence, pinned one-token)
p3a ff2994d9 HEAD rc=0
p3a 37da3c3a HEAD rc=0
p4a --self-test rc=0 14 control lines (3 positive, 8 head/tail, pin precedence, pinned one-token)
p4a ff2994d9 HEAD rc=0
p4a 37da3c3a HEAD rc=0
```
Both refs now print a NOTE saying the ref defines the row differently from the pin. The wording was
rewritten this round because the inherited p4a sentence was one-directional ("the ladder moved
between `<pin>` and `<ref>` without this gate being re-pinned") and reads as an alarm in the case
that is *expected*: when `<ref-a>` **predates** the pin commit the two SHOULD disagree, because the
pinned body is the change ID-41 admitted. The note now says both directions and states that it is
not a verdict.
### 1.2 R-16 — "I made it red once, by doing X"
`~/w7/p5-b1-r2-g5red.sh`. **X = rewind `PINNED_SHA_FlushPendingRangesFrom` to the pre-P5
`37fc94ff...`, in a copy of each script placed beside the original so its `REPO_ROOT` still
resolves, and run `ff2994d9 HEAD`.** No source file is touched, so the red can only be the pin's.
```
p3a: FIRST FUNCTION THAT MOVED: FlushPendingRangesFrom
FlushPendingRangesFrom IS A PINNED ROW (ID-41): ... the body reviewed at 3dadd4c1 ... rc=1
p4a: FIRST REGION THAT MOVED: FlushPendingRangesFrom
FlushPendingRangesFrom IS A PINNED ROW (ID-41): ... the body reviewed at 3dadd4c1 ... rc=1
shipped scripts, same refs, immediately after: rc=0
no leftover copies in scripts/
```
### 1.3 What would overturn ID-41's landing here
A pull-build symbol diff (G1 says 0/0/0/0, `.text +0`), or `FlushPendingRangesNow` turning out to
have moved after all (it hashes `c6557002...` at both ends). Either would mean the change is not
confined to the shipping arm and the row should be reverted rather than re-pinned. Separately: a P5
caller found to depend on the widened `INVALIDATE_RANGE` behaviour the tier-1 refusal now blocks —
nothing in the tree does today, and the refusal is only reachable once w1 passes a real `SEG_STAGE`
extent.
### 1.4 A debt this round created and did not take
`.github/workflows/test.yml` now describes the two self-tests by a control count that is one short
(`:2340` "six canned controls" for p3a; `:2374-2377` "three positive controls ... and FOUR negative
ones" for p4a), and `:2328` still says the push ladder is pinned "at 3e298c9a". The file is not in
my grant (ID-41 grants the two scripts and says to *run* CI's argument shapes, not to edit the
workflow). The edit is three comment lines:
```
:2328 "... a sha pinned in the script at 3dadd4c1 (ID-41), because that one was born in P3a
and is compared against the reviewed body rather than against the base ref"
:2340 "six canned controls" -> "eight canned controls ... plus the pin-precedence control and a
one-token edit to the pinned ladder compared against the pin"
:2377 "FOUR negative ones" -> "NINE negative ones"
```
Nothing fails on it; the steps themselves are unchanged and green.
---
## 2. ID-42 — CONFIRMED, with evidence, and what the fix is
### 2.1 The provisional diagnosis, checked line by line
**Reproduced first**, exactly as asked:
```
cd ~/w7/p5-b1/build-split
MOBILEGL_TRANSPORT=monolith ctest -R 'DirectGLES.PersistentCoherentMapScenario.TwoWrites' --output-on-failure
PersistentCoherentMapScenario.cpp:270: Failure Value of: live Actual: false Expected: true
```
**Claim 1 — "the assertion never ran in the push build (tracker unavailable → early return)".
CONFIRMED.** `PersistentMapPeek.cpp:26` compiles the tracker half only when
`MGITEST_PERSISTENT_MAP_TRACKER` is defined, and `MG_IntegrationTest/CMakeLists.txt:1832-1843`
defines it **inside `if (MOBILEGL_BUILD_DISAGGREGATED)`**. A push build never compiles `MG_Remote`,
so `PersistentMapTrackerAvailable()` is false, and the old `AssertMembership` recorded
`"unavailable"` and returned at its first line. The seven entries went red the first time the
assertion ran at all.
**Claim 2 — "on the split build's monolith lane the map is ADOPTED (tier T1)". CONFIRMED, and the
tier name is the only thing I would correct.** Direct evidence, read from the production peek:
```
build-split/.../MobileGLIntegrationTest --gtest_filter=...TheMapLandsInTheArmItsLaneDeclares
--gtest_output=xml:...
<property name="persistent_map_arm" value="adopted"/>
```
The mechanism is `PipeApply.cpp:2005`: R-6's decline is
`if (MG_Config::Transport != Monolith && AdoptTierIsEmulate()) return nullptr;` — **ANDed with the
transport**. Under `MOBILEGL_TRANSPORT=monolith` the decline is skipped, `g_resourceOps->MapPersistent`
mints, `BufferObject.cpp:856` calls `AdoptPersistentMap`, and `IsBackendPersistentMapped()` is true.
So the store is adopted by the ordinary monolith path rather than by an adopt *tier*: `AdoptTier` is
still 2 the whole time. "Tier T1" in ID-42 should read "the monolith mint" — the conclusion is
unaffected, but the distinction matters for the next claim.
**Claim 3 — "`IsLivePersistentMap` answers false on its `IsBackendPersistentMapped()` row by
design". CONFIRMED verbatim**, `PersistentMapTracker.cpp:40-58`:
```cpp
Bool PersistentMapTracker::IsLivePersistentMap(const BufferObject& buffer) {
if (!buffer.IsMapped()) return false;
// ... At tier T2 this arm is unreachable - MapPersistent declines - but
// the predicate must still read the chain, not the tier ...
if (buffer.IsBackendPersistentMapped()) return false;
```
**Claim 4 — "the membership claim is only true on the emulated arm". CONFIRMED.** The set is the set
of maps the client still has to PUSH; an adopted store's bytes are already in coherent GPU memory
and there is nothing to ship, so it must *not* be a member.
### 2.2 The fix
`PersistentCoherentMapScenario.cpp`: `AssertOrRecordArm` now **remembers** the arm it observed in
`m_observedArm` (a three-state `ObservedArm{NotLookedAt, Adopted, Emulated}`), and `AssertMembership`
expects `live == (arm == emulated)` from **that same peek** — not a second one, which would be a
second question that could straddle a change. `NotLookedAt` records and does not assert, because
"could not look" is not "it was emulated" (`PersistentMapPeek.h`'s own rule); a lane that *declares*
an arm has already been skipped by `AssertOrRecordArm` in that state. The failure message names both
directions and points at the unit case for the arm-independent half.
`MG_Test/Buffer/SplitBufferTest.cpp`: the arm-independent statement is pinned by a new unit case,
**`SplitBufferSet.TheAdoptedArmIsNotAMemberAndItIsTheChainRowThatSaysSo`** — not by an integration
entry, because an integration entry only ever sees whichever arm its driver and transport hand it,
which is precisely how the old assertion came to state the emulated arm's property as universal.
The case produces both arms and compares them:
- a **declined twin** with no backend ops: not adopted, and a member;
- an **adopted** buffer produced by the *production* path — a `BufferBackendOps` table whose only
live member is `AcquirePersistentMap`, installed for exactly one `AcquireMemoryRange` call with
`Transport` flipped to `Monolith`, because `PipeApply.cpp:2005` means there is no other way to
reach a mint in this build. The case never sets a flag by hand: with the production adoption
deleted the buffer is simply not adopted and the case fails on its own `ASSERT_TRUE`, which is
R-16's rule.
The predicate is then asked with the tier back at **T2 / `InProcess`** — the configuration in which
R-6 says every acquisition declines — and must still answer "not a member". Two asserted
consequences follow: `NoteMapStateChanged` (the production set-maintenance entry point, not a
member read) refuses to enrol it, and `PushPersistentMapsBeforeVerb()` ships the declined twin's
4096 bytes and nothing else.
What I did **not** claim: the case does not pin `PushBlocksFor`'s re-check of a *stale* member,
because that state is not reachable through production paths on this tree —
`NotePersistentMapStateChanged` early-returns unless `PushIsArmed()` (`BufferObject.cpp:430`), and
`EnsureGpuResidentStorage` refuses a mapped buffer outright (`:783`). The re-check stays
belt-and-braces and unpinned; saying so is better than a case that pretends to drive it.
### 2.3 R-16 — the red-checks
`~/w7/p5-b1-r2-red2.sh`. **X = delete `IsLivePersistentMap`'s `IsBackendPersistentMapped()` row**,
which is the exact claim both gates make. (The file is restored from a byte copy, never from git, so
the other edits in the tree are never touched; the script asserts the row appears exactly once
before removing it.)
```
baseline, unmodified tree
SplitBufferSet.TheAdoptedArmIsNotAMember... 1/1 passed
PersistentCoherentMapScenario (split, monolith) 14/14 passed
with the row removed
SplitBufferSet.TheAdoptedArmIsNotAMember... 0/1 passed, three failures
SplitBufferTest.cpp:332 "... This answer must come from that ROW and not from the adopt
tier: the tier is T2 and the transport is InProcess right now ..."
SplitBufferTest.cpp:346 the set enrolled it
SplitBufferTest.cpp:354 the push shipped its bytes
PersistentCoherentMapScenario (split, monolith) 7 of 14 FAILED - the same seven:
DirectGLES.{TwoWrites, AWriteAfterAFrameBoundary, TheMapLands}
DirectVulkan.{TwoWrites, AWriteAfterAFrameBoundary, TheMapLands}
DirectGLES.PersistentMapArm.TheMapLands
PersistentCoherentMapScenario.cpp:318 Which is: true / Which is: false
"... This map landed in the adopted arm immediately after the map and the predicate made it
a member ... (ID-42 ...)"
after restore
1/1 and 14/14 again; `git diff --stat` on the file is empty
```
Both gates go red for their own reason and assert their own string.
### 2.4 The EMULATED-arm red-check: PENDING JOINT MERGE — not faked
**No knob reaches the emulated arm in a monolith lane, and I checked rather than assumed.** Measured
matrix (`~/w7/p5-b1-r2-armmatrix.sh`, reading the production `persistent_map_arm` property):
| configuration | arm |
|---|---|
| GLES, `MOBILEGL_TRANSPORT=monolith` (default) | adopted |
| GLES, monolith, `MOBILEGL_PIPE_PUSH=0` | adopted |
| GLES, monolith, `MOBILEGL_IPC_ADOPT_TIER=2` | adopted |
| GLES, monolith, `MOBILEGL_DISABLE_LARGE_BUFFER_ADOPTION=1` | adopted |
| DirectVulkan, monolith (default) | adopted |
| DirectVulkan, monolith, `MOBILEGL_PIPE_PUSH=0` | adopted |
Why: `MOBILEGL_IPC_ADOPT_TIER=2` is already the default and is ANDed with `Transport != Monolith`
(`PipeApply.cpp:2005`); 0 and 1 are a named `abort`. `MOBILEGL_DISABLE_LARGE_BUFFER_ADOPTION` guards
only `TryAdoptLargeStorage`'s 16 MiB path, which a scenario-sized buffer never reaches.
`MOBILEGL_PIPE_PUSH=0` merely moves the mint from the MGPipe arm to the legacy
`g_bufferBackendOps->AcquirePersistentMap` arm (`BufferObject.cpp:870-881`), which mints too. There
is no `MOBILEGL_IPC_*` knob for "decline under monolith", and inventing one would be a Config.h
change through the integrator (c0's file), not a red-check.
So the emulated arm is reachable **only** with `Transport != Monolith`, i.e. the `DirectGLES.Split.*`
lanes, and those skip today at `ScenarioFixture.h:143` — "`MG_Remote::Client::ClientSession::Active()`
is null" — until s1 and c1 land the session (ID-45).
**The exact commands the integrator runs on the joint merge** (the perturbation address was checked
against the tree this round: `PersistentMapTracker.cpp:40` matches exactly once):
```bash
cd ~/w7/p5-b1 && ~/w7/p5-b1-submodlinks.sh on
export GLIBC_TUNABLES=glibc.malloc.tcache_count=0
# 1. GREEN, and it must report arm=emulated rather than skip:
(cd build-split && ctest -R 'DirectGLES\.Split\.PersistentCoherentMapScenario' --output-on-failure)
# 2. RED, with the production predicate broken on the arm that is now reachable:
sed -i 's|^ Bool PersistentMapTracker::IsLivePersistentMap(const BufferObject& buffer) {|&\n return false; // R-16 red-check, ID-42|' \
MobileGL/MG_Remote/Client/PersistentMapTracker.cpp
cmake --build build-split -j 24
(cd build-split && ctest -R 'DirectGLES\.Split\.PersistentCoherentMapScenario' --output-on-failure)
# MUST fail at PersistentCoherentMapScenario.cpp with
# "This map landed in the emulated arm ... and the predicate did not make it a member"
# 3. restore
~/w7/p5-b1-submodlinks.sh off && git checkout -- MobileGL/MG_Remote/Client/PersistentMapTracker.cpp
~/w7/p5-b1-submodlinks.sh on && cmake --build build-split -j 24
```
Until step 2 has been observed, the emulated direction of `EXPECT_EQ(live, emulated)` is
**unverified**, and this report says so rather than counting the adopted-arm red twice.
### 2.5 What would overturn ID-42's ruling
`PeekBufferIsLivePersistentMap` answering **false on the EMULATED arm** once inproc arms — which is
exactly what step 2 above tests for, in the green direction. That would mean the push set and
`SyncPersistentMappedRange`'s early-out chain have genuinely drifted and the production side is
wrong, not the expectation. Also overturned by a decision that an adopted store *should* be a member
(it must not be: the push would read `m_resource.Bytes()`, which for an adopted store is the GPU
map, as if it were the shadow).
---
## 3. Item 3 — the split lane's evidence file
**The gate's expectation was the dishonest half, and that is the half I changed.** One edit, to
`~/w7/notes/tools/wsl_p5_gate.sh` (applied by writing a new file and `rename(2)`-ing it over the
original, so a copy of the gate that happened to be running would keep its inode; nothing was
running — checked).
### 3.1 Why the lane's file could not be made to say more
The split lane's log is **not** empty and it already carries a `pmap=`/`mpr=` line:
```
persistent-map-arm-split-DirectGLES.log:
MGPipe stats: frames=0 window=0 draws=0 ... bytes[... pmap=0 ...] ... cso[... mpr=0] ...
```
That is the library's teardown summary, and it is the honest answer: **the lane measured nothing,
because its case SKIPPED.** `ctest -R 'DirectGLES.Split.PersistentMapArm' -V` gives the reason in
the library's own words — `ScenarioFixture.h:143`, "`MG_Remote::Client::ClientSession::Active()` is
null: no client session exists in this process ... this is what 'packages s1 and c1 have not landed'
looks like from inside a running test".
The gate then does (correctly, review finding Q-2) `grep -v 'window=0'` to avoid reporting the union
of the real window and the teardown zeros — and on this lane that filter leaves **nothing**, which
it printed in the same shape as a measured pair. An empty value there reads identically to three
different facts: "it measured zero", "the stats channel never reached the process", and "the lane
did not run". That is R-16's defect class inside a gate's own echo.
I did **not** make the test binary write into the library's log. `MG_IntegrationTest` cannot link
`MG_Util::PipeStats` at all (`PipeStatsWindow.h:12-17`, and on Android it links the shipping
`libMobileGL.so` built `-fvisibility=hidden`), so the only way to put a line there would be for the
*test* to append to the *library's* file — a second, forgeable channel for a number the library
owns, which is the same mistake as a test constructing the state it should observe.
### 3.2 The edit
The echo now distinguishes three states:
```
persistent-map arm lanes: 100% tests passed, 0 tests failed out of 2
persistent-map-arm-DirectGLES.log: pmap=0.00 mpr=1
persistent-map-arm-split-DirectGLES.log: NO MEASUREMENT - every stats line in it is a TEARDOWN
window (window=0), i.e. the lane's case did no work. 1 of this run's PersistentMapArm entries
skipped; the split half skips on 'ClientSession::Active() is null' until s1 and c1 land the
client session (ID-45). Exit gate E3(c)'s pair is NOT closed while this line says NO
MEASUREMENT - it is closed when it carries mpr= and pmap=.
```
All three branches were observed: the measured one and the teardown-only one above, and the third
("the library emitted no `MGPipe stats:` line at all, so `MOBILEGL_PIPE_STATS` /
`MOBILEGL_PIPE_STATS_PERIOD` did not reach the process. This is NOT `pmap=0`.") against a throwaway
log in a temp directory (`~/w7/p5-b1-r2-pending.sh`). `bash -n` on the rewritten gate parses.
**What this costs the integrator to know:** exit gate E3(c) — "the split arm's `mpr` equals the
monolith arm's, and `pmap > 0`" — is **not** closed on this tree and was not closed at wave 1
either. The monolith half reads `pmap=0.00 mpr=1`; the split half has never produced a number. It
becomes a verdict on the commit that lands the last of c1/s1/v1, at which point the same gate line
will carry a pair or still say NO MEASUREMENT.
---
## 4. Acceptance
Worktree `~/w7/p5-b1` at `6cabc6b0`, `GLIBC_TUNABLES=glibc.malloc.tcache_count=0`, four build dirs
plus `build_verify_split`. Driver: `~/w7/p5-b1-r2-accept.sh`.
### 4.1 The four self-tests
**G1** — against the RE-TAKEN baseline `~/w7/p5-before-libMobileGL.so` (marker `.READY` =
`4595163c`, ID-44), `--threshold 0`:
```
.text 10806611 -> 10806611 (+0, +0.000%)
27814 -> 27814 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
nm pull MG_Remote: 0 nm split MG_Remote: 345
```
**Generators and purity**
```
gen_pipe.py --check : generated files are up to date
gen_pipe.py --self-test : 9 negative-control trips, positive control OK
gen_pipe_dirty_surface.py --check : reported (unchanged)
check_include_closure.py : 4 probes, 0 skipped, 0 problem(s)
```
**`ctest -L unit`**
| lane | integration head | here |
|---|---|---|
| build-linux | 1813 / 1813 | **1814 / 1814** |
| build-push | 1813 / 1813 | **1814 / 1814** |
| build-verify | 1813 / 1813 | **1814 / 1814** |
| build-split | 1974, 2 known reds | **1975, the SAME 2 known reds** |
The two split reds are `RingTest.TheTwoFlagSpacesAreDisjointByTranslation` (s1, ID-43) and
`PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot` (c1, ID-31 fallout).
Neither is mine and neither moved.
The one new name is `SplitBufferSet.TheAdoptedArmIsNotAMemberAndItIsTheChainRowThatSaysSo`, present
in **all four** builds (it skips outside build-split), which is why G2 and G14 do not move.
**`ctest -L integration-gpu`, `MOBILEGL_TRANSPORT=monolith`** — §4.3.
### 4.2 Name sets
```
ctest -N, all labels: pull=2942 push=2942 split=3124
G2 pull vs push, diff lines: 0
G14 split vs push: 182 added, 0 REMOVED
```
### 4.3 The integration lanes
```
ctest -L integration-gpu, MOBILEGL_TRANSPORT=monolith
build-push 100% passed, 0 failed out of 1128
build-split 100% passed, 0 failed out of 1149 <- the seven reds are ZERO
```
`build-split` monolith was **1149 with exactly the seven `PersistentCoherentMapScenario` reds**; it
is now 1149 with none. `build-push` is unchanged at 1128/1128.
**Name identity against `~/w7/p5-before-ctest-names.txt`.** One correction to how this is computed:
that file is a **full** `ctest -N` list (2902 names), not an integration-gpu-only one, so comparing
1128 integration-gpu names against it directly subtracts two different populations (my first pass
did, and printed a meaningless "1785 missing"). Computed properly
(`~/w7/p5-b1-r2-nameid.sh`):
```
baseline (full ctest -N): 2902
my push build (full ctest -N): 2942
baseline names MISSING from my push build: 0 <- the gate that matters
names my push build adds over the baseline: 40 (all of wave 1's, plus my one unit name)
integration-gpu in my push build: 1128
of those, not present at the baseline: 11
```
The eleven are t1's wave-1 scenario entries and nothing of mine —
`{DirectGLES,DirectVulkan}.TriangleScenario.*` (2 each) and
`{DirectGLES,DirectVulkan}.PersistentCoherentMapScenario.*` (3 each), plus
`DirectGLES.PersistentMapArm.PersistentCoherentMapScenario.TheMapLandsInTheArmItsLaneDeclares`.
This round's diff is four files and adds **one** ctest name, a `unit` one:
```
MobileGL/MG_IntegrationTest/Scenarios/PersistentCoherentMapScenario.cpp | 76 +++-
MobileGL/MG_Test/Buffer/SplitBufferTest.cpp | 109 +++--
scripts/p3a_untouched_regions.sh | 214 ++++--
scripts/p4a_untouched_regions.sh | 215 ++++--
```
### 4.4 The verify + split matrix cell (round 1's M-8)
`~/w7/p5-b1-verifysplit.sh`, `build_verify_split` = `MOBILEGL_PIPE_VERIFY=ON` +
`MOBILEGL_PIPE_PUSH=ON` + `MOBILEGL_BUILD_DISAGGREGATED=ON` + `INPROC=ON` — the only configuration
in which `MGPSubData::HasLiveHostWrites` can be non-zero **and** the G4 field comparator is compiled.
```
cfg rc=0 build rc=0
unit: 1975, the same TWO known reds (RingTest -> s1; PipeWireCodecTest -> c1), none of them mine
```
---
## 5. Where I think the decisions were slightly wrong
1. **ID-42 says "tier T1".** It is not a tier at all: `MG_Config::Ipc.AdoptTier` is 2 throughout,
and the adoption happens because `PipeApply.cpp:2005` ANDs R-6's decline with
`Transport != Monolith`. Reading it as a tier sends the next person to
`MOBILEGL_IPC_ADOPT_TIER`, which cannot change this lane's answer (§2.4's table).
2. **ID-42's "if a knob forces adoption tier T2, use it" has no referent.** T2 *is* the default and
is already forced; the thing that is not forced under monolith is the DECLINE. The honest
spelling of what ID-42 wanted is "if a knob makes `MGPipeApplyMapPersistent` decline under
monolith" — and there is none.
3. **The wave-1 gate line for the split arm was never a measurement**, at wave 1 either. The empty
value it printed was reported as data in the integration notes; §3 is the correction.
---
## 6. The account left
- **The emulated-arm red-check (§2.4)** is the one debt this round hands forward, with the exact
commands. It is owned by whoever lands the last of c1/s1/v1.
- **E3(c) is open** and the gate now says so out loud (§3.2).
- **`.github/workflows/test.yml`'s three stale comment lines** (§1.4), with the diff.
- `PushBlocksFor`'s re-check of a stale member is unreachable through production paths and therefore
unpinned (§2.2). It becomes pinnable the day a tier mints one (P11).
- Everything §7 of `b1-v1.md` listed is unchanged: the image-unit high-water mark (P8), the 21
`SyncPersistentMappedRange` sites retiring into `PushPersistentMapsBeforeVerb()` (P8, c1's call
site), `MOBILEGL_IPC_ADOPT_TIER` 0/1 (P11), C-6's re-opening when the barrier retires, and
m-13's unsynchronised `m_livePersistentMaps` (v1's thread work).
---
## 7. Temp files kept
`~/w7/p5-b1-r2-accept.sh` (the acceptance driver), `~/w7/p5-b1-r2-g5red.sh` (ID-41's red-check),
`~/w7/p5-b1-r2-red2.sh` (ID-42's red-checks), `~/w7/p5-b1-r2-repro.sh` (the ID-42 reproduction),
`~/w7/p5-b1-r2-armmatrix.sh` (§2.4's table), `~/w7/p5-b1-r2-walk.sh` (the pin-commit search),
`~/w7/p5-b1-r2-nameid.sh` (§4.3), `~/w7/p5-b1-r2-gatefix.py` (§3's edit),
`~/w7/p5-b1-r2-pending.sh`, and the run logs `~/w7/p5-b1-r2-buildrun.log`,
`~/w7/p5-b1-r2-igpu-push.log`, `~/w7/p5-b1-r2-igpu-split.log`. Everything else this round created
has been deleted, by name and never by glob. The worktree is clean and its submodule links are
left **off**, so the next `git` command in it works without a toggle.