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

318 lines
25 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.
# s1 — round 3 (wave 1.5): the five confirmed findings, ID-47, and the CI ledger red
**Branch** `p5/s1`, one commit `949ba509` on top of the integration head `ce53553c` (merged first, per
ID-44; fast-forward, my round-2 head `4ba14fa4` was already an ancestor). Committer identity checked:
`Swung0x48 <swung0x48@outlook.com>` (ID-40). Working tree clean after the commit.
Everything in the commit is `MOBILEGL_BUILD_DISAGGREGATED`-only (`MG_Remote/*`, `MG_Test/Wire/*`) plus
one CONTRACT row, and G1 proves it (§7).
## 0. The one-line summary per item
| # | finding | what changed | red once by |
|---|---|---|---|
| 1 | ID-47 / finding 2 | `SEG_REPLY` 16 MiB, 8 × 2 MiB, `MaxReplyBytes` = 2,097,136; `ReplySlotPool::CanHold` + `RequireReadPixelsFits` (client-side named refusal); `ClientSession::ReplyCanHold` / `RequireReadPixelsReplyFits` forwarders; ProtocolSmokeTest pin (now also reads `replyPool` back); CONTRACT §2 row 23 | reverting `ReplyBytes` to 8 MiB → `TheDefaultReplyGeometryHoldsTheLargestP5Read` dies in Post; bare `std::abort()` in `RequireReadPixelsFits` and `<` for `<=` in `CanHold` → `AReadPixelsLargerThanAReplySlotIsRefusedAtTheClientByName` |
| 2 | finding 5 | the pad-bit case stamps `kRecPad` into the header itself, past `Reserve`'s mask, plus the opposite control (a genuine filler still vanishes and does not advance `appliedSeq`) | deleting `&& header.kind == kRingPadRecordKind` in `Pop` → red on its own message |
| 3 | finding 6 | `CapsAbiFingerprint()` IS `MixAbiFingerprint(CapsAbiFingerprintInputs())` — one mixer over an inputs struct; CapsCodec's second FNV loop deleted; sensitivity case moved to `SessionHandshakeTest` and started from the production entry point | `return 1;` in `CapsAbiFingerprint` → red; deleting one `mix(...)` line → red naming the input |
| 4 | finding 7 | null-union Hello driven through `ServerSession::Accept`; null-union Welcome driven through `ClientSession::StartOverTransportPair` (Start's second half, now public); each asserts the guard's own log line | deleting either `msg_as_*() == nullptr` clause → SegFault (red) |
| 5 | finding 10 | `WireLogFatal` (MGLOG_F + stderr echo + abort) carries every Transport Fatal; both `SessionTestDeath` controls name their diagnostic | bare `std::abort()` in `AdvanceMonotonic` / in `Post` → "died but not with the expected error" |
| 6 | CI run 35079459114 | the ledger reads `VmHWM`/`VmRSS` in ONE pass and reports its OWN running peak (`SampleRoleMemoryInto`), never the kernel's verbatim | `PeakRssBytes = kernelPeakRssBytes;` → red |
All eleven perturbations were executed by `~/w7/p5-s1-redcheck.sh` (log `~/w7/p5-s1-redcheck.log`): every
one RED for its own reason, every file restored byte-for-byte (sha256-checked), baseline green before
and after. §8 has the verbatim lines.
## 1. ID-47 — the reply geometry (finding 2)
**What was wrong.** `ReplyBytes` 8 MiB / 8 slots = 1 MiB slots, `MaxReplyBytes()` = 1,048,560. The
512×512 RGBA8 read my v1 report claimed the slot covered is 1,048,576 bytes — 16 over. E2's retrace
snapshot is a full-surface 640×480 GL_RGBA/GL_UNSIGNED_BYTE read = 1,228,800 bytes — 180,240 over.
**What changed.**
- `SessionSegmentSizes::ReplyBytes = 16 MiB` (`SessionRings.h`), `kDefaultReplySlotCount` stays 8 → slots
of 2 MiB, `MaxReplyBytes() = 2,097,136`. Canonical sizes are now 8/32/16 MiB + 256 KiB; the header
comment in `SessionRings.h` and the geometry comment in `ReplySlot.h` say so and say why. No knob was
added (§5 has none for `SEG_REPLY`, by design — ID-47 did not ask for one).
- `ProtocolSmokeTest.WelcomeCarriesTheFourSegmentAnnouncements` pins 16 MiB **and now reads
`replyPool()` back** — before this round the pin built the reply SegmentRef and never asserted on it,
so a moved size would have gone unnoticed there.
- `SessionTest.TheDefaultGeometryIsTheFourContractRingSizes` pins 16 MiB on the mapping and the
announcement.
- CONTRACT §2 row 23 (line 147, c0's file, the one row ID-47 granted): the geometry, the canonical
sizes, the client-side refusal and its message, and the P6 debt. Nothing else in that file was touched.
- **The helper.** `ReplySlotPool::CanHold(bytes)` (inclusive boundary, false on an unconfigured pool) and
`ReplySlotPool::RequireReadPixelsFits(width, height, format, type, bytes)` — returns when the answer
fits, otherwise `WireLogFatal` with exactly
`MGPipe: Fatal{ReplyTooLarge, "ReadPixels <w>x<h> 0x<format>/0x<type> <bytes> > <cap>"} - ...`
and abort. `<format>` is the GL enum pair the record carries (`MGPReadbackInfo::Format/Type`), printed
as hex, e.g. `ReadPixels 640x480 0x1908/0x1401 1228800 > 2097136`. `ClientSession::ReplyCanHold` and
`ClientSession::RequireReadPixelsReplyFits` forward verbatim (a fifth primitive beside Encoder /
Producer / WaitForApplied / ReadReply).
- `Post`'s oversize refusal is unchanged in meaning and is documented as the LAST line of defence; it
now goes through `WireLogFatal` so it can be named by a death test (§5).
**The one line c1 must add**, in `OnReadPixels`, immediately before `EmitAndWait(MGPWireOp::ReadPixels, ...)`:
```cpp
Client::ClientSession::Active()->RequireReadPixelsReplyFits(info.Box.W, info.Box.H, info.Format, info.Type, info.DstSize);
```
(with whatever names c1's emitter uses for the box extent, the two enums and the byte count it computed
for `DstSize`; the byte count passed is what would have been posted, so what is refused is exactly that).
`ReplyCanHold(bytes)` is there for a caller that wants a non-fatal probe first.
**Controls (R-16).**
- `SessionTest.TheDefaultReplyGeometryHoldsTheLargestP5Read` — the verifier's case, committed: a pool from
`SessionSegmentSizes{}` posts exactly `640*480*4` bytes and reads them back byte-for-byte, then `512*512*4`
in the next slot; pins `SlotBytes()==2 MiB`, `MaxReplyBytes()==2097136`. **Red once by** reverting
`ReplyBytes` to 8 MiB: `Subprocess aborted` (Post's oversize branch), the verifier's original outcome.
- `SessionTestDeath.AReadPixelsLargerThanAReplySlotIsRefusedAtTheClientByName` — the boundary pair on the
DEFAULT geometry: exactly 2,097,136 bytes (524284×1 RGBA8) returns; 2,097,137 dies with
`Fatal{ReplyTooLarge, "ReadPixels 524284x1 0x1908/0x1401 2097137 > 2097136"}`; 1024×512 RGBA8 (exactly
2 MiB, sixteen over — the same sixteen-byte shape that sank the 1 MiB claim) dies with its own dimensions
in the line; E2's 640×480 read returns. **Red once by** a bare `std::abort()` in
`RequireReadPixelsFits` (regex matches nothing) and, separately, by `<` for `<=` in `CanHold` (the
exact-cap call dies).
- `SessionTestDeath.AReplyLargerThanItsSlotIsFatalRatherThanTruncated` is now a boundary pair at the Post
level too (exactly `MaxReplyBytes()` posts and reads back; +1 is the named refusal) — see §5.
**The fingerprint did not move for ID-47**: it mixes no segment size (§3 lists what it mixes), and the
Welcome `SegmentRef` cross-check in `Start` is what catches a geometry disagreement.
**Not mine, flagged:** `docs/Disaggregated/ARCHITECTURE.md:422` says "`SEG_REPLY` … 8 MiB,4 KiB slot" —
stale before this round and stale after it; `~/w7/notes/p5/BRIEF-P5.md:742` lists "`SEG_REPLY` 8 MiB". ID-47
says the BRIEF/ID-file sentences change in the same commit, but `~/w7/notes` is not a git repository and
those files were not in my grant, so they are the integrator's two lines to fix.
## 2. Finding 5 — the pad-bit case never sent the bit
`RingProducer::Reserve` masks `kRecPad` out (`flags & ~kRecPad`), so `Reserve(7, kRecPad, 16)` put `flags=0`
on the wire and the case was green with Pop's kind check deleted. The case now does what a codec with its
own header struct does: `Reserve(7, kRecNone, 16)`, then stamps `kRecPad` into the eight header bytes
directly. `ApplyOne` must deliver it (`seen==1`, kind 7, the bit intact, `appliedSeq==1`), and the opposite
control follows in the same case: a header wearing `kRecPad` whose kind IS `kRingPadRecordKind` is a
genuine filler, still vanishes, and does NOT advance `appliedSeq` (R-9). That last assertion is what this
case adds over ID-43's `RingTest.TheTwoFlagSpacesAreDisjointByTranslation`, which is the same control at
the ring; this one is at the session.
**Red once by** deleting `&& header.kind == kRingPadRecordKind` from `RingConsumer::Pop`:
`SessionTest.ARecordWearingThePadBitIsDeliveredRatherThanEatenAsAFiller ... ***Failed` on its own
message ("the record was skipped as a wrap filler because it wore bit 2 …"). Chosen over deleting the case
because the session-level half (appliedSeq counts the record, not the filler) is not stated anywhere else.
**§8.2 of s1-v1.md is re-pointed here**: the kind-check control is this case AND
`RingTest.TheTwoFlagSpacesAreDisjointByTranslation`; the v1 text that named the old case as the control
was false at the time it was written.
## 3. Finding 6 — the fingerprint gate tested a function with no production caller
**What changed.** `Transport::AbiFingerprintInputs` (struct, `SessionRings.h`) and
`MixAbiFingerprint(const AbiFingerprintInputs&)` (`Ring.cpp`) are the ONE mixer.
`CapsAbiFingerprintInputs()` (new, `CapsCodec.h/.cpp`) fills it from the real values;
`CapsAbiFingerprint()` is the one-liner `return Transport::MixAbiFingerprint(CapsAbiFingerprintInputs());`.
The hand-rolled FNV loop in `CapsCodec.cpp` (the second implementation) is deleted.
**What the fingerprint mixes after this round** (in order, FNV-1a, never 0):
`sizeof(DynamicBackendParameters)`, `sizeof(MGPCaps)`, `sizeof(GLFunctionsTable)`,
`kFormatCapabilityTargetCount`, `kFormatCapabilityFormatCount`, `kFormatCapabilitiesCodecVersion`,
`kRendererInfoCodecVersion`, `MGPWireOp::kOpCount` (ID-33), `MOBILEGL_ABI_VERSION(major, minor)` (ID-33),
a presence marker for the stamp, then `GIT_COMMIT_HASH_SHORT`'s bytes (ID-33). ID-33's inputs are all
kept. Two value-level changes versus the previous `CapsAbiFingerprint`: the stamp is preceded by a
presence marker (so `nullptr` and `""` are distinct inputs — the old mixer collapsed them), and the
zero-guard. Nothing pins the value itself; both roles are one build in P5. **It did not move for ID-47**
(no segment size is mixed).
**The case** `SessionHandshakeTest.TheAbiFingerprintChangesWhenAnyOfItsInputsDoes` (moved from
`SessionTest`, which cannot include `CapsCodec.h` without the umbrella header): (1) `CapsAbiFingerprint()`
is non-zero, stable, and EQUAL to `MixAbiFingerprint(CapsAbiFingerprintInputs())`; (2) every field of
`CapsAbiFingerprintInputs()` equals the real sizeof/constant (so a hard-coded input is caught); (3) each of
the ten inputs, perturbed by one on a copy of the REAL inputs, changes the answer, and `nullptr` ≠ `""` ≠
a real stamp.
**Red once by** (a) `Uint64 CapsAbiFingerprint() { return 1; }` — the verifier's exact perturbation —
`***Failed` on "CapsAbiFingerprint() is not MixAbiFingerprint over CapsAbiFingerprintInputs()"; (b)
deleting `mix(inputs.OpCount);` from the mixer — `***Failed` on "MGPWireOp::kOpCount is not mixed".
`PipeWireCodecTest.TheAbiFingerprintIsStableWithinABuildAndNotZero` (w1's) still passes and is untouched.
## 4. Finding 7 — the null-union case never reached either guard
**What changed.** New suite `MG_Test/Wire/SessionHandshakeTest.cpp` (own `main()` that points
`MOBILEGL_LOG_FILE_PATH` at a per-pid file before anything logs — PipeWireCodecTest's shape — because
`Defines.h` compiles the console sink out and "refusal by message" means reading the log). Registered in
`Wire/CMakeLists.txt` with PipeWireCodecTest's include paths.
- `ANullUnionHelloIsRefusedByAcceptRatherThanDereferenced`: a real `InProcessTransport` pair, the
null-union Hello sent from the client end, a `ServerSession` of the case's own (the constructor is
public; not the process singleton) → `Accept` returns `MOBILEGL_ERR_PROTOCOL_MISMATCH`, `Accepted()` is
false, the log delta contains `MG_Remote server: the first control frame is not a verifiable Hello` and
no `Fatal{`.
- `ANullUnionWelcomeIsRefusedByStartRatherThanDereferenced`: `Start()` builds its transport pair itself,
so no control could queue a frame ahead of the server's Welcome. `ClientSession::StartOverTransportPair(
clientEnd, serverEnd)` is Start's second half (everything from Hello on), now public and documented as
such — `Start(mode, endpoint)` = the mode refusal + `CreatePair` + this. The case queues the null-union
Welcome on the server→client direction, then calls it: Hello goes out, the singleton server's `Accept`
runs FOR REAL (segments, resolver, its genuine Welcome queued behind the injected one), the client reads
the injected frame first, refuses with `MG_Remote client: the server's first control frame is not a
verifiable Welcome`, and `Stop()`'s not-started path closes the server (`Accepted()` false,
`ServerSession::Active()` null). The case also requires the server's "accepted with NO backend" line in
the delta, proving `Start` was driven past the point a stub would stop at.
- The old `SessionTest.AVerifiableFrameCanCarryANullUnionPayload` stays as the reachability premise,
renamed `ANullUnionFrameVerifiesWhichIsThePremiseOfBothHandshakeGuards`, with a comment saying it is
the premise and not the control.
**Red once by** deleting `envelope->msg_as_Hello() == nullptr` (ServerSession.cpp) →
`ANullUnionHelloIsRefusedByAcceptRatherThanDereferenced ... ***Exception: SegFault`; deleting
`envelope->msg_as_Welcome() == nullptr` (ClientSession.cpp) →
`ANullUnionWelcomeIsRefusedByStartRatherThanDereferenced ... ***Exception: SegFault`. Red by crash rather
than by message — with the clause gone the very next line dereferences the null member, which is the
defect the guard exists for; there is no message left to name.
**s1-v1.md:338 corrected**: the sentence "so the guard cannot be simplified away" was false when written
— the case it cited never called either handshake. After this round the two guards are protected by the
two `SessionHandshakeTest` cases above, which do.
## 5. Finding 10 — empty death regexes
**Why they were empty, mechanically.** `Defines.h:71-72` builds the logger with `MOBILEGL_LOG_ENABLE_CONSOLE 0`
and the file sink on, so an MGLOG line never reaches stderr — and a gtest death test matches its regex
against the child's stderr and nothing else. There was nothing to name.
**What changed.** `Transport::WireLogFatal(format, ...)` (`WireLog.h/.cpp`, `[[noreturn]]`, printf-checked):
formats once, `MGLOG_F`, echoes the line to stderr (flushed; `abort()` does not flush stdio), aborts.
`AdvanceMonotonic`'s backwards-watermark block and all three of `Post`'s refusals (unconfigured pool,
seq 0, oversize) go through it, as does `RequireReadPixelsFits`. Texts unchanged. A Fatal now also shows on
a terminal and in a CI job log, which the file-only sink never did.
- `AWatermarkThatMovesBackwardsIsFatalRatherThanIgnored`: regex
`Fatal\{ProtocolCorruption, "watermark"\} appliedSeq moved backwards, 10 -> 9`.
- `AReplyLargerThanItsSlotIsFatalRatherThanTruncated`: regex
`reply pool: Fatal\{ProtocolCorruption\} - a 8177 byte answer for seq 2 does not fit a 8192 byte slot \(payload cap 8176\)`,
and the case now posts exactly `MaxReplyBytes()` first and reads it back (the boundary pair at the Post
level).
**Red once by** replacing the `WireLogFatal` block in `AdvanceMonotonic` with `(void)name; std::abort();`
→ `***Failed` ("Death test: … Result: died but not with expected error"); the same in `Post`'s oversize
branch → `***Failed`. Both are the verifier's perturbations, which previously left both cases green.
## 6. GitHub run 35079459114 — `TheMemoryLedgerIsPerRoleAndIsReleasedOnClose` red on CI (add-on)
**Diagnosis: CONFIRMED, with the mechanism one step sharper than proposed.** The kernel stores
`mm->hiwater_rss` only when RSS is about to DROP; `task_mem()` reports `VmHWM = max(stored, rss-at-this-read)`.
Within ONE read of `/proc/self/status` the pair is therefore self-consistent — but the wave-1 sampler read
the two keys in TWO passes (one `fopen` per key), and the second `fopen` itself grows RSS (stdio buffer,
allocator), so the second pass's `VmRSS` can exceed the first pass's `VmHWM`. Probe (`~/w7/p5-s1-probe/`,
kernel 6.18.33.2-microsoft-standard-WSL2):
```
pass1: VmHWM=3660 VmRSS=3788 | after touching 4 MiB: VmRSS=7884 > pass1 VmHWM? YES | VmHWM re-read=7884
single-pass reads with 64 KiB growth between them: 0/1000 had VmRSS > VmHWM
```
— two passes disagree by 128 KiB with nothing allocated between them (exactly the CI shape: 4,784,128 <
4,849,664 is 64 KiB); one pass never disagrees. Why CI and not local: only timing — the second `fopen`'s
first-touch pages are more often already resident locally; the race is real everywhere.
**What changed (as ruled).** `ProcessRssBytes(&peak, &current)` reads BOTH keys in one pass (the two old
accessors remain, implemented over it). `SampleRoleMemoryInto(runningPeak, role, kernelPeak, kernelCurrent)`
folds `max(kernelPeak, kernelCurrent)` into a caller-owned running peak (CAS loop — the GL and apply
threads both log memory at phase boundaries) and reports THAT as `PeakRssBytes`, so `Peak >= Current`
holds by construction and never decreases; `SampleRoleMemory(role)` = one pass + the fold into a
process-wide running peak. `RoleMemory.h` documents the rule and the run id. The `LogRoleMemory` line is
unchanged in shape (t1's grep tag `MG_Remote memory[` is untouched).
**Controls.** The CI assertion `EXPECT_GE(sample.PeakRssBytes, sample.CurrentRssBytes)` stays, now true by
construction. New `SessionTest.TheLedgersPeakIsItsOwnRunningMaxAndNeverTheKernelsHighWaterMarkVerbatim`:
a running peak of its own, fed (peak 100, current 200) → `PeakRssBytes == 200`; then (150, 120) → stays
200; then (300, 100) → 300 (the kernel's peak still counts when larger); and one real
`ProcessRssBytes` pass on Linux is non-zero and self-consistent. **Red once by** reverting the fold to
`sample.PeakRssBytes = kernelPeakRssBytes;` → `***Failed` ("the kernel's peak was reported verbatim
although its current exceeded it", 100 vs 200) — the CI line, deterministically.
## 7. The four self-tests (all on `949ba509`; scripts `~/w7/p5-s1-gate3.sh`, logs `~/w7/p5-s1-gate3-run.log`, `~/w7/p5-s1-split-unit.log`, `~/w7/p5-s1-split-monolith-igpu.log`, `~/w7/p5-s1-igpu-push.log`)
1. **G1** against `~/w7/p5-before-libMobileGL.so` (`.READY` = `4595163c…`, the ID-44 re-take): `27814 -> 27814
defined symbols: 0 added, 0 removed, 0 resized, 0 renamed`, `.text 10806611 -> 10806611 (+0, +0.000%)`;
`nm` of the pull library finds 0 `MG_Remote` symbols. `check_include_closure.py`: 4 probes, 0 problems.
`gen_pipe.py --check`: up to date (no `.def` or generator touched).
2. **`ctest -L unit`**: pull 1814/1814, push 1814/1814, verify 1814/1814; split **1979/1980** with exactly
the ONE known red that is not mine (`PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot`,
c1's) — 1980 = the head's 1975 + 5 (six cases added: `TheDefaultReplyGeometryHoldsTheLargestP5Read`,
`AReadPixelsLargerThanAReplySlotIsRefusedAtTheClientByName`, `TheLedgersPeakIsItsOwnRunningMax…`, and the
three `SessionHandshakeTest` cases; one moved out of `SessionTest`). Split Wire suites under the task's
regex (`^Ring|^Doorbell|^Framing|^FdPassing|^InProcessTransport|^Protocol`): 58/58 unchanged; with
`^Session` added: 91/91 (`SessionTest` 30, `SessionHandshakeTest` 3).
3. **`integration-gpu`**: push 1128/1128; G14 vs `~/w7/p5-before-ctest-names.txt` (the reference gate's
`names`/`comm`): 0 removed, 40 added — the head's own P5 entries, none from this round (my cases are
split-only); G2 pull-vs-push name diff 0. Split under `MOBILEGL_TRANSPORT=monolith`: 1149/1149.
4. **Generators**: not touched; `--check` green as above.
Build-harness hygiene (the verifier's C-10 note): every build ran from a script file, the generator was
confirmed `Ninja` from `CMakeCache.txt` for all three reconfigured dirs, the split configure was reused, and
`p5-s1-redcheck.sh` refuses to run a test when the perturbed build's rc is non-zero.
## 8. The red-once ledger, verbatim (`~/w7/p5-s1-redcheck.log`)
```
RESULT: RED as required (geometry-8mib) SessionTest.TheDefaultReplyGeometryHoldsTheLargestP5Read ...Subprocess aborted***Exception
RESULT: RED as required (readpixels-bare-abort) SessionTestDeath.AReadPixelsLargerThanAReplySlotIsRefusedAtTheClientByName ...***Failed
RESULT: RED as required (canhold-exclusive) SessionTestDeath.AReadPixelsLargerThanAReplySlotIsRefusedAtTheClientByName ...Subprocess aborted***Exception
RESULT: RED as required (pop-kind-check) SessionTest.ARecordWearingThePadBitIsDeliveredRatherThanEatenAsAFiller ...***Failed
RESULT: RED as required (fingerprint-return-1) SessionHandshakeTest.TheAbiFingerprintChangesWhenAnyOfItsInputsDoes ...***Failed
RESULT: RED as required (fingerprint-drop-opcount) SessionHandshakeTest.TheAbiFingerprintChangesWhenAnyOfItsInputsDoes ...***Failed
RESULT: RED as required (hello-guard) SessionHandshakeTest.ANullUnionHelloIsRefusedByAcceptRatherThanDereferenced ...***Exception: SegFault
RESULT: RED as required (welcome-guard) SessionHandshakeTest.ANullUnionWelcomeIsRefusedByStartRatherThanDereferenced ...***Exception: SegFault
RESULT: RED as required (watermark-bare-abort) SessionTestDeath.AWatermarkThatMovesBackwardsIsFatalRatherThanIgnored ...***Failed
RESULT: RED as required (post-bare-abort) SessionTestDeath.AReplyLargerThanItsSlotIsFatalRatherThanTruncated ...***Failed
RESULT: RED as required (ledger-kernel-peak) SessionTest.TheLedgersPeakIsItsOwnRunningMaxAndNeverTheKernelsHighWaterMarkVerbatim ...***Failed
```
Each perturbation is an exact-text edit applied and reverted by `~/w7/p5-s1-redcheck.py` (sha256 of the
file checked equal after revert; no git command runs while the submodule links are on). Baseline green
before and after: 11/11 named cases pass on the unperturbed tree.
## 9. Corrections to s1-v1.md (the verifier's three falsifications)
- **:134** "1 MiB, which covers a 512×512 RGBA8 ReadPixels" — false by 16 bytes (the header). True now:
2 MiB slots, cap 2,097,136, which holds 512×512 RGBA8 (1,048,576) and E2's 640×480 RGBA8 (1,228,800); the
committed control posts both.
- **:338** "so the guard cannot be simplified away" — false: the cited case never called a handshake.
True now: `SessionHandshakeTest`'s two cases drive both guards and go red (SegFault) when either clause
is deleted.
- **§8.2** named `ARecordWearingThePadBitIsDeliveredRatherThanEatenAsAFiller` as the kind-check control
while its producer stripped the bit. True now: that case stamps the bit itself and is red under the
perturbation, beside ID-43's `RingTest.TheTwoFlagSpacesAreDisjointByTranslation`.
## 10. What needs the integrator, and accounts left open
1. **Two sentences outside my grant** still say 8 MiB: `docs/Disaggregated/ARCHITECTURE.md:422`
("8 MiB,4 KiB slot" — wrong on both numbers, before and after) and `~/w7/notes/p5/BRIEF-P5.md:742`.
ID-47's "same commit" clause cannot cover the notes (not a git repo); both are one-line edits.
2. **c1's one line** (§1) is the only thing between ID-47's ruling and a server-side abort on an oversize
read; until `OnReadPixels` lands, `Post`'s refusal is still the only defence. The helper, its message
and its boundary are pinned on my side, so c1 owes a call, not a test.
3. **`StartOverTransportPair` is public** for the Welcome control only. If the integrator prefers a
`friend`-shaped seam, it is a two-line change; I chose the public function because it is Start's real
second half (Start now composes it) rather than a test-only hook, and its header comment says who may
call it (nobody but Start and the control).
4. **The reply-slot count is not announced in Welcome.** Under inproc both roles read the same
`SessionSegments`; under P6's spawn the client would need `ReplySlotCount` on the wire (or the
fingerprint) to size its pool. Not a P5 defect — noted so P6 does not rediscover it.
5. **Wire-suite count** for the gate: the task's regex still gives 58; a gate that wants the new suite
counted needs `^Session` in it (91 today).
6. Perf: not measured this round; nothing on a hot path changed (the fold is at phase boundaries, the
client-side check is one compare per ReadPixels).
## 11. Files
Committed (`949ba509`): `MG_Remote/Transport/{WireLog.h,WireLog.cpp,ReplySlot.h,SessionRings.h,Ring.cpp,RoleMemory.h,ShmSegment.cpp}`,
`MG_Remote/{CapsCodec.h,CapsCodec.cpp}`, `MG_Remote/Client/{ClientSession.h,ClientSession.cpp}`,
`MG_Remote/CONTRACT-P5.md` (row 23 only), `MG_Test/Wire/{SessionTest.cpp,SessionHandshakeTest.cpp (new),ProtocolSmokeTest.cpp,CMakeLists.txt}`.
Not touched: anything of w1's (`MG_Remote/Wire/*`, `PipeWireCodecTest.cpp`), c1's (`OnReadPixels`,
`MG_Impl/Pipe/*`), `protocol.fbs`, any `.def` or generator, `ServerSession.cpp` (the guard is exercised, not
edited). No line of mine meets w1's finding-3 work.
Kept under `~/w7/` (cited above): `p5-s1-gate3.sh`, `p5-s1-gate3-run.log`, `p5-s1-redcheck.{py,sh,log}`,
`p5-s1-redcheck-run.log`, `p5-s1-split-unit.log`, `p5-s1-split-monolith-igpu.log`, `p5-s1-igpu-push.log`,
`p5-s1-names-{linux,push}.txt`, `p5-s1-symbols.md`, `p5-s1-build-{linux,push,verify,split}.log`,
`p5-s1-probe/`. Deleted: the configure logs and the interim library-build log.