mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-18 15:33:22 +09:00
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.
582 lines
36 KiB
Markdown
582 lines
36 KiB
Markdown
# 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.
|