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.
274 lines
21 KiB
Markdown
274 lines
21 KiB
Markdown
# Package A continuation `p2/spans` — result file v3 (rework round 3)
|
||
|
||
Tree `~/w7/p2-spans`, branch `p2/spans`, HEAD **`842af233`**, ten commits on top of the contract
|
||
`9c6a8a25` (tag `p2/contract`). Not pushed. `git status --porcelain` empty at HEAD; every build
|
||
directory is fully up to date at HEAD (`cmake --build` reports 0 steps in all three), so §2's
|
||
table below was produced against the final checkout — review minor 9.
|
||
|
||
**This round fixes both majors and nine of the ten minors of `spans-review-v2.md`.** The tenth
|
||
(minor 4, the process-global CSO store) is argued rather than fixed and is declared as D-8.
|
||
|
||
---
|
||
|
||
## 1. Commits
|
||
|
||
| commit | subject |
|
||
|---|---|
|
||
| `810850b1` | `[Feat] (Pipe): derive every render-state PipeInputs field from the assembled working block instead of pulling it again from GLContext` (round 1) |
|
||
| `eec92cd2` | `[Test] (Pipe): walk every RenderState setter and assert the pipeline-subset hash moves exactly when the pipeline version does` (round 1) |
|
||
| `02b970e9` | `[Test] (Pipe): pin the slot allocator's identity contract - gen moves only on reuse and a recycled address never reproduces a handle` (round 1) |
|
||
| `a9bb99a4` | `[Fix] (Pipe): scope the derivation to the chunks a scatter moved, and give the patch trio and the residual block trip wires that do not depend on call order` (round 2) |
|
||
| `ad1238bd` | `[Test] (Pipe): require a named pipeline member to be WHOLLY pipeline, drive every indexed setter at index 0, and walk the incremental chunk path` (round 2) |
|
||
| `7c2c1456` | `[Test] (Pipe): make the slot allocator's ABA case prove its claim without waiting for the heap, and narrow the DEBUG skip to the arm that needs it` (round 2) |
|
||
| **`bee07c32`** | **`[Fix] (Pipe): arm both applier trip wires off the applier's own scatter ledger instead of off a bound handle, and stop leaving a mixed CSO or a malformed attribute tail to a DEBUG-only assertion`** (round 3 — MAJOR 1, minors 2/3/5) |
|
||
| **`ce370a3e`** | **`[Test] (Pipe): drive both redundancy trip wires and the four apply entry points nothing in any build reached, and finish the setter walk's stencil faces and hint targets`** (round 3 — MAJOR 2, minor 6, minor 7) |
|
||
| **`d1a7c5f1`** | **`[Fix] (Pipe): stop claiming set_pixel_pack_state supplies a field it only half writes, and fold the chunk boundaries into the subset hash's seed`** (round 3 — minors 1 and 8) |
|
||
| **`842af233`** | **`[Chore] (Pipe): drop the executable bit from MGPipeRenderStateSpans.cpp`** (round 3 — minor 10, mode-only, no code) |
|
||
|
||
Files touched this round, all A-owned per `BRIEF-P2.md` §C.5: `MG_Pipe/PipeApply.{h,cpp}`,
|
||
`MG_Pipe/MGPipeRenderStateSpans.{h,cpp}`, `MG_Pipe/Coverage.def`,
|
||
`MG_Pipe/generated/PipeFilled.inc`, `MG_Test/Pipe/RenderStateSpansTest.cpp`,
|
||
`MG_Test/Pipe/CMakeLists.txt`. **No file owned by another package was touched.**
|
||
|
||
---
|
||
|
||
## 2. Verification — every command and what it actually printed
|
||
|
||
All in `~/w7/p2-spans` at `842af233`, `CCACHE_BASEDIR=/home/swung/w7`.
|
||
|
||
| gate / command | observed |
|
||
|---|---|
|
||
| `cmake --build build-{linux,push,verify} -j 12` | rc 0, rc 0, rc 0; **0 build steps in each** (the tree at HEAD is fully built — minor 9) |
|
||
| **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 10792579 -> 10792739 (+160)`. Identical to round 2 — the four resizes are all `c0`'s (`RenderState::{RenderState,SetCapability,IsCapabilityEnabled}` + `_GLOBAL__sub_I_DirectGLES.cpp`), and this round adds nothing to the pull build. |
|
||
| **G5** `awk '/namespace RenderStateImpl \{/,/\} \/\/ namespace RenderStateImpl/' DirectGLES.cpp \| sha256sum` | `d8fd1c48…0efe27` — byte-equal to `~/w7/p2-before-syncrenderstate.sha` |
|
||
| **G13** `grep -rc 'pGLContext' MobileGL/MG_Backend \| grep -v ':0$'` | empty (rc 1) |
|
||
| **G13** `python3 scripts/check_include_closure.py` | `4 probes, 0 skipped, 0 problem(s)` (rc 0) |
|
||
| **G13** `gen_pipe.py --check` / `--self-test` | `generated files are up to date` (rc 0) / `7 negative-control trip(s), positive control OK` (rc 0) |
|
||
| `ctest -L unit` build-linux / build-push / build-verify | **100% passed, 0 failed, out of 1504** in each (1498 before this round; +6 cases) |
|
||
| `ctest -R 'RenderStateSpans\.'` ×3 builds | 11 / 11 / 11 passed (5 cases before round 2, 5 after, **11 now**) |
|
||
| `ctest -R 'SlotAllocator\.'` ×3 builds | 6 / 6 / 6 passed |
|
||
| **G10** `ctest --test-dir build-verify -R 'Residual' --no-tests=error` | **6 tests, 100% passed** — and three of the six are now the wire itself: `ResidualTripWireIsSilentUntilTheApplierOwnsTheBytes`, `…HoldsAcrossAVerbClassThatDoesNotPublishTheBlock`, `…FiresNamingTheCapability`. Before this round `-R Residual` reached only the two `static_assert` catalogue cases and an unrelated `DriverBugProbes` entry. |
|
||
| **G2 shape** `names build-linux` vs `names build-push` | 2382 vs 2382, `diff` empty |
|
||
| **G14** `comm -23 ~/w7/p2-before-ctest-names.txt <names>` | **0 removed**, 19 added (12 `RenderStateSpans.*`, 6 `SlotAllocator.*`, 2 placeholders — 19 because the two placeholders are counted once each) |
|
||
| **G7** manual negative control (D19: move the P1/D2 boundary from `ClearColor` to `ColorMasks`, byte counts 396/772 → 361/807) | build rc 0; `ctest -R 'RenderStateSpans\.'` **rc 8, exactly two entries red**: `ChunkTablePartitionsTheBlock` (`ColorMasks … only 0 of its 32 bytes are in the pipeline half`, plus the three D3 bools) and `SetterConsistency` (`SetColorMask`, `SetColorMaskIndexed`, `SetColorMaskIndexed(0)`, `SetCapability(DepthClamp/FramebufferSrgb/TextureCubeMapSeamless)`: *the pipeline-subset hash held but m_pipelineStateVersion MOVED*). Reverted, rebuilt, 11/11 green, `git status` clean. `scripts/g7_negative_control.sh` is package E's and does not exist on this tree. |
|
||
| **new: trip-wire negative control A** — delete both wires' arming (the pre-`bee07c32` unconditional shape) | `build-verify` builds; `RenderStateSpansTest` **dies inside `ResidualTripWireIsSilentUntilTheApplierOwnsTheBytes`** with no further output — i.e. `std::abort()` on a correct context, MAJOR 1 exactly. Reverted and rebuilt. |
|
||
| **new: trip-wire negative control B** — make every comparison agree (the wire can never fire) | `ResidualTripWireFiresNamingTheCapability` and `PatchCarrierTripWireFiresOnlyWhenTheApplierOwnsChunkP0` both **FAIL**; the other two trip-wire cases still pass. Reverted and rebuilt. |
|
||
|
||
Not run here and not this package's: `ctest -L integration-gpu` / `-L integration-verify`, the
|
||
40-trace retrace (G3/G4), the device runs (G11), the microbenchmark (G12). They are the
|
||
integrator's D.3/D.4.
|
||
|
||
---
|
||
|
||
## 3. What each review item became
|
||
|
||
### MAJOR 1 — the residual wire's oracle (fixed, `bee07c32`)
|
||
|
||
The review is right that `a9bb99a4` moved the oracle from a field published at seven verb
|
||
classes to one published at five, that the m9 claim ("unchanged in strength", "no ordering
|
||
contract at all") was false in both halves, and that `MOBILEGL_PIPE_PUSH=0x10` +
|
||
draw / `glDisable(GL_DITHER)` / dispatch aborts a correct context. **That claim is withdrawn.**
|
||
|
||
The fix is neither of the first two directions the review offered verbatim; it is the second one
|
||
made precise, and it does not touch `FillPoints.def` (package B's file):
|
||
|
||
`MGPipeApplierState` gains `Uint32 ScatteredChunkBits` — the global chunk bits **this applier has
|
||
itself scattered** into `PipeInputs::m_renderState`, written by `bind_render_state` (the whole
|
||
pipeline half) and `set_dynamic_state` (the chunks it names), cleared by `MGPipeApplierReset()`.
|
||
The residual wire compares capability *i* only when every chunk that capability's answer is read
|
||
out of is in the ledger. `set_patch_state`'s own write to the working block deliberately does not
|
||
enter the ledger.
|
||
|
||
Why the ledger and not `m_capability`:
|
||
|
||
- with the render-state subsystem **off**, the ledger is empty, the wire is silent, and the
|
||
`0x10` repro is dead. That is correct rather than merely convenient: with the subsystem off the
|
||
working block is the per-verb fill loop's, published per class, so disagreeing with it means
|
||
nothing;
|
||
- with the subsystem **on**, the applier is the block's only writer (D5's skip rule removes the
|
||
field from the fill loop), so its bytes are current at *every* verb of *every* class — which is
|
||
what case 6b drives, as a draw / capability change / `kDispatch` sequence;
|
||
- `m_capability` would be the *weaker* oracle exactly where the review calls it correct: at a
|
||
class that publishes it, the fill loop filled it out of the same `GLContext` the client built
|
||
`CapabilityBits` from, so the comparison is a tautology. The redundancy D9 exists to check is
|
||
between the **carried** bits and the **assembled** block.
|
||
|
||
The grain is per capability because a bind alone owns the pipeline half while the eight
|
||
`ClipDistance` answers come from `ClipDistanceEnabledMask` in dynamic chunk **D7**; case 6a pins
|
||
both directions. The source-chunk table is written from the same `MGP_PLAIN_CAPABILITY_LIST` and
|
||
the same boundary table `DeriveCapability` reads, so the two cannot drift.
|
||
|
||
On the `MGP_INPUT_CHECK` bypass: the poison gate answers "did the **filler** publish this field
|
||
for this verb". For this read that is the wrong question — the applier reads bytes it wrote
|
||
itself, at a verb the filler may legitimately not have published anything for — and the ledger is
|
||
a strictly stronger guard for it, because it is false in exactly the cases the poison would have
|
||
caught and in more besides. This is now stated in `PipeApply.h` next to the field, and recorded
|
||
as **D-9** below.
|
||
|
||
### MAJOR 2 — no caller, no test (fixed, `ce370a3e`)
|
||
|
||
All five unreached entry points plus `MGPipeDeriveRenderStateFields` are now driven, and both
|
||
wires are driven in three states each (disarmed / armed-and-agreeing / armed-and-diverging), in
|
||
**every** build:
|
||
|
||
| case | what it pins |
|
||
|---|---|
|
||
| `ResidualTripWireIsSilentUntilTheApplierOwnsTheBytes` | the `0x10` shape says nothing; a bind alone arms some but not all; a `ClipDistance` disagreement is silent until the dynamic half lands; the full 35 are compared after it |
|
||
| `ResidualTripWireHoldsAcrossAVerbClassThatDoesNotPublishTheBlock` | the review's own repro: draw → capability change → `kDispatch`. Red on the pre-fix wire (negative control A), green now |
|
||
| `ResidualTripWireFiresNamingTheCapability` | the wire fires: SIGABRT + `Fatal{PipeResidualDiverged, "Dither"}` under poison/verify, counted + logged under plain push |
|
||
| `PatchCarrierTripWireFiresOnlyWhenTheApplierOwnsChunkP0` | disarmed → silent; armed + agreeing **with a NaN outer level** → silent (a `==` compare would call that a divergence); armed + diverging → `Fatal{PipePatchCarriersDiffer}` / counted |
|
||
| `WholeBlockDerivationAgreesWithTheChunkScopedOne` | D-7's kept whole-block entry point, previously dead (minor 7) |
|
||
| `TheRemainingApplyEntryPointsReachPipeInputs` | `set_pixel_pack_state`, `set_vertex_attrib_defaults` and `delete_render_state`, each read back through the accessor a backend uses, under the verb class that publishes it |
|
||
|
||
Both wires now also **run in the shipped push build**, counting and logging where a poison or
|
||
verify build aborts (one `MGP_TRIP_WIRE_REPORT`/`MGP_TRIP_WIRE_TAG` pair; only the fatal arm
|
||
writes the `Fatal{…}` marker G4 greps for). A wire compiled out of every build a device runs is
|
||
not a wire, and the counters are what make the non-fatal arm assertable.
|
||
|
||
The diverging cases fork and read the wire's line back out of a log file, so the suite now has
|
||
its own `main()` and links `GTest::gtest` — `PipeInputsTest`'s shape and its stated reason
|
||
(*"Never `EXPECT_DEATH`"*). That is a `MG_Test/Pipe/CMakeLists.txt` edit; the file is A's
|
||
(§C.5), and the change is additive for the other three suites, which stay in the `foreach`.
|
||
|
||
### Minors
|
||
|
||
1. **`GetPixelStoreParameters` marked emitted (fixed, `d1a7c5f1`).** The row is removed from
|
||
`MGP_COVERAGE_EMITTED_LIST` and the reason is in `Coverage.def`'s prose (`kNone` in
|
||
`generated/PipeFilled.inc:355`). The accessor's row in `MGP_COVERAGE_ACCESSOR_LIST`
|
||
(`Coverage.def:66`) is a *plan* mapping and stays. Emitted count 34 → 33; `gen_pipe --check`
|
||
and `--self-test` green; no test pinned the count. **This is a change to a `c0` contract file
|
||
after the tag**, in the safe direction (a field goes back through B's fill loop rather than
|
||
being skipped) — package B is the only consumer of that table and it has not landed. Declared
|
||
again in §4 so the integrator tells B.
|
||
2. **`MOBILEGL_ASSERT` in the incremental create path (fixed, `bee07c32`).** Both arms start from
|
||
a defined base (`{}` or the base record) and report through the trip-wire verdict, so a dead
|
||
`BaseCso` can no longer leave a recycled slot's previous occupant under the delta chunks in an
|
||
INFO build. A brand-new CSO that does not name every chunk is reported the same way.
|
||
3. **`MOBILEGL_ASSERT` in `SetVertexAttribDefaults` (fixed, `bee07c32`).** The loop walks the
|
||
mask's 32 bits, consumes a tail entry for every named location (so a named-but-unstorable
|
||
attribute cannot desynchronise the rest), and reports all three faults in every build.
|
||
`PipeInputs::kMaxVertexAttribs` is `VertexArrayObject::MAX_VERTEX_ATTRIBS == 32` today, so the
|
||
out-of-range arm is unreachable; the guard is what keeps that true if the two stop agreeing.
|
||
4. **Process-global CSO store (not fixed — declared, D-8).** See §4.
|
||
5. **The patch wire's undeclared class contract (fixed, `bee07c32`).** Same ledger; the arming
|
||
condition is now "chunk P0 is the applier's", which covers the ordering contract and the
|
||
verb-class one at once, and it is written down at the wire.
|
||
6. **`SetterConsistency` never wrote chunk P3 (fixed, `ce370a3e`).** `SetStencilOp`,
|
||
`SetStencilFunc` and `SetStencilMask` are driven on **both** faces and `SetHint` on all four
|
||
targets.
|
||
7. **`MGPipeDeriveRenderStateFields` dead (fixed as far as this package can, `ce370a3e`).** It now
|
||
has a caller — `WholeBlockDerivationAgreesWithTheChunkScopedOne` — and no production caller,
|
||
which is correct: under split a scatter can arrive without a chunk mask. **D2's sentence "after
|
||
any scatter the applier calls `MGPipeDeriveRenderStateFields`" is still false of the landed
|
||
code** (the applier calls the chunk-scoped form) and remains for the integrator's doc pass,
|
||
alongside T-1 and T-2. Carried into §5.
|
||
8. **The chunk-table version was a promise, not a gate (fixed, `d1a7c5f1`).** The hash is now
|
||
seeded with `kMGPipeRenderStateChunkTableVersion ^ BoundaryChecksum()`, an FNV-1a fold of the
|
||
16 boundaries, so a moved boundary invalidates every persisted key whether or not anyone
|
||
bumps the version. Deliberately **not** a `static_assert` on the boundaries: that would turn
|
||
G7's negative control — which moves a boundary on purpose and must still compile (D19) — into
|
||
a build break instead of a red test. Re-verified: the G7 control still builds and still fails
|
||
exactly the two cases.
|
||
9. **The table was written against a stale checkout (fixed).** §2 above was produced at
|
||
`842af233` with all three build directories reporting 0 steps.
|
||
10. **Mode changes riding in a code commit (fixed, `842af233`).** The last `100755` file is now
|
||
`100644` in a mode-only commit. The three that rode inside `a9bb99a4` cannot be un-ridden
|
||
without rewriting a reviewed commit, which is not worth it; recorded here instead.
|
||
|
||
---
|
||
|
||
## 4. Deviations from the brief, with reasons
|
||
|
||
Carried forward from v2 (unchanged, re-stated so this file stands alone):
|
||
|
||
- **D-1** G1's `resized` set is three `RenderState` symbols plus `_GLOBAL__sub_I_DirectGLES.cpp`
|
||
(−9 bytes), not the one the G1 row names. All four are `c0`'s; contract-to-HEAD is `0/0/0/0`.
|
||
- **D-2** `MGPipeTypes.h`'s `MGPDynamicState` comment about sample coverage was corrected in `c0`
|
||
(D6 asks for it).
|
||
- **D-3** The 29 derivations are 25 `kDraw` + 3 `kClear` + 1 `kReadback`, checked under three
|
||
separate verb scopes, because the fill table is what says which verb may read which field.
|
||
- **D-4** `SlotAllocator.CompositeShaderBandIsNeverHandedOut` skips its exhaustion arm in a DEBUG
|
||
build only (`MOBILEGL_ASSERT` is live there and the band is asserted, not returned).
|
||
- **D-5** — **superseded this round.** v2 declared an *ordering* contract on both wires ("the
|
||
bind comes first within a validate"). The real contract is the applier's scatter ledger, which
|
||
subsumes it and the verb-class contract; see MAJOR 1 above and D-9 below.
|
||
- **D-6** The four P2 files were created `100755`; all four are now `100644`, the last of them in
|
||
its own commit.
|
||
- **D-7** `MGPipeDeriveRenderStateFields` (whole block) is kept beside the chunk-scoped form for
|
||
the split server. It now has a test caller and still no production caller.
|
||
|
||
New this round:
|
||
|
||
- **D-8 — the CSO store is process-global, not per context (review minor 4).** `BRIEF-P2.md:103`
|
||
says "per-context CSO store"; the tree has one `MGPipeApplierState g_applier`
|
||
(`PipeApply.cpp`). **Not changed, and the reason is that the thing it writes into is also one
|
||
process-global**: the working block *is* `gPipeInputs` (D2's own decision), a single block for
|
||
the process, and none of the seven apply signatures carries a context identity. A per-context
|
||
slot space over a per-process working block would be the inconsistent shape, not the current
|
||
one. `MGPipeApplierReset()` is the teardown hook and has no production caller yet — **the
|
||
tracker (package B) must call it when a context is destroyed**, or a second context inherits
|
||
the first's slot space and its `ScatteredChunkBits`. Flagged for B and for the integrator; the
|
||
header says so at `PipeApply.h`.
|
||
- **D-9 — the applier reads `m_renderState` through the friend accessor, bypassing
|
||
`MGP_INPUT_CHECK`, deliberately.** The poison gate answers "did the filler publish this field
|
||
for this verb"; the applier reads bytes *it* wrote, at a verb the filler may legitimately not
|
||
have published anything for. The guard that is right for this read is the scatter ledger, and
|
||
it is strictly stronger here: it is false in every case the poison would have caught and in the
|
||
cases the poison cannot see (the subsystem being off entirely). Related to, but not the same
|
||
as, the P1 `g_fbSlotCache` bypass D13 asks P2 to close — that one is a *cache* read of state
|
||
the filler owns.
|
||
- **D-10 — both trip wires now run in the shipped push build**, not only under poison/verify as
|
||
`BRIEF-P2.md` D6/D9 phrase it ("asserts under verify", "counted and logged otherwise"). D9
|
||
already asks for the counted-and-logged arm; this makes the patch wire behave the same way
|
||
instead of compiling out. Cost: a 24-byte `memcmp` on `set_patch_state` (emitted about once per
|
||
program) and a 35-iteration switch on `set_residual_value_state` (emitted once per context and
|
||
on capability-set changes). Neither is a hot path and neither is instrumentation.
|
||
- **D-11 — `MG_Test/Pipe/CMakeLists.txt` changes after the contract tag.** `RenderStateSpansTest`
|
||
moves out of the four-suite `foreach` and links `GTest::gtest` with its own `main()`. A's file
|
||
(§C.5); the other three suites are untouched.
|
||
- **D-12 — `Coverage.def`'s emitted list loses `GetPixelStoreParameters` after the contract
|
||
tag** (minor 1). The direction is safe for every other package; B is the only consumer and has
|
||
not landed.
|
||
|
||
---
|
||
|
||
## 5. Where the tree contradicted the brief
|
||
|
||
Carried from v2 and re-confirmed at HEAD:
|
||
|
||
- **T-1** `ScissorTestEnabledMask` is both a `DynamicTailKey` input and pipeline state; the file
|
||
wins, `DynamicChunksCoverMagmasDynamicTailKey` asserts the direction that makes a later
|
||
demotion loud. `ARCHITECTURE.md` §5.3 needs the sentence.
|
||
- **T-2** `StencilStates[0].Func` ends chunk **P2**, not P3; the brief's own P2 row was
|
||
internally inconsistent (20 bytes for four members measuring 16). The file wins.
|
||
- **T-3/T-4/T-6** as recorded in v2 (the 44-name `kMGPipePipelineStateMembers`, the nine fill
|
||
classes, the `MGPipeTypes.h` comment).
|
||
- **T-5 withdrawn** in v2: `BRIEF-P2.md`'s `grep -E '^\s+Test #'` in G2/G14 drops 999 of 2382
|
||
names because ctest wraps long lines. `~/w7/p2-before-ctest-names.txt` is exact and must be
|
||
kept; the brief's command needs `sed -n 's/^ *Test *#[0-9]*: //p'` (the shape §D.3 already
|
||
uses). Re-confirmed this round.
|
||
- **T-7 (new)** `BRIEF-P2.md` D2: *"After any scatter the applier calls
|
||
`MGPipeDeriveRenderStateFields(PipeInputs&)`"*. The landed applier calls
|
||
`MGPipeDeriveRenderStateFieldsForChunks` with the chunks the scatter moved; the whole-block
|
||
form is kept for the split server. The doc line needs correcting in the integrator's pass.
|
||
|
||
---
|
||
|
||
## 6. Unfinished
|
||
|
||
1. **`MGPipeApplierReset()` has no production caller.** Package B's tracker must call it at
|
||
context teardown (D-8). Until it does, the applier's slot space and its scatter ledger
|
||
outlive a context.
|
||
2. **The unpack half of `m_pixelStore` has no carrier** and now correctly claims none. Splitting
|
||
the field, or giving unpack its own call, is a later phase's; the decision the review asked
|
||
for is made (minor 1) and it is B-safe.
|
||
3. **`MGPipeDeriveRenderStateFields` still has no production caller** — correct for now, but the
|
||
integrator must correct D2's sentence (T-7).
|
||
4. **Nothing emits any of these calls yet.** The tracker (B) is what turns the applier into a
|
||
live path; everything above is driven by unit cases and by the retrace/integration lanes once
|
||
B lands.
|
||
5. Not run on this tree, by design: `-L integration-gpu` / `-L integration-verify`, the 40-trace
|
||
retrace under push and verify (G3/G4), the device pairs (G11), the microbenchmark and the
|
||
CSO-content-addressing control (G12), `scripts/g7_negative_control.sh` (package E's file — the
|
||
control was run by hand, §2).
|