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.
40 KiB
P3a package B review — the client (client-review-v1)
Reviewed: p3a/client 73bab3d6 / 1ae6b4f4 / 71805d59 / a0ac79cc, worktree /home/swung/w7/p3a-client, diffed
against 39722687. Read-only; a private worktree at a0ac79cc was used for the scanner experiments in §6 and
removed (git worktree list is back to seven, p3a-client is clean at a0ac79cc).
VERDICT: REWORK
Two critical defects, both latent on this tree and both live the moment the granted *BaseInstance call sites
and package wire land underneath. Five majors, one of which (the missing call sites) is known and granted.
The emission bodies themselves are, with the exceptions listed, careful and brief-conformant; the failures are
at the seams — draw state parked in a container whose Reset() is context-scoped, and a re-publication path
that was built for the CSO half and not for the resource half.
The package's own §5 evidence stands. I re-ran the four generator/closure gates and both scanner directions myself (§6); all green, and the scanner's new mechanism has a live control.
1. Critical
B-C1 — the tracker's context Reset() zeroes the pending base instance that the same call is about to read
MG_Impl/Pipe/Tracker.h:373 — Reset() does m_pendingBaseInstance = 0;. Reset() is called from
MGPipeTracker::Update itself at Tracker.h:194-197:
if (m_context != &ctx) { Reset(); m_context = &ctx; }
and the value is read two screens later at Tracker.h:286 (bit 9's shutter) and at
MG_Impl/Pipe/PipeFill.cpp:1335 (tracker.PendingBaseInstance() → EmitVertexBuffers).
Failure scenario. eglMakeCurrent(ctxB); glDrawArraysInstancedBaseInstance(..., baseinstance = 7);
The granted call site runs MGPipeSetPendingBaseInstance(7) immediately before MGP_FILL. MGP_FILL →
MGPipeValidateForVerb → tracker.Update(*ctxB, ...) sees m_context != &ctxB, calls Reset(), and the 7 is
gone before either reader sees it. FreshlyPrimed then sets every bit, so set_vertex_buffers does go out —
carrying BaseInstance = 0. Espryt computes fetchBaseInstance = UseNativeBaseInstance() ? 0 : 0 and, on a
device without GL_EXT_base_instance, fetches every instanced array from element 0. One silently mis-shifted
instanced draw per context switch, on the emulation path, with no gate: the desktop retrace corpus is
single-context, DrawParametersScenario does not switch contexts between the setter and the draw, and the unit
case that pins the hash (VertexInputEmit.ABaseInstanceChangeAloneStillEmitsTheVertexBufferSet) calls
EmitVertexBuffers(Ctx(), 7) directly and never touches the tracker.
Refutation attempted, three ways, all fail. (a) "Reset only happens at teardown" — no; Tracker.h:194
fires on every change of the current GLContext, which is what wire-review-v1.md's C1 established for the
applier through the same three lines. (b) "the setter could run after Update" — it cannot; D-H2.1 and B's own
PipeFill.h:65-70 put it immediately before MGP_FILL, and Update is inside it. (c) "a fresh context is
a fresh server, so clearing is right" — the pending base instance is not context state, it is this call's
argument. Everything else Reset() clears is a latch describing what the server was told; this one is an
input that has not been read yet. The fact that Reset() clears it is the bug, not the mitigation.
Fix (one line, in B's file): delete Tracker.h:373. The value is already cleared unconditionally at the end
of every verb (PipeFill.cpp:1446) and again in MGPipeLeaveVerb (PipeFill.cpp:801), so it is provably 0 at
every Update except the one that immediately follows a setter — which is the one that must see it. Add the
case that would have caught it (§7).
B-C2 — the resource family has no re-publication path after MGPipeApplierReset(); the vertex-input family has one
PipeFill.cpp:1404-1412, the FreshlyPrimed arm, resets four things: the CSO cache, the applier, the set-hash
suppressor and — B's addition, correctly — MGPipeVertexInputEmitterInstance().Reset(). Nothing resets or
re-arms MGPipeResourceTrackerInstance(), and MG_Impl/Pipe/ResourceTracker.h:390-393 states the absence as
policy: "A unit fixture's per-case reset. Never called by the library: a context change does not invalidate
a handle."
That is true of the handle and false of the record. MGPipeApplierReset() empties g_applier.Resources
(wire-review-v1.md C1: "At each switch g_applier.Resources is emptied (:558)"), and the client's only
producer of a record is MGPipeEmitResourceCreate, emitted from the BufferObject constructor
(MG_State/GLState/BufferState/BufferObject.cpp:44-45), which a context switch does not re-run.
Failure scenario. Share-group buffer B created under ctxA. eglMakeCurrent(ctxB); first draw →
FreshlyPrimed → MGPipeApplierReset() empties Resources. Now glBufferSubData(B): the client emits
ResourceSubData for a handle whose record is no longer Live; the applier's FindResource returns null and
the call is dropped — "nothing stored, nothing dispatched, no serial" — with the only trace a
MOBILEGL_ASSERT that is inert at INFO, which is what both gate builds use. The upload is lost. Every later
draw from B renders stale geometry, and IsBufferDrawCleanByHandle reports clean because no serial moved.
Refutation attempted. (a) "wire owns the reset, so this is wire's defect" — wire raised it and explicitly
routed the decision here: "B (whose ResourceTracker.h mints the handles) or the integrator must decide:
re-emit ResourceCreate + ResourceRespecify on first use after a reset, or take Resources /
VertexElementsCsos out of the reset … This … must be settled before p3a/client lands"
(wire-v1.md §5 item 1). client-v1.md does not mention the item anywhere — not in §4's deviations, not in
§6's "left undone", not in §7's re-run list. (b) "not reachable today" — correct and irrelevant; it is
reachable the moment wire + espryt are underneath, which is the tree the integrator is building. (c) "the
CSO precedent covers it" — it does not, and B proved that by having to add MGPipeVertexInputEmitterInstance() .Reset() for exactly this reason (PipeFill.cpp:1408-1411). The asymmetry is the finding: B saw the problem
for the half it could fix from the emitter and did not carry the reasoning to the half whose producer is a
constructor.
Fix (in B's files, the option wire named "re-emit on first use"): give MGPipeResourceTracker a
Uint64 m_publishEpoch and a per-Entry PublishedEpoch; bump m_publishEpoch from the FreshlyPrimed arm
beside the emitter reset; in MGPipeEmitResource{Respecify,SubData,FlushRange,Readback,MapPersistent} and
…BufferSubDataResident, when entry.PublishedEpoch != m_publishEpoch, emit ResourceCreate (and, for the
non-respecify calls, a ResourceRespecify carrying the live GetSize()/GetUsage()/GetStorageFlags()) before the
call and stamp the entry. That is the same shape MGPipeVertexInputEmitter::EmitCreate already has. If the
integrator instead exempts Resources / VertexElementsCsos from the reset, B still owes the deletion of
ResourceTracker.h:390-393's claim and a line saying which decision was taken.
2. Major
B-M1 — the three MGPipeSetPendingBaseInstance call sites (known, granted; here are the exact points)
MG_Impl/GLImpl/Drawing/GL_Drawing.cpp. The public entry points at :1088, :1108, :1132 delegate to the
*_Backend functions, and MGP_FILL is in the latter. One line each, immediately above the MGP_FILL:
| function | file:line of the MGP_FILL |
line to insert above it |
|---|---|---|
DrawElementsInstancedBaseVertexBaseInstance_Backend (:655) |
GL_Drawing.cpp:662 |
MG_Pipe::MGPipeSetPendingBaseInstance(baseinstance); |
DrawElementsInstancedBaseInstance_Backend (:678) |
GL_Drawing.cpp:684 |
MG_Pipe::MGPipeSetPendingBaseInstance(baseinstance); |
DrawArraysInstancedBaseInstance_Backend (:707) |
GL_Drawing.cpp:713 |
MG_Pipe::MGPipeSetPendingBaseInstance(baseinstance); |
The value is the raw baseinstance argument, never EmulatedFetchBaseInstance(baseinstance): whether to
emulate the shift is the server's (wire-v1.md A1 stores hdr.BaseInstance unresolved and hands the decision to
package C). Each site must be inside #if MOBILEGL_PIPE_PUSH or behind a pull-build no-op — MGPipeSetPending BaseInstance is declared in PipeFill.h outside any guard but defined at PipeFill.cpp:783, which is inside
the file's push-only region, so a pull build would fail to link if the call is unguarded. Check that when the
lines land.
What the reset in MGPipeLeaveVerb must guarantee — and what it actually guarantees. grep over
MobileGL/ finds MGPipeLeaveVerb called from exactly two places: MG_Test/ScopedPipeVerb.h:73 and
MG_Test/Pipe/TrackerTest.cpp:651. No GL entry point calls it. So PipeFill.cpp:801's clear guarantees
only that a unit case which opens a ScopedPipeVerb cannot leak a base instance into the next case. The
production guarantee is entirely PipeFill.cpp:1446's unconditional tracker.ClearPendingBaseInstance() at the
end of step 3, and the property it must hold is: the pending value is consumed by exactly the verb whose entry
point set it, and is 0 at every other Update. It holds — with one hole, PipeFill.cpp:1371's
if (ctx == nullptr) return;, which skips the clear; a base-instanced draw with no live context would leave the
value standing for the next verb. Harmless in practice (a draw with no context is already a no-op) but it is the
one path the "neither of them relies on the other" claim in client-v1.md §4 B-DEV-3 does not cover, and
B-C1's fix makes Reset() no longer a second safety net. Move the clear above the ctx == nullptr return, or
say why not.
B-M2 — the content emitters mutate the process-global slot allocator on a path Espryt documents as off-thread
PipeFill.cpp:622, 656, 669, 696 each open with MGPipeResourceTrackerInstance().Acquire(buffer), which is
ResourceTracker.h:262-268: MGPipeSlots().Acquire(...) (a FindByLifetimeId on a non-atomic map, then a
free-list pop and a map insert on a miss) followed by m_bySlot.resize(slot + 1).
D-A2's SubData row preserves "the off-thread/stale queue" arm of Ops_SubData verbatim, i.e. the design
states that BufferObject::NotifySubData is reachable off the render thread. Today that path touches one
const BufferBackendOps* read and the backend's own mutex. B adds an unsynchronised insert into a global map
and a possible Vector reallocation to it. Two threads in Acquire for two different buffers, or one in
Acquire while another is in Free from ~BufferObject, is a data race with a torn free list and a dangling
m_bySlot span as the outcomes.
Refutation attempted. "Acquire is a lookup for an existing buffer, so it does not mutate" — the lookup
itself walks a map another thread may be rehashing, and m_bySlot.resize is reached whenever the slot index
exceeds the vector, which a concurrent Acquire on the other thread can cause between the two statements.
"contract-review item 13 already accepts non-atomic parity" — that item is about the g_resourceOps pointer,
a single word written only at bring-up; this is a container mutated on the hot content path.
Fix, and it is cheap and strictly better: the handle is minted unconditionally in the constructor
(BufferObject.cpp:44), so on every content path it already exists. Replace Acquire(buffer) with
Find(buffer) (ResourceTracker.h:273, const, no allocator mutation) in
MGPipeEmitResource{SubData,FlushRange,Readback}, MGPipeEmitBufferSubDataResident and
MGPipeEmitMapPersistent, and treat a null handle as a loud MGLOG_E_ONCE + return (which is also the
diagnostic B-C2 needs). Acquire then survives only in the constructor path and in the two validate-time
vertex emitters, both of which are GL-thread by construction.
B-M3 — hostBytes disagreement with package C: espryt latches the shadow base, the client sends base + offset
espryt-v1.md §1 e1: "GLESBufferResource gains one push-only member, const Uint8* hostBytes: the client's
shadow base as the last content-carrying resource call left it. It is what the three-tier flush, the pool
reseed and the full re-upload read on the handle arm", and D10: "(The three content-carrying calls that do
record it — respecify / sub-data / flush-range — all carry the client's own shadow.)"
The client sends, per D-A2 and correctly: PipeFill.cpp:623 base = buffer.MappedData() then base + at per
piece; PipeFill.cpp:666 buffer.MappedData() + offset. Only MGPipeEmitResourceRespecify
(PipeFill.cpp:614) passes the true base. So after any glBufferSubData(b, 4096, …) Espryt's hostBytes is
shadow + 4096, and the next pool reseed or full re-upload reads 4096 bytes past the store's end.
Refutation attempted. "B is wrong to add the offset" — no: D-A2 spells bytes = MappedData() + offset for
SubData and MappedData() + Offset for FlushRange, and the applier hands the pointer straight to
ops->SubData(res, record, bytes) where the record's box carries the offset. B is brief-conformant; espryt's
latch is the side that must change (hostBytes = bytes - MGPipeSubDataBufferOffset(record), or drop the latch
on the two ranged calls and keep it only on respecify). Recorded here because it is a merge-time defect that
neither package's own gates can see, and espryt-v1.md §6 item 14's confirmation list does not include it.
B-M4 — the sampled BindMask widens the D-A3 hole in exactly the direction the risk register names, and the stated ownership reason misquotes C.1
ResourceTracker.h:332-380 (RefreshBindMask), called only from MGPipeEmitResourceCreate
(PipeFill.cpp:592) and MGPipeEmitResourceRespecify (PipeFill.cpp:606).
Two separate problems.
(a) The stated reason is wrong. B-DEV-2 says the bind entry points "are MG_Impl/GLImpl/Buffer/GL_Buffer.cpp's,
which C.5 assigns to no package and C.1 does not list for this one". C.1's file table does list
MobileGL/MG_State/GLState/BufferState/BufferState.{h,cpp} with the note "the sticky everBoundAs mask's bump
points at the buffer bind entry points (D-A3), all #if MOBILEGL_PIPE_PUSH", and C.5 gives B
MG_State/GLState/BufferState/**. I checked whether the brief was simply wrong about where the binds are:
BufferState (BufferState.h:38-43) only vends BindingSlot<BufferObject>& / BindingSlotRange1D&, and the
.Bind() calls are at GL_Buffer.cpp:1463, :1518, :1531 and in BindBufferRange_State (:1602) — none of
them B's. So the substance of the deviation survives; the sentence does not, and the difference matters
because it reads as "no package owned it" when what is true is "the brief pointed at a file that turned out not
to contain the entry points". Correct the record.
(b) The hole is not the one B describes. B says sampling "widens it from 'a bind after the last respecify'
to 'a bind after the last resource emission of any kind'". The real widening is a transient bind: with
OR-at-bind the mask is correct in client state forever after the bind, and any later respecify publishes it;
with sampling, glBindBuffer(ELEMENT_ARRAY, ebo); glDrawElements(…); glBindBuffer(ELEMENT_ARRAY, 0); glNamedBufferSubData(ebo, …); glNamedBufferData(ebo, …) publishes a respecify whose sample sees no binding at
all, so ELEMENT_ARRAY is never set even though a respecify followed. The DSA idiom makes this the common case,
not the corner: TryAdoptLargeStorage's own comment (BufferObject.cpp:215-217) names glNamedBufferSubData as
what MC 26.3 streams with, and a DSA-defined EBO may never be bound at any emission. MGPResourceDesc::BindMask & ELEMENT_ARRAY is the kCapNeedsHostIndexBytes switch; getting it wrong silently disables restart rewriting
and multi-draw flattening under split, is invisible in monolith, and the brief's risk register says this is
"the one P3a deliverable whose only real gate is a unit test".
Fix, entirely inside B's files and better than the handed-on GL_Buffer.cpp hook for the bit that matters:
MGPipeVertexInputEmitter::EmitVertexBuffers and EmitIndexBuffer already resolve, at every draw, exactly the
attribute buffers and the element-slot buffer (VertexInputEmit.h:200, :240). Call
MGPipeResourceTrackerInstance().NoteBoundAs(handle, BufferTarget::Vertex) / …::Index there. Any buffer ever
drawn from then carries its bit for the rest of its life, whether or not it was bound at a storage op, and the
GL_Buffer.cpp hook stays a P8 nicety for the seven bits nothing keys on. Also call RefreshBindMask from the
other four emitters, not just create/respecify — the mask is only published on create/respecify, so extra
sampling can only widen the sticky union.
Secondary, same function: BindEpoch (ResourceTracker.h:414-425) sums only the 14 global slot versions plus
the bound VAO's element-slot version and identity. It does not see the 84×4 indexed binding points. That is
sound today only because BindBufferBase_State also binds the generic slot (GL_Buffer.cpp:1531, with the
comment saying why); if that ever stops being true, CONSTANT/SHADER_BUFFER/ATOMIC/STREAM_OUTPUT start
being missed silently. One sentence in the comment, or fold GetTouchedBufferBindingPointCount into the epoch.
B-M5 — UnmapPersistent has no producer, and the omission is not recorded
D-A2's row and my review brief both name the pair "map/unmap persistent → MapPersistent / UnmapPersistent".
PipeMutation.h:1626-1657 declares eight emitters plus the mint; there is no MGPipeEmitUnmapPersistent, and
grep finds no client call to MGPipeApplyUnmapPersistent. So a catalogue call that wire implemented is dead
in P3a and its gate can never go red.
Refutation attempted, and it succeeds on the substance: BufferBackendOps has seven hooks and none of them
is an unmap; PipeResource::ReleasePersistentMap() (BufferObject.cpp:157, from RedefineStorage) tells the
backend nothing today and the backend learns from the Respecify that follows. Emitting UnmapPersistent would
be new behaviour, which D-J forbids. So the right answer is "no producer in P3a, deliberately" — but
client-v1.md §6 does not say it, and a reader of the catalogue cannot tell a deliberate absence from a missed
hook. Add the row to §6 and a sentence beside the MapPersistent emitter.
3. Minor
| # | finding | file:line |
|---|---|---|
| m1 | MGPipePendingBaseInstance() has no caller anywhere, and its stated reason — "Exists for the unit gate, which drives the emitter without a draw entry point to set it" — is false: no test calls it (grep finds only the declaration and the definition). Either use it in the case B-C1 needs, or delete it. |
PipeFill.h:70, PipeFill.cpp:787 |
| m2 | contract-review must-know item 10 ("B must reject an attribute index ≥ 256 before narrowing") is not discharged: a bare static_cast<Uint8>. Safe only by an invariant of VertexArrayObject, which is another package's file — the same "assert rather than assume" rule B applies, correctly, to the staging mirror at PipeFill.cpp:1288-1300. Same class: entry.Stride = static_cast<Uint32>(attrib.Stride) narrows a signed value with no check (contract-review m6 asks for both directions). |
VertexInputEmit.h:89, :206 |
| m3 | MGPSubData::SourceIsVerbatimLevelShadow = 1 is set unconditionally by the shared builder, including on the buffer_subdata_resident path where the bytes are the application's staging store, and on the FillSubData path where they are a locally expanded pattern (BufferObject.cpp:497-506). The field's documented meaning is "are these bytes an untransformed level shadow?"; on those two callers the answer is no. Nothing reads it on the buffer path today. |
ResourceTracker.h:200, PipeFill.cpp:645 |
| m4 | MGPipeBuildSubDataRecord's Bool return is discarded inside both walk lambdas. Unreachable because the pre-pass at ResourceTracker.h:235-237 proves every piece encodable first — but if that pre-pass is ever relaxed, a false emits a zeroed record (null handle, size 0) rather than refusing. One if. |
PipeFill.cpp:626-629, :644-647 |
| m5 | MGPipeClientOnGpuWritten discards rangeCount/ranges. espryt-v1.md D8 makes the shape a contract point "the client's OnGpuWritten must read it that way": one range of kMGPipeWholeBuffer, deliberately not zero ranges, because zero will mean a fully narrowed set at P8/P9. B's implementation would mark a whole buffer written for a zero-range announcement. Safe direction today; encode the contract (assert the shape, or name it in the comment). Same function resolves-to-null silently, unlike its sibling at :461-464. |
ResourceTracker.h:485-489 |
| m6 | ResourceEmit.EveryBufferTargetSetsItsBindMaskBit asserts respecified.BindMask == MGPipeBindMaskForBufferTarget(target) — the emitted value against the table under test. It pins the plumbing, not the table, for 14 of the 15 targets; only Index gets a literal (:228). The risk register calls this case the only real gate on the ELEMENT_ARRAY bit. Assert literals per target. |
ResourceEmitTest.cpp:214-216 |
| m7 | set_index_buffer has no content suppressor and bit 10's shutter mixes vaoIdentity, which includes GetConfigVersion(). Any VAO reconfiguration therefore re-emits an identical MGPIndexBuffer and moves the applier's IndexBufferSerial, which is precisely the memo espryt's m_syncedIndexSerial early-out reads. Correctness is fine (over-fire); it is a measurable per-draw cost for a reconfiguring app. Latch m_lastIndex and skip the apply when unchanged. |
VertexInputEmit.h:235-245, Tracker.h:293-301 |
| m8 | DirtySurface.def:292-294's new comment states that MarkVertexArrayForDeletion "→ delete_vertex_elements, published through the death notice". By B-DEV-8 this package emits no delete_vertex_elements; the row's comment asserts a publication that becomes true only when package C lands. Mark it "(from espryt)". |
DirtySurface.def:292-294 |
| m9 | Bits 7 and 8 are documented as an independent per-subsystem A/B, and are not: EmitVertexBuffers/EmitIndexBuffer name buffer handles by {slot,gen} whether or not the resource family created a record for them, so a mask with bit 8 set and bit 7 clear sends the server handles it cannot resolve. Not reachable from 0x1ff or from G12's 0x7f; state the coupling where an operator reads it. |
VertexInputEmit.h:200, :240 |
| m10 | desc.Width = static_cast<Uint32>(buffer.GetSize()) truncates silently for a store ≥ 4 GiB; the applier's range gate then aborts a legal write as Fatal{ProtocolCorruption}. The 32-bit Width is the contract's, not B's, but the truncation should be a refusal or a MOBILEGL_ASSERT. |
ResourceTracker.h:180 |
| m11 | MGPSubData::Blob is filled (Seg, Size) while wire-review-v1.md M-E leaves it an open one-rule decision ("either gate Blob.Size when non-zero, or state … that B must not fill it"). Harmless — the applier never reads it — but B and wire must not settle it differently. |
ResourceTracker.h:201-203 |
| m12 | Create/destroy pairing is gated in two different places: the create at the call site (BufferObject.cpp:45), the destroy inside the helper (PipeFill.cpp:699). A buffer constructed while a table is registered and destroyed after UnregisterBufferBackendOps() frees its slot without emitting ResourceDestroy, leaving the applier record Live and Espryt's twin (a driver buffer id) alive on a slot about to be re-handed-out. Espryt's M2 (GetOrCreate(MGPipeHandle) adopting a stale generation) is the only thing standing between that and a cross-buffer id mix-up. Latch the decision on the Entry at mint time and use the latched value in both places. |
BufferObject.cpp:45, :55-57; PipeFill.cpp:695-706 |
4. Judgement of the nine declared deviations
| dev | verdict |
|---|---|
B-DEV-1 declarations in PipeMutation.h |
Correct, and the only shape available. MG_State may not include MG_Impl/Pipe/ResourceTracker.h; the closure probe still reports mutation-header OK, 84 headers, 0 forbidden (I re-ran it). The forward declaration of BufferObject is the whole coupling. Accept. |
B-DEV-2 sampled BindMask |
Accept the mechanism, reject the reasoning and the hole assessment. See B-M4. |
| B-DEV-3 bit 9's shutter gains the pending base instance | Correct and necessary; keep it. D-H4 read literally does not work, for exactly the reason B gives: neither GetAnyVaoAttributeGeneration nor vaoIdentity moves on a base-instance-only draw, so the emitter is never reached and the content hash never gets its chance to refuse suppression. The over-fire is bounded to draws that carry one and the first plain draw after. But it is what makes B-C1 fatal: the deviation put draw state into the shutter without moving it out of the container whose Reset() is context-scoped. Accept with B-C1's fix. |
| B-DEV-4 what the widened scan found | Accept. Both rows are real (BumpSamplingResolutionGeneration had no row at all; NoteUnitTouched is unreachable by pGLContext->), the `kPulledPartialShutter |
B-DEV-5 TrackerTest follows kMGPipeDirtyEmittedAtP3a |
Accept. The name is unchanged (G14), the property is unchanged, the P2 constant was not edited in place, and the three new arms are asserted by name. |
| B-DEV-6 the splitter is a capped walk, cap as a parameter | Accept, and it is better than the brief. D-A2's "the emitter must split" is genuinely unreachable at the record's own bounds — a second piece starts ≥ 2³²−1 past the first, already past the 2³¹−1 offset cap — and refusing whole (all-or-nothing, nothing emitted before the decision) is the only safe answer for a content write. The unit case drives the split at 32 MiB, which is the bound P5 will actually hit. |
B-DEV-7 kMGPipeResourceTargetBuffer / MGPipeBindBit spelled client-side |
Accept, with the coordination item live. Target = 0 for the buffer arm matches MGPipeTypes.h:148's documented order and a zero-initialised record. Nothing in wire-v1.md or espryt-v1.md states a different value; the integrator must still confirm it once, as B asks. |
B-DEV-8 no delete_vertex_elements here |
Accept. C.1's emitter list names only three, and the consumer is MG_Backend's. See m8 for the .def comment. |
| B-DEV-9 the two client callbacks are installed over a null slot only | Accept. Installing from the mint's one-shot means they exist before any backend can call them, and never over an entry a backend claimed. See m5 for the shape. |
Two things client-v1.md claims that I could not sustain: §4 B-DEV-3's "neither of them relies on the other
being called" (B-M1 — MGPipeLeaveVerb is called by no GL entry point, so in production there is only one
clear, and PipeFill.cpp:1371's early return skips it), and §2's "the verify lane cannot regress on account of
a skipped field — there is none", which is true and which I re-derived independently (§5).
5. Dimension-by-dimension, where I did not raise a finding
(1) Emission correctness. All eight/nine dispatch sites carry exactly one call and fall through unchanged:
~BufferObject (:50-57), NotifyRespecify (:67-71), NotifySubData (:83-87), NotifyFlushMappedRange
(:99-106), TryAdoptLargeStorage (:233-237), SyncGpuWrites (:371-379), LandBytesIntoResidentStore
(:430-452), FillSubData's nullability probe (:488-495), EnsureGpuResidentStorage (:598-604),
AcquireMemoryRange's persistent arm (:650-658). I diffed each push arm against the pull arm below it
statement by statement; the guards (m_size != 0, bytes.size > 0, !IsGpuResident && Write && !FlushExplicit)
are reproduced exactly, and the size == 0 and decline fall-throughs land on the same code. NotifyRespecify is
called after m_size, m_storageFlags, m_isImmutableStorage and m_hasDefinedContent are all final
(:187-189, :206-210), so Immutable — the kNeedsAck predicate's discriminator — is right for both idioms.
initialBytes is MappedData() only under HasDefinedContent, which preserves the orphaning idiom.
MGPipeResourceOpsHaveSubDataResident() discharges wire-review-v1.md n7 before wire wrote it down — the
client's dispatch gate on the resident path is the member, not the subsystem predicate. The BufferTarget
static_assert is complete (no default:, kMGPipeBindUnmapped sentinel, a second assert pinning
Index ⇒ ELEMENT_ARRAY).
"ResourceSubData on a buffer with no prior respecify": not reachable from a legal GL sequence. A
glBufferSubData on an unsized buffer is INVALID_OPERATION/INVALID_VALUE at the GL layer and never reaches
NotifySubData; a zero-size glBufferData followed by a non-empty glBufferSubData is likewise rejected
upstream (and NotifySubData early-returns on size == 0 at :82 before any emission). The applier's Width
gate is therefore armed against a client bug, not against an application. B-C2 is the one way it fires.
(2) Vertex input. The wire conversion is field-for-field (VertexInputEmit.h:80-91) and I checked that each
of the eleven copied members is individually detectable by
EveryAttributeFieldSurvivesTheWireConversion: the fixture's three configuration families give every field at
least one non-default value across the 32 slots (Offset 64+4i, Stride 16+i / a binding-model 0, Type
cycling six values, Size 1..4, Enabled alternating, Normalized i%3, IsInteger i%5, IsLong on the two
L-format doubles, IsBgra on the tail, BindingIndex deliberately (i+5)%32 ≠ i). Each assertion is a
separate EXPECT_EQ naming both sides, under a SCOPED_TRACE carrying the index, so G7's scripted drop answers
by field name — B's hand-run of the IsBgra drop is representative, not lucky. AttributeCount/
BindingPointCount are both 32 and Blob.Size = 32*24 + 32*16 = 1280 exactly, which is what
wire-v1.md §5 item 2's Fatal{ProtocolCorruption} gate requires. Start = 0, Count = highest enabled + 1
means no enabled attribute can ever index past Count, so wire's "entries outside the window are not cleared"
cannot bite. BindingIndex == attribute index matches what espryt-v1.md §6 item 14 says
VertexBufferForBindingIndex's fast path assumes. The per-handle latch is per handle and includes Gen
(VertexInputEmit.h:172-174), so a recycled slot re-creates. The suppressor's reserved-0 rule is the
suppressor's own (SetHashSuppressor.h:62-63 remaps a computed 0 to 1); the emitter does not need to.
SetIndexBuffer is emitted independently of the CSO's configuration version. SyncClientSideAttributesForDraw Arrays is untouched and Res == kMGPipeNullHandle for a client array is emitted as designed.
(3) Tracker. The three MGPipeSubsystemForDirty arms are present and paired
(Tracker.h:141-148, asserted by the P2 static_asserts with no edit, exactly as the contract commit asked).
Bit 10's narrowing is real and its two cases are well built — in particular the wrap case cycles three
buffers, because two would put the version and the bound object on the same parity and the wrap would be
unobservable; that is the one construction that makes the identity half load-bearing.
(4) Verify-lane soundness. With bits 7 and 8 in kMGPipeWiredSubsystems (PipeFill.cpp:918-924), supplied
at PipeFill.cpp:1470 can newly be true only for a field whose SubsystemForEmitter returns one of the two.
kMGPipeSubsystemResources is returned for no MGPipeFieldEmitter (the resource family has no Coverage.def
emitted row), and kMGPipeSubsystemVertexInput names exactly GetBoundVertexArray, for which
EmittedCallSuppliesTheWholeField returns false (PipeFill.cpp:964-969). No field is newly skipped; P3a
retires no pull. That discharges contract-review must-know item 3, which said the omission would be silent and
catchable only by G4 — and the 79/79 verify-armed retrace with zero divergence and zero unarmed cases is the
independent confirmation. Ordering: the seven resource hooks emit after the frontend state they read is final
(above); the three vertex emitters run at validate time, after the entry point's state writes.
(5) G1. BufferObject.h is untouched; no member, no virtual, no base was added; every edit is inside
#if MOBILEGL_PIPE_PUSH and the constructor and destructor are out-of-line. sizeof(BufferObject) and its
vtable cannot move in a pull build, which is what the 0/0/0/0 reading against the original baseline says. The
one resize B found and fixed during b1 (SyncGpuWrites's dropped m_size == 0 ||) is exactly the failure mode
D-K predicts and is the evidence the gate can go red. Per ID-1/ID-8/ID-9 the reading is valid against the
baseline it was taken against; the re-measure is the rebase's.
(6) The scanner. I ran all three directions myself in a throwaway worktree at a0ac79cc:
inserting a row for a mutator that does not exist → rc=1, "STALE row SetSomethingThatDoesNotExist"; deleting
the BumpSamplingResolutionGeneration row → rc=1, "UNMAPPED mutator BumpSamplingResolutionGeneration";
and — the control B did not run — removing the new MGP_NOTE_MUTATION attribution from scan_file → rc=1,
"STALE row NoteUnitTouched", so the new mechanism itself has a live negative control. --check reports
75 mutators, 0 UNDECIDED, 0 COARSE; --self-test trips all 21 canned controls; --summary renders and its
known-limits line is down to the two blind spots the .def still declares. gen_pipe.py --check,
git diff --exit-code -- MG_Pipe/generated and check_include_closure.py (4 probes, 0 problems) are green.
(7) Tests. All eleven names C.1 asks for are present, in the two suites C.1 names, as plain TESTs with an
RAII scope — B's reason for refusing TEST_F is right and is worth propagating: a fixture files cases under the
fixture's name and would silently move them out of ctest -R 'VertexInputEmit\.', disarming G6 and G7. The pull
build declares the same names and skips, so the G2 name-set identity holds. No vacuous assertions except m6. Two
coverage gaps, both named above: nothing drives the pending base instance through MGPipeValidateForVerb
(B-C1), and nothing drives an emission after a FreshlyPrimed reset (B-C2).
(8) Hygiene. Four commits, single-line messages in [Type] (Scope): description form, no bodies, no
attribution lines; b1/b2/b3's messages are the brief's verbatim. Fourteen files, all B's by C.5 except
MG_Test/Pipe/TrackerTest.cpp, which C.5 assigns to nobody and which B-DEV-5 justifies. git status clean.
6. Rework list (ordered; 1-3 are blocking)
- B-C1. Delete
Tracker.h:373(m_pendingBaseInstance = 0;insideReset()), leaving the two verb-scoped clears. AddTrackerWalk.ABaseInstanceSurvivesTheFirstWalkOnAFreshContext: set the pending value,Walk()against a differentGLContextthan the previous case used, assertPendingBaseInstance() == 7at the emitter and that bit 9 fired. MovePipeFill.cpp:1446's clear above thectx == nullptrreturn at:1371, or record why not. - B-C2. Implement the publish-epoch re-emission described in §1, or carry the integrator's decision to
exempt
Resources/VertexElementsCsosfromMGPipeApplierReset(); either way delete the claim atResourceTracker.h:390-393and add a §6 row. AddResourceEmit.AResetApplierGetsTheResourceRepublishedBefore TheNextWrite. - B-M1. The three
MGPipeSetPendingBaseInstance(baseinstance)lines atGL_Drawing.cpp:662,:684,:713, guarded so the pull build still links, plus one integration assertion that a base-instanced draw reaches the emitter with a non-zero value. - B-M2.
Findinstead ofAcquirein the five content emitters; null handle →MGLOG_E_ONCE+ return. - B-M4.
NoteBoundAsfromEmitVertexBuffers/EmitIndexBuffer;RefreshBindMaskfrom the other four resource emitters; correct B-DEV-2's citation of C.1 in the result file; one sentence onBindEpoch's dependence onBindBufferBase_Statealso binding the generic slot. - B-M5. Record the deliberate absence of an
UnmapPersistentproducer, with the reason (noBufferBackendOpsunmap hook exists to convert). - B-M3 is not B's to fix — hand it to the integrator and package C verbatim (§2).
- Minors m1-m12 at B's discretion; m2, m5, m6 and m12 are the ones I would insist on, because each is a contract point stated elsewhere that this package is the last chance to encode.
7. Post-rebase verification the integrator must insist on
Rebase order is feat/disaggregated@5cb826b0 → wire (post-rework) → client. B touches none of the files
ID-9 names as conflict-prone (Managers.cpp, LargeArenaAdoptionScenario.cpp), so the rebase should be clean
apart from the ResourceEmitTest.cpp / VertexInputEmitTest.cpp append that C.5 predicts — resolve by union,
never by choosing a side.
- Re-take both baselines at
5cb826b0and re-run G1 (--threshold 0 --fail-on-symbol-set-change --fail-on-added-bytes 0) and G14 (ctest -Nname sets, pull vs push vs verify, andcomm -23against the baseline). B's §5 caveat about the replaced baseline is correct and is now moot under ID-9; the reading has to be retaken, not inherited. - The mirror-image assertions B's §7.1 owes. Every
ResourceEmit/VertexInputEmitcase gains a secondEXPECTonMGPipeApplier(): the storedMGPipeResourceRecord::Desc(Width, Usage, StorageFlags, Immutable, HasDefinedContent, BindMask),MGPipeVertexElementsRecord::Attributes[]/BindingPoints[],MGPipeApplierState::VertexBuffers[],VertexFetchBaseInstance, and the threeSerials.EveryAttributeFieldSurvivesTheWireConversionbecomes a round trip; G6's statement is only then about what the backend reads. - The
Blob.Sizegate, exercised.wire-review-v1.mdM-B measured that disabling it leaves the suite green. Withclientunderneath, a deliberateBlob.Sizeoff-by-one inEmitCreatemust produceFatal{ProtocolCorruption}in the verify build. Run it once as a negative control. - B-C1's and B-C2's scenarios on a real applier. A two-context integration case: draw with a base instance
immediately after a make-current (assert
VertexFetchBaseInstance == 7), and aglBufferSubDataon a share-group buffer immediately after a make-current (assert the applier'sSerialmoved and, once C1b lands, thatRefusedResourceCallsis 0). - B-M3, before
esprytis trusted. Confirm what Espryt latches ashostBytesforOps_H_SubData/Ops_H_FlushRange; if it is the rawbytespointer, it isshadow + offsetand must be corrected. AStreamedArenaScenariorecycle plus aCrossFrameBufferScenarioflush at a non-zero offset is the shape that catches it. - The two contract points
espryt-v1.md§6 item 14 lists, now answerable:OnGpuWrittenis announced as onekMGPipeWholeBufferrange (m5 — the client currently ignores the shape), andMGPVertexBuffer::BindingIndexis the attribute index for every entry (it is;VertexInputEmit.h:207). AddkMGPipeResourceTargetBuffer == 0(B-DEV-7) as a third. map-persistent-roundtripsbecomes non-zero the momentesprytregisters the table (G10), andMOBILEGL_PIPE_PUSH=0x7fvs0x1ffbecomes a behavioural A/B (G12) rather than an emission-only one. Both are currently unprovable and both are on the merged tree's critical path.- The four lanes and the verify-armed retrace re-run on the merged tree, with the note that
integration-gpu'sTheXIsActuallyArmedWhenTheEnvironmentPinsItOnfamily races on shared log files under concurrent load (MG_IntegrationTest/CMakeLists.txt:1040records the shape); B's chase-down was correct and the quiet run is the result to record.