mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-16 06:23:23 +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.
377 lines
27 KiB
Markdown
377 lines
27 KiB
Markdown
# P2 package B — `p2/tracker` — result, rework round 3
|
||
|
||
Tree `~/w7/p2-tracker`, branch `p2/tracker`, branched from the contract commit `9c6a8a25`
|
||
(the `p2/contract` tag). Not pushed. Supersedes `tracker-v2.md`; everything that file says
|
||
about rounds 1–2 still holds except where §2 below corrects it.
|
||
|
||
Round-3 scope: the three majors and all ten minors of `tracker-review-v2.md`. Nothing from
|
||
rounds 1–2 was reverted; two new commits sit on top of `dc452c02`.
|
||
|
||
---
|
||
|
||
## 1. Commits
|
||
|
||
Rounds 1–2 (`9c6a8a25..dc452c02`, unchanged): `f52dd262`, `9c9df515`, `8d000f7e`, `a0c44c4f`,
|
||
`e54e7399`, `e49f0ea7`, `b3daa404`, `7993d711`, `57b85f73`, `80b861b8`, `d5d4e757`, `dc452c02`.
|
||
|
||
Round 3 (`dc452c02..HEAD`, new):
|
||
|
||
| sha | subject | closes |
|
||
|---|---|---|
|
||
| `4e8f7179` | `[Fix] (Pipe): re-arm the residual block on any render-state move and republish every vertex-attribute default on a fresh context` | **MAJOR 1**, **MAJOR 3**, minors 1, 4, 5, 6 |
|
||
| `06f9adfd` | `[Fix] (Pipe): derive the dirty-surface map's object-class and value-class answers too, and correct the two rows that named a shutter their mutator never moves` | **MAJOR 2**, minors 8, 9 |
|
||
|
||
Round-3 diffstat: 5 files, +594 / −56.
|
||
|
||
```
|
||
MobileGL/MG_Impl/Pipe/PipeFill.cpp | 119 ++++++--
|
||
MobileGL/MG_Impl/Pipe/PipeFill.h | 9 +
|
||
MobileGL/MG_Pipe/DirtySurface.def | 43 ++-
|
||
MobileGL/MG_Test/Pipe/TrackerTest.cpp | 107 ++++++-
|
||
scripts/gen_pipe_dirty_surface.py | 372 ++++++++++++++++++++++++---
|
||
```
|
||
|
||
All five are B's own rows in C.5. Whole package: 26 files, +3395 / −78. No `MG_Backend/**`,
|
||
no `CMakeLists.txt`, no A/E file touched this round (round 1's `MG_State/GLState/Core.{h,cpp}`
|
||
edits stand as declared deviation 3, "nobody" in C.5). Single-line `[Type] (Scope): …`
|
||
subjects, `- ` bullets, zero attribution lines.
|
||
|
||
---
|
||
|
||
## 2. The three majors
|
||
|
||
### MAJOR 1 — the residual block's shutter
|
||
|
||
**Confirmed and fixed.** `g_residualDue` was set only on `FreshlyPrimed || NEW_PIPELINE_STATE`
|
||
(`PipeFill.cpp:1096-1098` at `dc452c02`), while `CapabilityInput::ClipDistance0..7` are 8 of
|
||
the 35 bits the block carries and `RenderState::SetCapability`'s clip-distance arm is
|
||
deliberately `++m_version` only. The comment above the emitter asserted the opposite as its
|
||
justification.
|
||
|
||
What landed (`4e8f7179`):
|
||
|
||
* the arming is now `NEW_RENDER_STATE | NEW_PIPELINE_STATE` — the coarsest always-true
|
||
shutter, and the same answer `DirtySurface.def`'s derivation gives `SetCapability`;
|
||
* it moved **outside** the `kMGPipeSubsystemResidualValues` gate: whether the capability set
|
||
may have moved is a fact about the frontend, not about which subsystems this build pushes,
|
||
so a per-subsystem A/B that turns the block off no longer loses the record that one is owed;
|
||
* `FreshlyPrimed` arms it in the new fresh-context block (below), which is also where
|
||
`MGPipeApplierReset()` clears the applier's residual mirror — the two now cannot disagree;
|
||
* the false comment is replaced with the fact and the trade (over-firing costs one 35-bit
|
||
loop on a verb that already moved render state; under-firing renders stale).
|
||
|
||
Pinned by `TrackerShippedEmitter.AClipDistanceEnableReArmsTheResidualBlock`, which poisons
|
||
`MGPipeApplier().Residual`, asserts the premise (`glEnable(GL_CLIP_DISTANCE0)` moves
|
||
`m_version` and not `m_pipelineStateVersion` — asserted, not assumed, so the test says so if
|
||
that ever changes), and requires the re-emitted block to carry the bit.
|
||
|
||
**Cost, for `MEASUREMENTS.md`.** The block now goes out on every verb where render state
|
||
moved, not only where the pipeline version moved: 8 bytes plus a 35-way `IsCapabilityEnabled`
|
||
loop plus the applier's 35-bit compare. In the `CrossFrameBufferScenario` window trace this
|
||
changes nothing measurable (§5.5: `resid=8.00` in window 1, `0.00` after, exactly as in round
|
||
2, because nothing there moves render state after the priming draw). A blend-toggle workload
|
||
pays it once per toggled draw. I did not add a content-level suppressor (skip when the 35 bits
|
||
are unchanged) on purpose: the trip wire's job is to catch an *assembled* block that drifts
|
||
from the frontend's answer, and that drift does not move the carried bits, so suppressing on
|
||
them would disarm the oracle for exactly the case D9 built it for.
|
||
|
||
### MAJOR 2 — two `.def` rows, and a gate that could not see them
|
||
|
||
**Both confirmed and fixed, and the gate widened rather than merely documented.**
|
||
|
||
* `X(SetPixelStoreParam, NEW_PIXEL_PACK)` → **`kPulledEveryVerb`**. The setter writes both
|
||
halves (eight `Pack` arms, eight `Unpack` arms) and the tracker's bit 2 is a byte compare of
|
||
the pack half alone, so eight of sixteen arms move nothing that bit reads. What is true on
|
||
every path is the pull: `GetPixelStoreParameters` is one of the two `Coverage.def` rows an
|
||
emitted call does not supply completely, so the residual fill copies both halves at every
|
||
verb of the class. The comment on the row says all of that.
|
||
* `X(SetNamedTransformFeedbackBinding, NEW_SO_TARGETS)` → **`kPulledEveryVerb`**. False on
|
||
*every* path: the mutator binds a `BufferState` binding point or writes a saved-bindings
|
||
entry, while the bit mixes the buffer-**content** aggregate with the transform-feedback
|
||
generation. It reaches the backend like every other buffer binding point, through
|
||
`GetBufferBindingPoint` in the class's may-read mask.
|
||
* **`--check` now derives the other 28 rows' answers too.** `gen_pipe_dirty_surface.py`
|
||
reads `Tracker.h`'s `Update()` for what each bit's shutter READS (locals expanded, and the
|
||
two `BitwiseEqual` bits taken from the block that builds the compared value), resolves those
|
||
accessors through `MG_State`'s getters to the members behind them, computes what every
|
||
mutator transitively WRITES as a fixed point over `MG_State/GLState` + `MG_Impl/Pipe`
|
||
(expanding `MGP_NOTE_AGGREGATE` through `MGPipeNoteAggregate`'s own `switch` rather than
|
||
assuming the hop), and fails a row naming a bit whose shutter its mutator moves on no path.
|
||
The enumerator spelling (`MGPipeDirty::NewSoTargets`) and the row spelling
|
||
(`NEW_SO_TARGETS`) are paired **by position** out of `Tracker.h`, so the enum and
|
||
`kMGPipeDirtyNames` drifting apart is itself a gate failure.
|
||
* It is **one-directional by construction** and the file and `--check` both say so: the write
|
||
analysis over-approximates (a call name resolves to every body of that name, a write inside
|
||
an `if` counts), so it can prove absence and not presence. Absence is the under-firing
|
||
direction. There is deliberately no MISSING check on this family.
|
||
* `--check` now prints its own coverage, including what it did **not** check:
|
||
`45 render-state answers derived …; 7 other bit answers derived from their shutter in
|
||
Tracker.h (under-firing only); 0 declined; 25 rows carry a prose answer (kExplicitDestroy,
|
||
kImmediate, kNoBackendRead, kPulledEveryVerb, kReverseChannel, kUnpublishedDestroy) that no
|
||
derivation checks`, and it lists every row it had to decline (none today).
|
||
|
||
**The gate demonstrably sees the two defects.** Before the rows were corrected, the new
|
||
derivation printed exactly, and only, them:
|
||
|
||
```
|
||
dirty-surface: UNDER-FIRING answer NEW_SO_TARGETS for SetNamedTransformFeedbackBinding - it
|
||
writes nothing NEW_SO_TARGETS's shutter reads (shutter: m_anyBufferChangeGeneration,
|
||
m_transformFeedbackGeneration), so a mutation through it publishes nothing
|
||
dirty-surface: UNDER-FIRING answer NEW_PIXEL_PACK for SetPixelStoreParam - it writes nothing
|
||
NEW_PIXEL_PACK's shutter reads (shutter: m_pixelStorePackParameters,
|
||
m_pixelStoreUnpackParameters), so a mutation through it publishes nothing
|
||
dirty-surface: 2 problem(s); … (main() returned 1)
|
||
```
|
||
|
||
Two more self-test negative controls make that permanent (one object-class, one value-class):
|
||
`--self-test` is now `7 negative controls, all tripped`.
|
||
|
||
The review's own in-memory demonstration no longer passes: `SetNamedTransformFeedbackBinding
|
||
← NEW_VERTEX_ATTRIB_DEFAULTS`, `SetPixelStoreParam ← NEW_SO_TARGETS`,
|
||
`BumpTextureBindGeneration ← NEW_GLOBAL_CONSTANTS` and `SetCurrentVertexAttributeInt ←
|
||
NEW_FRAMEBUFFER` are all UNDER-FIRING under the new check.
|
||
|
||
### MAJOR 3 — `set_vertex_attrib_defaults` published nothing across a context change
|
||
|
||
**Confirmed and fixed.** `Tracker::Reset()` sets the staging mirror to `AttribDefaults{}`
|
||
(the GL defaults) and a fresh `GLContext` holds the same, so the per-attribute diff was empty
|
||
on the one walk that must publish a complete state, while `MGPipeApplierReset()` left
|
||
`gPipeInputs.m_currentVertexAttribute` holding the **previous** context's values — cancelling,
|
||
two lines later, the `InvalidateAll()` written for exactly that case.
|
||
|
||
What landed (`4e8f7179`): `EmitVertexAttribDefaults(ctx, freshlyPrimed)` sends all 32 when the
|
||
tracker is freshly primed — the arm `EmitRenderState` already had, and the same shape as
|
||
`EmitPixelPackState`/`EmitPatchState`, which send whole values. `MGPipeVertexAttribDefaultsLastHeader()`
|
||
(PipeFill.h) is the observable: `Count`/`Mask` of the last call that actually went out, which
|
||
is the only way to see this without a poisoned read of `m_currentVertexAttribute`.
|
||
|
||
Pinned by `TrackerShippedEmitter.AFreshContextRepublishesEveryVertexAttributeDefault`
|
||
(fresh context ⇒ `Count == 32`, `Mask == 0xFFFFFFFF`; a steady context ⇒ `Count == 1`).
|
||
|
||
**This closed round-2 minor 2 as a side effect, with corpus evidence.** The repair path used
|
||
to have unit coverage only — the reviewer found 0 occurrences of the applier warning across
|
||
79 verify logs. Now the fresh-context republish carries the GL default `{0,0,0,1}`, whose
|
||
float bit pattern (`0x3F800000` in component 3) is not the int view the frontend holds, so
|
||
the applier's class-blind `memcpy` cannot reproduce it, the client detects that and repairs
|
||
the mirror — **once per process, in all 79 verify logs and all 79 push logs** (§5.4). The
|
||
repair is now exercised by the whole retrace corpus and the whole integration lane, not just
|
||
by a unit test.
|
||
|
||
Consequence the integrator must know: **every push/verify run now logs one
|
||
`MGLOG_W_ONCE` line** — `MGPipe: MGPipeApplySetVertexAttribDefaults does not reproduce the
|
||
carried value on this build (it ignores MGPAttribValue::ValueClass) - the client is keeping
|
||
m_currentVertexAttribute authoritative`. It is once per process, it is true, and it stops by
|
||
itself the day package A honours `ValueClass` (§7 hand-off 1). I kept it at W rather than
|
||
demoting to D because a mirror the applier cannot reproduce is exactly what a warning is for.
|
||
|
||
### The three fixes' negative controls, run
|
||
|
||
Each fix was reverted in the working tree, the test binary rebuilt, the new case run, and the
|
||
tree restored (`scratchpad/wf5/p2-tracker/r3_neg.py`):
|
||
|
||
| control | result |
|
||
|---|---|
|
||
| residual armed on the pipeline version only | `AClipDistanceEnableReArmsTheResidualBlock` **TRIPPED (red)** |
|
||
| no freshly-primed arm in `set_vertex_attrib_defaults` | `AFreshContextRepublishesEveryVertexAttributeDefault` **TRIPPED (red)** |
|
||
| applier/cache reset back inside the render-state gate | `AFreshContextResetsTheApplierWithTheRenderStateSubsystemOff` **TRIPPED (red)** |
|
||
|
||
---
|
||
|
||
## 3. The ten minors
|
||
|
||
| # | verdict |
|
||
|---|---|
|
||
| 1 the repair test asserted the defect | **fixed.** It now asserts the invariant: the call went out naming exactly the attribute that moved (`Count == 1`, `Mask == 1`), `repairs <= before + 1`, and a second identical walk neither re-emits nor re-repairs. It stays green the day A honours `ValueClass`. |
|
||
| 2 the repair path had unit coverage only | **fixed by MAJOR 3's fix, with evidence**: the warning now appears once in each of the 79 verify logs and 79 push logs (§5.4). Still true that no fixture *moves* a `glVertexAttrib*` default mid-trace; the fresh-context republish is what exercises the path. |
|
||
| 3 `build-verify` was stale at `dc452c02` | **accepted and acted on**: all three build dirs were rebuilt from scratch of the current tip before any lane in §5 was run, and the numbers below are from those binaries. My verify retrace's lowest SSIM is **0.993475**, equal to the push arm and to the reviewer's own run — `tracker-v2.md` §5.2's `0.997009` was indeed produced from a binary that was not the tip. **Do not copy `tracker-v2.md` §5 into `MEASUREMENTS.md`; use §5 here.** |
|
||
| 4 the fresh-context reset sat inside the render-state subsystem gate | **fixed.** `MGPipeCsoCacheInstance().Reset()`, `MGPipeApplierReset()`, `InvalidateAll()` and the residual arming now happen in one block before any per-subsystem gate. Pinned by `AFreshContextResetsTheApplierWithTheRenderStateSubsystemOff`, which clears bit 0 and keeps bits 1–3 (the A/B D14 invites). |
|
||
| 5 the residual gate names a subsystem constant directly | **fixed as far as it can be**: it still tests `kMGPipeSubsystemResidualValues` directly, because the residual block has no dirty bit to route through `MGPipeSubsystemForDirty` — that is what makes it the residue. The exception is now stated at the code and *asserted*: a `constexpr` `static_assert` that **no** `MGPipeDirty` bit maps onto `kMGPipeSubsystemResidualValues`, so the day one does, the double gate is a build break rather than a silent second switch. |
|
||
| 6 the `MOBILEGL_ASSERT` is compiled out in Release | **recorded at the code**: the comment now says the assert is a debug/verify alarm and that the *behaviour* is safe in every build regardless — it is the narrowing of the mirror advance to the `NEW_RENDER_STATE` branch, which is unconditional, that makes it safe; a broken invariant in a shipping build costs a re-send, never a false claim. |
|
||
| 7 `SetPatchVertices` changed answer class without a declaration | **declared**, §6 deviation 14. |
|
||
| 8 `render_state_publishers()` unions across bodies of one name | **fixed**: the fold is now `set.intersection` over the bodies of a name (per-body resolution, then intersect). No answer changes today (45 names / 45 bodies); it is the fold that stays right when one name has two bodies. |
|
||
| 9 a conditional `BumpVersions()` derives as unconditional | **fixed in the header's wording**: "every path" now reads "every path that MUTATES" — a redundant-write guard has no mutation to carry, so it does not make its publisher conditional; a publisher reached on only some *mutating* paths is what must not be named. |
|
||
| 10 the outstanding list | **restated**, §7/§8: G9 is not a CI gate until E lands; G1's admitted resize set is four symbols; D14/D.4.3's T1−T2 no longer isolates the tracker; `MGPipeWidenedCounter` cannot see a change of exactly 65536; `s_hashForTest` is a live function pointer; the three header-only files still want their `list(APPEND)` line. |
|
||
| 11 three commands in brief §A are broken | **re-reproduced this round**, §6.1. |
|
||
|
||
---
|
||
|
||
## 4. What is *not* fixed, and why
|
||
|
||
* **`kPulledEveryVerb` is a prose answer no derivation checks.** Both corrected rows now carry
|
||
it, and so do 23 others. Checking it would mean deriving "this field is in its verb class's
|
||
may-read mask and no emitted call supplies it", which is `Coverage.def` + `gen_pipe.py` +
|
||
`EmittedCallSuppliesTheWholeField` — A's files and E's gate, not B's. `--check` prints the
|
||
count of prose rows so the gap is visible in the gate's own output rather than implied.
|
||
* **The object-class derivation cannot prove a publisher fires on every path**, only that it
|
||
fires on none. Stated in the file, in the script's docstring and in `--check`'s output.
|
||
* **No content suppressor on the residual block** — see MAJOR 1's cost note.
|
||
|
||
---
|
||
|
||
## 5. Verification — every command and its actual output
|
||
|
||
All commands run in `~/w7/p2-tracker` at `06f9adfd`, after `cmake --build` of all three build
|
||
dirs (build-linux 67 targets, build-push 51, build-verify 73 — the tip is what every number
|
||
below was produced from). `git status --porcelain` is empty before and after.
|
||
|
||
### 5.1 Generators and gates
|
||
|
||
| command | output |
|
||
|---|---|
|
||
| `python3 scripts/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` + `7 other bit answers derived from their shutter in Tracker.h (under-firing only); 0 declined; 25 rows carry a prose answer (…) that no derivation checks` |
|
||
| `python3 scripts/gen_pipe_dirty_surface.py --self-test` | rc 0 — `7 negative controls, all tripped` |
|
||
| `python3 scripts/gen_pipe_dirty_surface.py --summary` | rc 0 — unchanged shape, E's CI step still works |
|
||
| `python3 scripts/gen_pipe.py --check` | rc 0 — `inventory 477 rows … 0 UNMAPPED`, `generated files are up to date` |
|
||
| `python3 scripts/gen_pipe.py --self-test` | rc 0 — `7 negative-control trip(s), positive control OK` |
|
||
| `python3 scripts/check_include_closure.py` | rc 0 — `4 probes, 0 skipped, 0 problem(s)` |
|
||
| `grep -rc 'pGLContext' MobileGL/MG_Backend \| grep -v ':0$'` | empty |
|
||
|
||
### 5.2 Section-A gates reachable from this tree
|
||
|
||
| gate | command | output |
|
||
|---|---|---|
|
||
| **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%)`; file size identical. The four resized are the contract's (`RenderState::RenderState()` +148, `SetCapability` +77, `IsCapabilityEnabled` +29, `_GLOBAL__sub_I_DirectGLES.cpp` −9). **Round 3 adds zero pull-build delta.** |
|
||
| **G2** | `ctest -N` name sets, `'^ +Test +#[0-9]+: '` | `build-linux 2407`, `build-push 2407`, **zero-line diff** (2404 + the 3 new cases and their pull SKIP twins) |
|
||
| **G3** | `retrace_gate.py --tree ~/w7/p2-tracker --lib …/build-push/libMobileGL.so --out ~/w7/retrace-out/r3-push -j 4` | rc 0 — **79 / 79**, `failed: []`, lowest SSIM **0.993475** (two cases), then 0.995426 |
|
||
| **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 --out ~/w7/retrace-out/r3-verify -j 4` | rc 0 — **79 / 79**, lowest SSIM **0.993475** |
|
||
| **G4** | log evidence at `<out>/<case>/<backend>/output/mobilegl.log`, arming string `MGPipe: verify armed` | 79 logs; `Fatal{` **0**; unarmed **0**; `PipeVerifyDiffer` **0**; `PipeResidualDiverged` **0**; `UnmigratedPipeInput` **0** |
|
||
| **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` |
|
||
| **G9** | above | green, and now a gate over the object-class and value-class answers as well |
|
||
| **G10** (desktop half) | `MOBILEGL_LOG_FILE_PATH=… MOBILEGL_PIPE_STATS=1 MOBILEGL_PIPE_STATS_PERIOD=1 MobileGLIntegrationTest --gtest_filter='*CrossFrameBufferScenario*'` | 13/13 pass; window 1 `resid=8.00 … cso[csom=1 csob=1]`, windows 2+ `resid=0.00 … csom=0 csob=0` |
|
||
| **G13** | above | clean |
|
||
| **G14** | `comm -23 ~/w7/p2-before-ctest-names.txt <build-linux names>` | empty (0 of 2363 baseline names removed) |
|
||
|
||
Not reachable here: **G6/G7** (package A), **G8/G12** (package E), **G11** (device).
|
||
|
||
### 5.3 Test lanes
|
||
|
||
| lane | result |
|
||
|---|---|
|
||
| `ctest --test-dir build-linux -L unit -j 8` | rc 0 — **1529 / 1529** |
|
||
| `ctest --test-dir build-push -L unit -j 8` | rc 0 — **1529 / 1529** |
|
||
| `ctest --test-dir build-verify -L unit -j 8` | rc 0 — **1529 / 1529** |
|
||
| `ctest --test-dir build-push -L integration-gpu -j 4` | rc 0 — **878 / 878** |
|
||
| `MOBILEGL_PIPE_PUSH=0 ctest --test-dir build-push -L integration-gpu -j 4` | rc 0 — **878 / 878** (all-pull arm) |
|
||
| `ctest --test-dir build-linux -L integration-gpu -j 4` | rc 0 — **878 / 878**, first try, no flake |
|
||
| `ctest --test-dir build-verify -L integration-verify -j 4` | rc 0 — **818 / 818** |
|
||
|
||
Unit count 1526 → 1529: the three new `TrackerShippedEmitter` cases (and their pull SKIP
|
||
twins, which is why G2 stays name-for-name identical).
|
||
|
||
### 5.4 The applier-repair warning, now visible in the corpus
|
||
|
||
`grep -l 'does not reproduce the carried value' …/output/mobilegl.log`: **79 of 79** verify
|
||
logs and **79 of 79** push logs, exactly one occurrence each (`MGLOG_W_ONCE`). Before this
|
||
round: 0 of 79. See MAJOR 3.
|
||
|
||
### 5.5 G10's stats windows, verbatim (first two)
|
||
|
||
```
|
||
MGPipe stats: frames=1 window=1 draws=1 draws/f=1.00 acc=16 acc/draw=16.00
|
||
bytes/f[buf=184.00 … resid=8.00] tex[…] cso[csom=1 csob=1] gates[ers=1/1 etl=1/1 eub=1/1 …]
|
||
MGPipe stats: frames=2 window=1 draws=1 draws/f=1.00 acc=14 acc/draw=14.00
|
||
bytes/f[buf=0.00 … resid=0.00] tex[…] cso[csom=0 csob=0] gates[ers=2/0 etl=2/0 eub=2/0 …]
|
||
```
|
||
|
||
**Note for whoever repeats this**: the stats line does **not** reach `ctest -V`'s captured
|
||
output. It is `MGLOG_I`, so on desktop it needs `MOBILEGL_LOG_FILE_PATH`; run the integration
|
||
binary directly with `--gtest_filter='*CrossFrameBufferScenario*'` (the ctest entry names are
|
||
not the gtest suite names).
|
||
|
||
---
|
||
|
||
## 6. Where the tree contradicted the brief
|
||
|
||
Rounds 1–2's list stands (`tracker-v2.md` §6): `MGPipeDeriveRenderStateFields` is a stub on
|
||
this tag; the two `Coverage.def` rows cannot retire their pull; `MGPipeApplyDeleteRenderState`
|
||
takes `MGPHandleOnly`; D13's "six kinds" is not self-consistent with the `Core.cpp` ranges it
|
||
cites; `MG_Backend/MGPipe/PipeInputs.cpp`'s `static_assert(sizeof(...) == 3*4*4)` forces the
|
||
attribute-value class to live beside the array. New or re-confirmed this round:
|
||
|
||
### 6.1 Three commands in section A still do not work as written (re-reproduced)
|
||
|
||
1. **G3/C.2/C.3's `--ssim 0.99`** — `retrace_gate.py: error: unrecognized arguments: --ssim
|
||
0.99`, with `--tree`/`--lib`/`--out` all supplied. As written the gate exits non-zero
|
||
having run nothing. The threshold is internal.
|
||
2. **G2/G14's `grep -E '^\s+Test #'`** — matches 1408 of 2407 names in this tree (it drops
|
||
every test numbered under 1000). Corrected pattern used here: `'^ +Test +#[0-9]+: '` with
|
||
`sed -E 's/^ *Test +#[0-9]+: //'`.
|
||
3. **G4's log glob and arming string** — logs are at `<out>/<case>/<backend>/output/mobilegl.log`
|
||
(the brief's `<out>/<case>/mobilegl.log` matches nothing) and the arming line is
|
||
`MGPipe: verify armed - 63 fields, 69 verbs, fatal=1`, not `MGPipe verify:` (0 files match
|
||
the brief's string). Fixing only the path would turn a true green into a false red.
|
||
|
||
**§A and D.3 must be corrected before the five-part gate is run.**
|
||
|
||
### 6.2 The G10 stats command needs a log file on desktop
|
||
|
||
Recorded in §5.5. `tracker-v2.md` and `tracker-review-v2.md` both present a `ctest`-shaped
|
||
command; what actually produces the line is the direct binary run with
|
||
`MOBILEGL_LOG_FILE_PATH`.
|
||
|
||
---
|
||
|
||
## 7. Deviations from the brief
|
||
|
||
Rounds 1–2's twelve deviations are unchanged and still declared (header-only
|
||
`Tracker/CsoCache/SetHashSuppressor`; the sixth aggregate generation; `Core.{h,cpp}`; coarse
|
||
shutters for bits 5–17; `Vector` scan in the CSO cache; `s_hashForTest`; the residual block
|
||
emitted after the fill; the runtime derivation probe; five stale comment references in A's
|
||
files; `|`-joined `.def` answers; `GLContext`'s push-only class array;
|
||
`MGPipeVertexAttribDefaultRepairCount`). New in round 3:
|
||
|
||
13. **`MGPipeVertexAttribDefaultsLastHeader()` is a second observable in production code** —
|
||
one 8-byte global written only when a `set_vertex_attrib_defaults` actually goes out. It
|
||
is the only way to see "the fresh context republished all 32" and "one moved attribute
|
||
published exactly one": reading `m_currentVertexAttribute` back at a verb whose class does
|
||
not carry it is the poison violation `FillPoints.def` forbids. Not on any hot path.
|
||
14. **`X(SetPatchVertices, …)` answers `NEW_PATCH_STATE|NEW_RENDER_STATE|NEW_PIPELINE_STATE`,
|
||
not D16's supplied `kImmediate`** (round-2 change, undeclared until now — round-2 review
|
||
minor 7). It *is* also an immediate publish point, but it has a real bit and the bit is
|
||
the more useful answer: `set_patch_state` carries it whatever the caller does next. The
|
||
row's comment says so, and the render-state half of the answer is derived and checked.
|
||
15. **`kPulledEveryVerb` now carries two rows whose mutator does move *a* real shutter on
|
||
*some* paths** (`SetPixelStoreParam`'s eight pack arms). D16 describes one answer per row
|
||
and the file forbids mixing a prose answer with a bit; under the file's own rule the
|
||
coarsest true answer is the pull. The information that is lost — "the pack half also moves
|
||
NEW_PIXEL_PACK" — is in the row's comment, where no shutter builder can mistake it for a
|
||
licence to narrow.
|
||
|
||
---
|
||
|
||
## 8. Unfinished, and the hand-off
|
||
|
||
1. **Package A must teach `MGPipeApplySetVertexAttribDefaults` to switch on
|
||
`MGPAttribValue::ValueClass`** and reproduce `GLContext`'s conversions
|
||
(`MG_State/GLState/Core.cpp:205-250`). Until then `GetCurrentVertexAttribute` keeps being
|
||
pulled, the client repairs the mirror after every such call, and **every push run logs the
|
||
one-time warning of §5.4**. No edit here is needed when it lands: the repair stops firing,
|
||
`TrackerShippedEmitter.APushedAttributeDefaultTheApplierCannotReproduceIsRepaired` stays
|
||
green (it asserts `repairs <= 1`, not `== 1`), and the `Coverage.def` row can then retire
|
||
its pull.
|
||
2. **The 26 derived render-state mirrors are still pulled on this branch**; the one-shot
|
||
derivation probe flips when A's `c1` lands, and the probe samples one derivation, so the
|
||
verify lane is what proves the rest.
|
||
3. **The residual block's trip wire is still half an oracle here** — while
|
||
`MGPipeDeriveRenderStateFields` is a stub, the mirror it compares against is filled by the
|
||
residual fill from the same accessor. It becomes independent with A's `c1`.
|
||
4. **No fixture in the corpus *moves* a `glVertexAttrib*` default mid-trace.** The repair path
|
||
is now exercised by the fresh-context republish in all 158 retrace runs, but an integration
|
||
entry with a `glVertexAttrib4f` in it would still be worth one line of E's lane.
|
||
5. **`MEASUREMENTS.md` items the integrator owns**: the admitted resized-symbol set is four
|
||
symbols, not D15's three; D14/D.4.3's T1−T2 no longer isolates the tracker (the dirty walk
|
||
is unconditional, only emission is behind the bitmask); the
|
||
`*.IsActuallyArmedWhenTheEnvironmentPinsItOn` family belongs in the known-flake list by
|
||
name (it did not flake this round, but it did in round 2 under lane parallelism, in the
|
||
pull build); and the residual block's new firing rate (MAJOR 1's cost note) belongs beside
|
||
the `resid=` byte class.
|
||
6. **G9 is not a CI gate until package E lands** the `pipe-gates` step; `test.yml` is E's file
|
||
and still runs `--summary` under an "Informational" comment. The two new derivations are
|
||
only as load-bearing as that step.
|
||
7. Unchanged from round 2: per-bit fire rates are not printed (`FormatWindowLine` is A's),
|
||
the six other `SetHashSuppressor` slots are unwired (D11's own scope), `MGPipeWidenedCounter`
|
||
cannot see a change of exactly 65536, `s_hashForTest` is a live function pointer in
|
||
production code, the three header-only files want their `list(APPEND)` line, and there is
|
||
no device work here (G11, D.4).
|