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.
550 lines
37 KiB
Markdown
550 lines
37 KiB
Markdown
# P5 scout — the unmigrated-input census
|
||
|
||
Tree: `/home/swung/w7/pipe` @ `a29807cc` (feat/disaggregated, P4a landed). READ-ONLY survey; nothing
|
||
was built, compiled or run. Every claim below is `file:line` at that commit. Where I am inferring
|
||
rather than reading, the sentence says **guess**.
|
||
|
||
---
|
||
|
||
## 0. The one-paragraph answer
|
||
|
||
`PipeInputs` is a 63-field block the *client* fills at every verb boundary and the *backends* read
|
||
through `MGB_CTX->`. The poison that backs the P5 gate is real, loud and already wired
|
||
(`MobileGL/MG_Pipe/generated/PipeFilled.inc:407-416`), but **only the client stamps it**
|
||
(`MobileGL/MG_Impl/Pipe/PipeFill.cpp:306`, `MGPipeFillAccess`), and the applier **deliberately does
|
||
not** (`MobileGL/MG_Backend/MGPipe/PipeInputs.h:613-618`). So on a split server — which does not link
|
||
`MG_Impl` — `CurrentVerbSerial` stays 0, every `FilledGen[]` stays 0, `MGPipeInputFieldIsFresh`
|
||
returns false for everything, and **the first accessor read of any field is
|
||
`Fatal{UnmigratedPipeInput, "<Field>@<none>"}`**. Making that gate mean something (fire on genuinely
|
||
unmigrated fields, not on all 63) is the single largest hidden item in P5. 21 of the 63 fields are
|
||
genuinely unserviceable by any pushed record on the reduced path; §3 is that list.
|
||
|
||
---
|
||
|
||
## 1. What `PipeInputs.h` is, how big, how filled, and the poison mechanism
|
||
|
||
### 1.1 The file
|
||
|
||
`MobileGL/MG_Backend/MGPipe/PipeInputs.h` (736 lines) + `PipeInputs.cpp` (179 lines).
|
||
`PipeInputs.cpp` is compiled **only under `MOBILEGL_PIPE_PUSH`** (`PipeInputs.cpp:11-13`).
|
||
The struct is `struct PipeInputs` (`:158`), the single global is
|
||
`inline PipeInputs& gPipeInputs = *new PipeInputs();` (`:706`, and see §5 for why it is a `new`).
|
||
|
||
The switch that routes backend reads is `MobileGL/MG_Pipe/PipeInputsSwitch.h`:
|
||
|
||
```
|
||
#if MOBILEGL_PIPE_PUSH
|
||
#define MGB_CTX (&::MobileGL::MG_Pipe::gPipeInputs)
|
||
#define MGB_CTX_LIVE (::MobileGL::MG_Pipe::gPipeInputs.IsLive())
|
||
#define MGB_CTX_IDENTITY (::MobileGL::MG_Pipe::gPipeInputs.ContextIdentity())
|
||
#else
|
||
#define MGB_CTX (::MobileGL::MG_State::pGLContext) // pull arm
|
||
...
|
||
```
|
||
|
||
Purity gate C (`grep -c pGLContext MG_Backend/` == 0) is **already effectively green**: the only hit
|
||
in `MG_Backend/` at `a29807cc` is a comment, `PipeInputs.h:693`. One hit, zero code.
|
||
|
||
### 1.2 Field count and classes
|
||
|
||
`kMGPipeInputFieldCount == 63` (`MobileGL/MG_Pipe/generated/PipeFilled.inc:96`, `static_assert`).
|
||
Note: `ARCHITECTURE.md:83` still says "61 个" for G5 — **that number is stale**; the generated
|
||
assertion says 63 and `ROADMAP.md`'s P1 row says 63.
|
||
|
||
Three storage classes, documented at `PipeInputs.h:139-157`:
|
||
|
||
| class | count | storage | notes |
|
||
|---|---|---|---|
|
||
| **V** value | 47 | copied out of `GLContext` by calling the *same* accessor at fill time | plain POD mirrors, `PipeInputs.h:628-675` |
|
||
| **O** object reference | 9 | `SharedPtr<>` or a raw pointer **into the live GLContext** | `PipeInputs.h:677-686`; this is what a payload can never carry |
|
||
| **F** forwarded | 7 | none — defined out-of-line in `MG_Impl/Pipe/PipeFill.cpp` (client side) | `PipeInputs.h:558-577`; sticky |
|
||
|
||
`MGP_INPUT_STORAGE_LIST` (`PipeInputs.h:73-129`) is 56 rows = V+O; +7 F = 63, asserted at
|
||
`PipeInputs.h:710-711`. `sizeof(PipeInputs) < 20 KiB` asserted at `:714`.
|
||
|
||
The **9 O-class fields** (`PipeInputs.h:477-556` accessors, `:678-686` storage) are the ones P5 has to
|
||
care about first:
|
||
|
||
```
|
||
GetBoundVertexArray SharedPtr<VertexArrayObject>
|
||
GetBufferBindingSlot BindingSlot<BufferObject>* [kBufferTargetCount]
|
||
GetBufferBindingPoint BindingSlotRange1D<BufferObject>* [kBufferTargetCount]
|
||
GetFramebufferBindingSlot BindingSlot<FramebufferObject>* [kFramebufferTargetCount]
|
||
GetImageTextureBinding ImageTextureBinding* (base pointer)
|
||
GetProgramForDispatch SharedPtr<ProgramObject>
|
||
GetProgramForDraw SharedPtr<ProgramObject>
|
||
GetTransformFeedbackProgram SharedPtr<ProgramObject>
|
||
GetTextureUnitObject TextureUnit* (base pointer)
|
||
```
|
||
|
||
The **7 F-class = the 7 sticky fields** (`PipeInputs.h:569-577`; the identity is asserted, not tested,
|
||
at `PipeInputs.h:135-137`; argued in `Coverage.def:138-150`):
|
||
|
||
```
|
||
GetBufferBindingPointCount(BufferTarget) HasOpenTransformFeedbackSpan(Uint64)
|
||
GetProgramObject(Uint) InvalidateCompileEnv() [reverse channel]
|
||
GetTextureObject(Uint) ValidateProgramName(Uint)
|
||
RecordError(ErrorCode, UniquePtr<ErrorInfo>) [reverse channel]
|
||
```
|
||
|
||
F-class accessors carry **no** `MGP_INPUT_CHECK` and **no** verify read-hook — the declared exception,
|
||
argued at `PipeInputs.h:563-568` (`InvalidateCompileEnv` is reached from backend init before any verb
|
||
has filled, where a check would fatal on every start). So the poison cannot protect these seven; in
|
||
split they must become handle tables / callbacks, and a wrong answer is silent.
|
||
|
||
### 1.3 The per-verb fill points
|
||
|
||
The single fill/validate entry is `MGPipeValidateForVerb(MGPipeVerb)`
|
||
(`MobileGL/MG_Impl/Pipe/PipeFill.h:35`), spelled at 83 statements over 69 verbs via
|
||
`#define MGP_FILL(Verb)` (`PipeFill.h:141`). Its five ordered steps are documented at
|
||
`PipeFill.h:21-29`: bump serial → tracker dirty walk → emit the P2/P3a/P4a calls for set bits →
|
||
**P1 residual fill for every field an emitted call did NOT supply, stamping each with the new
|
||
serial** → (verify build) entry compare.
|
||
|
||
The verb set *is* `MG_Backend::GLFunctionsTable`'s member list in declaration order, refused by
|
||
`gen_pipe.py` if it drifts (`FillPoints.def:16-22`). 69 verbs, 9 classes
|
||
(`FillPoints.def:152-154`, `generated/PipeFillPoints.inc:183` asserts 9). The may-read table is
|
||
`MGP_FILL_FIELD_LIST` (`FillPoints.def:157-339`), compiled to
|
||
`kMGPipeClassFieldMask[9]` (`generated/PipeFillPoints.inc:279-297`):
|
||
|
||
| class | fields (own + 7 sticky) |
|
||
|---|---|
|
||
| kDraw | 54 (47 + 7) |
|
||
| kDispatch | 22 (15 + 7) |
|
||
| kClear | 25 (18 + 7) |
|
||
| kBlitOrCopy | 29 (22 + 7) |
|
||
| kTextureOp | 17 (10 + 7) |
|
||
| kReadback | 24 (17 + 7) |
|
||
| kXfbSpan | 15 (8 + 7) |
|
||
| kProgramOp | 18 (11 + 7) |
|
||
| kQuery | 8 (1 + 7) |
|
||
|
||
Eight rows of that table are deliberate static over-approximations, all KEPT, each argued at
|
||
`FillPoints.def:28-56` (depth/stencil readback emulation pausing XFB; Magma's `VkClearManager`
|
||
reading `GL_FRAMEBUFFER_SRGB` from `GenerateMipmap`/`PrepareStorageImageTextures`; Magma's
|
||
`TryBlitToDefaultFramebufferWithShader` being a real draw). **P5 must not "tidy" these**: the rule
|
||
there is that removing a row on desktop-corpus evidence turns a rare path into a shipped-build Fatal.
|
||
|
||
### 1.4 The poison / generation mechanism (P1's per-verb generation poison)
|
||
|
||
```
|
||
MOBILEGL_PIPE_POISON == MOBILEGL_PIPE_PUSH && ( LOG<=DEBUG || MOBILEGL_BUILD_DISAGGREGATED
|
||
|| MOBILEGL_PIPE_VERIFY )
|
||
```
|
||
`PipeInputs.h:21-26`. **A disaggregated build arms the poison by construction** — that is the
|
||
mechanism behind the P5 exit gate, and it needs no new switch.
|
||
|
||
- State: `struct MGPipeFilledState { Uint64 CurrentVerbSerial; Uint64 FilledGen[63]; }`
|
||
(`generated/PipeFilled.inc:404-406`), held as `PipeInputs::m_filled` (`PipeInputs.h:625`, only
|
||
under `MOBILEGL_PIPE_POISON`).
|
||
- Freshness: `MGPipeInputFieldIsFresh` (`generated/PipeFilled.inc:418-426`) —
|
||
`gen == 0` ⇒ **not fresh** (the "`@<none>`" case, argued in the comment at `:415-417`);
|
||
otherwise fresh iff **sticky** or `gen == CurrentVerbSerial`. It is a *generation*, not a bitmap,
|
||
precisely to catch "filled by the previous draw, read by the following `glTexSubImage`"
|
||
(`generated/PipeFilled.inc:19-23`, `ARCHITECTURE.md:357`).
|
||
- Check: `MGP_INPUT_CHECK(Field)` (`PipeInputs.h:44-49`) on **every non-forwarded accessor**, ahead
|
||
of `MGP_INPUT_VERIFY_READ` and the load.
|
||
- Five accessors additionally poison on a *structurally* impossible argument, with an `MGLOG_E`
|
||
naming the argument first: `IsCapabilityEnabledIndexed` (`:461-463`), `GetBufferBindingSlot`
|
||
(`:489-492`), `GetBufferBindingPoint` (`:499-503`), `GetFramebufferBindingSlot` (`:512-515`),
|
||
`GetImageTextureBinding` (`:521-523`, `:529-531`), `GetTextureUnitObject` (`:552-554`).
|
||
- **Who stamps**: `MGPipeFillAccess`, i.e. `MG_Impl/Pipe/PipeFill.cpp` only
|
||
(`PipeInputs.h:609-611` names it; `PipeFill.cpp:306` is `SetVerb`). Grep for writers of
|
||
`m_currentVerb` / `m_filled` outside `MG_Test` finds nothing else.
|
||
- **Who does NOT stamp**: `MGPipeApplyAccess` (`MG_Pipe/PipeApply.cpp:176`), the applier's door into
|
||
the same block. `PipeInputs.h:612-618`: *"It deliberately does NOT stamp the poison generations —
|
||
a stamp says 'the filler published this for THIS verb', which is the walk's statement, not the
|
||
applier's."* The applier writes `m_renderState`, `m_pixelStore[0]`, `m_capability`,
|
||
`m_currentVertexAttribute`, the render-state versions and the patch fields
|
||
(`PipeApply.cpp:177-184`, `:1338-1437`), and derives the rest of the render-state mirrors through
|
||
`MGPipeDeriveRenderStateFields` (`PipeApply.h:1084`, `PipeApply.cpp:2157`).
|
||
|
||
Negative controls already exist: `MGPipeSetPoisonOmission(verb, field)` / `MOBILEGL_PIPE_POISON_OMIT`
|
||
(`PipeFill.h:103-109`, `Config.h:373`), pinned by
|
||
`MG_IntegrationTest/Scenarios/PoisonOmissionScenario.cpp:88` and
|
||
`MG_Test/Pipe/PipeInputsTest.cpp:93,292-296`.
|
||
|
||
---
|
||
|
||
## 2. THE CENSUS at `a29807cc`
|
||
|
||
### 2.1 Two censuses, and they answer different questions
|
||
|
||
**(a) `MGB_CTX->` read sites** — what the backends textually read. Recursive counts
|
||
(`MobileGL/MG_Backend/`, note `DirectVulkan/Renderer/` is a third level and a shallow glob misses it):
|
||
|
||
| | arrow reads | `MGB_CTX_LIVE` | `MGB_CTX_IDENTITY` |
|
||
|---|---|---|---|
|
||
| Espryt `DirectGLES/` | **117** | 8 | 1 |
|
||
| Magma `DirectVulkan/` | **165** | 49 | 0 |
|
||
| total | **282** | 57 | 1 |
|
||
|
||
per file: `DirectGLES.cpp` 98, `Managers.cpp` 23, `MultiDraw.cpp` 5, `Utils.cpp` 2,
|
||
`DirectVulkan.cpp` 47, `BackendObject_DirectVulkan.cpp` 4, `Renderer/UniformManager.cpp` 23,
|
||
`Renderer/VulkanRenderer.cpp` 130, `Renderer/VkRenderPassManager.cpp` 3,
|
||
`Renderer/VkTextureManager.cpp` 2, `Renderer/VkClearManager.cpp` 1.
|
||
|
||
Split by class:
|
||
|
||
| | O-class | F-class | V-class | total |
|
||
|---|---|---|---|---|
|
||
| Espryt | **60** | 7 | 50 | 117 |
|
||
| Magma | **52** | 12 | 101 | 165 |
|
||
|
||
**This count under-reports reachability.** Espryt funnels several fields through helpers, so one
|
||
`MGB_CTX->` site serves many call sites:
|
||
- `GetFramebufferBindingSlotChecked` (`DirectGLES/DirectGLES.cpp:173`) wraps
|
||
`MGB_CTX->GetFramebufferBindingSlot` and has **8** call sites: `:2077 :2236 :2844 :2995 :3106
|
||
:4175 :4357 :4447`.
|
||
- `CaptureDrawTextureSyncKeys` (`DirectGLES.cpp:2019`) reads `GetTextureContextId` `:2021`,
|
||
`GetMaxTouchedTextureUnit` `:2034`, `GetSamplingResolutionGeneration` `:2035`, and
|
||
`CurrentUnitBindingsEpoch` (`:1875`) reads `GetTextureContextId` `:1904` +
|
||
`GetTextureBindGeneration` `:1905`.
|
||
The poison fires at the accessor either way, so the Fatal still names the right field — but a P5
|
||
brief that sizes work off "60 Espryt O-class sites" will undercount.
|
||
|
||
**(b) The field census** — what no pushed record can supply. This is the one that matters, because
|
||
the applier fills `PipeInputs` from records and everything else has to come from somewhere.
|
||
|
||
From `generated/PipeFilled.inc:336-402` (`kMGPipeFieldEmittedBy`, `kMGPipeEmittedFieldCount = 40`)
|
||
and `MG_Impl/Pipe/PipeFill.cpp:1924-1939` (`EmittedCallSuppliesTheWholeField`):
|
||
|
||
* **23 fields have NO emitter at all** (`kNone`): `GetActiveTextureUnit`,
|
||
`GetBoundTransformFeedbackName`, `GetBufferBindingSlot`, `GetBufferBindingPoint`,
|
||
`GetBufferBindingPointCount`\*, `GetTouchedBufferBindingPointCount`, `GetPixelStoreParameters`,
|
||
`GetProgramObject`\*, `GetSamplingResolutionGeneration`, `GetTextureBindGeneration`,
|
||
`GetTextureContextId`, `GetTextureObject`\*, `GetTransformFeedbackCapturedVertices`,
|
||
`GetTransformFeedbackGeneration`, `GetTransformFeedbackPausedPrimitiveCounter`,
|
||
`GetTransformFeedbackProgram`, `IsTransformFeedbackActive`, `IsTransformFeedbackPaused`,
|
||
`InvalidateCompileEnv`\*, `ValidateProgramName`\*, `RecordError`\*,
|
||
`GetBoundTransformFeedbackLifetimeId`, `HasOpenTransformFeedbackSpan`\* (\* = the 7 sticky F).
|
||
* **9 fields are emitted but STILL PULLED** — `EmittedCallSuppliesTheWholeField` returns false
|
||
(`PipeFill.cpp:1924-1939`, reasons at `:1875-1923`): `GetPixelStoreParameters` (only the PACK half
|
||
has a carrier, D5/D10), `GetCurrentVertexAttribute` (the applier cannot reproduce GLContext's
|
||
cross-view conversion), `GetBoundVertexArray`, `GetFramebufferBindingSlot`,
|
||
`GetImageTextureBinding`, `GetTextureUnitObject`, `GetProgramForDraw`, `GetProgramForDispatch`
|
||
(all six: *the storage is a frontend heap reference and the record carries an 8-byte
|
||
`{slot, gen}`*), `GetMaxTouchedTextureUnit` (the set is hash-suppressed while the high-water mark
|
||
still moves).
|
||
|
||
Union, de-duplicating `GetPixelStoreParameters`: **31 of 63 fields are not served by any pushed
|
||
record** — 24 V/O + the 7 sticky F. Only 32 fields (render state, dynamic, patch, attrib defaults,
|
||
pixel-pack half) are genuinely applier-supplied today.
|
||
|
||
### 2.2 The census table — by site, backend, what it reads, owner
|
||
|
||
O/F sites only (the V-class ones are all applier-supplied except the ones in §3). "owner" = the phase
|
||
whose row in `ROADMAP.md` retires it.
|
||
|
||
| site | backend | reads | owner |
|
||
|---|---|---|---|
|
||
| `DirectGLES/DirectGLES.cpp:4486` `PrepareForDraw` | Espryt | `GetBoundVertexArray` — **unconditional, every draw** | P8 (`PipeFill.cpp:1902-1905`: "what retires the pull is P8") |
|
||
| `DirectGLES.cpp:4497` `PrepareForDraw` | Espryt | `GetProgramForDraw` — **unconditional, every draw** | P3b/P4b→P8 |
|
||
| `DirectGLES.cpp:6287` `DrawArrays`, `:6097` `BoundElementArrayBuffer`, `:6326` MultiDrawArrays, `:1507` `SyncCurrentVertexAttributeValues`, `MultiDraw.cpp:96` | Espryt | `GetBoundVertexArray` | P8 |
|
||
| `DirectGLES.cpp:2995` `SyncCurrentFBO` (via `GetFramebufferBindingSlotChecked`) | Espryt | `GetFramebufferBindingSlot` → `.GetBoundObject()` handed to `SyncToBackend` — **labelled "MONOLITH GLUE" at `DirectGLES.cpp:2961`** | P3b/P4b |
|
||
| `DirectGLES.cpp:4357` `BindCurrentFBO`, `:4447` `ForceBindCurrentFBO`, `:2077 :2236 :2844 :3106 :4175` | Espryt | `GetFramebufferBindingSlot` | P3b/P4b |
|
||
| `Managers.cpp:8603` `GetReadColorAttachment`, `:8966` `IsFixedPointFallbackReadAttachment` | Espryt | `GetFramebufferBindingSlot(Read)` | P3b/P4b |
|
||
| `DirectGLES.cpp:1702 :1730 :1765 :1778` (`CaptureUnitBindings`/`UnitBindingsUnchanged` ×2 arms), `:2205` `SyncNeccessaryTextures`, `:4577 :4863 :5262`, `:7847 :8529 :8624 :8770 :11049` | Espryt | `GetTextureUnitObject` (13) | P3b/P4b (`g_unitTextureSyncList` epoch row) |
|
||
| `DirectGLES.cpp:2475` `SyncImageTextureBinding`, `:2592`, `Managers.cpp:10011` | Espryt | `GetImageTextureBinding` | P3b/P4b |
|
||
| `DirectGLES.cpp:627` `SyncBoundBuffer`, `:359 :905`, `:6397 :6428 :6429 :6499 :6530 :6531 :6703 :6744`, `:9407 :10389 :10626 :10936 :11362`, `Utils.cpp:2298`, `MultiDraw.cpp:88` | Espryt | `GetBufferBindingSlot` (18) — PixelPack / DrawIndirect / Parameter / DispatchIndirect / transfer targets, the 7 of 15 `BufferTarget`s **no call covers** (`Coverage.def:37-70`) | P8 (indirect), P9 (readback), P13 (transfer) |
|
||
| `DirectGLES.cpp:468 :527 :563 :586 :1250 :5164` | Espryt | `GetBufferBindingPoint` | P3b/P4b + P7 |
|
||
| `DirectGLES.cpp:1230` `StartPendingTransformFeedback` | Espryt | `GetTransformFeedbackProgram` | P3b/P4b (XFB scatter to client) |
|
||
| `DirectGLES.cpp:5779` `PrepareForCompute` | Espryt | `GetProgramForDispatch` | P3b/P4b |
|
||
| `DirectGLES.cpp:5805 :5810`, `:9202 :9203` (`ShaderStorageBlockBinding`) | Espryt | `ValidateProgramName` + `GetProgramObject` (F, sticky) | P5/P9 — these must become `kClientResolved`, ARCHITECTURE §3.2 "显式不移植" |
|
||
| `DirectGLES.cpp:8123`, `Managers.cpp:12812` | Espryt | `RecordError` (F, reverse channel) | P9 (`OnGlError`, ordered) |
|
||
| `DirectGLES.cpp:579` `SyncAtomicCounterBuffers` | Espryt | `GetBufferBindingPointCount` (F, sticky) | P7/P13 |
|
||
| `Managers.cpp:2656-2674` `IsBufferDrawCleanByHandle` | Espryt | **not via `MGB_CTX`** — a `const BufferObject*` parameter, `IsMapped()`. Comment: *"The frontend read retires the moment **P5** gives `HasLiveHostWrites` a producer, and it is the last frontend read in this function"* | **P5** |
|
||
| `Managers.cpp:2850-2862` `EnsureBufferResourceForHandle` | Espryt | **not via `MGB_CTX`** — `bufferObject->HasDefinedContent()`; *"retires the moment the client publishes a live content flag beside the descriptor (P5/P8)"* | **P5**/P8 |
|
||
| `Managers.cpp:7700`, `:9268`, `:12107`, `:12716`, `Managers.h:895`, `:2687`, `SlotTables.h:74`, `:258` | Espryt | eight more sites explicitly labelled "MONOLITH GLUE" — handle minted from a frontend object/lifetime id *inside* `MG_Backend` | P3b/P4b, P13 |
|
||
| `Renderer/VulkanRenderer.cpp:3084 :5413 :5633 :6263 :6368 :6748 :7551 :7919 :8877 :8878 :9513 :10224`, `Renderer/UniformManager.cpp:556` | Magma | `GetFramebufferBindingSlot` (13) | **P7** |
|
||
| `VulkanRenderer.cpp:7423 :10979 :12397 :12403 :12498 :12568`, `DirectVulkan.cpp:279 :403 :466 :534 :587` | Magma | `GetBufferBindingSlot` (11) | **P7** |
|
||
| `UniformManager.cpp:507 :783 :822 :848 :1663`, `VulkanRenderer.cpp:9505 :11010 :11254` | Magma | `GetTextureUnitObject` (8) | **P7** |
|
||
| `VulkanRenderer.cpp:6349 :6755 :12387 :12488`, `DirectVulkan.cpp:787 :911` | Magma | `GetBoundVertexArray` (6) | **P7** |
|
||
| `UniformManager.cpp:1017 :1296 :1851 :1939` | Magma | `GetImageTextureBinding` (4) | **P7** |
|
||
| `VulkanRenderer.cpp:6287 :6718 :6756` | Magma | `GetProgramForDraw` (3) | **P7** |
|
||
| `UniformManager.cpp:1195 :2019`, `VulkanRenderer.cpp:11607` | Magma | `GetBufferBindingPoint` (3) | **P7** |
|
||
| `VulkanRenderer.cpp:11568 :11661` | Magma | `GetTransformFeedbackProgram` (2) | **P7** |
|
||
| `VulkanRenderer.cpp:7327 :7379` | Magma | `GetProgramForDispatch` (2) | **P7** |
|
||
| `VulkanRenderer.cpp:1339 :1343 :1399`, `DirectVulkan.cpp:717` | Magma | `RecordError` (F) | P9 |
|
||
| `BackendObject_DirectVulkan.cpp:390 :788` | Magma | `InvalidateCompileEnv` (F) | P9 (`OnCapsInvalidated`) |
|
||
| `UniformManager.cpp:1190 :2014` | Magma | `GetBufferBindingPointCount` (F) | P7 |
|
||
| `VkTextureManager.cpp:810` | Magma | `GetTextureObject` (F, by GL name) | P7 |
|
||
| `VulkanRenderer.cpp:11527` | Magma | `HasOpenTransformFeedbackSpan` (F) | P7/P9 |
|
||
| `DirectVulkan.cpp:271 :274` | Magma | `ValidateProgramName` + `GetProgramObject` (F) | P7 |
|
||
|
||
Coverage.def's own arithmetic, for cross-checking a brief:
|
||
`generated/PipeCoverage.inc:98-104` — 477 inventory read points = 299 → call + 5 client-resolved +
|
||
6 reverse-channel + **167 structural handle** + 0 UNMAPPED. Coverage.def:16 says UNMAPPED becomes a
|
||
**hard zero gate from P5 onward** — it is already 0, so that half of the gate is free.
|
||
|
||
`MGPipeUnmigratedEmulation` (declared `MG_Pipe/PipeApply.h:1068`, monolith body
|
||
`MG_Pipe/PipeApply.cpp:2820` = `(void)name;`) has **five** call sites, not the six the P4a ROADMAP row
|
||
claims ("`Managers.cpp` 2 处、`DirectGLES.cpp` 4 处" — `Managers.cpp:5287` is a *comment*, not a call):
|
||
|
||
```
|
||
DirectGLES/Managers.cpp:5334 "texture-remint-pull"
|
||
DirectGLES/DirectGLES.cpp:8051 "generate-mipmap-storage"
|
||
DirectGLES/DirectGLES.cpp:8702 "generate-mipmap-cpu-fallback"
|
||
DirectGLES/DirectGLES.cpp:8997 "copy-image-shadow-mirror"
|
||
DirectGLES/DirectGLES.cpp:10623 "get-tex-image-shadow"
|
||
```
|
||
`PipeApply.cpp:2812-2817` and `PipeApply.h:1055-1066` both say in so many words: **"P5 and P8 give it
|
||
teeth by editing one function instead of rediscovering five call sites."** The list is pinned by
|
||
`MG_Test/Pipe/PipeCatalogueTest.cpp:923-959`
|
||
(`EveryUnmigratedEmulationIsNamedOnce`). None of the five is on the reduced path (§3).
|
||
|
||
---
|
||
|
||
## 3. **The most important answer: what a SPLIT reduced path actually hits**
|
||
|
||
Reduced path = `glClear` (class `kClear`) + a triangle (`kDraw`) + `glReadPixels` (`kReadback`),
|
||
then the OpenRA trace (adds `kBlitOrCopy`, `kTextureOp`, `kProgramOp`).
|
||
|
||
Intersect each class's may-read mask (`FillPoints.def:157-339`) with §2.1(b)'s
|
||
"no record supplies it" set. **These are the fields P5 must either migrate or Fatal on:**
|
||
|
||
### kClear — 7 of its 18 own fields
|
||
`GetFramebufferBindingSlot`, `GetTextureUnitObject`, `GetImageTextureBinding`,
|
||
`GetTextureContextId`, `GetSamplingResolutionGeneration`, `GetTextureBindGeneration`,
|
||
`GetMaxTouchedTextureUnit`.
|
||
The other 11 (`GetRenderStateParameters/Version`, `GetViewport`, `IsCapabilityEnabled`,
|
||
`GetClearColor/Depth/Stencil`, `GetScissorBox`, `GetColorMaskIndexed`, `GetDepthMask`,
|
||
`GetStencilState`) are applier-supplied today. Espryt's `Clear` is `DirectGLES.cpp:5828`; it calls
|
||
`SyncNeccessaryTextures()` (`:2313` → `CaptureDrawTextureSyncKeys` `:2019`), `SyncCurrentFBO()`
|
||
(`:3084`), `SyncRenderState`, `BindCurrentFBO(Draw)` (`:4303`).
|
||
|
||
### kDraw — **19 of its 47 own fields**
|
||
`GetBoundVertexArray`, `GetProgramForDraw`, `GetBufferBindingSlot`, `GetBufferBindingPoint`,
|
||
`GetTouchedBufferBindingPointCount`, `GetTextureUnitObject`, `GetTextureContextId`,
|
||
`GetTextureBindGeneration`, `GetMaxTouchedTextureUnit`, `GetSamplingResolutionGeneration`,
|
||
`GetImageTextureBinding`, `GetCurrentVertexAttribute`, `GetFramebufferBindingSlot`,
|
||
`IsTransformFeedbackActive`, `IsTransformFeedbackPaused`, `GetTransformFeedbackProgram`,
|
||
`GetTransformFeedbackGeneration`, `GetBoundTransformFeedbackLifetimeId`,
|
||
`GetTransformFeedbackCapturedVertices`.
|
||
The remaining 28 are render-state/dynamic/patch — applier-supplied.
|
||
|
||
### kReadback — 12 of its 17 own fields
|
||
`GetPixelStoreParameters`\*, `GetBufferBindingSlot`, `GetFramebufferBindingSlot`,
|
||
`GetActiveTextureUnit`, `GetTextureUnitObject`, `GetTextureContextId`,
|
||
`GetSamplingResolutionGeneration`, `GetTextureBindGeneration`, `GetMaxTouchedTextureUnit`,
|
||
`GetImageTextureBinding`, `IsTransformFeedbackActive`, `IsTransformFeedbackPaused`.
|
||
Supplied: `GetClampReadColor`, `IsCapabilityEnabled`, `GetRenderStateParameters/Version`,
|
||
`GetViewport`.
|
||
|
||
\* **Two readings of `GetPixelStoreParameters`, and they differ.** (a) The field is
|
||
`m_pixelStore[2]` and only `[0]` (pack) has a carrier, so the *field* is unmigrated —
|
||
that is why it is absent from `MGP_COVERAGE_EMITTED_LIST` (`Coverage.def:172-181`) *and* false in
|
||
`EmittedCallSuppliesTheWholeField` (`PipeFill.cpp:1877-1881`). (b) A readback only ever reads the
|
||
pack half, which the applier does write (`PipeApply.cpp:1373`), so a split readback is materially
|
||
served. **What settles it:** whether any `MGB_CTX->GetPixelStoreParameters(...)` on the readback path
|
||
passes `isUnpack == true`. The five Espryt sites are `DirectGLES.cpp:7924` (`~ScopedPackState`),
|
||
`:9399`, `:10893`, `:11272`, `Utils.cpp:2302` — read the argument at each. My **guess** is all-pack,
|
||
i.e. reading (b), but the poison is per-field so it will Fatal under (a)'s rules regardless: **P5
|
||
either splits the field into pack/unpack or teaches the server stamper to stamp it.**
|
||
|
||
### **Union across the three = 21 distinct fields**
|
||
```
|
||
GetActiveTextureUnit GetPixelStoreParameters GetTextureUnitObject
|
||
GetBoundVertexArray GetProgramForDraw GetTransformFeedbackCapturedVertices
|
||
GetBufferBindingSlot GetSamplingResolutionGeneration GetTransformFeedbackGeneration
|
||
GetBufferBindingPoint GetTextureBindGeneration GetTransformFeedbackProgram
|
||
GetTouchedBufferBindingPointCount GetTextureContextId GetBoundTransformFeedbackLifetimeId
|
||
GetCurrentVertexAttribute GetMaxTouchedTextureUnit IsTransformFeedbackActive
|
||
GetFramebufferBindingSlot GetImageTextureBinding IsTransformFeedbackPaused
|
||
```
|
||
plus, of the 7 sticky F, `RecordError` (reachable from any error) and — on Magma only —
|
||
`InvalidateCompileEnv` at init. Only 3 of the 24 non-sticky unmigrated fields are **off** the reduced
|
||
path: `GetBoundTransformFeedbackName` (dead — `PipeInputs.h:232-234`, read by no backend since D21),
|
||
`GetTransformFeedbackPausedPrimitiveCounter` (`kQuery` only), `GetProgramForDispatch`
|
||
(`kDispatch` only).
|
||
|
||
### Concrete blockers the reduced path hits, ranked
|
||
|
||
1. **Nothing stamps anything on the server.** See §0. Until P5 gives the applier (or a server-side
|
||
verb boundary) a stamper, `Fatal{…@<none>}` fires on the first read of `GetRenderStateParameters`
|
||
inside `SyncRenderState` — i.e. before the interesting cases. **This is the gate's own
|
||
prerequisite and it is not in the ROADMAP P5 row.**
|
||
2. **`PrepareForDraw` reads two pointers unconditionally** — `DirectGLES.cpp:4486`
|
||
(`GetBoundVertexArray`) and `:4497` (`GetProgramForDraw`). No `#if`, no arm guard, no record
|
||
fallback. Every triangle in split hits both. `PipeFill.cpp:1897-1908` says outright the pull is
|
||
retired by P8, not P5 — so **P5's only options are a server-side substitute or a Fatal**, and a
|
||
Fatal here means no split triangle, which is the exit gate. This is the phase's sharpest tension.
|
||
3. **`SyncCurrentFBO` is self-declared monolith glue.** `DirectGLES.cpp:2961-2965`: even on the handle
|
||
arm, the twin's `SyncToBackend` still takes the frontend `SharedPtr<FramebufferObject>`, obtained
|
||
at `:2995` via `GetFramebufferBindingSlotChecked`. Clear *and* readback both go through it.
|
||
Contrast `BindCurrentFBO` (`:4303-4353`), which **does** return early from the record when
|
||
`FramebufferSubsystemEnabled() && g_fboRecordsTrusted` and never reaches `:4357` — so the *bind*
|
||
is already split-clean, the *sync* is not.
|
||
4. **`IsBufferDrawCleanByHandle` needs `HasLiveHostWrites` to have a producer** —
|
||
`Managers.cpp:2656`, `Managers.h:911-913`, `PipeApply.cpp:839-845`, `:1905`, `PipeApply.h:225`.
|
||
The field exists and is asserted pinned-false (`Managers.cpp:2671-2672`). ROADMAP's P5 bullet
|
||
"client 侧块粒度 persistent-map 推送" **is** this producer; the assert at `:2671` fires the moment
|
||
P5 sets it, which is the intended tripwire (`Managers.cpp:2644-2646`).
|
||
5. **`EnsureBufferResourceForHandle` reads `HasDefinedContent()`** — `Managers.cpp:2860-2862`,
|
||
named P5/P8.
|
||
6. The three texture *shutters* (`GetTextureContextId`, `GetTextureBindGeneration`,
|
||
`GetSamplingResolutionGeneration`) are read on **all three** classes and `Coverage.def:220-224`
|
||
is explicit that no call carries them and none should — *"what replaces them server-side is the
|
||
applier's own `Serial`, which is a different value with a different owner"*. So for P5 these are
|
||
not "migrate the value", they are "the server answers them from its own state". `GetTextureContextId`
|
||
and `GetActiveTextureUnit` are in the same bucket (`Coverage.def:215-219`).
|
||
|
||
### OpenRA trace (the second half of the gate)
|
||
Adds `kBlitOrCopy` (22 own; unmigrated subset adds `GetViewportIndexed`, `GetDepthRangeIndexed`,
|
||
`GetProvokingVertexMode` only if Magma — on Espryt those three are render-state-derived, and all
|
||
three of the `kBlitOrCopy`-specific rows are the Magma shader-blit rows of `FillPoints.def:265-275`),
|
||
`kTextureOp` (10 own, adds nothing new beyond `GetActiveTextureUnit`) and `kProgramOp` (11 own, adds
|
||
nothing new). **So the OpenRA trace does not widen the field set beyond the 21 above** — it widens the
|
||
*site* set, and it is the first thing that reaches `Managers.cpp:8603`/`:8966` (read-attachment) and
|
||
the texture-unit walks with `maxTouchedUnit >= 0`. **Guess**, on the grounds that OpenRA is a
|
||
textured 2D sprite renderer with FBO blits and no compute/XFB; a brief should verify against the
|
||
fixture's actual call set rather than take this on my word.
|
||
|
||
---
|
||
|
||
## 4. What `Fatal{UnmigratedPipeInput}` is today
|
||
|
||
**A real fatal, fully wired, with negative controls — not a stub.**
|
||
|
||
```cpp
|
||
// MobileGL/MG_Pipe/generated/PipeFilled.inc:407-413
|
||
[[noreturn]] inline void MGPipeInputPoisonFatal(MGPipeInputField field, const char* verb) {
|
||
MGLOG_F("MGPipe: Fatal{UnmigratedPipeInput, \"%s@%s\"}",
|
||
kMGPipeInputFieldNames[static_cast<SizeT>(field)], verb);
|
||
std::abort();
|
||
}
|
||
```
|
||
Generated from `scripts/gen_pipe.py:909`. The verb-named wrapper is
|
||
`MGPipeInputPoisonFatalForVerb` (`MG_Backend/MGPipe/PipeInputs.cpp:25-27`), declared
|
||
`PipeInputs.h:32`. `MGLOG_F` + `std::abort()`, **live at every log level on purpose** —
|
||
`PipeInputs.h:29-31` says so explicitly: *"this is not `MOBILEGL_ASSERT`, which is inert in INFO
|
||
builds."*
|
||
|
||
Armed whenever `MOBILEGL_PIPE_POISON` (§1.4), which a disaggregated build turns on for free.
|
||
Existing coverage:
|
||
- `MG_Test/Pipe/PipeInputsTest.cpp:93` (`"…GetActiveTextureUnit@GenerateMipmap"`), `:292-296`
|
||
(`"GetLineWidth@<none>"`), `:576`.
|
||
- `MG_IntegrationTest/Scenarios/PoisonOmissionScenario.cpp:85-88,341` — the negative control: omit
|
||
one stamp, the child must abort with that exact prefix.
|
||
- `MG_IntegrationTest/Scenarios/PipeVerifyArmingScenario.cpp:78`.
|
||
- `MG_Test/ScopedPipeVerb.h:21` — the test-side "I am not inside a verb" helper.
|
||
|
||
**So P5 does not build this.** P5 builds the *server side of the stamp*, which is what turns a
|
||
universal abort into the gate ROADMAP describes. The sibling mechanism for emulations,
|
||
`MGPipeUnmigratedEmulation`, is the reverse: named and greppable but a **no-op today**
|
||
(`PipeApply.cpp:2820`), explicitly waiting for P5/P8 to give it a body.
|
||
|
||
---
|
||
|
||
## 5. The exit-order rule (P3a ID-18/21) and what it implies for a two-role build
|
||
|
||
### The rule
|
||
`~/w7/notes/p3a/INTEGRATOR-DECISIONS.md:215-227` (ID-18) and `:244-251` (ID-21); restated as a
|
||
standing ruling binding every later package at `~/w7/notes/p4a/INTEGRATOR-DECISIONS.md:42-44` (ID-8):
|
||
|
||
> **No frontend destructor may run from an exit handler into pipe/backend state. Every new static
|
||
> holder of frontend `SharedPtr`s is leak-at-exit storage; every new singleton reachable from a
|
||
> destructor is never-destroyed. Prove with `GLIBC_TUNABLES=glibc.malloc.tcache_count=0` on both
|
||
> lanes.**
|
||
|
||
The original defect chain (ID-18): `exit` → `~PipeInputs` (`gPipeInputs` held a
|
||
`SharedPtr<VertexArrayObject>`) → `~VertexArrayObject` → `~BufferObject` →
|
||
`MGPipeEmitResourceDestroyAndFree` → `MGPipeSlotAllocator::FindByLifetimeId` on a hash table already
|
||
freed by `~MGPipeSlotAllocator` (a Meyers singleton constructed at the first buffer, so it dies
|
||
first). Every case ran the chain; only when the freed table still resolved did `Free()` write freed
|
||
vectors and glibc report `double free or corruption` — which is why it was **CI-only** until
|
||
`GLIBC_TUNABLES=glibc.malloc.tcache_count=0` made it deterministic.
|
||
|
||
In the tree today the rule is written out at `MG_Backend/MGPipe/PipeInputs.h:692-706`
|
||
(the 15-line comment above `inline PipeInputs& gPipeInputs = *new PipeInputs();`), and enforced at:
|
||
`MG_Impl/Pipe/PipeFill.cpp:376` (the verify snapshot block), `MG_Impl/Pipe/ProgramEmit.h:477`
|
||
(*"it MUST NOT hold a frontend `SharedPtr`"*), `MG_Impl/Pipe/ImageEmit.h:177`,
|
||
`MG_Impl/Pipe/SamplerEmit.h:1080`, `MG_Test/Pipe/FramebufferEmitTest.cpp:196`,
|
||
`MG_Util/Async/ShaderCompilePool.h:91`, and the pre-existing `Init.cpp:168`.
|
||
|
||
### What it implies for a two-role build
|
||
|
||
1. **The rule doubles.** Today it says "one process, one leak-at-exit set". In split there are two
|
||
role-local singleton sets that must *each* obey it, and they die at different times and for
|
||
different reasons (client `MobileGL::Destroy()`; server EOF-detect + `_exit`). Every new
|
||
`MG_Remote/Client/*` and `MG_Remote/Server/*` singleton — `PipeEmitter`, `EmitTables`,
|
||
`CapsMirror`, `ShadowArena`, `PersistentMapTracker`, `GpuWritePending`, `PipeApplier`,
|
||
`PipeObjectTables`, `ReplyPool`, `EventRing`, `ServerLoop` (the file list is
|
||
`ARCHITECTURE.md:575-576`) — is reachable from a destructor and therefore **never-destroyed by
|
||
the standing ID-8 ruling**, not by a fresh judgement call.
|
||
2. **The server side is the easy half and the client side is not.** The server holds no frontend
|
||
objects at all (that is the whole design), so its tables can be plain never-destroyed singletons.
|
||
The client still holds `gPipeInputs` with its nine O-class members *and* now additionally owns the
|
||
transport, whose teardown is ordered.
|
||
3. **`ARCHITECTURE.md:537` already fixes the teardown order and it is the opposite direction from a
|
||
destructor chain**: *publish + server drains and acks → stop the apply thread → close the
|
||
transport → client drains the compile pool (before `glslang::FinalizeProcess()` and the
|
||
`pGLContext` destructor) → `MobileGL::Destroy()` → release sync/query handles.* Every one of those
|
||
steps is an **explicit** call, not a destructor — which is exactly what ID-18 demands. **P5's job
|
||
is to make sure nothing added in P5 can start a chain that runs *after* step 3**, because after
|
||
the transport is closed a frontend destructor that reaches an emitter has no ring to write to.
|
||
4. **Two new death modes ID-18 never saw**: the server dying first (client reads EOF → device-lost
|
||
latch, `ARCHITECTURE.md:563`) and the client dying first (server reads EOF → destroy native
|
||
context and exit). In both, one side's objects are torn down while the other's are mid-flight. The
|
||
`Doorbell.h` `Kill()` death state (`ARCHITECTURE.md:432`) exists for exactly this, but it is a
|
||
*transport* answer, not an *exit-handler* answer.
|
||
5. **`HeadlessGL`'s fork pre-check is the exit-order trap in the new shape** —
|
||
`ARCHITECTURE.md:556`: it forks a child that runs a full EGL bring-up and `_exit`s, and in split
|
||
that child would spawn an orphan server. The stated rule (server EOF detection immediate and
|
||
unconditional, sub-second; client fd shaped so `_exit` closes it deterministically) is listed as a
|
||
**P6** acceptance item, but P5's `InProcessTransport` arm reaches the same `HeadlessGL` harness
|
||
first. **Guess**: `inproc` has no fork and no orphan, so P5 is safe here and P6 is the right
|
||
owner; a brief should say so explicitly rather than leave it ambiguous.
|
||
6. **The proof recipe is inherited, not new**: `GLIBC_TUNABLES=glibc.malloc.tcache_count=0` on both
|
||
lanes (ID-8, ID-20, ID-21). P3a ran `integration-verify 844/844` and push `integration-gpu
|
||
966/966` under it. P5 should run its new split lane the same way from the first green, because the
|
||
failure is layout-dependent and a clean run without the tunable proves nothing (ID-20 is exactly
|
||
that lesson: *"not a fix, a layout change"*).
|
||
|
||
---
|
||
|
||
## 6. Side findings a brief writer will want
|
||
|
||
- **None of P5's named deliverables exist yet.** `MobileGL/MG_Remote/` at `a29807cc` contains only
|
||
`Protocol/` and `Transport/` (19 files) — **no `Client/`, no `Server/`**.
|
||
`MOBILEGL_TRANSPORT` appears exactly once in the whole source tree, in a comment
|
||
(`MG_Remote/Transport/InProcessTransport.h:19`); there is no `MG_Config::Transport` and no
|
||
`ConfigLoader` parsing. `MobileGL/MG_Backend/Init.cpp` has no disaggregated branch.
|
||
`MOBILEGL_BUILD_DISAGGREGATED_INPROC` is not a CMake option (`CMakeLists.txt:23,28,29,36` are the
|
||
four MGPipe options that do exist). `SPLIT` / `TRACE_TRANSPORT` appear nowhere in
|
||
`CMakeLists.txt`, `tools/` or `scripts/`. `PersistentCoherentMapScenario` does not exist.
|
||
`MGPCaps` the **struct** does exist (`MG_Pipe/MGPipeTypes.h:126`, `PipeCalls.def:80` `GetCaps`),
|
||
but no snapshot machinery.
|
||
- **No `DirectGLES.Split.*Triangle` test exists**, and there is no `Triangle` scenario at all —
|
||
`ClearThenReadPixelsScenario.cpp` is real (`MG_IntegrationTest/Scenarios/`, 5 `TEST_F`s, the
|
||
closest to a triangle being `ADrawIntoTheDefaultFramebufferSurvivesAnEarlierClear` at `:308`).
|
||
Two readings: (a) the gate names two *new* minimal scenarios P5 must author; (b) it means the
|
||
existing `ClearThenReadPixels` suite plus some existing draw test renamed under a `Split.` prefix.
|
||
**What settles it:** whether `add_trace_replay_test`/the ctest registration grows a `Split.` name
|
||
prefix (ARCHITECTURE.md:584 describes the `SPLIT` suffix for *trace* tests, not for ctest scenario
|
||
names). Reading (a) is my **guess**.
|
||
- **`ARCHITECTURE.md:83` is stale**: "PipeInputs 字段 id(61 个)" vs the generated
|
||
`static_assert(kMGPipeInputFieldCount == 63)`.
|
||
- **ROADMAP's P4a row is off by one** on the emulation count: it says 6 sites
|
||
(`Managers.cpp` 2 + `DirectGLES.cpp` 4); there are 5 calls + 1 comment.
|
||
- **`ARCHITECTURE.md:299` names the ack hook P5 inherits**: *"monolith 下 ack 是 `((void)0)`
|
||
(applier 只隔一次函数调用),**P5 把门铃接到这个谓词上**"* — the predicate being
|
||
`MGPipeResourceRespecifyNeedsAck(desc)` (`MG_Pipe/MGPipeTypes.h:680`), narrowed by P4a (D-A2) to
|
||
buffer targets only. That is a one-line P5 wiring item with a test already pinning it
|
||
(`MG_Test/Pipe/PipeCatalogueTest.cpp:552-585`).
|
||
- **`MG_Pipe/PipeApply.h:1034-1038`**: `create_shader_state` passes the artefacts **by pointer**
|
||
beside the record with `Size 0` and does not call the codec — *"Splitting this record for a
|
||
transport whose ring caps one record at half its capacity is P5's problem."* So the program record
|
||
is a P5 chunking item, and `ProgramArtifactsCodec.{h,cpp}` goes hot for the first time
|
||
(`ARCHITECTURE.md:265`). The companion-pointer shape recurs at `PipeApply.h:1052-1053`
|
||
(`set_global_constants` takes `const void* bytes` with `Blob.Size 0`) — **guess**: every
|
||
companion-pointer payload in `PipeApply.h` is a P5 serialisation item; worth a systematic grep for
|
||
`Size 0` / `companion pointer` in that header.
|
||
- **`MG_Impl/Pipe/SamplerEmit.h:432`** is a fourth self-declared "P5's problem" marker.
|
||
- `ARCHITECTURE.md:492` pins `map-persistent-roundtrips` (`mpr`) as *every* `MapPersistent`
|
||
emission, minted or refused (`MG_Impl/Pipe/PipeFill.cpp:736`,
|
||
`MG_Util/Metrics/PipeStats.h:126`), with two existing gates
|
||
(`StorageBufferRegrowScenario.cpp:255`, `LargeArenaAdoptionScenario.cpp:450`). P5's
|
||
`persistent-map-push` counter is the one that is **not yet wired** — `ARCHITECTURE.md:619` lists it
|
||
as "P0 未接线:monolith 期不存在推送".
|