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.
26 KiB
P3a package D — the gates, rework round 1 (gates-v2)
Branch p3a/gates, worktree /home/swung/w7/p3a-gates, rebased onto refs/heads/feat/disaggregated
(5cb826b0) per ID-9. HEAD 2bafb316. Not pushed.
Answering gates-review-v1.md's REWORK (four majors) plus the integrator's ID-9 / ID-10 / ID-11.
Everything in the review's §5 rework list is addressed; the optional minors (m5, m6) are done too.
| # | sha | message |
|---|---|---|
| — | 5cb826b0 |
(base: contract e01c0ccc + the dev@9eae9858 merge) |
| 1 | 9e08c563 |
[Test] (Pipe): reproduce the buffer handle ABA through public GL and prove the pre-rekey guards are what stops it |
| 2 | ecbddcea |
[Test] (Pipe): assert a regrown adopted store costs one map-persistent round trip per storage definition, not one per draw |
| 3 | 20dfb64c |
[CI] (Pipe): gate that the buffer pool, the deferred-release drain and the three rings did not move |
| 4 | 331bb425 |
[Test] (Pipe): count the map-persistent round trips over a re-specified adopted arena in both arms, now that the VAO rebind fix is in the branch |
| 5 | 2dfac81a |
[Fix] (Pipe): raise the four CSO stats lanes to the P3a subsystem mask so they stop asserting on a configuration nothing ships |
| 6 | 854b1be3 |
[CI] (Pipe): select the P3a subsystem and map-persistent lanes in the only job that unpacks a push build |
| 7 | a9d4011a |
[Fix] (Pipe): restore and rebuild on every exit path of the vertex-input negative control, and keep its logs out of the repository |
| 8 | 2bafb316 |
[CI] (Pipe): add FlushPendingRangesNow's three-tier drain to G5's byte-identical set |
Commits 1–3 are the original three, rebased (the duplicate contract patch dropped out automatically).
Commits 4–8 are the rework. Diffstat 20dfb64c..HEAD: 6 files, +294 / −156.
1. The rebase (ID-9)
git rebase refs/heads/feat/disaggregated — rc 0, no conflict. Git merged
LargeArenaAdoptionScenario.cpp cleanly: dev's two cases were appended in one hunk and gates' case in
another, far enough apart that the union is what git produced. It was verified by name rather than
assumed, because ID-9 names this file as where a name can be lost:
| side | TEST_F(LargeArenaAdoptionScenario, …) |
|---|---|
gates pre-rebase 80f6bf1b |
SubDataAfterAnInFlightDrawReachesTheNextDraw, ReadbackSeesTheLatestCpuWrite, GpuWriteIntoTheArenaIsReadBack, AnAdoptionCostsExactlyOneMapPersistentRoundtrip (4) |
dev side 5cb826b0 |
SubDataAfterAnInFlightDrawReachesTheNextDraw, RespecifiedVertexArenaKeepsVaoBindings, RespecifiedIndexArenaKeepsVaoBinding, ReadbackSeesTheLatestCpuWrite, GpuWriteIntoTheArenaIsReadBack (5) |
| HEAD | all 6 — the union, nothing renamed, nothing dropped |
The 11 PersistentBufferOrderingProbeTest.* names from 9eae9858 are in a file this package does not
touch and arrived untouched. G14 below confirms both sets at the ctest level.
feat/disaggregated has moved on since this rebase. It was 5cb826b0 when this package rebased and
when every number below was taken; by the end of this round ~/w7/pipe reads 12e6bfcf (package A's
wire landed; p3a/client has also moved to b6706362). Under ID-2 gates integrates last, so one
more rebase is expected and is the integrator's; nothing in this package touches MG_Pipe/**,
MG_Impl/** or MG_Backend/**, so the only file with any chance of conflicting again is
MG_IntegrationTest/CMakeLists.txt. G1 and G14 must be re-measured against whatever pull baseline the
integrator holds at that point — the ~/w7/p3a-before-* captures used here are 5cb826b0's.
2. Per-finding disposition
M1 — the four CSO stats lanes still pinned 0x7f — FIXED (2dfac81a)
MG_IntegrationTest/CMakeLists.txt, at the review's line numbers, now at HEAD's:
| lane | was | now | line at HEAD |
|---|---|---|---|
MGL_ITEST_GLES_CSO_ON_ENVIRONMENT (:1044) |
0x7f |
0x1ff |
:1046 |
MGL_ITEST_GLES_CSO_OFF_ENVIRONMENT |
0x800000000000007f |
0x80000000000001ff |
:1051 |
MGL_ITEST_VULKAN_CSO_ON_ENVIRONMENT |
0x7f |
0x1ff |
:1056 |
MGL_ITEST_VULKAN_CSO_OFF_ENVIRONMENT |
0x800000000000007f |
0x80000000000001ff |
:1061 |
The control semantics are unchanged: the only bit that separates the two arms is 63
(kMGPipeBehaviourNoCsoContentAddressing, MG_Pipe/MGPipe.h:90); every other bit is the shipping mask
and now moves with the phase (kMGPipeSubsystemsMigratedAtP3a = 0x1ff, MGPipe.h:95). A comment block at
:1031-1043 states that rule at the site, so the next phase's author does not have to rediscover it, and
closes contract-review item 11 explicitly for all three lane families.
Re-run (M1's own requirement). ctest --test-dir build-push -R CsoContentAddressing → rc 0, 6
entries (the 4 lanes pass; the 2 ambient entries skip by design). The arms are still distinguishable at
the new mask — the lane logs read csom=3 csob=17 (content-addressed) against csom=17 csob=17
(no content addressing), i.e. 3 mints for 17 binds versus one mint per bind. The generated ctest
environment was checked directly: the CSO On lanes now carry MOBILEGL_PIPE_PUSH=0x1ff and no
0x800000000000007f string survives anywhere in the build tree.
Every remaining pin in the file re-read (grep -n 'MOBILEGL_PIPE_PUSH=0' MG_IntegrationTest/CMakeLists.txt),
which is the second half of the instruction. Thirteen value-carrying pins remain:
| line | value | verdict |
|---|---|---|
:930 MGL_ITEST_HANDLES_ARM_KNOBS |
0x1ff |
phase default |
:944, :947 HandleRecycle.Legacy (both backends) |
0 |
named control — the pre-handle arm, documented at :895-900 |
:950 HandleRecycle.AbaControl |
0 |
named control — D18's lane verbatim |
:1046, :1056 CSO On |
0x1ff |
fixed here |
:1051, :1061 CSO Off |
0x80000000000001ff |
fixed here; bit 63 is the control |
:1130 ResourceSubsystemControl.On |
0x1ff |
phase default |
:1135 ResourceSubsystemControl.Off |
0x7f |
named control — G12's armed/cleared A/B |
:1164, :1169 MapPersistentRoundtrips. ×2 |
0x1ff |
phase default |
:1200 ResourceSubsystemOn. |
0x1ff |
phase default |
:1203 ResourceSubsystemOff. |
0x7f |
named control |
HandleRecycle.AbaControlHandles (:953-956) pins nothing of its own — it composes
MGL_ITEST_HANDLES_ARM_KNOBS, so it followed 0x1ff automatically. No lane runs with P3a's subsystems
off unless it is a named control.
M2 — the eight ResourceSubsystemOn./Off. entries never ran in a push build in CI — FIXED (854b1be3)
.github/workflows/test.yml:615, the integration-verify job's controls step:
-R 'HandleRecycle|CsoContentAddressing|ResourceSubsystem|MapPersistentRoundtrip'
ResourceSubsystemControl → ResourceSubsystem and the plural MapPersistentRoundtrips → singular, for
exactly the reasons the review gives. A 14-line comment above the step records that these alternatives are
test-name PREFIXES, that each is the shortest string that still selects only what it means to, and that
this is the only CI job unpacking a push build — so an entry the filter misses either never runs under the
P3a bits or runs only in the pull integration job where the mask steers nothing.
Measured, in the job's own build directory (build-verify, -L integration-gpu -R …):
| filter | entries selected |
|---|---|
| old (as reviewed) | 80 |
| new | 96 |
of which P3a lane entries (ResourceSubsystem{On,Off,Control}. / MapPersistentRoundtrips.) |
16 |
The step run for real: rc 0, 96/96 pass. Of the 12 ResourceSubsystemOn./Off. entries, 10 assert and
2 skip — the two skips are AnAdoptionCostsExactlyOneMapPersistentRoundtrip in each lane, which needs
package B's counter and says so; the other five cases per lane (including dev's two
Respecified*Arena*) run on both arms today. That is review item 9 ("confirm the lanes actually assert")
discharged, at least for the pre-B tree.
Every other new lane checked the same way. All 38 names D adds are present in ctest -N on
build-linux, build-push and build-verify; the 22 that carry ResourceSubsystem or
MapPersistentRoundtrip in their names (16 lane entries + 6 ambient) are all inside the new filter. The
HandleRecycle families were already reachable and remain so.
M3 — the G7 script's exit contract — FIXED (a9d4011a)
scripts/p3a_vertex_input_negative_control.sh restructured:
- A single
repair()(:103-123): restore the header from the pre-patch byte copy,cmake --build, then re-run the suite to prove the tree went back. Idempotent, a no-op until the patch is applied. PATCH_APPLIED=1is set before the patcher runs (:178), not after, so a python that died mid-write is repaired too.trap 'repair' EXIT(:174) replacestrap 'restore' EXIT, so mid-way failures repair: the "patched header did not compile" branch (:203) and any interrupt now go through it.- Step 4 (from
:212) only records a verdict (tripped/did-not-trip/wrong-reason); step 5 (from:227) callsrepairand clears the trap before anything is printed or exited, and a failed repair downgrades the verdict to 2 ("a build directory that could not be put back is 'could not run'"). All three outcomes share one block. - No file is written into the repository.
LOG_DIRis<build-dir>/p3a-g7-logs(absolute, created withmkdir -p, falling back tomktemp -dif the build dir is unwritable); the header backup lives there too, and both formercp … ./p3a-vertex-input-control-*.loglines are gone. Every verdict prints the log path. - The header's exit-code block (
:39-63) now states the rebuild as part of the contract and explains why the "did not trip" path is the one that needs it most.
Proved by forcing each path once. A rehearsal ran a byte-identical copy of the shipped script
(cmp clean) inside a throwaway repo at /tmp/g7rehearsal, whose
MobileGL/MG_Impl/Pipe/VertexInputEmit.h and VertexInputEmit.Roundtrip ctest entry are tiny stand-ins —
so the control flow exercised is the real one, and only the two constants' contents differ:
| forced condition | rc | header after | binary after | repo root |
|---|---|---|---|---|
the walk names IsBgra when it is zeroed |
0 | original | built from the restored header | clean |
| the walk stopped comparing (stays green) | 1 | original | built from the restored header | clean |
| the walk fails without naming the field | 1 | original | built from the restored header | clean |
the patched header does not compile (Bgra enum class) |
2 | original | built from the restored header | clean |
In every case the transcript shows restored …; rebuilding … / the tree is restored, rebuilt and green again before the verdict line (or, for the exit-2 case, from the trap), and ls of the fake repo root
shows nothing new. The rehearsal tree was deleted.
On the real tree the script still answers rc 2 — MG_Impl/Pipe/VertexInputEmit.h is package B's and
does not exist yet — and leaves git status clean.
M4 / ID-11 — FlushPendingRangesNow in G5 — DONE (2bafb316)
scripts/p3a_untouched_regions.sh: FUNCTIONS is now ten names, appended last so the first nine lines
of the D.0 baseline keep their positions. EXPECTED_FUNCTION_COUNT=10 replaces the hard-coded 9. The
header table gains the row and a paragraph recording why the tenth is there (ID-11 resolving
BRIEF-P3A.md:420 / :1708 against D-F's nine-function table) and what byte-identical means for it:
the handle arm must CALL it, not carry a copy — a push arm that re-spells the ladder beside an untouched
#else copy satisfies G1 and defeats G5, because two ladders drift.
The self-test grew a control for it. SELF_TEST_FUNCTIONS="ClearBufferPool FlushPendingRangesNow", one
negative control each, each run from the pristine copy and each required to be named in the message.
ClearBufferPool is the easy shape (small, no forward declaration); FlushPendingRangesNow is the
opposite on purpose — 70 lines, three nested tiers, its own early returns — so an entry that silently
extracted the wrong extent cannot pass. Both trip:
[p3a-untouched] positive control: 10 bodies extracted from the working tree
[p3a-untouched] positive control: an untouched copy compares equal
[p3a-untouched] positive control: an edit outside the ten bodies is invisible
[p3a-untouched] negative control: a perturbed ClearBufferPool body is reported, and named
[p3a-untouched] negative control: a perturbed FlushPendingRangesNow body is reported, and named
[p3a-untouched] self-test passed
The new D.0 baseline (p3a_untouched_regions.sh HEAD, rc 0):
ba79b92dc6ebf2cb2af6aa79f23ba1941818d131812965e9f96a89caffc8e90a IsPoolable
6563286e007650a5abb0a1bbdd7acddd901776f3e55d3c0087c8fee60aa6cc4c EnrollIntoPool
dc9d3066b2429208e18adc27c639d16260e74b7f17f7c3f290d54f58534f089b AcquireFromPool
12656cfd716dec50a4a4893459a7a6aaa0a635f79dda8fa51b88a819da27e5e0 TrimBufferPool
c44a12746bcd82e55d8a635adf766e1fe2cf961ded5d9d745896fd65535bde16 ClearBufferPool
15259e547fb514dcdcf087bbde1d048fc2d9e7901ea6c6c94a1109fb7987073a ProcessDeferredBufferReleases
2daaa5254c38db63742ef8d6dacd25f8868c7fcd3d9745956862134cf76911d5 CreateRingStorage
6221df2e4c0b185fbac061e956253dacd8f8d886bb3f3341cd76a26b5e1f84b1 RingAvailable
709b6f4190c735517034b9c5d62967a9ae61f2198d2eb441dfe4e7af437cb784 RingAllocate
c65570022a5856c1afccfd0cb42fefac707689f5bb3154c3a8e17d2495ccdf8e FlushPendingRangesNow
The integrator should replace ~/w7/p3a-before-untouched.sha with this list (it is 44c2b5cf's too — the
gate is rc 0 between them).
D6 — the second-arena workaround undone (331bb425)
ID-9 makes d7655247 an ancestor of this branch, so both counting workloads now re-specify an adopted
store under a live VAO instead of routing around it:
LargeArenaAdoptionScenario.cpp:457-474—glBindBuffer(m_arena); glBufferData(kArenaBytes, nullptr, …)inside the counted window, and the attribute pointers are deliberately not re-declared afterwards, so the draws below can only land if the backend VAO followed the new store on its own.m_secondArenaand its TearDown lines are gone.ResourceSubsystemControlScenario.cpp—DefineAnArenaAndDrawFromIt→DefineTheArenaAndDrawFromIt(:225): index 0 creates the store and declares the attributes, every later index re-specifies the same buffer and declares nothing.std::vector<GLuint> m_arenas→ a singleGLuint m_arena(:250). Two storage definitions either way, so the counter's expectations (mpr == 2on,0off) are unchanged.
Both comments now say why the shape is the hard one and cite ID-9 rather than the old detour. Because the
first of these runs under ResourceSubsystemOn./Off., the respecify path is now exercised on both arms
of the P3a A/B, which is what ID-9 asks for; a handle arm that re-implemented the retire without the
rebind is a dead draw or a fault there rather than a divergence found on device.
The minors
| # | disposition |
|---|---|
m1 (the -V artefact) |
Done. Both logs regenerated post-rebase and kept: ~/w7/p3a-handlerecycle-before.log (the D.2 command) and ~/w7/p3a-handlerecycle-before-verbose.log (ctest -V, 158 KB, 22 [ HandleRecycle ] verdict lines), both copied to ~/w7/notes/p3a/p3a-results/. The AbaControl green is now readable as a verdict line, not inferred from an exit code. |
| m2 (D6 wording) | Moot — the workaround is gone. For the record the review was right: StorageBufferRegrowScenario never used a second arena (it re-specifies an SSBO with no VAO attributes). |
| m3 (the stale workaround) | Fixed — see D6 above. |
| m4 (G14 numbers) | Re-measured against 5cb826b0's baseline; see §3. D's contribution is +38 (34 + the 4 new ResourceSubsystem{On,Off}.…Respecified*Arena* lane entries the union produced). |
| m5 (digit separator) | Done. mask() skips a ' preceded by a digit or a hex digit that itself follows a hex digit — a C++14 separator (16'777'216, 0xff'ff) no longer opens a char literal that could blank a brace a function away. |
m6 (perturb() brace) |
Done. The opening brace is located in the masked text and used as an offset into the original (mask() preserves length), so a brace in a comment or a default argument on the signature line cannot misdirect the perturbation. |
| m7 (return type on its own line) | Not changed. Still true that none of the ten is written that way, FlushPendingRangesNow included (void FlushPendingRangesNow( is one line). |
m8 (build-bench) |
Still not run — there is no build-bench in this worktree and no benchmark source changed. Integrator item, unchanged. |
m9 (588d25e9's message) |
Unchanged: the messages are C.3's verbatim and the rebase preserved them (ecbddcea). The D5 RESOURCE_LOCK fix is still carried by that commit; this report is the place it is written down. |
| m10 (no DirectGLES ABA positive control) | Unchanged; carried to package C's scope as the review suggests. |
3. The G5 verdict against espryt's tree
git -C /home/swung/w7/p3a-espryt rev-parse HEAD has moved: it is now cdbd5535
([Test] (Espryt): extend the slot-table suite to the buffer kind and pin that its death crosses as resource_destroy), not the 203120fa the brief names. The gate was run against both, and answers
identically.
$ bash scripts/p3a_untouched_regions.sh 44c2b5cf 203120fa -> rc 2
$ bash scripts/p3a_untouched_regions.sh 44c2b5cf cdbd5535 -> rc 2
[p3a-untouched] FlushPendingRangesNow: expected exactly one definition, found 2
[p3a-untouched] ...definition at line 1127, 3 lines
[p3a-untouched] ...definition at line 1307, 70 lines
[p3a-untouched] the handle arm must CALL the untouched FlushPendingRangesNow, not carry a copy of
[p3a-untouched] it: two ladders drift (BRIEF-P3A.md:1708, ID-11)
The gate was not weakened. Instead the len(hits) > 1 diagnostic was made to print the two extents and
the rule, because this is now the expected shape of the failure rather than a limitation of the
extractor.
The exact hunk, for espryt's rework (MG_Backend/DirectGLES/Managers.cpp at both refs; the whole region
is #if MOBILEGL_PIPE_PUSH at :902 … #else at :1188 … #endif at :1424):
| what | where | lines | sha256 (16) |
|---|---|---|---|
push arm — FlushPendingRangesFrom(GLESBufferResource&, const Uint8* hostBase, SizeT frontendSize), a re-spelled copy of the whole three-tier ladder |
:1051-1125 |
75 | 37fc94ffc5991923 |
push arm — FlushPendingRangesNow(GLESBufferResource&, BufferObject&), a thin forwarder to it |
:1127-1129 |
3 | 7ac74243aec7b6f8 |
#else (pull) arm — FlushPendingRangesNow(GLESBufferResource&, BufferObject&) |
:1307-1376 |
70 | c65570022a5856c1 = byte-identical to $BASE:1004 |
New callers of the re-spelled core are at :2000 and :2541 (the handle arm); :1708 and :2677 still
call FlushPendingRangesNow.
Read this precisely, because it is not "a body moved":
- All nine original G5 functions are byte-identical at espryt's HEAD — verified by extracting them
from espryt's file directly; every sha matches
44c2b5cf. The review's earlier rc 0 still holds for the nine. - The pull arm's
FlushPendingRangesNowis byte-identical too. Nothing was edited in place. - What the gate objects to is that inside a push build the ladder exists twice — once as
FlushPendingRangesFrom(75 lines, re-parameterised) and once as the#elsecopy that G1 freezes — and the gate cannot say which is "the" body, so it refuses (rc 2) rather than picking one.
This is a real conflict between G1 and G5-with-the-tenth, and it is the integrator's to settle. Espryt's
deviation D1 exists because refactoring these helpers in place resized five pull symbols
(FlushPendingRangesNow +14 among them), which G1's empty admitted-resize set forbids; the #if/#else
split is what bought G1 back. The two obvious resolutions both cost something:
- Espryt restores it byte-identical and the handle arm calls it. This is what ID-11 asks for and it is
what makes the risk row at
BRIEF-P3A.md:1708true. It needs the handle arm to reach the same body without aBufferObject&, which is the constraint D1 was written around — so it is not a one-line change, and whether it is achievable without resizing a pull symbol is espryt's call, not this package's. - The tenth entry stays and the phase records a written, argued exception for it — naming the two
copies, stating that the
#elsecopy is frozen by G1 and the push copy is covered byCrossFrameBufferScenario's thirteen cases plusStreamedArenaScenario's two, and that the exception retires with the pull path at P13. That is a decision, not a silence, and it is what D.5 would record.
What this package will not do is drop the tenth entry or teach the extractor to prefer one of two
definitions: either would turn ROADMAP.md:19's headline p99 number back into a risk with a mitigation
that does not exist. The finding is recorded here so espryt's rework and the integrator can choose.
4. Verification transcript
All in /home/swung/w7/p3a-gates, CCACHE_BASEDIR=/home/swung/w7, at 2bafb316.
| check | result |
|---|---|
cmake --build {build-push,build-linux,build-verify} -j 28 |
rc 0, rc 0, rc 0 |
G1 symbol_report.py --before ~/w7/p3a-before-libMobileGL.so --after build-linux/libMobileGL.so --threshold 0 --fail-on-symbol-set-change --fail-on-added-bytes 0 |
rc 0 — Removed 0, Added 0, Resized 0, Renamed 0. 0/0/0/0 against ID-9's re-captured 5cb826b0 baseline |
G2 ctest -N (ID-4 extractor), pull vs push |
identical, 2540 each (build-verify 3382) |
G14 comm -23 ~/w7/p3a-before-ctest-names.txt <build-linux names> |
empty — 0 removed. comm -13 = +38 added, all new names; the union kept dev's LargeArenaAdoptionScenario.Respecified{Vertex,Index}Arena* on both backends and in both new subsystem lanes |
ctest -L unit -j 12 on all three builds |
rc 0 — 1582/1582 each |
ctest -L integration-gpu -j 8 on build-push |
rc 0 — 958/958 |
ctest -L integration-gpu -j 8 on build-linux |
rc 0 — 958/958 |
ctest -L integration-verify -j 4 on build-verify |
rc 0 — 842/842 |
hard rule 4 ctest --test-dir build-verify -R HandleRecycle --no-tests=error |
rc 0; only visible skips (the .Handles buffer arm and the Verify. prefixed copies, each naming what is missing) |
hard rule 4 ctest --test-dir build-push -R 'StorageBufferRegrow|LargeArenaAdoption|ResourceSubsystem' |
rc 0; the only skips are the four counting entries + the two lane copies, all saying no source under MobileGL/MG_Impl/Pipe/ names MapPersistentRoundtrips |
M1 re-run ctest --test-dir build-push -R CsoContentAddressing |
rc 0 — 6 entries, 4 lanes assert, arms distinguishable (csom=3 vs csom=17 at 17 binds) |
| M2 re-run the CI step as CI runs it, on build-verify | rc 0 — 96/96; 80 → 96 entries, the 16 P3a lane entries now included; 10 of the 12 On/Off entries assert, 2 skip naming package B |
G5 p3a_untouched_regions.sh 44c2b5cf HEAD |
rc 0 — ten bodies byte-identical |
G5 p3a_untouched_regions.sh --self-test |
rc 0 — 3 positive controls + 2 negative controls (both named) |
G5 vs p3a/espryt (203120fa and cdbd5535) |
rc 2, naming the two definitions — §3 |
G7 p3a_vertex_input_negative_control.sh build-push on this tree |
rc 2 — package B's header absent, message says so |
| G7 all four exit paths, forced on a byte-identical copy | 0 / 1 / 1 / 2, tree restored and rebuilt on every one, nothing written to the repo root |
git status |
clean |
Two D.2 artefacts kept (~/w7/ and copied to ~/w7/notes/p3a/p3a-results/):
handlerecycle-before.log and handlerecycle-before-verbose.log. Every other log this round created —
~/w7/p3a-gates-build.log, the /tmp build and label logs, the /tmp/g7rehearsal tree — was deleted.
ls ~/w7/p3a-gates-* is empty.
5. What remains for the integrator
gates-v1.md §8's list stands, with items 8 (carry D6) and the G14 re-measurement discharged. What is
left, in the order it bites:
- Settle the
FlushPendingRangesNowduplication with package C (§3). This is the one item that is not mechanical: either espryt's handle arm calls the untouched body, or the phase writes down an argued exception in D.5. Until then G5 is rc 2 on any tree carrying espryt, and rc 2 must not be read as "the script is broken" — the message names the two definitions and their line extents. - Re-run
p3a_untouched_regions.sh 44c2b5cf HEADafter every merge, plus--self-test. Re-capture~/w7/p3a-before-untouched.shawith the ten-line listing above (§2, M4). p3a_vertex_input_negative_control.sh build-pushon the tree carrying package B — it must reportnegative control tripped, naming IsBgra(rc 0). Anything else is a finding about G6, and rc 2 now means something different from what it means here. Its logs land in<build-dir>/p3a-g7-logs/.- The
.Handlesbuffer arm must stop skipping once package C registersMGPipeResourceOps; the four counting entries must stop skipping once package B emitsMapPersistentRoundtrips, and then readmpr == 3,1,2(On) and0(Off). A green Off arm beside a skipping On arm is not the A/B (review item 11). MOBILEGL_PIPE_PUSH=0x7f ctest -L integration-gpu -j 8beside the default0x1ff— the label-wide third arm. The twoResourceSubsystemOn/Off.lanes now cover the adopted store's whole life including the respecify path in both arms, but the label-wide A/B is still the integrator's.cmake --build build-bench && ctest --test-dir build-bench -L benchmarkonce (C.3's block, m8).gh workflow run test.yml --ref feat/disaggregated—pipe-gatesruns the two G5 rows (branch scoped,BASELINE: "44c2b5cf",fetch-depth: 0); theintegration-verifycontrols step now selects 96 entries instead of 80.- The DirectGLES buffer ABA has no positive control (review m10) — carry into package C's scope rather
than losing it:
HandleRecycleScenario.cpp:319-321names where aFeatures.PipeHandleAbaControlconsumer over the resource slot table would go.