Files
MobileGL/docs/Disaggregated/notes/p2/p2-results/espryt-review-v2.md
T
swung0x48 aba329cc53 [Docs] (Disaggregated): P6's plan and contract draft; the working notes move from a local directory into the repository
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.
2026-09-18 23:31:39 -04:00

20 KiB
Raw Blame History

Adversarial review — p2/espryt (package C, Espryt 0b) — round 2

Reviewer ran everything below itself in ~/w7/p2-espryt at 5f245ac7 (tag p2/contract = 9c6a8a25). Nothing in the tree was modified: the four build directories were only re-built incrementally (ninja: no work to do on all four, so the artefacts under test are the ones the implementer measured), and every probe is a read, a ctest, or a gdb -batch counting run.

Verdict: NOT APPROVED — 2 majors.


0. What reproduces, exactly as claimed

I re-ran the package's own evidence before hunting. These all hold:

claim my command my result
G1 python3 scripts/symbol_report.py --before ~/w7/p2-before-libMobileGL.so --after build-linux/libMobileGL.so --threshold 0 27799 -> 27799 defined symbols: 0 added, 0 removed, 4 resized, 0 renamed; resized = RenderState::RenderState() +148, RenderState::SetCapability +77, RenderState::IsCapabilityEnabled +29, _GLOBAL__sub_I_DirectGLES.cpp −9
G1 attribution same, --before ~/w7/p2-contract/build-linux/libMobileGL.so .text +0, 0 added / 0 removed / 0 resized / 0 renamed — package C's pull-build delta is exactly zero
G5 git show {48268068, p2/contract, HEAD}:…/DirectGLES.cpp | awk '/namespace RenderStateImpl {/,/} \/\/ namespace RenderStateImpl/' | sha256sum all three d8fd1c48…0efe27, equal to ~/w7/p2-before-syncrenderstate.sha
G2 ctest -N | sed -n 's/^ *Test *#[0-9]*: //p' | sort × 4 dirs build-linux 2374, build-push 2374, build-nolegacy 2374, diffs empty; build-verify 3192 (+818 verify lanes)
G14 comm -23 ~/w7/p2-before-ctest-names.txt <pull names> empty (2363 before). Added: 4 *.PlaceholderUntilTheOwningPackageFillsThisIn + 7 DirectGLESSlotTable.*
G13 grep -rc 'pGLContext' MobileGL/MG_Backend | grep -v ':0$' empty
G13 python3 scripts/check_include_closure.py 4 probes, 0 skipped, 0 problem(s), rc 0
G13 gen_pipe.py --check / --self-test rc 0 / rc 0
G13 stdio grep -nE '\b(printf|fprintf|std::cout|std::cerr|puts|putchar)\b' over the four touched backend files 9 hits, all the English word "puts" in comments
unit ctest -L unit -j 6 on all four dirs 100% tests passed … out of 1496 × 4
slot cases ctest -R DirectGLESSlotTable 7/7 on build-push and build-nolegacy; 42 Skipped lines on build-linux
integration, handle arm ctest --test-dir build-push -L integration-gpu -j 4 -R DirectGLES 446/446
integration, legacy arm same, MOBILEGL_PIPE_PUSH=0 446/446
integration, no legacy compiled build-nolegacy, same 446/446
integration-verify ctest --test-dir build-verify -L integration-verify -j 4 818/818; grep -c 'Fatal{' over all six pipe-verify-*.log = 0 each
G3 (DirectGLES half) python3 ~/w7/retrace_gate.py --tree ~/w7/p2-espryt --lib …/build-push/libMobileGL.so --out ~/w7/retrace-out/rev-espryt -j 4 --only 'DirectGLES$' passed 39 / 39; failed: []; five lowest SSIM 0.993475 / 0.995426 / 0.995920 / 0.996197 / 0.996301 — identical to §3 of the result file
Fatal{PipeLegacyMemosDisabled} MOBILEGL_PIPE_PUSH=0 MOBILEGL_PIPE_LEGACY_MEMOS=0 ./MobileGLIntegrationTest --gtest_filter=CrossFrameBufferScenario.VertexBufferSubData exit=0, [ PASSED ] 0 tests, [ SKIPPED ] 1, harness prints "a forked pre-flight child died on signal 6 (Aborted)" — the disabled arm does not run
MAJOR-4 mechanism gdb -batch, break MGPipeSlotAllocator::{Acquire,Free,FindByLifetimeId} on CrossFrameBufferScenario.VertexBufferSubData (build-push) Acquire 5, FindByLifetimeId 6, Free 0 — the implementer's Measurement 1 reproduces exactly
churn sweep is real gdb -batch, break MGPipeSlotAllocator::{Free,Allocate} on DirectGLESSlotTable.ObjectChurnAloneDrivesTheSweep Free 192 hits, Allocate 256 hits over 256 churned objects — the creation-driven sweep fires ~3× and slots are recycled, so the case is genuinely falsifiable

