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.
31 KiB
P4a package A — wire, adversarial review of rounds v2 + v3 (wire-review-v2)
Scope: the eight commits after the rebase point on refs/heads/p4a/wire
(7b5b3957 fb709418 52a16a1e be0e032a 22a3e265 = v2, aff381c7 282325d5 70e742a3 = v3), HEAD 70e742a3,
against ID-8 / ID-12 / ID-15 / ID-17 / ID-18 M3+M4 / ID-19(b) / ID-21 / ID-22, wire-review-v1.md
(C1, m1-m5), wire-v2.md, wire-v3.md, esprytobj-review-v1.md (C-1), clientfb-review-v1.md (M3/M4),
esprytdraw-v2.md and c0e (now integrated: pipe = e8502a61, ID-25).
Read-only in /home/swung/w7/p4a-wire. Every experiment ran in a private detached worktree
~/w7/p4a-review-wire2 at 70e742a3 (build-push, -j 8, CCACHE_BASEDIR=/home/swung/w7), which is
removed (git worktree prune run, log deleted, p4a-wire clean, its three build dirs untouched).
Verdict
ACCEPT WITH MAJORS — one major, four minors, two nits. Nothing here blocks the merge: every line of
applier behaviour this round changed is correct on the code I read, and the three items the round was launched
for (C1's level scoping, ID-19(b)'s per-object table, ID-18 M3/M4) are implemented as specified and gated by
tests that I re-killed with mutations of my own. The major is a package-boundary contract gap — wire changed
what the stored Target byte MEANS and told nobody, and package E has a live consumer of it — plus the memo key
E must now use. Both are exactly the class of silent hand-off defect ID-19 exists to close, and neither is
visible to any gate P4a owns.
What I re-measured rather than took on trust
| claim | result |
|---|---|
ctest -L unit = 1680 in all three builds |
1680 / 1680 / 1680 (ctest -N, LC_ALL=C) |
name sets build-linux == build-push, 2646 |
2646 == 2646, 0 differing lines |
| applier suites = 130 | 130 |
| MU1 (Named arm moves the draw binding) | rc 8, 1/74 — FramebufferEmit.ANamedRecordDescribes… |
| MU4 (metadata arm disarmed) | rc 8, 1/74 — TextureEmit.ARespecifyThatRedefinesNoStorage… |
| MU8 (C1's per-level scoping disarmed) | rc 8, 1/74 — TextureEmit.ARespecifyOfOneLevelKeeps… |
| baseline clean | 74/74, rc 0 |
MX3 (mine) — stale-generation test disarmed (record.Gen != fbo.Gen → false) |
rc 8, 1/74 — AFramebufferHandleWhoseGenerationHasMovedOn… |
MX2 (mine) — the Level half of the level-scoped erase key deleted |
rc 8, 1/74 — ARespecifyOfOneLevelKeeps… |
MX1 (mine) — the UploadTarget half of the same key deleted |
rc 0, 74/74 — GREEN (MINOR-1) |
git diff -- MobileGL/MG_Pipe/generated rc 0; gen_pipe.py contains no reference to PipeApply.h
(its only hit is the string it emits, gen_pipe.py:672), so §3's default-tail / acceptance-return
source-compatibility claim survives v3 intact. No [[nodiscard]]; the four P3a call sites
(PipeFill.cpp:645, 678, 691, 705) discard the Bool and compile.
Findings
MAJOR-1 — the stored record's Target byte silently changed meaning, and wire-v3.md §5's package-E section does not say so (the one consumer is DirectGLES.cpp:2983)
Where. PipeApply.h:397-401 (MGPipeFramebufferRecord) + :383-396 (its comment) + :957-975
(MGPipeApplySetFramebufferState's contract) + wire-v3.md §5 "Package E".
Consumer: /home/swung/w7/p4a-esprytdraw/MobileGL/MG_Backend/DirectGLES/DirectGLES.cpp:2982-2987.
Before ID-19(b) the applier held two records, one per binding, so record.Target read out of the
read-binding record was a live statement about the current binding pair: Target == Both meant "the object on
the read binding is the same object the draw pass just synced". After ID-19(b) the table is per object
(PipeApply.cpp:2207-2211, the record is written at FramebufferRecords[state.Fbo.Slot] whatever the target
is), so the stored Target is a property of the last emission that named that object, from any target
including Named — not of the object and not of the bindings. c0e's own comment
(MGPipeTypes.h:596-600, "the draw-buffer array … reaches the driver's bound draw framebuffer only for a
record whose Target is Draw or Both") reads as an invitation to keep asking the binding question of the field.
E does exactly that:
// DirectGLES.cpp:2982
if (target == FramebufferTarget::Read &&
record.Target == static_cast<Uint8>(MG_Pipe::MGPipeFramebufferTarget::Both)) {
backendObj->SyncReadBufferToBackend(currentFBO); // skip the draw pass's work
Failure scenario. FBO X is bound to both bindings, so its record says Both. A DSA call on X —
glClearNamedFramebufferfv(X, …), glBlitNamedFramebuffer(…, X, …), or any of the DSA attachment /
draw-buffer / read-buffer setters ID-19(c) puts a Named record in front of — overwrites the record at X's
slot with Target = Named (bindings untouched, which is correct). On the next draw the read pass no longer
matches Both, falls through to a full SyncToBackend(currentFBO, Read) and re-does the whole attachment and
draw-buffer walk the draw pass has just done, every frame that issues such a call. The wrong-direction case —
a stale Both on an object that is no longer bound to both, which would make the read pass skip a
framebuffer that was never synced — is the one that corrupts, and it is what the field-test shape now
permits in principle.
Refutation I tried, and it holds for the corrupting direction only. I read B v2's emitter
(~/w7/p4a-clientfb/MobileGL/MG_Impl/Pipe/FramebufferEmit.h:219-260): EmitFramebufferState walks both
bindings at every validate and rebuilds a Both/Draw/Read record from the current pair, suppressed on the
(drawHash, readHash) pair, and Target is a ContentHash input (:193). So any binding change re-emits
both records with the right Target, and the stale-Both corruption is not reachable while B keeps that
shape. What survives the refutation is (a) the Named false-negative above — cost, not corruption, but
per-frame cost on exactly the DSA traffic ID-19 added — and (b) that a correctness property now rests on an
undocumented emitter habit rather than on the applier's contract. Wire answers the binding question exactly
and cheaply — BoundFramebuffer[Draw] == BoundFramebuffer[Read] (ID-19(d)) — and wire-v3.md §5's E section
says only "a reference becomes a pointer", listing the seven BoundFramebufferRecord call sites and the
SyncCurrentFBOByRecord null test while omitting the one site that reads a field whose meaning moved.
Two further inaccuracies in the same §5-E section, found by reading E at 9b8441a6: the quoted half-described
test if (MGPipeHandleIsNull(st.DrawFramebuffer.Fbo) || …) return false; no longer exists — E v2 replaced
it (ID-23 F2) with drawUnrecorded/readUnrecorded plus a loud one-sided branch at DirectGLES.cpp:2865-2894
— and the line reference :2765 now points at g_fboSyncedSerials. The section is written against E v1.
Fix (wire's half is two sentences). In PipeApply.h beside MGPipeFramebufferRecord: "State.Target is
the target of the LAST EMISSION that named this framebuffer, Named included; it is not a statement about the
object's current bindings. The binding question is BoundFramebuffer[t] == fbo (ID-19(d)) and nothing else."
In wire-v3.md §5-E: add DirectGLES.cpp:2983 to E's change list with that expression, and re-derive the
quoted shapes from E v2.
MINOR-1 — the UploadTarget half of the level-scoped erase key is ungated: a mutation that deletes it is GREEN, and the case that claims to pin it does not
Where. PipeApply.cpp:1646-1652 (the erase loop); MG_Test/Pipe/TextureEmitTest.cpp:473-545
(ARespecifyOfOneLevelKeepsThePendingUploadsOfTheOthers), specifically :503-511.
The key is (UploadTarget, Level) and the code is right:
// PipeApply.cpp:1648
if (it->UploadTarget != level->UploadTarget || it->Level != level->Level) continue;
The case's own comment at :503-504 says the second face exists "so that the level number alone cannot be
what matched". It can. I applied MX1 — delete the UploadTarget clause, leaving
if (it->Level != level->Level) continue; — rebuilt and ran the seven emit suites: rc 0, 74/74. The
symmetric mutation MX2 (delete the Level clause) is red. So exactly half of the key is gated.
Why the case misses it. Trace it: the second-face respecify at :507 is fed levelDesc(1, 0x8058u), which
is byte-identical to the descriptor the previous respecify stored — so it is classified metadata-only
(RespecifyRedefinesNoStorage true) and takes the third arm, erasing nothing at all, contrary to the comment.
The only real per-level erases in the case name (kTex2D, 1), and (kTex2D, 1) is the only entry with
Level == 1, so the Level half alone decides both of them.
Failure scenario the gate should hold. A cube map: glTexSubImage2D on face 0 level 1 and on face 1 level 1
both pending behind Espryt's incomplete-texture bail, then glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 1, …)
redefines face 0 level 1 only. With a Level-only key the loop erases the first entry with Level == 1,
which is whichever face was accumulated first — face 1's texels are dropped for good (its client dirty flag was
cleared at its own emission, D-D5 step 1). That is C1's bug one axis over.
Refutation I tried. The shipped code has the full key, so this is a test gap and not a live defect. But
the level-scoped erase is the thing C1's whole rework exists to make right, MU8 is the round's own proof that
the arm is load-bearing, and half of its key has no mutation behind it — which is the condition under which a
later refactor of AccumulatePendingUpload's keying would land green.
Fix. In the same case, make the second-face respecify a real redefinition (move one storage-defining field,
e.g. levelDesc(1, 0x8051u)) that names {secondFace, 0}, and assert (kTex2D, 0) survives while
(secondFace, 0) goes. Add it to the mutation table as MU10 = MX1.
MINOR-2 — FramebufferSerial is one number for the whole family and a Named write moves it, so E's per-target memo is invalidated by DSA traffic on framebuffers that are not bound; the table has no per-record serial to key on instead
Where. PipeApply.h:600-603 (Uint64 FramebufferSerial), PipeApply.cpp:2229 (++ on every applied
record, Named included); consumer DirectGLES.cpp:2758-2765 (SyncedFramebufferSerialMemo, serial) and
:2903 (if (SyncedFramebufferSerialIsCurrent(target, st.FramebufferSerial)) continue;).
Before ID-19(b) the serial moved only when a bound framebuffer was described, so a per-target memo keyed on
it was about as sharp as the four g_fboSynced* arrays it retires. Now every Named record — one ahead of
each BlitNamedFramebuffer, each of the four ClearNamedFramebuffer*, and each DSA attachment / draw-buffer /
read-buffer setter (ID-19(c)) — moves the same number, invalidating both targets' memos and forcing a full
attachment re-sync of the currently bound draw and read framebuffers on the next draw, for a write that touched
neither.
Refutation. Over-invalidation is always safe: the memo is stamped after the sync, so a spurious miss costs
a redundant SyncToBackend, never a wrong frame. And P4a is behaviour-neutral today (all four
kMGPipeWired*Subsystem are 0 on this tree), so nothing regresses now, and ID-6 records performance rather
than gating it. That is why this is a minor and not a major. It is still a real coarsening introduced by this
round, on the draw path, and the applier is the only place that can undo it.
What E should key on, and what wire owes it. The exact question is "has the record describing the
framebuffer bound to target t changed, or has the binding changed". That is
(BoundFramebuffer[t], <that record's own serial>). Wire supplies the first half and not the second:
MGPipeFramebufferRecord (PipeApply.h:397-401) carries Gen, Live, State and no serial. Three lines fix
it — a Uint64 Serial in the record, ++record->Serial beside PipeApply.cpp:2229, and an accessor (or
simply returning the record struct rather than &record.State from a second entry point). Until then E's
honest key is (BoundFramebuffer[t], st.FramebufferSerial), which at least stops a binding change being
missed but does not stop the over-invalidation.
MINOR-3 — the kMGPipeFramebufferTargetNamed retirement recipe in wire-v3.md §7.2 is one site short, and c0e has already landed
Where. wire-v3.md §7 item 2 names "six readers": PipeApply.cpp:2153, FramebufferEmitTest.cpp:276,
:443, :454, and prose at PipeApply.h:595 / :965. A full grep of the tree finds nine occurrences:
those six plus the declaration PipeApply.h:173, its static_assert :174-176, and a ninth the recipe
misses — the prose mention at PipeApply.cpp:2148.
This is now live rather than hypothetical: c0e is integrated (ID-25, pipe = e8502a61,
MGPipeFramebufferTarget::Named = 3, Count = 4), so the static_assert at PipeApply.h:174 fires on the
merged tree and PipeApply.h is included by Managers.cpp, DirectGLES.cpp, VulkanRenderer.h and
fourteen test TUs — the whole tree fails to compile until the retirement lands. ID-24 already schedules that
edit ("the Named-constant retirement edit done by the integrator in the wire tree after its rebase,
unit-tested, one commit"), so the ordering is handled; only the recipe's completeness is not. The trip wire
itself is well designed and I would keep it — it is the reason the local constant cannot be forgotten.
Refutation. A prose mention left behind compiles fine, so the miss costs a stale comment, not a build. It is a minor only because the recipe presents itself as exhaustive ("One constant, six sites, no behaviour change") and the integrator is being asked to execute it verbatim under time pressure.
MINOR-4 — resource_create's reserved-slot refusal is the one refusal class with no observable at all in a shipped build, and the header's contract says there are only two
Where. PipeApply.cpp:1524-1527 (MOBILEGL_ASSERT + return false); contract text PipeApply.h:777-789.
The header states the acceptance-return rationale as "a dead or stale handle is a counted no-op and a corrupt
record is a Fatal that deliberately moves no counter" — two classes. resource_create with
Slot < kMGPipeFirstAllocatableSlot is a third: MOBILEGL_ASSERT compiles out at INFO (which every gate build
and every shipped build is), nothing is counted, nothing is logged, and before M3 the call was a completely
silent drop. The other two create refusals (:1533 no resource target, :1550 slot past
kMGPipeMaxResourceSlots) are MGP_TRIP_WIRE_REPORT and therefore at least an MGLOG_E.
Refutation. M3 is precisely the cure: the emitter now sees false and must not advance its dedupe or clear
a level's flags, and TextureEmit.TheCreateAndRespecifyCallsAnswerWhetherTheRecordWasAccepted (:757) pins
it. So the hole M3 was written to close is closed. What remains is that the header's two-class taxonomy is
incomplete where it is used to justify the return — one clause, not a code change.
NIT-1 — kMGPipeMaxFramebufferSlots is a unilateral bound with no counterpart in the allocator
PipeApply.h:156 sets it at 1u << 16; MG_Impl/Pipe/SlotAllocator.h has no per-kind ceiling for
MGPipeKind::Framebuffer (only the ShaderCso composite band is policed), so nothing on the client side
prevents a handle above the cap. The verdict on one is correct and loud, not UB:
MGP_TRIP_WIRE_REPORT → abort() under MOBILEGL_PIPE_VERIFY/POISON, MGLOG_E + return under push, with
nothing stored, no serial moved, and AFramebufferRecordThatNamesNoUsableHandleIsRefusedRatherThanStored
(:528) asserting the table did not resize. Unreachable in practice — the client frees a framebuffer's
slot at death (PipeFill.cpp:1260-1261, NotifyAndFree(MGPipeKind::Framebuffer, …)), so the high-water mark
tracks peak live FBOs, not lifetime creations, and 65 536 simultaneously live FBOs is not a thing. Identical
in shape to the VertexElements and SamplerCso bounds v1 accepted. Recorded so F can assert
HighWater(Framebuffer) < kMGPipeMaxFramebufferSlots if it wants a gate.
NIT-2 — contract review m1 (the tautological static_assert, MGPipeTypes.h:185-188) is still unclaimed
v2 declined it because c0c was in flight on that file; c0c, c0d and c0e have all landed since and it is still there. Not wire's file; the integrator's to fold or drop.
What I checked and found correct (so a later round does not re-derive it)
C1's fix (dimension 1). The three arms at PipeApply.cpp:1640-1653 are ordered metadataOnly →
level == nullptr (whole-resource PendingUploads.clear()) → the keyed erase, and the precedence is right:
M4's rule refines C1's rather than contradicting it (a call that replaces no storage replaces no level's
coordinate system), and it is the arm that must win, because the mask republish B v2 will emit is exactly the
call that would otherwise eat texels standing behind Espryt's incomplete-texture bail. Both are pinned —
ARespecifyThatRedefinesNoStorage… (TextureEmitTest.cpp:687) drives the metadata arm with a level pointer
and carries its own negative control (move Width/Height and the same call drops the level), and MU4/MU8 are
red on the right cases. A cube-face respecify erases by the full packed key and leaves the other five faces
standing — correct in code, half-gated (MINOR-1). Keys are unique by AccumulatePendingUpload's construction
(:813-824 looks for the pair before appending), so erase(it); break; is right and no iterator survives it.
The packed decode (dimension 1). v2's local SubDataResourceTargetOf is gone; PipeApply.cpp:1698 and
:1711 go through MGPipeSubDataResourceTargetOf / MGPipeSubDataUploadTargetOf, TextureEmitTest.cpp:505
through MGPipePackSubDataTarget. A grep for 0x00FF / 0xFF00 / & 0xFF / >> 8 across
PipeApply.{h,cpp} and the two test files returns one hit, and it is inside a comment (:520).
SubDataNamesABuffer (:512) still matches the whole field, which is ID-12 as written and is what c0c's
own static_assert (MGPipeTypes.h:962) keeps exact. MGPRespecifiedLevel::UploadTarget is Uint16 holding
the same packed value PendingUpload::UploadTarget stores verbatim — types line up, and the header
(PipeApply.h:763-775) states the pairing to B in as many words.
ID-19(b) (dimension 2). Table slot-indexed by the handle with the generation checked on lookup
(PipeApply.cpp:2235-2264); the three nulls are separated correctly and only the third is loud
(++StaleFramebufferRecordLookups + MGLOG_E_ONCE, counted apart from RefusedObjectCalls, mutable so
E keeps its const auto&); the accessors are defined in the .cpp so MGLOG stays out of the header's
include closure; RecordAt deliberately does not apply kMGPipeFirstAllocatableSlot, which is what lets
the reserved default framebuffer {0,1} be a real record at slot 0 while MGPipeHandleIsNull (Slot == 0 && Gen == 0, MGPipeHandles.h:75) still refuses {0,0} — both pinned as positive/negative controls at
FramebufferEmitTest.cpp:528. Draw/Read/Both set the bound handle(s) and Named sets neither
(:2214-2221, MU1 red). Reset clears BoundFramebuffer only and keeps the table (:1183, MU7); the
argument — a DSA-only framebuffer has no re-emission trigger, since InvalidateAll re-sends the two bound
records — is sound, and the slots come from one process-global allocator so nothing aliases across a switch.
ReleaseObjectRecords clears the table and the two bound handles and the three unit windows
(:1211-1245, m1 discharged by fixing, MU6). ReadSurface is stored verbatim under every target, which is
what c0e (ID-25) rules and what §5-B.1 tells B to fill.
M3 (dimension 3). Bool on Create (:1524) / Respecify (:1576) / SubData (:1678); every refusal
path returns false (create: reserved slot, null table, slot past the bound; respecify: null table, no live
record at that generation; subdata: the resource-target gate and AccumulatePendingUpload's overflow), every
accepted path returns true including a metadata update and including an unregistered MGPipeResourceOps
(right: the op table is a property of the build, not of the record). ResolveResourceIn still moves
RefusedResourceCalls on the stale-generation path — asserted at TextureEmitTest.cpp:775.
M4 (dimension 4), and W10 is now the contract's own ruling. RespecifyRedefinesNoStorage
(PipeApply.cpp:558-585) compares field by field (not memcmp — MGPResourceDesc carries Pad0/Pad1) and
excludes exactly BindMask, ImageBindableHint, GlNameForDiag and the padding. ID-25 records c0e's ruling
as "metadata = BindMask, ImageBindableHint, GlNameForDiag; HasDefinedContent is storage-defining" — the
implementation matches the contract exactly, including the field ID-21's narrower list omitted. A metadata
respecify therefore cannot flip defined content: HasDefinedContent differing makes the call a redefinition.
I chased the one way that could have gone wrong — whether B's builder moves HasDefinedContent independently
of the storage fields, which would silently reclassify every mask republish as a redefinition — and it does
not: TextureEmit.h:272-275 derives it from mipmap->GetMipmapLevelCount() > 0, in lockstep with
desc.Levels (:261), and Immutable from texture.IsImmutable() (:268); Usage/StorageFlags are never
written for a texture. A respecify that changes only Levels, or only Samples, is not metadata (both are
compared at :568-570), and the C1 case now feeds the level counts a real mip build produces so it exercises
the per-level arm rather than the metadata one. MGPipeResourceRespecifyNeedsAck is false by construction for
every metadata record because the buffer target is excluded outright (:559) — the right shape, since a
second suppression rule is one the transport would have to learn.
m2 / m3 / m5 (dimension 5). RefusedObjectCalls' comment (PipeApply.h:507-535) now names four families,
states positively that set_framebuffer_state resolves no record and can only fault, and — new in v3 — that
ID-19(b) does not change that, because the per-object table is written by that call and never looked up by it,
the lookup refusal being counted apart. Three test cases assert RefusedObjectCalls == 0 across the family.
The Renderbuffer enumerator and everything >= MGPipeResourceTarget::Count are refused in the texture half
(:1699-1712) with both halves in the line. unmap_persistent's kind check (:1876-1882) is
Fatal{ProtocolCorruption}, uncounted — the same verdict resource_destroy gives at :1804-1810, asked of a
narrower question (Buffer only vs any of the three kinds), which is right for a donation that is buffer-only.
Exit order and hygiene (dimension 7). g_applier is MGPipeApplierState& g_applier = *new MGPipeApplierState{}; (PipeApply.cpp:396) — the deliberate never-destroyed singleton P3a ID-18/21 asks for.
FramebufferRecords rides inside it and holds only PODs (MGPFramebufferState's surfaces carry MGPipeHandle,
never a SharedPtr), so this round adds no new static holder of frontend SharedPtrs and no new
destructor reaching into pipe state. MGLOG_E_ONCE is used once, on a genuine seam defect — correct level, and
MGLOG_D would have been wrong there. MGPipeApplierReleaseObjectRecords still has no production caller
(tests only), as the header says.
Integration lanes (dimension 6). The nine mutations are honest — I re-ran three at random and all three
killed exactly the named case, and my two extra mutations behaved as the design predicts (MX2 red, MX3 red).
No DirectVulkan lane applies to this round: the seven emit suites are backend-agnostic unit tests, all four
kMGPipeWired*Subsystem are 0, PipeApply.{h,cpp} are push-only TUs, and G1 is 0/0/0/0 — the "leak test per
new kind on the DirectVulkan lane" that ID-8 requires belongs to the packages that mint (B and C), not here.
The deviations, judged
| # | verdict |
|---|---|
| W1–W6, W8 | Stand. v1's review accepted them and nothing in v2/v3 disturbed them. |
| W7′ | Superseded by W11's third arm, correctly. The metadata arm precedes the scope arm and refines it; the scope argument is unchanged. |
W9 (MGPipeApplyResourceSubData returns Bool) |
Accept. Source-compatible, gen_pipe.py re-verified as never parsing this header, no [[nodiscard]], P3a's call sites unchanged. Extended cleanly to Create/Respecify in v3. |
| W10 (a buffer is never metadata-only; the comparison is wider than ID-21's list) | Accept, and it is no longer a deviation. ID-25 records c0e ruling HasDefinedContent storage-defining and metadata = exactly the three fields wire excludes, so the implementation and the contract now agree field for field. Both reasons wire gives are right independently: the asymmetry argument (comparing too much costs one dropped upload on a call B does not emit; comparing too little uploads past the end of a new level) picks the safe direction, and excluding the buffer target is what makes "no reallocation ack" true by construction rather than by a second rule. I verified the claim the deviation rests on — that none of the extra fields moves on a mask republish — against B's actual builder (TextureEmit.h:243-285); it holds. |
| W11 (identical storage fields clear nothing, whatever the level pointer says — and its sharp edge) | Accept as written, and the sharp edge is benign in the direction that matters. A per-level respecify whose descriptor does not move keeps the level it names. Wire calls this unreachable on B's memcmp dedupe; I add the stronger argument it did not make: even if B did emit one, nothing is lost — the descriptor is unchanged, so that level's coordinate system is unchanged, and the surviving box is re-uploaded from the client's current shadow, i.e. correct content over a possibly larger region. The failure W11 warns about would need a redefinition that moves no descriptor field at all, which HasDefinedContent, Levels, Immutable and the extent between them make impossible on B's builder. Honest, well-flagged, and the ten minutes of B-review it asks for is the right ask. |
Rework list
Small, and none of it blocks the merge.
- MAJOR-1. Add the two sentences to
PipeApply.hbesideMGPipeFramebufferRecord(:397): the storedState.Targetis the last emission's target,Namedincluded, and is not a binding fact; the binding question isBoundFramebuffer[t] == fbo. Amendwire-v3.md§5-E to listDirectGLES.cpp:2983with that replacement expression, and re-derive its quoted E shapes from E v2 (9b8441a6) — the half-described test it quotes no longer exists and:2765is nowg_fboSyncedSerials. - MINOR-1. Make the second-face respecify in
TextureEmitTest.cpp:503-511a real redefinition of{secondFace, 0}and assert(kTex2D, 0)survives; add MX1 (delete theUploadTargetclause atPipeApply.cpp:1648) to the mutation table as MU10 and show it red. Fix the comment at:503-504, which currently claims a property the suite does not hold. - MINOR-2. Either add
Uint64 SerialtoMGPipeFramebufferRecordwith++besidePipeApply.cpp:2229and an accessor, so E can key per bound record — three lines, and it is the applier's to give — or state inPipeApply.h:600-603that the family serial is deliberately coarse and that DSA traffic on unbound framebuffers invalidates a bound target's memo, so E's verification round records the cost rather than discovering it. - MINOR-3. Add
PipeApply.cpp:2148to §7.2's retirement site list (nine occurrences, not six). - MINOR-4. One clause in
PipeApply.h:777-789: the reserved-slot create refusal is neither counted nor a Fatal, and the return is its only observable.
The integrator's post-merge re-run list
- The full five-part gate of D.3 on the merged head, plus
symbol_report --threshold 0(P4a's admitted set is empty) andp3a_untouched_regions.sh 37da3c3a HEAD. Nothing in this review substitutes for it; what I did re-measure on wire's own tree (unit 1680 × 3, names 2646 == 2646 with 0 differing lines, applier suites 130, generated-dir diff rc 0) matcheswire-v3.md§6 exactly. - The Named-constant retirement is merge-blocking, not a later round. c0e is integrated (
e8502a61,Count= 4), so thestatic_assertatPipeApply.h:174fires the moment wire is rebased, andPipeApply.his in the include closure ofManagers.cpp,DirectGLES.cpp,VulkanRenderer.hand fourteen test TUs — the tree does not compile until it is done. ID-24 already schedules it as one commit in the wire tree; use the nine-site list from MINOR-3, not §7.2's six, and re-run the seven emit suites (130) plus-L unitafterwards. - After B v2 lands, the three ten-minute reads
wire-v3.md§7.3 names — all five DSA entry points plus the DSA setters emit aNamedrecord; the suppressor is per framebuffer and not one global slot (B v2 at8534abf7is still one slot,MGPipeSuppressorSlot::SetFramebufferState, on the(drawHash, readHash)pair — that is the shape §5-B.2 asks B to change); the mask republish moves onlyBindMask/ImageBindableHint. Add a fourth: B must keep re-emitting both bound records at every validate — the refutation of MAJOR-1's corrupting direction rests on it, so it is now a load-bearing property and should be stated in B's own header rather than left as a habit. - After D v2 lands:
PushedFramebufferRecordmust lose itsasTargetparameter and itsrecord.Fbo == fbotest (~/w7/p4a-esprytobj/…/Managers.cpp:8216-8227still has both) or C-1 is only half fixed; D's teardown must not read a binding afterMGPipeApplierReleaseObjectRecords. - At E's verification round:
DirectGLES.cpp:2983becomesst.BoundFramebuffer[Draw] == st.BoundFramebuffer[Read](MAJOR-1); the sevenBoundFramebufferRecordcall sites (:2127, :2273, :2863, :2864, :2905, :4009, :4179) takeconst auto*and null-check;FramebufferRecordMatchesBindingand the one-sided loud branch at:2865-2894take pointers;StaleFramebufferRecordLookupsmust read 0 on every scenario — a non-zero value is the seam defect ID-19 was written to make visible, not traffic. - D-K2's fourth row ("bit 10 requires bit 11", ID-15's H1) is still owed by D and F; the applier's
Fatalon a nullBuiltinSampleris unchanged and correct, and the0x5fflane still aborts until that row exists. - Docs: the brief's D-C2 (record "per bound target") and D-J4 (framebuffer records as working state) are both amended by ID-19(b) and by this round; D.5 should carry the correction beside c0e's.
- LFS:
git lfs install --localin each worktree would stop ID-13's trap recurring after every WSL restart —/usr/bin/git-lfsexists but no worktree hasfilter.lfs.smudge, which is why wire restored 92 fixture blobs by copy this round.