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.
43 KiB
p1 — the poison, the field-ownership table and the visibility of unmigrated inputs, v1
Branch p5/p1, worktree ~/w7/p5-p1, base feat/disaggregated @ 5175f9cc.
Ten commits, 5175f9cc..9d40d3e9 — round 1 388364d5..6fc1bcc8, fix round 1
6fc1bcc8..9d40d3e9. Not pushed. Working tree clean.
§7 is the fix round against p1-review-v1.md and it SUPERSEDES parts of §1, §2 and §8. Where
they disagree, §7 is newer: the self-test is 15 controls and not 11 (§7.1 M-1), the stamp map is
12 rows + 3 exemptions and not 4 (§7.1 M-2), and MGPipeServerClearVerbBoundary is mandatory for
the applier rather than optional (§7.2 M-5).
0. The one-paragraph answer
Table 2 is now generated, checked and load-bearing at runtime. 63 fields + 7 sticky forwards
= 70 rows, each in exactly one of four classes; RECORD-SUPPLIED is derived from Coverage.def
and PipeFill.cpp rather than asserted, so the table cannot drift away from the emitters it
describes. The class decides what a stale read means under split: a BARRIER-PULLED read is
counted as rsp and is Fatal under MOBILEGL_IPC_STRICT_ERRORS=1; everything else is Fatal
as today. The prerequisite — the server-side stamp — is defined, implemented and unit-pinned,
and its withdrawal half is what makes rsp a real number instead of a decoration. The seven
sticky forwards' exemption dies for free, because the stamp zeroes their generation and
PipeFilled.inc tests "never filled" before it tests sticky. MGPipeUnmigratedEmulation has
teeth. GetPixelStoreParameters is split by argument rather than into a second field id, and
§6 says why that is a deviation and what would overturn it.
1. What landed
Five commits, all single-line messages, no trailer lines.
| # | scope | what |
|---|---|---|
| 1 | MG_Pipe/FieldOwnership.def, scripts/gen_pipe_field_ownership.py, generated/PipeFieldOwnership.inc, PipeInputs.h |
the generator, its mapping file, the generated table, and the one #include that puts it where the poison check and the stamp both already are |
| 2 | MG_Backend/MGPipe/PipeInputs.{h,cpp}, MG_Impl/Pipe/PipeFill.cpp, MG_Util/Metrics/PipeStats.{h,cpp} |
the server stamp, the four-way read verdict, rsp, and the sticky forwards' hook |
| 3 | MG_Pipe/PipeApply.cpp |
MGPipeUnmigratedEmulation's split arm — one function, five call sites |
| 4 | MG_Test/Pipe/FieldOwnershipTest.cpp + MG_Test/Pipe/CMakeLists.txt |
20 cases: 6 arithmetic (any push build) + 14 behavioural (split only) |
| 5 | docs/Disaggregated/{ARCHITECTURE,MEASUREMENTS}.md |
the G8 generator row and the two stale "61 fields" lines |
1.1 The generator (deliverable 1)
scripts/gen_pipe_field_ownership.py, in gen_pipe.py's shape (write / --check / --self-test)
with gen_pipe_dirty_surface.py's mapping-file + negative-control discipline.
- Sources.
Coverage.def(the ordered 63 accessors, the 7 sticky, the 40 emitted),MG_Impl/Pipe/PipeFill.cpp(EmittedCallSuppliesTheWholeField's nine refusals, parsed out of the function rather than restated),MG_Pipe/FieldOwnership.def(the hand half),PipeCalls.def+FillPoints.def(the two name spaces the stamp map joins). - RECORD-SUPPLIED is DERIVED. emitted ∧ ¬refused. A
.defrow that claims it is a contradiction and stops the generator — which is the only thing that keeps the hand half true as the emitted list grows. - A field in no class stops the generator, so the committed header can never contain an
unclassified row, and a
static_assert(MGPipeEveryFieldIsClassified())in the emitted header catches a hand edit of the generated file. --self-test: 11 negative controls, all trip; positive control passes. They are, by name: a field in no class (GetActiveTextureUnit's row removed — E4's control), a RECORD-SUPPLIED field claimed by hand, a row naming a non-field, a BARRIER-PULLED row with no retiring phase, a fifth class, a sticky forward with no row, a forward row contradicting its field row, an argument exception that narrows nothing, the derivation's source function renamed away, and two stamp-map rows naming an op / a verb that does not exist.- Output also prints the debt by retiring phase, which is the table's whole point.
1.2 The table, as it came out
| class | count | |
|---|---|---|
| RECORD-SUPPLIED | 32 | derived |
| APPLIER-DERIVED | 1 | GetPixelStoreParameters (pack half) |
| BARRIER-PULLED | 27 | 20 non-sticky + the 7 sticky forwards |
| FATAL | 3 | GetBoundTransformFeedbackName, GetTransformFeedbackPausedPrimitiveCounter, GetProgramForDispatch |
| 63 | + 7 forward rows = 70 |
The contract's "31 fields today" for RECORD-SUPPLIED is arithmetically wrong and the right
number is 32. 40 − 9 double-subtracts GetPixelStoreParameters, which is already kNone in
kMGPipeFieldEmittedBy and so was never among the 40; only eight of the nine refusals are.
The census's own "31 of 63 fields are not served by any pushed record" is right, and
63 − 31 = 32. Nothing else in either document depends on the 31.
1.3 rsp (deliverable 2)
PipeStats::CallClass::ResidualPulls, short name rsp, inside the #if MOBILEGL_PIPE_PUSH
block (PipeStats.h), name "residual-pulls", published per frame on the summary line's
emit[...] bracket beside trp=. A process-wide raw counter
(MGPipeResidualPullCount()) sits beside it because PipeStats can be switched off and the exit
gate may not be; PipeApplier::ResidualPullCount() should forward to it (§3).
Both are incremented at one place — CountBarrierPull in PipeInputs.cpp — so the 56
checked accessors and the seven sticky forwards cannot drift apart on what a pull is.
1.4 The four-way read verdict
MGP_INPUT_CHECK grows a split arm. On a not-fresh read:
| condition | verdict |
|---|---|
| not inside a server-stamped verb | Fatal (today's behaviour, unchanged) |
| class ≠ BARRIER-PULLED | Fatal |
| field outside the verb's own class mask | Fatal |
| otherwise | ++rsp; Fatal under MOBILEGL_IPC_STRICT_ERRORS=1 |
The third row is not in the contract and is worth keeping: a BARRIER-PULLED field outside the
verb's kMGPipeClassFieldMask was never copied for this verb by the client's residual fill, so
answering it would trade a loud staleness for a quiet one. Pinned by
ABarrierPulledFieldOutsideTheVerbsClassIsStillFatal.
The arming condition is the server stamp, not the build. build-split runs
MOBILEGL_TRANSPORT=monolith in every unit and integration lane, and there the client fills and
stamps all 63 fields at every verb — so a stale read there is the same defect it is in a verify
build and gets the same Fatal. Arming on MOBILEGL_BUILD_DISAGGREGATED would have taken 1862
unit cases' ability to go red away with it.
1.5 The sticky exemption, cancelled (deliverable 4)
Two halves, and both are needed:
- the stamp zeroes the seven's
FilledGen, andgenerated/PipeFilled.inc:420tests "never filled" before:421tests sticky — so0wins and the exemption is gone without a line of the generated file changing, i.e. without touchinggen_pipe.py(c0's); - the seven carry no
MGP_INPUT_CHECKat all, so freshness can never reach them. Each body inPipeFill.cppopens withMGP_STICKY_FORWARD_PULL(<Field>), which is what actually puts them inrspand makes themFatalunder strict.
Assignments per the contract: the first five and RecordError → BARRIER-PULLED;
InvalidateCompileEnv → BARRIER-PULLED retiring in P5 via OnCapsInvalidated (see §6.2 —
there is no fifth class to put it in, and its forward row carries the mechanism). The hook is a
no-op outside a server-stamped verb, which is exactly what keeps InvalidateCompileEnv
reachable from backend initialisation — the case the exemption was written for
(PipeInputs.h:565).
1.6 MGPipeUnmigratedEmulation (deliverable 6)
One function edit in PipeApply.cpp (shared with w1 — I touched that one function and its
include block and nothing else), five call sites armed: Managers.cpp:5334,
DirectGLES.cpp:8051, :8702, :8997, :10623.
The arm is the TRANSPORT, not the build, and this is a correction to the contract's wording
("in a split build"): build-split's own 1117 integration cases run monolith and several of the
five are on ordinary monolith paths they exercise (glGenerateMipmap reaches two). Arming on the
build would have turned that lane red for running code that is correct in the role it runs in.
Pinned both ways by AnUnmigratedEmulationIsFatalUnderARealTransportAndInertUnderMonolith.
1.7 MOBILEGL_IPC_STRICT_ERRORS=1 (deliverable 5)
MG_Config::Ipc.StrictErrors (c0 landed the knob and its parse) promotes a BARRIER-PULLED read —
including the seven sticky forwards — to:
MGPipe: Fatal{UnmigratedPipeInput, "GetActiveTextureUnit@ReadPixels"} [BARRIER-PULLED,
MOBILEGL_IPC_STRICT_ERRORS=1, retires in P3b/P4b]
Same first clause as the ordinary poison Fatal so every existing filter still matches, plus the class and the phase that owes the answer — a strict abort that did not name the phase would leave the reader exactly where the gate found them.
Three named death tests assert it actually aborts:
StrictErrorsTurnsABarrierPulledReadIntoANamedAbort,
StrictErrorsAlsoPromotesTheStickyForwards, and the non-strict control
TheSameReadWithoutStrictErrorsSurvivesAndIsCounted.
2. THE STAMP RULE — v1 reads this section
Server/PipeApplier::StampVerbBoundary(MGPWireOp op) should be exactly:
void PipeApplier::StampVerbBoundary(MG_Pipe::MGPWireOp op) {
const MG_Pipe::MGPipeVerb verb = MG_Pipe::MGPipeVerbForWireOp(op);
if (verb == MG_Pipe::MGPipeVerb::kVerbCount) return; // not a verb boundary: stamp nothing
MG_Pipe::MGPipeServerStampVerbBoundary(verb);
}
Uint64 PipeApplier::ResidualPullCount() const { return MG_Pipe::MGPipeResidualPullCount(); }
Both entry points are declared in MG_Backend/MGPipe/PipeInputs.h under
#if MOBILEGL_BUILD_DISAGGREGATED and defined in PipeInputs.cpp.
WHEN. Once per record, before the record's applier runs, exactly as
PipeApplier.h already says. MGPipeVerbForWireOp is generated from
MGP_VERB_OP_LIST in FieldOwnership.def and answers kVerbCount for every op that is not a
verb boundary, so calling it unconditionally on every record is correct and cheap.
WHICH OPS. Four: Clear → Clear, DrawVbo → DrawArrays, ReadPixels → ReadPixels,
Blit → BlitFramebuffer. The two name spaces do not line up by name, which is why the map is a
table and is checked against PipeCalls.def and FillPoints.def.
Present IS DELIBERATELY NOT A STAMP POINT, although CONTRACT §7 puts it in class B:
FillPoints.def:21 — "Present and SetSwapInterval go through BackendObject virtuals and read no
frontend state, so they are not verbs here". There is no MGPipeVerb::Present,
MGPipeValidateForVerb is never called for it, and stamping there would retire the previous
verb's answers with nothing to put in their place. Pinned by
VerbBoundaryOpsAreTheFourTheStampRuleNames.
WHAT IT DOES, in three lines, the third being the load-bearing one:
++CurrentVerbSerialand setm_currentVerb, so a Fatal names the verb instead of<none>;- stamp
FilledGen[i] = CurrentVerbSerialfor every field that is (RECORD-SUPPLIED or APPLIER-DERIVED) and in this verb'skMGPipeClassFieldMask; - zero
FilledGen[i]for everything else — BARRIER-PULLED, FATAL, and anything outside the class mask.
(3) is what makes the instrumentation real. The client's residual fill stamps all 63 fields at
its own verb boundary, so without the withdrawal every field would read fresh on the server, rsp
would be identically 0, and the exit gate would be decoration — the exact "an inproc
implementation proves nothing" failure R-2 exists to prevent. It is also, for free, what cancels
the sticky exemption.
The value a BARRIER-PULLED read then gets is still the client's residual fill's, and it is still correct, because the verb barrier (R-1) leaves exactly one of the two threads runnable. That is the debt, not a bug.
CLEARING. MGPipeServerClearVerbBoundary() disarms it. The client's own
MGPipeValidateForVerb and MGPipeLeaveVerb already call it (landed here), so v1 does not
have to — but calling it when the apply thread leaves the applier is harmless and makes the flag
mean "the current stamps are the server's" even if a future phase stops routing through the
client's fill.
WHAT V1 MUST NOT DO. Do not stamp per record on non-verb ops (a set_dynamic_state between
two draws is part of the draw's verb); do not batch two verbs into one stamp (the withdrawal is
per verb and a batched stamp would let the second verb read the first's answers).
3. Acceptance
All four build directories, ~/w7/p5-p1-gate.sh.
| gate | number |
|---|---|
| configure / build, 4 dirs | rc=0 × 4, CTestTestfile.cmake present in all four |
gen_pipe.py --check |
up to date |
gen_pipe_dirty_surface.py --check / --self-test |
green / 27 controls tripped |
gen_pipe_field_ownership.py --check / --self-test |
green / 11 controls tripped, positive control OK |
check_include_closure.py |
4 probes, 0 skipped, 0 problems |
| G1 | .text 10806323 → 10806323 (+0); 27811 → 27811 defined symbols, 0 added / 0 removed / 0 resized / 0 renamed |
| G1 purity | nm pull MG_Remote = 0; split = 188 |
ctest -L unit pull / push / verify |
1791 / 1791 / 1791, 0 failed (baseline 1785 + 6 arithmetic cases) |
ctest -L unit split |
1862 / 1862, 0 failed (baseline 1842 + 20 cases) |
ctest -L integration-gpu, MOBILEGL_TRANSPORT=monolith |
build-push 1117/1117, build-split 1117/1117 |
G14 (build-push, all labels, vs p5-before-ctest-names.txt) |
0 removed, +6 added (the six arithmetic cases) |
| integration-gpu names, push vs split | identical (0 diff lines) |
Why G1 held, stated so it is not rediscovered: every new line is behind
MOBILEGL_BUILD_DISAGGREGATED or inside a translation unit the pull build does not compile.
PipeInputs.{h,cpp} and PipeFill.cpp are push-only (CMakeLists.txt:519), PipeApply.cpp is
push-only, and the generated table is included from PipeInputs.h, not from
MG_Pipe/MGPipe.h — which is the one decision in this package that G1 actually turned on,
because MGPipe.h is in the pull build's include closure. The only file that is in the pull
build at all is PipeStats.{h,cpp}, and both of its new lines are inside the existing
#if MOBILEGL_PIPE_PUSH block.
3.1 The named negative controls
- E4's field control:
gen_pipe_field_ownership.py --self-testcontrol #1, "a field in NO class (GetActiveTextureUnit's row removed)". Verified red by name. - E4's supplied→FATAL control:
--self-testcontrol #2 refuses it at generation time, and if it is forced through the generated header, two named cases go red —FieldOwnershipTest.TheClassSizesPartitionTheFieldSetandFieldOwnershipTest.ARecordSuppliedFieldIsReadableAfterAServerStamp. (v1 of this report said the latter goes red because "the read aborts instead of completing"; it does not — itsASSERT_EQon the field's class fires first and returns. Red by name either way, but the mechanism is the assertion, not the abort. Reviewer's m-7.) - the instrumentation can go red:
StrictErrorsTurnsABarrierPulledReadIntoANamedAbort.
4. The size of the debt
The exit gate wants rsp's end-of-P5 value. It cannot be measured yet: rsp counts reads
inside a server-stamped verb, and nothing stamps until v1 places the call and s1/c1 supply a
session. What can be derived now, and is, is the field debt — the distinct BARRIER-PULLED
fields each reduced-path verb class may read, intersected out of kMGPipeClassFieldMask:
| verb class | fields it may read | of those, BARRIER-PULLED |
|---|---|---|
kClear |
25 | 14 |
kDraw |
54 | 26 |
kReadback |
24 | 18 |
kBlitOrCopy |
29 | 18 |
kTextureOp |
17 | 16 |
kProgramOp |
18 | 14 |
Union over the reduced path (kClear ∪ kDraw ∪ kReadback) = 27 distinct fields, which is the
census's 20 non-sticky rows plus the seven sticky forwards. (The census's "21" counted
GetPixelStoreParameters, which is APPLIER-DERIVED here, and did not count the sticky seven,
which were invisible to the gate before this package.)
Per-frame rsp will be larger than 27, because several of these are read many times per verb —
GetFramebufferBindingSlot alone has eight Espryt call sites through
GetFramebufferBindingSlotChecked, and GetBufferBindingSlot has 18. The first real number is
v1+c1+s1's to record; the retiring-phase histogram the generator prints is what says which phase
takes which share of it:
P3b/P4b 7 P8 1
P3b/P4b (Espryt), P7 (Magma) 7 P8 (Espryt), P7 (Magma) 1
P3b/P4b, P7 3 P8 (indirect), P9 (readback), P13 … 1
P5 1 P9 3
P7 1 P7/P13 1
P7/P9 1
5. Findings
F-1. Every backend read of the pixel store passes false. All six
MGB_CTX->GetPixelStoreParameters(...) sites in the tree read the PACK half:
DirectGLES.cpp:7924, :9399, :10893, :11272, Utils.cpp:2302 and
VulkanRenderer.cpp:10980 — six, not the five the contract names; the scout named five and
did not open them. PipeFill.cpp's EmitPixelPackState says the same from the other side:
"PACK only, deliberately: nothing on the far side of the boundary reads unpack state". So the
unpack half is not merely uncarried — it has no reader at all, which is what makes FATAL the
right class for it rather than BARRIER-PULLED.
F-2. RECORD-SUPPLIED is 32, not 31 (§1.2).
F-3. The applier's derivation and the record-supplied set overlap completely. The contract
describes APPLIER-DERIVED as "the render-state mirrors, m_pixelStore[0], capability bits, the
current vertex attribute and the patch fields", but all of those except the pixel store are
also emitted, and GetCurrentVertexAttribute is emitted-and-still-pulled (the applier writes it
and cannot reproduce GLContext's cross-view conversion — PipeFill.cpp:1884-1896), so it is
BARRIER-PULLED, exactly as the contract's own 21-row list says. With "each row in exactly one
class" enforced, APPLIER-DERIVED has precisely one member: the field with a record that supplies
half of it. That is a real class, not a degenerate one — it is the shape "a record arrives and
the applier writes the field, but no row of the emitted list may claim it".
F-4. Present is class B but not a verb (§2).
6. Where I did not do what the contract said, with evidence
6.1 GetPixelStoreParameters is split BY ARGUMENT, not into a second field id
The contract (§3) and the brief (R-7, §5 p1) both say: split it into pack and unpack field ids,
kMGPipeInputFieldCount 63 → 64. I did not, and the table narrows it by argument instead —
one field row (APPLIER_DERIVED) plus one row in MGP_FIELD_OWNERSHIP_ARG_LIST
(arg0 == 1 → FATAL), consulted by the accessor through MGP_INPUT_CHECK_ARG.
Four reasons, in order of weight:
- The tree already ruled this exact shape, in the file the contract cites.
Coverage.def:62-69, aboutGetBufferBindingSlot: "THE ROW STAYS ONE ROW, and that is structural rather than a shortcut: this list IS theMGPipeInputFieldenum and thePipeInputsfield set, and the field is ONE array … that a second row of the same name could only duplicate."m_pixelStore[2]indexed byisUnpackis the same shape asm_bufferBindingSlot[15]indexed by aBufferTarget, andGetBufferBindingSlotis half-migrated in exactly the same way (8 of 15 targets carried, 7 not) without anyone proposing 15 field ids for it. The same file also says the opposite about this field, eleven lines down (Coverage.def:173-181): "Until the field is split, the whole of it keeps going through the fill loop and the pack half is simply written twice." So the precedent is genuinely two-sided and v1 of this report presented only the half that supported the decision (reviewer's q-3). What settles it for P5 is reason 4, not the precedent: the tree anticipates a split into two storage halves so that each can be independently filled and verified, and this package needed a split into two verdicts, which is a smaller thing and is available without a field id. - A second field id costs c0's files and mine cannot. The enum is generated from
Coverage.def's accessor list; the class masks come fromFillPoints.def. Both are c0's,gen_pipe.pyis c0's, and the preamble's 铁律 is that a package does not edit another's files. The argument-keyed form needed zero c0-owned files. - It would break the strangler invariant.
PipeInputs.h:140-142: "every accessor keeps the NAME, PARAMETERS and RETURN TYPE of its GLContext counterpart … so the strangler sed is type-neutral".GLContext::GetPixelStoreParameters(Bool isUnpack)is one accessor; two field ids want two accessors or a field id chosen from an argument anyway — and if it is chosen from an argument, the second id buys nothing the argument row does not. - The result is strictly stronger than the contract's. Two field ids would make the unpack
half BARRIER-PULLED — counted and silently served out of the client's fill. Because no
backend reads it (F-1), FATAL is available, and a future reader gets a named abort on its first
read instead of a stale struct.
TheUnpackHalfOfThePixelStoreAbortsWhileThePackHalfDoesNotpins both halves.
What would overturn it: a decision by the integrator that the 63 → 64 move is wanted anyway
(e.g. because the verify comparator or a later phase needs per-half stamping). The change is then
small and localised: add GetPixelStoreUnpackParameters to Coverage.def's accessor list and to
FillPoints.def's kReadback/kTextureOp rows, add its storage row to
MGP_INPUT_STORAGE_LIST, and replace the one row in MGP_FIELD_OWNERSHIP_ARG_LIST with a normal
field row. I did not pre-stage it because it would have left c0's files edited by p1.
Consequently kMGPipeInputFieldCount stays 63 and there were no asserts to move. The two
stale doc lines the package was asked to fix were stale for a different reason — they said
61 — and both are corrected to 63 (ARCHITECTURE.md:83, MEASUREMENTS.md:82).
6.2 InvalidateCompileEnv is BARRIER-PULLED with retiring phase "P5"
The contract lists the seven sticky forwards' P5 assignment as "five → BARRIER-PULLED,
InvalidateCompileEnv → OnCapsInvalidated, RecordError → BARRIER-PULLED". There is no fifth
class, and R-7.1 requires every row to be in exactly one of four. So InvalidateCompileEnv is
BARRIER-PULLED, retiring in P5, and OnCapsInvalidated is recorded as its mechanism in the
forward row (kMGPipeFieldOwnershipForwardMechanism). It is the only row in the table whose
retiring phase is P5 itself. Nothing about the runtime behaviour differs from the contract's
intent: it is counted in rsp and Fatal under strict, and it stops being either the moment
R-12's reverse channel replaces the forward.
6.3 PipeFilled.inc:421 is not edited
The contract asks that the unconditional-fresh line stop being unconditional in a split build.
It is generated by gen_pipe.py, which is c0's, and editing it there would change
MGPipeInputFieldIsFresh for every push build. It is also unnecessary: :420's
gen == 0 ⇒ not fresh is tested first, so the stamp's withdrawal already wins. Pinned by
TheStickyExemptionIsCancelledByTheServerStamp, which shows the seven fresh after a client fill
and stale after a server stamp. What would overturn it: a phase that wants the seven poisoned
without a server stamp having happened — at which point the line has to move, in c0's file.
6.4 MGPipeUnmigratedEmulation arms on the transport, not the build (§1.6)
6.5 The class-mask condition on a BARRIER-PULLED read (§1.4) is mine, not the contract's
7. Files I touched that are not mine, and what the integrator should sequence
| file | owner | what I did | conflict risk |
|---|---|---|---|
MG_Util/Metrics/PipeStats.{h,cpp} |
b1 | one enumerator, one name string, one line += — all inside the existing #if MOBILEGL_PIPE_PUSH block, appended after TextureRemintPulls |
b1 adds persistent-map-push in the same block. Textual conflict is likely and trivial; both are appends at the same point. Land either order, keep both. |
MG_Pipe/PipeApply.cpp |
shared with w1 | MGPipeUnmigratedEmulation's body (last function in the file) + one guarded #include <Config.h> |
low; w1 works in the record entry points |
MG_Test/Pipe/CMakeLists.txt |
shared | one add_executable + one gtest_discover_tests, appended |
the P4a same-point-append shape; other packages adding suites here will conflict textually |
docs/Disaggregated/{ARCHITECTURE,MEASUREMENTS}.md |
shared | ARCHITECTURE.md:83 61→63 + a G8 paragraph; MEASUREMENTS.md:82 61→63 |
b1 owns MEASUREMENTS.md:111 (20→21); different line |
.github/workflows/test.yml is t1's and I did not touch it. The two lines t1 must add, beside
gen_pipe_dirty_surface.py's at :1664-1665:
python3 scripts/gen_pipe_field_ownership.py --check
python3 scripts/gen_pipe_field_ownership.py --self-test
Without them the table is generated and committed but nothing diffs it in CI, which is exactly
the half of R-7.1 a build-level static_assert cannot cover.
8. The account left for later phases
rsp's first real value. Needs v1's stamp call and a session. §4 has the field-level ceiling and the per-phase histogram; MEASUREMENTS wants the runtime number.- The strict lane end-to-end.
MOBILEGL_IPC_STRICT_ERRORS=1is proven to abort at unit level, on reduced-path verbs (Clear,DrawArrays,ReadPixels) and reduced-path fields. The lane — aDirectGLES.Split.*run under strict that aborts and names the field — needs t1's ctestENVIRONMENTblock and a live session, and it is the last third of E4. MOBILEGL_PIPE_POISON's visibility (c0's filed note, left on p1's account). c0 closed the seven-TU defect with per-file includes. I did not move the derivation intoMG_Pipe/MGPipe.hor add a tripwire for TUs that test the macro without including its header: the derivation lives in a header that the pull build does not see, and moving it there would put a new macro on every push TU's surface — a much larger blast radius than the defect. It stays filed.- The 41 null-checked emit-table slots (CONTRACT §7's cross-cutting rule) are c1's, not touched here, but they are the same shape as this package's problem: a probe that reads as "supported" because the thing it probes cannot be null any more.
MGPipeVerbForWireOphas four rows. Every phase whose record becomes a verb boundary adds its row toMGP_VERB_OP_LISTinFieldOwnership.def; the generator refuses a row whose op or verb does not exist, so the failure mode is a red generator rather than a silently absent stamp.
§7 — Fix round 1, against p1-review-v1.md
Verdict answered: 0 BLOCKER / 5 MAJOR / 8 MINOR / 4 QUESTION, conditional on M-1, M-2, M-3. All three conditions are closed. Second commit range below; §3's numbers re-run in full.
7.1 The three conditions
M-1 — a vacuous negative control, and the harness that let it be vacuous. CLOSED.
The reviewer is right, and the root cause is the part worth keeping. expect_trip caught any
SystemExit and asked nothing about which one, so control #4's raw replacement string could
mangle the row past ROW_RE's reach, make the row disappear, and exit with control #1's
message while the report counted a trip for #4. The guard that every debt row names its retiring
phase had no control at all.
Three changes, in order of importance:
expect_trip(name, because, fn)now takes the substring the control's own message must contain and fails when the message belongs to another control, printing both. This is the disciplinegen_pipe_dirty_surface.pyalready used (:1574p.startswith("UNMAPPED"),:1581"STALE row", …) and the half that had been dropped.- A harness control, so the harness itself cannot rot back: control #1's edit, asserted against control #4's reason, must be rejected, and the self-test exits if it is accepted. That is the reviewer's instrumentation made permanent instead of thrown away.
- Control #4's replacement is no longer a raw string.
Re-audit of every control under the stricter harness, as instructed: each was re-run with its
actual exit message printed and compared. Evidence in ~/w7/p5-p1-selftest-evidence.log
(produced by ~/w7/p5-p1-selftest-evidence.py, which monkeypatches expect_trip and changes
nothing on disk). Result:
15 controls, 15 DISTINCT exit messages, 15 asserted against their own message
No second duplicate existed — #4 was the only one — but the check can no longer be skipped, and the count went 11 → 15 because M-2 added four.
M-2 — the stamp map could not see an OMITTED row. CLOSED.
check_verb_ops now asks the other direction. The required set is derived twice, not
asserted: a call is verb-shaped if (a) PipeCalls.def gives it the kind kCtxVerb — the
catalogue's own word for it — or (b) its name is also an MGPipeVerb name in FillPoints.def.
That is 15 calls, and every one must have a stamp row or an exemption row with a reason.
The map went from 4 rows to 12 rows + 3 exemptions:
- the four class-B boundaries (
Clear,DrawVbo,ReadPixels,Blit) — unchanged; - eight mapped ahead of the phase that will emit them:
LaunchGrid→DispatchCompute,MemoryBarrier,BeginStreamOutput→BeginTransformFeedback,EndStreamOutput,PauseStreamOutput,ResumeStreamOutput,GenerateMipmap,GetTextureImage. All are class C today and cannot arrive in P5, which is why mapping them is free — and the reviewer's point is that the failure of not mapping them is silent, so free is the right price; - three exemptions with their reasons in the file:
PresentandSetSwapInterval(FillPoints.def:21, they are not verbs),Flush(BRIEF §12 C-3: not a slot at all, andglFlush/glFinishare empty function bodies, so there is noMGPipeVerb::Flushto name).
Four new negative controls, each asserting its own message: an omitted row (#12), an exemption
for a call that was never required (#13), an exemption with no reason (#14), and — the one
that keeps the derivation honest — #15, the catalogue's kCtxVerb kind renamed away, which
collapses the required set and must be caught. VerbBoundaryOpsCoverEveryVerbShapedCall pins all
twelve rows, the three exemptions and two non-boundaries at runtime.
Not claimed, and the .def says so: a call that is a verb boundary, is not kCtxVerb, and is
renamed. ResourceCopyRegion is the one in the tree and it maps to three verbs
(CopyImageSubData / CopyTexSubImage2D / CopyTexImage2D), so it cannot be a row without a
rule for choosing; the phase that emits it writes its row. §8.5 of this report was wrong in the
direction that mattered — it claimed the failure mode was a red generator rather than a silently
absent stamp — and is superseded by this section.
M-3 — --check ran in no CI job. CLOSED, and it is t1's file.
Landed as a step in the pipe-gates job of .github/workflows/test.yml, immediately after the
dirty-surface step its siblings live in:
- name: MGPipe PipeInputs field-ownership table is complete (R-7.1, table 2)
run: |
python3 scripts/gen_pipe_field_ownership.py --check
python3 scripts/gen_pipe_field_ownership.py --self-test
No branch guard, deliberately, unlike the two G5 steps below it: the question is "does the
committed table still follow from the .def files", which every branch can answer and which
outlives feat/disaggregated.
Why the existing "Regenerate the MGPipe interface (G1-G7)" step does not already cover it: that
step runs gen_pipe.py and diffs MobileGL/MG_Pipe/generated, and gen_pipe.py does not write
PipeFieldOwnership.inc — so a drifted ownership table passes it untouched. The reviewer proved
in §E4 control C that a hand edit changing a class builds clean (the static_assert catches
only kUnclassified), so --check is the only thing in the tree that catches it.
.github/workflows/test.yml is t1's file. I landed the step rather than skipping it, on the
coordinator's instruction. It is a pure insertion of one step between two existing ones, so the
merge is textual and trivial — but the integrator should sequence it against t1.
7.2 The other MAJORs
M-4 — the stamp asserts freshness from the table, not from the records that arrived
Not changed. Documented — and the reviewer's proposed repair does not work as stated, which is the useful half of this answer.
The finding is right: for the 33 RECORD-SUPPLIED + APPLIER-DERIVED fields, a dropped emitter or an over-eager suppressor now renders wrong instead of aborting, and the report did not say so.
The suggested repair — "have MGPipeApplyAccess's writers stamp the field they write, and let
the verb boundary only withdraw" — would abort on nearly every verb. MGPipeInputFieldIsFresh
requires gen == CurrentVerbSerial for a non-sticky field, and the applier's mirror is
persistent across verbs by design: bind_render_state / set_dynamic_state /
set_sampler_views are all suppressed when nothing changed (PipeFill.cpp:1917-1923), so a field
written at verb N and legitimately not rewritten at verb N+1 would carry stamp N, read stale and
Fatal. The client's fill does not have this problem because it copies every field in the class
mask at every verb; the applier structurally cannot.
So the real choice is between three designs, and it needs a c0 ruling, because two of them
change MGPipeInputFieldIsFresh, which gen_pipe.py generates:
| rule | catches a dropped emitter? | cost | |
|---|---|---|---|
| A (landed) | the boundary stamps by class + mask | no | 0 |
| B | writers stamp; the boundary stamps a supplied/derived field only if it already has a non-zero generation | yes, for a field whose record never arrives | one call per applier write site in PipeApply.cpp (w1-shared): 6 sites + MGPipeDeriveRenderStateFields' 29 fields |
| C | writers stamp; supplied/derived become server-sticky (gen != 0 ⇒ fresh) and the boundary withdraws only the other two classes |
yes, same scope as B, and it is the honest generation model for a mirror that persists | B's cost plus a change to MGPipeInputFieldIsFresh in gen_pipe.py |
Neither B nor C catches the case the reviewer names first — a chunk dropped from a record that
does arrive — because the write site still runs. That case's oracle is the verify lane's
compare-at-read, which is what MOBILEGL_PIPE_VERIFY is for and which does not exist under split;
saying so is more useful than implying a stamp could cover it.
Recommendation: C, in a later round or a later phase, not mid-flight. It touches a c0 file and a w1 file and it changes the rule v1 is coding against now. Landing A and writing this table down is the smaller risk. The integrator should rule before v1 places the call if they disagree.
M-5 — MGPipeServerClearVerbBoundary was described to v1 as optional. CLOSED.
The reviewer is right that it holds only for inproc: in a spawned server MG_Impl is not in the
process, nothing calls MGPipeValidateForVerb, and m_serverStampedVerb would latch TRUE for the
life of the server — after which MGPipeStickyForwardPull stops being a no-op outside a verb and
InvalidateCompileEnv from a later context's backend initialisation (the exact case the sticky
exemption exists for) is counted and, under strict, aborts.
PipeInputs.h'sServerStampedVerb()andMGPipeServerClearVerbBoundary()now say MANDATORY for the applier, with that failure written out.- §2 of this report is superseded on that point: v1 must clear on leaving the applier.
- New named test
TheAppliersOwnClearDisarmsTheStampWithoutTheClientsFillreaches that path directly — stamp, pull a forward, clear, pull it again, assert the count did not move — instead of relying on the client's fill, which is what the old test did.
7.3 MINOR
| # | disposition |
|---|---|
| m-1 | Fixed. AServerStampMakesRecordSuppliedFieldsFreshAndWithdrawsTheRest now also asserts four named fields against expectations that are arguments of this package rather than lookups into the array under test: GetClearColor and GetRenderStateParameters fresh, GetFramebufferBindingSlot and RecordError withdrawn. The loop stays, because it is what catches a stamp that disagrees with the table. |
| m-2 | Fixed. The argument-keyed abort now prints [argument 0 = 1 is FATAL while the field is APPLIER-DERIVED] after the standard Fatal{UnmigratedPipeInput, "…@…"} clause, so it is no longer byte-identical to a stale pack read. Asserted in TheUnpackHalfOfThePixelStoreAbortsWhileThePackHalfDoesNot. |
| m-3 | Not fixed; documented at the stamp entry point. draw_vbo carries no verb id, so all twenty draw verbs stamp as DrawArrays. The class mask is right and only the NAME in a Fatal is wrong. Fixing it needs a field on the record or a second argument to the stamp, and it belongs with the phase that widens draw_vbo to the multi-draw family (P8). Written into PipeInputs.h's note (b) so v1 does not rediscover it. |
| m-4 | Fixed. MGPipeInputArgumentRead returns Bool handled and MGP_INPUT_CHECK_ARG skips the field-level check when the argument row decided. Worth noting the bug would have been the other way round from the report's guess: with the field's own class not BARRIER-PULLED, the field-level check would have aborted a read the argument row had just declared legal, rather than double-counting it. |
| m-5 | Fixed (comment). MGPipeResidualPullCount's declaration now states that g_residualPulls, m_serverStampedVerb and FilledGen[] all rest on the verb barrier's mutual exclusion — CONTRACT §4's ruling for gPipeInputs itself — and that MOBILEGL_IPC_VERB_BARRIER=0 is therefore a data race on all three as well as the correctness failure it exists to show. |
| m-6 | Documented here. PipeApplier::m_residualPulls (c0's Server/PipeApplier.h:99) is vestigial under §2's snippet: ResidualPullCount() forwards to the process-wide counter, because the count is made at the accessor and the accessor has no applier to reach. v1 should delete the member rather than wire both. |
| m-7 | Fixed in §3.1. |
| m-8 | Fixed in §1.5 and §6.3 (:419/:422 → :420/:421). |
7.4 QUESTION
- q-1 —
texture-remint-pullhas no documented exclusion. Correct, and I cannot close it from the source:Managers.cpp:5334is reached from the image-bindable re-mint transition, BRIEF §4's reduced-path exclusions do not name it, and OpenRA's fixture is the only thing that could answer. The consequence of being wrong is an abort in E2's inproc arm, not a degraded frame — the safe direction for a gate and the loud direction for a lane. Two cheap ways out if the integrator does not want the risk: run the OpenRA fixture once with the other four sites armed and this one still(void)name;, or put the five sites behindMOBILEGL_IPC_STRICT_ERRORSinstead of the transport. Integrator's call; I have not taken it. - q-2 — the transport-keyed arm is inert in a server that does not inherit the env. Right, and
the third option the reviewer names is better than either of mine: key on "am I inside a server
role". That predicate does not exist yet —
ServerLoop/PipeApplierare v1's and land this phase — and once it does,MGPipeUnmigratedEmulationshould read it instead ofMG_Config::Transport. P6's account, because P6 is where a child process without the variable can exist at all; under inproc the variable is this process's and correct. - q-3 —
Coverage.def:173-181cuts against §6.1. Accepted; §6.1 now quotes both halves and says which reason actually carries the decision (reason 4, not the precedent). - q-4 — non-boundary records apply under the previous verb's stamp. Accepted and now written
into the rule v1 inherits, as note (a) at
MGPipeServerStampVerbBoundary's declaration: it is correct today because everyMGPipeApply*entry point touchesgPipeInputsthroughMGPipeApplyAccess, which carries noMGP_INPUT_CHECK; the day one of them calls back into the backend, its reads will be judged against a verb they do not belong to.
7.5 Fix-round acceptance, re-run in full
Second commit range: 6fc1bcc8..9d40d3e9. Everything below was re-run from the gate script, not
carried over.
| gate | fix round | round 1 |
|---|---|---|
| configure / build, 4 dirs | rc=0 × 4, CTestTestfile.cmake present in all four |
same |
gen_pipe.py --check |
up to date | same |
gen_pipe_dirty_surface.py --check / --self-test |
green / 27 controls tripped | same |
gen_pipe_field_ownership.py --check |
green | green |
gen_pipe_field_ownership.py --self-test |
15 controls, each asserted against its OWN message; harness control OK; positive control OK | 11, one of them vacuous |
| per-control evidence | 15 distinct exit messages / 15 controls (~/w7/p5-p1-selftest-evidence.log) |
— |
check_include_closure.py |
4 probes, 0 skipped, 0 problems | same |
G1 (--threshold 0) |
.text 10806323 -> 10806323 (+0); 27811 -> 27811, 0 added / 0 removed / 0 resized / 0 renamed |
+0, 0/0/0/0 |
| G1 purity | nm pull MG_Remote = 0; split = 188 |
same |
ctest -L unit pull / push / verify |
1791 / 1791 / 1791, 0 failed | 1791 × 3 |
ctest -L unit split |
1863, 0 failed (+1: the new applier-clear case) | 1862 |
integration-gpu, MOBILEGL_TRANSPORT=monolith |
push 1117/1117, split 1117/1117 | 1117 / 1117 |
G14 vs p5-before-ctest-names.txt |
0 removed, +6 added (one of the six renamed this round; the baseline is the phase base, so a rename of my own round-1 name is not a deletion) | 0 removed, +6 |
| integration-gpu names, push vs split | identical, 0 diff lines | identical |