Also confirmed independently, refuting a worry I had on first read: CMakeLists.txt:466-471 makes MOBILEGL_PIPE_VERIFY imply MOBILEGL_PIPE_PUSH, so build-verify (whose CMakeCache says MOBILEGL_PIPE_PUSH:BOOL=OFF) really does compile -DMOBILEGL_PIPE_PUSH=1 (compile_commands.json), and gdb shows MGPipeSlotAllocator::Acquire hit 5 times in build-verify's integration binary. Minor 12's fix is real.

And ConfigLoader.cpp:254 + MGPipe.h:85 (kMGPipeSubsystemsMigratedAtP2 = 0x7f) do set bit 5 by default, so the 446 push-arm integration entries really are on the handle arm.


MAJOR 1 — the D13 "must not break" pins never execute the handle arm in any build directory the brief defines

C.2 says, verbatim:

Must not break — the D13 list. Each item has a named existing test: SanityTest.cpp:2575-2596 (scratch-FBO scrub), :2650-2665, :2757-2790 (context-generation guards on texture/framebuffer/renderbuffer twins), :3020-3062 (sampled-set staleness) …

and D13 additionally names the whole-registry save/reset/restore fixture ScopedDirectGLESTextureBindings (MG_Test/SanityTest.cpp:145-197, unchanged at HEAD: :154-197) as something the slot table "needs the same copy-assign-and-restore shape" for.

Those cases run against the legacy UnorderedMap arm, not against BackendSlotTable, in build-linux, build-push and build-verify. The reason is MobileGL/Config.h:334 — Uint64 PipePush = 0; — and MG_Backend/DirectGLES/Managers.cpp:517 — const Bool bitSet = (MG_Config::Features.PipePush & kMGPipeSubsystemEsprytSlots) != 0;. SanityTest never runs ConfigLoader, so Features.PipePush stays at its static default of 0, ResolveEsprytSlotTablesArm() returns false, and StateBackendObjectRegistry::GetOrCreate (Managers.h:364-366) takes the map arm.

Reproduction (build-push):

$ gdb -batch -x /tmp/gdb6.txt build-push/MobileGL/MG_Test/SanityTest      # --gtest_filter=-DirectGLESSlotTable.*
[  PASSED  ] 82 tests.
1  breakpoint  keep y  <MobileGL::MG_Backend::DirectGLES::EnsureProcessTeardownSentinel()>
        breakpoint already hit 4 times
2  breakpoint  keep y  <MobileGL::MG_Pipe::MGPipeSlotAllocator::Acquire(MGPipeKind, unsigned long)>
                                                     # <-- no "already hit" line: ZERO hits
3  breakpoint  keep y  <MobileGL::MG_Backend::DirectGLES::ResolveEsprytSlotTablesArm()>
        breakpoint already hit 1 time

EnsureProcessTeardownSentinel is called from StateBackendObjectRegistry::GetOrCreate (Managers.h:360) on both arms, so 4 hits proves the twin registry was entered four times (SanityTest.cpp:321, :365, and the flows under :2635 and :3001); Acquire at 0 proves every one of them went down the map arm. build-verify behaves identically (Acquire: no hits). Only build-nolegacy — where MOBILEGL_PIPE_LEGACY_MEMOS is undefined and Managers.cpp:540 returns true unconditionally — reaches the new code (Acquire 4 hits, 82 tests pass).

