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.
41 KiB
P4a package D — p4a/esprytobj (the twins and the slot tables), v1
Branch refs/heads/p4a/esprytobj, worktree ~/w7/p4a-esprytobj, based on the tag p4a/contract
(08192d72). Files touched: MG_Backend/DirectGLES/{Managers.h, Managers.cpp} and
MG_Test/SanityTest.cpp — nothing else. SlotTables.h needed no edit: GetOrCreate(handle),
FindByHandle, ReleaseByHandle and LiveGenAt were already there from P3a, which is what C.3's
d1 is written against.
1. Commits
| step | hash | message |
|---|---|---|
| d1 | 7aa598fa |
[Refactor] (Espryt): key the texture, renderbuffer, framebuffer, sampler and program twins on the client-minted handle instead of the frontend object |
| d2 | c1d6b41c |
[Refactor] (Espryt): drive texture storage, parameters and uploads from the pushed descriptors and take the upload strides from the record |
| d3 | 49ff8d91 |
[Refactor] (Espryt): allocate renderbuffer storage from the pushed descriptor and keep the deferred out-of-memory report where it is |
| d4 | 7e400454 |
[Refactor] (Espryt): sync the driver framebuffer from the pushed record and answer the read buffer from the resolved read surface |
| d5 | a69819e4 |
[Refactor] (Espryt): take the sampler parameters and the program artefacts from the applier instead of the frontend objects |
| d6 | 9bb95335 |
[Test] (Espryt): drive the sampler-view table through the handle arm and prove every P4a death notice is idempotent |
C.3 gives no message for step 6; DV-10 records the one used.
2. Per-step summary — every memo and member re-keyed, retired or added
This section is the Track H census input. Nothing is deleted. Every pre-handle member stays
beside its replacement under MOBILEGL_PIPE_LEGACY_MEMOS, which ARCHITECTURE.md:369 keeps
compiled through P3a/P4a and which is what makes the four subsystem bits a real A/B rather than a
bring-up-order question.
d1 — the handle-keyed API, the sixth table, the four arm resolvers
Added to StateBackendObjectRegistry (push-only, so the pull build's mangled names are the
pre-P2 two-argument ones):
| member | what it is |
|---|---|
GetOrCreateByHandle(MGPipeHandle) |
resolve-or-create by the handle the CALL carried. Returns a POINTER, not the reference the minting overload returns, because it has three ways to decline: the legacy arm is running, the slot is past kMaxHandleSlot, or the generation is BEHIND the live entry's |
LiveGenAt(Uint32 slot) |
the live entry's generation, or 0 — so a release build, where MOBILEGL_ASSERT is inert, can DIAGNOSE the refusal the table performs silently |
ReleaseByHandle(MGPipeHandle) |
hands the twin OUT rather than destroying it in place; the SLOT is not freed, the client frees it after the destroy returns |
Added at DirectGLES namespace scope (push-only):
AdoptTwinByHandle(registry, handle, kindName)— one anonymous-namespace template holding the release-build VOICE for the two silent refusals, shared by the five kinds so the wording cannot drift between them. It is P3a'sGetOrCreateBufferResourceForHandleshape lifted into one place.ResolveFramebufferSubsystemArm/ResolveTextureResourceSubsystemArm/ResolveSamplerSubsystemArm/ResolveProgramSubsystemArm, plus the four inline latchesFramebufferSubsystemEnabled()/TextureResourceSubsystemEnabled()/SamplerSubsystemEnabled()/ProgramSubsystemEnabled(). Lazy at first use, never at bring-up (a forked pre-flight child dying on a signal makes a whole lane SKIP green). All four reuseBufferImpl::ClassifyPipeSubsystemArm/StopOnArmlessPipeSubsystemunchanged and all four passlegacyArmSurvivesLegacyMemos = false, which is D-K3's table verbatim.- The three dependency refusals, each one
MGLOG_Enaming both bits and then the legacy arm: bit 11 requires bit 10, bit 9 requires bit 10, bit 10 requires bit 7. The mirror pairs are stated as fine in the source, because an unreachable branch that says something different is how the reachable one drifts. Bit 12 depends on nothing and says so. - D-C3's
MaxColorAttachments > 8refusal, onResolveFramebufferSubsystemArm: readsg_GLESCapabilities.MaxColorAttachments(the driver's RAW ES cap, whichBackendObject_DirectGLES.cpp:1518publishes verbatim and which is NOT clamped to 8 on this path), refuses bit 9 naming the cap, and runs the legacy arm.
The sixth table — namespace SamplerViewImpl (push-only):
BackendSamplerViewObject—{MGPSamplerView View; Uint64 SyncedSerial; Uint64 SyncedSamplerSerial; Bool NeedsRawDepthFetchSampler;}. It owns no driver id: there is nothing in ES to create for a view, the id the unit binds is the texture's, and what this twin is is the server's memo of one resolved view plus Espryt's raw-depth-fetch substitution decision — one of the two backend post-processingsARCHITECTURE.md:206keeps on the server. No destructor is declared, and that is deliberate: nothing here owns a GPU object, so the teardown sentinel's whole reason does not apply and the defaulted one is correct in every teardown order.BackendSamplerViewTable=BackendSlotTable<ITextureObject, BackendSamplerViewObject, SamplerViewCso>and the globalg_backendSamplerViews. Handle-keyed only, exactly like P3a'sBackendBufferResourceTable; theStateObjectparameter namesITextureObjectbecause the view is minted off the TEXTURE's lifetime id (D-F2), which is what makesHandleOfresolve at all.GetOrCreateSamplerViewForHandle/FindSamplerViewForHandle/HandleOfSamplerViewForTexture(monolith glue, named as such).OnFrontendStateObjectDestroyedgains aSamplerViewCsoarm. §3 below is its idempotence argument.
d2 — the texture twin
| retired as a KEY | replaced by | member kept? |
|---|---|---|
m_syncedContentVersion (Managers.h:1468) |
m_syncedResourceSerial = the resource record's Serial |
yes, legacy arm |
m_syncedShapeContextId / m_syncedShapeGeneration / m_syncedShapeParamsVersion (:1481-1483) — the cheap-gate trio |
the same one Serial compare, plus "the pending-upload set is empty" |
yes, legacy arm |
m_syncedTextureParamsVersion (:1503) |
m_syncedParamsSerial = the record's ParamsSerial |
yes, legacy arm |
m_forceTextureParamsResync (:1507) |
MGPTextureParams::ForceResync on the wire — READ, acted on, and never written back (D-E2); the twin's own flag is still cleared here exactly as before |
yes, both |
m_syncedSamplerVersion (texture-owned, :1502) |
m_syncedBuiltinSampler + m_syncedBuiltinSamplerSerial — the HANDLE is part of the key, not just the serial, because sampler CSOs are content-addressed and a texture whose sampling diverges is re-pointed at a different CSO whose serial may be SMALLER |
yes, legacy arm |
m_forceSamplerResync (:1516) |
MGPTextureParams::SamplerResync — the byte that had no wire spelling at all before P4a |
yes, both |
the frontend dirty model (IsStorageDirty / MarkStorageDirty / GetStorageDirtyRegion / GetStorageDirtyRects) |
the applier record's PendingUploads set, read through FindPipeTextureUpload and cleared through ConsumePipeTextureUpload only where the level actually uploaded |
yes, legacy arm |
New members (all #if MOBILEGL_PIPE_PUSH): BackendTextureObject::{m_syncedResourceSerial, m_syncedParamsSerial, m_syncedBuiltinSamplerSerial, m_syncedBuiltinSampler}.
New members functions: ResolvePushedBuiltinSampler, ResolvePushedTextureParams.
The upload shape. The DECISION stays on the server verbatim — subRectEligible, the
UnpackRingAvailable() "one box, one job" collapse, and the three staging shapes are unchanged.
What moves is the SOURCE: the union box comes from PendingUpload::UnionBox, the rect list from
PendingUpload::Regions, and the strides are carried, never inferred —
MGPSubRegion::SrcRowStride / SrcSliceStride, with 0 meaning tightly packed, which is what a
whole-level region sends. StageBlocksIntoUnpackRing, UnpackRingAvailable and
UnpackRingAllocate are byte-identical (§4).
MGPipeUnmigratedEmulation("texture-remint-pull") is planted at
RequireImageBindableStorage's re-dirty of already-uploaded levels — the one D-M site that lives
in this package's files. The other four are DirectGLES.cpp's and are package E's.
d3 — the renderbuffer twin
| retired as a KEY | replaced by |
|---|---|
m_cacheInternalFormat / m_cacheWidth / m_cacheHeight / m_cacheSamples (Managers.h:2251-2254) as the four-field GATE |
m_syncedResourceSerial = the record's Serial |
The four members stay and are still written, because they are also what the legacy arm compares and
what the twin reports about the storage it actually holds. The four allocation values now come from
Desc.InternalFormat/Width/Height/Samples. The GL_OUT_OF_MEMORY probe and its RecordError
are untouched, and the serial is stamped AFTER the allocation so a refused allocation leaves the
twin describing what it holds. D-D2's publication hole (SetInternalFormat / AllocateStorage /
SetSamples bump no version and raise no notice, so re-storaging an ALREADY-ATTACHED renderbuffer
was invisible) is closed by the client emitting from those three mutators; this side needs only the
one serial compare, which is what it now has.
d4 — the framebuffer twin
| retired as a KEY | replaced by |
|---|---|
m_syncedFrontendAttachmentVersions[41] (Managers.h:1604) as the attachment walk's KEY |
m_syncedRecordHashes[target] = MGPFramebufferState::ContentHash, which is the hash's SECOND job — "the server's render-pass memo key, and the CLIENT's emission suppressor" |
stateFBOObject->GetDrawBuffers() |
MGPFramebufferState::DrawBuffers[8], decoded by DecodePushedDrawBuffers |
stateFBOObject->GetReadBuffer() |
MGPFramebufferState::ReadSurface, matched against Color[] to recover the attachment POINT |
New members / functions (push-only): BackendFramebufferObject::m_syncedRecordHashes,
FramebufferImpl::PushedFramebufferRecord, FramebufferImpl::DecodePushedDrawBuffers.
PushedFramebufferRecord(asTarget, fbo)matches the applier's per-target working state against this twin's own handle. A mismatch means the object being synced is not the one currently bound to that target — a real sequence (a scratch FBO synced while another is bound) — and is answered with null rather than with the other framebuffer's attachments.- The record's own
Targetis validated against the binding it is being applied to;Bothis legal for either, anything else is refused and named. That is the D-C2 property: the OIT bug atManagers.cpp:7544-7551, where a READ-only sync landedglDrawBufferson the wrong framebuffer and falsely stamped the memo, becomes a one-line test on carried data instead of a call-site discipline nobody can check. - Survives untouched:
g_attachmentBackendIdGeneration, the~0re-arm it drives, the re-entrancy loop until it is quiescent,RecomputeBackendColorSlots(byte-identical), the empty-colour-point detach, and the draw-bufferNone -> GL_NONEhandling. - Over-firing is free and under-firing is fatal, so the per-attachment version array stays as a narrower SECOND gate underneath the hash: an attachment that moved without the record moving still re-attaches.
d5 — the sampler and program twins
| retired as a KEY | replaced by |
|---|---|
BackendSamplerObject::m_syncedSamplerVersion (Managers.h:2222) |
m_syncedSamplerSerial = the SamplerCso record's Serial |
BackendProgramObjectImpl::m_syncedLinkVersion + m_syncedImageUnitVersion (:2354-2355) |
m_syncedShaderCsoSerial = the ShaderCso record's Serial, exposed as GetSyncedShaderCsoSerial() for the draw path |
All four border-colour comparands (float, int, uint, form) are still compared on the sampler
side, reading the CSO record's SamplerParameters instead of the frontend object — D-F4, and the
reason is unchanged: two integer borders differing above 2^24 share one float, and a Float→Int
transition can leave every number unchanged while needing a different driver entry point.
The frontend/CSO asymmetry that must survive, survives: the texture path resolves its min filter
with IsAngleLlvmpipeRenderer() and the sampler-object path with
ShouldAvoidSamplerMipmapMinFilterOnAngleLlvmpipe(). Both are server-side choices made from the
same value, so nothing about them moves.
The program artefacts deliberately do NOT move — see DV-8. That is D-H3's ruling, not a shortcut.
d6 — SanityTest.cpp
EverySwitchedOverKindResolvesItsTwinThroughTheHandleArmgains a SamplerViewCso block (the fiveTwinRegistrykinds and the Buffer table were already covered): handle minted off the texture's lifetime id, the two kinds' slot spaces proven independent for the SAME lifetime id,GetOrCreate/FindByHandle/HandleOf/ReleaseByHandle, the recycle with a movedGen, and the backward-generation refusal.- New:
DirectGLESSlotTable.ADeathNoticeForEveryP4aKindIsIdempotent, driven through the REAL consumer the backend installed (GetStateObjectDeathOps()->OnDestroyed) rather than a recording stub, because what is under test is Espryt's own arm. Skip stub added in the pull arm so G2/G14 hold (name-for-name identical lists, additions only). ScopedDirectGLESTextureBindings(:218-260, the second live holder of kind Texture),ASavedCopyOfARealRegistryDropsTheTwinOnTheSameNoticeandPixelPackBindingCacheSkipsRedundantBindsAndRestsAtZeroall pass unchanged.
3. The death-notice idempotence argument, per kind (ID-8)
The rule: the client emits the wire delete, raises NotifyStateObjectDestroyed(kind, lifetimeId)
and frees the slot, in that order, and the backend notice is the REDUNDANT SECOND PATH.
The mechanism that makes all six idempotent is one property of the allocator plus one of the table:
MGPipeSlotAllocator::Freeerases the lifetimeId → slot mapping, so the second resolution of the same id finds nothing; and aFreeon a slot that is no longer live at that generation is a proven no-op (SlotAllocator.cpp:117-119), with theGenbump riding the next handout rather than the free, so a double free cannot skip a generation.BackendSlotTable::OnFrontendObjectDestroyedreturns false without touching anything whenFindByLifetimeIdanswers the null handle, andReleaseTwinAtreturns false for an entry whoseGenno longer matches — so a notice that arrives after the client'sFreecannot drop a successor's twin.
| kind | first path | second path | why the second is a no-op |
|---|---|---|---|
| Texture | ~TextureObjectBase raises the notice; Espryt drops the twin in every holder and frees the slot |
the client helper MGPipeEmitTextureDestroyAndFree emits ResourceDestroy, raises the same notice and frees |
whichever gets there first erases the mapping; the other resolves the null handle. The twin's driver id is released exactly once, by ReleaseTwinAt, which retires the entry BEFORE running the destructor |
| Renderbuffer | same shape | MGPipeEmitRenderbufferDestroyAndFree |
same |
| Framebuffer | same shape | MGPipeEmitFramebufferDestroyAndFree, which emits no wire call at all (D-I2: a framebuffer has a handle but no wire lifetime) — it is notice-then-free only |
same |
| SamplerCso | ~SamplerObject |
MGPipeEmitSamplerCsoDestroyAndFree |
same. A texture's death legitimately raises a SamplerCso notice too, because every ITextureObject owns a private SamplerObject with its own lifetime id (contract D5), so the two notices name two different ids and neither can free the other's slot |
| ShaderCso | ~ProgramObject |
MGPipeEmitShaderCsoDestroyAndFree, called twice for a composite (the pipeline cache's LRU eviction and the composite's own destructor) |
the composite band is a client-side indexing detail; on this side a composite handle is an ordinary ShaderCso handle and both calls resolve through the same table. The second finds nothing |
| SamplerViewCso | nothing raises it today — the view has no frontend object; the only raiser is the client helper MGPipeEmitSamplerViewCsoDestroyAndFree, which fires from ~TextureObjectBase's body |
the same helper's own Free |
the notice names the TEXTURE's lifetime id, and it is safe for it to arrive beside the Texture notice for the same id because the two kinds have separate slot spaces — the allocator resolves (kind, lifetimeId), so each arm finds its own slot or nothing. The twin owns no driver id at all, so even a double release is a pointer reset |
ADeathNoticeForEveryP4aKindIsIdempotent exercises exactly this: for the sampler view, notice →
notice → client Free → notice, then a successor acquire proving the slot really came back with a
moved generation (which a double free would break by skipping one); for the five object kinds, the
real destructor followed by two more deliveries.
Leak-freedom. No new table has a garbage collector and none needs one: the sampler-view table's
entries leave on the notice, and SamplerViewImpl's twin owns nothing a sweep could reclaim. No new
static holds a frontend SharedPtr (the exit-order rule, ID-8): g_backendSamplerViews is a
BackendSlotTable, whose Entry::stateRef is a weak_ptr and is never even written on the
handle-keyed overload, and it links itself into the per-type holder list from its own constructor
with no initialisation-order question to answer. It adds no std::atexit registration of its
own; EnsureProcessTeardownSentinel() is still armed by the first insertion of a table whose twin
owns a driver id.
4. The byte-identical set (G5) — evidence
scripts/p4a_untouched_regions.sh is package F's and does not exist on this tree, so the
evidence below was produced with a one-off equivalent that copies the parent script's shape:
mask-first, preprocessor-blind extraction (comments and string/char literals replaced by spaces of
the same length), the definition found as the one <name> ( whose closing paren is followed by
{, the body brace-matched in the masked text and hashed from the ORIGINAL text, exactly one
definition per name or exit 2, both arguments git refs.
Four of D-N's seventeen live in this package's files. The other thirteen are P3a's eleven
(p3a_untouched_regions.sh, run after every commit, rc 0 every time) plus
DepthStencilSamplingReadImpl and ShouldUseCaveatTextureFormat, which are in DirectGLES.cpp
and Utils.cpp — package E's files, untouched here.
$ python3 <p4a-dn equivalent> 37da3c3a HEAD
d75537bc1fb9170bf98d8f711c7a86fa229b80a3219f091c487ba56251628b9a StageBlocksIntoUnpackRing
a0c9994d7647f6d55491767e813bbab07f1ac54b8804bff466e8c53e29356465 UnpackRingAvailable
f56d432fff8d015c08911f846d8c196c3c297261a8301dc8b9c4299d199b95db UnpackRingAllocate
39a3724922a007509173c330557f6e5f6b938e5b6cd8800817c63ac67ccf4840 RecomputeBackendColorSlots
[p4a-dn] rc=0
ScopedDefaultUnpackState and its process-wide s_synced shadow are untouched, and the ring path
still issues no glPixelStorei, so D-O's inherited hazard is neither fixed (ROADMAP.md:98) nor
made worse.
5. Deviations, each with its reason
DV-1 — d1's message names a re-key the commit only half performs, and that is a C.7 boundary.
C.3's d1 says "the five kinds' tables re-keyed onto client-minted handles". The resolution sites
for framebuffer, sampler and program are SyncCurrentFBO, the lazy sampler mint at
DirectGLES.cpp:4014-4020 and SyncCurrentProgram — all in DirectGLES.cpp, which C.7 gives to
package E. SyncTextureObjectToBackend is likewise defined at DirectGLES.cpp:1501. So d1
lands everything the re-key needs on this side — the handle-keyed registry API, the shared refusal
voice, the sixth table and the four arm resolvers — and each family's own resolution moves with its
commit (d2–d5) where it lives in Managers.cpp. The brief's exact message is used unchanged per
ID-2; this note is the correction.
DV-2 — MGPTextureParams::DepthStencilMode's encoding was unstated, and Espryt now defines it.
The field is a Uint8; ITextureObject::GetDepthStencilTextureMode() is a GLenum
(GL_DEPTH_COMPONENT 0x1902 / GL_STENCIL_INDEX 0x1901), which does not fit in a byte, and the
contract's payload comment says nothing about how it crosses. Espryt decodes 0 =
GL_DEPTH_COMPONENT, 1 = GL_STENCIL_INDEX, and package B must emit that. The direction is
chosen by one property rather than by the enum's low byte: GL_DEPTH_COMPONENT is the GL and ES
default and a texture that never asks for the stencil aspect never emits the call, so a zeroed
record has to decode to exactly what such a texture already has. Owner: the integrator, to amend
MGPipeTypes.h's payload comment; package B, to emit it.
DV-3 — MGPSubData::Target's upload-target half was unstated. D-D3 says Target carries "the
owner's upload target … plus the cube-face upload target in MGPSurface-style terms" without
fixing the encoding. Espryt reads static_cast<Uint16>(MobileGL::TextureUploadTarget), i.e. the
frontend enumerator value, and the applier's PendingUpload::UploadTarget is matched against it.
Owner: same as DV-2.
DV-4 — MGPSurface::Kind's enumerator values are unstated, so Espryt does not read them. The
comment says Texture | Renderbuffer | None and no enum exists. Every test this package needed is
expressible without it, because D-C1 fixes the other spelling: "an empty point is
{Res = kMGPipeNullHandle, Kind = None}". So the framebuffer arm asks
MGPipeHandleIsNull(surface.Res) and never touches Kind. Nothing is blocked; recorded so the
integrator can mint the enum in the same amendment as DV-2/DV-3 rather than discovering it in
package E.
DV-5 — the four cross-object masks still read the frontend attachment objects, and this is a
finding rather than a shortcut. IsSnormFallbackAttachment, IsUnormFallbackAttachment and
IsAlphaWidenedColorAttachment all reduce to (format, **TextureTarget**) for a texture
attachment — ShouldUseCaveatTextureFormat(format, target) and
BackendTextureFormatAddsAlpha(format, target). MGPSurface carries InternalFormat and
UploadTarget but no texture target, and no TextureUploadTarget -> TextureTarget inverse
exists anywhere in the tree. Inventing one would feed ShouldUseCaveatTextureFormat — which is on
D-N's byte-identical list, so a change to what it is asked silently changes what every texture
is allocated as — with a guessed input. D-C1 promises the inline InternalFormat makes "the four
cross-object masks fall out at push time with no lookup"; that promise needs one more field.
Recommended fix: widen MGPSurface's Pad0 (2 bytes, already there) into Uint16 TextureTarget,
which keeps MGP_ASSERT_POD(MGPSurface, 24). Owner: the contract (package A) + the integrator.
Until then this package leaves the four masks reading the frontend, unchanged and correct.
DV-6 — MGPFramebufferState::DrawBuffers[] cannot spell the default framebuffer's tokens, and
that is provably harmless here. The wire array is an attachment INDEX with -1 for None (D-C1),
so FrontLeft / FrontRight / BackLeft / BackRight are unrepresentable. Those are the DEFAULT
framebuffer's own tokens; the default framebuffer has no BackendFramebufferObject (it is
pDefaultFramebufferInfo->defaultFBO, which is exactly why MGPipeHandles.h reserves {0,1} for
it), and the legacy arm's branch for them already says "shouldn't remap". The decode is therefore
total for every object that reaches this twin, and IsDefault is what a later phase would test if
that ever changed.
DV-7 — the framebuffer attachment WALK still reads the frontend attachment objects. What moved
is the KEY (DV-5's sibling): SyncAttachmentObject drives the texture and renderbuffer twins
through the frontend objects the monolith hands over, and resolving them from MGPSurface::Res
instead is package E's SyncAttachmentObject work — and is blocked on DV-5's missing target field
for the same reason. Recorded so the integrator does not read the ContentHash re-key as the whole
of D-C.
DV-8 — the program twin still reads the frontend archive, and D-H3 says it must. "THE ARTEFACTS
ARE NOT HELD HERE IN MONOLITH: … the applier stores the DESCRIPTOR and the identity and the server
reads the frontend's own archive." That is what keeps the codec off the monolith hot path entirely
and out of ID-19's budget. So BackendProgramObjectImpl::SyncToBackend's artefact reads are
correct as they stand, and what d5 moves is the identity and the serial. Recorded because the
step's own message ("take … the program artefacts from the applier") reads the other way.
DV-9 — the value sites are PREPROCESSOR MACROS, not helper functions or lambdas, and G1 is why.
This was measured, not assumed. Inserting two lambdas into SyncMipmapsToBackend renumbered every
one of its nine existing ErrorLopper lambdas — their mangled names are …::$_N by position —
for 8 symbols added, 8 removed and 4 std::function thunks resized in the PULL build. Routing
SyncTextureParamsToBackend's values through locals resized it +9 bytes, and the same shape
cost SyncBuiltinSamplerToBackend -2. P4a's admitted-resize set is EMPTY, so all three are G1
failures. A macro expands to the pre-P4a expression exactly when MOBILEGL_PIPE_PUSH is off, so
the pull build's preprocessed text — and therefore its object code — is unchanged. Every macro is
#undef'd immediately after its function. The alternative D-N blesses (a separate
#if MOBILEGL_PIPE_PUSH function with its own name) was used where the arms diverge structurally
(ResolvePushedBuiltinSampler, ResolvePushedTextureParams, PushedFramebufferRecord,
DecodePushedDrawBuffers) and rejected for SyncMipmapsToBackend, which would have meant
duplicating ~950 lines.
DV-10 — step d6 has no message in C.3. Used
[Test] (Espryt): drive the sampler-view table through the handle arm and prove every P4a death notice is idempotent.
DV-11 — the legacy arms are guarded #if MOBILEGL_PIPE_LEGACY_MEMOS only inside the push arm.
CMakeLists.txt:477-480 forces MOBILEGL_PIPE_LEGACY_MEMOS ON whenever MOBILEGL_PIPE_PUSH is
OFF, so a pull build always compiles the pre-P4a text; the #else branch of each arm switch is
that text verbatim. The #if !MOBILEGL_PIPE_LEGACY_MEMOS bodies are unreachable — the arm resolver
stops the process at its first call — and are kept loud, for the reason
BackendVertexArrayObject::SyncToBackend keeps its twin.
DV-12 — p4a_untouched_regions.sh does not exist on this tree. §4 says what was run instead.
6. Verification transcript
export CCACHE_BASEDIR=/home/swung/w7 in every shell; commands run from ~/w7/p4a-esprytobj.
6.1 After every commit (G1, unit, P3a's eleven, purity)
Run after each of 7aa598fa, c1d6b41c, 49ff8d91, 7e400454, a69819e4, 9bb95335:
$ python3 scripts/symbol_report.py --before ~/w7/p4a-before-libMobileGL.so \
--after build-linux/libMobileGL.so --threshold 0 \
--fail-on-symbol-set-change --fail-on-added-bytes 0
symbol-report: .text 10806323 -> 10806323 (+0, +0.000%)
symbol-report: 27811 -> 27811 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
rc=0
$ ctest --test-dir build-linux -L unit --no-tests=error -j 12
100% tests passed, 0 tests failed out of 1635 (1636 from d6 on)
$ ctest --test-dir build-push -L unit --no-tests=error -j 12
100% tests passed, 0 tests failed out of 1635 (1636 from d6 on)
$ bash scripts/p3a_untouched_regions.sh 37da3c3a HEAD
[p3a-untouched] the 11 pool / deferred-release / ring / flush-drain functions are
[p3a-untouched] byte-identical between 37da3c3a and HEAD rc=0
$ grep -rc 'pGLContext' MobileGL/MG_Backend | grep -v ':0$'
MobileGL/MG_Backend/MGPipe/PipeInputs.h:1 # pre-existing at 37da3c3a, unchanged
$ awk '/struct MGPipeResourceOps \{/,/^ \};/' MobileGL/MG_Pipe/PipeApply.h | grep -c MG_State
0 # D-B1: no op-table member added, no MG_State type
One G1 failure was found and fixed inside d2, before the commit, and it is DV-9's evidence: 8 added / 8 removed / 6 resized, every one of them attributable to the two lambdas and the two value locals. The committed tree of every step is 0/0/0/0.
6.2 D-N byte identity
§4. rc 0 for all four functions this package owns; p3a_untouched_regions.sh rc 0 for P3a's eleven
after every commit. git diff 37da3c3a HEAD -- MobileGL/MG_Backend/DirectGLES/Managers.cpp lands
no hunk inside any of the four.
6.3 The legacy-arm lanes
$ MOBILEGL_PIPE_PUSH=0x1ff ctest --test-dir build-push -L integration-gpu --no-tests=error -j 8 -R DirectGLES
99% tests passed, 6 tests failed out of 491
$ MOBILEGL_PIPE_PUSH=0 ctest --test-dir build-push -L integration-gpu --no-tests=error -j 8 -R DirectGLES
99% tests passed, 6 tests failed out of 491
Both lanes fail on the SAME six cases and nothing else, and the two failing sets are identical:
DirectGLES.HandleRecycle.Handles.HandleRecycleScenario.AVertexArrayAtARecycledAddressDoesNotInheritItsPredecessorsVertexInput
DirectGLES.HandleRecycle.Handles.HandleRecycleScenario.AVertexArrayAtARecycledAddressDoesNotInheritItsPredecessorsVertexBufferSet
DirectGLES.HandleRecycle.Handles.HandleRecycleScenario.ABufferAtARecycledAddressDoesNotInheritItsPredecessorsContents
DirectGLES.HandleRecycle.Handles.HandleRecycleScenario.ATextureAtARecycledAddressDoesNotInheritItsPredecessorsTwin
DirectGLES.HandleRecycle.Handles.HandleRecycleScenario.AFramebufferAtARecycledAddressDoesNotInheritItsPredecessorsTwin
DirectGLES.HandleRecycle.Handles.HandleRecycleScenario.DestroyedVertexArraysReturnTheirVertexElementsSlots
(Subprocess aborted)
Explanation, and it is a cross-package sequencing artefact the brief itself predicts — not a
defect in this package, and not a missing applier record. Those six cases are the .Handles arm,
whose ctest ENVIRONMENT property pins MGL_ITEST_HANDLES_ARM_KNOBS = "MOBILEGL_PIPE_LEGACY_MEMOS=0" "MOBILEGL_PIPE_PUSH=0x1ff" at
MobileGL/MG_IntegrationTest/CMakeLists.txt:949. A ctest ENVIRONMENT property replaces rather
than appends and overrides the job env, which is why both outer lanes see the identical failure
set. Under that pinned pair, all four P4a families classify as NoArm — the bits are clear AND the
operator asked for the pre-handle arms to be gone — and StopOnArmlessPipeSubsystem aborts, which
is exactly what D-K3 rules must happen ("all four can reach NoArm and all four stop with the
named Fatal{PipeLegacyMemosDisabled, …} rather than skipping green").
The fix is the pin move D-K1 already mandates and C.7 already assigns: 0x1ff → 0x1fff at
MG_IntegrationTest/CMakeLists.txt:949, 1065, 1075, 1149, 1183, 1188, 1219 and
0x80000000000001ff → 0x8000000000001fff at :1070, 1080, which contract deviation D10 confirms
is package F's — "pinning it at 0x1ff after P4a would leave the Handles arm asserting the P3a
shape while the handles it is supposed to be about stayed switched off" (CMakeLists.txt:942-947's
own argument). Until F lands, or the integrator moves those pins when merging esprytobj, these
six cases are red on the integrated tree. Softening the stop would be re-deciding D-K3 inside a
package, which ID-8 forbids, and would make the whole four-family A/B silently unmeasurable.
Everything else in both lanes passes; the skip list is the pre-existing one (the seven
DirectGLES.*Scenario entries that skip without an arm selector, the two
LargeArenaAdoption capability skips, the forced-D24S8 and async entries).
Proof, run standalone so the abort's own log line survives — ctest's ENVIRONMENT property
replaces the job env, so MOBILEGL_LOG_FILE_PATH cannot be injected into the lane, and the Fatal
goes to the log rather than to stdout:
$ MOBILEGL_LOG_FILE_PATH=/tmp/p4a-d.log MOBILEGL_BACKEND_TYPE=DirectGLES \
MOBILEGL_PIPE_LEGACY_MEMOS=0 MOBILEGL_PIPE_PUSH=0x1ff \
build-push/MobileGL/MG_IntegrationTest/MobileGLIntegrationTest \
--gtest_filter='IntegerBorderColorScenario.InsideTexelsAreUnaffectedByTheBorderColour'
Aborted exit=134 (SIGABRT)
[FATAL]: MGPipe: Fatal{PipeLegacyMemosDisabled, "MOBILEGL_PIPE_PUSH leaves
kMGPipeSubsystemTextureResources (bit 10) clear (or refuses it) and
MOBILEGL_PIPE_LEGACY_MEMOS=0 disables the pre-handle texture cheap-gate trio,
so there is no arm to run"}
$ ...same, with MOBILEGL_PIPE_PUSH=0x1fff (what package F's pin move produces)
exit=1 # no abort; an ordinary scenario failure
[ERROR]: MGPipe: texture 1 has no applier record on the handle arm, so its parameters
cannot be pushed (handle {1, 0})
That second run is the whole argument in two lines: with the phase mask moved, the armless stop disappears and what is left is §6.5's missing-record set, which the client packages close.
6.4 The default arm, and every failure classified
$ ctest --test-dir build-push -L integration-gpu --no-tests=error -j 8 -R DirectGLES
62% tests passed, 189 tests failed out of 491
189 = 183 + 6, and both terms are accounted for.
- 6 are §6.3's armless stop, unchanged from the other two lanes and owned by package F's pin move. They are the only cases that ABORT rather than fail.
- 183 are the missing-applier-record set, and the attribution is a log line rather than an argument. Running one of them standalone with the log captured:
$ MOBILEGL_LOG_FILE_PATH=/tmp/p4a-c.log MOBILEGL_BACKEND_TYPE=DirectGLES \
build-push/.../MobileGLIntegrationTest \
--gtest_filter='IntegerBorderColorScenario.InsideTexelsAreUnaffectedByTheBorderColour'
[ FAILED ] IntegerBorderColorScenario.InsideTexelsAreUnaffectedByTheBorderColour
$ grep -c 'no applier record' /tmp/p4a-c.log
3
[ERROR]: MGPipe: texture 1 has no applier record on the handle arm, so its parameters cannot be pushed (handle {1, 0})
[ERROR]: MGPipe: texture 1 has no applier record on the handle arm, so its built-in sampler cannot be pushed (handle {1, 0})
[ERROR]: MGPipe: texture 1 has no applier record on the handle arm, so its storage and uploads cannot be driven from the pushed descriptor (handle {1, 0})
Three refusals, one per switched-over texture path, each naming the handle it could not resolve —
{1, 0}, a handle the backend's own minting overload produced and for which the applier holds no
record because nothing has emitted one. No case fails for any other reason, and no handle arm
reads MGB_CTX or the frontend object to make a lane pass: every decline is a named
MGLOG_E_ONCE and a return.
The shape of the 183, stated so it can be re-stated unchanged after the rebase (P3a's espryt v2
discipline): every scenario whose draw needs a texture uploaded, a texture parameter pushed, a
built-in sampler pushed, a renderbuffer allocated, a framebuffer synced or a program's serial
stamped. The three lanes that carry their own phase pin (ForcedDepthStencilEmulation,
WidenedPacked16, NoViewportArrayEmulation) are in it for the same reason; the pure buffer,
clear, scissor, viewport and XFB scenarios are not, which is why 302 still pass.
6.5 What this tree cannot show, and why
Per ID-2 this package lands after wire, clientfb and clientsp. On this tree the applier's
fifteen P4a entry points are still c0's stubs and no client emitter has a body, so
MGPipeApplier().TextureResources / RenderbufferResources / SamplerCsos / SamplerViewCsos /
ShaderCsos and both framebuffer records are permanently empty. Every switched-over path therefore
takes its named refusal (MGLOG_E_ONCE, one per family per texture/framebuffer/sampler/program) and
declines, which is by construction: a fall-back to the frontend would hide a missing record behind a
picture that still looks right, and that is precisely what the subsystem A/B exists to expose
(MarkBufferGpuWritten's note, P3a). No handle arm re-reads MGB_CTX or the frontend object to
make a lane pass.
The expected failing set on the default arm is therefore "every case that draws through a texture, a framebuffer, a sampler or a program with a P4a bit set" — measured at 183 of 491 in §6.4, with its log evidence — and it is stated there by shape so it can be re-stated unchanged after the rebase, exactly as P3a's espryt v2 did.
The one thing to check first after the rebase is that this number goes to zero rather than down: a residual "no applier record" line for one kind after the client packages land is a seam defect (a handle minted on one side and looked up on the other), not a leftover.
7. Post-rebase verification list (to run on ~/w7/pipe after wire + clientfb + clientsp)
This is the list to run when the integrator says the client packages have landed — the first time real records exist. Every line is C.3's, plus the two this round could not run.
cmake --build build-linux && python3 scripts/symbol_report.py --before ~/w7/p4a-before-libMobileGL.so --after build-linux/libMobileGL.so --threshold 0 --fail-on-symbol-set-change --fail-on-added-bytes 0→ 0/0/0/0.grep -rc 'pGLContext' MobileGL/MG_Backend | grep -v ':0$'→ onlyPipeInputs.h:1.awk '/struct MGPipeResourceOps \{/,/^ \};/' MobileGL/MG_Pipe/PipeApply.h | grep -c MG_State→ 0.bash scripts/p3a_untouched_regions.sh 37da3c3a HEAD→ rc 0.bash scripts/p4a_untouched_regions.sh 37da3c3a HEAD→ rc 0 once package F has landed it; before that, §4's equivalent.cmake --build build-push && ctest --test-dir build-push -L unit --no-tests=error --output-on-failure.ctest --test-dir build-push -L integration-gpu --no-tests=error -j 8 -R DirectGLES— the real-path round. This is the one that matters: P3a's equivalent found three seam defects no package tree could see. The three seams to look at first, in order of risk:- the pending-upload set (D-D5): does the client clear its own dirty flags only for records the applier accepted, and does
ConsumePipeTextureUploadfire exactly where a level uploaded? A level cleared client-side but never consumed server-side is a texture that stops updating; the retain-mode comparison in the verify lane is the gate. - the
DepthStencilModeand upload-target encodings (DV-2, DV-3): if package B emitted a different encoding than §5 states,GL_DEPTH_STENCIL_TEXTURE_MODEis pushed backwards and cube faces resolve to the wrong pending entry.TextureParamsWithoutASamplerViewScenario's depth-stencil case is the behavioural gate. PushedFramebufferRecord'sFbomatch: if the client emitsTarget = Bothwhere Espryt expects a per-target record, or emits for a framebuffer other than the one being synced, the twin declines and the framebuffer is not synced at all.
- the pending-upload set (D-D5): does the client clear its own dirty flags only for records the applier accepted, and does
MOBILEGL_PIPE_PUSH=0x1ff ctest --test-dir build-push -L integration-gpu --no-tests=error -j 8 -R DirectGLES→ green only after the §6.3 pin move.MOBILEGL_PIPE_PUSH=0 ctest --test-dir build-push -L integration-gpu --no-tests=error -j 8 -R DirectGLES→ same.MOBILEGL_PIPE_PUSH=0x9ff ctest --test-dir build-push -R 'ObjectSubsystemControl'— the sampler-bit-without-the-texture-bit refusal, once package F has written that scenario. This package's half (theMGLOG_Eand the legacy fall-back) is already in.python3 ~/w7/retrace_gate.py --tree ~/w7/pipe --lib build-push/libMobileGL.so --out ~/w7/retrace-out/p4a-esprytobj -j 4— not run this round: with empty records the corpus can only reproduce the refusal set, so the number would mean nothing.ctest --test-dir build-verify -L integration-verify --no-tests=error -j 4, and the retain-mode texture-dirty-rect comparison of G4, which is the only way a consume-and-clear set can be checked at all.ctest --test-dir build-push -R 'TextureParamsWithoutASamplerView'— G9's mandatory scenario. Its red-before caseAReadAttachmentOnlyTexturesDepthStencilModeReachesTheDriveris closed on the E side (SyncAttachmentObjectgains the parameter sync for READ-only attachments); this package supplies the half that makes it possible, namely thatset_texture_paramsis addressed by resource andSyncTextureParamsToBackendno longer needs a sampler view to have a record.GLIBC_TUNABLES=glibc.malloc.tcache_count=0exported for 6, 7 and 12 (ID-18/ID-21).
8. Open items handed on
| item | owner |
|---|---|
DV-5's MGPSurface texture-target field (or the inverse mapping), which unblocks the four cross-object masks and E's SyncAttachmentObject |
contract (A) + integrator |
DV-2 / DV-3 / DV-4: the DepthStencilMode encoding, the upload-target encoding, the MGPSurface::Kind enum |
contract (A) + integrator; package B must emit DV-2/DV-3 as stated |
the itest phase-mask pins 0x1ff → 0x1fff and 0x80000000000001ff → 0x8000000000001fff |
package F (contract D10); blocks §6.3 |
scripts/p4a_untouched_regions.sh |
package F |
the four remaining MGPipeUnmigratedEmulation sites (copy-image-shadow-mirror, generate-mipmap-storage, generate-mipmap-cpu-fallback, get-tex-image-shadow) |
package E |
the four g_fboSynced* arrays' READERS, in SyncCurrentFBO |
package E |
the nine-clause rebuild condition reading GetSyncedShaderCsoSerial() |
package E |
| the sampler-view twin's first consumer (the resolved-set walk and the raw-depth-fetch substitution keyed on it) | package E |