mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-17 06:53: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.
404 lines
29 KiB
Markdown
404 lines
29 KiB
Markdown
# P3a package A, rework round 2 — the applier bodies (`wire-v2`)
|
|
|
|
Branch `p3a/wire`, worktree `/home/swung/w7/p3a-wire`, on top of `e9b4a263` (the three landed commits are untouched).
|
|
**Not pushed.** Three new commits, seven files, +2038 / -85 against the tag `39722687`.
|
|
|
|
| commit | message (single line, empty body, no attribution) |
|
|
|---|---|
|
|
| `cdc42379f6...` (`cdc42379`) | `[Fix] (Pipe): account for DispatchIndirect and Query in Coverage.def's target-by-target split, re-sort the new emitted row, and name the P3a default mask in ConfigLoader's include comment` |
|
|
| `761faca1...` (`761faca1`) | `[Fix] (Pipe): give both blob-carrying record families one Blob rule, and name the wire views the vertex-elements blob actually carries` |
|
|
| `48fe55be...` (`48fe55be`) | `[Fix, Test] (Pipe): a make-current is not a teardown - the applier keeps its object records across one, counts every call refused on a record it does not have, advances the two vertex-input serials instead of restarting them at 0, and bounds the slot it grows a record table on` |
|
|
|
|
```
|
|
MobileGL/ConfigLoader.cpp | 5 +-
|
|
MobileGL/MG_Pipe/Coverage.def | 33 +-
|
|
MobileGL/MG_Pipe/MGPipeTypes.h | 32 +- (comments only)
|
|
MobileGL/MG_Pipe/PipeApply.cpp | 683 ++++++-
|
|
MobileGL/MG_Pipe/PipeApply.h | 104 ++-
|
|
MobileGL/MG_Test/Pipe/ResourceEmitTest.cpp | 1232 +++++++++++-
|
|
MobileGL/MG_Test/Pipe/VertexInputEmitTest.cpp | 34 +-
|
|
```
|
|
|
|
**The granted `Tracker.h` waiver was not needed and not used.** The fix lives entirely inside A's files: the call
|
|
site at `MG_Impl/Pipe/Tracker.h:192-195` and `MG_Impl/Pipe/PipeFill.cpp:1188-1193` are byte-identical to `e9b4a263`,
|
|
`git diff 39722687..HEAD --stat` names no file of B's, and B's rebase sees no edit in `Tracker.h` or `PipeFill.cpp`.
|
|
One thing B *does* have to know is in §6.
|
|
|
|
---
|
|
|
|
## 1. Per-finding disposition
|
|
|
|
| finding | disposition | where |
|
|
|---|---|---|
|
|
| **C1** reset scope + invisible refusal | **fixed** — the records are out of the reset; the refusal is counted, named and driven | `PipeApply.h:202-229`, `:266-300`; `PipeApply.cpp:439-490`, `:597-660` |
|
|
| **C2** serials sent backwards | **fixed** — `++` at every reset, never 0 | `PipeApply.cpp:628-646`, `:649-660`; `VertexInputEmitTest.cpp:67-110` |
|
|
| **M-A** / contract `M1` `Coverage.def` split | **fixed** — all 15 `BufferTarget` enumerators, in the enum's own spelling | `Coverage.def:40-58` |
|
|
| **M-B** `c2`'s zero coverage | **fixed** — 9 new cases; all 8 review mutations measured red (§4) | `ResourceEmitTest.cpp:788-1330` |
|
|
| **M-C** `Fatal{PipeLiveHostWrites}` control + `map_persistent` | **fixed** — pinned on `map_persistent` and `resource_readback`, with a negative control and a positive one | `PipeApply.cpp:1049`, `:1110`; `ResourceEmitTest.cpp:1218-1281` |
|
|
| **M-D** unbounded `RecordAt` | **fixed** — two named bounds, `Fatal{ProtocolCorruption}`, never a resize | `PipeApply.h:112-113`; `PipeApply.cpp:416-421`, `:906-914`, `:1200-1210` |
|
|
| **M-E** the two `Blob` rules | **fixed** — ONE rule, stated on both records and enforced on both | `MGPipeTypes.h:254-265`, `:624-632`; `PipeApply.cpp:516-525`, `:1171-1188` |
|
|
| **m1** emitted-row order | **fixed** | `Coverage.def:202` |
|
|
| **m2** `Blob` comment names frontend types | **fixed** | `MGPipeTypes.h:270-275` |
|
|
| **m3** stale default-mask comment (A's half) | **fixed** | `ConfigLoader.cpp:11-13` |
|
|
| **m4** `static_assert` form | **NOT A's** — see §1.9 | `MG_Impl/Pipe/PipeFill.cpp:687-701` |
|
|
| **n1** bare `return` at `delete_vertex_elements` | fixed in passing (routed through the resolver) | `PipeApply.cpp:1266-1273` |
|
|
| **n2, n3, n4, n5, n8, n9, n10** | recorded, not taken (ID-4 declared minors) | §7 |
|
|
| **n6, n7** | carried into §6 for B, as the review asks | §6 |
|
|
|
|
### 1.1 C1 — the records are per-object, not per-draw, and the refusal is now an observable
|
|
|
|
**The rule that landed** (`PipeApply.h:200-229`, and the two functions' own comments):
|
|
|
|
* `MGPipeApplierReset()` — which runs at **every change of the current `GLContext`**, not once per fresh one — clears
|
|
the render-state CSOs, the residual mirror and the vertex-input **working state**, and advances the two global
|
|
serials. It does **not** touch `Resources` or `VertexElementsCsos`.
|
|
* `MGPipeApplierReleaseObjectRecords()` (new, `PipeApply.h:279-300`, `PipeApply.cpp:649-660`) clears them. It is the
|
|
**served context's teardown**: under split there is one applier per served context and this is what goes with it.
|
|
* Between the two, a record is cleared by its object's own death signal — `resource_destroy`,
|
|
`delete_vertex_elements` — which is what D-L already makes the buffer's death crossing.
|
|
|
|
**In the monolith `MGPipeApplierReleaseObjectRecords()` is deliberately wired to nothing**, and that is written into
|
|
the header. There is one `g_applier` behind every context (`PipeApply.h:286` has always said so), so calling it on
|
|
one context's destruction would drop every *other* context's records — C1 in its other direction. The only callers
|
|
are the unit fixtures, which is the one place that legitimately means "this applier is going away". The records that
|
|
would otherwise accumulate are bounded by the client's dense slot high-water mark and are dropped one at a time by
|
|
the death notices, so nothing leaks.
|
|
|
|
**The observable.** Both refusal paths now go through `ResolveResource` / `ResolveVertexElements`
|
|
(`PipeApply.cpp:472-490`), which assert *and* count into `MGPipeApplierState::RefusedResourceCalls` /
|
|
`RefusedVertexInputCalls` (`PipeApply.h:220-229`). One place resolves, asserts and counts, so a call that forgets one
|
|
of the three cannot exist. `ResourceEmit.ACallOnARecordTheApplierDoesNotHaveIsCountedRatherThanSilentlyDropped`
|
|
(`ResourceEmitTest.cpp:859`) pins that a legal sequence leaves both at 0 and walks all nine resource entry points and
|
|
both vertex-input ones to 9 and 2. Removing either increment is red (§4, M12/M13).
|
|
|
|
**Why it stays a defined no-op rather than becoming a `Fatal`, and the exact sequence that requires it.** The review
|
|
allowed a no-op only if a legal sequence genuinely needs one. It does — one, and it is written at
|
|
`PipeApply.cpp:439-470`:
|
|
|
|
```
|
|
the served context is torn down
|
|
-> MGPipeApplierReleaseObjectRecords() (the applier goes away with the context)
|
|
-> ~BufferObject / ~VertexArrayObject for every object the context still owns
|
|
-> resource_destroy / delete_vertex_elements, each naming a record the line above dropped
|
|
```
|
|
|
|
Those death notices are legal, unavoidable and unordered with respect to the release, so a wire here would abort a
|
|
verify lane on the ordinary shutdown of a context. The counter is what makes the *other* case — an unknown slot, a
|
|
stale generation, a genuinely dropped `glBufferSubData` — visible in all three gate builds, where `MOBILEGL_ASSERT`
|
|
is inert.
|
|
|
|
**§3 A2's frequency is corrected** (C1c): it read "at the first validate of a fresh context"; the truth is "at every
|
|
change of the current context", and that is now what the code comments say (`PipeApply.cpp:604-608`,
|
|
`PipeApply.h:279-292`).
|
|
|
|
### 1.2 C2 — the two global serials advance
|
|
|
|
`PipeApply.cpp:628-646` replaces `= 0` with `++`, with the three-row argument (carry over / restart / advance) in
|
|
place, and `MGPipeApplierReleaseObjectRecords` does the same (`:658-659`) for the same reason. `PipeApply.h:251-264`
|
|
carries the rule beside the members. `VertexInputEmitTest.cpp:67-110`'s comment is rewritten and `:104-110` now pins
|
|
"moved forward" (`43`/`44` from `42`/`43`, plus the two strict inequalities); **the case's name is unchanged**, which
|
|
is all G14 protects. `ResourceEmit.TheObjectRecordsSurvive…` (`:816-820`) pins the same property with real state
|
|
behind it. Restoring `= 0` is red in both suites (§4, M15).
|
|
|
|
### 1.3 M-A — `Coverage.def`'s split is exhaustive
|
|
|
|
`Coverage.def:40-58` now lists all **15** `BufferTarget` enumerators in `BufferObject.h:15-33`'s own spelling
|
|
(`Vertex`, `Index`, `DrawIndirect`, `Parameter`, …), so the list cross-checks mechanically. `DispatchIndirect` gets
|
|
its own bucket with the reason the review asked for — both backends read it at every `glDispatchComputeIndirect` and
|
|
**no call carries it**, `MGPIndirectBuffers` being the `DrawIndirect` + `Parameter` pair only — plus the sentence
|
|
that a later phase must not read the split as covering it. `Query` gets a one-line bucket. `:63` now says "seven
|
|
targets above are still pulled" rather than five. Comment-only: `gen_pipe.py --check` is clean and
|
|
`git diff -- MobileGL/MG_Pipe/generated` is empty.
|
|
|
|
### 1.4 M-B — the `c2` coverage, in `ResourceEmitTest.cpp`
|
|
|
|
Nine new cases (`ResourceEmitTest.cpp:788-1330`), deliberately **not** in `VertexInputEmitTest.cpp`, whose contents
|
|
`C.5` gives to B and which B is appending to now. The file header block at `:646-660` says so in those words.
|
|
|
|
| case | what it holds | line |
|
|
|---|---|---|
|
|
| `TheObjectRecordsSurviveAMakeCurrentAndOnlyTheWorkingStateIsReset` | C1's two scopes with live records behind them; the write after the switch lands | `:788` |
|
|
| `ACallOnARecordTheApplierDoesNotHaveIsCountedRatherThanSilentlyDropped` | C1's observable, all eleven refusing entry points | `:859` |
|
|
| `AVertexElementsBlobRoundTripsAndAShrinkLeavesNothingOfTheOneBeforeIt` | the blob unpack over all 32+32 slots, field by field; the shrink; `ContentSerial` re-create vs recycled slot; no rebind | `:930` |
|
|
| `AVertexElementsRecordThatDoesNotDescribeItsOwnBlobIsRefusedNamingIt` | the counts/`Blob.Size` gate in both build arms, plus the "0 is not a fault" half of the Blob rule | `:984` |
|
|
| `TheVertexBufferWindowIsBoundedAndItsEntriesLandWhereItSays` | entries land in the window and nowhere else; the raw `BaseInstance`; `Start + Count` at 32 and 33; the null-tail arm | `:1033` |
|
|
| `SetIndexBufferMovesOnlyItsOwnSerialAndTheBindingFollowsTheHandle` | D5 independence; null index buffer; bind null / bind dead / delete-clears-the-binding | `:1111` |
|
|
| `EveryContentCallsOwnBoundsGateRefusesAndNamesTheResource` | flush range, readback range, `Level`, and the new `MGPSubData::Blob` rule, each with a positive control | `:1166` |
|
|
| `TheLiveHostWritesWireFiresOnTheCallAPersistentMapProducerWouldSetItOn` | M-C's negative control (§1.5) | `:1218` |
|
|
| `ASlotOutsideTheRecordTablesBoundIsRefusedRatherThanAllocated` | M-D | `:1283` |
|
|
|
|
Every refusal case uses `ExpectRefusedNaming` (`:912-929`), which takes the file's two existing arms — forked child +
|
|
`SIGABRT` + `Fatal{…}` in poison/verify, in-process log read + "nothing moved" in a shipped push build — and picks
|
|
the right tag for the arm, so one needle serves both. Comparisons are **by field name**
|
|
(`ExpectAttribEq` / `ExpectBindingEq` / `ExpectVertexBufferEq`, `:697-726`), which is what G7's negative control needs
|
|
of this family.
|
|
|
|
### 1.5 M-C — the wire has a control, and it sits on the call P5 attaches its producer to
|
|
|
|
`PinNoLiveHostWrites` is now called from `MGPipeApplyMapPersistent` (`PipeApply.cpp:1110`, with the reason in place —
|
|
D-A4 and `ARCHITECTURE.md:481` name the persistent-map push as exactly where the flag gets set) and from
|
|
`MGPipeApplyResourceReadback` (`:1049`, which reads the store the flag describes), beside the three it already had.
|
|
|
|
`ResourceEmit.TheLiveHostWritesWireFiresOnTheCallAPersistentMapProducerWouldSetItOn` (`ResourceEmitTest.cpp:1218`)
|
|
sets `MGPipeApplier().Resources[slot].HasLiveHostWrites = true` **inside a forked child** — so the parent's applier
|
|
stays honest for the next drive — and asserts `SIGABRT` plus `Fatal{PipeLiveHostWrites} <call> {slot=8, gen=4}` for
|
|
all five calls. Its negative control is the same `map_persistent` with the flag clear: it answers normally and logs
|
|
nothing. In a shipped push build the wire is compiled out entirely, so the case is a **visible skip** there rather
|
|
than a vacuous pass (`ctest -N` names stay identical: 2504 in both the pull and push trees).
|
|
|
|
### 1.6 M-D — the slot is bounded before it reaches an allocator
|
|
|
|
`PipeApply.h:97-113` mints `kMGPipeMaxResourceSlots = 1u << 20` and `kMGPipeMaxVertexElementsSlots = 1u << 16` with
|
|
the reason for two numbers rather than one (a resource record is descriptor-sized; a vertex-elements record carries
|
|
both unpacked views at ~1.3 KB, so one bound would mean two very different worst cases). `RecordAt`
|
|
(`PipeApply.cpp:400-421`) takes the bound and returns `nullptr`; both call sites report
|
|
`Fatal{ProtocolCorruption}` with the identity and the bound in the line (`:906-914`, `:1200-1210`) and return. The
|
|
tables still grow only to the client's own dense high-water mark, so the bound costs nothing until a record is
|
|
already corrupt. The case drives the bound exactly (`slot == kMGPipeMaxResourceSlots` and `0xFFFFFFFE` refused, the
|
|
table not grown); the last slot *below* the bound is deliberately not driven, because naming it is a ~90 MB
|
|
allocation and the direction that matters is the one that reaches the allocator.
|
|
|
|
### 1.7 M-E — one Blob rule, stated on both records and enforced on both
|
|
|
|
> `Blob.Size` is the record's own statement of how many bytes its blob holds, and the applier holds the record to
|
|
> that statement **whenever the record makes it**: a non-zero `Blob.Size` that disagrees with the byte length the
|
|
> record's other fields describe is `Fatal{ProtocolCorruption}` and the call is refused. A **zero** `Blob.Size` means
|
|
> "this record does not declare its blob" — which is what a monolith emission is, because the bytes travel beside the
|
|
> record through the entry point's companion `const void*` — and it is not a fault. Either way the bytes read are
|
|
> bounded by the record's **other** fields (the two counts here, the destination range there), so the declared length
|
|
> is a cross-check and never the safety property.
|
|
|
|
Written verbatim on `MGPVertexElements` (`MGPipeTypes.h:254-265`) and on `MGPSubData` (`:624-632`), and enforced on
|
|
both: `SubDataBoxFault` gains the check (`PipeApply.cpp:516-525`) and `create_vertex_elements`'s gate relaxes from
|
|
`!= declared` to `!= 0 && != declared` (`:1187`). Both directions are driven (§4, M5/M9).
|
|
|
|
**This changes what §5 item 2 told B**: B is no longer *required* to compute
|
|
`A*sizeof(MGPVertexAttribWire) + B*sizeof(MGPVertexBindingPointWire)` by hand at the emitter — leaving
|
|
`MGPVertexElements::Blob` entirely zero is now legal and inert. If B does fill it, it must be exact. The asymmetry
|
|
the review objected to is gone in the direction that removes a verify-build abort from a legal emission rather than
|
|
adding one, and the safety argument is unchanged because the counts (not the length) are what bound the unpack.
|
|
|
|
### 1.8 m1, m2, m3
|
|
|
|
`m1`: `Coverage.def:202` — `X(GetBoundVertexArray, BindVertexElements)` moved from position 2 to position 4, the
|
|
`LC_ALL=C` place after `GetBlendFuncIndexed`. Regenerating leaves `MobileGL/MG_Pipe/generated` byte-identical
|
|
(`gen_pipe.py` sorts the emitter enum itself), so this is presentation only, which is what `m1` said.
|
|
|
|
`m2`: `MGPipeTypes.h:270-275` — the comment now names `MGPVertexAttribWire[AttributeCount]` followed by
|
|
`MGPVertexBindingPointWire[BindingPointCount]`, says why the frontend types cannot travel, and points at the one
|
|
place the layout is stated (`MGPipeValueTypes.h`'s P3a block).
|
|
|
|
`m3`: `ConfigLoader.cpp:11-13` — "For `kMGPipeSubsystemsMigratedAtP3a`, the push build's `PipePush` default (the P2
|
|
constant beside it is the phase-by-phase control, not the default)".
|
|
|
|
### 1.9 m4 is **not** in an A file, and neither is m3's other half
|
|
|
|
The review's M-F table calls all four minors "A-owned". For `m4` that is wrong against `C.5`:
|
|
`MG_Impl/Pipe/PipeFill.{h,cpp}` — the `SubsystemForEmitter` / `static_assert` / `kMGPipeWiredSubsystems` block — is
|
|
**"owner (contract commit only)" for A and "owner (after the tag)" for B**. The tag is cut, so the three pairing
|
|
asserts at `PipeFill.cpp:687-701` are B's to make uniform. The one-line fix is to give the `NewVertexBuffers`
|
|
(`:694-697`) and `NewIndexBuffer` (`:698-701`) arms the same right-hand side the `NewVertexElements` arm has,
|
|
`SubsystemForEmitter(MGPipeFieldEmitter::BindVertexElements)`, rather than the literal `kMGPipeSubsystemVertexInput`.
|
|
|
|
`m3`'s `MG_Backend/DirectVulkan/Renderer/MagmaPipeArms.h:112-115` half is the integrator's, as the review says: no
|
|
package owns `MG_Backend/DirectVulkan/**` in `C.5`.
|
|
|
|
---
|
|
|
|
## 2. What the applier's contract now is, in one place (for B and C)
|
|
|
|
1. **Records are object state.** They survive a make-current. They are cleared by `resource_destroy` /
|
|
`delete_vertex_elements` and by `MGPipeApplierReleaseObjectRecords()`. Nothing else clears them.
|
|
2. **`MGPipeApplierReleaseObjectRecords()` must not be wired in the monolith.** One applier serves every context.
|
|
3. **The two global serials only ever advance.** `VertexBuffersSerial` and `IndexBufferSerial` are `++`-ed by their
|
|
own calls, by `MGPipeApplierReset()` and by `MGPipeApplierReleaseObjectRecords()`, and are never assigned. A twin
|
|
may safely memo either one; no value can recur. (`Serial` and `ContentSerial` are per record and restart with the
|
|
record, which is safe because the handle's `Gen` moves with it — unchanged from `wire-v1`.)
|
|
4. **A refused call is counted**, in `RefusedResourceCalls` / `RefusedVertexInputCalls`, per context. A non-zero
|
|
count in a lane is a dropped call, and a legal sequence leaves it at 0 except during a context teardown.
|
|
5. **`handle.Slot` is bounded** by `kMGPipeMaxResourceSlots` / `kMGPipeMaxVertexElementsSlots` (`PipeApply.h:112`),
|
|
which C should reuse when it bounds `handle.Slot` before `BackendSlotTable::EntryAt` (contract-review M2).
|
|
6. **The Blob rule** (§1.7) — one rule, both families, `0` means "not declared".
|
|
|
|
---
|
|
|
|
## 3. Deviations declared in this round
|
|
|
|
**R1 — `MGPipeApplierReleaseObjectRecords()` has no production caller.** It is the split-side teardown hook and the
|
|
unit fixtures' "empty the applier". Wiring it in the monolith would be wrong (§1.1) and wiring it under split is P5's
|
|
server bring-up, not P3a's. It is `push`-only source, so G1 is unaffected; the two fixtures and one case drive it.
|
|
|
|
**R2 — the review's C1a asked for an `INTEGRATOR-DECISIONS.md` entry.** `docs`/notes ownership is the integrator's
|
|
(ID-5, and `C.5` gives `docs/Disaggregated/*.md` to nobody but the integrator), so the decision is written here and
|
|
into the two functions' own comments instead. The integrator owes ID-9 the two sentences in §2 items 1-2.
|
|
|
|
**R3 — the vertex-elements `Blob.Size` gate was RELAXED, not tightened.** §1.7. It is the one place this round
|
|
changes a rule rather than adding one, and it changes it in the direction that cannot abort a legal emission.
|
|
|
|
**R4 — `VertexInputEmitTest.cpp` was edited even though B is appending to it.** The edit is confined to `c0`'s
|
|
placeholder case (`:67-110`) and is not optional: at `e9b4a263` that case asserts `VertexBuffersSerial == 0` after a
|
|
reset, which is exactly the inversion C2 removes, so leaving it would leave the tree red. No case was added there.
|
|
See §6 for the rebase note.
|
|
|
|
**R5 — the shared G1 baseline has drifted and G1 was run as a parent-vs-HEAD control instead.** §5.
|
|
|
|
---
|
|
|
|
## 4. Mutation evidence — 17 mutations, 17 reds, measured
|
|
|
|
Each mutation was applied to `MobileGL/MG_Pipe/PipeApply.cpp` in this worktree, the two test targets rebuilt, the two
|
|
suites run, and the file restored with `git checkout --` (the tree was verified clean before and after every batch;
|
|
no other worktree was created). The eight the review measured green at `e9b4a263` are M1-M8.
|
|
|
|
| # | mutation | verdict | first case to go red |
|
|
|---|---|---|---|
|
|
| M1 | `create_vertex_elements`: the attribute `memcpy` removed | **RED** | `AVertexElementsBlobRoundTripsAndAShrink…` |
|
|
| M2 | `create_vertex_elements`: the binding-point `memcpy` removed | **RED** | `AVertexElementsBlobRoundTripsAndAShrink…` |
|
|
| M3 | `set_vertex_buffers`: the entry-copy loop body removed | **RED** | `TheVertexBufferWindowIsBounded…` |
|
|
| M4 | `set_vertex_buffers`: the `Start + Count` window gate disabled | **RED** | `TheVertexBufferWindowIsBounded…` |
|
|
| M5 | `create_vertex_elements`: the counts/`Blob.Size` gate disabled | **RED** | `AVertexElementsRecordThatDoesNotDescribeItsOwnBlob…` |
|
|
| M6 | `resource_flush_range`: `BufferRangeFault` removed | **RED** | `EveryContentCallsOwnBoundsGate…` |
|
|
| M7 | `resource_readback`: `BufferRangeFault` removed | **RED** | `EveryContentCallsOwnBoundsGate…` |
|
|
| M8 | `SubDataBoxFault`: the `Level` arm removed | **RED** | `EveryContentCallsOwnBoundsGate…` |
|
|
| M9 | `SubDataBoxFault`: the new `MGPSubData` Blob rule removed | **RED** | `EveryContentCallsOwnBoundsGate…` |
|
|
| M10 | `resource_create`: the slot bound widened by one | **RED** | `ASlotOutsideTheRecordTablesBound…` |
|
|
| M11 | `create_vertex_elements`: the slot bound widened by one | **RED** | `ASlotOutsideTheRecordTablesBound…` |
|
|
| M12 | the resource refusal counter removed | **RED** | `ACallOnARecordTheApplierDoesNotHave…` |
|
|
| M13 | the vertex-input refusal counter removed | **RED** | `ACallOnARecord…` + `SetIndexBufferMovesOnlyItsOwnSerial…` |
|
|
| M14 | **C1 reverted**: `MGPipeApplierReset` clears the records again | **RED** | `TheObjectRecordsSurviveAMakeCurrent…` |
|
|
| M15 | **C2 reverted**: the two serials zeroed at a reset | **RED** | `TheObjectRecordsSurvive…` + `VertexInputEmit.AResetApplierCarriesNoVertexInputStateOver` |
|
|
| M16 | `map_persistent`: the `PipeLiveHostWrites` pin removed | **RED** (verify tree) | `TheLiveHostWritesWireFires…` |
|
|
| M17 | `resource_readback`: the `PipeLiveHostWrites` pin removed | **RED** (verify tree) | `TheLiveHostWritesWireFires…` |
|
|
|
|
M1-M15 were run in `build-push`, M16-M17 in `build-verify` (the wire is compiled out of a shipped push build, and its
|
|
case skips visibly there). No mutation survived.
|
|
|
|
---
|
|
|
|
## 5. Verification transcript
|
|
|
|
All in `/home/swung/w7/p3a-wire` at `48fe55be`, `CCACHE_BASEDIR=/home/swung/w7`.
|
|
|
|
**G1 — and a baseline problem the integrator has to settle.** `~/w7/p3a-before-libMobileGL.so` and
|
|
`~/w7/p3a-before-ctest-names.txt` were **re-captured at 03:17 today at `5cb826b0`** ("`[Merge] (dev): bring
|
|
dev@9eae9858 into feat/disaggregated - the adopted-store respecify VAO rebind fix (d7655247) and the
|
|
persistent-buffer ordering POST probe`"), which is **not an ancestor of `p3a/wire`** (`~/w7/p3a-before-head.txt`
|
|
records it). Run against it, `symbol_report` now reports `27811 -> 27799, 0 added, 12 removed, 1 resized` — every
|
|
removed symbol is `MG_Util::SelfTest::…PersistentBufferUpdateOrdering…`, i.e. dev code this branch does not have —
|
|
and the name comparison shows 15 removals, all `PersistentBufferOrderingProbeTest.*` and
|
|
`*.LargeArenaAdoptionScenario.Respecified*`. None of it is P3a's. `wire-v1` ran the same command against the
|
|
*previous* baseline and got `27799 -> 27799`.
|
|
|
|
So G1 was run as the control that actually answers the question — **the pull library at `e9b4a263` versus the pull
|
|
library at `48fe55be`**, both built in this worktree:
|
|
|
|
```
|
|
python3 scripts/symbol_report.py --before <pull lib at e9b4a263> --after build-linux/libMobileGL.so \
|
|
--threshold 0 --fail-on-symbol-set-change --fail-on-added-bytes 0 rc 0
|
|
symbol-report: .text 10792739 -> 10792739 (+0, +0.000%) .data +0 .bss +0 .rodata +0
|
|
symbol-report: Total 17209979 -> 17209979 (+0)
|
|
symbol-report: 27799 -> 27799 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
|
|
symbol-report: 27060 -> 27060 normalised names, 27060 unchanged
|
|
```
|
|
|
|
The two libraries are the same size to the byte. P3a's admitted-resize set stays empty. **Action for the
|
|
integrator:** either re-capture `~/w7/p3a-before-*` at `44c2b5cf` (ID-1's stated base) or rebase every P3a package
|
|
onto `5cb826b0` and re-capture there; until then the shared baseline answers a different question than G1 asks.
|
|
|
|
**Generators and closure**
|
|
|
|
```
|
|
python3 scripts/gen_pipe.py --check rc 0 "gen_pipe: generated files are up to date"
|
|
python3 scripts/gen_pipe.py --self-test rc 0 "7 negative-control trip(s), positive control OK"
|
|
git diff --exit-code -- MobileGL/MG_Pipe/generated rc 0
|
|
python3 scripts/check_include_closure.py rc 0 "4 probes, 0 skipped, 0 problem(s)"
|
|
python3 scripts/check_include_closure.py --mode both --compiler clang++ --self-test --require-all rc 0
|
|
```
|
|
|
|
**Three builds** (`cmake --build <dir> -j 24`): `build-linux` rc **0**, `build-push` rc **0**, `build-verify` rc **0**.
|
|
|
|
**Three unit runs** (`ctest --test-dir <dir> -L unit -j 12 --no-tests=error`):
|
|
|
|
```
|
|
build-linux rc=0 100% tests passed, 0 failed out of 1588 (9.16 s)
|
|
build-push rc=0 100% tests passed, 0 failed out of 1588 (9.20 s)
|
|
build-verify rc=0 100% tests passed, 0 failed out of 1588 (9.28 s)
|
|
```
|
|
|
|
(1579 at `e9b4a263` + 9 new names.)
|
|
|
|
**The two P3a suites** (`ctest -R 'ResourceEmit\.|VertexInputEmit\.'`):
|
|
|
|
```
|
|
build-push 19 tests, 100% passed, 1 visible skip (the PipeLiveHostWrites wire is compiled out here)
|
|
build-verify 19 tests, 100% passed, 0 skips (every forked-abort arm taken)
|
|
build-linux 19 tests, 18 visible skips + the range-encoding case
|
|
```
|
|
|
|
**Names (G2's name half, G14)**
|
|
|
|
```
|
|
ctest -N: build-linux 2504, build-push 2504, build-verify 3332
|
|
diff <linux names> <push names> -> empty (rc 0)
|
|
comm -23 <names at e9b4a263> <names at HEAD> -> empty (nothing removed)
|
|
comm -13 ... -> 9 added, all ResourceEmit.*
|
|
```
|
|
|
|
**G13**: `grep -c 'MG_State' MG_Pipe/PipeApply.h` → **0**; `grep -rc 'pGLContext' MG_Backend | grep -v ':0$'` →
|
|
empty.
|
|
|
|
**Ownership**: `git diff --stat 39722687..HEAD` names exactly `MG_Pipe/{PipeApply.h, PipeApply.cpp, MGPipeTypes.h,
|
|
Coverage.def}`, `ConfigLoader.cpp` and the two `MG_Test/Pipe/*EmitTest.cpp` — all A's under `C.5`. No `MG_Impl`, no
|
|
`MG_Backend`. Working tree clean; nothing pushed; no other worktree created.
|
|
|
|
**Not run here, and why**: G2's execution half, G3/G3b/G4's retrace, G5 (the script is D's and is not in the tree;
|
|
this package touches no `Managers.cpp` region, so the nine functions are byte-identical by construction), G6-G12,
|
|
G15. This package still registers no `MGPipeResourceOps` and emits no call, so it changes no observable and those
|
|
gates belong to the integrator's D.1 merges. Behaviour neutrality is unchanged from `wire-v1`: `grep` over
|
|
`MobileGL/` for the fourteen entry points and for `MGPipeSetResourceOps` still returns hits only in
|
|
`MG_Test/Pipe/ResourceEmitTest.cpp`.
|
|
|
|
---
|
|
|
|
## 6. What is left, and for whom
|
|
|
|
1. **The rebase note for B** (R4). `MG_Test/Pipe/VertexInputEmitTest.cpp:67-110` changed: the placeholder case's
|
|
comment is rewritten and its two serial assertions now read "moved forward" (43/44) instead of 0/0, and the two
|
|
vacuous `…CsoCsos.empty()` / `Resources.empty()` assertions were removed because the records are no longer part of
|
|
that scope. The case's **name** is unchanged. B's `b4` is still an append below `:110`; if it collides it is a
|
|
union, never a choice.
|
|
2. **`MGPipeApplierReset` no longer empties the applier** — a fixture that wants an empty one must also call
|
|
`MGPipeApplierReleaseObjectRecords()`, as `ResourceEmitTest.cpp:139-150`'s `ApplierGuard` now does. Any B or C
|
|
test that resets the applier and then asserts `Resources.empty()` needs the second call.
|
|
3. **`MGPVertexElements::Blob.Size` may now be left 0** (§1.7), which supersedes `wire-v1` §5 item 2. If B fills it,
|
|
it must be exact. The same rule now applies to `MGPSubData::Blob`, which B must leave 0 or fill exactly.
|
|
4. **`resource_subdata` still requires a `Width`** — unchanged from `wire-v1` §5 item 3.
|
|
5. **`VertexFetchBaseInstance` is raw** — unchanged, for C.
|
|
6. **The serial contract for C**, complete: §2 items 3-5 above.
|
|
7. **n7 (cross-package, from the review):** B's resident dispatch must gate on
|
|
`MGPipeGetResourceOps()->SubDataResident != nullptr`, not on `MGPipeResourceSubsystemEnabled()` alone — the
|
|
applier drops a resident write when the member is null, after bumping `Serial`, and
|
|
`BufferObject::LandBytesIntoResidentStore` is unreachable once the call has been emitted. Unreachable in P3a
|
|
(Espryt registers all nine members; Magma registers no table), but it is B's dispatch shape.
|
|
8. **n6 (cross-package, from the review):** `MGPipeApplierState::MapPersistentRoundtrips` is **per context** (reset
|
|
by `MGPipeApplierReset`, pinned at `ResourceEmitTest.cpp:585-587`) while `PipeStats`' `mpr` is not. D's
|
|
`StorageBufferRegrowScenario` should assert against **`PipeStats`' `mpr`**, which is the one an operator greps and
|
|
the one that survives a context switch.
|
|
9. **Doc corrections owed to the integrator**, unchanged from `wire-v1` §5 item 8, plus: D-G4's reset prose should
|
|
say the records are share-group state (§2 items 1-2), and the review's M-F table should record that `m4` is B's
|
|
file after the tag (§1.9).
|
|
10. **The baseline drift** (§5) — integrator.
|
|
|
|
## 7. Declared minors not taken (ID-4)
|
|
|
|
`n2` (`unmap_persistent` refuses on a dropped record) — left as is; delivering a release to a backend that has no
|
|
record for it is the worse answer, and the refusal is now counted. `n3` (`SubDataBoxFault` holds three of seven
|
|
statements) — the other four are inert for a buffer and the helper's comment no longer claims completeness beyond
|
|
what it checks. `n4` (`IndexSize` unpoliced), `n5` (`BindingIndex` unpoliced) — both stated as deliberate at
|
|
`PipeApply.cpp:1331-1345` and `:1305-1311`; policing either would hand B a contract this package cannot justify.
|
|
`n8` (the by-handle assertion is half made), `n9` (`ARespecifyReplaces…` re-pins the ack predicate) — recorded.
|
|
`n10` (`PipeApply.h` edited after the tag) — this round edits it again, comment and members both; C's tree branches
|
|
from the tag and will see all of it on its rebase, and the integrator still owes C that message.
|
|
|
|
*Intermediate logs and the mutation harness under `~/w7/p3a-wire-mut/` were deleted at the end of the round.*
|