Why this is a major and not a nitpick:

  1. build-nolegacy is not one of the build directories the brief defines (section C's tree recipe, brief lines 485-500: build-linux, build-push, build-verify, build-bench). The integrator's D.1 per-merge loop and D.3 five-part gate never configure it, and package C ships no CMake entry, ctest label or CI step that would (E owns test.yml). So after integration nothing in any defined lane keeps these invariants holding on the arm that ships.
  2. §3 of the result file offers ctest -L unit … 100% tests passed … out of 1496 × 4 as the evidence for the "must not break" list. For three of those four directories it is evidence about the code the package did not change.
  3. The gap is not hypothetical for this package: the one behaviour the fixture exercises that only the handle arm has — g_backendTextureObjects = {} followed by = previousRegistry dropping the table's slots without returning them to MGPipeSlots() (the package's own minor 4 debt) — is exactly what ScopedDirectGLESTextureBindings would surface, and in build-push/build-verify it cannot.

MG_Test/SanityTest.cpp is package C's own file per C.5, so this is fixable inside the package (e.g. a second always-on ctest entry that runs SanityTest with the arm forced on before the EsprytSlotTablesEnabled() latch, in the shape MG_IntegrationTest already uses for environment-selected arms). It is not an ownership blocker.

MAJOR 2 — step e2 is still absent, and the brief forbids merging e3 without it

Unchanged from v1 and correctly declared by the implementer (§2 MAJOR 3, §4.1, §6.1), but it is still a missing scoped deliverable of C.2 and the brief is explicit that it blocks:

  • C.2 step 2: "e2: the explicit-destroy hook … This must land before the tables switch over, because a slot table has no garbage collector".
  • Section E, risk row "A slot table has no garbage collector…": "C's e2 lands the explicit delete_* notification before e3 switches the tables over, and e3 is not merged without it."

e3 and e4 are landed; e2 is not. Verified at HEAD: the seven CollectGarbageIfNeeded() call sites the brief asks to delete are all still there — DirectGLES.cpp:1275, 1662, 2027, 2028, 2029, 2857, 2858 — now driving BackendSlotTable::ReclaimDeadSlots() (SlotTables.h:224-235). Consequently ARCHITECTURE.md:363's census cannot count the six registries' GC as deleted, which is the unit D.4.6 measures the phase against.

I accept the implementer's ownership argument on the merits (C.5 gives MG_State/GLState/{Texture,Framebuffer,Renderbuffer,Sampler,Program,VertexArray}State/* to B and VertexArrayObject.h to D), and I confirm the mitigation is real: the creation-driven sweep (SlotTables.h:125-128, 145-157) restores parity with the map arm, and my gdb run shows it firing (192 Frees over 256 churned objects). But "the damage is now a no-op instead of a regression" is not the same as "the deliverable is present", and the brief's merge rule is not a package-level decision to make. This stays a major until the integrator re-scopes e2.


