mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-18 07:23:24 +09:00
Two things land together: the plan and contract draft P6 needs before it starts, and the
working notes that until now existed on exactly one machine.
1. P6's plan and contract draft (neither started; not one line of code)
docs/Disaggregated/P6-SPAWN-PLAN.md the package plan
docs/Disaggregated/P6-CONTRACT-DRAFT.md the contract draft (moves to
MG_Remote/CONTRACT-P6.md when c6 lands)
The three findings that mattered, all written into the documents:
a. P6 is SMALLER than its roadmap cell suggests. The transport primitives are already in
the tree and already tested: SocketDoorbell including hangup detection and the two
lost-wakeup fences (Doorbell.cpp:211-360, four cases in FdPassingTest), SCM_RIGHTS fd
passing, ShmSegment::Adopt, and the SurfaceOp / WindowKind schema already defined in
protocol.fbs. inproc uses a real second shm mapping rather than an alias, and
SessionRings.h:22-28 says that was done so today is not the first time it runs. P6 is
assembly plus a control plane plus a process, not "write a socket transport".
b. The evidence for "P6 is only a transport swap" has EXPIRED. It was bought by P5c, whose
audit found 59 direct memory accesses in a tree that already looked clean. P5e changed
the tree again. So the first package, a6, is a read-only audit that writes no code, and
every contract row that depends on it is marked PENDING a6 rather than decided in
advance.
c. P6 does not get a game running on the phone. ANativeWindow* is meaningless in the child,
and protocol.fbs:186-196's own comment says Android transfers the window out of band -
that band is P12. P6 lands pbuffer / surfaceless / offscreen, which is what HeadlessGL,
the split-equivalent lane and trace replay need, and which is exactly what P6's own exit
gate measures. A real window reaching the server is a named refusal. This gets its own
section because "P6 is done" would otherwise read as "the game runs now".
The contract adds rule G: a role may not name a process-local handle. It extends P5c's
rule E (a role may not name the other role's memory) from memory to identity - EGLDisplay /
EGLSurface / EGLContext / ANativeWindow* / fd number / pid / mapped address either cross as
a token this contract defines or they do not cross, and a descriptor crosses only through
SCM_RIGHTS, where the kernel renumbers it.
What P5e left for P6 gets its own section. The latch semantics are already designed
(ARCHITECTURE.md:504) and are copied unchanged. What is new is that after run-ahead the
client no longer waits while the peer process can DIE: the client holds records that were
published and will never be applied, and Android's freezer suspends the child without
closing anything. So slow and dead must be distinguishable WITHOUT a timeout threshold.
That is P6's only new design; everything else is carriage. It shares a predicate with E1's
outstanding re-specification (ID-122), and the two should be designed together.
Two gates carried over from P5e's lessons: G2 requires integration-spawn's test-name set to
match integration-split's name for name, because a differing set means the lane is quietly
running less; and the arm-proof gate requires every entry to record the child pid and
transport=spawn in its OWN private log - ID-124 established that this kind of false green
really happens, and a spawn lane that actually ran monolith would pass every other gate.
S2's shape must be settled before it is written, and the document says why: E1 is the
cautionary case.
2. The working notes move into the repository (docs/Disaggregated/notes/, 415 .md files)
ROADMAP / CURRENT_STAGE_PROGRESS / MEASUREMENTS cite ruling numbers, audit line numbers and
the provenance of gate figures from ~/w7/notes/, a directory that exists on one machine and
is under no version control. A record cited hundreds of times that lives only locally is not
a record, so it moves in whole, with its directory structure intact.
Only .md moves. Scripts, run logs, census and gate result JSON, patches, APKs and nm dumps
stay where they are: they are evidence DATA rather than documents - large, regenerated per
run, and mostly carrying absolute paths and device serials that mean something only on the
machine that produced them. The mapping and this split are written in
docs/Disaggregated/notes/README.md.
Two exceptions are recorded there too: P6's BRIEF has been promoted to a first-class
document and keeps no copy under notes/, so the two cannot drift apart; and recovered/ holds
material salvaged from failed workflow runs, which may duplicate the like-named phase
directories and is kept because a few of those were the only complete version at the time.
CI's citation lint takes docs/Disaggregated/*.md only (non-recursive), and notes/ is
deliberately outside it: those notes' file:line citations were written against their own
code heads, and resolving them against today's HEAD would fail wholesale - which is not an
error, it is their correct state as a historical record. To check one, use the revision it
declares (--rev).
3. Inconsistencies fixed in passing
- README.md's status line still said P5e was in progress while the stage table already said
closed.
- CURRENT_STAGE_PROGRESS's next-step item 1 still listed the exit gate as pending, though
(a) and (b) were run in the previous commit; rewritten to closed plus the one item that
actually remains (E1).
- ROADMAP's P6 row still had the pre-phase plan in three of its cells; it now carries the
package order, the scope boundary and the two new gates.
Checked with check_doc_citations.py: 125 citations across docs/Disaggregated/*.md, 0 problems.
664 lines
43 KiB
Markdown
664 lines
43 KiB
Markdown
# c0 — contract package, v1
|
|
|
|
Branch `p5/c0`, seven commits, **`41b4f8df..b4bbcc11`**, forked from `feat/disaggregated @ a29807cc`.
|
|
Worktree `~/w7/p5-c0`. Nothing pushed; nothing merged.
|
|
|
|
```
|
|
41b4f8df [Fix] (MG_Pipe, gen_pipe): export the per-opcode call flags and give GetCaps and
|
|
CreateSamplerState the kHasBlob their payloads have always owned
|
|
ec20e700 [Feat] (Config, ConfigLoader): parse MOBILEGL_TRANSPORT and the MOBILEGL_IPC_* family
|
|
entirely behind the disaggregated option, so the pull build's symbol set cannot move
|
|
1ee6c895 [Build] (CMake): add MOBILEGL_BUILD_DISAGGREGATED_INPROC, make DISAGGREGATED imply
|
|
PIPE_PUSH, and list the new MG_Remote Wire/Client/Server sources
|
|
418e6f50 [Feat] (MG_Remote): land the P5 contract headers and their named-Fatal stubs so all
|
|
seven parallel packages compile and link on day one
|
|
72a4cba5 [Fix, Test] (MG_Test): include the header that defines MOBILEGL_PIPE_POISON - seven
|
|
emitter suites tested the macro without it, compiled the non-aborting arm, and turned
|
|
eighteen expected refusals into aborts the moment a disaggregated build armed it
|
|
dd4afb0f [Docs, Test] (MG_Remote, Wire): state the five sequence watermarks, the
|
|
late-never-early batching rule and the pad-does-not-count rule on RingControl, and pin
|
|
all three with five cases
|
|
b4bbcc11 [Docs] (MG_Remote): CONTRACT-P5.md - the encoding, byte-carrier, field-ownership and
|
|
role-ownership tables every P5 package is held to
|
|
```
|
|
|
|
---
|
|
|
|
## 1. What landed, against BRIEF §5's nine items
|
|
|
|
| # | item | state |
|
|
|---|---|---|
|
|
| 1 | `MG_Remote/CONTRACT-P5.md`, tables 0/1/2/3 | **done.** Table 1 is **23 rows**, not 19 (see §3.5). Table 2 is the spec + the four class definitions + every known row; p1 generates the authoritative instance. |
|
|
| 2 | `PipeCalls.def` flag corrections + the `ResourceRespecify` initial-bytes ruling | **done.** `GetCaps` → `kReplySlot\|kHasBlob`; `CreateSamplerState` → `kHasBlob`. R-13.3 **confirmed** with evidence; R-13.2 **overturned in a third direction** (§3.2). No opcode moved; `PipeCatalogueTest`'s last-four pins untouched. |
|
|
| 3 | `gen_pipe.py` per-opcode flags table | **done.** `kMGPipeCallFlags[kOpCount]` + `MGPipeCallFlagsFor()` + six generator-authored `static_assert`s, in `generated/PipeWire.inc`. Plus a **new gate**: a flag token that is not an `MGPipeCallFlags` enumerator, or `kNone` OR'd with a real flag, stops the generator. Two new negative controls; `--self-test` went 7 → **9 controls**, all trip. `.inc` regenerated and committed. |
|
|
| 4 | `MG_Config::Transport` + `MOBILEGL_TRANSPORT` + the `MOBILEGL_IPC_*` family | **done**, all nine knobs plus `MOBILEGL_IPC_SERVER_PATH`. Runtime-verified on six arms (§2.5). |
|
|
| 5 | CMake | **done**, plus one implication the brief did not ask for: **`DISAGGREGATED` now implies `PIPE_PUSH`** (§3.8). |
|
|
| 6 | headers and stubs | **done**, 8 headers + 8 `.cpp`. Every stub is `MGLOG_F` + `std::abort`. |
|
|
| 7 | verb census | **done** — and for OpenRA it is **measured, not estimated**: the fixture was already hydrated locally. `~/w7/notes/p5/verb-census.md`. |
|
|
| 8 | `Ring.h` + five cases | **done.** `RingTest` 16 → 21 cases; the Wire suites go 52 → 57 and are **57/57 green**. |
|
|
| 9 | purity | **done.** `check_include_closure.py`: 4 probes, 0 skipped, **0 problems**. No new header is reachable from `ITransport.h`. |
|
|
|
|
---
|
|
|
|
## 2. Acceptance numbers
|
|
|
|
All in `~/w7/p5-c0`, `GLIBC_TUNABLES=glibc.malloc.tcache_count=0`.
|
|
|
|
### 2.1 Builds — four for four
|
|
|
|
`build-linux` (pull), `build-push`, `build-verify`, `build-split`
|
|
(`-DMOBILEGL_PIPE_PUSH=ON -DMOBILEGL_BUILD_DISAGGREGATED=ON -DMOBILEGL_BUILD_DISAGGREGATED_INPROC=ON`):
|
|
**configure rc=0, build rc=0, all four.**
|
|
|
|
### 2.2 G1 — did not move
|
|
|
|
```
|
|
nm --defined-only build-linux/libMobileGL.so | grep -ic MG_Remote -> 0
|
|
nm --defined-only build-split/libMobileGL.so | grep -ic MG_Remote -> 188 (was 98 at a29807cc)
|
|
symbol-report vs ~/w7/p5-before-libMobileGL.so, --threshold 0:
|
|
.text 10806323 -> 10806323 (+0, +0.000%)
|
|
27811 -> 27811 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
|
|
```
|
|
|
|
This is the gate the brief calls the easiest to break, and it held **because every knob and the
|
|
whole parser sit behind `#if MOBILEGL_BUILD_DISAGGREGATED`** — including the parser. A
|
|
`FeaturesTable` member would have resized `MG_Config::Features`; a warning in the unconditional
|
|
part of `ConfigLoader` would have resized `MG_ConfigLoader::Init`.
|
|
|
|
### 2.3 Generators and purity
|
|
|
|
```
|
|
gen_pipe.py --check : generated files are up to date
|
|
gen_pipe.py --self-test : 9 negative-control trips, positive control OK (was 7)
|
|
gen_pipe_dirty_surface.py --check / --self-test : green, 27 controls all trip
|
|
check_include_closure.py : 4 probes, 0 skipped, 0 problem(s)
|
|
```
|
|
|
|
### 2.4 Test lanes
|
|
|
|
| lane | result |
|
|
|---|---|
|
|
| `ctest -L unit` build-linux | **1785 / 1785** |
|
|
| `ctest -L unit` build-push | **1785 / 1785** |
|
|
| `ctest -L unit` build-verify | **1785 / 1785** |
|
|
| `ctest -L unit` build-split | **1842 / 1842** — the 18 aborts are gone (§4) |
|
|
| the five `MG_Test/Wire` suites in build-split | **57 / 57** (52 + my 5) |
|
|
| `ctest -L integration-gpu` build-push, `MOBILEGL_TRANSPORT=monolith` | **1117 / 1117** |
|
|
| `ctest -L integration-gpu` build-push, no `MOBILEGL_TRANSPORT` | **1117 / 1117** |
|
|
| `ctest -L integration-gpu` build-split, `MOBILEGL_TRANSPORT=monolith` | **1117 / 1117** |
|
|
|
|
Name-for-name identity, `integration-gpu` in `build-push`, mine vs `~/w7/pipe/build-push` at
|
|
`a29807cc`: **1117 = 1117, diff lines 0.**
|
|
**G2** (pull vs push ctest names, all labels): **0 diff lines.**
|
|
**G14** (split vs push): **57 added, 0 removed** — the added 57 are exactly the Wire suites.
|
|
|
|
### 2.5 The knobs, at runtime
|
|
|
|
Six arms through a binary that actually runs `MG_ConfigLoader::Init()`
|
|
(`ctest -R ClearThenReadPixels` in `build-split`, **10/10 green on every arm**):
|
|
|
|
| arm | observed |
|
|
|---|---|
|
|
| defaults | silent — nothing logged, because `Transport == Monolith` |
|
|
| `inproc` + tuned | `IPC ring=4MiB stage=16MiB spin=10us persistent-block=64KiB adopt-tier=2 verb-barrier=1 strict=0 audit=0 affinity='auto'` |
|
|
| `inproc` + both negative controls | both warnings fire by name, and the line shows `persistent-block=0KiB verb-barrier=0` |
|
|
| `spawn` | `names a transport P6 implements and P5 does not; staying on monolith. This run is NOT a split run.` |
|
|
| `MOBILEGL_TRANSPORT=banana` | `Ignoring invalid env variable MOBILEGL_TRANSPORT='banana'` |
|
|
| `MOBILEGL_IPC_RING_MB=0` | `Ignoring invalid env variable MOBILEGL_IPC_RING_MB='0'`, falls back to 8 |
|
|
|
|
### 2.6 The CMake implications actually fire
|
|
|
|
```
|
|
-- MOBILEGL_BUILD_DISAGGREGATED_INPROC=ON forces MOBILEGL_BUILD_DISAGGREGATED ON for this configure
|
|
-- MOBILEGL_BUILD_DISAGGREGATED=ON forces MOBILEGL_PIPE_PUSH ON for this configure: ...
|
|
-- PipeInputs push ON, appending the MGPipe fill sources
|
|
-- disaggregated transport ON, appending MG_Remote sources
|
|
```
|
|
|
|
Both are normal variables shadowing the cache for one configure, matching the house shape the
|
|
flatbuffers guard's own comment argues for — so an operator's cached `ON` stays theirs.
|
|
|
|
---
|
|
|
|
## 3. Rulings I made that the brief did not
|
|
|
|
Every one is also in `CONTRACT-P5.md §6`, with what would overturn it. Here, only the ones a
|
|
package will trip over.
|
|
|
|
**3.1 `CallMask` bits 32..47 carry the consumer mask.** R-8 says the client's liveness gates
|
|
read the `CallMask` mirror instead of `MGPipeGetResourceOps()`. But `CallMask` as declared has
|
|
only the nine `MGPCapBit` feature bits and **no per-family bit**, so R-8 was not implementable
|
|
as written — c1 and b1 would each have invented one. Ruling: bits 0..8 stay `MGPCapBit`; bits
|
|
32..47 are `(serverConsumedSubsystems & 0xFFFF) << 32`. Constants and the fold/test helpers are
|
|
in `MG_Remote/CapsCodec.h`; `CapsCodec.cpp` asserts the block does not collide with the cap bits
|
|
and that P4a's `0x1fff` fits. *Overturned by* a decision to carry a second schema field instead.
|
|
|
|
**3.2 `ResourceFlushRange` carries no bytes at all** — a third answer, not either of R-13.2's
|
|
two. The ladder it drives rewrites its range *"from the authoritative shadow"*
|
|
(`Managers.cpp:1047-1076`), and under R-11 the authoritative shadow is server-owned, so
|
|
`resource_subdata` is **already** the only way bytes reach it. A blobref would be a second,
|
|
forgeable way to say the same thing. *Overturned by* evidence that tier-1 `INVALIDATE_RANGE`
|
|
needs bytes and range in one record — impossible while the verb barrier holds; **revisit when
|
|
the barrier retires for the buffer family.**
|
|
|
|
**3.3 `ResourceRespecify` has a SECOND uncarried companion and the brief does not mention it.**
|
|
`const MGPRespecifiedLevel* level` (`PipeApply.h:792-795`) is the **scope** of the redefinition
|
|
and `MGPResourceDesc` cannot express it. Without a carrier, every per-level `glTexImage2D` in
|
|
OpenRA silently takes the whole-resource arm and drops every pending upload — precisely the
|
|
texel loss the server-side set exists to prevent. Ruling: two named fields in the **existing
|
|
pads** — `Pad1` (4 B) becomes `{Uint16 RespecifiedUploadTarget; Uint16 RespecifiedLevel;}` and
|
|
one byte of `Pad0` becomes `Uint8 HasRespecifiedLevel`. Zero size change,
|
|
`MGP_ASSERT_POD(MGPResourceDesc, 88)` does not move. **I ruled and specified it; I did not
|
|
implement it** — `MGPipeTypes.h` is not c0's file. It is coupled to `PipeFields.def`, which *is*
|
|
mine (pads are excluded from field lists, so the two named members must be added there or
|
|
`--check` fails). **Integrator: land this before w1 encodes the record.**
|
|
|
|
**3.4 R-13.3 confirmed, with the cost that makes it obvious.** `MGPBlobRef` is 24 bytes;
|
|
`MGPResourceDesc`'s two pads total **6**. A blob member takes the struct 88 → 112 and moves the
|
|
POD assertion. The recommended route reuses `MGPipeForEachSubDataRecordRange`, which is already
|
|
chunked and already acceptance-gated, and **the texture path already does exactly this** —
|
|
`TextureEmit.h:1137` passes `nullptr` and relies on a following upload. So the ruling
|
|
generalises today's texture behaviour to buffers rather than inventing anything.
|
|
|
|
**3.5 Table 1 is 23 rows.** The brief's 19 and `scout-premortem:§3`'s 19 are **different lists**;
|
|
the four only the premortem carries — `MapPersistent`, `ResourceReadback`, `ReadPixels`,
|
|
`GetTextureImage` — are exactly the server → client ones. A phase that omits them discovers in
|
|
week three that it never decided where readback pixels land. Ruling for `ReadPixels`:
|
|
**destination is always `SEG_REPLY` in P5**, so `MGPReadbackInfo` gains no `Seg` field.
|
|
|
|
**3.6 `tableSlotMask` is deleted, not renamed** (R-8 allowed either). Decisive: `GLFunctionsTable`
|
|
has **69** function-pointer slots and `ulong` is 64 bits — the field cannot address the table its
|
|
own comment names, and never could. `maxComputeWorkGroupCount`/`Size` and
|
|
`prefersCpuXfbPrimitiveAccounting` go with it.
|
|
|
|
**3.7 The persistent-map census is 21 sites, not 20**, and `DirectGLES.cpp:361`
|
|
(`ResolveIndirectCommandBytes`) is in the set. `MEASUREMENTS.md:111` says 20 and
|
|
`Managers.cpp:5047-5048` says eleven Espryt; both are exactly one low and the missing one is
|
|
Espryt's. A shared helper that reaches a persistently-mapped range can read stale bytes exactly
|
|
as a draw site can. **`ARCHITECTURE.md:290`'s cited "§5.7" attribution table does not exist in
|
|
the tree** — b1 should not go looking. Correcting `MEASUREMENTS.md:111` is b1's line.
|
|
|
|
**3.8 `MOBILEGL_BUILD_DISAGGREGATED` implies `MOBILEGL_PIPE_PUSH`.** The split path decodes into
|
|
the MGPipe applier and `PIPE_PUSH` is what compiles the applier, so
|
|
`-DMOBILEGL_BUILD_DISAGGREGATED=ON` alone used to configure cleanly and fail at link — a shape
|
|
indistinguishable at the CMake level from a legitimate transport-only build.
|
|
|
|
**3.9 The two doorbell accessors stay off `ITransport`.** They are on `InProcessTransport`
|
|
today (`InProcessTransport.h:64-68`). Ruling: the **session** owns the pair and hands out
|
|
references, so `ITransport` stays the dumb control-plane interface its own header describes and
|
|
`SocketTransport` does not grow two accessors with no natural home. Deciding this in P6 would
|
|
mean re-laying one package's call sites.
|
|
|
|
**3.10 `gMGPipeSegmentResolver` is installed by the SERVER role only.** It is one process-wide
|
|
non-atomic inline variable (`MGPipeHostSpan.h:47`), so it cannot be per-role — and under R-2 the
|
|
client never resolves a span anyway, it only ever writes `Ptr = nullptr`.
|
|
`SegmentTable::InstallProcessResolver()` asserts if one is already installed.
|
|
|
|
**3.11 `DrawVbo`'s host span stays in the variable tail.** `MGPipeTypes.h:1221-1224` defers the
|
|
fixed-head-versus-tail question to P5. There are no per-draw byte histograms yet, so moving it
|
|
would be a wire-format change with no measurement behind it. Keep.
|
|
|
|
**3.12 Silent `MOBILEGL_TRANSPORT` in a non-disaggregated build is accepted and unfixable at
|
|
runtime.** A complaint would have to live in the unconditional part of `ConfigLoader`, which
|
|
resizes a pull-build symbol and breaks G1. The guard is therefore t1's build-level `nm` check,
|
|
and it is written into the contract so nobody re-litigates it.
|
|
|
|
---
|
|
|
|
## 4. The 18 split-build unit aborts — root cause and disposition
|
|
|
|
**Disposition: FIXED here, by c0, in one test-local commit. Nothing is left red, and none of it
|
|
is p1's.**
|
|
|
|
The brief's leading hypothesis — a `PipeInputs` poison read hitting
|
|
`Fatal{UnmigratedPipeInput, "<Field>@<none>"}` — is **refuted**. `MG_Test/ScopedPipeVerb.h` is
|
|
not involved at all.
|
|
|
|
All 18 are `Fatal{ProtocolCorruption}` trip wires in `PipeApply.cpp` that **the tests
|
|
deliberately provoke and expect**, e.g.
|
|
|
|
```
|
|
MGPipe: Fatal{ProtocolCorruption} create_vertex_elements {slot=5, gen=2}: the declared blob
|
|
length is not the byte length the two counts describe (attributes=3, bindingPoints=2, that
|
|
describes 104 bytes, blob declares 103)
|
|
```
|
|
|
|
`MOBILEGL_PIPE_POISON` **is** derived from `MOBILEGL_BUILD_DISAGGREGATED`
|
|
(`PipeInputs.h:20-26`, exactly as the brief says) — but what it arms here is a *second* consumer,
|
|
`PipeApply.cpp:42-52`, which flips 32 trip wires from `MGLOG_E` to `MGLOG_F` + `abort`. Each of
|
|
the seven test files has a two-armed helper keyed on `#if MOBILEGL_PIPE_POISON || MOBILEGL_PIPE_VERIFY`
|
|
that picks between "fork a child and expect it to die" and "run in process and read the log".
|
|
|
|
**None of those seven TUs included `<MG_Backend/MGPipe/PipeInputs.h>`, the only header that
|
|
defines the macro.** So the token was undefined, the `#if` silently read 0, and they compiled
|
|
the non-aborting arm while `PipeApply.cpp` — which does include the header — compiled the
|
|
aborting one. Invisible in a push build (POISON really is 0) and in a verify build
|
|
(`-DMOBILEGL_PIPE_VERIFY=1` is on the command line); **`MOBILEGL_BUILD_DISAGGREGATED` is the one
|
|
arming condition that lives behind the header**, so `build-split` is the first configuration
|
|
that could ever expose it.
|
|
|
|
Fix: one include per file, matching what the two sibling files that get it right already do
|
|
(`RenderStateSpansTest.cpp:63`, `PipeInputsTest.cpp:34`), each with the six-line note explaining
|
|
why. Plus one latent guard correction that the same invisibility was masking:
|
|
`ResourceEmitTest.cpp`'s `TheLiveHostWritesWireFiresOnTheCallAPersistentMapProducerWouldSetItOn`
|
|
guarded itself with `#elif !(MOBILEGL_PIPE_POISON || MOBILEGL_PIPE_VERIFY)` while
|
|
`PinNoLiveHostWrites` is `#if MOBILEGL_PIPE_VERIFY` **only** (`PipeApply.cpp:838-853`) — so in a
|
|
split build the wire genuinely is compiled out and the case must skip. Corrected to
|
|
`#elif !MOBILEGL_PIPE_VERIFY`; verified **SKIPPED in push, SKIPPED in split, OK in verify.**
|
|
|
|
**Why it is c0's and not p1's:** p1's artefacts are all correct as they stand. `PipeInputs.h`
|
|
derives the macro the way its own comment says it must; `PipeApply.cpp` consumes it correctly;
|
|
`PipeFill.cpp` and `gen_pipe_dirty_surface.py` are not in the path. The defect is entirely
|
|
consumer-side visibility in seven files under `MG_Test/Pipe/`, which are not p1's (t1 owns only
|
|
`MG_IntegrationTest/**`), and the fix introduces no new convention — that `MG_Test` →
|
|
`MG_Backend/MGPipe/PipeInputs.h` edge already exists twice in the same directory.
|
|
|
|
**One hardening left on p1's account, deliberately not taken:** if the integrator wants
|
|
`MOBILEGL_PIPE_POISON` to be unmissable, the derivation could move into a header every push TU
|
|
already sees (`MG_Pipe/MGPipe.h`), or `PipeInputs.h` could grow a tripwire for TUs that test the
|
|
macro without it. That changes a p1-owned header and touches every push TU's macro surface —
|
|
a much larger blast radius than a seven-line include for a defect the include closes completely.
|
|
**Filed as a p1 note; not done here.**
|
|
|
|
*(One caveat inherited, not introduced: running a whole fixed binary by hand — all cases in one
|
|
process — leaves some `FramebufferEmit`/`TextureEmit` fork cases red, because the parent has
|
|
already opened the log file and the child inherits a handle to the unlinked inode. That is the
|
|
limitation `RenderStateSpansTest.cpp:1034-1040` names; under ctest every case is its own process
|
|
and it does not arise.)*
|
|
|
|
---
|
|
|
|
## 5. Every stub signature, with one line each
|
|
|
|
`MG_Remote/Wire/PipeWireCodec.h` — owner **w1**
|
|
|
|
| signature | why this shape |
|
|
|---|---|
|
|
| `enum SegmentId { kSegNone=0 … kSegAdopt=6 }` | one id space with `Protocol::SegmentKind`, tied by `static_assert` in the `.cpp`, which is the only place the flatbuffers header and the codec meet. |
|
|
| `struct SegmentView { void* Base; Uint64 Size; }` | a role's view of one segment; two roles in one process hold two different tables over the same memory on purpose. |
|
|
| `SegmentTable::{Install, Get, Resolve, InstallProcessResolver, UninstallProcessResolver}` | `Resolve` returns `nullptr` rather than Fatal-ing so a unit test can exercise the arithmetic without dying; the **caller** escalates. |
|
|
| `WireProtocolFatal(what, detail)` / `WireProtocolFatalAt(what, got, expected)` | **not stubs** — worded once so encoder, decoder and every package's own check emit the same line. |
|
|
| `CheckBlobIsHonest(op, blob, segments)` / `CheckHostSpanIsHonest(span)` | R-2.3's arms as functions, so "honest" means one thing. |
|
|
| `PipeWireEncoder::StageBytes(bytes, size) -> MGPBlobRef` | returns the ref; a zero-size call **Fatals** rather than returning an empty ref, because "declared no blob" and "declared an empty blob" must not be spelled the same way. |
|
|
| `PipeWireEncoder::EncodeRecord(op, payload, payloadBytes, varTail, varTailBytes) -> Uint64 seq` | returns the **seq**, which is also the reply-slot id (R-3). One function for fixed payload + tail so no package invents a second framing. |
|
|
| `PipeWireEncoder::{Publish, EmitSeq, MaxRecordBytesSeen}` | `MaxRecordBytesSeen` is R-10's proof obligation, on the encoder because that is where the number exists. |
|
|
| `class ReplySink { PostReply(seq, status, bytes, size) }` | declared in **Wire**, not Server, so the codec does not depend on the session: the decoder's job ends at "produce the answer bytes". |
|
|
| `PipeWireDecoder::DecodeAndApply(const RingRecordView&) -> Bool` | one record in; `false` = "this build does not implement it", **malformed never returns**. A `kRecPad` reaching it Fatals — the caller skips pads *before* counting. |
|
|
| `PipeWireDecoder::AppliedSeq()` | separate from the control page so the batching ban (R-9) has something to be checked against. |
|
|
|
|
`MG_Remote/CapsCodec.h` — owner **w1** (codecs) / **s1** (handshake)
|
|
|
|
| signature | why |
|
|
|---|---|
|
|
| `kMGCapsConsumerBitShift`, `kMGCapsConsumerMask`, `MGCapsConsumerBits(mask)`, `MGCapsServerConsumes(callMask, bit)` | the ruling of §3.1 as four `constexpr`s, so neither side hand-shifts. |
|
|
| `Encode/DecodeFormatCapabilities`, `Encode/DecodeRendererInfo` | the two serializers `MGPipeTypes.h:134-136` defers to this phase. Decoders return `false` on truncation; these bytes arrive over a wire. |
|
|
| `CapsAbiFingerprint() -> Uint64` | mixes the three `sizeof`s and the build fingerprint; compared in `Hello`/`Welcome`, `Fatal{AbiMismatch}` and never a downgrade. |
|
|
|
|
`MG_Remote/Client/CapsMirror.h` — owner **c1**
|
|
|
|
| signature | why |
|
|
|---|---|
|
|
| `Adopt(caps, formats, renderer, apiVersion, backend)` | one call, whole snapshot; **re-arrival is the invalidation** (R-12), so there is no separate `Invalidate()`. |
|
|
| `Generation()` | ++ per `Adopt`. The only thing on the client that can see a server context death; a client memo must key on it. |
|
|
| `Renderer()` returns a **reference** | `GetRendererInfo()` is `const RendererInfo&` (`BackendObject.h:590`), so the mirror must own an instance — including a placeholder before the first snapshot, because `LogBackendInfo` reads it at `Init.cpp:21`. |
|
|
| `Dynamic()`, `Formats()`, `ApiVersion()`, `Backend()` | the other 55 read points. `Backend()` returns the **server's** type, never a new "Remote" enumerator. |
|
|
| `ServerConsumes(subsystemBit)` | R-8's only legal client-side spelling. |
|
|
| `PrefersCpuXfbPrimitiveAccounting()` | it is a `GLFunctionsTable` member (`:274`), not a `Dynamic` one, so under split it has to come from the cap bit. |
|
|
|
|
`MG_Remote/Client/EmitTables.h` — owner **c1**
|
|
|
|
| signature | why |
|
|
|---|---|
|
|
| `RemoteEmitTable() -> const GlobalBackendFunctionsTable&` | **71** function pointers, not 69 (§3 of the contract): 69 `GL.*` + `Present` + `SetSwapInterval`. |
|
|
| `UnmigratedVerbFatal(slot)` `[[noreturn]]` | **not a stub** — same shape as `MGPipeInputPoisonFatal`, live at every log level, so the wording lives in one place and a death test can filter on it. |
|
|
| `ImplementedVerbCount()` / `kRemoteEmitSlotCount = 71` | a table that silently loses an emitter must not look like one that never had it; `EmitTables.cpp` asserts the 71 against the struct. |
|
|
|
|
`MG_Remote/Client/ClientSession.h` — owner **s1** (construction) / **c1** (barrier)
|
|
|
|
| signature | why |
|
|
|---|---|
|
|
| `Active()` returns `nullptr`, not a Fatal | `MG_Backend::Init()` legitimately asks "is there a session" and the monolith answer is no. |
|
|
| `Start(mode, endpoint)` | returns a named error rather than falling back to monolith. |
|
|
| `Stop()` | publish → `Kill` → join → only then free emitter-owned memory. |
|
|
| `EmitAndWait(op, payload, bytes, tail, tailBytes, replyOut, replyBytes, statusOut) -> seq` | **one call**, because the barrier's wait and the reply's wait are the same wait (R-3/R-5). Separating them is how a package re-derives an acceptance answer locally. |
|
|
| `BarrierArmed()`, `InBarrierWait()`, `ApplyThreadIsInsideApplier()` | R-1's mutual-exclusion invariant as a checkable pair rather than a sentence. Both return `false` in the stub — an assertion helper that aborts when asked is worse than useless. |
|
|
|
|
`MG_Remote/Server/PipeApplier.h` — owner **v1** (with **p1** for the stamp)
|
|
|
|
| signature | why |
|
|
|---|---|
|
|
| `ReplyPool(base, size, slotCount, slotBytes)` + `PostReply` override | addressed `seq % slots`, seq stamped back into the header for self-check. |
|
|
| `ReplyPool::SlotBytes()` | a reply bigger than a slot is Fatal, not chunked: P5's only big answer is `ReadPixels`, whose size the client knows before it emits. |
|
|
| `PipeApplier::ApplyOne(record)` | decode → stamp → apply → reply → advance `appliedSeq` by **one**. |
|
|
| `PipeApplier::StampVerbBoundary(op)` | the prerequisite nobody else owns (§3 of the contract). p1 defines what; v1 calls it. |
|
|
| `PipeApplier::ResidualPullCount()` | `rsp`; its end-of-P5 value **is** the P6/P7/P8 debt. |
|
|
| `PipeApplier::PoisonRetiredStageBytes(offset, size)` | R-2.5's `0xDD`, the only mechanical control on rule C. |
|
|
|
|
`MG_Remote/Server/ServerSession.h` — owner **s1**
|
|
|
|
| signature | why |
|
|
|---|---|
|
|
| `Accept(ITransport&)` | the ABI assertion happens here, **before** a single record is decoded. |
|
|
| `PublishCapsSnapshot()` | callable more than once; the second call **is** the invalidation. |
|
|
| `ConsumerDoorbell()` / `ProducerDoorbell()` | §3.9: the pair lives on the session, not on `ITransport`. |
|
|
|
|
`MG_Remote/Server/ServerLoop.h` — owner **v1**
|
|
|
|
| signature | why |
|
|
|---|---|
|
|
| `Start(session)` | names the thread `mgl-srv-apply`, applies the affinity **and logs the resolved mask**. |
|
|
| `Stop()` / `Running()` | `Running()` is not a stub: teardown asks it before deciding to Kill and join, and a helper that aborts when the thread never started is a hang. |
|
|
| `Backend()` | the server's **private** `BackendObject_DirectGLES`, not `pActiveBackendObject`. |
|
|
| `RunOnApplyThread(ControlWork, void*)` | a raw function pointer plus a user pointer, **not `std::function`**: this runs on the teardown path and the teardown path may not allocate (ID-8). |
|
|
|
|
---
|
|
|
|
## 6. Everything in the brief I believe is wrong or incomplete
|
|
|
|
Ordered by how much it would cost a package to discover it.
|
|
|
|
1. **R-13.3 covers only one of `ResourceRespecify`'s two uncarried companions.** §3.3. The
|
|
`MGPRespecifiedLevel*` scope needs a carrier or OpenRA's per-level uploads are silently lost.
|
|
**This is the one I most want the integrator to act on before w1 starts.**
|
|
2. **R-4's "69 slots" is `GLFunctionsTable`'s count; the table the client installs is 71.**
|
|
`Present` is on the reduced path and `Present`/`SetSwapInterval` have **zero `MG_Impl` call
|
|
sites** — they are reached through the EGL path, so an emit table built by mirroring GLImpl
|
|
covers neither.
|
|
3. **R-4's predicted minimum set names `Flush`. There is no `Flush` slot, and `glFlush`/`glFinish`
|
|
are literally empty bodies** (`Definitions.cpp:111-112`). A `TriangleScenario` that uses
|
|
`glFlush` to order its readback is ordering nothing.
|
|
4. **The census's real surprise: `GetIntegeri_v` is reached by the first `glCompileShader` of a
|
|
context**, via `CaptureCompileEnv` (`CompileEnv.cpp:134-138`), not by any verb. An all-Fatal
|
|
emit table aborts on the first shader compile of **every** scenario. It needs a real emitter
|
|
or a caps-mirror answer.
|
|
5. **R-8 is not implementable as written** — `CallMask` had no per-family bit. §3.1.
|
|
6. **Table 1's 19 rows are the wrong 19** (§3.5), and one of them, `SetResidualValueState`, is a
|
|
**fourth typed companion** nobody named: `MGPipeApplySetResidualValueState` takes
|
|
`const ResidualValueBlock&` and `MGPResidualValueState` is **never instantiated on the live
|
|
path**. Budget it as w1's hardest row, not one of the easy eight.
|
|
7. **Three of the 19 have no applier entry point at all** — `SetShaderBuffers`,
|
|
`SetStreamOutputTargets`, `DrawVbo`. `scout-premortem:§3` cites five entry points for a
|
|
six-call row and those five belong to other calls.
|
|
8. **The brief's diagnosis of the 18 aborts is wrong** (§4). It cost nothing here because it was
|
|
checked rather than assumed, but a package that had taken it at face value would have gone
|
|
looking in `ScopedPipeVerb` and p1's poison machinery, both of which are innocent.
|
|
9. **`CanTouchGLNow()` guards 16 sites, not 19** (19 = 1 definition + 2 comments + 16 calls), and
|
|
**`ScopedDefaultUnpackState` has six value shadows, not five**.
|
|
10. **`DirectGLES.cpp:12446` is not `ClampSamplesToBackendSupport`** — it is `Present()`'s fence
|
|
poll, and `DirectGLES.cpp` contains no `pActiveBackendObject` reference at all. The real
|
|
function is `BackendObject_DirectGLES.cpp:807-828`, and there are **seven** backend-internal
|
|
reads across **six** functions, not one. Table 3's conclusion survives; the diff does not.
|
|
11. **`MGPipeApply*` is 37 entry points / 41 call sites**, not "~45".
|
|
12. **The persistent-map census is 21, not 20**, and the attribution table `ARCHITECTURE.md:290`
|
|
cites does not exist (§3.7).
|
|
13. Doc corrections carried into the contract: `ARCHITECTURE.md:83` says 61 `PipeInputs` fields
|
|
(it is 63); `:492` cites `PipeStats.h:126` for `mpr` (it is `:141`); `:19` says eight EGL
|
|
lifecycle virtuals (there are nine — `ResizeEGLWindowSurface`); ROADMAP's P4a row says six
|
|
`MGPipeUnmigratedEmulation` sites (five calls + one comment).
|
|
14. **`MGHostSpan`, not `MGPHostSpan`** — the latter does not exist.
|
|
|
|
---
|
|
|
|
## 7. Notes for the integrator
|
|
|
|
- **The worktree's submodules are symlinks to `~/w7/pipe`'s.** `git worktree add` populates no
|
|
submodule content and a recursive init needs the network (apitrace's brotli tree is not in the
|
|
local object store), so `~/w7/p5-c0-setup.sh` links every `.gitmodules` path — `include/ska`
|
|
included, which is what `Includes.h:53` reaches for. **git refuses to run at all while they are
|
|
symlinks** ("expected submodule path X not to be a symbolic link"), so
|
|
`~/w7/p5-c0-submodlinks.sh off|on` toggles them: `off` before any git command, `on` before any
|
|
build. **Every parallel package will hit this on day one.** It is worth telling them once
|
|
rather than seven times.
|
|
- **An earlier bring-up script reported four green builds that never happened** — it dropped
|
|
`$COMMON` and its build loop passed no directory, so `cmake --build -j 24` only printed usage
|
|
and `$?` was 0. If any P5 script reports a build result, check that a `CTestTestfile.cmake`
|
|
exists before believing it.
|
|
- `~/w7/p5-c0-gate.sh` is c0's own gate (four dirs, generators, purity, G1, the four unit lanes)
|
|
and is a reasonable skeleton for t1's `wsl_p5_gate.sh` part 1/3/5.
|
|
- Retained logs this report cites: `~/w7/p5-c0-gaterun.log`, `~/w7/p5-c0-acceptrun.log`,
|
|
`~/w7/p5-c0-symbols.md`, `~/w7/p5-c0-names-push-{mine,base}.txt`. Everything else under
|
|
`~/w7/p5-c0-*` is a re-runnable script. The diagnosis scratch (`~/w7/p5-c0-diag-*`) is deleted.
|
|
- **Not run here, and not c0's:** `ctest -L integration-verify`, the retrace sweeps, and the
|
|
device lane. `integration-gpu` was run on both `build-push` and `build-split` and is
|
|
name-for-name identical to `a29807cc` on both.
|
|
|
|
---
|
|
|
|
## 8. Follow-up round — integrator rulings A and B, and the respecify-scope carrier
|
|
|
|
Two more commits. **Range is now `41b4f8df..5175f9cc`, nine commits.**
|
|
|
|
```
|
|
45b759e7 [Feat] (MG_Pipe): give resource_respecify's redefinition scope a wire carrier in the
|
|
descriptor's two existing pad fields, so a per-level glTexImage cannot cross as a
|
|
whole-resource redefinition and eat every other level's pending upload
|
|
5175f9cc [Docs] (MG_Remote): record R-15 and split the emit table's 71 slots into
|
|
answered-locally, emitted and Fatal, with the forty-one null checks that are really
|
|
capability probes
|
|
```
|
|
|
|
### 8.1 Ruling A — `MGPipeTypes.h` is c0's
|
|
|
|
Recorded in `CONTRACT-P5.md §8`. Worth keeping the causal note: that file being **unowned** is
|
|
precisely why the row-19b gap had nobody to close it, and the same is true of anything else that
|
|
falls between the `.def` files and a package's own directory. Ownership now reads: the three
|
|
`.def` files, `gen_pipe.py`, **`MGPipeTypes.h`**, `Config.h`, `ConfigLoader.cpp`, the root
|
|
`CMakeLists.txt`, `CONTRACT-P5.md`, the `MG_Remote` stub headers, `Ring.h`/`RingTest.cpp`.
|
|
|
|
### 8.2 Work item 1 — the carrier, landed
|
|
|
|
`MGPResourceDesc` (`MGPipeTypes.h`), exactly the §3.3 spec and nothing more:
|
|
|
|
- `Uint8 HasRespecifiedLevel` takes the **high byte of the old `Pad0`** (`Uint16 Pad0` →
|
|
`Uint8 HasRespecifiedLevel; Uint8 Pad0;`);
|
|
- `Uint16 RespecifiedUploadTarget; Uint16 RespecifiedLevel;` take **all of the old `Pad1`**, in
|
|
that order, so they are `MGPRespecifiedLevel` (`PipeApply.h:792-795`) byte for byte. Spelled as
|
|
two `Uint16`s rather than as that type because `PipeApply.h` includes *this* header, not the
|
|
reverse;
|
|
- **`MGP_ASSERT_POD(MGPResourceDesc, 88)` did not move**, and a new `offsetof` assertion pins the
|
|
pair adjacent and in that order — the layout is the contract, not the field names.
|
|
|
|
**Five helpers, because three fields are one value.** `MGPipeRespecifyIsWholeResource`,
|
|
`MGPipeRespecifiedUploadTargetOf`, `MGPipeRespecifiedLevelOf`, `MGPipeSetRespecifiedLevel`,
|
|
`MGPipeClearRespecifiedLevel`. The two readers return 0 for a whole-resource descriptor rather
|
|
than whatever the pad held, so a misuse is deterministic; the writers set or clear the presence
|
|
byte *with* the pair so it cannot be left behind. An open-coded reader that forgets the presence
|
|
byte reads **level 0 of upload target 0 as a real scope**, which is the one wrong answer that
|
|
looks plausible — hence the helpers rather than a comment.
|
|
|
|
**No emitter or applier behaviour changed.** The producer is a later package's. What did change:
|
|
|
|
- `PipeFields.def` gains the three rows — **required, not optional**: the generator's cover check
|
|
only excludes members literally named `Pad*`, so omitting them fails `--check`. Both directions
|
|
verified as negative controls: dropping `F(HasRespecifiedLevel)` →
|
|
*"member(s) with no F(...) in PipeFields.def: HasRespecifiedLevel"*; adding a name the struct
|
|
lacks → *"F(...) name(s) that are not members: RespecifiedNothing"*. They are also real **G4
|
|
comparands** now, which matters: a verify build that let the scope differ silently would be
|
|
blind to the one field deciding whether a respecify drops one pending upload or all of them.
|
|
- `PipeApply.cpp` gains `PinWholeResourceRespecifyScope`, the `PinNoLiveHostWrites` shape
|
|
(`:839-850`), called from `MGPipeApplyResourceRespecify` beside it. **Verify-build only**, and
|
|
verified so: the `Fatal{PipeRespecifyScope}` string appears in `build-verify/libMobileGL.so`
|
|
**once** and in `build-push` and `build-split` **zero** times. It pins that P5 builds only
|
|
whole-resource descriptors, so the phase that wires the carrier cannot arrive unannounced —
|
|
and in particular cannot land a descriptor saying "whole resource" while the still-live
|
|
trailing `MGPRespecifiedLevel*` says "level 1".
|
|
- A standalone round-trip compile (value-init → whole-resource; set a cube face + level 3; read
|
|
both back; clear; read 0 not the pad) returns **0**.
|
|
|
|
### 8.3 Ruling B — R-15, and the three-class split
|
|
|
|
`CONTRACT-P5.md §7`, cross-referenced from `MG_Remote/Client/EmitTables.h` and from
|
|
`verb-census.md` so c1 meets it wherever it starts reading.
|
|
|
|
- **Class A, answered locally from the caps mirror, never emitted and never Fatal — 2 slots:**
|
|
`GetIntegeri_v` (from `MGPCaps::Dynamic.MaxComputeWorkGroupCount/Size`) and
|
|
`IsTimerQuerySupported` (from `kCapTimerQuery`), plus the non-slot Bool
|
|
`PrefersCpuXfbPrimitiveAccounting` (from `kCapCpuXfbPrimitiveAccounting`).
|
|
- **Class B, emitted — 5 slots:** `Clear`, `DrawArrays`, `ReadPixels`, `BlitFramebuffer`,
|
|
`Present`.
|
|
- **Class C, `Fatal{UnmigratedVerb}` — 64 slots**, including `SetSwapInterval` and
|
|
`GetGpuTimestampNs` (a *live* GPU timestamp, not a static device property, so deliberately not
|
|
class A).
|
|
|
|
**One thing R-15 surfaced that is bigger than R-15.** R-4 forbids a null slot — and **41 of the
|
|
69 slots are null-checked at their call site, with several of those checks being capability
|
|
probes rather than safety checks**. In an emit table with no null slots every one of them answers
|
|
"supported" and the fallback behind it silently disappears. Named in the contract:
|
|
`BeginOcclusionQuery` (`GL_Query.cpp:481`, `:785`) → `kCapOcclusionQuery`;
|
|
`BeginXfbPrimitivesQuery`'s ternary (`:534`) → `kCapXfbPrimitivesQuery`; `SubDataResident` →
|
|
`kCapResidentSubData`. The rule generalises: **a null check on a slot may not survive into the
|
|
client under split** — it becomes a caps-mirror read. This is `ARCHITECTURE.md:114`'s "`CallMask`
|
|
replaces 'is this table slot null'" with a concrete list attached, and it is c1's to carry.
|
|
|
|
### 8.4 Work item 2 — the gate, re-run in full
|
|
|
|
**G1 is the one this edit could plausibly have moved** (a `PipeFields.def` row can widen a
|
|
generated array, and the descriptor's pads became named members). It did not move:
|
|
|
|
```
|
|
.text 10806323 -> 10806323 (+0, +0.000%)
|
|
27811 -> 27811 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
|
|
nm pull MG_Remote 0 / nm split MG_Remote 188
|
|
```
|
|
|
|
| check | result |
|
|
|---|---|
|
|
| four build dirs, configure + build | **rc=0, all four** |
|
|
| `gen_pipe.py --check` | up to date |
|
|
| `gen_pipe.py --self-test` | **9 / 9** controls trip, positive control OK |
|
|
| `gen_pipe_dirty_surface.py --check` / `--self-test` | green, 27 controls all trip |
|
|
| `check_include_closure.py` | 4 probes, 0 skipped, **0 problems** |
|
|
| `ctest -L unit` build-linux / push / verify | **1785 / 1785** each |
|
|
| `ctest -L unit` build-split | **1842 / 1842** |
|
|
| Wire suites, build-split | **57 / 57** |
|
|
| `integration-gpu` names, build-push vs `a29807cc` | **1117 = 1117, diff 0** |
|
|
| `integration-gpu` build-push, `MOBILEGL_TRANSPORT=monolith` | **1117 / 1117** |
|
|
|
|
**All four lanes held.**
|
|
|
|
---
|
|
|
|
## 9. Wave-1 round — the acceptance rows' reply slot, and the two flag spaces
|
|
|
|
Three commits on `p5/c0`, **`b5b6cef2..225819ab`**, on top of `feat/disaggregated @ 5175f9cc`.
|
|
|
|
```
|
|
b5b6cef2 [Fix] (MG_Pipe): give the four acceptance calls the kReplySlot their applier entry
|
|
points have always answered through, so the flags table is the single thing that sizes
|
|
the reply pool and the decoder posts against
|
|
c2273df1 [Fix, Test] (gen_pipe, Wire): stop the generated header comment inviting a stamp of the
|
|
call flags into the ring's framing flags - three of the six bits mean something else
|
|
there, and only one of the three is masked on one path
|
|
225819ab [Docs] (MG_Remote): record R-16 and R-17 - the fourteen reply-slot rows and why the
|
|
barrier makes them cost no block, and the two flag spaces being disjoint by translation
|
|
```
|
|
|
|
### 9.1 Item 1 — the four acceptance rows, verified before editing
|
|
|
|
**The set is exactly the one the ruling names.** Verified by enumerating every `MGPipeApply*`
|
|
entry point that returns a value, not by taking the brief's word:
|
|
|
|
```
|
|
Bool MGPipeApplyResourceCreate PipeApply.h:820
|
|
Bool MGPipeApplyResourceRespecify PipeApply.h:868
|
|
Bool MGPipeApplyResourceSubData PipeApply.h:897
|
|
Bool MGPipeApplySetTextureParams PipeApply.h:1023
|
|
void* MGPipeApplyMapPersistent PipeApply.h:917 (already kReplySlot)
|
|
```
|
|
|
|
No others return anything. So: `ResourceCreate` `kNone` → `kReplySlot`; `ResourceRespecify`
|
|
`kNeedsAck` → `kNeedsAck|kReplySlot`; `SetTextureParams` `kNone` → `kReplySlot`;
|
|
`ResourceSubData` `kHasBlob|kVarTail` → `+kReplySlot`. **`kReplySlot` rows 10 → 14. No opcode
|
|
moved.**
|
|
|
|
**One correction to the ruling's expectation, and it changes the work rather than the outcome:
|
|
`PipeCatalogueTest` had no `kReplySlot` count to update.** `grep -rn kReplySlot MobileGL/MG_Test/`
|
|
returns nothing at this base, and none of the five wave-1 branches adds one. Rather than leave
|
|
the number unpinned now that it is load-bearing, I **added** the pin, in the house shape the
|
|
neighbouring `kNeedsAck` count already uses (`MGP_COUNT_ACKING_CALLS`): a count assertion
|
|
(`== 14`) **and** a by-name assertion that all four acceptance rows carry the flag (`== 4`). A
|
|
count alone would let one row lose the flag while another gained it.
|
|
|
|
**The "never blocks" contradiction is resolved in the contract rather than papered over.**
|
|
`MGPipe.h:49` says a reply-slot call never blocks; R-5 says these four answers are read
|
|
synchronously. Both hold, because **under the verb barrier the client is already waiting for
|
|
`appliedSeq >= mySeq` at that verb boundary and the reply is read inside that wait**. A
|
|
`kReplySlot` row therefore adds no block — it adds a read to a wait that was already happening.
|
|
The flag keeps its literal meaning; the barrier blocks, and the barrier retires per family, at
|
|
which point these four become genuinely asynchronous and the acceptance answer becomes a real
|
|
latency question. That is P9's account.
|
|
|
|
### 9.2 Item 2 — and the part of w1's finding that the tree contradicts
|
|
|
|
The generated comment said `Flags` was "MGPipeCallFlags of the call, for asserts and tracing",
|
|
which invited exactly the stamp w1 found. It now says what the field is: **ring framing flags,
|
|
and the two spaces are disjoint by translation, not shared.**
|
|
|
|
**But the finding as relayed is stronger than the tree supports, and I would rather correct it
|
|
than pin something false.** `RingProducer::Reserve` **masks `kRecPad` out** of a caller's flags
|
|
(`Ring.cpp`: `flags & ~kRecPad`). So:
|
|
|
|
| collision | status |
|
|
|---|---|
|
|
| `kVarTail` → `kRecPad` | **defended, one bit wide, one path wide.** A stamp through `Reserve` does *not* delete the record. A producer that writes the header itself — which is what a codec with its own header struct does, since these are the same eight bytes — loses the mask, and then `Pop` skips the record as a wrap filler. |
|
|
| `kHostSpan` → `kRecBorrowSlot` | **undefended.** The consumer believes the record borrowed a slot into the GPU timeline and retires it on `completedFrameSerial` instead of on apply. |
|
|
| `kReplySlot` → `kRecVarTail` | **undefended** — and after item 1 this now fires on **fourteen** rows rather than ten. |
|
|
|
|
So the real failure is not one dramatic disappearance: it is **a lifetime lie and a phantom tail
|
|
on every affected record**, plus a disappearance only on the path that bypasses `Reserve`. My
|
|
first version of the test asserted the dramatic version, and it failed — which is the system
|
|
working. The landed test pins all three shapes *including the masking*, so the one defence that
|
|
exists cannot quietly go away either.
|
|
|
|
**Enforcement, split by what each file can see.** MG_Pipe is below MG_Remote and may not include
|
|
`Ring.h`, so no generated `.inc` can hold a cross-enum assertion:
|
|
|
|
- **`gen_pipe.py` now reads `enum MGPipeCallFlags` out of `MGPipe.h`** rather than hard-coding
|
|
it, and emits a value assertion per flag plus `kMGPipeCallFlagsAllBits == 0x3F`. A renumbering
|
|
or a seventh flag is a build break, and — because the parse also feeds the existing
|
|
unknown-flag gate — a flag added to the header no longer has to be added to the generator by
|
|
hand, which is the copy that would have gone stale in exactly the case that matters.
|
|
- **`MG_Test/Wire/RingTest.cpp`** holds the cross-enum table: the one place in the tree that sees
|
|
both enums, and built only under `MOBILEGL_BUILD_DISAGGREGATED`. Six correspondences, both
|
|
totals (`0x3F` and `0x1F`), and a runtime half that demonstrates each of the three shapes.
|
|
|
|
### 9.3 Acceptance — re-run in full, against this rebuilt tree
|
|
|
|
```
|
|
.text 10806323 -> 10806323 (+0, +0.000%)
|
|
27811 -> 27811 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
|
|
nm pull MG_Remote 0 / nm split MG_Remote 188
|
|
```
|
|
|
|
| check | result |
|
|
|---|---|
|
|
| four build dirs | **rc=0, all four** |
|
|
| `gen_pipe.py --check` / `--self-test` | up to date; **9 / 9** controls trip |
|
|
| `gen_pipe_dirty_surface.py --check` / `--self-test` | green, 27 controls |
|
|
| `check_include_closure.py` | 4 probes, **0 problems** |
|
|
| `ctest -L unit` build-linux / push / verify | **1785 / 1785** each |
|
|
| `ctest -L unit` build-split | **1843 / 1843** (1842 + the new cross-enum case) |
|
|
| Wire suites, build-split | **58 / 58** |
|
|
| `integration-gpu` names, build-push vs base | **1117 = 1117, diff 0** |
|
|
| `integration-gpu` build-push, `MOBILEGL_TRANSPORT=monolith` | **1117 / 1117** |
|
|
|
|
### 9.4 Three things for the integrator
|
|
|
|
1. **The unit baselines have not moved, because nothing has landed.** `~/w7/pipe`'s
|
|
`feat/disaggregated` is still at `5175f9cc` — my own tip. The five wave-1 branches
|
|
(`p5/w1`, `p5/s1`, `p5/p1`, `p5/t1`, `p5/b1`) exist and are ahead, but none is merged. My
|
|
numbers above are therefore directly comparable to §8's, and the only unit delta is the one
|
|
case I added.
|
|
2. **Two wave-1 branches have edited c0-exclusive files.** `p5/w1` → `scripts/gen_pipe.py`
|
|
(the decoder hook in `gen_wire`); `p5/b1` → `MGPipeTypes.h` (a `HasLiveHostWrites` byte out
|
|
of `MGPSubData`'s pad), `PipeFields.def`, `CMakeLists.txt`. Both look like good work and both
|
|
may well have been authorised the way my own `PipeApply.cpp` edit was — I raise it only so
|
|
the ownership table means something. **Their regions are disjoint from mine**, so the merge
|
|
is clean except for `generated/*.inc`, which both sides regenerate: the integrator should
|
|
take either side and re-run `gen_pipe.py`, never hand-merge a generated file.
|
|
3. **The submodule-symlink trap bit me once and will bit others.** A git command needs them off,
|
|
a build needs them on, and the failure mode when they are left off is four CMake "source
|
|
directory does not exist" errors that look nothing like the cause. `~/w7/p5-c0-gate.sh` now
|
|
restores them itself and refuses to run if they are unpopulated; worth copying into
|
|
`wsl_p5_gate.sh`.
|