Files
MobileGL/docs/Disaggregated/notes/p5/p5-results/b1-review-v1.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

24 KiB

b1 — adversarial review, v1

Reviewed p5/b1 5175f9cc..5c45ec2a (8 commits) in ~/w7/p5-b1, against ~/w7/notes/p5/BRIEF-P5.md §5 b1 / R-6 / R-11 / E3, MobileGL/MG_Remote/CONTRACT-P5.md (which outranks the brief), and ~/w7/notes/p5/scout-gpu-writes-and-persistent-map-push.md. All four builds re-configured and re-built by me; all gate numbers below are my own re-runs, not b1's (~/w7/p5-b1rev-gate.log, ~/w7/p5-b1rev-g2.log).

Counts: 1 BLOCKER, 7 MAJOR, 6 MINOR, 2 QUESTION.


BLOCKER

B-1 — retiring frontend->IsMapped() re-commits the exact regression SanityTest.cpp:4583 exists to remember

Managers.cpp:2695-2707 makes the last frontend read conditional:

const Bool askTheObjectWhetherItIsMapped =
    MG_Config::Transport == MG_Config::TransportMode::Monolith;
if (askTheObjectWhetherItIsMapped && frontend != nullptr && frontend->IsMapped()) return false;

The pre-existing comment two screens above it (Managers.cpp:2661-2664, not b1's text) states the precondition for doing this: "The frontend read retires the moment P5 gives HasLiveHostWrites a producer." b1's producer does not satisfy that precondition, because it is unreachable for the buffer class the read was protecting.

The chain, every link verified:

  1. The rising edge deliberately emits no record. BufferObject.cpp:436-446 (NotePersistentMapStateChanged): if (live) { /* RISING EDGE COSTS NOTHING */ return; }. So at glMapBufferRange(WRITE|PERSISTENT|COHERENT) the server's MGPipeResourceRecord::HasLiveHostWrites stays false.
  2. The only producer of the bit is a content record. PipeFill.cpp:709, inside MGPipeEmitResourceSubData. MGPipeEmitBufferSubDataResident does not set it (see M-2), and MGPipeEmitResourceFlushRange does not go through ApplyBufferWrite at all.
  3. The only content record a coherent persistent map produces is the push, and the push runs from BufferObject::SyncPersistentMappedRange (BufferObject.cpp:369-381 → PushBlocksFor).
  4. For a vertex / uniform / SSBO persistent map that call lives inside the ensure path — Managers.cpp:2841 (EnsureBufferResourceForHandle) and Managers.cpp:3018 (EnsureBufferResource). SanityTest.cpp:4578-4582 says so verbatim: "…and with it SyncPersistentMappedRange, the ONLY per-draw push for a vertex/uniform/SSBO persistent map". The other seven Espryt sites are index / indirect / parameter buffers (DirectGLES.cpp:361, 6185, 6439, 6440, 6541, 6542, MultiDraw.cpp:511).
  5. A "clean" answer skips the ensure. DirectGLES.cpp:691: if (IsBufferDrawCleanByHandle(entry.handle, entry.resource, entry.frontend)) continue;
  6. And then it latches. DirectGLES.cpp:697: memo->vboCleanEpoch = allClean ? bufferEpoch : 0;. A coherent persistent map bumps no mutation epoch (that is the whole point), so once every entry probes clean the probe loop itself is skipped on every later draw.
  7. PushPersistentMapsBeforeVerb() cannot break the cycle: it has no caller anywhere in the tree.
    $ grep -rn "PushPersistentMapsBeforeVerb\|MarkGpuWritesForDraw\|MarkGpuWritesForDispatch" MobileGL \
        --include=*.cpp --include=*.h | grep -v "MG_Remote/Client\|MG_Test"
    MobileGL/MG_State/GLState/BufferState/BufferObject.cpp:375:  // ... retire into ... at P8.
    
    (one comment, zero calls)

Failure scenario. glBufferStorage(GL_ARRAY_BUFFER, n, nullptr, MAP_WRITE|MAP_PERSISTENT|MAP_COHERENT), glMapBufferRange (declined by R-6, so the shadow is emulated), attributes pointed at it, then per frame: memcpy through the pointer, glDrawArrays. Draw 1 rebuilds the memo and calls EnsureBufferResource unconditionally (DirectGLES.cpp:721), so the first frame pushes. Draw 2 probes: record bit false, record->Serial == syncedChangeSerial, pendingRanges empty, size matches → clean → allClean → vboCleanEpoch stamped. Draw 3 and every frame after it skip the probe entirely, never reach SyncPersistentMappedRange, never emit a block, never move the serial. The frame draws frame 1's bytes, for ever, with no diagnostic — the C-1 shape, at the transport layer, for the single idiom (a persistently mapped streaming arena behind a static VAO) the whole feature exists to serve.

b1's new case does not catch it: SanityTest.cpp:4696-4735 (UnderSplitTheRecordAloneAnswersTheLiveHostMapQuestion) writes record.HasLiveHostWrites = true by hand. Delete PipeFill.cpp:709 entirely and that test still passes.

Fix. One of: (a) do not retire the frontend read in the same package that leaves the producer unreachable — keep it until the push is wired ahead of the probe; (b) publish the bit on the rising edge with a real record (the falling edge already proves a one-block state record is affordable); (c) have IsBufferDrawCleanByHandle under split ask MG_Remote::Client::PersistentMapTracker::IsLivePersistentMap for the handle — but that re-introduces a client read on the server side and is only legal in inproc; (d) wire PushPersistentMapsBeforeVerb() at the validate point now rather than deferring it to c1, so the push no longer depends on the probe it feeds. Whichever is chosen, the test that pins it must drive the producer chain (map → push → apply → probe), not a hand-written record.


MAJOR

M-2 — buffer_subdata_resident silently clears the bit

PipeApply.cpp:921 assigns rather than merges:

stored->HasLiveHostWrites = record.HasLiveHostWrites != 0;

ApplyBufferWrite has two callers — resource_subdata (PipeApply.cpp:1787) and buffer_subdata_resident (:1823) — and only the first emitter sets the field. MGPipeEmitBufferSubDataResident (PipeFill.cpp:725-745) builds MGPSubData record{} and never touches HasLiveHostWrites, so every glBufferSubData against a live-write-mapped buffer writes false into the server's state. b1's own comment at PipeApply.cpp:923-928 argues the assignment is right because "a content record emitted while nothing maps the buffer is exactly how the state goes back to false" — buffer_subdata_resident is a content record emitted while something does map it.

Failure: a persistently mapped arena that also takes glBufferSubData (legal, and the ordinary Flywheel/Create shape) ends every such call with the server believing no host writer is live. With B-1 fixed, this is the second door to the same draw-clean answer.

Fix: set the bit in MGPipeEmitBufferSubDataResident too (one line beside PipeFill.cpp:709), or add a record.DeclaresLiveHostWrites presence bit so the applier only overwrites from records that speak.

M-3 — pmap does double-count against stage-buffer, and the inventory now asserts it does not

PipeStats.cpp:33-35 (unedited, pre-existing) says of stage-buffer: "NOT covered: bytes an app writes THROUGH a persistent map. Those never pass through either backend (D4/D-B4)" — true only while adoption survives. R-6 kills adoption, so a pushed block becomes an ordinary resource_subdata, reaches Ops_H_SubData (Managers.cpp:1960-2000), is queued into pendingRanges, and is staged with AddBytes(ByteClass::StageBuffer, …) at Managers.cpp:1121 (upload ring), :1224, :1282. The same bytes are already counted as PersistentMapPush at BufferObject.cpp:404-412.

b1's new text at PipeStats.cpp:78-80 states the opposite: "NOT double-counted with stage-buffer". The inventory is contract; it is now wrong in exactly the configuration the counter was wired for, and §8's "pmap 与 mpr 的对照" measurement inherits the error.

Fix: amend the stage-buffer entry to say it does cover the pushed bytes under split (and drop the "NOT double-counted" sentence), or subtract the push at the staging site.

M-4 — MOBILEGL_IPC_PERSISTENT_BLOCK_KB=0 does not turn the push off, so E3(a) can go green

BufferObject.cpp:456-459, the falling edge:

const Uint64 blockBytes = MG_Remote::Client::PersistentMapTracker::BlockBytes();
const SizeT length = blockBytes == 0 || blockBytes >= static_cast<Uint64>(m_size)
                         ? m_size : static_cast<SizeT>(blockBytes);
NotifySubData(0, length);

With the knob at 0, PushBlocksFor correctly ships nothing (PersistentMapTracker.cpp:88) — but the unmap ships the whole buffer. Config.h:483-485 and CONTRACT-P5.md §5 both say 0 means the push is off and PersistentCoherentMapScenario must go red; if t1's scenario unmaps before it reads back, it goes green and the negative control is dead. The unit case that claims to pin this (SplitBufferSet.AZeroBlockSizeTurnsThePushOffRatherThanMakingItUnlimited, SplitBufferTest.cpp:299-315) only drives PushBlocksFor and never touches the falling edge.

Fix: if (blockBytes == 0) return; before the falling-edge emission, and extend the unit case to ReleaseMemory under the knob.

M-5 — the one new site that is not gated on Transport != Monolith (D-J)

Every other new site pairs #if MOBILEGL_BUILD_DISAGGREGATED with a transport test. GL_Drawing.cpp:1321-1327 does not:

#if MOBILEGL_BUILD_DISAGGREGATED
            buffer->SyncGpuWrites();
#endif

inside FixupGsStripCaptureOrder. In build-split running MOBILEGL_TRANSPORT=monolith on Magma — whose VulkanRenderer.cpp:11618 marks the capture targets — m_gpuWritePending is set, so this now takes the monolith arm of SyncGpuWrites, emits a whole-buffer MGPipeEmitResourceReadback (BufferObject.cpp:508-518) per capture buffer and bumps m_changeSerial through WritebackFromBackend, forcing a re-upload on the next draw. The fence at :1390 still runs in that arm, so the readback is pure new work. D-J forbids new behaviour on the monolith path, and integration-gpu does not observe it (build-split monolith is 1117/1117 either way).

Fix: if (MG_Config::Transport != MG_Config::TransportMode::Monolith) buffer->SyncGpuWrites();

M-6 — the tier-1 widening refusal cannot fire from production code, and R-11's actual deliverable did not land

Managers.cpp:1137-1139:

const GLbitfield access = mapUsable ? InvalidateFlushAccessFor(start, end, start, end,
                                                              limit, resource.storageSize) : 0u;

The map extent and the queued extent are the same two variables, so the refusal branch at Managers.h:927 (if (mapStart != queuedStart || mapEnd != queuedEnd) return 0u;) is unreachable at the only call site; it can only be exercised by the unit cases calling the function directly (SplitBufferTest.cpp:425-436). Meanwhile the charter's real item — "hostBase 的『每次使用重求值』 在 split 下变成『发射时快照进 SEG_STAGE』" — is not implemented: Managers.cpp:2752-2758's liveHostBase lambda is byte-for-byte unchanged, and Ops_H_SubData still parks a client pointer in GLESBufferResource::hostBytes (Managers.cpp:1980-1983). (That last one is v1's per BRIEF:551, fine.)

So: the answer to "is b1's snapshot narrower-or-equal to the range it claims?" is there is no snapshot. What landed is a refactor with identical behaviour plus a dead guard and five unit cases. Nothing in the tree forces w1 to pass a real snapshot extent when it writes one — no static_assert, no TODO trip, no failing test. b1 discloses this in its §5, but the brief listed it as a deliverable and no integrator ruling moved it.

Fix: either land the snapshot and pass its real extent as mapStart/mapEnd, or record an integrator ruling moving the item to w1 and leave a build-breaking marker (e.g. an #error-guarded MOBILEGL_IPC_STAGE_SNAPSHOT capability constant) so w1 cannot land the snapshot without wiring the extent.

M-7 — AwaitBufferWriteback is an unconditional no-op with no tripwire

GpuWritePending.cpp:158-170:

void AwaitBufferWriteback(BufferObject& buffer) {
    (void)buffer;
    ...
    if (ClientSession::Active() == nullptr) return;
}

ClientSession::Active() is { return nullptr; } (ClientSession.cpp:30), and the function has no non-null branch — so it is a no-op today and a no-op the day a session exists. SyncGpuWrites (BufferObject.cpp:497-529) then falls to if (m_gpuWritePending && !BufferWritebackIsReachable(*this)) m_gpuWritePending = false;, which leaves the flag set whenever a readback route exists, and returns to a caller that proceeds to read the un-refreshed shadow. Every consumer of the "third state" — including M-5's XFB fixup, which is the one place the removed ClientWaitSync guarantee had to be replaced — therefore reads stale bytes as soon as the apply side stops being synchronous. Nothing fails if the wait is never written.

Fix: make the empty case loud — an MGLOG_F/MOBILEGL_ASSERT on "session active and the answer has not landed", or a PipeStats counter that a named test asserts stays zero, so the hole has a red spelling before s1/c1 land.

M-8 — the pin is lifted only in a configuration nobody builds, so the new bit is never compared or tripped anywhere

PipeApply.cpp:845 and Managers.cpp:2677 are now #if MOBILEGL_PIPE_VERIFY && !MOBILEGL_BUILD_DISAGGREGATED. The build matrix (PACKAGE-PREAMBLE §"构建配方") has no VERIFY+DISAGGREGATED directory: build-verify is MOBILEGL_PIPE_VERIFY=ON without the transport, build-split is PUSH+DISAGG without VERIFY. So:

  • in build-verify nothing can set the bit — PipeFill.cpp:709 is inside #if MOBILEGL_BUILD_DISAGGREGATED — and the G4 field comparator (which does see the new field: MGP_FIELDS_MGPSubData at PipeFields.def:176, MGPSubData at MGP_VERIFY_PAYLOAD_LIST PipeFields.def:352, expanded at gen_pipe.py:876) compares 0 against 0, vacuously;
  • in build-split neither the pin nor the assert is compiled;
  • ResourceEmit.TheLiveHostWritesWireFiresOnTheCallAPersistentMapProducerWouldSetItOn (ResourceEmitTest.cpp:1253) skips in both push and split.

The wire tripwire for the field is therefore effectively deleted, not lifted, in every build where the field can be non-zero. This is the mechanism that lets B-1 and M-2 be invisible.

Fix: add a build-verify-split lane (VERIFY+DISAGGREGATED) to the gate skeleton and keep the pin meaningful by inverting it there — assert the bit is set iff the emitting object said so — or move the invariant into a split-buildable assertion.


MINOR

m-9 — the "same commit" claim is false

The brief (§5 b1) requires the AddBytes wiring and the PipeStats.cpp:68-70 inventory rewrite in the same commit. They are three commits apart: the AddBytes call is in 52d2d5dd (BufferObject.cpp only — git show --stat 52d2d5dd), the inventory in d9fb5273 (PipeStats.cpp + MEASUREMENTS.md). b1's report §1 row 5 states "rewritten in the same commit". The tree at HEAD is consistent; the report is not.

m-10 — two comments describe a carrier that does not exist

BufferObject.cpp:424-429: "it rides MGPResourceDesc's last pad byte as a METADATA field (ID-18 M4), so a respecify that moves only it allocates nothing, acks nothing and clears no pending upload", and BufferObject.h:217-219: "What MGPipeBuildResourceDesc writes into MGPResourceDesc::HasLiveHostWrites". Commit 450e21cc moved the bit to MGPSubData; MGPResourceDesc has no such member and MGPipeBuildResourceDesc writes nothing. Both survived.

m-11 — "the adoption path notes the change itself" — it does not

BufferObject.cpp:815-820 justifies publishing before the adoption attempt by saying the adoption path withdraws the entry. NotePersistentMapStateChanged has exactly four call sites (:188, :331, :735, :820); AdoptPersistentMap is not one of them. Self-healing today only because PushBlocksFor re-checks the predicate (PersistentMapTracker.cpp:76-83); the published bit does not self-heal and will stay true across an adoption until unmap. Latent for P11.

m-12 — R-6's other half was neither done nor handed off

R-6: "LargeArenaAdoptionScenario(断言发生了采纳)在 split 车道下改成断言 decline + mpr 不变". Not done (b1 touched no MG_IntegrationTest file — correctly, it is t1's) and not mentioned in b1's §4 "what the other packages need from me", which lists only PersistentCoherentMapScenario. LargeArenaAdoptionScenario.cpp:275/299/344/389/407/450 all depend on an adoption that R-6 now makes impossible; they will go red the first time a split lane runs inproc.

m-13 — unsynchronised process-wide state

g_producerMarks (GpuWritePending.cpp:28) is a plain Array<Uint64,…> incremented from MarkBufferForProducer on whatever thread calls a GL entry point, and PersistentMapTracker::m_livePersistentMaps (PersistentMapTracker.h:106) is an unsynchronised UnorderedMap mutated from ~BufferObject (BufferObject.cpp:58-64), which is not necessarily the GL thread. The counters are diagnostics; the map is load-bearing. Table 3 calls these client-role singletons, so this may be intended — flagging it as a thing v1's thread work must confirm rather than inherit.

m-14 — MOBILEGL_IPC_ADOPT_TIER refuses late and refuses everything

AdoptTierIsEmulate() (PersistentMapTracker.cpp:124-136) aborts for any value != 2, so =7 dies naming P11 as though it were a real tier, and the abort lands at the first map_persistent rather than at parse — a mis-set run gets through EGL bring-up and a frame of setup before it dies. Contract §5 only promises 0 and 1 parse-and-Fatal.


QUESTION

Q-15 — R-6's "always" has a second, ungated door

The decline lives in MGPipeApplyMapPersistent (PipeApply.cpp:1958-1975), but AcquireMemoryRange falls through to the legacy op when the MGPipe resource subsystem is off (BufferObject.cpp:840-847: g_bufferBackendOps->AcquirePersistentMap(*this)), and that arm has no transport test. In a split build with a backend that registered no MGPipe resource ops, a real pointer is minted and adopted. Is that configuration in scope for P5? If yes, R-6 needs the gate at the frontend too; if no, say so in the contract rather than leaving it to E3(d) to notice.

Q-16 — the seam, stated rather than left open

Row 0/1 walk bindings where their backend twins (DirectGLES.cpp:570/618, UniformManager.cpp:1231) walk a program-resolved subset — wider, and safe, and b1 argues it well (§3.3). Row 2 sweeps 192 units against the backend's bitset — wider, safe. Rows 3/5 resolve the XFB program on the client, which the client genuinely owns. What no row covers is the backend's own buffers: Espryt's converted-vertex-stream and primitive-restart scratch, Magma's UBO ring. Those have no MarkGpuWritten today either, so the client set is no narrower than monolith's — but that is worth one sentence in the header's inventory, because the next reader will ask the same question and the answer ("not a regression, still a hole") is not currently written down anywhere.


What I verified, and it held

  • The pad decision's premise is true at the source. RespecifyRedefinesNoStorage (PipeApply.cpp:565-566) refuses kMGPipeResourceTargetBuffer as its first line, so MGPResourceDesc genuinely cannot carry a metadata-only buffer update and the descriptor carrier would have cost a re-upload per map. The ruling is sound; the contract row should be corrected as b1 asks.
  • The pad move is clean. MGPipeTypes.h:1098 Uint8 Pad0[2], MGP_ASSERT_POD(MGPSubData, 72) at :1104 unmoved. Nothing in the tree zeroes, normalises or assert-zeroes MGPSubData's pads (grep -rn Pad0 MobileGL/MG_Pipe MobileGL/MG_Remote MobileGL/MG_Impl/Pipe scripts/gen_pipe.py).
  • The bit is registered where it must be. F(HasLiveHostWrites) in MGP_FIELDS_MGPSubData (PipeFields.def:176); MGPSubData is in MGP_VERIFY_PAYLOAD_LIST (:352); gen_pipe.py's cover check (:416-446, PADDING_MEMBER_RE = ^Pad\d*$) would have failed --check had it been omitted, so this is enforced and not merely tidy. The verify comparator expands the macro (gen_pipe.py:876), so no regeneration is needed and --check is honest. (What is not honest is that no lane ever gives it a non-zero value — M-8.) gen_pipe.py --check rc=0, --self-test rc=0.
  • PinNoLiveHostWrites was lifted, not deleted — #else empty body at PipeApply.cpp:865; the Managers.cpp assert keeps the same guard; SanityTest.cpp's original ALiveHostMapKeepsTheHandleArmProbeDirtyBetweenTwoDraws is untouched and a split twin was added beside it. The scope of the lift is the problem (M-8), not the mechanic.
  • G1 held, re-run by me at --threshold 0:
    .text 10806323 -> 10806323 (+0, +0.000%);  file bytes identical
    27811 -> 27811 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
    
    It holds for a real reason: FlushPendingRangesFrom (the only caller of InvalidateFlushAccessFor) is inside #if MOBILEGL_PIPE_PUSH (Managers.cpp:1046..), m_publishedLiveHostWrites is behind #if MOBILEGL_BUILD_DISAGGREGATED, MG_Config::Transport is an inline constexpr TransportMode::Monolith in any non-DISAGG build (Config.h:512-514), and ByteClass::PersistentMapPush already existed above the #if MOBILEGL_PIPE_PUSH block (PipeStats.h:72 vs :76) — so wiring it resized nothing. Confirmed.
  • Test lanes, re-run: ctest -L unit = 1806 / 1806 / 1806 (pull / push / verify) and 1863 (split), 100% passed, 0 failed. G2 pull-vs-push name diff = 0 lines; G14 split removed = 0, added = 57. Numbers match b1's report exactly.
  • integration-gpu under MOBILEGL_TRANSPORT=monolith: build-push 1117/1117, build-split 1117/1117, and the name set is identical to ~/w7/p5-before-ctest-names.txt (0 names added, 0 missing). Necessary but not sufficient — M-5 is a monolith-path behaviour change this suite does not observe.
  • mpr really is counted before the decline (PipeApply.cpp:1944, ++g_applier.MapPersistentRoundtrips; is the first statement), so E3(c)'s "mpr equal between the arms" is structurally true and not a coincidence.
  • T0/T1 are a named refusal, not a fallthrough — MGLOG_F + std::abort() (PersistentMapTracker.cpp:124-136), with a death test (SplitBufferSet.OnlyAdoptTierTwoIsImplemented).
  • The 21-site census is right. I counted them: Espryt 9 (DirectGLES.cpp:361, 6185, 6439, 6440, 6541, 6542, MultiDraw.cpp:511, Managers.cpp:2841, 3018) + Magma 12 (DirectVulkan.cpp:281, 472, 796, UniformManager.cpp:2024, VulkanRenderer.cpp:3542, 3621, 4013, 7428, 12423, 12424, VkBufferManager.cpp:628, 679) = 21. MEASUREMENTS.md:111's 20 → 21 correction and the naming of DirectGLES.cpp:361 as the missing one are both correct.
  • The membership predicate really is SyncPersistentMappedRange's chain, line for line and in order (PersistentMapTracker.cpp:40-59 vs BufferObject.cpp:382-395), including the FlushExplicit early-out, and a unit case drives them against each other.
  • Block arithmetic and the falling-edge byte source are sound. MappedData() is the shadow base (BufferObject.cpp:873, return m_resource.Bytes();), so block offsets are buffer-relative and correct; the remainder tail is right; and ReleaseMemory does land the staged writes and call NotifyFlushMappedRange before NotePersistentMapStateChanged (BufferObject.cpp:290-331), so the falling-edge record's bytes are current when landStagedWrites is true.
  • MarkEndTransformFeedbackCaptureTargets() is in the only correct place — before GLContext::EndTransformFeedback() clears the bindings (GL_Drawing.cpp:1369-1372) — and the fence removal's one in-function consumer (FixupGsStripCaptureOrder, which reads back through MappedData()) was spotted and given a SyncGpuWrites(). That the SyncGpuWrites() currently waits for nothing is M-7, and that it is ungated is M-5; the diagnosis was right and nobody else had named it.
  • The whole module is otherwise correctly gated. Every other new site pairs #if MOBILEGL_BUILD_DISAGGREGATED with Transport != Monolith, and the two entry points that are not textually gated (~BufferObject's Forget, NotePersistentMapStateChanged) check PushIsArmed() or are provably inert (the set is empty and m_publishedLiveHostWrites is never written) when the transport is monolith.