Files
MobileGL/docs/Disaggregated/notes/p2/p2-results/magma-review-v2.md
T
swung0x48 aba329cc53 [Docs] (Disaggregated): P6's plan and contract draft; the working notes move from a local directory into the repository
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.
2026-09-18 23:31:39 -04:00

25 KiB
Raw Blame History

P2 package D — p2/magma adversarial review (v2)

Tree reviewed: ~/w7/p2-magma @ 1e89fd90, six commits on top of the contract 9c6a8a25 (tag p2/contract). Build dirs as found: build-linux (pull), build-push, build-nolegacy. Auxiliary tree ~/w7/p2-magma-armed @ 88a8e661 (p2/magma + p2/tracker). The tree was left exactly as found: no source edit, no new build dir inside either worktree (the two out-of-tree compile probes wrote to ~/w7/rev-magma/ and /tmp).

Verdict: NOT APPROVED — 1 major, 11 minors.

The three v1 majors that were code defects (MAJOR 1 per-draw abort, MAJOR 2 all-pull arm contamination, MAJOR 5 "m1 executed by no test") are genuinely fixed and I reproduced the evidence for each. The remaining major is the replacement introduced by v2's fix for v1 MAJOR 3/4: the backend-local identity table. Its declared cost in magma-v2.md §2 MAJOR 4 is materially understated, and the understatement hides a new unbounded-memory failure mode in exactly the workload P2 exists to speed up.


0. What I re-ran, and what it said

Everything below was executed by me on ~/w7/p2-magma @ 1e89fd90 (builds were already current — ninja: no work to do in all three dirs).

gate command observed
G1 python3 scripts/symbol_report.py --before ~/w7/p2-before-libMobileGL.so --after build-linux/libMobileGL.so --threshold 0 27799 -> 27799 defined symbols: 0 added, 0 removed, 4 resized, 0 renamed; the four are RenderState::RenderState() +148, RenderState::SetCapability +77, RenderState::IsCapabilityEnabled +29, _GLOBAL__sub_I_DirectGLES.cpp −9
G1, isolated to this package same script, --before ~/w7/p2-contract/build-linux/libMobileGL.so 0 added, 0 removed, **0 resized**, 0 renamed, .text +0. This package's pull build is byte-identical to the contract's. D-13's #else duplication does what it claims.
G13 check_include_closure.py / gen_pipe.py --check / --self-test / grep -rc pGLContext MobileGL/MG_Backend / stdio grep 4 probes, 0 skipped, 0 problem(s); rc 0; 7 negative-control trip(s), positive control OK; grep empty; no stdio (only the word "puts" inside prose comments)
G5 awk '/^ namespace RenderStateImpl \{/,/^ \} \/\/ namespace RenderStateImpl/' DirectGLES.cpp | sha256sum d8fd1c48…0efe27 — equal to ~/w7/p2-before-syncrenderstate.sha
G2 (name half), G14 ctest -N with the working grep in all three dirs 2367 / 2367 / 2367, all three byte-identical; vs the 2363-name baseline: 0 removed, 4 added, all four the contract's MG_Test/Pipe placeholders
unit ctest -L unit -j 8 in build-linux / build-push / build-nolegacy 1489/1489 in each
integration ctest -L integration-gpu -j 4 -R DirectVulkan in six configurations 432/432 in every one: build-linux (pull); build-push default mask; MOBILEGL_PIPE_PUSH=0; MOBILEGL_PIPE_PUSH=0x60 MOBILEGL_PIPE_LEGACY_MEMOS=0 (v1 MAJOR 1's repro); MOBILEGL_PIPE_LEGACY_MEMOS=0 at the default mask; build-nolegacy. No flakes in any of the six (the result file's §7 flakes did not recur here).
G3, DirectVulkan half retrace_gate.py --tree ~/w7/p2-magma --lib build-push/libMobileGL.so --out ~/w7/retrace-out/rev-magma -j 4 --only 'DirectVulkan$' passed 40 / 40; failed: []
arming (v1 MAJOR 5) 13 DirectVulkan.*CrossFrameBuffer cases with MOBILEGL_LOG_FILE_PATH, armed tree vs delivered tree armed: 13/13, 0 occurrences of the fallback warning; delivered: 13/13, 1. Across the 40 retrace logs on the delivered tree the warning appears in 80 files (grep -rl "no render-state CSO" ~/w7/retrace-out/rev-magma). The claim in §4 reproduces exactly and its control half is real.
ownership (C.5) git diff --name-only 9c6a8a25..HEAD the six files C.3 names, nothing else
MOBILEGL_PIPE_VERIFY build recompiled VulkanRenderer.cpp and VertexInputStateFactory.cpp out-of-tree from build-push/compile_commands.json with -DMOBILEGL_PIPE_VERIFY=1 rc 0, no warnings — the never-built verify configuration is not a compile risk for this package

