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

7.9 KiB
Raw Blame History

s1 — round 2, ID-43 only

Branch p5/s1, worktree ~/w7/p5-s1. Step 0 (ID-44): git var GIT_COMMITTER_IDENT = Swung0x48 <swung0x48@outlook.com> (ID-40, OK); git merge --no-edit feat/disaggregated (5e5bf7b9) was a fast-forward — p5/s1's round-1 head f33e5d60 was already an ancestor of the integration head, so this round adds exactly one commit on top of 5e5bf7b9 and carries no merge resolution of its own.

Commit: 4ba14fa4 — [Test] (MG_Test, Wire): ID-43 - ..., one file, MobileGL/MG_Test/Wire/RingTest.cpp, +60 / −8. No source file, no other test file, nothing outside MG_Test/Wire/. PipeWireCodecTest.cpp untouched.


1. Reproduction, before anything was changed

cd build-split && ctest -R 'RingTest.TheTwoFlagSpacesAreDisjointByTranslation' --output-on-failure on the merged head:

../MobileGL/MG_Test/Wire/RingTest.cpp:774: Failure
Value of: ring.Consumer().Pop(view)
  Actual: true
Expected: false
a header stamped with the CALL flags outside Reserve should vanish into Pop's wrap-filler skip - ...

Exactly ID-43: c0's control (now 6e858fa3) states the pre-f33e5d60 tree. RingProducer::Reserve masks kRecPad out, so the first half of the case is untouched by my round-1 fix; the second half hand-stamps the header past Reserve, and since RingConsumer::Pop now requires kind == kRingPadRecordKind beside the flag (Transport/Ring.cpp:272), the DrawVbo-kind record is no longer eaten as a filler — it is delivered.

2. What the case says now

