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.
24 KiB
c1-v1 — the client role, the 71-slot emit table and the verb barrier
Branch p5/c1, worktree ~/w7/p5-c1, base feat/disaggregated @ 32563993 (wave 1 merged).
1. What landed
| area | file | state before | state now |
|---|---|---|---|
| the client BackendObject | MG_Remote/Client/BackendObject_Remote.{h,cpp} |
did not exist | 8 pure virtuals + 9 EGL virtuals, all three scout traps paid |
| the emit table | MG_Remote/Client/EmitTables.{h,cpp} |
RemoteEmitTable() aborted on sight; ImplementedVerbCount() = 0 |
71 slots: 2 class A, 5 class B, 64 class C, counts static_asserted to partition |
| the caps mirror | MG_Remote/Client/CapsMirror.{h,cpp} |
every accessor MGLOG_F + abort |
real, placeholder-safe, R-12 invalidation, R-8 refusal counter |
| the verb barrier | MG_Remote/Client/ClientSession.cpp |
EmitAndWait was c0's stub; the two R-1 probes returned false unconditionally |
one wait that is also the reply's wait, both probes honest, the reverse channel drained |
| the caps snapshot adoption | ClientSession::PumpControlPlane() |
s1 logged "adopting it is c1's" and dropped the frame | one drain, one adopter, called at handshake / Initialize / InitCapabilities / every Present |
| R-8's liveness gates | MG_Impl/Pipe/PipeFill.cpp |
MGPipeGetResourceOps() != nullptr |
CapsMirror::ServerConsumes under split; op table under monolith |
| the 41 null checks | MG_Remote/Client/SlotCaps.h + 5 MG_Impl files |
41 slot null checks | the three CONTRACT §7 names plus every other family where "absent" is a correct answer |
| b1's three unwired entry points | EmitTables.cpp |
zero callers | wired before the verb record |
| the suite | MG_Test/Wire/RemoteClientTest.cpp |
did not exist | 17 cases, 4 of them forked death tests |
Commit range: see §9.
2. The three traps, and where each is paid
GetRendererInfo()returns a reference (BackendObject.h:590) andLogBackendInfo()reads it atMG_Backend/Init.cpp:21, duringMG_Backend::Init(), before any surface exists.CapsMirrorowns a realRendererInfoandBackendObject_Remote::GetRendererInfo()forwards to it. c0's stubs aborted on every accessor butValid()/Generation(); that had to be reversed — an abort there is not a stricter mirror, it is a process that cannot start. Every accessor now answers a placeholder and logs one line naming itself, so a wrong number that reached a caller announced itself.MG_Backend::Init()is not restructured (scout-caps-reply §1.2 (a)).GetFormatCapabilities()is non-virtual (:594).BackendObject_Remotefillsm_formatCapabilitiesthroughMutableFormatCapabilities(), driven by a newCapsMirror::SetCapsAdoptedHook— a raw function pointer, installed in the constructor, because the only moment the object can know to refill is when a snapshot lands, and the teardown path may not allocate (ID-8).GetBackendType()answers the server's backend. NoRemoteenumerator exists and none was added; a snapshot naming a type this build has no enumerator for is refused whole rather than folded ontoUnknown, becauseGL_Framebuffer.cpp:47,GL_Texture.cpp:6536andCompileEnv.cpp:122switch on it and take a wrong arm rather than failing.
3. The emit table
kRemoteEmitSlotCount = 71, and the partition is arithmetic, not a comment:
kUnmigratedSlots (= the X-macro's own row count + 3 hand-written) == 64
kLocallyAnsweredSlots + kEmittedSlots + kUnmigratedSlots == kRemoteEmitSlotCount // static_assert
A slot that changes class without changing the arithmetic is a build break.
- Class A (2):
GetIntegeri_vanswersMaxComputeWorkGroupCount/MaxComputeWorkGroupSizefromMGPCaps::Dynamic; any other indexed pname is a warn-once and no answer, because writing a wrong number is worse than leaving the frontend's own.IsTimerQuerySupportedanswerskCapTimerQuery.PrefersCpuXfbPrimitiveAccountingis not a slot and is answered fromkCapCpuXfbPrimitiveAccounting. - Class B (5):
Clear,DrawArrays,ReadPixels,BlitFramebuffer,Present. - Class C (64): the rest, including
SetSwapInterval,GetGpuTimestampNsand the whole sync / query / XFB / compute / copy / mipmap surface.
Class C is assigned FIRST in BuildRemoteEmitTable, deliberately. If class B's assignment ran first,
a typo in the class-C list would leave a null slot — 91 potential null calls with no diagnostic. This
way the worst a mistake can do is name a verb that was meant to be emitted, loudly.
Two record-shape decisions v1 and the integrator must ratify
MGPClear::Kind.MGPipeTypes.h:1273states the list as a comment (Whole | Color | Depth | Stencil | DepthStencil) and mints no enumerator, because until now the record had no producer. c1 definesMGRemoteClearKindinEmitTables.hwith those five values in that order. P5 only ever produceskRemoteClearWhole—glClearis the only entry point that reaches the slot, the fourglClearBuffer*and fourglClearNamedFramebuffer*being class C — soWireVerbSink::OnClearshouldFatalon anything else rather than guess. When the other eight migrate, this belongs in the contract.MGPClear::FboandMGPBlit::ReadFbo/DrawFboare the NULL handle, on purpose. The bindings aregPipeInputs', written by the client'sMGP_FILL(Clear)/MGP_FILL(BlitFramebuffer)immediately before the table call and held still by the barrier. Naming a handle in the record would be a second statement of the binding, and the second one is the one that goes stale.
4. The verb barrier
ClientSession::EmitAndWait composes s1's four primitives in the one legal order:
[assert the apply thread is not inside the applier] -> EncodeRecord -> PublishAndNotify
-> BarrierWaitScope + WaitForApplied -> DrainEventRing -> ReadReply
- The wait and the reply's wait are one wait.
kMGPipeCallFlagsFor(op) & kReplySlotdecides whether a reply is read — the catalogue, never the caller — so a caller that forgot to pass a buffer cannot turn an answer into a guess. Acceptance is never re-derived and never assumed: DECLINED is passed through as a real answer, and akReplySlotrow whose slot does not stamp its own seq isFatal{ReplyMissing}rather than a plausible default. MOBILEGL_IPC_VERB_BARRIER=0turns off the barrier and nothing else. A reply-slot row still waits, because its answer is not derivable here and R-5 forbids inventing one.- The R-1 invariant is a runtime check now.
InBarrierWait()isthread_local;ApplyThreadIsInsideApplier()is a shared atomic. v1 must bracket itsDecodeAndApplywithClientSession::ScopedApplierEntry(or the twoNote*functions) or the check is inert — see §8. - The wait is bounded at 30 s and its Fatal names the seq. A wedged CI job and a lost record look identical from outside and only one of them is a bug worth finding.
SessionWait::ShutDownis not a Fatal. Teardown legitimately reaches it.- The reverse channel is drained here, between the barrier and the reply read — the one instant at
which the apply thread is known not to be inside the applier, and the thing that gives b1's
AwaitBufferWritebacksomething to have waited for.EventRingConsumer::Drained()is called only after every popped payload pointer has been consumed (R-11 one level down).
5. R-8
MGPipeResourceSubsystemEnabled(), P4aFamilyHasItsConsumer() and MGPipeResourceOpsHaveSubDataResident()
now read the caps mirror when MG_Config::Transport != Monolith, and the op table otherwise. The third is
CONTRACT §7's third named capability probe and reads kCapResidentSubData.
All four P4a families ride the one resource consumer bit, exactly as they do in monolith — asking per family would be a new rule, and a client that withheld more than the server refuses leaves the server's handle arm live with no records to read.
The negative control is counted, not inferred. CapsMirror::ServerConsumes is R-8's only legal
spelling, so it counts its own refusals and names the family (ConsumerRefusals(),
LastRefusedSubsystem(), plus one warn line per family). "The client emitted nothing" and "nothing called
it" are otherwise the same observation.
A placeholder mirror consumes nothing, which is the safe direction: the legacy pull path runs. The unsafe direction — emitting to a server with no consumer — is ID-39's 66 lost uploads.
One test had to change, and the change IS the finding
SanityTest.cpp's DirectGLESBufferDrawProbe.UnderSplitTheRecordAloneAnswersTheLiveHostMapQuestion
armed MG_Config::Transport = InProcess and MGPipeSetResourceOps(&ops) and expected the client gate
to answer from the op table. That is precisely the "right by accident under inproc" R-8 kills, and it went
red the moment the gate moved. The probe now arms both halves (it adopts a caps snapshot carrying the
resource consumer bit). It is the first concrete instance of R-8's defect found in the tree.
6. The 41 null checks — the walk, and the rule it needed
CONTRACT §7 names three cases and says "the rule generalises to all 41". Walking them turned up a third rule the contract does not state, and without it the generalisation is harmful:
A probe moves only where "absent" is a CORRECT and SUFFICIENT answer.
Where the fallback behind a probe produces a right result, "absent" is the accurate description of a client that does not have the slot, and converting keeps the lane running. Where the fallback produces a silently wrong result, converting would manufacture exactly the defect R-4 exists to prevent, and the probe is left alone so the class-C slot Fatals by name — which is R-4's stated intent.
Converted (MGL_BACKEND_SLOT_CAP where a bit exists, MGL_BACKEND_SLOT_LOCAL where none does):
| site | slot | becomes | the fallback that survives |
|---|---|---|---|
GL_Query.cpp:481, :558, :785 |
BeginOcclusionQuery |
kCapOcclusionQuery |
the target is rejected (GL's own answer) |
GL_Query.cpp:534 |
BeginXfbPrimitivesQuery |
kCapXfbPrimitivesQuery |
CPU primitive accounting |
GL_Query.cpp (begin) |
BeginTimeElapsedQuery |
kCapTimerQuery |
a zero result |
GL_Query.cpp:660 |
QueryCounterTimestamp |
kCapTimerQuery |
the same |
GL_Getter.cpp ×2 |
GetGpuTimestampNs |
kCapTimerQuery |
0, which BackendObject.h:192 already names |
GL_Sync.cpp:59 |
FenceSync |
local | always-signaled syncs — one gate carries the family, because every later sync site is already guarded on syncObject->backendHandle |
GL_Texture.cpp:6537 |
GetTextureImage |
local | the frontend's own CPU readback, which is exact |
GL_Texture.cpp:6799 |
GetTexImage |
local | the same |
PipeFill.cpp |
SubDataResident (op table, not a slot) |
kCapResidentSubData |
the non-resident upload path |
Not converted, deliberately:
- the transform-feedback span family (
GL_Drawing.cpp:1274/:1290/:1371/:1420/:1435/:1641/:1673). The frontend reads a nullEndTransformFeedbackas "this backend does not own the capture, so reorder the captured records for it" (FixupGsStripCaptureOrder). Under split the server's backend does own it, so "absent" would reorder a capture already in GL order — a silently corrupt buffer. XFB is off P5's reduced path and its slots are class C, so the first XFB call aborts by name. This family is the first that will need a newMGPCapBit, and that is anMGPipeTypes.hedit, i.e. c0's. GL_Drawing.cpp:844PatchParameteri: "absent" means the patch size is silently never set.- the 28 unguarded slots: no probe to convert, and
Fatal{UnmigratedVerb, "<slot>"}is strictly better than today's undiagnosed null call.
In a pull build both macros expand to exactly the check they replaced, so codegen is unchanged (G1).
7. b1's three entry points
PushPersistentMapsBeforeVerb()— runs in every class-B emitter, first, before the record.MarkGpuWritesForDraw()— runs inDrawArrays, after the push and before the record.MarkGpuWritesForDispatch()— wired in place, and unreachable-in-effect, and this report says so rather than claiming a gate. Its call site is theDispatchCompute/DispatchComputeIndirectslots, which are class C in P5, so the abort follows it. The phase that moves compute to class B replaces the Fatal and inherits a call site that is already correct instead of discovering that the mark walk was never wired. No test can observe it; none is claimed.MarkReadPixelsPackBuffer()is not called from the emitter: b1 already wired it atGL_Framebuffer.cpp:3109, and a second call would count one read as two.
8. What v1 and the integrator most need
ClientSession::ScopedApplierEntry(new,ClientSession.h). v1's apply loop must bracket itsPipeWireDecoder::DecodeAndApplywith it. Without itApplyThreadIsInsideApplier()is permanently false and R-1's mutual-exclusion assertion never fires — which is a gate that cannot go red for its own reason.- The hook order in
MG_Backend::Init()is load-bearing. It must be:ClientSessionInstance().Start(...)→pActiveBackendObject = MakeUnique<BackendObject_Remote>()→InitSpecificBackendLibs()(which copiesGetBackendFunctions()intogBackendFunctionsTable) →LogBackendInfo(). The client tolerates the snapshot arriving late —PumpControlPlaneruns again fromInitialize(),InitCapabilities()and everyPresent— butServerSession::SetBackend()beforeAccept()is what makes the FIRST log line accurate. WireVerbSink's five arms and what the records carry.OnCleargetsKind == kRemoteClearWholeandBufferMask; theFbois deliberately null (§3).OnDrawVbogetsIndexSize == 0,NumDraws == 1, oneMGPDrawRange{first, count, 0},Flags == 0(neverkDrawHasUserIndices).OnReadPixelsmust write exactlyMGPReadbackInfo::DstSizebytes into the reply slot with status OK — the client computed that number from the pack state and already checked it againstMaxReplyBytes(), so a short write is a silently truncated picture.OnPresentgetsFrameSerial == 0, meaning "stamp your own".- THE BIGGEST OPEN ITEM IN THE PHASE, and it is neither mine nor obviously anyone's: the 37
MGPipeApply*entry points have NO client-to-wire routing anywhere in the tree. The decode-side hook exists (gMGPipeWireRecordApply,generated/PipeWire.inc:871); there is no encode-side twin, and nothing inMG_Impl/PipeorMG_Pipebranches onMG_Config::Transportto produce one. So underinproctoday every resource / CSO / texture / sampler / program record still executes synchronously on the GL thread, against a context that v1 is moving to the apply thread — where all 16IsBackendContextCurrentOnThisThread()and 16CanTouchGLNow()guards answer false.ClearThenReadPixelsmay survive that;TriangleScenarioneeds a VBO and a program and will not. This decides whether the first inproc frame renders, and it needs an integrator ruling on owner and shape before v1 and c1 can be joined.ClientSession::EmitAndWaitis already the whole client half of it — it takes an opcode and a payload — so the missing piece is one hook inMG_Pipeplus the 37 call sites, not a new mechanism. - Two unit cases were already red at the merge base, before c1 touched anything, and c1 changes
neither file nor any generated table they read:
PipeWireCodecTest.NoReplyIsWrittenForARowTheCatalogueGivesNoReplySlot— line 1203 assertsMGPipeCallFlagsFor(ResourceCreate) & kReplySlot == 0; ID-31 gave that row the flag, so it reads 16. Pure ID-31 fallout: the test states the pre-ID-31 catalogue.RingTest.TheTwoFlagSpacesAreDisjointByTranslation— line 774, the runtime half.
- One knob was invented and is flagged rather than smuggled:
MOBILEGL_IPC_E2_DROP_CLEAR=1arms E2's control (below). It is read withgetenvinEmitTables.cpp, not throughMG_Config, becauseConfig.his c0's; it warns loudly every time it arms. Adopt it intoIpcTableor tell me to take it out. MGPCaps::FormatCapabilities/RendererInfoblobrefs are zeroed on adoption. They name SEG_STAGE runs owned by the server's encoder; a later client-side reader that resolved one would read whatever the stage allocator has since put there.
9. Numbers
Commit: 32563993..805f3322 on p5/c1 — one commit, 18 files, +2235 / -71.
Gate log ~/w7/p5-c1-gaterun.log, G1 re-measure ~/w7/p5-c1-g1run.log, symbols
~/w7/p5-c1-symbols.md, red-check ~/w7/p5-c1-redcheck.log.
The four self-tests, on FIVE build dirs (b1's build-verify-split cell included):
| pull | push | verify | split | verify-split | |
|---|---|---|---|---|---|
| configure + build | rc=0 | rc=0 | rc=0 | rc=0 | rc=0 |
ctest -L unit |
1813 / 1813 | 1813 / 1813 | 1813 / 1813 | 1989 / 1991 | 1989 / 1991 |
G1 — the gate this phase is most likely to break:
.text 10806323 -> 10806323 (+0, +0.000%)
27811 -> 27811 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed
nm --defined-only build-linux/libMobileGL.so | grep -ic MG_Remote -> 0
nm --defined-only build-split/libMobileGL.so | grep -ic MG_Remote -> 473
IT WAS RED ON THE FIRST MEASUREMENT AND THE WAY IT WENT RED IS WORTH THE PARAGRAPH.
.text -144, 2 resized: GLImpl::GetInteger64v -150 and GLImpl::GetIntegerv +2. Two sites in
GL_Getter.cpp were shaped if (const auto f = TABLE.GL.Slot), and rewriting them as
if (BOOL_MACRO) { const auto f = TABLE.GL.Slot; … } is semantically identical and generates
different code. The fix is MGL_BACKEND_SLOT_PTR_CAP / _PTR_LOCAL, which expand in a pull build to
the slot expression itself, so the init-statement survives verbatim. GL_Sync.cpp's FenceSync
had the same shape and did not happen to move; it was converted to the pointer form anyway, because
"did not happen to" is not a property.
Integration: build-push, MOBILEGL_TRANSPORT=monolith, ctest -L integration-gpu:
1128 / 1128, 0 failed.
Names (G2 / G14): baseline 2902, push 2941, split 3140.
push-vs-baseline 0 removed, 39 added (all wave-1's; c1 adds none to the push lane).
split-vs-push 0 removed, 199 added — adds only, of which 21 are DirectGLES.Split. entries
and 17 are this package's own unit cases.
Generators (c1 touched no .def and no generator): gen_pipe --check, gen_pipe_dirty_surface --check, gen_pipe_field_ownership --check all report up to date. check_include_closure: 4 probes,
0 problems.
The 2 split failures are PRE-EXISTING at the merge base and c1 changes neither test file nor any generated table they read — see §8.5.
The acceptance scenarios do NOT run yet, and the reason is measured rather than assumed.
ctest -L integration-split in build-split is 21 / 21 still skipping, and the skip names the
first fact that is not true:
MG_Remote::Client::ClientSession::Active() is null: no client session exists in this process.
Nothing in the test process calls ClientSession::Start() — MG_Backend::Init()'s hook is v1's
(§8.2), and the MGPipeApply* routing of §8.4 is unowned. So the first inproc frame is blocked on
those two, not on this package: ImplementedVerbCount() is now 5, not 0, which is the third of
t1's three arming facts, and the fourth (the encoder's record ordinal moving) is the one the emitters
above make true. The 21 entries and the two negative controls arm the moment a session exists.
10. R-16: I made every gate red once, by doing X
~/w7/p5-c1-redcheck.py (copied from ~/w7/p5-w1-redcheck.py; only ROOT, the target and the binary
path changed). It breaks the implementation, never the test, rebuilds RemoteClientTest, runs the one
control that should notice, requires [ FAILED ], restores, and finally requires the whole suite green
again. Log: ~/w7/p5-c1-redcheck.log.
| control | I made it red by |
|---|---|
AnUnmigratedSlotAbortsAndNamesItself |
renaming the Fatal tag UnmigratedVerb → SomethingElse |
EachUnmigratedSlotNamesItsOwnSlot |
making the X-macro pass the literal "DrawElements" instead of #Name |
TheThreeClassesPartitionAllSeventyOneSlots |
returning c0's stub value 0 from ImplementedVerbCount() |
NoSlotIsNull |
commenting out table.SetSwapInterval = &SetSwapInterval_Unmigrated; |
TheFiveEmittersAreTheOnesTheCensusMeasured |
setting table.Present = nullptr |
AClassBSlotWithNoSessionAbortsRatherThanFallingThrough |
renaming the NoClientSession Fatal tag |
SetSwapIntervalIsClassCAndSaysSo |
overwriting the slot with an empty lambda (a pass-through) |
AMaskWithoutAFamilyRefusesItAndNamesIt (×2) |
ServerConsumes returning true; and dropping the family id from the refusal |
GlGetStringReadsTheRendererStringsBackOutOfTheMirror |
deleting m_renderer = renderer — the producer |
GlGetIntegervReadsTheDynamicParametersBackOutOfTheMirror |
adopting only CallMask instead of the whole MGPCaps |
ReArrivalIsTheInvalidationAndMovesTheGeneration |
m_generation = 1 instead of ++m_generation |
ThePrefersCpuXfbAnswerComesFromTheCapBitAndNotFromTheTable |
returning false |
CONTROLS_THAT_DID_NOT_GO_RED=none; 13 / 13, restored build green, 17 / 17 after.
And the first run of the red-check found a real defect in my own controls, which is the point of it.
The forked death cases used w1's "remember the log length, fork, take the tail" helper. This suite's
parent never logs, so MG_Util::Debug's FILE* was opened for the first time by each child, with
"w" — truncating. The remembered offset then pointed past the end of the child's own log and substr
handed back a different child's output: EachUnmigratedSlotNamesItsOwnSlot was reading the previous
case's message and asserting on it. Three cases were green through a broken read. Fixed by truncating in
the parent before the fork and taking the whole file. A control that reads another control's message is
one of the three shapes R-16 was written after, and this is a fourth sighting of it.
11. Debts this package leaves
- E2's emitter-drop control is armed but not RUN by me.
MOBILEGL_IPC_E2_DROP_CLEAR=1makes everyglClearskip its record while still running the pre-verb hooks, and counts the drops (DroppedClearEmissions()). The statement E2 makes — "OpenRA's SSIM falls below 0.99" — is a trace lane's, and the lane cannot run until the first inproc frame does (§8.4). The unit half asserts only that the control is off unless armed. MarkGpuWritesForDispatchhas no gate and cannot have one whileDispatchComputeis class C (§7).- The XFB span family needs an
MGPCapBitbefore its probes can move (§6). Encoder().MaxRecordBytesSeen()still has noPipeStatspublisher (w1 flagged it as b1's line; it is still nobody's landed code), so R-10's MEASUREMENTS number remains unowned.GetIntegeri_vfor a pname outside the two device-owned ones warns and writes nothing. Monolith leaves the driver's own value in place; there is no such value here. If any target is found reaching it, that pname needs a home inMGPCaps.build-verify-split/needed a.git/info/excludeline (~/w7/pipe/.git/info/exclude:12), because the four older build dirs are excluded there by name and b1's fifth cell was not. The first commit of this branch swallowed 1625 build artefacts before that was noticed; it was reset and redone. Anyone adding a sixth build dir has to add the line too.
12. Files and scripts
~/w7/p5-c1-gate.sh— five build dirs, the generators, G1, the unit lanes, integration-gpu + names. Copied from~/w7/p5-w1-gate.shwith b1'sbuild-verify-splitcell added and C-10'sCTestTestfile.cmakecheck in front of every verdict.~/w7/p5-c1-redcheck.py— R-16, 13 controls. Copied from~/w7/p5-w1-redcheck.py.~/w7/p5-c1-names.sh— the G2/G14 name comparison. UseLC_ALL=Cfor both thesortand thecomm: without itcommreports "input is not in sorted order" and prints a nonsense diff that looks exactly like a catastrophic name change (267 removed / 306 added, where the truth is 0 / 39).~/w7/p5-c1-submodlinks.sh off|on,~/w7/p5-c1-setup.sh— the day-one symlink dance.