Chunk-table spot check (the review's "re-derive at least five setters" item). I re-derived eight setters from MG_State/GLState/RenderState/RenderState.cpp against the landed boundaries in MG_Pipe/MGPipeRenderStateSpans.h:60-100 and the declaration order in MG_Pipe/MGPipeValueTypes.h. All consistent with the rule "pipeline ⟺ a BumpVersions() setter writes it":

setter RenderState.cpp writes chunk half verdict
SetStencilFunc :637-649 Func (pipeline version conditional at :649), Ref, ValueMask (++m_version only) Func → P2/P3, Ref/ValueMask → D3/D4 split ✔ the sub-member split is exactly what the conditional bump needs
SetStencilMask :652-657 WriteMask, ++m_version D3/D4 dynamic ✔
SetSampleCoverage :786-791 SampleCoverageValue, SampleCoverageInvert, BumpVersions() P2 pipeline ✔ (the D6 deviation against MGPipeTypes.h:232-235 is real and correctly resolved)
SetCapability(ClipDistanceN) :373-381 ClipDistanceEnabledMask, ++m_version only, explicitly not BumpVersions D7 dynamic ✔
SetCapabilityIndexed(ScissorTest) :456-460 ScissorTestEnabledMask, BumpVersions() P6 pipeline ✔ — and it is why magma-v2.md D-4 inverts D12.3's claim correctly
SetScissorBox :926-948 ScissorBoxes, ScissorBoxWrittenMask, ++m_version D7 dynamic ✔
SetPolygonMode :174-178 PolygonModeFront, PolygonModeBack, BumpVersions() P5 pipeline ✔
SetMinSampleShadingValue :813-820 MinSampleShadingValue, BumpVersions() P2 pipeline ✔

The m1 discrimination argument holds. I read ComputePipelineStateHash (VulkanRenderer.cpp:4963-5051) field by field: every one of its RenderStateParameters inputs — the 11 capability bools, MinSampleShadingValue, SampleMaskValue, PatchVertices, the six patch levels, PolygonModeFront, CullFaceModeSetting, DepthFunc, LogicOp, both faces' {FailOp, PassDepthPassOp, PassDepthFailOp, Func}, BlendStates[i], ColorMasks[i] — lands in an odd (pipeline) chunk of the landed table. Its two remaining inputs, colorAttachmentCount and rasterizationSamples (also reached through ResolveEffectiveSampleMask, :4954-4960), are pinned by entry.renderPassHash: VkRenderPassManager.cpp:606-765 folds the draw-buffer list, the valid draw-buffer count and each attachment's sampleCount into that hash. So collapsing pipelineStateHash to the CSO handle loses no discrimination, and m_independentBlendFeatureEnabled is a per-renderer device constant while the memo is per renderer. I could not construct an aliasing case.

The m2 static_asserts are a real gate, not decoration. I compiled an out-of-tree probe (~/w7/rev-magma/probe/probe.cpp) that reuses the landed MagmaRenderStateRangeIsDynamic shape against MGPipeRenderStateSpans.h: the positive controls (BlendColor, LineWidth) hold, the inverted controls (DepthFunc, ScissorTestEnabledMask) hold, and a deliberately wrong assertion produces exactly one static assertion failed. I also checked the assertion set against DynamicTailKey's own inventory (VulkanRenderer.cpp:344-350): every listed reader is covered, none is missing.

Handle identity is sound for deletion, reuse and share groups. MGPipeHandles.h:52-58's contract is met by MagmaPipeIdentityTable::Acquire: Gen moves on every owner change, and lifetime ids are process-global monotonic from 1 (VertexArrayObject.cpp:17-21, BufferObject.h:254), so two live objects can never share a {slot, gen}, a recycled heap address cannot reproduce one, and a buffer shared across a share group keys identically in both contexts. The ABA control is wired the way D18 specifies (VertexInputStateFactory.cpp:293-301 hashes attr.Buffer.get() on the pre-handle arm; VulkanRenderer.cpp:3692-3710 drops the lifetime-id half of the compare), and both guards sit on the arm D18's AbaControl run selects (MOBILEGL_PIPE_PUSH=0).


MAJOR

M1 — the re-key replaces two unbounded, per-object VAO memos with a 2048-entry 2-way cache, and above capacity turns the vertex-input content hash into a per-draw value that inserts an entry into an unbounded map on every draw

Where. MG_Backend/DirectVulkan/Renderer/MagmaPipeArms.h:143-241 (the identity table, kMagmaVaoIdentityEntries = 2048, kMagmaBufferIdentityEntries = 8192, 2 ways per set); VertexInputStateFactory.h:487-508 (VaoBackendMemos, kVaoMemoSlotCount = 2048); VertexInputStateFactory.cpp:110-152 (TryGetMemoizedHash, GetOrComputeHash); VertexInputStateFactory.cpp:158-183 (GetOrCreateVertexInputState's state memo); VertexInputStateFactory.cpp:210-216 + .h:170 (m_cache, an unbounded UnorderedMap<HashType, UniquePtr<BackendVertexInputState>>); VertexInputStateFactory.cpp:420-452 (OnFrameBoundary: swept every 256 boundaries, retire age 1024 boundaries).

What changed, precisely. Before this package, the two facts the draw path memoises per VAO lived as mutable fields on the VertexArrayObject itself — m_backendHashMemo / m_backendHashMemoVersion and m_backendStateMemo / …Epoch / …Version (MG_State/GLState/VertexArrayState/VertexArrayObject.h:204-216). One memo per live VAO, no capacity, no eviction, guarded only by the VAO's own config version. After this package they live in VertexInputStateFactory::m_vaoMemos: 2048 entries, indexed by a slot minted from a 2-way set-associative LRU table with 1024 sets.

magma-v2.md §2 MAJOR 4 describes this as "the mitigations are not gone, they moved one level down", "both tables are caches", and "with more live objects than the table holds, an LRU eviction changes a live object's handle … For a VAO that costs a memo recompute". Two of those three statements are wrong for the memos in question, and the third understates the cliff.

Reproduction. MagmaPipeIdentityTable::Acquire (MagmaPipeArms.h:157-188) is 20 lines and fully deterministic. I transcribed it verbatim into …/scratchpad/wf5/magma-review/s29.sh / s37.sh and measured the fraction of uses whose first Acquire misses — each such miss clears the VAO's VaoBackendMemos (MemosFor, VertexInputStateFactory.cpp:100-106) and resets its VaoDrawMemo (VulkanRenderer.cpp:3662-3671):

VAO table (2048 entries, 1024 sets), live lifetime ids CONSECUTIVE (best case), round-robin draw order:
  live VAOs= 2048   handle-CHANGED=     0  (  0.0% of uses)
  live VAOs= 2500   handle-CHANGED=  4068  ( 54.2% of uses)
  live VAOs= 3000   handle-CHANGED=  8568  ( 95.2% of uses)
  live VAOs= 4000   handle-CHANGED= 12000  (100.0% of uses)

same, lifetime ids SPARSE (a long-running app that creates and destroys VAOs):
  live VAOs=  512   handle-CHANGED=    48  (  3.1%)
  live VAOs= 1024   handle-CHANGED=   615  ( 20.0%)
  live VAOs= 2048   handle-CHANGED=  3570  ( 58.1%)

Buffer table (8192 entries, 4096 sets), consecutive ids:
  live buffers= 8192  key-CHANGED=      0  (  0.0%)
  live buffers=10000  key-CHANGED=  16272  ( 54.2%)
  live buffers=16000  key-CHANGED=  48000  (100.0%)

The per-use miss rate is independent of how many times a draw re-acquires the same VAO (I re-ran at 1 and 5 acquires per use — s37.sh — identical numbers), because the extra acquires are hits that only refresh LastUse.

The second table is the one the code says is "sized four times the VAO one anyway … to keep it rare" (MagmaPipeArms.h:227-232). At 20 % on the first table with only half its nominal capacity in live objects, "rare" is not what the structure delivers.

Failure scenario, tier 1 (VAO table alone over capacity — certain). Minecraft in-world with one VertexBuffer-backed VAO per chunk section is the minecraft-1.21.4-in-world / …-sodium-in-world shape and is one of D.4.2's four device cases; the tree's own comment at VertexArrayObject.h:150-155 describes the target as "an app cycles hundreds of VAOs per frame", and VulkanRenderer.h:1385-1390 describes VAO create/destroy churn heavy enough that "a deleted VAO's heap address is handed straight back". For every draw whose VAO's set is over-subscribed:

  1. MemosFor clears the entry, so TryGetMemoizedHash returns false and GetOrComputeHash runs ComputeHash(vao) — a walk of all 16 attributes with ~10 XXH64_update calls each plus 16 more MagmaPipeBufferIdentity().Acquire() calls (VertexInputStateFactory.cpp:20-56, 284-303) — once per draw where it previously ran once per VAO reconfiguration;
  2. the state memo misses too, so GetOrCreateVertexInputState(vao, hash) does the m_cache probe the memo exists to skip;
  3. LookupVaoDrawMemo resets contentHash, layoutFactsValid and bindings.frameSerial (VulkanRenderer.cpp:3666-3671), so TryBindResolvedVertexBindings declines and the draw pays a full vertex-binding re-resolve.

That is three memos lost per draw in the workload whose per-draw cost is the entire point of P2, and G11's acceptance criterion is "per-thread CPU p50 and p99 deltas are not negative on either device".

Failure scenario, tier 2 (both tables over capacity — memory). Once the buffer table also thrashes, each per-draw ComputeHash mixes a different {slot, gen} for the same buffer (VertexInputStateFactory.cpp:289-292), so the content hash differs from the previous draw's. GetOrCreateVertexInputState(vao, hash) then misses m_cache and heap-allocates and inserts a new BackendVertexInputState (VertexInputStateFactory.cpp:210-216, .h:170). m_cache has no capacity bound; OnFrameBoundary sweeps only when m_frameBoundaryCounter % 256 == 0 and retires only entries older than 1024 boundaries (:428-433), so growth is bounded solely by ~1024 frames × draws-per-frame of insertions. Every erase in that sweep also bumps m_evictionEpoch, invalidating every VAO's state memo (:436-441), so the sweep itself is a second cliff. Nothing in magma-v2.md mentions this path; §2 MAJOR 4 stops at "costs a rebuilt BackendVertexInputState … per VAO reconfiguration, not per draw", which is exactly the premise tier 1 removes.

This is the same class of problem the design change was made to avoid — the header's own justification for not using MG_Impl/Pipe/SlotAllocator is that an allocator with a dead Free "grows … for the life of the process, on a platform with an LMK" (MagmaPipeArms.h:129-139). The replacement trades a bounded-rate leak of one SlotState plus one map node per object ever created for an unbounded-rate insertion into m_cache of a full BackendVertexInputState per draw.

Why this is a major and not a declared risk. The deviation is declared (D-5/D-7), but the declaration rests on three claims I can show are false or unsupported:

  • "both tables are caches" — false for VaoBackendMemos. Its predecessors were per-object fields with no capacity. The package does not move eviction one level down; it introduces eviction where there was none.
  • "2048 entries is what the address-hashed VaoDrawMemo table it replaces held, so the working set this covers without eviction is unchanged" (MagmaPipeArms.h:224-226) — true of the draw memo, false of the hash and state memos, which are the ones the P1→P2 per-draw win depends on.
  • "nothing on desktop reaches those working sets" (§2 MAJOR 4) — true, and that is the problem: the 432 integration cases, the 40 retraces and the 1489 unit tests are all below both capacities, so every green gate in §3 is green in the regime where the structure cannot fail, and the regime where it does fail is the device A/B that has not been run.

What would close it. Either size both tables off a measured live-object high-water mark for minecraft-1.21.4-in-world and …-sodium-in-world and pin the number with an assertion, or keep the hash/state memo per-object (unbounded, as today) and let only the draw memo be slot-indexed, or run D.4.2 on one device first and publish the p50/p99 before this lands. The minimum acceptable outcome is a measurement, because no gate this package can reach can see it.


MINORS

  1. MGLOG_W_ONCE is on the per-draw pipeline path and its documented cost is wrong by an order of magnitude. VulkanRenderer.h:1038-1041 and magma-v2.md §2 both state "_ONCE costs one static bool test". MOBILEGL_LOG_ONCE_INTERNAL (MG_Util/Debug/Log.h:51-58) is static std::atomic_flag latch; if (!latch.test_and_set(relaxed)) — an unconditional read-modify-write on every evaluation. objdump -dC of build-push/CMakeFiles/MobileGL_s.dir/…/VulkanRenderer.cpp.o shows ten xchg %al,0x0(%rip) (implicitly locked) inside VulkanRenderer::GetOrCreatePipeline. It is branch-guarded on MGPipeHandleIsNull(boundCso), so it is inert once a tracker is present (verified: 0 occurrences on the armed tree) — but it fires on every draw in the configuration this package ships today (bit 0 set, no tracker: 80 of 80 retrace logs carry it). ROADMAP.md:7 forbids committing hot-path instrumentation, and §4 uses this precisely as instrumentation. Fix the comment at minimum; consider MGLOG_D_ONCE plus a PipeStats counter, which is what D17 exists for.
  2. MOBILEGL_PIPE_LEGACY_MEMOS=0 does not stop Magma entering the pre-handle arm, and does not say so. With bit 0 (kMGPipeSubsystemRenderState) clear, ResolveBoundRenderStateCso returns null at VulkanRenderer.h:1046-1048 — before the warning — and ResolveFallbackPipelineStateHash (:924-935) calls ComputePipelineStateHash, which D14's compile-switch row names explicitly as part of "the pre-handle arm". D14's runtime row says "false: the legacy arm is never entered". Repro: MOBILEGL_PIPE_PUSH=0x7e MOBILEGL_PIPE_LEGACY_MEMOS=0 runs green while executing the legacy hash on every draw whose pipeline version moved, silently. The behaviour is arguably the only sensible one, but it is a D14 deviation and it is not in magma-v2.md §5.
  3. §4's inference is scoped more narrowly than it is stated. "Its ABSENCE from a run's log is the positive evidence that every draw keyed on a handle" (VulkanRenderer.h:1038-1041, magma-v2.md §2) holds only while bit 0 is set. With bit 0 clear the warning can never appear and no draw is keyed on a handle, so absence proves nothing. Worth one clause in the comment, because the integrator will grep these logs.
  4. The identity tables are process-global and never reset, while both consumer tables are per-instance. MagmaPipeVaoIdentity() / MagmaPipeBufferIdentity() (MagmaPipeArms.h:234-241) are function-local statics; m_vaoDrawMemoTable and m_vaoMemos belong to a VulkanRenderer / VertexInputStateFactory. Two live contexts, or a context recreation inside one process, share and drive one LRU: no aliasing (lifetime ids are globally unique) but halved effective capacity and interleaved eviction, which feeds M1. The tables also carry a Vector::resize and per-call LRU writes with no synchronisation; s_evictionEpochSource and the shared static inline XXH64_state_t* m_hashState (VertexInputStateFactory.h:184-190) set that precedent, so this is consistent with the file rather than new — but a global that outlives every context is new.
  5. Commit 553065dc's subject describes a change it does not make. "drive the dynamic tail from the pushed dynamic version" — git show --stat 553065dc is 1 file changed, 98 insertions(+), all of it comment and static_assert; ApplyDynamicDrawStateTail's const Uint paramsVersion = MGB_CTX->GetRenderStateParametersVersion(); is untouched. The re-sourcing is the contract's (D-2 says so honestly in §5, and the tree is right against D12.3), but the commit message claims the deliverable.
  6. D19's DynamicChunksCoverMagmasDynamicTailKey ctest entry exists nowhere. It is static_asserts in VulkanRenderer.cpp:399-425 here and a named test in package A's RenderStateSpansTest.cpp there. magma-v2.md §8.7 flags "make sure the outcome is not neither"; the integrator must actually close it. (The static_asserts themselves are a real gate — proved above.)
  7. D17's re-audit of the AccessorCalls tally constants was not done. D17 names VulkanRenderer.cpp:5009,5016,5274,5927,5934,6416,6449,6462; all eight line numbers have moved, and the tallies at the pipeline-memo gate (:5191, :5198) still say AccessorCalls, 1 on both arms although the handle arm no longer performs ComputePipelineStateHash's bulk GetRenderStateParameters() fetch. §8.11 lists this package's MEASUREMENTS.md input but not the re-audit D17 makes a precondition for quoting acc/draw.
  8. build-verify was never configured for this package. C.3 does not ask for one, and D.3 part 2 is the authority — but nothing here proves the package compiles under MOBILEGL_PIPE_VERIFY. I closed that specific hole myself (both changed TUs recompiled with -DMOBILEGL_PIPE_VERIFY=1 from build-push/compile_commands.json: rc 0, no warnings), so G4 is not at build risk; the applier's verify-only assertions remain unexercised here.
  9. Both assertions this package adds are compiled out in every build P2 runs. MOBILEGL_ASSERT is live only when MOBILEGL_LOG_ACTIVE_LEVEL <= DEBUG (MobileGL/Defines.h:97-115); all three build dirs are MOBILEGL_LOG_LEVEL_INFO. The Gen-wrap assert (MagmaPipeArms.h:175-178) never runs — consistent with MGPipeHandles.h:52-58, which says the wrap is defended only in a debug allocator — and 1e89fd90's null-handle assert (:214-215) never runs either; only its release-path ternary has effect. The commit's value is the ternary, not the assertion.
  10. Brief-vs-tree items I independently confirmed (all already listed in magma-v2.md §6, recorded here so the integrator has a second source): the A-section G2/G14 grep grep -E '^\s+Test #' returns 1368 of 2367 names, the working form returns 2367; ~/w7/retrace_gate.py --help shows only --tree --lib --out -j --only, so G3's --ssim and C.3's --backend do not exist; MGLOG_F_ONCE is absent from MG_Util/Debug/Log.h; and G1/D15's admitted resize set is short of _GLOBAL__sub_I_DirectGLES.cpp (−9), which is the contract's and appears after every merge.
  11. MG_Pipe::MGPipeApplier() is one process-global g_applier (PipeApply.cpp:99, 112), not the per-context CSO store D2 specifies. ResolveBoundRenderStateCso (VulkanRenderer.h:1045-1057) reads it directly, so in a multi-context process one renderer's pipeline memo would key on whatever CSO another context last bound. The defect is package A's, but Magma is its only consumer in P2 and the integrator should route it rather than let both reviews assume the other caught it.

Things I tried to break and could not

Recorded so the integrator does not re-spend the time.

  • Pipeline-memo aliasing across the two arms. Handle-arm entries carry pipelineStateHash == 0 and a non-null renderStateCso; fallback entries carry a real hash and kMGPipeNullHandle. The probe tests both components (VulkanRenderer.cpp:5180-5184, :6577-6582) and the insert writes both (:5851-5854). No cross-arm match is constructible.
  • Fast path vs full path keying differently. Both call ResolveBoundRenderStateCso() and both fall back through ResolveFallbackPipelineStateHash with the render-pass facts from their own source; the key tuples are identical.
  • vaoMoved weakening. The handle-arm form (VulkanRenderer.cpp:6313-6315) is strictly stronger than the address+lifetime-id form: identical VAO ⇒ identical handle unless the identity table evicted it, in which case the handle differs and the compare is conservative.
  • Mid-draw handle drift. Every Acquire inside one draw is for the same VAO lifetime id (the buffer acquisitions in ComputeHash hit a different table), so MemosFor, LookupVaoDrawMemo and ResolveVaoHandle cannot disagree within a draw.
  • A stale VaoBackendMemos served across an owner change. MemosFor clears on Owner != handle and Gen moves on every owner change, so contents are never inherited.
  • A reference into m_vaoMemos invalidated across the nested GetOrCreateVertexInputState. The table is fixed-size after its first resize, and the code re-takes the reference anyway.
  • GetBackendAuxMemo losing a reader. grep -rn across MobileGL/ confirms the getter has no caller anywhere, so retiring rather than moving it is correct (D12.5 agrees).
  • Slot-band collisions. MGPipeKind::Buffer and VertexElementsCso are distinct kinds; kMGPipeShaderCsoCompositeSlotBase is a ShaderCso-only band; kMGPipeDefaultFramebuffer is {0,1} of kind Framebuffer. Slots 1…8192 of these two kinds collide with nothing.
  • MOBILEGL_PIPE_PUSH=OFF -DMOBILEGL_PIPE_LEGACY_MEMOS=OFF failing to compile (VaoContentHashIfKnown's #else calls vao.GetBackendHashMemo, which only exists under MOBILEGL_PIPE_LEGACY_MEMOS). CMakeLists.txt:476-479 forces the option ON in that combination, so the configuration is unreachable.