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.
29 KiB
c1-v2 — R-17's routing, the reply mailbox, and the first IPC frame
Branch p5/c1. Base d628d906 (round 1), then three merges and one work commit:
d628d906 c1 round 1
87c1e1be Merge feat/disaggregated (5e5bf7b9) ID-44, step 0
4ba14fa4..571cbabb (via) Merge p5/v1 see §2
02f15bb6 [Feat] R-17 - the routing c1's round-2 work, 25 files, +2336/-273
41992649 Merge feat/disaggregated (39292958) s1 round 3 / ID-47's helper, t1, w1, b1
Commit range d628d906..41992649. c1's own commit is 02f15bb6.
1. What landed
| area | file | before | now |
|---|---|---|---|
| the generator's one asymmetry | scripts/gen_pipe.py |
a kVarTail row's table signature gained varTail+varTailCount; a kHasBlob row gained nothing |
5 lines: a kHasBlob row gains const void* blobBytes, Uint64 blobByteCount. 10 rows changed |
| the monolith arm | MG_Pipe/PipeRoute.{h,cpp} (new) |
gMGPipeScreen/gMGPipeContext were never installed — every entry null |
33 generated rows + 4 escapes installed; the reply mailbox; 37 MGPipeRoute* call-site names |
| the client arm | MG_Remote/Client/WireTables.{h,cpp} (new) |
gMGPipeWireRecordApply had no encode twin |
37 emitters over EmitAndWait, installed at the end of Start, uninstalled at the top of Stop |
| the call sites | MG_Impl/Pipe/* (8 files) |
40 direct MGPipeApply* calls |
40 MGPipeRoute* calls; MGPipeApplyVerifyCorruption untouched |
| R-13.2 / R-13.3's missing producers | MG_Impl/Pipe/PipeFill.cpp |
a split respecify carried initialBytes; a split flush carried none |
the content follows as resource_subdata, exactly as CONTRACT §2 rows 19/20 prescribe |
| the acceptance answers | MG_Remote/Wire/PipeWireCodec.cpp |
noteAcceptance recorded them and posted nothing |
4 lines: it PostReplys. w1's file — see §7 |
| the EGL seam | MG_Remote/Client/BackendObject_Remote.cpp |
private trampolines over RunOnApplyThread + Backend() |
v1's twelve Server* forwarders; −188/+~60 |
m_started |
MG_Remote/Client/ClientSession.cpp |
never set — round 1 dropped s1's line | set before g_active, with the order stated |
| ID-47 | MG_Remote/Client/EmitTables.cpp |
a local copy of the refusal | s1's ClientSession::RequireReadPixelsReplyFits |
| ID-49 | MG_Remote/Client/EmitTables.cpp |
DstSize was GL 8.4.4's packed size |
DstSize is the tight w*h*bpp; the client scatters the rows |
| the ID-31 fallout | MG_Test/Wire/PipeWireCodecTest.cpp |
:1203 asserted ResourceCreate has no reply slot |
the rule kept, the row moved to one that is really kNone; 3 sibling assertions updated; 1 case added |
| R-8's negative control | MG_Test/SanityTest.cpp |
the accessor had a counted refusal; the GATE did not | ACapsMaskWithoutTheResourceFamilyEmitsNothingAndCountsTheRefusal |
2. Two merges that were not in the charter, and why
p5/v1 is merged into p5/c1 (4ba14fa4..571cbabb). The coordinator put two edits in c1's files into this round's
scope — m_started, and routing the EGL virtuals through v1's twelve Server* forwarders — and the second one names
symbols that exist only on p5/v1 (ServerLoop.h:196-212). There was no way to ship a compiling, tested version of
that edit without v1 in the tree. One conflict, MG_Test/Wire/CMakeLists.txt, the same-point-append shape; both blocks
kept, and the second merge turned it into a foreach over three names so there is no fourth conflict.
feat/disaggregated @ 39292958 is merged (s1 round 3, ID-47's helper, plus t1/w1/b1). Two conflicts, both trivial
(ClientSession.cpp's include block; the same CMakeLists).
The integrator merging v1 first and c1 second is unaffected — v1's commits are already ancestors, so nothing is
duplicated. It does mean the diff of p5/c1 against the integration head is 45 files rather than 25; git show 02f15bb6
is c1's work by itself.
3. R-17's real size versus the estimate
R-17 costed it as "~41 direct call sites converted to the MGP_* thunks, the two install functions, and 37 thin client
emitters over EmitAndWait". The call-site number was exactly right (40, measured). The emitters really are thin. The
ROUTING was not, and it is bigger by four rows and one whole mechanism.
The generated table signature is the P2-era monolith interface: void (*Name)(const Payload*, ...),
async-with-handle, no return value, no companion pointer. Of the 37 apply entry points, as the tables stood
(~/w7/p5-c1-r2-sigdiff.py, which prints the pairing):
| count | |
|---|---|
| the row could carry every argument the call site passes today | 24 |
| it could not | 13 (14 counting SetResidualValueState's type mismatch) |
The thirteen split three ways, and only the first is a generator question:
(a) Nine carry a blob companion — chunkBytes, blobBytes, parameters, bytes — which is CONTRACT §2 table 1's
"companion pointer today" column. This is the whole generator change and it is five lines in Call.Signature: a
kHasBlob row gains const void* blobBytes, Uint64 blobByteCount, exactly as a kVarTail row already gains its pair.
Ten rows gained it (the nine plus GetCaps, which has no applier). --check up to date, --self-test 9/9 trips,
gen_pipe_field_ownership --check up to date. No .def file was touched.
(b) Four return a value the row cannot — ResourceCreate, ResourceRespecify, ResourceSubData,
SetTextureParams return Bool, MapPersistent returns void*. These are exactly CONTRACT §2's reply-slot rows.
MGPReplySlot is {Uint64 Id;} — an identifier, not a value — so a reader had to exist before minting one meant
anything. That is the reply mailbox (§4), and it is the part of R-17 that no amount of "thin emitter" covers.
(c) Four cannot go through a generated row at all, each for a written-down ruling. They are a hand-written third
table, gMGPipeRouteEscapes, installed and uninstalled by the same two functions so there is one mechanism and not two:
| row | why | what would overturn it |
|---|---|---|
ResourceRespecify |
initialBytes has no kHasBlob and R-13.3 forbids giving it one |
give MGPResourceDesc a blobref (c0's MGPipeTypes.h) |
ResourceFlushRange |
R-13.2: a blobref here "would be a second, forgeable way to say the same thing" | the same |
MapPersistent |
size + seedBytes have no carrier (MGPHandleOnly is {Handle, Kind}) and it returns void* |
give MGPHandleOnly a size, and P6 a real remote map |
CreateShaderState |
seven blobrefs (Spirv[6] + Reflection) and two typed frontend pointers; one blobBytes pair cannot express seven runs, and serialising under monolith to deserialise in the adapter would put EncodeProgramArtifacts on the monolith path, which PipeApply.h explicitly promises it is not |
measure that a per-stage SPIR-V run beats one archive |
So: 33 rows through the two generated tables, 4 through the escapes, 37 total — and PipeCatalogueTest asserts both
numbers, because a row moved out of the generated tables with its escape forgotten would otherwise read only as a
smaller count while its call site took a null.
Three of the 37 wrappers take one argument more than their applier, and the extra is always a byte count the record
does not declare (CONTRACT §2 rule A requires it under split; five rows already declare and the wrapper reads it back):
SetGlobalConstants (the length is GetUBOSize()), ResourceSubData's texture half (levelBytes — this closes
row 7's open half, "the byte count is the server's to compute", which table 1 itself says "cannot be a bounds check"),
and BufferSubDataResident. A defaulted argument was rejected: a default lets a site that has the number forget it and
still compile, and the failure is a silently short upload.
4. Every ruling made this round, with evidence and what would overturn it
R-17.1 — the reply mailbox is one entry deep, thread-local, and has no default answer.
Evidence: ReplySlot.h — "under R-1's verb barrier the in-flight depth is one". A second posting before the first is
taken is not a capacity problem, it is a barrier that has stopped holding, so it is Fatal{ReplyOverrun}. A take with
nothing posted is Fatal{ReplyMissing, "<row>"} — not false and emphatically not true: "always accept" is
ID-39's 66 lost uploads and "always refuse" is an emitter that re-sends for ever. ERROR is refused as an acceptance
answer at all (a transport fault is not a resource decision). Overturned when R-1's barrier retires for a family: the
mailbox becomes a slot pool keyed on seq, which is what Transport::ReplySlot already is on the wire side.
R-17.2 — the install is driven by an inline variable in the header, not a static initialiser in the .cpp.
This one was found by the gate, not designed. The first version put the installer in PipeRoute.cpp's dynamic
init, on correct reasoning about constant-initialised inline variables — and five CsoCacheTest cases SEGFAULTed in the
push and verify lanes, because every MG_Test target is its own binary over a static archive, CsoCache.h reaches the
table through an inline thunk and names no symbol in PipeRoute.o, so the linker dropped the object. The shared library
linked it and was fine, which is the shape that ships. An inline variable fixes both halves: its initialiser is a COMDAT
in every TU that includes the header, and naming MGPipeInstallMonolithTables from that header forces the archive
member into the link. Overturned by a toolchain that defers inline-variable dynamic init past first use.
R-17.3 — the client emitters run the MONOLITH adapter when they find themselves on the server role's thread.
The second gate-found defect, and the more serious one. gMGPipeScreen/gMGPipeContext are process globals; under
inproc the server role is a thread in the same process, so the apply thread running the server's own backend (the EGL
bring-up, InitCapabilities, the applier) reaches these very emitters. The first joint run died
Fatal{BarrierTimeout, "ResourceRespecify"} logged by mgl-srv-apply, thirty seconds in: the apply thread had
published a record and was waiting for itself to apply it. The predicate is v1's ServerLoop::OnApplyThread(); the
answer is not "suppress the record" but "run the server's own code", which is what PipeWireCodec already does on the
decode side. Under spawn it is constantly false in one process and constantly true in the other, so it costs one
atomic load. This is also what makes the integrator's ScopedApplierEntry bracket safe to add — on the apply thread
the emitters never reach EmitAndWait at all.
R-13.2 / R-13.3 — the contract's prescribed follow-ups had no producer, and now do.
CONTRACT §2 row 19 says initial content "arrives as ResourceSubData records immediately after this one" and row 20
says the flush's bytes "arrive ahead of it". Nothing emitted either. Evidence: the joint run died
Fatal{UncarriedInitialBytes, "resource_respecify"} on the first glBufferData with data, and then
Fatal{ProtocolCorruption} resource_flush_range ... a non-empty flush carries no bytes (offset=0, size=120, storage=120 bytes). Both are now emitted through MGPipeForEachSubDataRecordRange — the contract's own route ("reuses a
path that is already chunked and already acceptance-gated") — split-only, because under monolith the applier reads
initialBytes directly and a second upload would be a real change in the control arm. The flush stages exactly its
own range, never the whole buffer, because widening is what ID-37 forbids. Overturned if a caller is found that needs
the bytes and the range in one record — which cannot happen while the barrier holds.
ID-49 — DstSize is the tight extent and the client scatters. Ratified as issued and implemented; the emitter keeps
a zero-copy fast path when the pack state is neutral, and TheFastPathIsTakenExactlyWhenTheScatterWouldChangeNothing
drives the predicate and the scatter together, because testing either alone would pass a predicate that said "tight" for
a layout the scatter would have rearranged. The rule is format-agnostic, so the depth/stencil reads the 21 split entries
touch take it with no special case.
Ratified from round 1, no further debate, and unchanged: MGPClear::Kind (kRemoteClearWhole only); the Fbo and
ReadFbo/DrawFbo nulls; OnReadPixels writes exactly DstSize bytes — which ID-49 now defines as the tight extent,
so "exactly DstSize" means "into the reply", and the application's layout is the client's business.
R-12 — which of the four reverse-channel arms are wired. Asked and answered: OnGpuWritten, OnBufferWriteback
and OnSurfaceChanged are wired; OnCapsInvalidated is not, and deliberately. DirectGLES has no
OnCapsInvalidated producer at all; c0's ruling is that a second CapsSnapshot arrival IS the invalidation, and v1's
ServerMakeEGLCurrent/ServerInitCapabilities republish one. The joint log shows it working:
CapsMirror generation 2 adopted, then generation 3. So the fourth arm has a consumer and no producer, on
purpose, and adding one would be an eleventh MGPipeCallbacks slot for something already expressible.
5. The four self-tests
On 41992649, five build dirs, all configure + build rc=0.
G1 — against the ID-44 baseline (~/w7/p5-before-libMobileGL.so.READY = 4595163c):
.text 10806611 -> 10806611 (+0, +0.000%)
27814 -> 27814 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
nm --defined-only build-linux/libMobileGL.so | grep -ic MG_Remote -> 0
nm --defined-only build-split/libMobileGL.so | grep -ic MG_Remote -> 602
R-17 predicted "push-build-only, so G1 should be free". It is, and the proof is structural as well as measured: every
MG_Impl/Pipe/*Emit.h body is inside #if MOBILEGL_PIPE_PUSH, PipeRoute.{h,cpp} is inside it, WireTables.* is
inside #if MOBILEGL_BUILD_DISAGGREGATED, and the two tables are inline variables that stay zero in a pull build.
ctest -L unit, five lanes:
| pull | push | verify | split | verify-split |
|---|---|---|---|---|
| 1816 / 1816 | 1816 / 1816 | 1816 / 1816 | 2025 / 2025 | 2025 / 2025 |
All five 100%. The two split reds the charter listed are both gone: PipeWireCodecTest:1203 is this package's fix,
RingTest.TheTwoFlagSpacesAreDisjointByTranslation is s1's and arrived with the second merge.
ctest -L integration-gpu, build-push, MOBILEGL_TRANSPORT=monolith: 1128 / 1128, 0 failed. G2 green.
Generators: gen_pipe --check up to date, --self-test 9 trips + positive control OK,
gen_pipe_field_ownership --check up to date, check_include_closure 4 probes / 0 problems.
G2 / G14 names (~/w7/p5-c1-r2-names.sh; LC_ALL=C for both the sort and the comm):
baseline 2902, push 2944, split 3174. push-vs-baseline: 0 removed, 42 added. split-vs-push: 0 removed, 230
added, of which 21 are DirectGLES.Split. entries.
One note for the next package that renames a case: a rename is a removal to G2/G14. Rewriting
PipeCatalogue.UninstalledTablesAreAllNull cost one removed name, which is indistinguishable from a deleted case from
the gate's side. The name is kept, asserting the half that is still true (the 34 unrouted rows are null), and the new
statement is an added name beside it.
G5, the untouched regions: scripts/p3a_untouched_regions.sh ff2994d9 HEAD and the p4a twin are both rc=0 on
this head — b1's ID-41 re-pin arrived with the second merge, so the one admitted red is closed and nothing else moved.
6. integration-split: what arms it, and the first IPC frame
MOBILEGL_TRANSPORT=inproc, build-split, ctest -L integration-split: 14 / 21 pass.
Both TriangleScenario entries and all five ClearThenReadPixelsScenario entries pass, on both the default and the
SmallRing arm. The first IPC frame on the reduced path renders.
What arms the lane — the charter asked for this precisely, so: InstallClientWireTables() is called from the end
of a successful ClientSession::Start, step 9, on the GL thread (the thread that called MG_Backend::Init()), after
ServerLoop::Start has returned. Each of the four orderings is a different failure:
- after Hello/Welcome — an emitter publishing earlier writes into a ring the peer has not mapped;
- after the first
CapsSnapshot— R-8's liveness gates read the caps mirror, a placeholder mirror consumes nothing, so a record emitted earlier goes to a server this client has not been told consumes that family; - after
ServerLoop::Start—EmitAndWaitblocks onappliedSeq, and with no apply thread the firstresource_createspends 30 s in the barrier and thenFatal{BarrierTimeout}; - on the GL thread — table 3 makes
gPipeInputsits to touch while the barrier holds, and installing from the apply thread would publish the tables to the GL thread with no synchronisation at all.
UninstallClientWireTables() runs at the top of Stop(), before the rings go away, and puts the monolith
adapters back rather than nulling the rows: a null row is the pre-migration state and would be an undiagnosed crash at
whatever GL call raced teardown.
The 14/21 is measured WITH the integrator's merge-time one-liner in MG_Backend/Init.cpp applied locally, and c1 did
not commit it (the coordinator ruled it v1's). Without it the lane is 19 failed / 21 on this head, all of them
v1's weak CreateRemoteBackendObject placeholder aborting — and note that the failures are aborts, not skips, because
t1's ID-48 work made the split entries MOBILEGL_ITEST_REQUIRE_GPU. The exact patch is reproduced in
~/w7/p5-c1-r2-redcheck.py (init_patch), where two controls depend on it.
The remaining 7 are one root cause, and it is a server-side seam, not c1's. All seven are
PersistentCoherentMapScenario (both arms) and all seven abort with
Fatal{ProtocolCorruption} resource_flush_range {slot=1, gen=0, glName=1}:
a non-empty flush carries no bytes (offset=0, size=120, storage=120 bytes)
MGPipeApplyResourceFlushRange (PipeApply.cpp:1873) faults when record.Size != 0 && bytes == nullptr, and the
decode arm passes nullptr unconditionally (PipeWireCodec.cpp:1665) — correctly, because R-13.2 says the record
carries no bytes under split. The client half is landed (the covering resource_subdata now precedes the flush); the
consumer half has to read those bytes from v1's server-owned StagedShadowStore (R-11 / ID-37) instead of from a
companion pointer that no longer exists. That is the only thing between 14/21 and 21/21. The same seven are the only
integration-gpu failures in build-split under monolith (1149, 7 failed).
7. What v1, w1 and the integrator must provide
MG_Backend/Init.cpp's directMakeUnique<BackendObject_Remote>()— v1's file, the integrator's at the merge. Without it nothing in the split lane runs.PipeApplier::ApplyOne'sScopedApplierEntrybracket — v1's file, the integrator's at the merge. Until it landsApplyThreadIsInsideApplier()is permanently false and R-1's mutual-exclusion assertion is inert. §4's R-17.3 makes it safe to add.resource_flush_range's bytes under split (§6) — the last blocker for the 7.MG_Pipe/PipeApply.cpp+MG_Remote/Wire/PipeWireCodec.cpp; c1 did not touch either arm of it.MG_Remote/Wire/PipeWireCodec.cpp'snoteAcceptancenow callsPostReply, and that file is w1's. The hunk is four lines inside one lambda. It is made under R-17 because it is the server half of the routing R-17 assigns, and because the file's own comment named this as the pending edit: it said the answer could not ride a slot "until the integrator rules on which half of the contract moves (table 0 says these four use DECLINED; the catalogue gives them no slot)". Both halves have since moved the same way — ID-31 gaveResourceCreatethe flag andkMGPipeCallFlagsnow carries it on all four (PipeWire.incrows 2, 3, 47, 48), and R-17 says the acceptance answers come back through the reply slot. Without it the client cannot run at all:EmitAndWaitasks the catalogue, not the caller, so all four rows would wait for an answer nobody wrote and takeFatal{ReplyMissing}inside the barrier. Move it if it belongs elsewhere; the diff is self-contained.- One CMakeLists line each for
MG_Pipe/PipeRoute.cpp(theMOBILEGL_PIPE_PUSHlist) andMG_Remote/Client/WireTables.cpp(theMOBILEGL_BUILD_DISAGGREGATEDlist). RootCMakeLists.txtis c0's; R-17 grants the generated-table install and a build line is inseparable from it, but it is flagged rather than smuggled.
On v1's note about §8.4. v1 is right and round 1's report was wrong: TriangleScenario does not fail without the
37-entry routing under inproc — the P3a handle arm defers non-owner-thread GL touches and the apply thread drains them
at the draw, so it renders right by accident. That is not evidence against R-17; it is the strongest possible
argument for it, and it is ARCHITECTURE 10.3's exact shape. A green triangle produced by a client that executed every
resource, CSO and program record synchronously on the GL thread is a split lane running monolith, and the thing that
makes the difference visible is not the picture but ClientWireRecordsEmitted() — which is why t1's fourth arming fact
is "the client encoder's record ordinal actually moving during the case" and not "the scenario passed". The round-1
claim should be read as "needs the routing to be split", never "will not render".
8. R-16: I made every gate red once, by doing X
~/w7/p5-c1-r2-redcheck.py, log ~/w7/p5-c1-r2-redcheck.log. It extends round 1's harness with a per-case target and
binary (so a control in PipeCatalogueTest, SanityTest, PipeWireCodecTest or the integration binary is driven the
same way) and a multi-edit form for the controls whose subject is a scenario.
Run it with python3 ~/w7/p5-c1-r2-redcheck.py. Result: 20 / 20 RED, CONTROLS_THAT_DID_NOT_GO_RED=none,
all four unit binaries green again afterwards (26 / 106 / 66 / 32 cases).
| control | I made it red by |
|---|---|
| R1 the install fills the escape table | commenting out gMGPipeRouteEscapes.MapPersistent |
| R2 the install is reachable from a header | replacing the inline variable's initialiser with true |
| R3 a missing answer Fatals | renaming the ReplyMissing tag |
| R4 a missing answer is not silently false | if (g_reply.Slot == 0) → if (false) |
| R5 two outstanding answers are a barrier fault | renaming the ReplyOverrun tag |
| R6 ERROR is not an acceptance answer | renaming the ReplyError tag |
| R7 DECLINED is COUNTED | if (g_reply.Status == 1) ++Declined → if (false) |
| R8 DECLINED is not folded into accepted | return true; |
| ID47-a the boundary is the pool's real cap | CanHold → m_base != nullptr |
| ID47-b the emitter really asks the helper | passing tight * 1000 (split scenario aborts by name) |
ID49-a DstSize is the tight extent |
+ 16 |
| ID49-b the scatter honours the skips | dropping the skip terms from the destination |
| ID49-c the scatter writes the ROW, not the stride | writtenPerRow → strideBytes |
| ID49-d the fast path equals the scatter | || true in ReadbackPackStateIsTight |
| ID31 the acceptance rides the slot | deleting the PostReply from noteAcceptance |
| ID31-b the status agrees with the applier | hard-coding kStatusOk |
| R8 the liveness gate reads the mirror | putting MGPipeGetResourceOps() != nullptr back |
| R17 the role gate keeps the apply thread off the wire | RunsAsTheServerRole() → false |
v1-seam m_started before g_active |
deleting the line |
| R13.3 the bytes follow as sub-data | deleting the follow-up walk |
THE HARNESS ITSELF WAS THE FIRST THING THAT FAILED FOR THE WRONG REASON, TWICE, AND BOTH ARE WORTH THE LINES.
First: the opening run printed BUILD-BREAK (also a red) for all twenty controls and for the restore — the
submodule symlinks had been toggled off for a git command and never toggled back (PACKAGE-PREAMBLE trap 1). Twenty
controls "going red" for a reason that had nothing to do with any of them is R-16's own failure mode one level up. The
harness now has a preflight that builds all five targets before anything is broken and exits with "a red measured
against a broken baseline is not a red" if any of them fails.
Second: two controls reported STILL GREEN while in fact aborting exactly as designed — a control whose subject is a
Fatal kills the process with SIGABRT, so gtest never prints [ FAILED ] at all, and the harness was looking only
for that string. The return code is now part of the verdict.
And two controls were mis-aimed rather than the code being wrong, which is the third shape: ID49-d broke a function
its named case never called, and R13.3's subject produced no observable difference in any scenario's picture,
because every P5 scenario re-uploads its vertices through the ordinary dirty path afterwards. ID49-d got a case that
drives the predicate and the scatter together; R13.3's producer got a counted self-check — it compares
ClientWireRecordsEmitted() across the walk and Fatal{InitialBytesNotCarried}s if nothing was emitted, so the
statement "the content followed" is made where it can be made instead of left to a lane that cannot see it.
9. The G1 codegen trap (round 1) — self-contained, for ARCHITECTURE/MEASUREMENTS
A Bool-valued macro is not a drop-in replacement for a pointer-valued condition, and the difference is 144 bytes of
.text. CONTRACT-P5 §7 requires the 41 call sites that null-check aGLFunctionsTableslot to stop doing so under split, because with no null slot in the client's table every one of those checks answers "supported" and the fallback behind it silently disappears. The obvious conversion is a macro that answers the capability question as aBool:if (MGL_BACKEND_SLOT_CAP(Slot, kCapX)). In a pull build that macro expands to exactly the null check it replaced, so it looks free. It is not. Two sites inGL_Getter.cppwere written asif (const auto f = TABLE.GL.Slot)— a condition with an init-statement — and rewriting them asif (BOOL_MACRO) { const auto f = TABLE.GL.Slot; ... }is semantically identical and generates different code: G1 came back.text -144with 2 symbols resized,GLImpl::GetInteger64v−150 andGLImpl::GetIntegerv+2. The fix is a second spelling,MGL_BACKEND_SLOT_PTR_CAP/_PTR_LOCAL, which in a pull build expands to the slot expression itself, so the init-statement survives verbatim and the codegen is byte-identical.GL_Sync.cpp'sFenceSynchad the same shape and did not happen to move; it was converted to the pointer form anyway, because "did not happen to" is not a property. The general rule: when a gate requires byte-identical codegen, a macro must preserve the EXPRESSION SHAPE of what it replaces, not merely its truth value. A rewrite that changes an init-statement into a block, a short-circuit into a call, or a pointer into aboolis a codegen change even when it is not a behaviour change.
10. Debts
resource_flush_range's bytes under split (§6, §7.3) — the 7 remaining split entries. Not c1's arm.MapPersistentunder split is asserted to DECLINE, loudly.Wire_Escape_MapPersistentFatals if the server ever accepts, because a host pointer arriving there is one this client cannot dereference. R-6 says it never will; when P6 gives it a real remote map, that Fatal is the line to change.MarkGpuWritesForDispatchstill has no gate (round 1 §11.2) —DispatchComputeis class C.- The XFB span family still needs an
MGPCapBit(round 1 §11.3) before its probes can move; that is anMGPipeTypes.hedit, i.e. c0's. Encoder().MaxRecordBytesSeen()still has noPipeStatspublisher, so R-10's MEASUREMENTS number is still unowned.SetGlobalConstantsis the row most worth watching — per program per frame, unbounded length — and it is now a real staged blob rather than a companion pointer, so the number finally means something.- E2's emitter-drop control is still armed and still not RUN by c1 (round 1 §11.1).
MOBILEGL_IPC_E2_DROP_CLEAR=1is read withgetenvbecauseConfig.his c0's; adopt it intoIpcTableor tell me to take it out. - The three-way merge in
p5/c1(§2). If the integrator would rather have c1 standalone, the work commit02f15bb6is a clean cherry-pick onto any tree that already has v1 — but the two coordinator-assigned edits inBackendObject_Remote.cppwill not compile without v1'sServerLoop.h.
11. Files and scripts (the ones this report cites; the rest are deleted)
~/w7/p5-c1-r2-redcheck.py/.log— R-16, 20 controls, with the preflight and the return-code verdict.~/w7/p5-c1-r2-sigdiff.py— §3's table: all 37 apply signatures beside the generated row that replaces them.~/w7/p5-c1-r2-build.sh,-units.sh,-integ.sh,-names.sh,-isplit.sh— the five cells, the four self-tests, the integration lanes and the G2/G14 comparison.~/w7/p5-c1-r2-jointdbg.sh/-jointrun.sh— apply the integrator's merge-timeInit.cppone-liner, drive one split scenario with its log captured, revert. This is how §6's numbers and §4's two defects were found.~/w7/p5-c1-r2-symbols.md— G1's symbol report.