# b1 — the buffer side, v1 Branch `p5/b1`, eight commits, **`5175f9cc..5c45ec2a`**, forked from `feat/disaggregated @ 5175f9cc`. Worktree `~/w7/p5-b1`. Nothing pushed; nothing merged. ``` 450e21cc [Feat] (MG_Pipe): give MGPSubData's pad byte to HasLiveHostWrites - the live-host-writer fact is content-shaped, and MGPResourceDesc's only carrier costs a buffer a spurious reallocation on every map <- c0-owned files, see 3.1 c872df8f [Feat] (MG_Remote, Client): the conservative GPU-write set and the persistent-map block tracker, on the client, where the decision SyncGpuWrites makes synchronously actually lives 52d2d5dd [Feat] (MG_State, BufferObject): under split cut the mapped span into blocks, publish the live-host-writes edge, and let the writeback rather than the request clear a GPU write 3e62d4ad [Feat] (MG_Pipe): give HasLiveHostWrites its producer, decline every persistent-map acquisition under split, and retire the verify pin that was waiting for exactly this fe8a555e [Fix] (DirectGLES): retire the probe's last frontend read under split and refuse tier 1 of the flush ladder when the map and the queued range disagree in either direction d9fb5273 [Feat, Docs] (PipeStats, MEASUREMENTS): wire persistent-map-push to the bytes the client ships, rewrite the inventory line that called it unwired, and correct the persistent-map census from 20 to 21 8217b7fe [Feat] (GLImpl): mark the pack PBO after a glReadPixels and the capture targets at glEndTransformFeedback, in place of a stall and an unbounded fence wait 5c45ec2a [Test] (MG_Test): one case per GPU-write row, the lifted live-host-writes pin from both sides, the widened INVALIDATE_RANGE edge and a non-zero persistent-map-push ``` --- ## 1. What landed, against the seven items of the brief | # | item | state | |---|---|---| | 1 | client-side conservative GPU-write set, 6 mirrored rows + 2 new producers | **done.** `MG_Remote/Client/GpuWritePending.{h,cpp}`, one enumerator per row, one unit case per row. The narrowing is **untouched** — `ResourceTracker.h:587-592`'s `rangeCount == 1` assertion stands. | | 2 | the block push | **done.** `MG_Remote/Client/PersistentMapTracker.{h,cpp}`; `m_livePersistentMaps` is `SyncPersistentMappedRange`'s early-out chain read as a predicate; 64 KiB blocks; shipped as ordinary `resource_subdata`; whole module gated on `Transport != Monolith`. | | 3 | `hasLiveHostWrites` gets a producer + all four pins lifted | **done, and the carrier is NOT the one the brief named — see §3.1.** The bit rides `MGPSubData`'s pad, not `MGPResourceDesc`'s. All four pins lifted **for a split build only**. | | 4 | R-6, force tier T2 | **done**, inside `MGPipeApplyMapPersistent` (so `mpr` is unchanged), with `MOBILEGL_IPC_ADOPT_TIER` 0/1 a named refusal. | | 5 | wire `persistent-map-push` | **done.** The inventory rewrite is in `d9fb5273` and the `AddBytes` call in `52d2d5dd` - **three commits apart, not the same one as v1 claimed** (review m-9). The brief asks for one commit so the inventory cannot be left lying; the tree is consistent at every commit that has the call, but the claim was wrong and is corrected here. | | 6 | the flush ladder under split | **done** as a pure function, `BufferImpl::InvalidateFlushAccessFor` (`Managers.h`), with the widening edge as its own unit case. | | 7 | `MEASUREMENTS.md:111` 20 → 21 | **done**, with the missing site named (`DirectGLES.cpp:361`) and the non-existent `§5.7` recorded. | --- ## 2. Acceptance numbers `~/w7/p5-b1`, `GLIBC_TUNABLES=glibc.malloc.tcache_count=0`, four build dirs (`build-linux` / `build-push` / `build-verify` / `build-split`). ### 2.1 Builds — four for four configure rc=0 and build rc=0 in all four. ### 2.2 G1 — did not move ``` nm --defined-only build-linux/libMobileGL.so | grep -ic MG_Remote -> 0 nm --defined-only build-split/libMobileGL.so | grep -ic MG_Remote -> 213 (c0 left it at 188) symbol-report vs ~/w7/p5-before-libMobileGL.so, --threshold 0: .text 10806323 -> 10806323 (+0, +0.000%) 27811 -> 27811 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed ``` It held because **every** new line that could reach the pull build is behind `#if MOBILEGL_BUILD_DISAGGREGATED` — including the two new `BufferObject` members (`m_publishedLiveHostWrites`, and the accessor pair), which would otherwise have moved the class layout and with it every inlined constructor in `MG_State`. The one edit that is *not* behind the option, `IsBufferDrawCleanByHandle`'s `askTheObjectWhetherItIsMapped`, folds at compile time because `MG_Config::Transport` is an `inline constexpr Monolith` in a build without the option — which is exactly what `Config.h:512-514` says it is for. ### 2.3 Generators and purity ``` gen_pipe.py --check : generated files are up to date (the PipeFields.def edit needs no regen) gen_pipe.py --self-test : 9 negative-control trips, positive control OK check_include_closure.py : 4 probes, 0 skipped, 0 problem(s) ``` ### 2.4 Test lanes | lane | before (5175f9cc) | after | |---|---|---| | `ctest -L unit` build-linux | 1785 / 1785 | **1806 / 1806** | | `ctest -L unit` build-push | 1785 / 1785 | **1806 / 1806** | | `ctest -L unit` build-verify | 1785 / 1785 | **1806 / 1806** | | `ctest -L unit` build-split | 1842 / 1842 | **1863 / 1863** | The 21 new names are 15 `SplitBufferSet.*`, 5 `EsprytFlushLadder.*` and one `DirectGLESBufferDrawProbe.*`, and **every one of them exists in all four builds**: a case that cannot run in a lane skips with a reason instead of vanishing. That is not tidiness, it is what keeps G2 (pull vs push, line for line) and G14 (split adds, never removes) meaning anything — the first cut had the flush-ladder cases behind a bare `#if MOBILEGL_PIPE_PUSH` and the pull/push name sets diverged by five before anything was even wrong. ### 2.5 Name identity and the integration lane ``` ctest -N, all labels: pull=2923 push=2923 split=2980 (baseline 2902 / 2902 / 2959) G2 pull vs push, diff lines: 0 G14 split vs push: 57 added, 0 REMOVED (the 57 are c0's Wire suites) integration-gpu names not present at ~/w7/p5-before-ctest-names.txt: 0 baseline names missing from my push build: 0 ctest -L integration-gpu, MOBILEGL_TRANSPORT=monolith build-push 100% passed, 0 failed out of 1117 (names: 1117, all present at baseline) build-split 100% passed, 0 failed out of 1117 ``` **Monolith behaviour did not move at all**, which is the point of the whole gating discipline: the push, the GPU-write set and the two new producers are all behind `MG_Config::Transport != Monolith` as well as behind `#if MOBILEGL_BUILD_DISAGGREGATED`, so an `integration-gpu` lane that says `monolith` runs exactly the code it ran at `5175f9cc`. --- ## 3. Rulings I made that the brief and the contract did not ### 3.1 `HasLiveHostWrites` rides `MGPSubData`, not `MGPResourceDesc` **The brief names both pads (`:303` / `:1004`) and the natural reading is the descriptor's. That reading does not work, and the reason is P4a's, not P5's.** `MGPResourceDesc`'s only carrier is `resource_respecify`, and for a **buffer** the applier can never classify one as metadata-only: `RespecifyRedefinesNoStorage` (`PipeApply.cpp:559`) refuses `kMGPipeResourceTargetBuffer` **outright, as its first line**, and the comment above it says why — that refusal is what makes ID-18 M4's "no reallocation ack" true *by construction* rather than by a second suppression rule, because `glBufferData` at an unchanged size is the canonical orphaning idiom and `glBufferStorage` is the one entry point allowed a synchronous ack. So announcing a map on a descriptor would have dispatched `g_resourceOps->Respecify(..., initialBytes)` — a full re-upload — **on every map and every unmap**. That is precisely the "第一次推这个位就要一次假重分配" the brief warned about, and the only way to register the bit as metadata on that carrier is to re-open the buffer exclusion, which is a P4a contract the buffer family should not be re-opening for a flag. `MGPSubData` has `Uint8 Pad0[3]`; one byte becomes `HasLiveHostWrites` and `MGP_ASSERT_POD(MGPSubData, 72)` does not move. The fact is content-shaped anyway — "someone may be writing these bytes without telling you" — and the carrier is the record the push already emits, so the steady state costs **nothing**: the bit rides blocks that were going out regardless. **The falling edge is the part that needed a decision.** After an unmap there may be no further content record for the buffer's life, and a record stuck at "live" reads draw-DIRTY for ever — the mirror image of the C-1 regression, costing a re-upload per draw instead of losing bytes. So `NotePersistentMapStateChanged` emits **one block** (`NotifySubData(0, min(size, blockBytes))`) with the bit already cleared. The bytes are real and current — `ReleaseMemory` has already landed the staged writes and called `NotifyFlushMappedRange` above it — and a zero-length record was not an option (contract rule A). *Overturned by:* a decision to widen `RespecifyRedefinesNoStorage` to admit metadata-only buffer respecifies, which would make the descriptor carrier viable and remove the falling-edge record. **This touches two c0-owned files** — `MGPipeTypes.h` (one pad byte) and `PipeFields.def` (one `F(HasLiveHostWrites)`) — and is isolated in its own commit so the integrator can take or reject it without unpicking anything else. `gen_pipe.py --check` is green without regeneration. ### 3.2 The four pins are lifted **for a split build only**, not deleted `PinNoLiveHostWrites` becomes the no-op body under `MOBILEGL_PIPE_VERIFY && !MOBILEGL_BUILD_DISAGGREGATED`, and the `Managers.cpp` assertion takes the same guard. In a monolith verify build nothing sets the bit and the wire is still the thing that would say so if something started to — which is the whole value of the pin, and it survives the phase it was written for instead of being consumed by it. The same is true of `frontend->IsMapped()`: monolith keeps the frontend read, split does not have one to keep. ### 3.3 Row 1 (atomic counters) is deliberately WIDER than its backend twin `SyncAtomicCounterBuffers` (`DirectGLES.cpp:578-583`) walks the GL bindings the **transpiled program** declared; the client has the bindings but not that per-program list at the emission point, so it marks every *touched* atomic-counter point. Over-approximating costs a readback the narrowing channel then removes; under-approximating reads a stale counter and says nothing, which is what every atomic-counter conformance case is. The asymmetry decides the direction, exactly as `RespecifyRedefinesNoStorage`'s own comment argues for its width. ### 3.4 The image-unit walk sweeps, and is the one place P5 knowingly spends The backend keeps a bitset of writable image-buffer units (`DirectGLES.cpp:2350-2352`) built from its own `SyncImageTextureBinding`; the client has no equivalent, so it sweeps `MAX_TEXTURE_IMAGE_UNITS` (192) with a null test per unit. Bounding it by `MaxImageUnits` would have been a backend read, and a stale or absent backend object would silently *shorten* the walk — the one direction a conservative set may not fail in. **An image-unit high-water mark on `GLContext` is the obvious narrowing and belongs with P8's binding-walk migration.** Recorded, not gated (2026-09-08 rule). ### 3.5 `glEndTransformFeedback`'s fence removal needed a second edit nobody named Dropping the `~0ull` `ClientWaitSync` (`GL_Drawing.cpp:1367`) is safe for `glMapBuffer` — that is what the flag is for — but `FixupGsStripCaptureOrder` (`GL_Drawing.cpp:1310-1338`) reads the captured bytes back through `MappedData()` **in the same function**, so it was relying on the fence without saying so. Under split it now calls `SyncGpuWrites()` on the buffer it is about to read. Cost moves from every `glEndTransformFeedback` to the capture shapes that actually need reordering. ### 3.6 `WritebackFromBackend`'s clear is whole-buffer only The third state's exit is the writeback, but `FixupGsStripCaptureOrder` writes back **three vertices at a time**, and a partial writeback is not an answer to a whole-buffer readback. The clear is therefore `atOffset == 0 && data.size >= m_size`. Pinned by a unit case. --- ## 4. What the other packages need from me / from each other ### 4.1 t1 — `PersistentCoherentMapScenario` It is **t1's file to author**; these are the assertions it needs, and the first one is the one that decides whether the rest mean anything. 1. **Assert which arm it is in.** A scenario-sized buffer is far under `kLargeBufferAdoptBytes` (16 MiB), so `TryAdoptLargeStorage` never fires — but `AcquireMemoryRange`'s own adoption **does** fire for `PERSISTENT|WRITE` without `FLUSH_EXPLICIT` (`BufferObject.cpp:655-661`), subject only to whether the backend mints. `MOBILEGL_DISABLE_LARGE_BUFFER_ADOPTION` does **not** separate them — it is read only inside `TryAdoptLargeStorage`. So: `ASSERT_FALSE(buffer->IsBackendPersistentMapped())` immediately after the map, with a message that says "this is the adopted arm, not the emulated one". Under split R-6 makes that assertion always hold; under monolith it is what tells you the two arms are comparable. 2. `ASSERT_TRUE(MG_Remote::Client::PersistentMapTracker::IsLivePersistentMap(*buffer))` — the membership predicate, so a drift between it and `SyncPersistentMappedRange`'s early-out chain fails here rather than silently stopping the push. 3. **E3(b): a write with no GL call at all announcing it** — map, write, draw, write again, draw again, read back. If the second write is announced by a `glBufferSubData` the push becomes redundant and the scenario goes green for the wrong reason. 4. **E3(c):** `pmap > 0` in the split arm and `mpr` equal between the arms. `PipeStats::TotalBytes(ByteClass::PersistentMapPush)` and `TotalCalls(CallClass::MapPersistentRoundtrips)`. 5. **E3(d):** `MGPipeApplyMapPersistent` never returns non-null under split. The cheapest spelling is `IsBackendPersistentMapped()` staying false across the whole scenario. 6. **E3(a):** the same scenario under `MOBILEGL_IPC_PERSISTENT_BLOCK_KB=0` must go **red**. It will: `PushBlocksFor` returns before shipping anything and the frame draws the last uploaded bytes. Pinned at unit level by `SplitBufferSet.AZeroBlockSizeTurnsThePushOffRatherThanMakingItUnlimited`. 7. The scenario's buffer must be **`PERSISTENT|WRITE|COHERENT` without `FLUSH_EXPLICIT`**. With `FLUSH_EXPLICIT` the buffer is deliberately **not** a member (the application announces its own writes through `resource_flush_range`) and the push ships nothing. ### 4.2 c1 — two hooks with no in-tree caller yet `MG_Remote::Client::MarkGpuWritesForDraw()` / `MarkGpuWritesForDispatch()` and `MG_Remote::Client::PushPersistentMapsBeforeVerb()` are **written, tested and unwired**: their caller is the emit table's draw/dispatch slot, and both must run **before** the verb record is emitted, not after. A push deferred past its own draw record is the C-1 regression re-committed at the transport layer. In P5 the push is already live at the 21 `SyncPersistentMappedRange` sites (they route into `PushBlocksFor`), so `pmap` is non-zero without c1; the draw/dispatch mark walks are **not** otherwise reached. ### 4.3 w1 — `resource_subdata` now has a meaningful byte in its pad `MGPSubData::HasLiveHostWrites` must cross. It is one byte out of `Pad0[3]` and changes no size, but a codec that zeroes the pads would silently delete it — and the failure mode is the buffer reading draw-clean while a host writer is live, i.e. C-1 again. --- ## 5. What I did not do, and why - **No narrowing.** `ResourceTracker.h:587-592`'s `rangeCount == 1` assertion is untouched. A package that reads `:577-581` alone will think P5 owns it; it does not, it is P8/P9's. - **`AwaitBufferWriteback` is a `return` and not a loop.** With no session — every unit lane, and a build-split lane running monolith — the emission *was* the application, synchronously, so a loop there would be a hang in exactly the configuration every gate runs. The real wait is the barrier's (`ClientSession::EmitAndWait`), because the reply-slot id **is** the record's seq; when s1/c1 land it, this function's body becomes their wait and not a second one. - **The flush ladder's `hostBase` snapshot is specified, not implemented.** Taking the snapshot into `SEG_STAGE` is w1's encoder work. What b1 owes and has landed is the *decision* the snapshot makes unsafe: `InvalidateFlushAccessFor` refuses tier 1 whenever the map extent and the queued range disagree in either direction, so a snapshot that does not cover exactly the queued range costs a staging-ring copy instead of a silent clobber. - **`ScopedDefaultUnpackState`'s six shadows, the `g_uploadRing` reset asymmetry and the unlocked `pendingRanges` / `pendingResidentWrites` probes** (scout §5.2-§5.4) are all still open. The third one is the live one: two threads make an unlocked emptiness probe of a container the apply side mutates, and `syncedChangeSerial` beside it is already an acquire load. It belongs to v1's thread work, not to the buffer family's shape. --- ## 6. Where I believe the brief or the contract is wrong 1. **CONTRACT-P5.md section 3 and BRIEF §5 both point `hasLiveHostWrites` at `MGPResourceDesc`'s pad.** See §3.1: that carrier costs a spurious reallocation per map on the buffer path, and the rule that makes it so is P4a's deliberate one. The contract row should name `MGPSubData`'s pad. 2. **The brief's "登记进 `MGPipeResourceRespecifyNeedsAck` 旁边的元数据字段清单" is not enough on its own.** Registering `HasLiveHostWrites` in the metadata list does nothing for a buffer, because `RespecifyRedefinesNoStorage` refuses the buffer target before it looks at any field at all. The list is a texture/renderbuffer rule. 3. **`MG_Impl/GLImpl/**` has no owner in BRIEF §5's table**, and the two new producers live there (`GL_Framebuffer.cpp`, `GL_Drawing.cpp`). I took them; if another package is also in those files the integrator should say so. 4. **`CMakeLists.txt` is c0's**, and two source lines had to be appended to the `MOBILEGL_BUILD_DISAGGREGATED` list for the two new `.cpp`s. Every package will need the same append; it is a conflict waiting to happen at one point in one list (P4a's lesson), and a per-package `list(APPEND ...)` block would cost nothing. --- ## 7. The account left for later phases - **P8**: the 21 `SyncPersistentMappedRange` sites retire into `PushPersistentMapsBeforeVerb()`; the image-unit sweep gets a high-water mark; the narrowing channel makes `rangeCount == 0` legal and `MarkBufferForProducer`'s conservative set starts shrinking. - **P6+ (Phase 2 of the push)**: `MOBILEGL_IPC_SHADOW_SHM` and 64 KiB dirty bits with a `memcmp` first. `ARCHITECTURE.md:499` grants this the right to be pulled forward if Phase 1 is unacceptable on the Create/Flywheel fixtures — the one place in the plan where a measurement may reorder phases. Phase 1 pushes the **whole mapped span at every validate point**, so on a 128 MB arena it is exactly as expensive as it sounds. - **P11**: `MOBILEGL_IPC_ADOPT_TIER` 0 and 1. They parse and are a named `abort` at use today, so the negative control has a spelling before the thing it controls exists. - **The barrier's retirement for the buffer family** re-opens C-6 (`ResourceFlushRange` carries no bytes) — the contract itself says to revisit it then, and the tier-1 arm this package hardened is the arm that would need the bytes and the range in one record. --- # 8. Fix round 1 — every finding of `b1-review-v1.md` Commits **`5c45ec2a..2a539881`** (seven), same branch and worktree; the branch is now `5175f9cc..2a539881`, fifteen commits. The review's 1 BLOCKER / 7 MAJOR / 6 MINOR / 2 QUESTION, in its order. ``` 57a0efa4 [Fix] (MG_State, BufferObject): publish the live-host-writes bit on the RISING edge too - the only content record a coherent persistent map emits is the push, and a draw-clean answer skips the ensure the push lives in and then latches it B-1 M-4 Q-15 m-11 6d9548c4 [Fix] (MG_Impl, PipeFill): make buffer_subdata_resident declare the live-host-writes bit - ApplyBufferWrite assigns it, so a silent content record writes false over a live write map M-2 6e6b35cb [Fix, Test] (MG_Pipe): replace the always-false live-host-writes wire, which no producer can survive, with the one statement that stays true - the bit is the buffer family's M-8 3f37ad2f [Fix] (DirectGLES): make the extent hostBase is good for a parameter of the flush ladder, so tier 1's widening refusal is live code the moment a SEG_STAGE snapshot is narrower than the queued range M-6 f19bde2a [Fix] (MG_Remote, GLImpl): gate the transform-feedback reconciliation on the transport like every other new site, and give the unwritten writeback wait a named Fatal instead of an empty body M-5 M-7 m-14 Q-16 c222db5f [Docs] (PipeStats): state in both entries that persistent-map-push and stage-buffer cover the same bytes under split, because at tier T2 a pushed block IS an ordinary resource_subdata M-3 2a539881 [Test] (MG_Test): drive the live-host-writes probe through the production chain instead of writing the record by hand, and pin both map edges and the disabled-push control by serial arithmetic B-1 (test) ``` ## 8.1 B-1 — the cycle, and the test that could not see it **Both halves fixed.** **The cycle.** The diagnosis is right and it is the C-1 regression one layer down. The rising edge of a write map emitted nothing, so for the one idiom the feature exists to serve - a coherent persistent map behind a static VAO - the server never learned a host writer was live; the only content record such a buffer produces is the push; the push runs inside `EnsureBufferResourceForHandle`; a draw-clean answer **skips** that ensure (`DirectGLES.cpp:691`) and then **latches** it (`:697`, and a coherent map bumps no mutation epoch); and `PushPersistentMapsBeforeVerb()` has no caller. Draw 3 onward draws frame 1's bytes for ever. **Fix: option (b) — the rising edge publishes a real record.** One block, the same shape the falling edge already proved affordable, so the server knows before the first probe. The probe then answers dirty for every draw while the map is live, the ensure runs, the push runs, the serial moves. `BufferObject.cpp`'s `NotePersistentMapStateChanged` carries the argument in full. Options (a), (c) and (d) were considered and rejected: (a) leaves the last frontend read in a function that has no frontend under spawn, i.e. it defers the actual deliverable; (c) has the server read client state and is legal only under inproc, which is the shape R-2 exists to forbid; (d) is c1's call site and b1 wiring the emit table would collide with the package that owns it - and it would still leave the *probe* feeding itself. **The test.** Rewritten to drive the production chain end to end and to touch the record only by reading it: the resource subsystem is armed with an empty ops table (`MG_Test/Pipe`'s `PushArm` shape), the buffer is constructed, respecified, mapped, written through the pointer, pushed, unmapped - all through the ordinary frontend entry points - and the case reads `MGPipeApplier().Resources[slot]`. The probe is handed a **null** frontend object, which is the question a spawned server actually has to answer. **Evidence, run three ways (`~/w7/p5-b1-negctl.sh`):** ``` === control: unmodified tree 100% passed, 0 failed out of 2 === A) wire producer deleted (PipeFill.cpp record.HasLiveHostWrites = ...) 50% passed, 1 FAILED out of 2 === B) edge record deleted (BufferObject.cpp NotifySubData(0, length)) 0% passed, 2 FAILED out of 2 === restored 100% passed, 0 failed out of 2 ``` (The two cases are `DirectGLESBufferDrawProbe.UnderSplitTheRecordAloneAnswersTheLiveHostMapQuestion` and the new `SplitBufferSet.BothEdgesOfAWriteMapPublishOneStateRecord`. Deleting the wire producer alone leaves the client-side edge case green, which is correct - it observes the client's serial, not the server's record - and that is why the two exist rather than one.) ## 8.2 M-2 — `buffer_subdata_resident` clearing the bit **Fixed**, one line in `MGPipeEmitBufferSubDataResident` beside the one in `MGPipeEmitResourceSubData`. The assignment in `ApplyBufferWrite` stays an assignment - "a content record emitted while nothing maps the buffer is how the state goes back to false" is the rule - so the fix is to make the second emitter speak rather than to make the applier merge. One thing worth recording: under R-6 this path is **not reachable today**. `MGPipeEmitBufferSubDataResident` is called only from `LandBytesIntoResidentStore`, which requires `IsGpuResident()`, and at tier T2 nothing adopts. So it is a latent defect fixed for P11 rather than a live one - which is also why no unit case drives it: there is no way to reach it in a split build without first implementing T0/T1. ## 8.3 M-3 — `pmap` double-counts `stage-buffer` **Fixed by amending the inventory, deliberately, and both entries say the same thing.** The alternative - subtracting the push at the staging site - makes `stage-buffer` under-report what the backend actually moves, which is the question that class exists to answer. So: `stage-buffer`'s "NOT covered" clause is now "not covered IN A MONOLITH BUILD ... COVERED UNDER SPLIT, AND DELIBERATELY OVERLAPPING", with the mechanism (a pushed block *is* an ordinary `resource_subdata` at T2, so it reaches `Ops_H_SubData` and is staged), and `persistent-map-push`'s entry now says "DOUBLE-COUNTED WITH stage-buffer, deliberately ... adding them is wrong". The inventory is contract and it now describes the build it is read in. ## 8.4 M-4 — `MOBILEGL_IPC_PERSISTENT_BLOCK_KB=0` **Fixed.** `blockBytes == 0` now returns before **either** edge emits, so the knob turns the whole mechanism off - state record included - and an unmap delivers nothing. The unit case is extended to drive `ReleaseMemory` under the knob and pins the exact serial arithmetic: with the push on, an unmap moves the change serial by **2** (the unmap's own `NotifyFlushMappedRange` plus the falling-edge record); with the knob at 0 it moves by **1**. A whole-buffer ship would have been indistinguishable from the correct case without that. ## 8.5 M-5 — the ungated D-J site **Fixed.** `GL_Drawing.cpp`'s `buffer->SyncGpuWrites()` in `FixupGsStripCaptureOrder` now carries `MG_Config::Transport != Monolith`, like every other new site. The review's reading is right: on Magma in a `build-split` lane running `MOBILEGL_TRANSPORT=monolith` the capture targets *are* marked, the fence at the caller still runs, and the readback was pure new work that `integration-gpu` cannot observe. ## 8.6 M-6 — the tier-1 guard and the missing snapshot **Half fixed, half handed over with a spelling.** The guard is no longer unreachable: `FlushPendingRangesFrom` now takes the extent the bytes behind `hostBase` are good for (`hostBaseFrom`, `hostBaseTo`, defaulting to the whole store), and tier 1 is decided against the **intersection** of that window with the queued range. With the default the intersection is the queued range and every caller is byte-identical - G1 and the 1117/1117 monolith lanes say so - but the moment w1 passes a real `SEG_STAGE` snapshot extent the refusal is live code on the production path, not only under a unit case. A verify build also names a too-narrow snapshot (`Fatal{StageSnapshotTooNarrow}`), because tiers 2 and 3 would copy from outside it and neither of them has a guard of its own. What is **not** landed is the snapshot itself. It is encoder work - the bytes have to be staged into `SEG_STAGE` at emission and the applier handed the segment - and that is w1's surface, not `Managers.cpp`'s. b1's v1 already disclosed this; the review is right that disclosure without a mechanism is not enough, so the mechanism is the parameter plus the wire above. **Integrator: this is the ruling I am asking for** - either the snapshot moves to w1 formally (in which case the parameter is the handoff and w1 must pass a real extent), or it comes back to a b1 fix round 2 once w1's encoder exists to stage into. ## 8.7 M-7 — `AwaitBufferWriteback` was a no-op with no red spelling **Fixed.** The null-session arm still returns at once - that is the correct answer when the emission *was* the application, and a loop there would hang every gate lane. The other arm is now a named Fatal: a session exists, the apply side is no longer synchronous, and the flag is still set, so the caller is about to read a stale shadow. `Fatal{UnimplementedWritebackWait}`, `MGLOG_F` + `abort`, the same shape as `EmitTables.cpp`'s `UnmigratedVerbFatal`. The hole now has a red spelling before s1/c1 arrive rather than after. ## 8.8 M-8 — the pin was lifted only where nobody builds **Fixed by building it.** `~/w7/p5-b1-verifysplit.sh` adds the missing matrix cell, `build-verify-split` = `MOBILEGL_PIPE_VERIFY=ON` + `MOBILEGL_BUILD_DISAGGREGATED=ON` + `INPROC=ON`, which is the only configuration where `MGPSubData::HasLiveHostWrites` can be non-zero **and** the G4 field comparator is compiled. Numbers in §8.15. The gate skeleton every later package copies should carry this cell; it is the one that makes a new wire field's comparator mean anything, and its absence is exactly why B-1 and M-2 could hide. ## 8.9 m-9 — the "same commit" claim **Corrected** in §1 row 5 above. The brief's requirement is real and I did not meet it; the tree is consistent, the report was not. ## 8.10 m-10 — two comments describing a carrier that does not exist **Fixed.** `BufferObject.h`'s accessor comment now names `MGPipeEmitResourceSubData` / `MGPipeEmitBufferSubDataResident` and `MGPSubData`, and `BufferObject.cpp`'s block comment no longer claims the bit rides `MGPResourceDesc`'s pad as an ID-18 M4 metadata field. Both were left behind by `450e21cc`'s carrier move. ## 8.11 m-11 — "the adoption path notes the change itself" **Fixed by making it true.** `NotePersistentMapStateChanged()` is now called beside `AdoptPersistentMap` in `AcquireMemoryRange`'s push arm, so an adoption really does withdraw the entry and clear the published bit. Unreachable under R-6, which is why it was latent; it is P11's the day a tier mints one, and a comment that describes behaviour nothing implements is worse than no comment. ## 8.12 m-12 — `LargeArenaAdoptionScenario` **Fixed in the handoff, not in the code** (`MG_IntegrationTest/**` is t1's). Added to §4.1: the scenario asserts an adoption that R-6 now makes impossible, so under a split lane its `mpr`-and-adoption assertions have to become **decline + `mpr` unchanged**, with the test NAMES kept (G14). R-6 says so in as many words and v1's handoff list omitted it. ## 8.13 m-13 — unsynchronised process-wide state **Accepted, not fixed, and flagged.** `g_producerMarks` is diagnostics and its worst case is a lost increment in a counter no gate reads. `m_livePersistentMaps` is load-bearing and is mutated from `~BufferObject`, which is not necessarily the GL thread. Table 3 calls the client-role singletons client-exclusive and the verb barrier makes at most one of {GL thread, apply thread} runnable - but "the GL thread" is not the same claim as "one thread", and a buffer released from a worker is a real shape. **This belongs to v1's thread work**: it needs the same answer as the unlocked `pendingRanges` / `pendingResidentWrites` probes the scout raised (§5.4), and picking a lock here without that answer would be guessing. ## 8.14 m-14 — `MOBILEGL_IPC_ADOPT_TIER` refuses late and refuses everything **Half fixed.** The message now distinguishes 0/1 ("tier T0/T1, which P11 implements") from any other value ("is not an adoption tier"), so a `=7` no longer dies naming P11 as though it were real. The **lateness** is not fixed: refusing at parse means a validity rule in `ConfigLoader.cpp`, which is c0's file and, per the preamble, a knob change goes through the integrator. Filed rather than taken. ### Q-15 — R-6's second door **Answered by closing it.** The configuration is in scope - a split build whose backend registered no MGPipe resource ops is exactly what a bring-up lane looks like - so all three legacy `AcquirePersistentMap` arms in `BufferObject.cpp` (`TryAdoptLargeStorage`, `EnsureGpuResidentStorage`, `AcquireMemoryRange`) now carry a transport test. R-6's "always" is now true at the frontend as well as at the applier, and E3(d) is no longer the only thing that would have noticed. ### Q-16 — the seam, written down **Answered in the header.** `GpuWritePending.h` now states what no row covers: the backend's own scratch buffers - Espryt's converted-vertex-stream and primitive-restart substitution buffers, Magma's UBO ring - have no `MarkGpuWritten` today either, so the client set is no narrower than monolith's. Not a regression; a standing hole in both, and now one a reader does not have to re-derive. ## 8.15 Acceptance, re-run after the fixes ``` builds : pull / push / verify / split rc=0, plus the new build-verify-split G1 vs ~/w7/p5-before-libMobileGL.so, --threshold 0: .text 10806323 -> 10806323 (+0, +0.000%) 27811 -> 27811 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed nm pull MG_Remote : 0 nm split MG_Remote : 213 gen_pipe --check : up to date --self-test : 9 trips, positive control OK include-closure : 4 probes, 0 skipped, 0 problem(s) ctest -L unit : 1807 / 1807 / 1807 (pull / push / verify) 1864 (split) 100% passed build_verify_split : 1864 / 1864, 100% passed <- M-8's new matrix cell, VERIFY + DISAGGREGATED (it went red on its FIRST run, on ResourceEmit.TheLiveHostWritesWireFiresOnTheCallAPersistentMapProducer- WouldSetItOn, which is precisely the tripwire M-8 said had been deleted rather than lifted - so the lane earned its place before it was green) ctest -N all labels: pull=2924 push=2924 split=2981 G2 pull vs push : 0 diff lines G14 split vs push : 57 added, 0 REMOVED integration-gpu, MOBILEGL_TRANSPORT=monolith build-push : 1117 / 1117, names 1117, 0 not present at ~/w7/p5-before-ctest-names.txt build-split : 1117 / 1117 ``` The one new ctest name since v1 is `SplitBufferSet.BothEdgesOfAWriteMapPublishOneStateRecord`, present in all four builds (skipping outside split) so G2 and G14 do not move. ## 8.16 One thing the fix round changed about the shape, stated plainly The rising-edge record means a write map now costs **one `resource_subdata` at map and one at unmap**, split-only, on top of the per-validate-point push. On a 128 MB streaming arena that is two 64 KiB records per map/unmap pair, which is noise beside Phase 1's whole-span push - but it is new traffic and it is the price of the probe not feeding itself. Phase 2's dirty bits should subsume both: once the server can see which blocks moved, "a host writer is live" stops being a separate announcement. The reviewer's option (d) - wiring `PushPersistentMapsBeforeVerb()` at the validate point - is still the right long-term shape and is still c1's call site. When it lands, the rising-edge record becomes redundant for the *persistent* case (though not for a plain write map, which emits no push at all) and should be re-examined rather than inherited.