Files
MobileGL/docs/Disaggregated/notes/p2/p2-results/spans-review-v3.md
T
swung0x48 aba329cc53 [Docs] (Disaggregated): P6's plan and contract draft; the working notes move from a local directory into the repository
Two things land together: the plan and contract draft P6 needs before it starts, and the
working notes that until now existed on exactly one machine.

1. P6's plan and contract draft (neither started; not one line of code)

     docs/Disaggregated/P6-SPAWN-PLAN.md      the package plan
     docs/Disaggregated/P6-CONTRACT-DRAFT.md  the contract draft (moves to
                                              MG_Remote/CONTRACT-P6.md when c6 lands)

   The three findings that mattered, all written into the documents:

   a. P6 is SMALLER than its roadmap cell suggests. The transport primitives are already in
      the tree and already tested: SocketDoorbell including hangup detection and the two
      lost-wakeup fences (Doorbell.cpp:211-360, four cases in FdPassingTest), SCM_RIGHTS fd
      passing, ShmSegment::Adopt, and the SurfaceOp / WindowKind schema already defined in
      protocol.fbs. inproc uses a real second shm mapping rather than an alias, and
      SessionRings.h:22-28 says that was done so today is not the first time it runs. P6 is
      assembly plus a control plane plus a process, not "write a socket transport".

   b. The evidence for "P6 is only a transport swap" has EXPIRED. It was bought by P5c, whose
      audit found 59 direct memory accesses in a tree that already looked clean. P5e changed
      the tree again. So the first package, a6, is a read-only audit that writes no code, and
      every contract row that depends on it is marked PENDING a6 rather than decided in
      advance.

   c. P6 does not get a game running on the phone. ANativeWindow* is meaningless in the child,
      and protocol.fbs:186-196's own comment says Android transfers the window out of band -
      that band is P12. P6 lands pbuffer / surfaceless / offscreen, which is what HeadlessGL,
      the split-equivalent lane and trace replay need, and which is exactly what P6's own exit
      gate measures. A real window reaching the server is a named refusal. This gets its own
      section because "P6 is done" would otherwise read as "the game runs now".

   The contract adds rule G: a role may not name a process-local handle. It extends P5c's
   rule E (a role may not name the other role's memory) from memory to identity - EGLDisplay /
   EGLSurface / EGLContext / ANativeWindow* / fd number / pid / mapped address either cross as
   a token this contract defines or they do not cross, and a descriptor crosses only through
   SCM_RIGHTS, where the kernel renumbers it.

   What P5e left for P6 gets its own section. The latch semantics are already designed
   (ARCHITECTURE.md:504) and are copied unchanged. What is new is that after run-ahead the
   client no longer waits while the peer process can DIE: the client holds records that were
   published and will never be applied, and Android's freezer suspends the child without
   closing anything. So slow and dead must be distinguishable WITHOUT a timeout threshold.
   That is P6's only new design; everything else is carriage. It shares a predicate with E1's
   outstanding re-specification (ID-122), and the two should be designed together.

   Two gates carried over from P5e's lessons: G2 requires integration-spawn's test-name set to
   match integration-split's name for name, because a differing set means the lane is quietly
   running less; and the arm-proof gate requires every entry to record the child pid and
   transport=spawn in its OWN private log - ID-124 established that this kind of false green
   really happens, and a spawn lane that actually ran monolith would pass every other gate.
   S2's shape must be settled before it is written, and the document says why: E1 is the
   cautionary case.

2. The working notes move into the repository (docs/Disaggregated/notes/, 415 .md files)

   ROADMAP / CURRENT_STAGE_PROGRESS / MEASUREMENTS cite ruling numbers, audit line numbers and
   the provenance of gate figures from ~/w7/notes/, a directory that exists on one machine and
   is under no version control. A record cited hundreds of times that lives only locally is not
   a record, so it moves in whole, with its directory structure intact.

   Only .md moves. Scripts, run logs, census and gate result JSON, patches, APKs and nm dumps
   stay where they are: they are evidence DATA rather than documents - large, regenerated per
   run, and mostly carrying absolute paths and device serials that mean something only on the
   machine that produced them. The mapping and this split are written in
   docs/Disaggregated/notes/README.md.

   Two exceptions are recorded there too: P6's BRIEF has been promoted to a first-class
   document and keeps no copy under notes/, so the two cannot drift apart; and recovered/ holds
   material salvaged from failed workflow runs, which may duplicate the like-named phase
   directories and is kept because a few of those were the only complete version at the time.

   CI's citation lint takes docs/Disaggregated/*.md only (non-recursive), and notes/ is
   deliberately outside it: those notes' file:line citations were written against their own
   code heads, and resolving them against today's HEAD would fail wholesale - which is not an
   error, it is their correct state as a historical record. To check one, use the revision it
   declares (--rev).

3. Inconsistencies fixed in passing

   - README.md's status line still said P5e was in progress while the stage table already said
     closed.
   - CURRENT_STAGE_PROGRESS's next-step item 1 still listed the exit gate as pending, though
     (a) and (b) were run in the previous commit; rewritten to closed plus the one item that
     actually remains (E1).
   - ROADMAP's P6 row still had the pre-phase plan in three of its cells; it now carries the
     package order, the scope boundary and the two new gates.

Checked with check_doc_citations.py: 125 citations across docs/Disaggregated/*.md, 0 problems.
2026-09-18 23:31:39 -04:00

253 lines
21 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Adversarial review of `p2/spans` — round 3 (`~/w7/p2-spans` @ `842af233`)
Verdict: **approved — 0 majors, 11 minors.**
Scope reviewed: the full diff `refs/tags/p2/contract (9c6a8a25)..842af233`, per commit, i.e. the ten
commits of `c1`/`c2`/`c3` plus the three rework rounds. The contract commit `c0` itself is another
package's; where a finding lands in `c0` it is marked so.
Tree state on entry and on exit: `git status --porcelain` empty at `842af233`; all three build
directories report `ninja: no work to do`. The one experiment that patched a file (§3) reverted with
`git checkout --` and rebuilt; the tree was re-confirmed clean and 11/11 green afterwards.
---
## 1. What I re-ran independently (command → observed)
All in `~/w7/p2-spans`, `CCACHE_BASEDIR=/home/swung/w7`. Raw logs: `~/w7/rev-spans-gates.txt`,
`~/w7/rev-spans-nc.txt`, `~/w7/rev-spans-nc-ctest.txt`.
| gate | command | observed |
|---|---|---|
| build | `cmake --build build-{linux,push,verify} -j 12` | `ninja: no work to do` ×3, rc 0 — §2 of the result file was produced against this checkout |
| **G1** | `python3 scripts/symbol_report.py --before ~/w7/p2-before-libMobileGL.so --after build-linux/libMobileGL.so --threshold 0` | `27799 -> 27799 defined symbols: 0 added, 0 removed, 4 resized, 0 renamed`; `.text +160`, `.data/.bss/.rodata +0`. Resized: `RenderState::RenderState()` +148, `RenderState::SetCapability` +77, `RenderState::IsCapabilityEnabled` +29, `_GLOBAL__sub_I_DirectGLES.cpp` −9. See minor 3. |
| **G5** | `awk '/^ namespace RenderStateImpl \{/,/^ \} \/\/ namespace RenderStateImpl/' MobileGL/MG_Backend/DirectGLES/DirectGLES.cpp \| sha256sum` | `d8fd1c48…0efe27`, byte-equal to `~/w7/p2-before-syncrenderstate.sha` ✅ |
| **G13** | `grep -rc 'pGLContext' MobileGL/MG_Backend \| grep -v ':0$'` | empty (rc 1) ✅ |
| **G13** | `python3 scripts/check_include_closure.py` | `4 probes, 0 skipped, 0 problem(s)` rc 0 ✅ |
| **G13** | `gen_pipe.py --check` / `--self-test` | `generated files are up to date` rc 0; `7 negative-control trip(s), positive control OK` rc 0 ✅. `--check` prints `63 PipeInputs fields (7 sticky, 33 emitted by a P2 call)` — the 34→33 of minor 1 of the previous round is real and regenerated. |
| unit | `ctest --test-dir <d> -L unit --no-tests=error -j 12` | **100% passed, 0 failed, out of 1504** in `build-linux`, `build-push` and `build-verify` ✅ (the result file's number confirmed) |
| **G6** | `ctest --test-dir build-push -R 'RenderStateSpans\.'` | 11/11 pass; `build-verify` 11/11; `build-linux` 11/11 as visible SKIPs |
| c3 | `ctest -R 'SlotAllocator\.'` ×3 | 6/6, 6/6, 6/6 |
| **G10 (unit half)** | `ctest --test-dir build-verify -R 'Residual' --no-tests=error` | 6/6 pass, and 3 of the 6 are the wire itself (`ResidualTripWire*`) — `-R Residual` no longer reaches only `static_assert` catalogue cases ✅ |
| **G2 (shape)** | names of `build-linux` vs `build-push` | 2382 vs 2382, `diff` empty ✅ |
| **G14** | `comm -23 ~/w7/p2-before-ctest-names.txt <names>` | **0 removed**; 19 added (11 `RenderStateSpans.*`, 6 `SlotAllocator.*`, `Tracker`/`CsoCache` placeholders) ✅ |
| ownership | `git diff --name-status p2/contract..HEAD` | 9 files, all A-owned per §C.5; `git diff --name-only … -- tools/trace_replay/fixtures` = 0 ✅ |
Which build takes which trip-wire arm — checked, because D-10's claim depends on it:
`compile_commands.json` gives `build-push` = `MOBILEGL_PIPE_PUSH=1` with `MOBILEGL_PIPE_VERIFY`
absent, and `PipeInputs.h:20-26` derives `MOBILEGL_PIPE_POISON=0` at INFO with
`MOBILEGL_BUILD_DISAGGREGATED=OFF`. So **`build-push` exercises the counted-and-logged arm and
`build-verify` the fork/`SIGABRT`/`Fatal{…}` arm** — both halves of `MGP_TRIP_WIRE_REPORT`
(`PipeApply.cpp:30-40`) actually run under the gate set. The claim is not self-certified.
---
## 2. I re-derived the chunk table and the split rule myself
The claim under test is `MGPipeRenderStateSpans.h:20-22`: *a byte is pipeline iff some public
`RenderState` setter that calls `BumpVersions()` writes it.*
Boundaries recomputed from `MGPipeValueTypes.h`'s declaration order and alignment, against
`MGPipeRenderStateSpans.h:58-98`:
| chunk | range | size | verdict, from `RenderState.cpp` |
|---|---|---|---|
| D0 `[0,264)` | Viewports[16], LineWidth, PointSize | 264 | `SetViewport(:78)`, `SetViewportIndexed(:98)`, `SetLineWidth(:113)`, `SetPointSize(:203)` — all `++m_version` ✔ |
| P0 `[264,292)` | PatchVertices, Outer, Inner | 28 | `:214`, `:233`, `:244` — all `BumpVersions()` ✔ |
| D1 `[292,312)` | PolygonOffset{Factor,Units,Clamp}, ClipOrigin, ClipDepthMode | 20 | `SetPolygonOffsetClamped(:276)`, `SetClipControl(:288)` — `++m_version` ✔ |
| P1 `[312,584)` | BlendStates[8], LogicOp, DepthTestEnabled, DepthFunc, DepthMask, ColorMasks[8], the three D3 bools | 272 | `SetBlendFunc/Equation(+Indexed)`, `SetLogicOp`, `SetCapability(DepthTest)`, `SetDepthFunc/Mask`, `SetColorMask(+Indexed)` — all `BumpVersions()` ✔ |
| D2 `[584,752)` | ClearColor/Depth/Stencil, BlendColor, DepthRanges[16] | 168 | `:711,:722,:733,:744,:760,:775` — `++m_version` ✔ |
| P2 `[752,784)` | SampleCoverageValue/Invert, SampleMaskValue, MinSampleShadingValue, **StencilStates[0].Func** | 20+12? → **20** | `SetSampleCoverage(:791)`, `SetSampleMaskValue(:806)`, `SetMinSampleShadingValue(:820)`, `SetStencilFunc`'s conditional `++m_pipelineStateVersion(:649)` ✔ |
| D3 `[772,784)` | face 0 Ref/ValueMask/WriteMask | 12 | `SetStencilFunc(:648)` / `SetStencilMask(:657)` — `++m_version` only ✔ |
| P3 `[784,800)` | face 0 the three ops + face 1 Func | 16 | `SetStencilOp(:671)` `BumpVersions()`, face-1 Func as above ✔ |
| D4 `[800,812)` | face 1 Ref/ValueMask/WriteMask | 12 | ✔ |
| P4 `[812,840)` | face 1 ops, CullFaceEnabled, CullFaceMode, FrontFaceMode, ProvokingVertexMode | 28 | `SetCullFaceMode(:894)`, `SetFrontFaceMode(:905)`, `SetProvokingVertexMode(:916)`, `SetCapability(CullFace)` — `BumpVersions()` ✔ |
| D5 `[840,868)` | 4 hints, PointFadeThresholdSize, PointSpriteCoordOrigin, ClampReadColor | 28 | `SetHint(:131)`, `:147`, `:157`, `:167` — `++m_version` ✔ |
| P5 `[868,876)` | PolygonModeFront/Back | 8 | `SetPolygonMode(:178)` `BumpVersions()` ✔ |
| D6 `[876,880)` | PrimitiveRestartIndex | 4 | `:192` `++m_version` ✔ |
| P6 `[880,904)` | the 20 capability bools + ScissorTestEnabledMask | 24 | every `SET_CAPABILITY` arm `:313`, `SetCapability(ScissorTest) :360`, `SetCapabilityIndexed(ScissorTest) :460` — `BumpVersions()` ✔ |
| D7 `[904,1168)` | ScissorBoxes[16], ScissorBoxWrittenMask, ClipDistanceEnabledMask | 264 | `SetScissorBox(:948)`, `SetScissorBoxIndexed(:969)`, the ClipDistance arm's deliberate `++m_version` (`:377-381`) ✔ |
Sums: 396 pipeline + 772 dynamic = 1168 = `sizeof(RenderStateParameters)`. **The partition is exact,
sorted and complete, and I found no byte on the wrong side.** The subset hash therefore moves iff
`m_pipelineStateVersion` moves for all 47 public setters; the walk in `RenderStateSpansTest.cpp:349-556`
drives every one of them (I diffed it against `RenderState.h:30-153` — nothing is missing), each with
a vacuity guard (`:340`) so no case can pass by writing the value already stored.
Corollary I confirm independently: **T-2 is right and the brief's D6 table is wrong** — chunk P2 ends
at `StencilStates[0].Ref`, so it contains `StencilStates[0].Func`; the brief's own P2 row claims 20
bytes for four members measuring 16. **T-1 is right** — `ScissorTestEnabledMask` is a `DynamicTailKey`
input *and* pipeline state, and `RenderStateSpansTest.cpp:765-770` asserts the direction that makes a
later demotion loud rather than silent.
---
## 3. Independent negative control: the G6/G7 gate does go red for its own reason
The result file's control moves the P1/D2 boundary (demotes `ColorMasks`). I ran a **different** one,
so the answer is not the implementer's: demote `ScissorTestEnabledMask` out of P6 into D7 by moving
the last boundary from `offsetof(…, ScissorBoxes)` to `offsetof(…, ScissorTestEnabledMask)`
(`MGPipeRenderStateSpans.h:96`), with the two byte-count `static_assert`s (`:190-191`) adjusted to
392/776 so the control still **compiles**, as D19 requires.
```
build rc=0
ctest --test-dir build-push -R 'RenderStateSpans\.' --output-on-failure → rc 8
1/11 RenderStateSpans.ChunkTablePartitionsTheBlock ............ ***Failed
2/11 RenderStateSpans.SetterConsistency ....................... ***Failed
4/11 RenderStateSpans.DynamicChunksCoverMagmasDynamicTailKey .. ***Failed
73% tests passed, 3 tests failed out of 11
```
with, in the log:
```
RenderStateSpansTest.cpp:287: ScissorTestEnabledMask is named as pipeline state but only 0 of its 4
bytes are in the pipeline half - the rest have silently left the CSO's identity
RenderStateSpansTest.cpp:342: SetCapability(ScissorTest): the pipeline-subset hash held but
m_pipelineStateVersion MOVED
RenderStateSpansTest.cpp:342: SetCapabilityIndexed(ScissorTest, 5): … MOVED
RenderStateSpansTest.cpp:342: SetCapabilityIndexed(ScissorTest, 0): … MOVED
RenderStateSpansTest.cpp:766: ScissorTestEnabledMask moved into the dynamic half; …
```
`DerivationMatchesTheFrontendGetters` and `IncrementalChunksKeepEveryDerivedFieldInStep` correctly
stayed **green** (the block is still fully carried, only its halves moved), which is the discrimination
you want. Reverted, rebuilt, 11/11 green, `git status` empty.
So G6/G7's test is not a test that cannot fail, it names the setter, and the membership half
(`IsWhollyPipeline`, added in `ad1238bd`) catches the partial-demotion case the hash cannot see.
---
## 4. The other things I hunted for, and what I found
- **A subset hash that disagrees with the pipeline version for some setter** — none; §2 re-derives all
47. `MGPipeComputePipelineSubsetHash` (`MGPipeRenderStateSpans.cpp:188-195`) gathers exactly the
seven pipeline chunks in ascending order and `MGPipeHashPipelineBytes` hashes the same bytes; their
agreement is asserted at `RenderStateSpansTest.cpp:850`.
- **State that silently changed meaning in the CSO or the dynamic payload** — none. The strongest check
is `ExpectAssembledBlockIsTheLiveBlock` (`RenderStateSpansTest.cpp:217-224`): a `memcmp` of the whole
1168-byte assembled block against the live one, driven after the whole-block *and* after every
incremental step. That is the only cover for the ~25 members with no derived field (the ones Espryt's
span `memcmp` reads raw), and it is present.
- **A memo that can serve a stale answer** — the applier holds no derived-value memo. The one scoping
risk is `MGPipeDeriveRenderStateFieldsForChunks`' four guards. I checked each guard's chunk set
against the members its block reads (`PipeApply.cpp:96-107`): blend loop = chunks(BlendStates|ColorMasks)
= P1; viewport = D0; depth range = D2; scissor-enable = P6; capability walk = P1|P4|P6|D7 (the 20
bools in P6, `DepthTestEnabled` and the three new bools in P1, `CullFaceEnabled` in P4, `BlendStates`
in P1, `ScissorTestEnabledMask` in P6, `ClipDistanceEnabledMask` in D7 — complete because
`MGP_PLAIN_CAPABILITY_LIST` includes `DepthTest` and `CullFace`). Every guard is computed from the
boundary table, so a boundary move recomputes it. `IncrementalChunksKeepEveryDerivedFieldInStep`
drives all 35 capabilities one at a time through the scoped path, which is the case that would catch
a too-narrow guard.
- **A field marked emitted that nothing writes** — I walked all 33 rows of `MGP_COVERAGE_EMITTED_LIST`
against `DeriveRenderStateFields`/the seven apply entry points. Every one has a writer. This is the
check that makes minor 1 of the previous round (`GetPixelStoreParameters`) the right call rather than
a cosmetic one: with the row present, the *unpack* half would have had no writer at all.
- **A dirty bit never set or never cleared** — the applier's only latched state is
`ScatteredChunkBits` (`PipeApply.h:77`), set by bind and set_dynamic_state, cleared only by
`MGPipeApplierReset()`. That is correct for one context and is the substance of minor 8.
- **A handle re-key that breaks on deletion/reuse/share group** — `SlotAllocatorTest.cpp:57-246` covers
first handout = gen 0, no bump on respecify, bump on the *next handout* rather than on the free
(so a double free cannot skip a generation), a stale handle failing `IsLive` and failing to free its
successor's slot, kind independence, density, slot 0, and — the arm `7c2c1456` added — the strictly
stronger deterministic ABA: re-acquiring the **same lifetime id** after a free cannot reproduce the
handle. Share groups are safe by construction: `MGPipeSlots()` is keyed on the process-unique
lifetime id, so a shared object keeps one handle across contexts.
- **A gate green because it never ran** — the previous round's MAJOR 2. All eight apply entry points now
have a caller (`ce370a3e`), and I confirmed `ctest -R Residual` in `build-verify` reaches the three
wire cases rather than only the `static_assert` catalogue. Both wires are driven disarmed /
armed-agreeing / armed-diverging, and both `MGP_TRIP_WIRE_REPORT` arms are compiled in the gate set
(§1).
- **Hot-path instrumentation the brief forbids** — none committed. Both wires sit on
`set_patch_state` (24-byte `memcmp`, emitted about once per program) and `set_residual_value_state`;
D9 already specifies the residual comparison for all builds ("counted and logged otherwise"), so the
shipped-build arm is sanctioned rather than a deviation. No timer anywhere in `MGPipeValidateForVerb`'s
reach; nothing new on the per-draw path — the round-2 scoping (`a9bb99a4`) *removed* ~170 stores and
35 switch dispatches from it.
- **Undeclared deviation from D1-D20** — I found none. D-1 … D-12 in the result file cover every
departure I could identify, including the two contract-file edits after the tag (`Coverage.def`,
`MG_Test/Pipe/CMakeLists.txt`).
---
## 5. Minors
1. **A dead CSO on `bind_render_state` is still left to an INFO-inert assertion.**
`MobileGL/MG_Pipe/PipeApply.cpp:457-461` — `MOBILEGL_ASSERT(record != nullptr, …); if (record == nullptr) return;`.
At INFO (every gate and every shipped build) that is a silent no-op: the whole pipeline half and
**both** versions stay at the previous CSO's values while the client believes the new one is bound,
and under D12 Magma keys its pipeline memo on that handle — a cached `VkPipeline` built for CSO X
would then draw with CSO W's fixed-function state, with no gate that can see it. `bee07c32`'s own
message says it stopped "leaving a mixed CSO … to a DEBUG-only assertion"; it did that for
`create_render_state` and for the attribute tail but not for the bind, which is the more
consequential of the three. Latent today (nothing emits binds yet), so not a major.
2. **The same for slot 0 and for an unvalidated slot index on create.** `PipeApply.cpp:408-412`:
`MOBILEGL_ASSERT(desc.Cso.Slot >= kMGPipeFirstAllocatableSlot, …)` is inert at INFO, so a `{0,0}`
desc creates a live record at slot 0 and a subsequent bind of the *null handle* would scatter it;
and `RenderStateCsos.resize(desc.Cso.Slot + 1)` sizes the vector from an unchecked wire field
(harmless in-process, a denial-of-service shape once this file becomes `MG_Remote/Server/PipeApplier`).
3. **G1's `resized` set has a fourth member that no brief line admits.** `_GLOBAL__sub_I_DirectGLES.cpp`
−9 bytes, beside the three `RenderState` symbols. G1's row says "empty or exactly the one mangled
`RenderState::RenderState()`"; D15 admits three. The delta is `c0`'s and is declared as D-1, but the
result file does not say *why* a `DirectGLES.cpp` static initialiser resizes when three `Bool`s are
added to `RenderStateParameters` — G5 proves the source text did not move, so this is pure codegen.
The integrator has to either explain it or widen G1's admitted set before the merge gate reads
`--threshold 0` literally.
4. **A comment describes a short-circuit the code does not have.** `PipeApply.h:52-53`:
"The last bind, so a rebind of the same handle can be answered without a scatter" —
`MGPipeApplyBindRenderState` (`PipeApply.cpp:457-474`) always scatters; `BoundRenderStateCso` is
only read at `PipeApply.cpp:485` to clear it on delete.
5. **A declaration comment went stale with `d1a7c5f1`.** `MGPipeRenderStateSpans.h:272-273` still says
the subset hash is "seeded with the table version"; since that commit the seed is
`kMGPipeRenderStateChunkTableVersion ^ BoundaryChecksum()` (`:157-158`).
6. **The mode-bit claim is not true of the whole contract.** Result file D-6 and minor 10 say all four
files created `0755` are now `0644`; `git ls-tree -r HEAD` shows
`MobileGL/MG_Impl/Pipe/SlotAllocator.h` and `SlotAllocator.cpp` are still `100755`. (`c0`'s files —
two more than the four the result file counted.)
7. **`Coverage.def:79` attributes the working block to the wrong call.**
`X(GetRenderStateParameters, CreateRenderState)` — `create_render_state` writes only the applier's
CSO record; the block reaches `PipeInputs::m_renderState` from `bind_render_state` and
`set_dynamic_state` (`PipeApply.cpp:464`, `:492`), which is how the two version rows are already
spelled. Behaviourally inert (both calls sit in `kMGPipeSubsystemRenderState`, and the skip rule is
per subsystem), but package B reads this table and the label is misleading.
8. **D-8: the process-global applier, and `MGPipeApplierReset()` with no production caller.**
`PipeApply.cpp:380` `MGPipeApplierState g_applier{}` vs `BRIEF-P2.md:103`'s "per-context CSO store".
The argument (the working block it writes into is itself the process-global `gPipeInputs`) is sound,
but the consequence is real and must not be lost in the hand-off: a second context inherits the
first's slot space **and its `ScatteredChunkBits`**, so a `set_residual_value_state` that arrives
before the new context's first bind compares the new context's carried bits against the old
context's block — `Fatal{PipeResidualDiverged}` and `std::abort()` in a verify build, on a correct
program. Package B's tracker must call `MGPipeApplierReset()` at context teardown; this is currently
only a sentence in a result file and a comment in a header.
9. **`set_pixel_pack_state` now removes no pull.** With `GetPixelStoreParameters` back to `kNone`
(`generated/PipeFilled.inc:355`), the fill loop keeps copying both halves of `m_pixelStore` and the
applier writes the pack half a second time (`PipeApply.cpp:499-501`). The decision is the right one
— the alternative leaves the unpack half unwritten under a poison stamp that says it was published —
but it means the ROADMAP P2 line item `set_pixel_pack_state` currently buys nothing, and splitting
the field is unscheduled. Worth a line in `MEASUREMENTS.md` rather than only in §6 of the result file.
10. **The non-fatal trip-wire arm has no latch and no rate limit.** `PipeApply.cpp:650-654` reports per
diverging capability per emission, and `set_residual_value_state` is emitted "whenever the
capability set changes" (D9) — which is the Blaze3D `glEnable/glDisable(GL_BLEND)` shape, i.e.
potentially twice per batch. A persistent divergence (minor 8's multi-context case is exactly one)
would emit up to 35 `MGLOG_E` lines per emission into `/sdcard/MG/latest.log` on the G11 device
windows. A "report once per capability until `MGPipeApplierReset`" latch would cost one bitmask.
11. **Confirmed, and carried, from the result file's own §5** — `T-5`: `BRIEF-P2.md`'s G2/G14 command
`ctest -N | grep -E '^\s+Test #'` yields **1383** of the 2382 names on this tree (ctest wraps long
lines); `sed -n 's/^ *Test *#[0-9]*: //p'` yields 2382, and `~/w7/p2-before-ctest-names.txt` (2363)
is in the exact form. The integrator must use the `sed` form or G14 will silently compare a
fifty-eight-percent sample. `T-7` also confirmed: `BRIEF-P2.md` D2's "after any scatter the applier
calls `MGPipeDeriveRenderStateFields`" is not what the code does (it calls the chunk-scoped form);
the doc line needs the integrator's pass.
---
## 6. Not run here, and correctly so
`ctest -L integration-gpu` / `-L integration-verify`, the 40-trace retrace under push and verify
(G3/G4), the two-device paired A/B (G11), the microbenchmark and the CSO-content-addressing control
(G12), and `scripts/g7_negative_control.sh` (package E's file, absent on this tree — §3 above is the
hand-run substitute, and it is a *different* control from the implementer's, so the two together cover
both a demotion at an array head and a demotion of a scalar mask). G8 (`HandleRecycleScenario`) and G9
(the dirty-surface gate) belong to packages E and B and do not exist on this tree; G12's counters are
package B's. Nothing in this package's diff can affect them except through the contract, which is
`c0`'s.