mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-19 07:51:57 +09:00
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.
253 lines
21 KiB
Markdown
253 lines
21 KiB
Markdown
# 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.
|