The first half (the Reserve-masked path, RingTest.cpp:736-757) is not weakened: same ASSERT_TRUE(Pop), same EXPECT_EQ(flags & kRecPad, 0), same EXPECT_NE(flags & kRecBorrowSlot, 0), same Invariants(). Only the second half and one stale comment moved.

  1. EXPECT_FALSE(Pop) → ASSERT_TRUE(Pop), with a message that names the kind check as the defence: "the stamped record vanished into Pop's wrap-filler skip. Pop's kind check — a filler must carry kind == kRingPadRecordKind as well as kRecPad — is the only thing standing between a header stamped with the CALL flags and every var-tail call being deleted from the stream with nothing logged on either side."
  2. EXPECT_EQ(view.kind, MGPWireOp::DrawVbo) — the kind is what Pop tells a record from a filler by.
  3. The flags, stated exactly and by their translated names. MGPipeCallFlagsFor(MGPWireOp::DrawVbo) is kHostSpan|kVarTail (PipeCalls.def:184) = 0x0C, and it arrives verbatim:
    • EXPECT_EQ(view.flags, drawVboCallFlags) — the header arrived as stamped;
    • EXPECT_NE(flags & kRecPad, 0) — bit 2, the kVarTail collision, is still set. The kind check narrows the skip; it does not scrub the bit. Naming the record is the decoder's job, and it can only do that because it got the record.
    • EXPECT_NE(flags & kRecBorrowSlot, 0) — bit 3, the kHostSpan collision, the lie about this record's lifetime (same wording as the first half already uses).
    • EXPECT_EQ(flags & kRecVarTail, 0) — bit 4. Note for the integrator: ID-43's text says the "lying kRecBorrowSlot/kRecVarTail bits" are visible. kRecVarTail is kReplySlot's bit and draw_vbo is not a reply-slot call, so that bit is clear here, in the stamped half exactly as in the Reserve half. The case now pins it clear and says why, so draw_vbo growing kReplySlot is a red here rather than a silent change of what this case demonstrates.
    • EXPECT_EQ(view.payloadSize, 16u) and EXPECT_TRUE(ring.Invariants()).
  4. The other side of the control, new: a header hand-stamped with kRecPad whose kind is kRingPadRecordKind is still skipped (EXPECT_FALSE(Pop)), Invariants() still holds. Without it, "the record is popped" could be satisfied by deleting the wrap-filler skip outright. Together the two halves say the whole ruling: same bit, different kind, different fate.
  5. The stale prose at RingTest.cpp:704-709 (the static_assert table's "the middle one is the worst: Pop treats kRecPad as a wrap filler and SKIPS the record") now reads in the conditional — that is what would happen on the flag alone — and points at the runtime half as the control. The static_asserts themselves are unchanged.

3. I made it red once, by doing X

X = deleting the kind half of Pop's wrap-filler condition, one line, MobileGL/MG_Remote/Transport/Ring.cpp:272:

-  if ((header.flags & kRecPad) != 0 && header.kind == kRingPadRecordKind) {
+  if ((header.flags & kRecPad) != 0) {                 // P5-S1-REDCHECK: kind check removed

Rebuilt build-split (rc=0) and re-ran the case. It went red on its own message, at the new assertion and nowhere else:

../MobileGL/MG_Test/Wire/RingTest.cpp:784: Failure
Value of: ring.Consumer().Pop(view)
  Actual: false
Expected: true
the stamped record vanished into Pop's wrap-filler skip. Pop's kind check - a filler must carry
kind == kRingPadRecordKind as well as kRecPad - is the only thing standing between a header stamped
with the CALL flags and every var-tail call being deleted from the stream with nothing logged on
either side

Reverted with git checkout -- MobileGL/MG_Remote/Transport/Ring.cpp; git status --porcelain then listed MobileGL/MG_Test/Wire/RingTest.cpp and nothing else, and the line at Ring.cpp:272 is back to the pair. build-split and build-push were rebuilt from the reverted tree before any number below was taken — no verdict here comes from a perturbed binary.

4. Numbers (all at 4ba14fa4)

lane result
the case itself, build-split Passed
ctest -R '^Ring|^Doorbell|^Framing|^FdPassing|^InProcessTransport|^Protocol', build-split 58 / 58
ctest -L unit, build-push 1813 / 1813
ctest -L unit, build-split 1974 total, 1 failed — PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot (#1947), c1's, ID-43's closing paragraph. Nothing else red, nothing aborted, nothing timed out.
builds build-push rc=0, build-split rc=0, build-linux (pull) rc=0; CTestTestfile.cmake confirmed present in each before any verdict
G1 symbol_report.py --before ~/w7/p5-before-libMobileGL.so --after build-linux/libMobileGL.so --threshold 0 .text 10806611 -> 10806611 (+0, +0.000%); 27814 -> 27814 defined symbols: **0 added, 0 removed, 0 resized, 0 renamed**. Baseline marker ~/w7/p5-before-libMobileGL.so.READY = 4595163c present (ID-44), so this is against the re-taken baseline.
nm role check pull build MG_Remote symbols 0
flake ctest -R '^RingTest' -j 8 --repeat-until-fail 20 — 22 / 22, 0 failing reps

RingTest is 22 cases in build-split (21 pre-P5 + c0's one). This round adds no case and removes none; the counts above are the merged head's counts, not a delta of mine.

Logs kept: ~/w7/p5-s1-r2-push-unit.log, ~/w7/p5-s1-r2-split-unit.log. Everything else under the p5-s1-r2- prefix was deleted.

5. For the integrator

  • ID-43 is closed. f33e5d60's Pop change stands as production behaviour; the test states it, and the control is two-sided (kRecPad + kind 0 vanishes, kRecPad + DrawVbo is delivered), so neither "delete the kind check" nor "delete the skip" can pass it.
  • The one wording correction to ID-43 is in §2.3 above: kRecVarTail is not among the bits a stamped draw_vbo header lies with, because draw_vbo carries no kReplySlot. The case now pins that bit clear rather than asserting it set.
  • Nothing outside MG_Test/Wire/RingTest.cpp changed, so nothing here interacts with c1's :1203 red, with b1's ID-41/ID-42, or with v1's resumed work-in-progress. The split-unit red count on p5/s1 is exactly one and it is c1's.
  • f33e5d60's other pins of the same ruling are untouched and still green: SessionTest.ARecordWearingThePadBitIsDeliveredRatherThanEatenAsAFiller and SessionTest.ABorrowSlotSightingIsCountedRatherThanJustActedOn.