Minors

  1. §2 minor-2's claim is wrong about the shipping path. The result file says "The MOBILEGL_ASSERT was removed from that path on purpose: a DEBUG build must not trap where release quietly does the defined thing." It was removed only from BackendSlotTable::GetOrCreate (SlotTables.h:109-119). Every production call goes through StateBackendObjectRegistry::GetOrCreate, which still opens with MOBILEGL_ASSERT(stateObj != nullptr, "State object must not be null") (Managers.h:353) before dispatching to the slot table. So a DEBUG build still traps on null on the shipping path, and DirectGLESSlotTable.GetOrCreateToleratesANullStateObject exercises a path production never takes. The behaviour is unchanged from pre-P2, so this is documentation, not a defect — but the claim as written is not true.

  2. Minor 4's stated blocker does not exist. §2 minor 4 and §6.3 argue that returning slots on table destruction/reset cannot be done because "Free on the same {slot, gen} twice pushes the slot on the free list twice and two later Allocates hand out the same slot". That is refuted by the allocator itself: MG_Impl/Pipe/SlotAllocator.cpp:113-130 — if (!entry.Live || entry.Gen != handle.Gen) return; — makes Free idempotent and generation-safe, so a second Free of the same {slot, gen} is a no-op and a Free of a stale handle whose slot was re-handed is also a no-op. The debt may still be worth deferring to e2, but it should be deferred for a reason that is true; as it stands the package carries a real (if small and test-only) slot/ByLifetimeId leak on table reset that it believes it cannot fix.

  3. D13's "SyncTextureObjectToBackend's by-value copy and second Find … are deleted in the same change, not left as harmless" is not honoured, and the deviation is not declared. Both survive on the handle arm: the copy at DirectGLES.cpp:1377 (const SharedPtr<BackendTextureObject> backendObj = backendSlot;) and a re-resolving Find at :1403. The code's own comment (:1369-1373) gives a sound reason — a nested GetOrCreate can reallocate Vector<Entry> m_slots and invalidate the reference, so the copy is now a keep-alive and the Find is a re-resolve rather than a repair — so I do not dispute the engineering. But §4 of the result file lists five deviations and this is not one of them, and C.2/D13 is worded as an outright deletion.

  4. UnitBindingsSnapshot is split by #if MOBILEGL_PIPE_PUSH, not by the runtime arm, so MOBILEGL_PIPE_PUSH=0 is still not a faithful P1 control there. DirectGLES.cpp:1445-1493 replaces the WeakPtr snapshot with lifetime ids for the whole push build, including the MOBILEGL_PIPE_PUSH=0 legacy arm. This is the same complaint the implementer accepted and fixed for g_fbSlotCache (minor 6, DirectGLES.cpp:171-186, #if !MOBILEGL_PIPE_PUSH || MOBILEGL_PIPE_LEGACY_MEMOS); it was not applied here. I checked the semantics and they are equivalent (OwnerEquals on two empty pointers is true, and LifetimeIdOf(null) == 0 == 0; a live-vs-expired control block and two distinct lifetime ids both compare unequal), so this is A/B fidelity against D14 ("MOBILEGL_PIPE_PUSH=0 … reproduces P1's behaviour exactly"), not correctness. §4.5 mentions the file but frames it as a G1 concern only.

  5. The new unit cases share process-global allocator state with no ordering pin. TwoTablesOfTheSameKindShareOneSlotAndKeepTheirOwnTwin (SanityTest.cpp:3316-3345) deliberately never sweeps and lets both FakeSlotTables die holding a live MGPipeKind::Query slot, permanently raising MGPipeSlots().LiveCount(Query); ObjectChurnAloneDrivesTheSweep (:3353-3382) then reads HighWater(Query) and LiveCount(Query) from the same singleton. Both use deltas so they pass today (and gtest keeps registration order within a suite), but nothing pins that, and --gtest_shuffle or a later case that also uses kind Query would make them interact.

  6. The comment that justifies (5) will stop being true at integration. SanityTest.cpp:3342-3344: "The six shipping registries are one table per kind, so that cannot arise outside this case." ScopedDirectGLESTextureBindings already creates a second live table value of kind Texture for the duration of a test, and package D's subsystem 4 re-keys VaoDrawMemo on MGPipeHandle out of the same per-kind allocator. Worth flagging to the integrator: two holders of one kind, where whichever sweeps first frees the slot the other still names, is a cross-package hazard, not a test-only one. (I checked the fallout and it is contained — Free is generation-guarded, and FindByHandle's Gen compare turns a stale handle into a miss — but a live object whose ByLifetimeId row was erased by another table's sweep would be re-Acquired onto a new slot, orphaning the first table's entry.)

  7. Gates outside this package were not verifiable from it, and the result file's §3 does not say so per-gate. From ~/w7/p2-espryt I could not exercise G6/G7 (RenderStateSpans.* is still package A's placeholder — RenderStateSpans.PlaceholderUntilTheOwningPackageFillsThisIn is the only entry), G8 (HandleRecycle — no such ctest name exists in any of the four dirs; package E), G9 (scripts/gen_pipe_dirty_surface.py still has only --summary: --check and --self-test both exit 2 with "unrecognized arguments"; package B), G10 (MGL_RESIDUAL_BLOCK_SIZE is already 8 at MGPipeTypes.h:546, but there is no Residual ctest entry and no resid= device window) or G12 (CsoContentAddressing; package E). None of these is C's fault; they are recorded so the integrator does not read "446/446 + 818/818 + 39/39" as a P2 acceptance pass.

  8. Declared deviations I re-checked and agree with, listed here only so the integrator does not have to: §5.1 (_GLOBAL__sub_I_DirectGLES.cpp −9 belongs to the contract — confirmed, my contract→HEAD run is 0 resized); §4.3 (UnitBindingsSnapshot holds lifetime ids because a bound-but-never-synced texture has no twin — correct, and s_nextTextureLifetimeId starts at 1 at TextureObject.cpp:17, so the 0 == nothing bound sentinel is sound); §4.4 (the four defaultFBO compares need an owner for kMGPipeDefaultFramebuffer); §4.6 (retrace_gate.py has no --backend/--ssim; confirmed, --only 'DirectGLES$' is the working form); §5.3 (grep -E '^\s+Test #' drops four-digit entries — confirmed, sed -n 's/^ *Test *#[0-9]*: //p' is the working form). I did not hit §5.2's first-run scheduling flake in any of my runs (the cost data was already warm), so I neither confirm nor refute it.


