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.
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:
- The rising edge deliberately emits no record.
BufferObject.cpp:436-446(NotePersistentMapStateChanged):if (live) { /* RISING EDGE COSTS NOTHING */ return; }. So atglMapBufferRange(WRITE|PERSISTENT|COHERENT)the server'sMGPipeResourceRecord::HasLiveHostWritesstays false. - The only producer of the bit is a content record.
PipeFill.cpp:709, insideMGPipeEmitResourceSubData.MGPipeEmitBufferSubDataResidentdoes not set it (see M-2), andMGPipeEmitResourceFlushRangedoes not go throughApplyBufferWriteat all. - The only content record a coherent persistent map produces is the push, and the push runs from
BufferObject::SyncPersistentMappedRange(BufferObject.cpp:369-381→PushBlocksFor). - For a vertex / uniform / SSBO persistent map that call lives inside the ensure path —
Managers.cpp:2841(EnsureBufferResourceForHandle) andManagers.cpp:3018(EnsureBufferResource).SanityTest.cpp:4578-4582says 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). - A "clean" answer skips the ensure.
DirectGLES.cpp:691:if (IsBufferDrawCleanByHandle(entry.handle, entry.resource, entry.frontend)) continue; - 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. PushPersistentMapsBeforeVerb()cannot break the cycle: it has no caller anywhere in the tree.(one comment, zero calls)$ 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.
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-verifynothing can set the bit —PipeFill.cpp:709is inside#if MOBILEGL_BUILD_DISAGGREGATED— and the G4 field comparator (which does see the new field:MGP_FIELDS_MGPSubDataatPipeFields.def:176,MGPSubDataatMGP_VERIFY_PAYLOAD_LISTPipeFields.def:352, expanded atgen_pipe.py:876) compares 0 against 0, vacuously; - in
build-splitneither 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) refuseskMGPipeResourceTargetBufferas its first line, soMGPResourceDescgenuinely 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:1098Uint8 Pad0[2],MGP_ASSERT_POD(MGPSubData, 72)at:1104unmoved. Nothing in the tree zeroes, normalises or assert-zeroesMGPSubData'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)inMGP_FIELDS_MGPSubData(PipeFields.def:176);MGPSubDatais inMGP_VERIFY_PAYLOAD_LIST(:352);gen_pipe.py's cover check (:416-446,PADDING_MEMBER_RE = ^Pad\d*$) would have failed--checkhad 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--checkis honest. (What is not honest is that no lane ever gives it a non-zero value — M-8.)gen_pipe.py --checkrc=0,--self-testrc=0. PinNoLiveHostWriteswas lifted, not deleted —#elseempty body atPipeApply.cpp:865; theManagers.cppassert keeps the same guard;SanityTest.cpp's originalALiveHostMapKeepsTheHandleArmProbeDirtyBetweenTwoDrawsis 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:It holds for a real reason:.text 10806323 -> 10806323 (+0, +0.000%); file bytes identical 27811 -> 27811 defined symbols: 0 added, 0 removed, 0 resized, 0 renamedFlushPendingRangesFrom(the only caller ofInvalidateFlushAccessFor) is inside#if MOBILEGL_PIPE_PUSH(Managers.cpp:1046..),m_publishedLiveHostWritesis behind#if MOBILEGL_BUILD_DISAGGREGATED,MG_Config::Transportis aninline constexpr TransportMode::Monolithin any non-DISAGG build (Config.h:512-514), andByteClass::PersistentMapPushalready existed above the#if MOBILEGL_PIPE_PUSHblock (PipeStats.h:72vs: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-gpuunderMOBILEGL_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.mprreally is counted before the decline (PipeApply.cpp:1944,++g_applier.MapPersistentRoundtrips;is the first statement), so E3(c)'s "mprequal 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 ofDirectGLES.cpp:361as the missing one are both correct. - The membership predicate really is
SyncPersistentMappedRange's chain, line for line and in order (PersistentMapTracker.cpp:40-59vsBufferObject.cpp:382-395), including theFlushExplicitearly-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; andReleaseMemorydoes land the staged writes and callNotifyFlushMappedRangebeforeNotePersistentMapStateChanged(BufferObject.cpp:290-331), so the falling-edge record's bytes are current whenlandStagedWritesis true. MarkEndTransformFeedbackCaptureTargets()is in the only correct place — beforeGLContext::EndTransformFeedback()clears the bindings (GL_Drawing.cpp:1369-1372) — and the fence removal's one in-function consumer (FixupGsStripCaptureOrder, which reads back throughMappedData()) was spotted and given aSyncGpuWrites(). That theSyncGpuWrites()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_DISAGGREGATEDwithTransport != Monolith, and the two entry points that are not textually gated (~BufferObject'sForget,NotePersistentMapStateChanged) checkPushIsArmed()or are provably inert (the set is empty andm_publishedLiveHostWritesis never written) when the transport is monolith.