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.
33 KiB
v1-v1 — the server role, the apply thread, and the EGL context migration
Branch p5/v1, commits 5e5bf7b9..571cbabb (six single-line commits; base = the integration head
feat/disaggregated@5e5bf7b9 = wave 1 + dev fff9d639, merged first per ID-44). Resumed after the
Sep 11 outage from the uncommitted WIP the integrator preserved (ID-45); nothing was restarted.
Commits, oldest first:
| sha | what |
|---|---|
377356f8 |
R-11: MG_Remote/Server/StagedShadow.h + the four Managers.cpp sites; Fatal{StageSnapshotTooNarrow} asserted BEFORE the flush drain |
8dbe230a |
Server/PipeApplier.{h,cpp}: Attach on the apply thread, stamp → apply → clear per record, ServerVerbSink for the five class-B verbs |
23c04687 |
Server/ServerLoop.{h,cpp}: mgl-srv-apply, affinity mask, three-way park predicate, blocking control mailbox, bounded Stop, the twelve EGL forwarders |
d6231184 |
MG_Backend/Init.cpp hook + MobileGL/Init.cpp ShutdownSplitRoles() at the top of DestroyImpl |
7ea3b1d1 |
MG_Test/Wire/ServerLoopTest.cpp (11 cases) + its CMake registration (split-only) |
571cbabb |
G1 fix: ShutdownSplitRoles exists only under MOBILEGL_BUILD_DISAGGREGATED |
Files touched: MobileGL/Init.cpp, MG_Backend/{Init.cpp,BackendObjects.h},
MG_Backend/DirectGLES/Managers.cpp (b1's; R-11 only, see §5), MG_Remote/Server/{ServerLoop,PipeApplier}.{h,cpp},
MG_Remote/Server/StagedShadow.h (new), MG_Test/Wire/{ServerLoopTest.cpp,CMakeLists.txt}. No .def, no
generator, no c0/c1/s1/w1/p1/t1 file.
1. What landed
The thread (charter 1). ServerLoop::Start spawns mgl-srv-apply; the thread names itself, resolves
MOBILEGL_IPC_SERVER_AFFINITY (auto = ShaderCompilePool's 85%-of-peak cpufreq rule re-derived as a
MASK, off = 0, or a number), applies it with sched_setaffinity, and logs the RESOLVED mask (0 on this
WSL box: no cpufreq tree, so "do not pin" rather than "pin to a guess"). It parks through
Doorbell::Wait(control.consumerParked, ready, spinUs, kWaitForever) and treats Wait == false && Dead() as
shutdown. The park predicate is THREE things - ring head moved, stop requested, control request pending -
not SessionConsumer::WaitForWork's one: a Notify is consumed by one Park, so a predicate that cannot
see the control request re-parks for ever (that is red-check case park-predicate-loses-control, which
must TIME OUT). Stop = set stop, ring, wait for the exit flag with a 5 s bound, then join; a bound
that expires is Fatal{ApplyThreadJoinTimeout} + abort, never detach (a detached apply thread still owns
the context and reads rings the client is about to unmap).
The EGL migration (charter 2). ServerLoop::CreateBackend builds the server's private
BackendObject_DirectGLES (or _DirectVulkan) on the app thread and runs its non-GL Initialize(); the
context is created and made current LATER, on the apply thread, when the client's eglMakeCurrent
crosses as a blocking control request (RunOnApplyThread: one-slot mailbox, caller-serialised, runs
INLINE when already on the apply thread - which the teardown path needs, and inline when no thread exists
yet). Twelve free-function forwarders Server{InitializeEGLDisplay, CreateEGLWindowSurface, ResizeEGLWindowSurface, CreateEGLPbufferSurface, MakeEGLCurrent, SwapEGLBuffers, SetEGLSwapInterval, ReleaseEGLSurface, ReleaseEGLResources, InitCapabilities, InitWindowSurface, SetWindowHandle} are the seam
c1 needs; ServerMakeEGLCurrent and ServerInitCapabilities also re-publish the CapsSnapshot on
success (R-12 arm (a): a second arrival IS the invalidation). The backend is destroyed on the apply
thread, while it still owns the context, by the thread itself on its way out - so ~BackendObject_DirectGLES
→ DestroyEGLContext never runs on the app thread. Evidence it works: on the joint build the log shows
GL_VENDOR: Mesa / GL_RENDERER: llvmpipe written by thread mgl-srv-apply, CapsMirror generation 2 adopted on the client after make-current, and destroying the server's BackendObject on mgl-srv-apply, which is the context owner at teardown (~/w7/p5-v1-joint-preflight.log).
The hook (charter 3). MG_Backend::Init() gains one #if MOBILEGL_BUILD_DISAGGREGATED block before the
switch: if Transport != Monolith → InitSplitRoles() = server backend → the two CallMask halves (§1
"caps") → ClientSession::Start (s1/c1's; it does the handshake and ends by calling ServerLoop::Start) →
the client's backend object into pActiveBackendObject → InitSpecificBackendLibs() (which fills
gBackendFunctionsTable from THAT object, i.e. c1's emit table) → LogBackendInfo(). c1-v1 §8.2's order,
exactly. A failed bring-up leaves pActiveBackendObject null and returns - no fallback to the switch.
The counterpart ShutdownSplitRoles() runs first in DestroyImpl (§1 "teardown").
The applier (charter 4, 5). PipeApplier::Attach builds w1's decoder ON the apply thread (its
constructor installs the process-wide apply hook) and points it at ServerVerbSink. ApplyOne =
StampVerbBoundary(op) → DecodeAndApply → LeaveApplier(); s1's SessionConsumer::ApplyOne advances
appliedSeq by exactly one after it returns, and nothing here touches RingControl. No batching. After each
drain batch: the decoder tally and the session watermark must agree (Fatal{ProtocolCorruption, "appliedSeq batched"} otherwise) and RetireThrough(AppliedSeq()) runs once. p1's rule verbatim:
MGPipeVerbForWireOp(op), kVerbCount ⇒ nothing, else MGPipeServerStampVerbBoundary(verb) once before the
applier; MGPipeServerClearVerbBoundary() on leaving - inside ApplyOne, before the watermark publishes
(§6). PipeApplier::m_residualPulls is deleted; ResidualPullCount() forwards to MGPipeResidualPullCount().
ServerVerbSink is the consumer for the five class-B verbs that have no MGPipeApply* entry point: Clear
(five kinds, three value classes, against the BOUND framebuffer - MGPClear::Fbo is null by c1's ruling),
Blit, Present (through the server's own Present, so present ↔ eglSwapBuffers stays 1:1;
FrameSerial == 0 = stamp your own), ReadPixels (writes exactly DstSize bytes into the reply slot,
DECLINED when no table, ERROR on zero size - never a silent non-answer, because the client is parked on
that seq), DrawVbo (single non-instanced arrays / indexed draw; NumDraws != 1, instancing and any user-index
span are DECLINED BY NAME - P8's). Per-verb tallies exist for lanes to assert against.
R-11 (charter 6). StagedShadowStore (header-only, keyed by the resource twin's address) copies
[offset, offset+size) into server-owned storage and records the EXACT covered ranges (adjacent runs merge,
gapped ones do not). Ops_H_SubData / Ops_H_FlushRange / the respecify base go through
MGL_SERVER_STAGED_ADOPT, whose non-split expansion is the ORIGINAL expression character for character
(raw - offset), so push/verify compile what they compiled before. Drops at destroy, at a successful
map_persistent, and at context death. The integrator's M-6 ruling is enforced as
Fatal{StageSnapshotTooNarrow, "<site>"}: UploadRangeFrom and the tier-1 invalidating map in
Ops_H_FlushRange check their own range, and the three-tier drain's queue is checked at its two
server-shadow call sites (Ops_H_Readback, the handle-arm ensure path) by
RequireStagedCoverageForPendingRanges before FlushPendingRangesFrom is called - the pinned body is
untouched (§5). The store's copying arm is a constructor parameter, not a MG_Config::Transport read, so
StagedShadowTest builds one of each and asserts the DIFFERENCE.
Caps defaults (charter 7). InitSplitRoles sets both halves before Accept: SetCapabilityBits(0)
(explicit: kCapNeedsHostIndexBytes/kCapNeedsHostUboBytes are 0 for all of P5 by table 0) and
SetConsumedSubsystems(ConsumedSubsystemsFor(type)) = kMGPipeSubsystemsMigratedAtP4a for DirectGLES,
the same minus kMGPipeSubsystemResources for DirectVulkan (which registers no resource ops) - stated from
what the backend IS, not derived from the process-wide MGPipeGetResourceOps(), which under inproc
answers with whatever the client half registered. AssertConsumerMaskIsHonest runs after Initialize() and
is Fatal{ConsumerMaskLie} if the mask claims the resource family while no op table is registered (ID-39's
shape, one level down). On the joint run the client adopted callMask=0x1fff00000000.
Teardown (charter 8). ShutdownSplitRoles() → ClientSession::Stop(), which IS table 3's order:
publish + bounded drain → transport->Shutdown() (= Doorbell::Kill, the only thing that wakes a
kWaitForever park) → ServerLoop::Stop() (bounded join; the thread applies whatever is still queued,
detaches the decoder, destroys the backend on itself) → only then the emitter-owned things → transport
closed. It runs at the TOP of DestroyImpl, so the apply thread is joined before PipeStats::Shutdown()
dumps and before pActiveBackendObject.reset(). The sync/query registries keep today's order (drained at
MobileGL/Init.cpp:62/:67, before :68); CONTRACT §4's known open item is recorded as "P5 keeps today's
order" in BackendObjects.h, and it is P10's to move. Under GLIBC_TUNABLES=glibc.malloc.tcache_count=0
(exported by the gate) every case, the shutdown case included, is green; StopKillsTheDoorbellJoinsAndTheThreadReallyExits
asserts the thread really PARKED first and that Stop returned inside the bound.
2. Acceptance
| charter line | status | evidence |
|---|---|---|
DirectGLES.Split.ClearThenReadPixelsScenario.* green under inproc |
green on the joint preview, not on p5/v1 alone (needs c1) |
~/w7/p5-v1-joint-isplit.log: 21 entries, 19 passed, 2 skipped by design (TheMapLandsInTheArmItsLaneDeclares in the two non-counting lanes: "MGITEST_PMAP_LANE is set only by the .PersistentMapArm. entries"; the counting entry passed). All 5 ClearThenReadPixels, both TriangleScenario, both SmallRing.* families. The probe is t1's runtime one (SplitLane.h:SkipReasonForSplitOnlyAssertions → SplitRuntimeSkipReason), armed only by a live session, non-zero implemented verbs and a moved record ordinal - not by source text. |
| four self-tests, all four dirs + split; G1 must not move | all green, §3 | ~/w7/p5-v1-gaterun.log |
| teardown clean under the tcache tunable, 5 s bounded join | green | gate exports it; ServerLoopTest.StopKills… + red-check park-predicate-loses-control (the case TIMES OUT when the predicate loses the control flag, i.e. a lost wakeup is red, not a wedge) |
MOBILEGL_IPC_AUDIT=1 on the reduced path, no 0xDD reaches a draw |
19/21 green under audit on the joint | ~/w7/p5-v1-joint-isplit-audit.log; plus unit-scope TheAuditPoisonFillsExactlyTheStagedRunAfterTheApplierReturns (asserts the bytes crossed, the poison ran, and it landed on the named run, read back through the CLIENT's mapping) |
The first IPC frame renders on the reduced path (~/w7/p5-v1-joint-preflight.stdout:
[ OK ] ClearThenReadPixelsScenario.ClearWithNoDrawIsVisibleToDefaultFramebufferReadPixels (6 ms) under
MOBILEGL_TRANSPORT=inproc, MGITEST_SPLIT_LANE=1, MOBILEGL_ITEST_REQUIRE_GPU=1), after three seam
fixes that live on the scratch branch only (§8). p5/v1 by itself cannot arm the lane: there is no client
role without c1, and the weak placeholder aborts by name rather than pretending.
3. The four self-tests (final gate on 571cbabb, ~/w7/p5-v1-gate.sh, log ~/w7/p5-v1-gaterun.log)
All four dirs rebuilt first (CTestTestfile.cmake checked before anything is reported, C-10).
| pull | push | verify | split | |
|---|---|---|---|---|
| build | rc=0 | rc=0 | rc=0 | rc=0 |
ctest -L unit |
1813/1813 | 1813/1813 | 1813/1813 | 1985, 2 known reds (RingTest.TheTwoFlagSpacesAreDisjointByTranslation = s1's ID-43, PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot = c1's ID-31) = the charter's 1974 + v1's 11 |
G1 (pull build vs ~/w7/p5-before-libMobileGL.so, marker 4595163c):
.text 10806611 -> 10806611 (+0, +0.000%), 27814 -> 27814 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed; nm pull MG_Remote = 0, nm split MG_Remote = 426, ServerLoop symbols in split = 24.
It was red on the first measurement - +32 .text, 1 added (MG_Backend::ShutdownSplitRoles()), 1 resized (DestroyImpl) - because the first version called ShutdownSplitRoles() unconditionally from
MobileGL/Init.cpp with an empty body in a pull build. "A no-op call" is still a call and a symbol. Fixed in
571cbabb: declaration, definition and call all under #if MOBILEGL_BUILD_DISAGGREGATED.
Integration: build-push, MOBILEGL_TRANSPORT=monolith, ctest -L integration-gpu: 1128/1128.
build-split, monolith: 1149 with exactly the seven known reds, all PersistentCoherentMapScenario
(b1's ID-42), none other.
G2/G14, in the integrator's exact shape (wsl_p5_gate.sh:25,118-122: every registered name, comm):
names pull 2941 / push 2941 / split 3134 / baseline 2902; G2 pull-vs-push 0 diff lines; G14 pull
0 removed, 39 added (wave 1's own, identical to c1's report); split vs push 0 removed, 193 added (182
wave-1/c0 split-only + v1's 11).
Generators: gen_pipe --check, gen_pipe_field_ownership --check, gen_pipe_dirty_surface --check all
up to date (v1 touched none); check_include_closure: 4 probes, 0 problems.
G5 (scripts/p3a_untouched_regions.sh / p4a_…) against ff2994d9 and against 5e5bf7b9: the ONLY
region that moves is FlushPendingRangesFrom, and its sha at my HEAD is 172b0222…, the integration
head's own body (ID-41) - p3a reports "byte-identical between 5e5bf7b9 and HEAD" for all eleven; p4a stays
red on that one name because it consults the pin unconditionally (ID-41's D-N/2), which b1's re-pin closes.
My WIP had a line INSIDE that body; §5 says where it went.
Flake sweep (new gate part 2b): v1's suite ×100 under -j 8: 100% - the two ordering defects were
1-in-40 reds at that load, so a single green run is not a verdict for this suite.
4. The red-check (R-16): python3 ~/w7/p5-v1-redcheck.py, log ~/w7/p5-v1-redcheck.log
Baseline green → each of TEN perturbations rebuilds build-split, runs the named case, and must go RED →
restore → baseline green again. Final line P5_V1_REDCHECK_ALL_WENT_RED. "I made it red once, by doing X":
| gate | X |
|---|---|
AClearRecordCrossesAndIsStampedAsAVerbBoundary |
stamp-removed: StampVerbBoundary answers kVerbCount → red at :366 |
| same, the M-5 half | leave-applier-removed: comment out LeaveApplier() → ServerStampedVerb() stays true, red at :373 |
TheSessionWatermarkAndTheDecoderTallyAgreeAfterEveryRecord |
drained-tally-removed: remove the per-record m_drained bump → red at :398 (deterministic control for the ordering defect, §6) |
| same, the retire half | retire-removed: comment out RetireThrough → the 2 s bounded poll of retiredSeq times out, red at :414 |
AControlRequestRunsOnTheApplyThreadAndUnparksIt |
control-runs-on-caller: if (true) return work(user) → "ran on the CALLER" at :250 |
| same, the un-park half | park-predicate-loses-control: drop ControlIsPending() from the predicate → the case times out at 60 s (the honest shape of a lost wakeup) |
TheAffinityStringResolvesToAMaskAndTheMaskIsLogged |
resolved-mask-not-logged: rename the log token → :335 |
TheAuditPoisonFillsExactlyTheStagedRunAfterTheApplierReturns |
audit-poison-disarmed: SetAuditPoison(false) after attach → :483/:491 |
StagedShadowTest.TheSplitArmCopiesAndSurvivesTheSourceBeingPoisoned |
r11-copy-removed: the split arm returns raw - offset → seven :529 reds (the copy reads 0xDD) |
StagedShadowTest.CoverageIsExactAndAGapIsNotCovered |
coverage-widened: merge ranges 16 bytes apart → :547-:552 |
Every control asserts its own string; no case constructs the state it observes (records go in through w1's
encoder over a real ShmSegment session and come out through the real apply thread; nothing calls
PipeApplier::ApplyOne directly, nothing writes a record field by hand); no probe arms against a stub (the
five class-B verbs DECLINE in the unit process because there is no GL context, and the case asserts the
decline - Clears() == 0 - rather than skipping).
5. Charter/contract lines I did NOT do, or did differently - with evidence and what overturns the ruling
ClientSession::ScopedApplierEntrydoes not bracketApplyOneonp5/v1. It cannot: the type (and the twoNote*statics) exist only onp5/c1; the integration head'sClientSession.hhas the two stubbed predicates and nothing to call. The bracket IS placed and verified onp5/v1-joint(0a02f94b, in~/w7/p5-v1-joint-seam.diff): aconst Client::ClientSession::ScopedApplierEntryat the TOP ofApplyOne, covering the stamp andLeaveAppliertoo, not onlyDecodeAndApply- both aregPipeInputswrites and the client asserts the flag is DOWN before it publishes, so a bracket around the decode alone would leave two real writes outside the check. It drops beforeApplyOnereturns, i.e. before s1 publishesappliedSeq, so the client can never observe it up. The 19 passing split entries ran with it in. Integrator: apply that hunk in the merge commit. Overturned if c1's flag moves out ofClientSession.hinto something the server may include.- My R-11 line inside
FlushPendingRangesFromis gone, deliberately. The WIP asserted coverage INSIDE the pinned body (MGL_SERVER_STAGED_REQUIRE(..., "flush_pending_ranges")). ID-41 admits the row's move for b1's re-parameterisation and b1 re-pins to172b0222…; a second move by v1 would turn G5 red again the moment my landing follows b1's. So the pinned body is byte-identical to the integration head and the coverage Fatal moved to the instant BEFORE the drain takes the queue, at the two call sites whose base can be a server shadow (Ops_H_Readback, the handle-arm ensure path), throughRequireStagedCoverageForPendingRanges- same clamp as the drain's, checked overpendingRangesunderpendingMutex,RequireCoverageno-ops for the legacy arm'sMappedData(). Cost: the three clamp lines are spelled twice. Overturned if a THIRD caller ever passes a server shadow (grepFlushPendingRangesFrom(: the other two passMappedData()). Also note for ID-41: my WIP never passedhostBaseFrom/To; it asserted coverage instead. The two defaulted parameters are unused by v1. - No
mgl-srv-io- by charter; inproc's control plane is in-process (InProcessTransport), P6 splits it. ServerVerbSink::OnClearimplements all five kinds and three value classes, where c1-v1 §3 saysOnClear"should Fatal on anything else" thanWhole. The numbering is shared (kMGPClearKind*inPipeApplier.h= c1'sMGRemoteClearKind, Whole..DepthStencil = 0..4, same order,ValueClassreusesCore.h:39-41's three-way split), each arm is a distinct GL entry point rather than a guess, and an out-of-range value ISWireProtocolFatalAt. c1 emitsWholeonly in P5, so the other arms are inert until the eightglClearBuffer*/glClearNamedFramebuffer*migrate. FLAGGED FOR c0: both enums belong inMGPipeTypes.h, which is c0's; two package headers now agree by discipline, not by construction.- The
rspfloor. A record that is NOT a verb boundary applies with the stamp flag disarmed (p1 forbids re-stamping on a non-verb op), so a sticky forward pulled from inside such a record's applier is not counted. Documented inPipeApplier.cpp; closing it needs an "enter the applier without stamping" entry point in p1'sPipeInputs.cpp. The number this phase reports is a floor, never an over-count. - DirectVulkan under split is untested by me.
CreateBackendand the consumer mask handle it (bit 7 withheld), the inproc lane's DirectVulkan entries are in~/w7/p5-v1-joint-inproc.log(§8), but no DirectVulkan split scenario exists to arm. - OpenRA under split / audit was not run: it needs t1's
SPLITtrace-replay variant and c1's landing; the audit was run over the 21 split entries only. MOBILEGL_IPC_VERB_BARRIER=0andMOBILEGL_IPC_STRICT_ERRORS=1were run once each on the joint split lane and the way they go red is recorded in §8 (they are lane matters, but the brief says "run once and record", so they are).
6. The ordering defect - what it was, and its fix
My last words before the outage were "Found a real ordering defect via the red-check baseline". Re-derived
today by re-running that baseline under load (ctest -R 'ServerLoopTest|StagedShadowTest' -j 8 --repeat until-fail:40): red at run < 40 - TheSessionWatermarkAndTheDecoderTallyAgreeAfterEveryRecord:398
(DrainedRecords() 7, expected 8) and AClearRecordCrossesAndIsStampedAsAVerbBoundary:365 (0, expected 1).
The family is "server-side bookkeeping ordered AFTER the watermark that releases the client". s1's
SessionConsumer::ApplyOne publishes appliedSeq the instant the apply callback returns, and publishing
appliedSeq is what makes the client runnable (R-1). Anything the apply thread records about a record AFTER
that publish is visible to the client only eventually. Two members:
- (a)
LeaveApplier()after the drain batch - the stamp-clear ran while the client was already touchinggPipeInputs: a second writer, table 3's one forbidden thing. Already fixed in the WIP the integrator preserved: the clear is insideApplyOne, before the publish (PipeApplier.cpp's block says so, and~/w7/p5-v1-patch3.py's timestamp shows the red-check anchor moved fromServerLoop.cpptoPipeApplier.cppat 16:32 on Sep 11 - that was the fix in flight). - (b)
m_drainedtallied once per batch, after the publish - unfixed in the WIP, reproduced today, fixed in23c04687: the tally moves inside the apply callback, before s1 publishes, soDrainedRecords()can never lagappliedSeq. 200 consecutive-j 8runs of the two cases green after the fix; the gate's 100× flake sweep is green; red-checkdrained-tally-removedis the deterministic control. (A third,retiredSeq, is NOT a defect: R-9 lets every watermark butappliedSeqpublish late, and the case polls it with a 2 s bound instead of reading it once - the bound is what keeps it a check.)
Which of the two the sentence referred to I cannot know from the record; both were in the red-check baseline's failure mode, (a) was fixed in the tree I inherited and (b) was not. Both are fixed now, and the gate now sweeps for this family under load.
7. What I think the brief or contract got wrong
- A weak-symbol seam is unsafe under the static archive the tests link. My own design, not the
contract's, but worth recording as a tenth-class finding:
MobileGLIntegrationTestlinksMobileGL_s; an archive member is pulled only to satisfy an UNDEFINED reference, andServerLoop.cpp.o's weakCreateRemoteBackendObjectalready satisfied it, so c1'sBackendObject_Remote.cpp.owas never linked and the joint build aborted in the placeholder with c1's object fully present (nmshows the symbolt, local, at the placeholder's address). Direct construction in the hook (c1-v1 §8.2's own wording) needs no factory and no weak symbol; that is the merge-time form (§8). - The preamble's G14 wording ("
ctest -L integration-gpu… name-for-name equal top5-before-ctest-names.txt") does not describe the file. The file isctest -Nover EVERY label (2902 names, unit suites included); the integrator'swsl_p5_gate.sh:118-122compares all names withcomm. Taken literally, the preamble's line produces a 1774-line diff on a correct tree (my first run printed 213AsyncCompileTest.*"removals"). My gate now spells it the integrator's way. - c1-v1 §8.4 says
TriangleScenario"will not" render without the 37-entryMGPipeApply*routing. It does - both cases pass under inproc - because the P3a handle arm already DEFERS every GL touch made on a non-owner thread (CanTouchGLNow()false →pendingRanges/ lazy ensure) and the apply thread drains them at the draw. That is "right by accident under inproc", the exact shape R-8 warns about: the same records execute nothing under spawn. R-17's routing is still required; the green triangle must not be read as its absence being harmless. - Table 3's
pActiveBackendObjectrow says the EGL lifecycle becomes "a blocking request onto the apply thread" but not THROUGH WHAT. c1 built its own trampolines overRunOnApplyThread+Backend()instead of the twelve forwarders, and thereby skipped the R-12 republish thatServerMakeEGLCurrentcarries - while c1's ownInitCapabilitiescomment assumes the republish happened. The contract should name the forwarders as the seam (they are declared inServerLoop.hfor exactly that reason). - ID-41 credits my WIP with "passing a real extent"; it did not - it asserted coverage. Harmless to the
ruling (the re-pin target is still
172b0222…), but the pin's justification should not cite a caller that does not exist. - BRIEF §5 says 19
CanTouchGLNow()sites; the contract's 16 is right (c0-v1 §6.13) - already known, restated because the charter text repeats 16+16 correctly.
8. The joint preview: p5/v1-joint = p5/v1@7ea3b1d1 + p5/c1@87c1e1be (c1 round 1 + the same dev merge; c1 round 2 had landed no code yet)
Worktree ~/w7/p5-v1-joint, links toggle ~/w7/p5-v1-joint-submodlinks.sh, split build only. Merge
c24cb5b7 had ONE conflict (MG_Test/Wire/CMakeLists.txt: both packages appended a test target; kept
both). Then three scratch commits, none of which is on p5/v1 (~/w7/p5-v1-joint-seam.diff, 137
lines, git diff c24cb5b7 f3ed2ed4):
| scratch commit | edit | whose |
|---|---|---|
0a02f94b |
ScopedApplierEntry bracket at the top of PipeApplier::ApplyOne |
v1's - the merge hunk (§5.1) |
0a02f94b |
c1's RunMakeCurrent → Server::ServerMakeEGLCurrent(...) (runs inline on the apply thread; carries the R-12 republish) |
c1's file - c1 must provide (or call all twelve forwarders) |
97f8b8d2 |
hook constructs MakeUnique<MG_Remote::Client::BackendObject_Remote>() directly (#include <MG_Remote/Client/BackendObject_Remote.h>); weak placeholder deleted from ServerLoop.cpp |
v1's two files - the merge-time form, for the integrator's merge commit (§7.1) |
f3ed2ed4 |
m_started = true; restored in ClientSession::Start step 7 |
c1's file - c1 must provide: c1's rewrite of Start dropped s1's line (integration head ClientSession.cpp:328), so EmitAndWait's !m_started guard aborted EVERY verb with Fatal{NoClientSession, "Clear"} on a fully-up session |
The three failures, in the order they were hit, each the first real failure of its run
(~/w7/p5-v1-joint-preflight.log is the last run's log):
Fatal{UnimplementedRemoteBackendObject}in the pre-flight child → every entry SKIPPED (harness: "the EGL bring-up ABORTS … signal 6") - the static-archive link, §7.1.Fatal{NoClientSession, "Clear"}at the first verb, afterCapsMirror generation 2 adopted- c1's missingm_started = true.- none:
[ OK ] ClearThenReadPixelsScenario.ClearWithNoDrawIsVisibleToDefaultFramebufferReadPixels (6 ms).
ctest -L integration-split on the joint: 21 entries, 19 ran and passed, 2 skipped by design
(~/w7/p5-v1-joint-isplit.log); under MOBILEGL_IPC_AUDIT=1: identical, 19/21
(~/w7/p5-v1-joint-isplit-audit.log) - no 0xDD reached a draw. Unit lanes ServerLoopTest + StagedShadowTest
- c1's
RemoteClientTest: 11/11 in the joint binaries (the bracket and c1's barrier check coexist).
The inproc integration-gpu lane (MOBILEGL_TRANSPORT=inproc ctest -L integration-gpu, 1149 entries,
~/w7/p5-v1-joint-inproc.log). Before the seam fixes: 1138 skipped + 11 failed, all "the EGL bring-up
ABORTS" (the placeholder). After them: 428 passed, 185 skipped, 506 subprocess-aborted, 28 failed. The
aborts are R-4 working as ruled - a class-C slot by name, e.g. CrossFrameBufferScenario.VertexBufferSubData
→ Fatal{UnmigratedVerb, "DrawElements"} (probed directly with a log file; ctest's capture holds only the
gtest lines because MGLOG_F writes to the log file). What passes is what the six-verb reduced path plus
the deferred handle arm can serve: OrientationScenario (11/11 DirectGLES), HandleRecycle.*,
AdvertisedLimitsScenario, the Split.* families; what aborts is every suite that reaches a class-C verb
(ImageTargetKindScenario 29, CrossFrameBufferScenario, VertexAttribBindingScenario,
UnboundImageDescriptorScenario 13 each, both backends). This lane is judged on the reduced path only
(BRIEF §4); the 506 are the census's 65 Fatal{UnmigratedVerb} slots being reached, not a v1 defect.
Negative controls, run once each on the joint split lane, and the way each goes red:
MOBILEGL_IPC_VERB_BARRIER=0(R-1's control,~/w7/p5-v1-joint-isplit-barrier0.log): 19 of 21 red. One assertion-red -ClearThenReadPixelsScenario.cpp:290/:295,bottom.r/top.bread back as0where> 200was cleared (the readback overtook the clear); the other eighteen ABORT withFatal{BarrierViolation, "DrawVbo"}- c1's runtime form of R-1's invariant, which can only fire because theScopedApplierEntrybracket (§5.1) raised the apply-side flag. That is the bracket's own red-check.MOBILEGL_IPC_STRICT_ERRORS=1(R-7.3,~/w7/p5-v1-joint-isplit-strict.log): 19 of 21 abort on the APPLY THREAD withFatal{UnmigratedPipeInput, "GetTextureContextId@Clear"} [BARRIER-PULLED, MOBILEGL_IPC_STRICT_ERRORS=1, retires in P3b/P4b]- p1's instrumentation naming the firstrspread the server makes on the reduced path, exactly table 2's row. Therspcount is the P3b/P4b debt; the number itself is for thePipeStatsline once the lane runs under the integrator's gate.
9. What c1 must provide (nothing of it is implemented on p5/v1)
m_started = true;beforeg_active = this;inClientSession::Startstep 7 (§8,f3ed2ed4).- The nine EGL virtuals of
BackendObject_Remoteshould call v1's twelveServer*forwarders rather than private trampolines - at minimumMakeEGLCurrent→ServerMakeEGLCurrentandInitCapabilities→ServerInitCapabilities, which are the two that republish the caps snapshot (R-12 arm (a)). Without it the client's mirror keeps the Accept-time snapshot, whose limits were read before any context existed, and c1's ownInitCapabilitiescomment ("whose ServerSession re-published the snapshot") is false. - Nothing else.
CreateRemoteBackendObjectis NOT needed: at the merge the hook constructsBackendObject_Remotedirectly and v1's weak placeholder is deleted (97f8b8d2's hunk is the exact edit, both files v1's).ClientSession::Active()is set at step 7, beforeServerLoop::Start- correct. - For c0 (via the integrator):
kMGPClearKind*/kMGPClearValueClass*belong inMGPipeTypes.h(§5.4).
Where the bracket belongs (the integrator's question): in PipeApplier::ApplyOne, and at its TOP, for
the reason in §5.1 - one hunk in v1's file, applied at the merge, verified on the joint.
10. Debts left
rspis a floor for non-verb records (§5.5): needs p1's "enter without stamping" entry point.- The clear-kind enums are duplicated across
PipeApplier.hand c1'sEmitTables.huntil c0 hosts them. ServerVerbSink::OnDrawVbodeclines instancing, multi-draw and indirect by name (P8);OnReadPixelshas no PBO destination (b1's, client-side);OnBlituses the bound framebuffers only.DetectBigCoreMaskreads/sys/devices/system/cpu/*/cpufreq/cpuinfo_max_freqon Linux/Android only; every other platform resolves to "no affinity" and says so.- The
SetVertexAttribDefaultswarning in the joint log ("does not reproduce the carried value … the client is keepingm_currentVertexAttributeauthoritative") is p1/w1's known one, visible now because the path runs. MOBILEGL_IPC_E2_DROP_CLEAR(c1'sgetenvknob) was not exercised here.- The sync/query release order stays today's (recorded, P10).
p5/v1is based on5e5bf7b9;feat/disaggregatedhas since gained4ba14fa4(s1's ID-43,RingTest.cpponly). It touches nothing of mine; merging it will retire one of the two known split reds.
11. Files and scripts (kept; everything else with the p5-v1- prefix was deleted)
~/w7/p5-v1-gate.sh (the four self-tests + flake sweep + split/monolith lane + G2/G14 in the integrator's
shape; log ~/w7/p5-v1-gaterun.log), ~/w7/p5-v1-redcheck.py (log ~/w7/p5-v1-redcheck.log),
~/w7/p5-v1-cfg.sh / -allbuilds.sh / -submodlinks.sh / -setup.sh, ~/w7/p5-v1-joint-submodlinks.sh,
~/w7/p5-v1-symbols.md, ~/w7/p5-v1-names-{linux,push,split}.txt, ~/w7/p5-v1-igpu-push.log,
~/w7/p5-v1-igpu-split-monolith.log, ~/w7/p5-v1-{pull,split}-unit.log, ~/w7/p5-v1-flake.log,
~/w7/p5-v1-joint-{isplit,isplit-audit,isplit-barrier0,isplit-strict,inproc}.log,
~/w7/p5-v1-joint-preflight.{log,stdout}, ~/w7/p5-v1-joint-seam.diff. The six p5-v1-patch*.py one-off
edit scripts from Sep 11 are gone (their edits are the commits).