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
P4a package D — p4a/esprytobj rework v2, focused re-review
Reviewed: refs/heads/p4a/esprytobj cce81d19..ef6beb28 (the seven rework commits) against
esprytobj-review-v1.md, INTEGRATOR-DECISIONS.md ID-12 / ID-15 / ID-18 / ID-19 / ID-23 / ID-27 /
ID-28, wire-v3.md + wire-review-v2.md, contract-v3/v5.md, gates-review-v1.md R1,
gates-review-v2.md, esprytdraw-v2.md. Read in full: the whole git diff cce81d19 HEAD
(Managers.cpp +892 / Managers.h +98 / SanityTest.cpp +218) plus the surrounding bodies of every
function it touches, PipeApply.{h,cpp}'s FramebufferRecordFor / AccumulatePendingUpload /
SubDataTextureFault, SlotTables.h's handle overloads, and — only to refute findings —
p4a/clientfb's TextureEmit.h and E's DirectGLES.cpp call sites.
Experiments in a private worktree ~/w7/p4a-rereview-esprytobj (removed at the end of this
round). Every number in §4 was measured on the rebased tree — D's thirteen commits replayed
onto the real pipe head 712c9467 — not on the temporary merged base.
Verdict: ACCEPT WITH MINORS
The critical and all four majors are closed, and closed the right way rather than papered over. ID-12, ID-15's fourth row, ID-18's M4, ID-19(d), E's item (4) and the R1/G9 probe are all in and I could break none of them. Nine minors below; two of them are owed before the verification round (N-1's log wording, N-2's census under-count, because the integrator's residual-refusal check is written from that census and would miss two of the eight shapes). Nothing blocks the merge.
The one thing the integrator must not do is run ID-32's rebase command as written — it fails, and §5 gives the recipe that works and builds.
1. Per-item closure table
| v1 item / ruling | verdict | where |
|---|---|---|
| CRITICAL (C-1) framebuffer record keyed by the bound target | CLOSED | PushedFramebufferRecord(fbo) = MGPipeApplier().FramebufferRecordFor(fbo) (Managers.cpp:8803, decl Managers.h:1879). The asTarget parameter and the record.Fbo == fbo test are gone; both DSA entry families reach it through SyncToBackend unchanged. FramebufferRecordFor (PipeApply.cpp:2235) is silent for the null handle and for an undescribed slot and loud + counted (StaleFramebufferRecordLookups, MGLOG_E_ONCE) on a stale generation — exactly what Managers.h:1888-1898 claims |
| … refusal BEFORE the bind | CLOSED in the twin, but see N-1 | the record block is :9054-9091, Bind(asTarget) is :9092. The claim the refusal line makes about the resulting driver state is false at every call site |
… the record's Target no longer compared to asTarget |
CLOSED | the old expected/Both block is deleted. What stays gated on asTarget is what reaches the driver's bound target: glDrawBuffers (:9151), the four masks (:9159-9192), glReadBuffer (:9220) |
ID-27 — any remaining record.Target == Both-style test in D |
NONE | grep -n 'Target *[=!]=' Managers.cpp at HEAD: 20 hits, every one of them glTarget/fbTarget/uploadTarget/glTextureTarget/asTarget/surface.TextureTarget/color.UploadTarget. MGPipeFramebufferTarget appears only at :8814-8815, as the BoundFramebuffer index. D has nothing of E's MAJOR-1 shape |
M-1 server re-dirty arms the applier's PendingUploads |
CLOSED | RearmPipeTextureLevelUpload (:3834, decl Managers.h:717), called from RequireImageBindableStorage (:5277). Entry is whole-level, RegionCount 0, merged with an existing entry, loud refusal at kMGPipeMaxPendingUploads (256). The three server-side MarkStorageDirty sites are enumerated at :3836-3856 and the third is correctly identified as the clear half |
| … keyed with the PACKED target so the consume site finds it | YES, verified end to end | the write is entry.UploadTarget = packedTarget (:3888) built with MGPipePackSubDataTarget(MGPipeResourceTargetForTextureTarget(GetTarget()), uploadTarget) (:5279); FindPipeTextureUpload (:3799), ConsumePipeTextureUpload (:3821) and the re-arm's own scan (:3872) all decode with MGPipeSubDataUploadTargetOf. Same key, both directions. See N-7 for the one asymmetry against wire |
| … consumed exactly once | YES | ConsumePipeTextureUpload swap-and-pops the first match and returns; at most one entry can exist per (uploadHalf, level) because RearmPipeTextureLevelUpload and wire's AccumulatePendingUpload both merge before inserting |
| … does the re-arm actually re-open the gate? | YES | the serial gate is m_isInitialized && m_syncedResourceSerial == Serial && PendingUploads.empty() (:6353-6357). RequireImageBindableStorage clears m_isInitialized and fills the set, so the gate misses on both counts. No recursion: the function early-returns on m_imageBindableStorageRequired |
M-2 storage from Desc |
CLOSED | seven MGB_STORAGE_* macros (:6244-6270), applied at currentTextureInfo/the storage-kind switch, mipmapCount, IsImmutable at both allocator branches, the two multisample allocations, and all sixteen GetFormat() reads |
… every StorageKind incl. buffer textures / multisample / cube / array |
YES | buffer texture: Desc.BufferForTexBuffer + EnsureBufferResourceForHandle + the BufOffset/BufSize window with kMGPipeWholeBuffer resolved live (:7324-7360, :7421-7443); multisample: MGB_STORAGE_SAMPLES / MGB_STORAGE_FIXED_SAMPLE_LOCATIONS at glTexStorage2D/3DMultisample; cube/array: the base extent is Desc.{Width,Height,Depth} and B fills those three from GetBaseSize() verbatim (p4a/clientfb:TextureEmit.h:185-188), deriving ArrayLayers in addition rather than instead — so §5-item-7's feared seam does not exist. I checked it so the integrator need not |
| … metadata respecify re-derives flags without reallocation | CLOSED, with N-4 | :6335-6339: ImageBindableHint != 0 || (BindMask & kMGPipeBindShaderImage) and !m_imageBindableStorageRequired → RequireImageBindableStorage. Idempotent, no reallocation from the mask alone (the reallocation is the widening, which is what the flag means on this backend) |
… HasDefinedContent honoured |
NOT READ, and not declared — see N-8 | it is storage-defining per c0e; the buffer family reads it (:1911, :1956, :2846), the texture arm never does and :6230-6237's "what the descriptor does NOT answer" does not list it |
M-3 SyncAttachmentObject from MGPSurface |
CLOSED | PushedSurfaceForAttachment (:8605) + SyncAttachmentSurface (:8631); call site :9299-9322. Res → twin by adoption, and Layered/Level/Layer/UploadTarget/TextureTarget off the surface |
… TextureTarget for the four masks, D-N functions byte-identical |
CLOSED, shas recomputed | PushedSurfaceTextureTarget (:8539) gates on Kind == kMGPipeSurfaceKindTexture and refuses kMGPipeSurfaceNoTextureTarget loudly. ShouldUseCaveatTextureFormat / BackendTextureFormatAddsAlpha and the two renderbuffer siblings are untouched — p4a_untouched_regions.sh 37da3c3a HEAD rc 0 on the rebased tree, and all six printed shas equal esprytobj-v2.md §4 exactly (791b54a3… 1d6f15c9… 19e614af… 3ae7e347… 822ca3b0… 266710e0…) |
… kMGPipeSurfaceNoTextureTarget never fed to the masks on a renderbuffer point |
YES | the renderbuffer arms of all four take the Kind == Renderbuffer branch and call the renderbuffer siblings, which take no target; IsIntegerColorSurface reads the format alone. PushedSurfaceTextureTarget is only reachable under Kind == Texture |
| … E's READ-only attachment parameter sync still reachable | YES | E's SyncReadFramebufferTextureAttachments lives in DirectGLES.cpp and calls SyncTextureParamsToBackend / SyncBuiltinSamplerToBackend; neither those two entry points nor their signatures changed, and nothing in this round touches E's file (git diff --stat: three files, DirectGLES.cpp not among them) |
M-4 AdoptTwinByHandle wired; ReleaseByHandle gone |
CLOSED in letter — see N-3 | two callers, :8657 (texture) and :8723 (renderbuffer). StateBackendObjectRegistry::ReleaseByHandle removed, the decision written where the method was (Managers.h:470-481); SlotTable::ReleaseByHandle untouched and still driven by SanityTest.cpp |
ID-12 MGPipeSubDataUploadTargetOf at find + consume, no bare comparison |
CLOSED | see M-1's row. MGPResourceDesc::Target still has zero readers; MGPFramebufferState::Target is no longer compared anywhere |
| ID-12 DV-2 / DV-4 | CLOSED | MGB_TEXPARAM_DS_MODE reads kMGPipeDepthStencilModeStencil (:7835-7839); the read-surface emptiness test keeps MGPipeHandleIsNull(Res) as the authority and cross-checks Kind against it, refusing when they disagree (:8877-8886) |
| ID-15 bit 10 requires bit 11, in the precedent's voice | CLOSED | ResolveTextureResourceSubsystemArm :3651-3664, through the shared PipeSubsystemDependencyMissing (:3521), guarded if (!refused) so the bit-7 row cannot pre-empt it. ResolveSamplerSubsystemArm's "the mirror pair … is FINE" sentence is corrected in place (:3692-3699); the mirror-pair table in esprytobj-v2.md §2(7) matches the source |
… the exact MGLOG_E sentence F's matcher expects |
MATCHES | one MGLOG_E line, "MGPipe: %s - REFUSING the dependent bit and running the legacy arm. Set both bits, or clear both" with what naming both bits in set-then-needed order. gates-review-v2.md §2.6 fed D's four real what strings through F's matcher: the two dependency rows match in both the 0x9ff and 0x5ff columns and all four near-misses are rejected. Nothing changed in that sentence after b6169dba, so F's measurement still applies at ef6beb28 |
E's item (4) InvalidateFramebufferHandleArmMemos inside InvalidateFramebufferBindingCache |
CLOSED as a declared two-line handshake (DV-13) | the call is Managers.cpp:8270-8278, inside the function, beside the pre-handle trio it clears; the declaration and the whole argument are at Managers.h:1996-2015, gated by #define MOBILEGL_ESPRYT_FBO_HANDLE_ARM_MEMOS_LINKED 0 (:2011). Can E's memo miss an invalidation once it is on? No — the three SanityTest.cpp callers (:2530, :2778, :2799) all go through FramebufferImpl::InvalidateFramebufferBindingCache, as do the six in DirectGLES.cpp, so being inside it is exactly the "forgetting is impossible" property E asked for. Half-done handshake does not link: the constant has no other reader and the declaration no other definition |
| G9 white-box probe (R1) | CLOSED, green on four arms, red under mutation — see N-9 for the residual | SanityTest.cpp:3184. Covers deferred-to-first-view as R1 demanded: the reading is taken while the texture is attachment-only, and the probe asserts before the sync that no sampler-view twin exists — the assertion the public scenario cannot make |
| ten minors m-1..m-10 | all closed or declared, individually re-checked (§3 of esprytobj-v2.md matches the source at every line I spot-checked) |
m-1 fixed + DV-14 declared (PendingUpload really is {UploadTarget, Level, UnionBox, Regions} — PipeApply.h; SourceIsVerbatimLevelShadow is genuinely unreachable); m-2 :6975-7001; m-3 :8063; m-4 :8888-8912; m-5 reworded; m-6 run (I re-ran it, §4); m-7 the nested #if is gone and the dispatcher's own guard at :182 really does open the whole function; m-8 :4194-4208; m-9 :4337-4352; m-10 restated — but the restatement is still short by two, N-2 |
| DV-9 wording | CORRECTED | the false sentence is withdrawn and the claim is narrowed to the property D-P actually requires. I verified that property directly and independently (§4): pull build at 712c9467 vs pull build at D's rebased head, +0 bytes of .text, 0 added / 0 removed / 0 resized / 0 renamed, identical file size |
| G1 0/0/0/0 mechanism (macros, not locals/lambdas) intact | YES | 20 push-arm #define MGB_* and 20 matching #undefs; every one takes the receiver it would have been spelled on, so the pull expansion is the pre-P4a expression in one pair of parentheses. MGB_RECT_SRC_PTR is a macro for the stated $_N-renumbering reason and the pull arm is literally (rectShadowPtr(rect)) |
| macro leak into headers | NONE | grep -rn 'MGB_LEVEL_|MGB_TEXPARAM|MGB_RBO_|MGB_STORAGE_|MGB_RECT_' MobileGL --include=*.h → no hits |
| purity greps (G13) | CLEAN | pGLContext → MG_Backend/MGPipe/PipeInputs.h:1 only; MGPipeResourceOps ∌ MG_State (0) |
| exit-order rule (ID-8) | HELD | the diff adds no namespace-scope object in Managers.cpp — the seven new file-scope symbols are all static functions. SanityTest.cpp adds g_texParamCalls (a raw pointer) and g_texParamBoundTexture (a GLuint): trivially destructible, no guard variable, no std::atexit, and neither holds a frontend SharedPtr |
| logging discipline | CLEAN | the diff adds 17 MGLOG_E_ONCE, 0 bare MGLOG_E, 0 MGLOG_I. No printf, no commented-out code |
| DirectVulkan lane 475/475 — what runs there | REPRODUCED, and the attribution is right | 475 DirectVulkan.* integration-gpu cases, run under GLIBC_TUNABLES=glibc.malloc.tcache_count=0. D changes only MG_Backend/DirectGLES, so what this lane actually exercises of D's work is the shared half: MGPipeSlotAllocator, the death-notice dispatcher (Managers.cpp:182-250, which the SamplerViewCso arm's #if removal touched) and process-teardown ordering, on the backend that installs no death ops. That is precisely ID-8's leak/idempotence half, and 0 failures is the right reading |
| the default arm 189 = 183 + 6 | REPRODUCED EXACTLY, classification confirmed by mechanism | §4 |
2. Findings
Nine, none blocking. Each has a file:line, a failure scenario and the refutation I tried.
N-1 (minor, but it ships in a log line) — "left unbound rather than bound-and-unconfigured" is false at every caller
Managers.cpp:9083-9087 (the refusal text), and esprytobj-v2.md §2(1)'s claim that on a missing
record "the driver's binding is where the caller left it rather than pointing at a freshly minted,
attachment-less driver FBO".
SyncToBackend returning without binding does not decide the driver's binding, because every
caller binds immediately afterwards:
DirectGLES.cpp:3292-3293—SyncAndBindFramebufferObjectisbackendObj->SyncToBackend(...)thenbackendObj->Bind(target), unconditional,voidreturn. That is the path all five DSA entry points take (:6474,:6475,:7960,:7980,:7997,:8017).DirectGLES.cpp:3206-3256—BindCurrentFBObinds the current FBO's twin independently of whetherSyncCurrentFBO(:2310) synced it.
Failure scenario. On the integrated tree B fails to emit a Named record for one DSA-cleared
framebuffer. The twin refuses and returns; SyncAndBindFramebufferObject then calls Bind(Draw),
which mints and binds the driver FBO exactly as before, and glClearBufferfv lands on a framebuffer
with no attachments — the identical outcome to v1. The integrator reads the log line, believes
nothing was bound, and looks for the wrong symptom.
Refutation attempted, and it fails three ways. (a) Does Bind early-out when nothing was
synced? No — it binds m_backendFBOId, minting it if needed. (b) Does any caller check a return
value? SyncToBackend returns void. (c) Does the reorder buy anything at the bound-FBO path?
No: SyncCurrentFBO never binds, and BindCurrentFBO binds regardless.
What the reorder does buy is real but smaller and worth saying instead: the twin no longer mints and binds a driver FBO as a side effect of a refusal, so the refusal itself has no driver effect. Fix: reword the message to "…so it is not configured; the caller's own bind still targets it" (or similar), and correct §2(1). One string, and it is the string F's residual grep and the integrator's eye will both land on.
N-2 (minor, owed before the verification round) — the refusal census names six of eight shapes, and I observed seven in a single run
esprytobj-v2.md §4 ("six distinct shapes and no seventh") and §5 item 2 ("the integrated tree must
show zero of all six shapes").
grep -n 'applier record' Managers.cpp at HEAD gives eight distinct MGLOG_E_ONCE refusals:
:6310 texture %u ... its storage and uploads cannot be driven from the pushed descriptor
:7564 texture %u ... its built-in sampler cannot be pushed
:7778 texture %u ... its parameters cannot be pushed
:8866 framebuffer %u ... its read buffer cannot be pushed
:9083 framebuffer %u ... it cannot be synced from the pushed record and is left unbound ...
:11925 program %u has no shader-CSO applier record ... its synced serial cannot be stamped
:12174 sampler %u ... its parameters cannot be pushed <- NOT IN THE CENSUS
:12418 renderbuffer %u ... its storage cannot be allocated from the pushed descriptor <- NOT IN THE CENSUS
Demonstrated, not argued. One standalone run of *IntegerBorderColor* on the default arm with
MOBILEGL_LOG_FILE_PATH set produced exactly seven ERROR]: MGPipe lines — the six the report
names plus MGPipe: sampler N has no applier record on the handle arm, so its parameters cannot be pushed. (The renderbuffer one needs a scenario with a renderbuffer attachment; it is the eighth
by inspection.) v1's m-10 corrected "three" to "six"; six is still short.
Failure scenario. ID-12's rule is that a residual of any named refusal on the integrated tree is a seam defect. The verification round greps the six, the sampler-CSO and renderbuffer families still refuse because C's or B's records never arrive for them, and the round reports "zero residuals" over a tree where two families are running the legacy arm.
Refutation attempted. Could the sampler line be another package's? No — Managers.cpp:12174 is
in BackendSamplerObject::SyncToBackend, D's file, added by D's v1 commit 107658f7 ("take the
sampler parameters … from the applier"). Could it be unreachable on an integrated tree? No: it is
the sampler family's only decline, and it fires the moment a sampler object is synced with no
create_sampler_state applied — which is exactly what a C-side seam looks like.
Fix: list all eight in §4 and §5-item-2. The common stem no applier record on the handle arm
matches seven of the eight; only :11925 ("no shader-CSO applier record") needs its own pattern.
N-3 (minor) — AdoptTwinByHandle now has callers, but neither can reach either of its refusals
Managers.cpp:8657 and :8723, against the helper at :3550-3574.
Both call sites are preceded by a cross-check that the record's Res equals
registry.HandleOf(frontendObject) (:8642-8655, :8709-8722) and return false when it does
not. HandleOf (Managers.h:420) resolves through MGPipeSlots().FindByLifetimeId, i.e. the
live handle. So by the time AdoptTwinByHandle runs, handle.Slot is a slot the registry itself
minted (below kMaxHandleSlot) and handle.Gen equals LiveGenAt(handle.Slot) — neither the
slot-bound refusal nor the backward-generation refusal can fire, and GetOrCreateByHandle can never
take its entry.backend.reset() path either.
Failure scenario. M-4's actual argument was "dead code cannot be wrong-and-noticed; its bound and
its wording will first be exercised at P5". That argument is unchanged: the helper is now called
but its distinguishing behaviour is still never exercised outside SanityTest.cpp. A typo in
either bound would still ship.
Refutation attempted, and it half succeeds. HandleOf memoises (SlotTables.h,
m_memoLifetimeId/m_memoHandle), so a stale memo could in principle return a generation behind the
live entry and make the refusal reachable. I could not construct a sequence that does it — a live
object's handle does not change generation — so I record this as "essentially unreachable" rather
than "provably unreachable". Either way the letter of M-4 is closed and its substance is not; say so
in the report rather than leaving the integrator to infer it.
N-4 (minor) — the metadata respecify routes the prevention case through the remint-pull emulation marker
Managers.cpp:6335-6339 calling RequireImageBindableStorage (:5203), whose first statement is
MG_Pipe::MGPipeUnmigratedEmulation("texture-remint-pull") (:5235).
MGPResourceDesc::ImageBindableHint exists as mitigation 1, the prevention half — the comment at
:5223-5231 says so in as many words: a texture that has ever been image-bound "is allocated in the
carrier from the start and never reaches this path". D's rework makes the hint's arrival the trigger
for entering that path.
Failure scenario. glBindImageTexture on a texture whose storage is not yet defined: B's sticky
mask gains kMGPipeBindShaderImage, emits the mask-only respecify (ID-18 M4), D calls
RequireImageBindableStorage, the marker fires, and the level loop then finds nothing to re-arm.
Under split (P9) that marker is the arm that aborts/counts, so the case the hint was invented to
prevent is counted as an unmigrated emulation. In monolith MGPipeUnmigratedEmulation is
{ (void)name; } (PipeApply.cpp:2717), so nothing is observable today — this is a P9-facing
accuracy defect, which is why it is a minor and not a major.
Refutation attempted. (a) Is the marker about something wider than the replay? No — its own
comment scopes it to "the server is reaching BACK into the client's own dirty model to ask for texels
it does not hold". (b) Is the no-levels case unreachable? No: B fills
desc.ImageBindableHint = (bindMask & kMGPipeBindShaderImage) != 0
(p4a/clientfb:TextureEmit.h:230, :520, :982) from the sticky mask on every respecify, including
one that precedes any level definition.
Fix: move the marker to where a level is actually re-armed (inside the loop, or behind a "replayed at least one level" flag). Two lines, and it keeps the marker honest for P9.
N-5 (minor, consistency) — SrcOffset is consumed raw while its sibling stride got a loud refusal in the same commit
Managers.cpp:7091-7096 (MGB_RECT_SRC_PTR), used at :7123, :7218, :7262.
The macro adds Regions[idx].SrcOffset to uploadData and hands the result to glTexSubImage* as
the client pointer for (w·bpp × h × d) bytes. The same commit added a loud refusal when the
regions' strides disagree (:6975-7001), on the argument that "a record whose regions disagree is
corrupt". SrcOffset gets no equivalent — and the block two lines above computes the same number
independently (rectShadowPtr, :7074-7079), so the cross-check is free.
Refutation attempted, and it is strong enough to keep this a minor. (a) Wire validates
region-inside-box and box-encodability (PipeApply.cpp:743-770) but explicitly does not validate
the box against the level extent, and says so. (b) B derives SrcOffset from the same box origin and
level pitch the shadow path uses (clientfb:TextureEmit.h:394-396), so in monolith the two agree by
construction. (c) The pre-existing rectShadowPtr derivation is exactly as untrusted, so this is not
a new exposure. It is an asymmetry in the package's own discipline, not a live defect.
Also: the first of the three use sites is unreachable. dirtyRectCount is forced to 0 whenever
UnpackRingAvailable() (:7069-7071), and the staging-block loop at :7119 requires
ringUsable && dirtyRectCount >= 2. Pre-existing shape, not D's — but esprytobj-v2.md §3-m-1 cites
three live sites where there are two.
N-6 (minor) — an empty surface is accepted silently while every other record-vs-frontend disagreement is loud
Managers.cpp:8634-8640 (the Kind == kMGPipeSurfaceKindNone || MGPipeHandleIsNull(Res) arm of
SyncAttachmentSurface), against the detach at :9289-9291.
The detach is decided by the frontend (attachmentObject.IsEmpty()); the attach is decided by
the record. When the record says a point is empty and the frontend still holds an attachment,
neither fires: no detach (frontend not empty), no attach (surface empty), return true — and the
caller then stamps m_syncedFrontendAttachmentVersions[i], so the point is marked synced with the
previous owner's image still attached. The comment claims "the caller has already detached it where
that is what an empty point means", which is only true when the two sides agree.
Refutation attempted, and it explains why this is a minor. (a) Would the point even be visited?
Yes — a moved ContentHash re-arms every version to ~0 (:9256-9260), so a record-only change
forces the whole walk. (b) Can the two disagree in monolith? Only through a frontend that keeps a
detached attachment object non-empty, which I could not find. (c) Is the converse loud? Yes:
Kind == Texture with a null frontend texture, and a Res/HandleOf mismatch, are both
MGLOG_E_ONCE. So the hole is exactly one direction wide. One else if (!attachmentObject.IsEmpty())
with the same voice closes it.
N-7 (minor) — D keys on the high byte, wire keys on the whole packed field
Managers.cpp:3799 / :3821 / :3872 versus PipeApply.cpp:814 (AccumulatePendingUpload:
if (entry.UploadTarget != record.Target || entry.Level != record.Level) continue;).
Wire treats two entries with the same upload half and different resource-target bytes as distinct;
D treats them as the same. They agree today only because a texture's
MGPipeResourceTargetForTextureTarget(GetTarget()) is constant for the object's life.
Failure scenario. If that ever stopped holding, wire would store two entries and D's consume would erase the first match and leave the second in the set for ever — a full re-upload of that level on every sync, silently, for the life of the texture.
Refutation attempted, and it holds today. A texture emits sub-data only through
MGPipeBuildSubRegion/the texture emitter, whose resource-target byte comes from the object's own
target; texture views own their own resource. So this is a latent divergence, not a live one. Fix:
either compare the packed field (which is what RearmPipeTextureLevelUpload already writes, so
nothing else changes) or assert the low byte matches, at the two comparison sites.
N-8 (minor) — Desc.HasDefinedContent is neither read nor listed among what the descriptor does not answer
Managers.cpp:6230-6237 enumerates what the descriptor answers and what it does not; c0e made
HasDefinedContent storage-defining (MGPipeTypes.h:301), the buffer family reads it three times,
and the texture arm reads it nowhere.
Refutation attempted, and it succeeds on behaviour. For a texture the per-level pending set is
the authority on content (D-D5), and a level the shadow has not defined is skipped by the per-level
loops; HasDefinedContent would add nothing. So this is a documentation gap in an enumeration
whose whole purpose is to be exhaustive — one line at :6237.
N-9 (minor) — the G9 probe covers deferral inside the function, not above it
SanityTest.cpp:3184, and gates-review-v1.md R1's second half ("distinguish 'not applied yet' from
'applied late'").
The probe calls twin->SyncTextureParamsToBackend(texture) directly. The negative control the report
describes — requiring FindSamplerViewForHandle(...) != nullptr inside the swizzle block — is
therefore the only deferral shape it can see. A regression that gates the call on a sampler view
existing (in SyncNeccessaryTextures, or in E's per-unit walk) leaves this case green.
Refutation attempted, and it is why this is a minor. R1 asked for a backend-side probe taking its reading while the texture is attachment-only, and that is exactly what this is; the caller-level shape is a scenario's job and the scenario is F's. Worth one sentence in the case's comment and in F v3's G9 note, so the next reader does not over-trust it.
3. What I tried to break and could not
- Can a
Namedrecord reach a target-gated apply? No.glDrawBuffersand the four masks are underasTarget == Draw(:9151,:9159),glReadBufferunderasTarget == Read(:9220), andasTargetis the caller's binding intent, not the record'sTarget. The D-O row survives. - Can the metadata respecify recurse? No.
RequireImageBindableStorageearly-returns onm_imageBindableStorageRequiredand calls nothing that re-entersSyncMipmapsToBackend. - Can
pushedStoragedangle across the re-arm? No. The re-armpush_backs intorecord.PendingUploads, which does not moveTextureResources; only a create/respecify for a new slot grows the outer vector, and nothing on this path emits one. - Can the re-arm break wire's own invariants? No. It either replaces
UnionBoxand clearsRegions(box-only, which is legal and is whatAccumulatePendingUploaditself falls back to) or inserts a region-less entry. The one nit is that it replaces rather than unions the box; the replacement is a whole-level box, which contains any box built from the same level's extent, andUnionOfBoxesisstaticinPipeApply.cppso D could not call it anyway. - Can
dirtyRects[r]andRegions[r]fall out of step? No. On the handle armdirtyRectsis built fromRegions(:7043-7060), index for index, soMGB_RECT_SRC_PTR(r, rect)is consistent by construction. - Does the sampler-view / death-notice
#ifremoval (m-7) change any arm? No. The dispatcher's own#if MOBILEGL_PIPE_PUSHat:182opens the wholeOnFrontendStateObjectDestroyedbody; the removed inner pair was strictly nested inside it.
4. What I measured — all of it on the rebased tree (base 712c9467, D head d86b32e9)
build-push (PUSH=ON) rc 0
build-linux (pull, PUSH=OFF) rc 0
ctest -L unit build-push 100% passed, 0 failed out of 1686
ctest -L unit build-linux 100% passed, 0 failed out of 1686
G1, ISOLATING D (pull build at 712c9467 -> pull build at D's head):
symbol_report.py --threshold 0 --fail-on-symbol-set-change --fail-on-added-bytes 0 rc 0
file bytes 19114360 -> 19114360 ; .text 10806323 -> 10806323 (+0, +0.000%)
.data/.bss/.rodata all +0 ; Total 17226471 -> 17226471 (+0)
27811 -> 27811 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
27072 normalised names, 27072 unchanged
### Removed (0) ### Added (0) ### Resized (0) ### Renamed only (0)
p4a_untouched_regions.sh 37da3c3a HEAD (F's script, from ~/w7/p4a-gates) rc 0
17 pool / ring / unpack-staging / attachment-permutation /
depth-stencil-sampling / format-caveat regions byte-identical
791b54a3.. StageBlocksIntoUnpackRing 1d6f15c9.. UnpackRingAvailable
19e614af.. UnpackRingAllocate 3ae7e347.. RecomputeBackendColorSlots
822ca3b0.. DepthStencilSamplingReadImpl 266710e0.. ShouldUseCaveatTextureFormat
== esprytobj-v2.md §4, sha for sha
ctest -L integration-gpu -j 8 -R DirectGLES, build-push:
default (0x1fff) 62% passed, 189 failed out of 491 (6 aborts, 183 named)
MOBILEGL_PIPE_PUSH=0x1ff 99% passed, 6 failed out of 491 (6 aborts)
MOBILEGL_PIPE_PUSH=0 99% passed, 6 failed out of 491 (6 aborts)
comm -3 (0 vs 0x1ff) EMPTY -> the two failing SETS are identical
comm -13 (0x1ff not in default) EMPTY -> the default arm is a strict superset
ctest -L integration-gpu -j 8 -R DirectVulkan 100% passed, 0 failed out of 475
G9 probe DirectGLESTextureSync.AnAttachmentOnlyTexturesParametersReachTheDriverWithNoSamplerView
push @ 0, push @ 0x1ff, push @ 0x1fff, and the pull build: PASSED (4/4)
DirectGLESSlotTable.* 20/20 passed
m-6, re-run as a SINGLE TU rather than a whole configure: the build-push compile command for
Managers.cpp with -DMOBILEGL_PIPE_LEGACY_MEMOS=1 rewritten to =0, -fsyntax-only:
rc 0, 0 errors, 0 warnings
(six `#if !MOBILEGL_PIPE_LEGACY_MEMOS` bodies now live in the file: :333 :4281 :7642 :7902
:12187 :12431 — the four P4a added plus two inherited)
greps: MGB_* in any header no hits
pGLContext in MG_Backend PipeInputs.h:1 only
MGPipeResourceOps ∌ MG_State 0
diff adds MGLOG_E_ONCE 17 / MGLOG_E 0 / MGLOG_I 0
The 189 = 183 + 6 classification. Confirmed by mechanism rather than by a log I no longer have:
the six are the ctest ENVIRONMENT-pinned .Handles aborts, they are present in all three arms'
failing sets and are the only overlap (comm), and comm -13 shows the default arm adds nothing
that fails for a pre-existing reason. The census run's log carried zero FATAL]: MGPipe lines —
the only two FATAL lines are ambient EGL entry-point loads under llvmpipe
(eglSwapBuffersWithDamageEXT, eglUnlockSurfaceKHR), which the integrator should expect and not
mistake for a pipe fault.
Not re-derived: DV-9's 38-line preprocessed-text count (the report withdraws the claim it supported; the property that matters is measured above), and the retrace corpus (meaningless with no records, as §5-item-13 says).
5. The rebase onto 712c9467 — ID-32's command does not work
ID-32 and the brief both say:
git rebase --onto refs/heads/feat/disaggregated cce81d19 # "replays only the seven rework commits"
Ran it. It conflicts on the first commit:
Rebasing (1/7)
CONFLICT (content): Merge conflict in MobileGL/MG_Backend/DirectGLES/Managers.cpp (4 hunks)
CONFLICT (content): Merge conflict in MobileGL/MG_Backend/DirectGLES/Managers.h (2 hunks)
error: could not apply ac6757e6...
Why, and it is not a resolvable conflict — it is the wrong range. cce81d19..HEAD is the seven
rework commits only, and those seven are built on D's v1 six (b1983e2c..8338c18f), which sit
below the two merges and are not on pipe: git diff cce81d19 712c9467 -- Managers.{cpp,h} is
-1208 / -360 lines, exactly D's v1 additions. Replaying the seven onto a tree that has none of v1
asks git to re-apply PushedFramebufferRecord's edit to a file that has no
PushedFramebufferRecord. Resolving the conflicts by hand would silently drop the whole v1
deliverable.
git rebase --onto refs/heads/feat/disaggregated 9ea44389 is also wrong: it linearises the merged
branch, so after replaying D's six v1 commits cleanly it tries to replay wire's twelve on top of
pipe's already-rebased copies of them and conflicts in PipeApply.{h,cpp} (wire's rebase onto
e8502a61 changed their patch-ids, so git cannot skip them).
The recipe that works — verified, zero conflicts, builds, and reproduces every number
git checkout --detach 712c9467
git cherry-pick 9ea44389..8338c18f # D's six v1 commits -> clean, 6/6
git cherry-pick cce81d19..ef6beb28 # D's seven rework -> clean, 7/7
Thirteen commits, no conflicts at any step, and
git diff HEAD ef6beb28 -- MobileGL/MG_Backend/DirectGLES/ MobileGL/MG_Test/SanityTest.cpp
is empty — D's three files are byte-identical to the pre-rebase tree. cce81d19 is excluded by
the range (its retirement is already 712c9467); its patch-id and 712c9467's differ, so git
would not have skipped it automatically — leaving it out of the range is what drops it, and that is
the point of starting the second range at cce81d19 rather than at 815dd6d3.
Resulting head d86b32e9. Both builds rc 0, unit 1686 × 2, G1 0/0/0/0 against 712c9467's own pull
build, D-N rc 0, three integration arms at 189/6/6, DirectVulkan 475/475 — §4.
The pipe head moved during this review and the recipe survives it. refs/heads/feat/disaggregated
is now 92dffb81 (C v3 / p4a/clientsp fast-forwarded in: eleven commits, 1534cf37..92dffb81),
with 712c9467 still an ancestor. git diff 712c9467 92dffb81 -- Managers.cpp Managers.h SanityTest.cpp is empty — nothing C landed touches any file D owns — so both cherry-pick ranges
apply unchanged onto 92dffb81 and every number in §4 stands. Substitute whatever
refs/heads/feat/disaggregated is at integration time for 712c9467 in the recipe; the two ranges
(9ea44389..8338c18f and cce81d19..ef6beb28) are what matters and they are fixed.
6. D's verification-round checklist, corrected
esprytobj-v2.md §5 is sound; these are the amendments this review adds. Order is still ID-24's
(C v3 → B v2 → D v2 → E verification → D verification → F v3).
- Item 2 is short by two shapes (N-2). The residual-refusal check must cover eight:
the six §4 lists, plus
MGPipe: sampler %u has no applier record …its parameters cannot be pushed(Managers.cpp:12174) andMGPipe: renderbuffer %u has no applier record …its storage cannot be allocated from the pushed descriptor(:12418). Grep the stemno applier record on the handle arm(catches seven) andno shader-CSO applier record(catches:11925). A residual sampler shape points at C's cache seam, a residual renderbuffer shape at B's renderbuffer descriptor — neither is what the framebuffer shapes would tell you. - Item 3 stays, but read it with N-1 in mind: if a DSA case is red and the framebuffer refusal
is in the log, the driver still had the unconfigured FBO bound. That is B's missing
Namedrecord, not a residue of the CRITICAL fix. - Item 7 (the storage-shape seam) is already closed — I compared
TextureEmit.h:183-241againstManagers.cpp:6244-6270this round: B fillsWidth/Height/DepthfromGetBaseSize()verbatim and derivesArrayLayersin addition, soMGB_STORAGE_BASE_SIZEand the frontend agree exactly andneedsRegenerationcannot churn on it. Ten minutes saved; spend them on item 6 instead. - Add: assert
MGPipeApplier().StaleFramebufferRecordLookups == 0— already item 3's tail, but also worth asserting after the image-bindable remint set, because the re-arm and the framebuffer table are the two places D writes/reads applier state outside a record apply. - Add (N-4): when B's
ImageBindableHintlands, confirm that a texture whose mask-only respecify arrives before any level is defined does not tripMGPipeUnmigratedEmulation. Today it does, and it is inert; P9 will not be. - Add (N-9): when F v3 writes G9's scenario half, note in the white-box case's comment that it covers in-function deferral only.
MOBILEGL_ESPRYT_FBO_HANDLE_ARM_MEMOS_LINKED→ 1 (Managers.h:2011) after E drops thestatic— unchanged, and the gate is that the flip does not link without E's half.- The 0x5ff arm is expected GREEN, not red —
gates-review-v2.mdF-v2-m2 already corrected the gates side, and D's row is in and matches F's matcher. A red there is a real finding about D's resolver.
7. What I could not check
- The 183's per-case classification.
~/w7/p4a-esprytobj-lanes*.logare gone (ID-5-compliant). I reproduced the count, the six-abort overlap and the superset property mechanically, and sampled the shapes from a fresh standalone run — which is how N-2 surfaced. The same recommendation as v1 stands: keep the lane logs until the review of the round closes. - Anything behind a record. With no client on this tree the handle arms mostly decline; the CRITICAL's fix, M-1's replay, M-2's descriptor allocation, M-3's attachment walk and the four masks are all first executed on the integrated tree. §6 is where they get their first real reading.
- G4's retain-mode comparison — still has not run anywhere in this phase, and DV-15 makes it the one lane that can tell a legitimate server-side re-arm from a lost emission.
Private worktree ~/w7/p4a-rereview-esprytobj removed and git worktree prune run; the
~/w7/rr-obj-*.log files and /tmp/rr-obj-* scratch removed with it.