mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-19 07:51:57 +09:00
CONTRACT-P7 §5.4, OQ-10. InitServerRoleCommon computes the whole capability mask and
never ORed this bit, so MGPipeResourceOpsHaveSubDataResident answered false under every
transport and BOTH backends were pinned to the ordered in-place host memcpy - which made
Magma's SubDataResident arm (VkBufferManager.cpp's g_vulkanWireResourceOps) dead code on
the wire even though the arm has been there since P5f.
The bit is derived from g_resourceOpsAtStep2->SubDataResident, i.e. from the pointer this
function already pinned at step 2 and that step 5 already refuses to see swapped - never
from ActiveBackendType. That is ID-39's lesson and not a style preference: a mask is a
statement about THIS backend's registered table, and a bit derived from the enum would
keep claiming the capability for a build, a flavour or a future backend whose table does
not carry the arm.
`rsd=` joins the emit[] bracket on the PipeStats summary line, counted at the emitter once
per buffer_subdata_resident record rather than once per call, because a write past the
content chunk cap is cut into several records. It is the only observable that separates
the resident arm from the memcpy beside it: the bytes in the buffer are identical either
way, which is exactly how the capability stayed unpublished for a phase with every lane
green.
WHAT THIS DOES NOT YET PROVE, and R-6 is the reason rather than an omission. §5.4 asks for
a white-box case showing opcode 49 on the wire. None can exist at this tree: the resident
arm is reached only from a GPU-RESIDENT store, residency comes only from
AdoptPersistentMap, and every persistent-map acquisition declines under split by R-6
(PipeApply.cpp:2331 "A SPLIT BUILD RUNS AT TIER T2 AND DECLINES EVERY ACQUISITION,
ALWAYS"; T0/T1 are P11's and AdoptTierIsEmulate is a named Fatal for them). So the
capability is wired AHEAD of its consumer, deliberately, and `rsd=` is what will show the
records the day P11 lands a tier that adopts. Filed for the integrator in
notes/p7/magma-c.md.
What IS proved is both halves of the bit itself. RemoteClientTest's Magma bootstrap case
now asserts the published bit EQUALS `ops->SubDataResident != nullptr` - the two compared
to each other rather than both to true, so the case also covers a backend without the arm
on the day one exists - and a new CtWireScenario case reads the bit out of the client's
own caps mirror, through the same accessor the frontend reads, on both backends and all
three transports.
RED-ONCE, both levels. Deleting the OR reds
CapsMirrorTest.MagmaTransportPublishesRealBufferConsumersWithoutRunAhead
(RemoteClientTest.cpp:692, "Which is: false / Which is: true") and all SIX arms of
DirectGLES/DirectVulkan x {Split,Spawn,Tcp} Ct.TheServerPublishesTheResidentSubData
CapabilityFromItsOwnTable ("the client's caps mirror did not receive
kCapResidentSubData"). Restored: green.
Also carries the P4a death-helper comment from the previous commit's sweep: it no longer
says Magma installs no death table, because it now does and still frees no slot.
154 lines
9.3 KiB
Markdown
154 lines
9.3 KiB
Markdown
# P7 wave 2 package C — Magma object death, resident sub-data, the reflection archive, the vertex-layout split
|
|
|
|
Base: `p7/magma-c` off `feat/disaggregated @ a686131e` (pipe HEAD at branch time).
|
|
Build: `build-split` = `-DMOBILEGL_BUILD_DISAGGREGATED=ON -DMOBILEGL_BUILD_DISAGGREGATED_INPROC=ON
|
|
-DMOBILEGL_PIPE_PUSH=ON -DMOBILEGL_BUILD_INTEGRATION_TEST=ON`, ICD pinned to
|
|
`/usr/share/vulkan/icd.d/lvp_icd.json` (the same lavapipe ICD `~/w7/pipe/build-split` pins; the
|
|
worktree tool leaves `MOBILEGL_ITEST_VK_ICD` empty and CMake warns about it).
|
|
|
|
Contract rows: CONTRACT-P7 §5.5 (`StateObjectDeathOps`), §5.4 (OQ-10), §5.3 (OQ-8), §3.2
|
|
(`vertex-layout`, `vertex-format-conversion`). Discipline: rule I (no `std::abort()` on a Magma
|
|
wire arm), rule J / R-16 (every fix red once on a two-process arm first).
|
|
|
|
---
|
|
|
|
## Slice 1 — Magma `StateObjectDeathOps` (§5.5)
|
|
|
|
**What landed.** `MG_Backend/DirectVulkan/DirectVulkan.cpp` gains
|
|
`g_magmaStateObjectDeathOps` and `InstallStateObjectDeathOps()`, installed from
|
|
`BackendObject_DirectVulkan::Initialize()` — i.e. from `ServerLoop::CreateBackend`, step 1 of
|
|
`InitServerRoleCommon`, which both Magma server roles (inproc and the spawn/TCP child) run and
|
|
which is before any client session exists. Guarded `#if MOBILEGL_BUILD_DISAGGREGATED &&
|
|
MOBILEGL_PIPE_PUSH`, so the pull build compiles nothing new (G1).
|
|
|
|
**The one arm, and why it is only one.** Espryt's `g_glesStateObjectDeathOps` has two jobs: emit
|
|
the wire `object_death` record off the apply thread, and otherwise destroy a backend twin keyed
|
|
by lifetime id. Magma has no lifetime-id-keyed twin at all — its two client-minted kinds
|
|
(`VertexElementsCso`, `Buffer`) are keyed on `{slot, gen}` by `MagmaPipeIdentityTables` and the
|
|
other six are still reached from their frontend objects — so the Magma table is exactly the EMIT
|
|
arm and nothing else.
|
|
|
|
**Correction to the plan's wording (worth the integrator's attention).** Plan §1.3 and the task
|
|
brief describe the gap as a client SLOT leak provable with `PipeSlotPeek`. It is not, and has not
|
|
been since P4a: `MG_Impl/Pipe/PipeFill.cpp`'s `NotifyAndFree` frees the client slot
|
|
unconditionally and backend-neutrally, so `PipeSlotPeek` never saw a Magma leak and does not see
|
|
a change now. What leaked was the **server's twin**. A framebuffer has no wire delete opcode at
|
|
all (BRIEF-P4A D-I2), so `object_death` is its only death delivery; with no consumer installed
|
|
under Magma inproc, the server's record stayed `Live` for the life of the session. The
|
|
`CtWireScenario` framebuffer case now reads BOTH numbers — the server's `deaths` tally and the
|
|
client's `PipeSlotKind::Framebuffer` live count — so a future regression in either half is
|
|
attributable.
|
|
|
|
**Cleanup of the Magma special cases.** The two executable ones are the `CtWireScenario` skip
|
|
guards (`:153` / `:209`), both deleted. Everything else the audit counted is comment text, and it
|
|
is reworded rather than deleted because the underlying argument survives: `PipeSlotPeek.h`,
|
|
`MagmaPipeArms.h` (the age-sweep-instead-of-death-notice paragraph — still true, because the new
|
|
table never touches the per-renderer identity tables), `PipeMutation.h`, `PipeFill.cpp`,
|
|
`VertexArrayObject.cpp`, `DirectGLES/Managers.cpp`, `HandleRecycleScenario.cpp`,
|
|
`WireTables.cpp`.
|
|
|
|
**The install-order question, answered rather than assumed.** `SetStateObjectDeathOps` is a bare
|
|
last-writer-wins pointer with no stacking, so two installers could in principle race.
|
|
They cannot meet: Magma's runs only in a process that OWNS a DirectVulkan backend, and
|
|
`InstallClientWireTables`' arm runs only under `Transport == Spawn`, which is by construction the
|
|
process that owns no backend (`InitSplitRoles` builds a `BackendObject_Remote` there). The
|
|
red-once below measures exactly that split of responsibility.
|
|
|
|
**Proof (green).** `ctest -R "DirectVulkan\.(Split|Spawn|Tcp)\.Ct\..*Death"` — 6/6 pass
|
|
(`integration-magma-all-{split,spawn,tcp}`), plus the two `TcpServer` fixtures. DirectGLES
|
|
control `ctest -R "DirectGLES\.(Split|Spawn|Tcp)\.Ct\..*Death"` — 6/6 pass, unchanged.
|
|
|
|
**RED-ONCE (executed).** `BackendObject_DirectVulkan::Initialize()`'s call changed to
|
|
`if (false) InstallStateObjectDeathOps();`, rebuilt, lane re-run:
|
|
|
|
```
|
|
1/8 DirectVulkan.Split.Ct.CtWireScenario.TextureDeath... ***Failed
|
|
2/8 DirectVulkan.Spawn.Ct.CtWireScenario.TextureDeath... Passed
|
|
4/8 DirectVulkan.Tcp.Ct.CtWireScenario.TextureDeath... Passed
|
|
5/8 DirectVulkan.Split.Ct.CtWireScenario.FramebufferDeath... ***Failed
|
|
6/8 DirectVulkan.Spawn.Ct.CtWireScenario.FramebufferDeath... Passed
|
|
7/8 DirectVulkan.Tcp.Ct.CtWireScenario.FramebufferDeath... Passed
|
|
75% tests passed, 2 tests failed out of 8
|
|
|
|
CtWireScenario.cpp:264: Failure
|
|
Expected: (afterCounters.deaths) > (deathsBefore), actual: 0 vs 0
|
|
```
|
|
|
|
Restored and rebuilt: 8/8 green again. This is precisely the shape package L's temporary probe
|
|
predicted (`notes/p7/magma-two-process-first-run.md` §6): spawn and tcp were already carried by
|
|
`InstallClientWireTables`' emitter, and **inproc was the only hole** — which is the hole this
|
|
table closes.
|
|
|
|
---
|
|
|
|
## Slice 2 — OQ-10 `kCapResidentSubData` (§5.4)
|
|
|
|
**What landed.** `InitServerRoleCommon` ORs `kCapResidentSubData` when
|
|
`g_resourceOpsAtStep2->SubDataResident != nullptr` — the pointer that function already pinned at
|
|
step 2 and that step 5 already refuses to see swapped. Never from `ActiveBackendType` (ID-39).
|
|
`rsd=` joins the `emit[]` bracket on the PipeStats summary line, counted at
|
|
`MGPipeEmitBufferSubDataResident` once per record. `SplitRuntimePeek` gains
|
|
`residentSubDataCap`, read through the same `CapsMirrorInstance().HasCap()` accessor the
|
|
frontend's `MGPipeResourceOpsHaveSubDataResident` reads.
|
|
|
|
### BLOCKER FOR THE INTEGRATOR: §5.4's white-box case is not achievable at this tree
|
|
|
|
§5.4 asks for a case in `integration-magma-buffers` and one in `integration-split` proving that
|
|
the emitted record is `BufferSubDataResident` (opcode 49). **Neither can exist today, and the
|
|
reason is R-6 rather than anything this package did or did not do.** The chain:
|
|
|
|
| step | site | verdict under split |
|
|
|---|---|---|
|
|
| the resident emitter runs only from a resident store | `BufferObject.cpp` `UploadSubData` → `if (m_resource.IsGpuResident())` | — |
|
|
| residency comes only from `AdoptPersistentMap` | `PipeResource.h:181`, the only writer of `m_gpuMapped` | — |
|
|
| adoption needs a non-null `map_persistent` answer | `BufferObject.cpp` `TryAdoptLargeStorage` / `EnsureGpuResidentStorage` / `AcquireMemoryRange` | — |
|
|
| the answer is a decline | `PipeApply.cpp:2331` "**A SPLIT BUILD RUNS AT TIER T2 AND DECLINES EVERY ACQUISITION, ALWAYS**" | always |
|
|
| the tier gate has no other implemented value | `PersistentMapTracker.cpp:1033` `AdoptTierIsEmulate` — T0/T1 are P11's and are a named `Fatal{UnimplementedAdoptTier}` | always |
|
|
|
|
So under any transport no buffer is ever GPU-resident, `LandBytesIntoResidentStore` is
|
|
unreachable, and opcode 49 cannot cross. The capability is therefore wired **ahead of its
|
|
consumer**, deliberately: when P11 lands a tier that adopts, the bit is already correct and
|
|
already derived from the table, and `rsd=` is the counter that will show the records. The
|
|
plan's phrasing ("both backends fall back to the in-place memcpy at `BufferObject.cpp:~711-716`")
|
|
is one step optimistic — under split the code does not reach that fallback either, it takes the
|
|
plain shadow `Memcpy` in `UploadSubData` above it.
|
|
|
|
**What is proved instead, and it is both halves of the bit.**
|
|
|
|
- *Server half* — `CapsMirrorTest.MagmaTransportPublishesRealBufferConsumersWithoutRunAhead`
|
|
(`RemoteClientTest.cpp`) now asserts
|
|
`(mask & kCapResidentSubData) != 0 == (ops->SubDataResident != nullptr)`. The two sides are
|
|
compared to each other rather than both to `true`, so the case also covers a backend WITHOUT
|
|
the arm on the day one exists.
|
|
- *Client half* — the new `CtWireScenario.TheServerPublishesTheResidentSubDataCapabilityFromIts
|
|
OwnTable`, registered through the `ctCase` list so tier 2 replays it: green on
|
|
`DirectGLES.{Split,Spawn,Tcp}` (`integration-{split,spawn,tcp}`) and
|
|
`DirectVulkan.{Split,Spawn,Tcp}` (`integration-magma-all-*`), 6/6.
|
|
- *Negative half* — `CapsMirrorTest.APlaceholderMirrorConsumesNothing` keeps the
|
|
no-snapshot-withholds-the-bit reading, which stopped being vacuous the moment anything set it.
|
|
|
|
**RED-ONCE (executed, both levels).** `capBits |= MG_Pipe::kCapResidentSubData;` → `capBits |= 0;`:
|
|
|
|
```
|
|
RemoteClientTest.cpp:692: Failure
|
|
Expected equality of these values:
|
|
(server.CallMask() & static_cast<Uint64>(kCapResidentSubData)) != 0
|
|
Which is: false
|
|
Which is: true
|
|
|
|
25% tests passed, 6 tests failed out of 8
|
|
DirectGLES.{Split,Spawn,Tcp}.Ct....ResidentSubDataCapability... ***Failed
|
|
DirectVulkan.{Split,Spawn,Tcp}.Ct....ResidentSubDataCapability... ***Failed
|
|
CtWireScenario.cpp:262: Failure
|
|
Value of: runtime.residentSubDataCap
|
|
Actual: false
|
|
```
|
|
|
|
Restored: 11/11 unit and 6/6 integration green again.
|
|
|
|
**One incidental finding, recorded because it cost a cycle.** The first cut of the capability
|
|
case did no GL work and failed on `ScenarioFixture.h:90` — an armed split lane refuses a case
|
|
whose encoder ordinal did not move, because "emitted nothing" and "resolved the transport and
|
|
then put nothing on the wire" are the same observation. The case now clears and reads back
|
|
first. This is the same F1 arming rule package L hit on tier 3.
|