# 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 `.def` row 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: 1. the stamp **zeroes** the seven's `FilledGen`, and `generated/PipeFilled.inc:420` tests "never filled" *before* `:421` tests sticky — so `0` wins and the exemption is gone **without a line of the generated file changing**, i.e. without touching `gen_pipe.py` (c0's); 2. the seven carry no `MGP_INPUT_CHECK` at all, so freshness can never *reach* them. Each body in `PipeFill.cpp` opens with `MGP_STICKY_FORWARD_PULL()`, which is what actually puts them in `rsp` and makes them `Fatal` under 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: ```cpp 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: 1. `++CurrentVerbSerial` and set `m_currentVerb`, so a Fatal names the verb instead of ``; 2. **stamp** `FilledGen[i] = CurrentVerbSerial` for every field that is (RECORD-SUPPLIED or APPLIER-DERIVED) **and** in this verb's `kMGPipeClassFieldMask`; 3. **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-test` control #1, "a field in NO class (GetActiveTextureUnit's row removed)". Verified red by name. - **E4's supplied→FATAL control**: `--self-test` control #2 refuses it at generation time, and if it is forced through the *generated header*, two named cases go red — `FieldOwnershipTest.TheClassSizesPartitionTheFieldSet` and `FieldOwnershipTest.ARecordSuppliedFieldIsReadableAfterAServerStamp`. (v1 of this report said the latter goes red because "the read aborts instead of completing"; it does not — its `ASSERT_EQ` on 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: 1. **The tree already ruled this exact shape, in the file the contract cites.** `Coverage.def:62-69`, about `GetBufferBindingSlot`: *"THE ROW STAYS ONE ROW, and that is structural rather than a shortcut: this list IS the `MGPipeInputField` enum and the `PipeInputs` field set, and the field is ONE array … that a second row of the same name could only duplicate."* `m_pixelStore[2]` indexed by `isUnpack` is the same shape as `m_bufferBindingSlot[15]` indexed by a `BufferTarget`, and `GetBufferBindingSlot` is 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. 2. **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 from `FillPoints.def`. Both are c0's, `gen_pipe.py` is 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. 3. **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. 4. **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. `TheUnpackHalfOfThePixelStoreAbortsWhileThePackHalfDoesNot` pins 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 ` | 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`: ```yaml 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 1. **`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. 2. **The strict lane end-to-end.** `MOBILEGL_IPC_STRICT_ERRORS=1` is proven to abort at unit level, on reduced-path verbs (`Clear`, `DrawArrays`, `ReadPixels`) and reduced-path fields. The *lane* — a `DirectGLES.Split.*` run under strict that aborts and names the field — needs t1's ctest `ENVIRONMENT` block and a live session, and it is the last third of E4. 3. **`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 into `MG_Pipe/MGPipe.h` or 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. 4. **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. 5. **`MGPipeVerbForWireOp` has four rows.** Every phase whose record becomes a verb boundary adds its row to `MGP_VERB_OP_LIST` in `FieldOwnership.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: 1. **`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 discipline `gen_pipe_dirty_surface.py` already used (`:1574` `p.startswith("UNMAPPED")`, `:1581` `"STALE row"`, …) and the half that had been dropped. 2. **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. 3. 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: `Present` and `SetSwapInterval` (`FillPoints.def:21`, they are not verbs), `Flush` (BRIEF §12 C-3: not a slot at all, and `glFlush`/`glFinish` are empty function bodies, so there is no `MGPipeVerb::Flush` to 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: ```yaml - 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`'s `ServerStampedVerb()` and `MGPipeServerClearVerbBoundary()` 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 `TheAppliersOwnClearDisarmsTheStampWithoutTheClientsFill` reaches 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-pull` has no documented exclusion.** Correct, and I cannot close it from the source: `Managers.cpp:5334` is 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 behind `MOBILEGL_IPC_STRICT_ERRORS` instead 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` / `PipeApplier` are v1's and land this phase — and once it does, `MGPipeUnmigratedEmulation` should read it instead of `MG_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-181` cuts 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 every `MGPipeApply*` entry point touches `gPipeInputs` through `MGPipeApplyAccess`, which carries no `MGP_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 |