mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-17 23:13:22 +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.
403 lines
27 KiB
Markdown
403 lines
27 KiB
Markdown
# Adversarial review — P2 package B `p2/tracker`, round 2 (`~/w7/p2-tracker`, `9c6a8a25..dc452c02`)
|
||
|
||
Reviewer's brief: refute correctness / completeness against BRIEF-P2 §A (G1–G14), §B (D1–D20),
|
||
§C.1 and §C.5. Everything below was re-derived or re-run by me in `~/w7/p2-tracker`; the tree was
|
||
left as found (`git status --porcelain` empty before and after — only `build-*`, `~/w7/rev-tk2/`
|
||
and `~/w7/retrace-out/rev-tk2-*` were written; no source file was edited, and the two negative
|
||
controls I ran were run **in memory**, never against the file).
|
||
|
||
**Verdict: NOT APPROVED — 3 majors.**
|
||
|
||
Round 1's two majors are genuinely fixed and I re-established both fixes. What blocks approval is
|
||
that the *root fact* behind round-1 MAJOR 1 — "a publisher named in the mapping does not fire on
|
||
every path" — was fixed in two rows and in one gate, and the **same fact is still wrong in two
|
||
other rows of the same file (which the new gate is structurally unable to see) and in the shipped
|
||
residual-block emitter, where a code comment states the false invariant explicitly**. Plus a third,
|
||
independent hole: the one call P2 fully owns (`set_vertex_attrib_defaults`) publishes **nothing** on
|
||
a context change, and the `InvalidateAll()` that exists to force it is defeated by a second
|
||
suppressor two lines later.
|
||
|
||
None of the three renders anything wrong *today* (the residual fill still pulls every affected
|
||
field, which is why every lane is green). All three are in the direction `ARCHITECTURE.md:502`
|
||
names as the dangerous one, all three are load-bearing the moment P3a builds shutters from this
|
||
file or the pulls retire, and no gate in the tree can report any of them.
|
||
|
||
---
|
||
|
||
## 1. What I re-ran, and what it printed
|
||
|
||
Every row is my own run, not a quotation from `tracker-v2.md`.
|
||
|
||
| gate | command | observed |
|
||
|---|---|---|
|
||
| **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 (+0.001%)`. Resized: `RenderState::RenderState()` +148, `RenderState::SetCapability` +77, `RenderState::IsCapabilityEnabled` +29, `_GLOBAL__sub_I_DirectGLES.cpp` −9 — all four the contract's. **Reproduced.** |
|
||
| **G2** | `ctest -N` name sets, `'^ +Test +#[0-9]+: '` | `build-linux 2404`, `build-push 2404`, **zero-line diff**. Reproduced. |
|
||
| **G14** | `comm -23 ~/w7/p2-before-ctest-names.txt <build-linux names>` | empty (0 of 2363 baseline names removed). Reproduced. |
|
||
| **G5** | `git show {p2/contract,HEAD}:…/DirectGLES.cpp \| awk '/namespace RenderStateImpl/,…' \| sha256sum` | `d8fd1c48…0efe27` on both sides **and** equal to `~/w7/p2-before-syncrenderstate.sha`. Reproduced. |
|
||
| **G9** | `gen_pipe_dirty_surface.py --check` | rc 0 — `73 mutators, all mapped, no stale rows; 45 render-state answers derived from RenderState.cpp and matching` |
|
||
| **G9** | `… --self-test` | rc 0 — `5 negative controls, all tripped` |
|
||
| **G9** | `… --summary` | rc 0 — E's CI step still works |
|
||
| **G13** | `gen_pipe.py --check` / `--self-test` | rc 0 / rc 0 (`7 negative-control trip(s), positive control OK`) |
|
||
| **G13** | `check_include_closure.py` | rc 0 — `4 probes, 0 skipped, 0 problem(s)` |
|
||
| **G13** | `grep -rc 'pGLContext' MobileGL/MG_Backend \| grep -v ':0$'` | empty |
|
||
| unit | `ctest -L unit -j 8` in build-linux / build-push / build-verify | `100% tests passed, 0 tests failed out of 1526` × 3 |
|
||
| integration | `ctest --test-dir build-push -L integration-gpu -j 4` | 878 / 878 |
|
||
| integration | `MOBILEGL_PIPE_PUSH=0 ctest --test-dir build-push -L integration-gpu -j 4` | 878 / 878 (all-pull arm) |
|
||
| integration | `ctest --test-dir build-linux -L integration-gpu -j 4` | 878 / 878 (**no flake this time**, first try) |
|
||
| **G4** | `ctest --test-dir build-verify -L integration-verify -j 4` | 818 / 818 |
|
||
| **G4** | `MOBILEGL_PIPE_VERIFY=1 retrace_gate.py --lib build-verify/libMobileGL.so -j 4` | rc 0, `passed 79 / 79; failed: []`, lowest SSIM **0.993475** |
|
||
| **G4** | corrected log evidence (`<out>/<case>/<backend>/output/mobilegl.log`, arming string `MGPipe: verify armed`) | 79 logs; `Fatal{` **0**; unarmed **0**; `PipeVerifyDiffer`/`PipeResidualDiverged`/`UnmigratedPipeInput` **0** |
|
||
| **G10** (desktop half) | `MOBILEGL_PIPE_STATS=1 MOBILEGL_PIPE_STATS_PERIOD=1 … ctest -R DirectGLES.CrossFrameBufferScenario` | 13/13; `resid=8.00 … cso[csom=1 csob=1]` in window 1, `resid=0.00 … csom=0 csob=0` in windows 2-4. Reproduced exactly. |
|
||
| G6/G7, G8/G12, G11 | — | not reachable from this tree (packages A / E / device). Correctly not claimed. |
|
||
|
||
Ownership (C.5), re-checked with `git diff --name-only p2/contract..HEAD`: 26 files, every one B's row
|
||
plus `MG_State/GLState/Core.{h,cpp}`, `MG_Test/ScopedPipeVerb.h`, `MG_Test/Pipe/PipeInputsTest.cpp`
|
||
(all "nobody"). No `MG_Backend/**`, no `CMakeLists.txt`, no `.github/`, no `MG_IntegrationTest/**`,
|
||
no `scripts/gen_pipe.py`, no A-owned `MG_Pipe/*` file. **No ownership violation.** Commit subjects
|
||
are single-line `[Type] (Scope): …`; zero attribution lines.
|
||
|
||
### 1.1 Round 1's two majors — both genuinely fixed
|
||
|
||
**Round-1 MAJOR 1.** `render_state_publishers()` (`scripts/gen_pipe_dirty_surface.py:161-224`) now
|
||
derives the answer instead of accepting it. I dumped its table and compared it setter by setter
|
||
against `RenderState.cpp` for all 45: `SetCapability` → `NEW_RENDER_STATE` (the ClipDistance arm at
|
||
`:363-383` does `++m_version` only), `SetStencilFunc` → `NEW_RENDER_STATE` (`:641-649`, the pipeline
|
||
bump is conditional), the 18 `BumpVersions()` setters → both, `SetPixelStoreParam` → neither,
|
||
`SetPolygonOffset` → inherited from `SetPolygonOffsetClamped`. The old wrong answer trips in memory:
|
||
|
||
```
|
||
SetStencilFunc <- NEW_RENDER_STATE|NEW_PIPELINE_STATE
|
||
-> ['UNDER-FIRING answer NEW_PIPELINE_STATE for SetStencilFunc - RenderState.cpp does NOT move
|
||
it on every path ... (derived: NEW_RENDER_STATE)']
|
||
```
|
||
|
||
**Round-1 MAJOR 2.** `MGPAttribValue::ValueClass` is now the class the frontend actually wrote
|
||
(`Tracker.h:409-427` + `Core.h:249-271`, `Core.cpp:217-219,237-239,255-257`), all three
|
||
`SetCurrentVertexAttribute*` writers are covered (`grep` finds exactly three), and the emitter
|
||
verifies the applier reproduced the value and repairs it when it did not
|
||
(`PipeFill.cpp:851-866`). `TrackerAttribPayload` pins the flattening on all three classes and on
|
||
the per-attribute-ness of the class. The argument that the class need not be mirrored into
|
||
`PipeInputs` (`tracker-v2.md` §3.2) is sound: a rebuild is a function of (class, that class's four
|
||
words), so two writes leaving the three views identical rebuild identically either way.
|
||
|
||
Round-1 minors 1, 3, 5, 10, 12, 15 are also fixed as claimed, and 4, 6, 7, 8, 9, 11, 13, 14 are
|
||
recorded where the review asked. I verified the five `static_assert`s tying `MGPipeSubsystemForDirty`
|
||
to `SubsystemForEmitter` (`PipeFill.cpp:643-661`) and the shipped-emitter fixture that reads the
|
||
real singletons (`TrackerTest.cpp:539-620`).
|
||
|
||
### 1.2 The chunk table and the setters, re-derived again
|
||
|
||
I re-derived the split rule against `RenderState.cpp` for more than five setters, hunting for a
|
||
*pipeline* byte written by a `++m_version`-only setter (which would leave the assembled block
|
||
permanently stale) or a *dynamic*-only write by a `BumpVersions()` setter (which would break the G6
|
||
⟺). Spot checks: `SetSampleCoverage`→P2 ✓, `SetStencilMask`→D3/D4 ✓, `SetStencilOp`→P3/P4 ✓,
|
||
`SetCapability(ScissorTest)`→P6 ✓ while `SetCapability(ClipDistanceN)`→**D7** ✓ (the one trap, and
|
||
the boundary table gets it right — `ClipDistanceEnabledMask` is in the dynamic chunk),
|
||
`SetScissorBox`→D7 ✓, `SetPolygonMode`→P5 ✓, `SetHint`→D5 ✓, `SetColorMask`→P1 ✓,
|
||
`SetMinSampleShadingValue`→P2 ✓, `SetPatchVertices`→P0 ✓. **No violation found**; the partition
|
||
itself is a `static_assert` chain in `MGPipeRenderStateSpans.h` and the build is green.
|
||
|
||
---
|
||
|
||
## 2. Majors
|
||
|
||
### MAJOR 1 — the residual value block's shutter is the pipeline version, so a change to 8 of the 35 capabilities it carries never re-arms G10's trip wire; the comment above it asserts the opposite as its justification
|
||
|
||
`MobileGL/MG_Impl/Pipe/PipeFill.cpp:1096-1098`:
|
||
|
||
```cpp
|
||
if (tracker.FreshlyPrimed() || (dirty & MGPipeDirtyBit(MGPipeDirty::NewPipelineState)) != 0) {
|
||
g_residualDue = true;
|
||
}
|
||
```
|
||
|
||
`g_residualDue` is set nowhere else (`grep -n g_residualDue PipeFill.cpp` → `917` init, `1097` set,
|
||
`1107` clear). And `PipeFill.cpp:892-894` states the reason:
|
||
|
||
> `// Emitted once per context and again whenever the capability set may have moved,`
|
||
> `// which is whenever the pipeline version moved: every SET_CAPABILITY arm calls`
|
||
> `// BumpVersions, so that shutter cannot miss one.`
|
||
|
||
**That sentence is false, and it is false because of exactly the fact this round's MAJOR 1 fix was
|
||
built on.** `RenderState::SetCapability`'s `ClipDistance0..7` arm
|
||
(`MobileGL/MG_State/GLState/RenderState/RenderState.cpp:363-383`) ends:
|
||
|
||
```cpp
|
||
// Deliberately NOT BumpVersions(): no backend bakes a clip-distance enable ...
|
||
++m_version;
|
||
```
|
||
|
||
and `CapabilityInput::ClipDistance0..7` are values 1..8 of the enum
|
||
(`MobileGL/MG_Pipe/MGPipeValueTypes.h:170-177`), inside the `CapabilityInputCount` the block loops
|
||
over (`PipeFill.cpp:897-903`). So `glEnable(GL_CLIP_DISTANCE0)` changes
|
||
`ResidualValueBlock::CapabilityBits` and moves **only** `NEW_RENDER_STATE`; `g_residualDue` is not
|
||
set and `set_residual_value_state` is not emitted.
|
||
|
||
Reproduction (all from `~/w7/p2-tracker`):
|
||
|
||
```
|
||
$ grep -n 'g_residualDue' MobileGL/MG_Impl/Pipe/PipeFill.cpp
|
||
917: Bool g_residualDue = true;
|
||
1097: g_residualDue = true;
|
||
1105: if (g_residualDue && MGPipeFieldMaskHas(mask, MGPipeInputField::IsCapabilityEnabled)) {
|
||
1107: g_residualDue = false;
|
||
$ sed -n '893,894p' MobileGL/MG_Impl/Pipe/PipeFill.cpp
|
||
// which is whenever the pipeline version moved: every SET_CAPABILITY arm calls
|
||
// BumpVersions, so that shutter cannot miss one.
|
||
$ sed -n '377,381p' MobileGL/MG_State/GLState/RenderState/RenderState.cpp
|
||
// Deliberately NOT BumpVersions(): no backend bakes a clip-distance enable
|
||
...
|
||
++m_version;
|
||
$ sed -n '170,177p' MobileGL/MG_Pipe/MGPipeValueTypes.h # ClipDistance0..7 ARE CapabilityInputs
|
||
$ python3 scripts/gen_pipe_dirty_surface.py --check # rc 0 — and its own derivation says
|
||
# SetCapability is NEW_RENDER_STATE only
|
||
```
|
||
|
||
Consequence, and why it is a major rather than a nit:
|
||
|
||
* **It weakens a named P2 acceptance deliverable.** G10 and D9 specify "the block is emitted once
|
||
per context **and again whenever the capability set changes**", and the whole value of the block
|
||
is that "the day a later call takes a capability over and forgets to carry it, the residual block
|
||
says so on the next draw". For `ClipDistance0..7` it cannot say so at all until some unrelated
|
||
setter happens to bump the pipeline version — the trip wire is disarmed for 8 of 35 capabilities
|
||
for an unbounded window.
|
||
* It is the **same defect class the package just fixed one file over**, in shipped emission code
|
||
rather than in a data file, and carrying a comment that argues the opposite. Nothing in
|
||
`tracker-v2.md` §6/§7/§8 declares it.
|
||
* No gate can see it: the block is rebuilt from `ctx` at each emission, so a *stale* block never
|
||
produces a false `Fatal{PipeResidualDiverged}` — it simply never runs. G10's evidence
|
||
(`resid=8.00` once, then `0.00`) is exactly as consistent with the hole as without it.
|
||
|
||
The fix is one clause: also set `g_residualDue` on `NEW_RENDER_STATE` (the coarser, always-true
|
||
shutter, the same answer the `.def` derivation now gives `SetCapability`), or key it on the
|
||
capability bits themselves.
|
||
|
||
### MAJOR 2 — two rows of `DirtySurface.def` still violate the file's own stated rule, and the new derivation gate is structurally blind to them: it checks 45 of 73 mutators and accepts an arbitrarily false answer for the other 28
|
||
|
||
`MobileGL/MG_Pipe/DirtySurface.def:21-24` (the rule this round introduced):
|
||
|
||
> `// ANSWERS. A row lists EVERY publisher that fires on EVERY path through that mutator,`
|
||
> `// and only those; several are joined with '|'. A publisher that fires on some paths but`
|
||
> `// not all must not appear, because a shutter built from this file would then UNDER-fire`
|
||
|
||
**(a) `DirtySurface.def:142` — `X(SetPixelStoreParam, NEW_PIXEL_PACK)`.**
|
||
`RenderState::SetPixelStoreParam` (`RenderState.cpp:827-855`) writes **both** halves — eight
|
||
`SET_PIXEL_STORE_PARAM(Pack, …)` arms and eight `SET_PIXEL_STORE_PARAM(Unpack, …)` arms — while the
|
||
tracker's bit 2 is the **pack half only** (`MG_Impl/Pipe/Tracker.h:275-280`:
|
||
`const PixelStoreParameters pack = ctx.GetPixelStoreParameters(false);`). So on the eight `Unpack`
|
||
paths — `glPixelStorei(GL_UNPACK_ALIGNMENT, 8)` and its seven siblings — the named publisher does
|
||
not fire. The package *knows* this: `PipeFill.cpp:678-682` says "the unpack half has no carrier at
|
||
all, so the field keeps being pulled". Under the file's own vocabulary the honest answer is
|
||
`kPulledEveryVerb` (or `NEW_PIXEL_PACK|kPulledEveryVerb` if a row may mix, which the checker
|
||
currently forbids).
|
||
|
||
**(b) `DirtySurface.def:154` — `X(SetNamedTransformFeedbackBinding, NEW_SO_TARGETS)`. This one is
|
||
false on *every* path.** `GLContext::SetNamedTransformFeedbackBinding`
|
||
(`MG_State/GLState/Core.cpp:1514-1530`) either calls `point.Bind(buffer)` / `SetRange` /
|
||
`ClearRange` on a `BufferState` binding point (index == bound XFB) or writes
|
||
`m_transformFeedbackObjects[index].bindings[…]` (index != bound). Neither bumps anything the
|
||
`NEW_SO_TARGETS` shutter reads:
|
||
|
||
* `Tracker.h:261-262`: `now[NewSoTargets] = MGPipeMixShutter(buffers, ctx.GetTransformFeedbackGeneration())`.
|
||
* `buffers` is `GetAnyBufferChangeGeneration()`, and the only bump sites are the seven
|
||
`MGP_NOTE_AGGREGATE(BufferChange)` in `BufferState/BufferObject.cpp:47,55,65,80,88,311,376` —
|
||
all buffer *content* mutations, none of them a bind.
|
||
* `m_transformFeedbackGeneration` is bumped in exactly one place,
|
||
`MG_State/GLState/Core.h:386` inside `BeginTransformFeedback`.
|
||
|
||
So `glTransformFeedbackBufferBase/Range` moves **no** dirty bit, and the row claims one that never
|
||
fires.
|
||
|
||
**(c) The gate cannot see either, by construction.** `check_mapping`'s truth half intersects the
|
||
claimed answer with `{NEW_RENDER_STATE, NEW_PIPELINE_STATE}` only
|
||
(`gen_pipe_dirty_surface.py:283-315`), so every non-render-state answer is accepted verbatim.
|
||
Demonstrated in memory (no file was edited):
|
||
|
||
```
|
||
$ python3 -c '<load gen_pipe_dirty_surface.py; mutate the mapping dict; call check_mapping>'
|
||
baseline problems: []
|
||
SetNamedTransformFeedbackBinding <- NEW_VERTEX_ATTRIB_DEFAULTS problems=0 []
|
||
SetPixelStoreParam <- NEW_SO_TARGETS problems=0 []
|
||
BumpTextureBindGeneration <- NEW_GLOBAL_CONSTANTS problems=0 []
|
||
SetCurrentVertexAttributeInt <- NEW_FRAMEBUFFER problems=0 []
|
||
SetStencilFunc <- NEW_RENDER_STATE|NEW_PIPELINE_STATE
|
||
-> ['UNDER-FIRING answer NEW_PIPELINE_STATE for SetStencilFunc …']
|
||
```
|
||
|
||
i.e. the gate is real for the 45 RenderState rows and a rubber stamp for the other 28 — including
|
||
the two rows above, which are wrong today. `--check` prints
|
||
`45 render-state answers derived from RenderState.cpp and matching`, which reads as coverage but is
|
||
the count of the rows it *can* check.
|
||
|
||
Why major: `tracker-v2.md` §2 states the round-2 fix as "correct the two rows that named a
|
||
publisher which does not always fire" and "a row that claims a publisher the derivation does not
|
||
find is UNDER-FIRING". Two rows of the same file still name such a publisher, one of them
|
||
unconditionally, and the file is the input D16 hands to P3a to build the narrow shutters from —
|
||
`NEW_SO_TARGETS` built from row (b) would miss every transform-feedback buffer binding.
|
||
Minimum to clear: correct both rows, and either widen the derived check to the object-class bits
|
||
(the shutter expressions are all in `Tracker.h::Update` and are mechanically readable) or state
|
||
in the file and in `--check`'s output that only the RenderState family's answers are verified.
|
||
|
||
### MAJOR 3 — `set_vertex_attrib_defaults` publishes nothing on a context change, and the `InvalidateAll()` that exists to force it is defeated two lines later by the staging mirror
|
||
|
||
`MGPipeValidateForVerb` invalidates the set-hash suppressor on a fresh context
|
||
(`PipeFill.cpp:1044-1047`) for the stated reason "what the server has is no longer what this slot
|
||
last emitted". `EmitRenderState` handles the same case explicitly — `freshlyPrimed ?
|
||
kAllDynamicChunks` (`PipeFill.cpp:957-959`) — and `EmitPixelPackState` / `EmitPatchState` send the
|
||
whole value unconditionally. `EmitVertexAttribDefaults` does neither: after the suppressor it
|
||
diffs each attribute against the tracker's staging mirror and returns early when nothing differs
|
||
(`PipeFill.cpp:833`, `:846`):
|
||
|
||
```cpp
|
||
for (SizeT i = 0; i < kAttribs; ++i) {
|
||
if (std::memcmp(&resolved[i], &staged[i], sizeof(resolved[i])) == 0) continue;
|
||
…
|
||
}
|
||
if (header.Count == 0) return 0;
|
||
```
|
||
|
||
On a context change `MGPipeTracker::Reset()` sets `m_stagedAttribs = AttribDefaults{}`
|
||
(`Tracker.h:321`), which value-initialises 32 `CurrentVertexAttributeValue`s to the NSDMI defaults
|
||
`{0,0,0,1}` (`Core.h:45-47`) — and a fresh `GLContext`'s `m_currentVertexAttributes{}`
|
||
(`Core.h:587`) holds exactly those same defaults. So `resolved == staged` for all 32, `header.Count
|
||
== 0`, and **no call goes out**. Meanwhile the server-side mirror is *not* reset:
|
||
`MGPipeApplierReset()` (`MG_Pipe/PipeApply.cpp:114-119`) clears `RenderStateCsos`,
|
||
`BoundRenderStateCso` and `Residual` and nothing else — `gPipeInputs.m_currentVertexAttribute[]`
|
||
still holds the **previous** context's attribute defaults.
|
||
|
||
Reproduction:
|
||
|
||
```
|
||
$ sed -n '821,846p' MobileGL/MG_Impl/Pipe/PipeFill.cpp # no freshlyPrimed arm; early return
|
||
$ sed -n '957,959p' MobileGL/MG_Impl/Pipe/PipeFill.cpp # the arm EmitRenderState does have
|
||
$ sed -n '321p' MobileGL/MG_Impl/Pipe/Tracker.h # m_stagedAttribs = AttribDefaults{};
|
||
$ sed -n '45,47p;587p' MobileGL/MG_State/GLState/Core.h # the same {0,0,0,1} defaults
|
||
$ sed -n '114,119p' MobileGL/MG_Pipe/PipeApply.cpp # the applier reset does not touch it
|
||
```
|
||
|
||
Consequences:
|
||
|
||
* The two-level suppression means the deliberate `InvalidateAll()` at `:1046` has **no effect** for
|
||
the only slot P2 wires — the mechanism `SetHashSuppressorTest.InvalidateMakesTheNextSetGoOutWhateverItHashesTo`
|
||
proves in isolation is cancelled in the shipped path. That is precisely a "memo that can serve a
|
||
stale answer", and it is the failure mode the tracker's own comment
|
||
("the first walk on a fresh context must publish a COMPLETE state rather than an increment",
|
||
`Tracker.h:186-188`) exists to prevent.
|
||
* Today the residual fill re-pulls `GetCurrentVertexAttribute` at every `kDraw` verb (the row is
|
||
shape-only), so nothing renders wrong; that is also why 818 verify entries and 79 verify
|
||
retraces are green. It becomes a real stale answer the moment A's applier honours `ValueClass`
|
||
and the pull retires — which is the very hand-off `tracker-v2.md` §7 asks the integrator to do.
|
||
* Not declared anywhere in §6/§7/§8.
|
||
|
||
The fix is the same one line `EmitRenderState` already has: send all 32 when
|
||
`tracker.FreshlyPrimed()`, or reset the applier's attribute mirror alongside the staging mirror.
|
||
|
||
---
|
||
|
||
## 3. Minors
|
||
|
||
1. **`TrackerShippedEmitter.APushedAttributeDefaultTheApplierCannotReproduceIsRepaired`
|
||
(`TrackerTest.cpp:604-618`) asserts the *defect*, not the invariant.** It requires
|
||
`MGPipeVertexAttribDefaultRepairCount() == before + 1`, so it goes **red** the day the blocking
|
||
follow-up of `tracker-v2.md` §7 (A teaching `MGPipeApplySetVertexAttribDefaults` to switch on
|
||
`ValueClass`) lands — the exact event §3.3 advertises as "stops repairing by itself with no edit
|
||
here". Nothing in the test or the hand-off says the test must change with it. Assert
|
||
`<= before + 1` plus a positive control on the emission, or name it in the hand-off.
|
||
2. **The repair path has unit coverage only.** Across all 79 verify-retrace logs I found **0**
|
||
occurrences of the applier-cannot-reproduce warning — confirming §8.3: no fixture in the corpus
|
||
moves a `glVertexAttrib*` default, so the corpus proves nothing about this call.
|
||
3. **`build-verify` was not up to date at `dc452c02` when I arrived**: my first
|
||
`cmake --build build-verify` relinked 55 targets on an otherwise clean tree, and `DirtySurface.def`
|
||
is included by no C++ file (`grep -rn 'DirtySurface.def' --include=*.h --include=*.cpp --include=*.txt`
|
||
→ empty), so it cannot explain the rebuild. `tracker-v2.md` §5 presents its verify rows as run at
|
||
`dc452c02`; at least one of them was produced from a binary that was not the tip. Everything is
|
||
green after my rebuild, and my verify retrace's lowest SSIM (**0.993475**) differs from the
|
||
`0.997009` §5.2 reports for the same command — evidence hygiene, not a defect, but the
|
||
integrator should not copy §5.2's verify rows into `MEASUREMENTS.md` unchecked.
|
||
4. **The applier / cache fresh-context reset sits inside the render-state subsystem gate.**
|
||
`MGPipeCsoCacheInstance().Reset()` and `MGPipeApplierReset()` are reached only from
|
||
`EmitRenderState` (`PipeFill.cpp:945-950`), which runs only when
|
||
`wants(NewPipelineState) || wants(NewRenderState)` — i.e. only when bit 0 of the bitmask is set.
|
||
A per-subsystem A/B that clears bit 0 and keeps bits 1–3 (which D14 explicitly invites) gives a
|
||
fresh context a never-reset applier while the suppressor *is* invalidated. Latent; worth one
|
||
`if (tracker.FreshlyPrimed())` outside the gate.
|
||
5. **The residual block is the one emission still gated by a hand-written subsystem constant.**
|
||
`PipeFill.cpp:1096` tests `(pushMask & kMGPipeSubsystemResidualValues)` directly instead of going
|
||
through `MGPipeSubsystemForDirty`, so round-1 minor 1's "the ONE map" argument
|
||
(`PipeFill.cpp:1035-1038`) has one exception left, and no `static_assert` covers it.
|
||
6. **The `MOBILEGL_ASSERT` that replaced round-1 minor 5's assumption is compiled out in the
|
||
shipping build.** `PipeFill.cpp:986-990` asserts "NEW_PIPELINE_STATE fired without
|
||
NEW_RENDER_STATE", which is exactly right, but Release/INFO is the G1/G3 configuration — the
|
||
invariant is checked in debug and verify only. Worth saying so, since §4 minor 5 reads as if the
|
||
assumption is now unconditionally guarded.
|
||
7. **`X(SetPatchVertices, …)` changed answer class without a declaration.** D16's own example row
|
||
is `X(SetPatchVertices, kImmediate)`; the file now answers
|
||
`NEW_PATCH_STATE|NEW_RENDER_STATE|NEW_PIPELINE_STATE` and the report still labels the row
|
||
`(immediate)`. The new answer is the better one and the comment explains it — but it is a
|
||
departure from a brief-supplied row and is not in §7's list.
|
||
8. **`render_state_publishers()` unions across bodies of the same name.**
|
||
`gen_pipe_dirty_surface.py:186-196` computes publishers per body and `|`s them, so two overloads
|
||
of one setter — one bumping both counters, one bumping only `m_version` — would derive as "both
|
||
always fire", i.e. bless an under-firing row. Latent only: I verified every `Set*` name in
|
||
`RenderState.cpp` has exactly one body (45 names / 45 bodies). An intersection would be the safe
|
||
fold.
|
||
9. **A conditional `BumpVersions()` derives as unconditional.** `SetColorMask`
|
||
(`RenderState.cpp:679-688`, `if (changed) BumpVersions();`) and `SetCapability`'s Blend arm
|
||
(`:349`) derive as always-firing. That is correct under "every path *that mutates*", which is
|
||
the reading the file means — but the file's rule says "every path through that mutator", and the
|
||
two readings differ. One sentence in the header would close it.
|
||
10. Still outstanding and correctly recorded by B: G9 is not a CI gate until E lands (`test.yml` is
|
||
E's file); G1's admitted resize set has four symbols, not D15's three; D14/D.4.3's T1−T2 no
|
||
longer isolates the tracker because the walk is unconditional; `MGPipeWidenedCounter` cannot see
|
||
a change of exactly 65536; `s_hashForTest` is a live function pointer in production code; the
|
||
header-only `Tracker.h`/`CsoCache.h`/`SetHashSuppressor.h` still want their one `list(APPEND)`
|
||
line at integration.
|
||
11. Still outstanding in **§A of the brief itself** (B reproduced all three; so did I): `--ssim` is
|
||
not a `retrace_gate.py` flag, G2/G14's `'^\s+Test #'` grep drops every test numbered under
|
||
1000, and G4's log glob is one directory level short with an arming string
|
||
(`MGPipe verify:`) that appears in no log. The integrator must fix §A and D.3 before running
|
||
the five-part gate.
|
||
|
||
---
|
||
|
||
## 4. Deviations checked against §B
|
||
|
||
Declared and accepted: 1 (header-only, ownership-forced), 2 (a sixth aggregate
|
||
`VertexAttribDefault`), 3 (`Core.{h,cpp}` — "nobody" in C.5, all `#if MOBILEGL_PIPE_PUSH`, G1
|
||
unaffected — verified), 4 (coarse shutters for bits 5–17), 5 (`Vector` scan in the CSO cache), 6
|
||
(`s_hashForTest`), 7 (residual block after the fill), 8 (the one-field derivation probe), 9 (stale
|
||
comment references), 10 (`|`-joined answers), 11 (`GLContext`'s push-only class array), 12
|
||
(`MGPipeVertexAttribDefaultRepairCount`).
|
||
|
||
**Undeclared deviations found:** the three majors above (the residual shutter's disagreement with
|
||
D9's "again whenever the capability set changes"; two `.def` rows against the file's own rule; the
|
||
missing fresh-context republish of `set_vertex_attrib_defaults` against `Tracker.h`'s own
|
||
"COMPLETE state" contract) and minor 7.
|
||
|
||
Checked and clean: no hot-path timer anywhere (`Tracker.h` has none; every tally is behind
|
||
`PipeStats::Enabled()`), no stdio under `MG_Backend`/`MG_State`, `PipeCalls.def` untouched, the
|
||
walk does not use `GetProgramForDraw` (`Tracker.h:214-216`) so it cannot force a link join, the
|
||
C.1-mandated verdict on the 8 statically over-approximated `FillPoints.def` rows is written into
|
||
the def with a per-group reason (`FillPoints.def:29-64`), and the CSO cache's collision `memcmp`,
|
||
LRU eviction and content-addressing-off arm are each pinned by a test that can fail
|
||
(`CsoCacheTest.cpp:117-147`).
|
||
|
||
---
|
||
|
||
## 5. Bottom line
|
||
|
||
The machinery is sound and independently verified: G1, G2, G4 (818 integration-verify entries and
|
||
79/79 verify retraces, 0 `Fatal{`, all armed), G5, G9, G10's desktop half, G13 and G14 all
|
||
reproduce; three unit lanes are 1526/1526; three integration-gpu arms are 878/878 with no flake;
|
||
the chunk-table rule survived another setter-by-setter re-derivation; and round 1's two majors are
|
||
properly closed, one of them with a derivation gate that is a genuine improvement.
|
||
|
||
What blocks approval is that the round-2 fixes stopped at the two artefacts the round-1 review
|
||
named, while the underlying fact — "`SetCapability`'s clip-distance arm does not bump the pipeline
|
||
version, and a publisher must fire on every path" — is still wrong in the shipped residual-block
|
||
shutter (MAJOR 1) and in two more rows of the very file that was turned into a gate, which the gate
|
||
cannot check (MAJOR 2); and the one call P2 fully owns silently publishes nothing across a context
|
||
change while the invalidation written for that case is cancelled two lines later (MAJOR 3). All
|
||
three are invisible to every lane in the tree for the same reason: the residual fill still pulls
|
||
the fields. That is exactly the shape of defect this phase exists to stop shipping.
|