What I hunted for and did not find

  • A stale answer from the new lifetimeId -> handle memo (SlotTables.h:185-193, 272-279). I could not construct one. The key is a per-class monotone counter that starts at 1 and is never reused (TextureObject.cpp:17,24-26 and the same shape in Buffer/Program/VertexArray/ Sampler/FramebufferObject), ITextureObject's only implementation family is TextureObjectBase so one counter covers the whole Texture kind, ReclaimDeadSlots clears the memo when it frees the memoised slot (:218), and every consumer resolves through FindByHandle's Gen compare (:175-181). A cached miss is overwritten by the next GetOrCreate on the same table.
  • A BackendPtr* invalidated behind a caller's back. Find never mutates (SlotTables.h:166-181), and the only mover is a GetOrCreate that grows m_slots; I walked every g_backend*Objects.{Find,GetOrCreate} site in DirectGLES.cpp and Managers.cpp and found none that holds a reference across an insertion into the same table without the re-resolve at :1403.
  • A transcription error in the detachFrom lambda. I diffed DirectGLES.cpp:6598-6653 (the shared lambda) against the pull-arm walk retained at :6676-6727 line by line: identical, with the stateRef.expired() test correctly hoisted to the two callers.
  • ResolveUnitSamplerBackend's "a miss is never cached" contract. Preserved on the handle arm (DirectGLES.cpp:3335-3350), and the null-sampler case is unreachable (:3805 guards with else if (samplerObject)).
  • Unguarded legacy residue. Rather than re-implement the implementer's preprocessor walker I used the stronger proof: build-nolegacy (-DMOBILEGL_PIPE_PUSH=1 with MOBILEGL_PIPE_LEGACY_MEMOS undefined) compiles and links rc=0 and passes 1496 unit + 446 integration entries, which is only possible if every OwnerEquals / TwinLookupMemo / g_fbSlotCache reference is inside a guard. GetFramebufferBindingSlotFast is gone from the whole tree (grep -rn over MobileGL/: no hits).
  • Hot-path instrumentation. None added; CreationTickForTest() is a const accessor and the only new logging is MGLOG_D/MGLOG_F inside the once-per-process ResolveEsprytSlotTablesArm().
  • A double free through the copy-assignable table. MGPipeSlotAllocator::Free (SlotAllocator.cpp:113-130) is generation-guarded and idempotent — which is also what makes minor 2 above a real finding.

To clear the review

  1. Land a lane that runs SanityTest's twin-registry cases on the {slot, gen} arm inside one of the brief's four build directories (MAJOR 1) — package C owns MG_Test/SanityTest.cpp, so no ownership line is crossed.
  2. Integrator decision on e2 (MAJOR 2): re-assign it to package B, or land B first and re-open C for one commit. Until then e3 is merged in violation of section E's own rule.
  3. Minors 1-4 are cheap: correct the two claims (1, 2), declare the SyncTextureObjectToBackend deviation (3), and either arm-split UnitBindingsSnapshot the way g_fbSlotCache was or say in §4 that MOBILEGL_PIPE_PUSH=0 is knowingly not P1-faithful there (4).