mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-18 07:23:24 +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.
359 lines
26 KiB
Markdown
359 lines
26 KiB
Markdown
# Adversarial review — P2 package B `p2/tracker` (`~/w7/p2-tracker`, `9c6a8a25..7993d711`)
|
||
|
||
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 in `~/w7/p2-tracker`; the tree was
|
||
left as found (`git status --porcelain` empty before and after; only `build-*` and
|
||
`~/w7/rev-tk/`, `~/w7/retrace-out/rev-tk-verify/` were written).
|
||
|
||
**Verdict: NOT APPROVED — 2 majors.** The headline deliverable is real and is proven by the
|
||
strongest oracle in the tree; the two majors are a factually wrong row-pair in the mapping
|
||
file that this package just turned into a gate, and a wire payload that is landed as "real"
|
||
while being incapable of reproducing the value it carries.
|
||
|
||
---
|
||
|
||
## 1. What I re-ran, and what it printed
|
||
|
||
Every command below was run by me, not read out of `tracker-v1.md`.
|
||
|
||
| gate | command | observed |
|
||
|---|---|---|
|
||
| G9 | `python3 scripts/gen_pipe_dirty_surface.py --check` | rc 0 — `dirty-surface: 73 mutators, all mapped, no stale rows` |
|
||
| G9 | `… --self-test` | rc 0 — `3 negative controls, all tripped` |
|
||
| G9 | `… --summary` | rc 0 — still works (E's CI step is unbroken) |
|
||
| G13/G6 | `python3 scripts/gen_pipe.py --check` | rc 0 — `63 PipeInputs fields (7 sticky, 34 emitted by a P2 call)`, `generated files are up to date` |
|
||
| G13 | `python3 scripts/gen_pipe.py --self-test` | rc 0 — `7 negative-control trip(s), positive control OK` |
|
||
| G13 | `python3 scripts/check_include_closure.py` | rc 0 — `4 probes, 0 skipped, 0 problem(s)` |
|
||
| G13 | `grep -rc 'pGLContext' MobileGL/MG_Backend \| grep -v ':0$'` | empty |
|
||
| **G5** | `git show {48268068,HEAD}:…/DirectGLES.cpp \| awk '/namespace RenderStateImpl/,/} \/\/ namespace RenderStateImpl/' \| sha256sum` | `d8fd1c48…0efe27` on both sides **and** equal to `~/w7/p2-before-syncrenderstate.sha`. Confirmed. |
|
||
| **G1** | `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 are the **contract** commit's; this package adds zero pull-build delta on top. See minor m7 for the fourth symbol. |
|
||
| **G2** | ctest `-N` name sets, corrected grep | `build-linux 2396`, `build-push 2396`, **zero-line diff** |
|
||
| **G14** | `comm -23 ~/w7/p2-before-ctest-names.txt <names-build-linux>` | empty (0 of 2363 baseline names removed) |
|
||
| unit | `ctest --test-dir build-linux -L unit -j 8` | rc 0 — 1518/1518 |
|
||
| unit | `ctest --test-dir build-push -L unit -j 8` | rc 0 — 1518/1518 |
|
||
| unit | `ctest --test-dir build-verify -L unit -j 8` | rc 0 — 1518/1518 |
|
||
| integration | `ctest --test-dir build-push -L integration-gpu -j 4` | rc 0 — **878/878** |
|
||
| integration | `MOBILEGL_PIPE_PUSH=0 ctest --test-dir build-push -L integration-gpu -j 4` | first run rc 8, one failure: `DirectGLES.PointSizeDemotion.…TheDemotionIsActuallyArmedWhenTheEnvironmentPinsItOn`. **Re-run of the full lane: rc 0, 878/878.** The entry also passes 3/3 standalone under `MOBILEGL_PIPE_PUSH=0`. Confirms `tracker-v1.md` §4.4: a lane parallel flake, not a push/pull divergence. |
|
||
| **G4** | `ctest --test-dir build-verify -L integration-verify -j 4` | rc 0 — **818/818** |
|
||
| **G4** | `MOBILEGL_PIPE_VERIFY=1 retrace_gate.py --lib build-verify/libMobileGL.so -j 4` | see §1.1 |
|
||
| **G10** (stats half) | `MOBILEGL_PIPE_STATS=1 MOBILEGL_PIPE_STATS_PERIOD=1 MOBILEGL_LOG_FILE_PATH=… ctest -R DirectGLES.CrossFrameBufferScenario` | `MGPipe stats: … resid=8.00 … cso[csom=1 csob=1]`, then 4 windows of `resid=0.00 … csom=0 csob=0`. Reproduced exactly as claimed. |
|
||
| G6/G7 | `ctest --test-dir build-push -N \| grep RenderStateSpans` | only `RenderStateSpans.PlaceholderUntilTheOwningPackageFillsThisIn`. Not reachable from this tree — package A. Correctly not claimed. |
|
||
| G8/G12 | `ctest -N \| grep -E 'HandleRecycle\|CsoContentAddressing'` | absent in both `build-push` and `build-verify`. Package E. Correctly not claimed. |
|
||
|
||
Ownership (C.5) re-checked against `git diff --stat p2/contract..HEAD`: 26 files. Every file is
|
||
B's row, plus `MG_State/GLState/Core.{h,cpp}`, `MG_Test/ScopedPipeVerb.h`,
|
||
`MG_Test/Pipe/PipeInputsTest.cpp` (all "nobody"). `CMakeLists.txt`, `MG_Backend/**`,
|
||
`VertexArrayState/VertexArrayObject.h` (D's), `.github/workflows/test.yml` (E's),
|
||
`scripts/gen_pipe.py` (A's) untouched. **No ownership violation.** Commit subjects are
|
||
single-line `[Type] (Scope): …`; no `Co-Authored-By` anywhere.
|
||
|
||
### 1.1 Verify retrace
|
||
|
||
`MOBILEGL_PIPE_VERIFY=1 python3 ~/w7/retrace_gate.py --tree ~/w7/p2-tracker --lib
|
||
~/w7/p2-tracker/build-verify/libMobileGL.so --out ~/w7/retrace-out/rev-tk-verify -j 4`
|
||
→ **RETRACE_RESULT_PLACEHOLDER**
|
||
|
||
### 1.2 The chunk table and the setters — re-derived independently
|
||
|
||
I re-derived the split rule (`MGPipeRenderStateSpans.h:20-22`) against `RenderState.cpp` for
|
||
**more than five** setters, hunting for a pipeline byte written by a `++m_version`-only setter
|
||
(the failure that would leave the assembled block permanently stale, because
|
||
`EmitRenderState` sends only dynamic chunks when `NewPipelineState` does not fire):
|
||
|
||
* `++m_version` only, all landing in **dynamic** chunks — `SetViewport`/`SetViewportIndexed`
|
||
(D0, `:69,98`), `SetLineWidth` (D0, `:113`), `SetPointSize` (D0, `:203`),
|
||
`SetPolygonOffsetClamped` (D1, `:276`), `SetClipControl` (D1, `:288`), `SetHint`
|
||
(D5, `:131`), `SetPointFadeThresholdSize`/`SetPointSpriteCoordOrigin`/`SetClampReadColor`
|
||
(D5, `:147,157,167`), `SetPrimitiveRestartIndex` (D6, `:192`), `SetClearColor`/`SetClearDepth`/
|
||
`SetClearStencil`/`SetBlendColor` (D2, `:711,722,733,744`), `SetDepthRange`/
|
||
`SetDepthRangeIndexed` (D2, `:760,775`), `SetStencilMask` (D3/D4, `:657`),
|
||
`SetScissorBox`/`SetScissorBoxIndexed` (D7, `:948,969`), `SetCapability(ClipDistance0..7)`
|
||
(D7 `ClipDistanceEnabledMask`, `:381`).
|
||
* `BumpVersions()`, all landing in **pipeline** chunks — the 25 `SET_CAPABILITY` arms and the
|
||
`Blend`/`ScissorTest` arms (P1/P6, `:313,349,360`), `SetCapabilityIndexed` (P1/P6,
|
||
`:460,476`), the four blend setters (P1, `:520,546,572,591`), `SetLogicOp`/`SetDepthFunc`/
|
||
`SetDepthMask` (P1, `:607,619,630`), `SetColorMask`/`SetColorMaskIndexed` (P1, `:688,699`),
|
||
`SetStencilOp` (P3/P4, `:671`), `SetSampleCoverage`/`SetSampleMaskValue`/
|
||
`SetMinSampleShadingValue` (P2, `:791,806,820`), `SetCullFaceMode`/`SetFrontFaceMode`/
|
||
`SetProvokingVertexMode` (P4, `:894,905,916`), `SetPolygonMode` (P5, `:178`),
|
||
`SetPatchVertices`/`SetPatchDefault{Outer,Inner}Level` (P0, `:214,233,244`).
|
||
* The one hybrid, `SetStencilFunc` (`:641-649`): `Func` → pipeline (P2 for face 0, P3 for
|
||
face 1), `Ref`/`ValueMask` → dynamic (D3/D4), and `++m_pipelineStateVersion` is conditional
|
||
on `Func` moving. Exactly what the table encodes.
|
||
|
||
**No violation found.** The partition itself is a `static_assert` chain
|
||
(`MGPipeRenderStateSpans.h:144-174`: boundaries ascend, start 0, end `sizeof`, 7+8 chunks,
|
||
396+772 == 1168), so a gap is a build break, and the build is green. The brief's D6 table and
|
||
the landed header disagree only cosmetically (`StencilStates[0].Func` sits inside the
|
||
brief's `[752,772)` P2 range but the brief's member list omits it; the header lists it).
|
||
Tree wins; no action beyond the integrator copying the header's member list into
|
||
`MEASUREMENTS.md`.
|
||
|
||
### 1.3 The headline claim IS proven
|
||
|
||
`GetRenderStateParameters`, the two version fields and the patch trio are the six fields the
|
||
residual fill actually skips on this branch (`PipeFill.cpp:695-710` `AppliedWithoutDerivation`
|
||
∩ `:668-676` `EmittedCallSuppliesTheWholeField`, `applierDerives == false` here). For those,
|
||
`gPipeInputs.m_renderState` is assembled purely from `bind_render_state` + `set_dynamic_state`
|
||
(`PipeApply.cpp:156-189`). The verify build's read hook re-copies the **whole**
|
||
`RenderStateParameters` from the live context at every backend read and compares it field-wise
|
||
(`PipeFill.cpp:452-475` → `PipeInputs.cpp:153-158` → the generated field comparator), and
|
||
`EntryCompare` does the same at every verb (`PipeFill.cpp:422-431`). 818 `integration-verify`
|
||
entries and the verify retrace green therefore *do* prove the chunk table, the scatter and the
|
||
skip together — `tracker-v1.md` §8 is more modest than the evidence warrants. The `csom=1
|
||
csob=1` / `resid=8.00` window I reproduced proves the emission is live and not dead code.
|
||
|
||
---
|
||
|
||
## 2. Majors
|
||
|
||
### MAJOR 1 — `DirtySurface.def` gives the two mutators with a real two-answer split the *narrower*, under-firing answer, contradicting its own stated rule; the gate it just became cannot see it
|
||
|
||
`MobileGL/MG_Pipe/DirtySurface.def:21-22` states the rule:
|
||
|
||
> where a mutator has more than one true answer the row carries the **COARSER** one — the one
|
||
> that cannot under-fire
|
||
|
||
`RenderState.h:159-162` — `BumpVersions()` bumps **both** `m_version` and
|
||
`m_pipelineStateVersion`. Therefore, over every `RenderState` setter,
|
||
`{NEW_PIPELINE_STATE fires} ⊆ {NEW_RENDER_STATE fires}`: `NEW_RENDER_STATE` is the coarser
|
||
answer, always. Two rows pick the other one:
|
||
|
||
* `DirtySurface.def:68` — `X(SetCapability, NEW_PIPELINE_STATE)`. The comment immediately
|
||
above it (`:66-67`) *names the counter-example* — "SetCapability's ClipDistance0..7 arms
|
||
move only m_version" — and then concludes the opposite of the rule.
|
||
`RenderState.cpp:377-381`: the ClipDistance arm writes `ClipDistanceEnabledMask` (dynamic
|
||
chunk D7) and does `++m_version` with an explicit "Deliberately NOT BumpVersions()" comment.
|
||
So for `glEnable(GL_CLIP_DISTANCE0)` the row's named publisher **does not fire at all**; the
|
||
mutation is in fact published by `NEW_RENDER_STATE` → `set_dynamic_state` chunk D7.
|
||
* `DirtySurface.def:86` — `X(SetStencilFunc, NEW_PIPELINE_STATE)`, with the comment at
|
||
`:82-85` again spelling out the split. `RenderState.cpp:641-649`: `++m_version` is
|
||
unconditional, `++m_pipelineStateVersion` is conditional on `Func` moving. A
|
||
`glStencilFunc` that changes only `Ref`/`ValueMask` (chunks D3/D4) does **not** move
|
||
`NEW_PIPELINE_STATE`.
|
||
|
||
Reproduction (both directions, from `~/w7/p2-tracker`):
|
||
|
||
```
|
||
$ grep -n "SetCapability,\|SetStencilFunc,\|COARSER" MobileGL/MG_Pipe/DirtySurface.def
|
||
22:// the COARSER one - the one that cannot under-fire:
|
||
68: X(SetCapability, NEW_PIPELINE_STATE) \
|
||
86: X(SetStencilFunc, NEW_PIPELINE_STATE) \
|
||
$ sed -n '377,381p;641,649p' MobileGL/MG_State/GLState/RenderState/RenderState.cpp
|
||
// Deliberately NOT BumpVersions(): ...
|
||
++m_version;
|
||
const Bool pipelineRelevantChange = state.Func != func;
|
||
...
|
||
++m_version;
|
||
if (pipelineRelevantChange) ++m_pipelineStateVersion;
|
||
$ python3 scripts/gen_pipe_dirty_surface.py --check
|
||
dirty-surface: 73 mutators, all mapped, no stale rows # rc 0 — the gate is blind to this
|
||
```
|
||
|
||
Why it is a major and not a nit: D16's whole purpose is that *"every frontend mutation a
|
||
backend can observe has an answer to 'what publishes this'"*, and the file itself says the
|
||
failure mode "is silent and one-directional: a mutation that forgets to publish renders
|
||
stale" (`DirtySurface.def:12-14`). The gate `--check` only validates row **existence** and
|
||
**vocabulary** (`gen_pipe_dirty_surface.py:171-193`), never the answer's truth, so the two
|
||
wrong rows survive a green gate — literally the "green because it never checked" pattern.
|
||
P3a is specified to build the narrow shutters from this file; a shutter keyed on the pipeline
|
||
version for `SetStencilFunc`'s dynamic half or for the clip-distance mask is exactly the
|
||
under-firing that `ARCHITECTURE.md:502` names as the dangerous direction.
|
||
|
||
Fix inside B's ownership: change both rows to `NEW_RENDER_STATE` (the coarser, always-true
|
||
answer), or introduce a two-answer notation and let `--check` require it wherever a setter has
|
||
both a `BumpVersions` and a `++m_version` path. Either way the two comments at `:66-67` and
|
||
`:82-85` should state which bit actually fires.
|
||
|
||
### MAJOR 2 — `set_vertex_attrib_defaults` is emitted with a payload that provably cannot reproduce the frontend value, and the ordering of steps 3/4 makes it invisible to every gate
|
||
|
||
`MobileGL/MG_Impl/Pipe/PipeFill.cpp:752-786`, `EmitVertexAttribDefaults`:
|
||
|
||
```
|
||
776: value.ValueClass = 0;
|
||
777: std::memcpy(value.Data, resolved[i].floatValue.data(), sizeof(value.Data));
|
||
```
|
||
|
||
* `MGPipeTypes.h:475-481` declares `MGPAttribValue { Uint32 Location; Uint8 ValueClass; /* Float | Int | Uint | Double */ Uint8 Pad0[3]; Uint32 Data[4]; }`. The client hard-codes the
|
||
discriminator to `0` for every attribute, unconditionally — the field is never computed.
|
||
The comment above it (`PipeFill.cpp:773-775`) justifies this with "ClassifyVertexAttribType
|
||
resolves the float/int/uint view on the CLIENT", which is a non-sequitur:
|
||
`ClassifyVertexAttribType` is applied at the **backend read sites**
|
||
(`DirectGLES.cpp:1278`, `VulkanRenderer.cpp:6243,6887`) against the *shader's* declared
|
||
attribute type — it is not the emitter's answer and it is not applied here.
|
||
* Only `floatValue` is carried, and `MGPipeApplySetVertexAttribDefaults`
|
||
(`PipeApply.cpp:224-226`) memcpys those same 16 bytes into all three views. But the frontend
|
||
does a **numeric** conversion between the views (`Core.cpp:212-216`:
|
||
`current.intValue[c] = static_cast<Int32>(value[c])`). So a `glVertexAttrib4f(loc, 1.5f, …)`
|
||
puts `1` in the frontend's `intValue` and `0x3FC00000` (1069547520) in the pushed one.
|
||
The pushed value is wrong for every non-integral float and for every int/uint attribute set
|
||
through `glVertexAttribI4i/ui`.
|
||
|
||
`tracker-v1.md` §4.2 names the gap and proposes the right fix, but then claims the call is
|
||
still worth landing because "the wire shape, **the payload bytes** and the suppressor are all
|
||
real". The payload bytes are not real; they are wrong, and `ValueClass` — which exists
|
||
"precisely so it does not have to" guess (§4.2's own words) — is the one field the client was
|
||
free to fill correctly and did not.
|
||
|
||
Why the gates cannot see it: the emission runs at step 3 (`PipeFill.cpp:924-947`) and the
|
||
residual fill at step 4 (`:949-…`). `GetCurrentVertexAttribute` is deliberately excluded from
|
||
`EmittedCallSuppliesTheWholeField` (`PipeFill.cpp:668-676`), so step 4 immediately overwrites
|
||
the three corrupted views with a correct pull, **before** `EntryCompare` (`:1006`) and before
|
||
any backend read can reach the verify read hook. G4's 818 verify entries and the verify
|
||
retrace are therefore structurally incapable of reporting this, which is why it is green.
|
||
The correctness of a shipped push build here rests entirely on a later step undoing an
|
||
earlier one; the moment anyone flips that one `case` label — or assumes
|
||
`MGP_COVERAGE_EMITTED_LIST`'s `GetCurrentVertexAttribute → SetVertexAttribDefaults` row
|
||
(`Coverage.def`) is authoritative, which is what the generated
|
||
`kMGPipeFieldEmittedBy[]` says — it is silent wrong vertex-attribute defaults with no gate
|
||
between it and the screen.
|
||
|
||
Minimum to clear this: set `value.ValueClass` from the frontend's actual class rather than a
|
||
literal `0`, and either (a) carry all three views, or (b) record in `Coverage.def`/the result
|
||
file that this row is a **shape-only** emission whose payload is not yet usable, with the
|
||
applier fix (A's `PipeApply.cpp`) named as a blocking follow-up before any phase retires the
|
||
pull for this field. Do not carry the "payload bytes are real" claim into `MEASUREMENTS.md`.
|
||
|
||
---
|
||
|
||
## 3. Minors
|
||
|
||
1. **`MGPipeSubsystemForDirty` has no production caller.** `Tracker.h:119-135` defines the
|
||
bit→subsystem map, but `MGPipeValidateForVerb` gates emission with a *second*, independent
|
||
copy: `SubsystemForEmitter` (`PipeFill.cpp:612-630`) plus four hand-written `if`s
|
||
(`:926-948`). `grep -rn MGPipeSubsystemForDirty MobileGL/` finds it only in
|
||
`TrackerTest.cpp:283-289`. So the one test that pins "each of the five names its own
|
||
subsystem" pins the copy nothing runs; mis-gating `NewPatchState` on the PixelPack bit in
|
||
the real path would pass every test.
|
||
2. **The tracker's unit tests exercise a re-implementation, not the shipped emitter.**
|
||
`TrackerTest.cpp:240-258` (`TrackerWalk::Walk`) reproduces step 3 against a *local*
|
||
`MGPipeTracker`/`MGPipeCsoCache`, with the justification (`:216-220`) that the validate
|
||
point uses process-wide singletons. That is a fair reason, but it means
|
||
`BlendToggleReusesTwoCsos`, `ViewportDoesNotMintACso` and `SteadyStateEmitsNothing` cannot
|
||
fail on a defect in `MGPipeValidateForVerb`; the shipped emitter's only coverage is the
|
||
integration/verify lanes. The brief's C.1 wording ("mints exactly 2 CSOs and issues 2N
|
||
binds") reads as a test of the real path. Worth one always-on integration entry that drives
|
||
`MGP_FILL` and reads `csom`/`csob` back through `PipeStats` (E's `CsoContentAddressingScenario`
|
||
is the natural home).
|
||
3. **`MGPipeCsoCache::Counters::Binds` is declared, documented and never incremented.**
|
||
`CsoCache.h:59` ("bind_render_state emissions, mint or reuse") and the header's promise to
|
||
"publish the mint / bind / evict counters" (`:28-29`); `grep -rn 'm_counters.Binds'` finds
|
||
nothing, and the tests count binds in their own `m_binds`. Either wire it in `Acquire`, or
|
||
delete it before P13's retune reads a permanent zero.
|
||
4. **The residual value block's trip wire is a tautology on this branch.**
|
||
`EmitResidualValueState` (`PipeFill.cpp:800-820`) builds the bits from
|
||
`ctx.IsCapabilityEnabled(...)`, and `MGPipeApplySetResidualValueState`
|
||
(`PipeApply.cpp:244-256`) compares them against `gPipeInputs.m_capability[]` — which step 4
|
||
filled from the *same* accessor a few lines earlier, because `applierDerives` is false and
|
||
`IsCapabilityEnabled` is not in `AppliedWithoutDerivation`. So it cannot diverge here. It
|
||
becomes a real oracle the moment A's `c1` lands (then `IsCapabilityEnabled` is skipped by
|
||
the fill and comes from `MGPipeDeriveRenderStateFields`). `tracker-v1.md` §2.2's G10 line
|
||
should say that the *semantic* half is deferred to the merged tree, alongside the `resid=`
|
||
evidence it does establish.
|
||
5. **`tracker.Staged() = live` is latched on either bit, but `set_dynamic_state` is emitted
|
||
only on `NewRenderState`.** `PipeFill.cpp:889-893`. If `NewPipelineState` ever fired without
|
||
`NewRenderState`, the staging mirror would claim the server holds dynamic bytes it never
|
||
received, and the chunk-level suppressor would never resend them — a permanently stale
|
||
answer. It is unreachable today only because `BumpVersions()` moves both counters
|
||
(`RenderState.h:159-162`), i.e. it depends on an invariant of *another package's* file that
|
||
nothing here asserts. A `MOBILEGL_ASSERT` (or narrowing the assignment to the chunks
|
||
actually sent) costs nothing.
|
||
6. **G9 is only half-landed here and `tracker-v1.md` §2.2 lists it green without the caveat.**
|
||
`.github/workflows/test.yml:1528-1532` still runs `--summary` under an "Informational …
|
||
becomes a gate in P2" comment. B correctly did not touch E's file (C.1 constraint), but the
|
||
G14 row of §A says "CI: `pipe-gates`", so the gate is not a gate until E lands. Say so in
|
||
the hand-off.
|
||
7. **G1 admits three named resizes; the tree has four.** `_GLOBAL__sub_I_DirectGLES.cpp`
|
||
(−9 bytes) is resized alongside the three `RenderState` symbols. It is the contract
|
||
commit's, not B's (B's own delta on top is zero), but D15/§A's "resized ⊆ the three
|
||
RenderState symbols" is not literally satisfiable on the merged tree and the integrator has
|
||
to widen the admitted set explicitly rather than wave it through.
|
||
8. **D14's "all-pull control reproduces P1's behaviour exactly" and D.4.3's T2 are no longer
|
||
true of the landed code.** The dirty walk (`PipeFill.cpp:918-922`) runs unconditionally;
|
||
only emission is behind the bitmask. So `MOBILEGL_PIPE_PUSH=0` still pays for ~18 shutters
|
||
per verb, and `T2 = ns_per_op(push, PUSH=0) − ns_per_op(pull)` already contains the whole
|
||
tracker cost — which means `T1 − T2` does **not** isolate what P2 added, it cancels the
|
||
largest thing P2 added. B followed D1 correctly (the walk is step 2, before the gate); the
|
||
integrator must restate T1/T2 in `MEASUREMENTS.md` before the D.4.3 run, or the ≤45 ns
|
||
ceiling is checked against the wrong difference.
|
||
9. **`ApplierDerivesRenderStateFields()` probes one of twenty-nine derivations.**
|
||
`PipeFill.cpp:679-704` latches on `m_clearStencil` alone. A partial `c1` that implements
|
||
`m_clearStencil` and forgets, say, `m_viewport`'s rounding flips the latch to true and lets
|
||
28 mirrors go unwritten; the verify lane is the backstop, not the probe. Worth saying so in
|
||
the comment (which currently says "this only says it is THERE" — accurate, but the
|
||
integrator should know the probe is a single-field sample).
|
||
10. **Three `kExplicitDestroy` rows name a mechanism nothing builds.**
|
||
`DirtySurface.def:127,128,131` map `MarkProgramForDeletion`,
|
||
`MarkProgramPipelineForDeletion` and `MarkShaderForDeletion` onto "the `delete_*` call the
|
||
Track H slice emits", but D13 scopes Espryt 0b's explicit destroy to six object kinds that
|
||
do not include programs, pipelines or shaders. Those three answers are aspirational, not
|
||
factual — the same class of defect as MAJOR 1, at lower stakes.
|
||
11. **`MGPipeWidenedCounter` can miss a change, contrary to its own comment.**
|
||
`Tracker.h:154-159`: the wrap test is `now < m_last`, so a `Uint16` counter that advances
|
||
by exactly 65536 between two walks reads as unchanged and the bit does not fire.
|
||
`TrackerWalk.WrapAroundRePushesButNeverMisses` drives 70000 *single-step* changes, which
|
||
cannot construct that case, so "never a missed push" (`Tracker.h:150-151`) is stronger than
|
||
what is tested. Pre-existing in class (both backends already compare raw `Uint16`s), so
|
||
record it rather than fix it.
|
||
12. **Test seam and reset asymmetry.** `MGPipeCsoCache::s_hashForTest` (`CsoCache.h:120-121`)
|
||
is a writable function pointer in production code — declared as deviation 6 and contained,
|
||
but note that `MGPipeApplierReset()` is callable from a test *without* resetting
|
||
`MGPipeCsoCacheInstance()`/`MGPipeTrackerInstance()`, which would make the next
|
||
`bind_render_state` name a dead CSO (`PipeApply.cpp:156-160` asserts and returns, leaving
|
||
`m_renderState` unwritten while the fill skips it). Safe today only because ctest runs one
|
||
gtest case per process. `TrackerWalk::SetUp`/`TearDown` (`TrackerTest.cpp:223-233`) do
|
||
exactly that pairing.
|
||
13. **The brief's own G2/G14 grep is broken — confirmed.** `ctest -N | grep -cE '^\s+Test #'`
|
||
returns **1397** of 2396 on this tree (I reran it). `tracker-v1.md` §4.3 is right and the
|
||
corrected pattern `'^ +Test +#[0-9]+: '` is what I used above. §A's G2/G14 rows and D.1's
|
||
loop must be fixed by the integrator before anyone copies them into CI.
|
||
14. **Header-only `Tracker.h`/`CsoCache.h`/`SetHashSuppressor.h`** (deviation 1) is a sound
|
||
route around A's frozen `CMakeLists.txt`, but it leaves a `static PipeInputs probe`
|
||
(`PipeFill.cpp:681`) and three function-local singletons in whichever TU includes them.
|
||
Land the one `list(APPEND)` line at integration rather than letting the deviation stand as
|
||
the final shape.
|
||
|
||
---
|
||
|
||
## 4. Deviations checked against §B
|
||
|
||
Declared and accepted: 1 (header-only, ownership-forced), 2 (a sixth aggregate
|
||
`VertexAttribDefault` — over-fires, cheaper than D4's per-draw 768-byte hash, and
|
||
`TrackerAggregates.AVertexAttribDefaultMovesOnlyItsOwnAggregate` pins it), 3 (`Core.{h,cpp}`
|
||
— "nobody" in C.5, all `#if MOBILEGL_PIPE_PUSH`, G1 unaffected — verified), 4 (coarse
|
||
shutters for bits 5–17; every one of them over-fires, and P2 emits nothing from them), 5
|
||
(`Vector` linear scan instead of `ska::flat_hash_map` — behaviour is exactly D7), 6
|
||
(`s_hashForTest`), 7 (residual block after the fill, held rather than dropped), 8 (the
|
||
derivation probe), 9 (five stale `MGPipeFillForVerb` comment references in A's files).
|
||
|
||
Undeclared deviations found: **none**. I checked the aggregate bump points against D4 line by
|
||
line — every `++m_configVersion` (`VertexArrayObject.cpp:300,307,314`), every
|
||
`++m_contentVersion` (`TextureObject.cpp:295,367,379`, `TextureObject2DCube.cpp:52,64`), every
|
||
`++m_textureParamsVersion` (`TextureObject.cpp:102,128,143,158,208,216,234,246,267,305,315`,
|
||
`TextureObject.h:183`), `SamplerObject::BumpVersion` (`:28-37`, the one choke point for all 15
|
||
sampler setters), every `++m_changeSerial` in `BufferObject.cpp` (7 sites) and every
|
||
`++m_objectVersion` in `FramebufferObject.cpp` (`:191,203-206` inside the five-setter macro,
|
||
`:216-219`) carries an `MGP_NOTE_AGGREGATE`. No bump site is uncovered — the "dirty bit that is
|
||
never set" hunt came up empty.
|
||
|
||
Also checked and clean: no hot-path instrumentation (no timer anywhere in `Tracker.h`; every
|
||
tally is behind `PipeStats::Enabled()`, `Tracker.h:292-298`); no stdio under
|
||
`MG_Backend`/`MG_State`; no accessor in the walk forces a link join (`GetCurrentProgram`
|
||
`Core.cpp:386-388` and the six program version getters are plain member reads —
|
||
`GetProgramForDraw` is deliberately not used, `Tracker.h:208-211`); `PipeCalls.def` untouched.
|
||
|
||
---
|
||
|
||
## 5. Bottom line
|
||
|
||
The core of the package is sound and independently verified: G1, G2, G4 (integration-verify),
|
||
G5, G9, G13, G14 all reproduce, three unit lanes are 1518/1518, both integration-gpu arms are
|
||
878/878, the chunk-table partition is a `static_assert` and its *rule* survived a
|
||
setter-by-setter re-derivation, and the assembled render-state block is proven byte-identical
|
||
to the live one by an oracle that re-reads the whole struct at every backend read.
|
||
|
||
What blocks approval is not the machinery but two artefacts landed as finished while being
|
||
factually wrong, in both cases in a way no gate in this tree can report: the mapping file's
|
||
two under-firing rows (MAJOR 1) and the vertex-attribute-default payload (MAJOR 2). Both are
|
||
small fixes; neither needs another package.
|