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.
23 KiB
P4a contract — c0d (Tracker.h): the two cross-package under-fires clientsp review v1 found
Commit 9ea44389e7219f74794eccb8a32586ba9b6f806c on refs/heads/p4a/contract, parent
17db7598 (= c0c = the pipe head at the time of writing). Two files, +269 / -6:
MobileGL/MG_Impl/Pipe/Tracker.h and MobileGL/MG_Test/Pipe/TrackerTest.cpp.
PipeFill.cpp is not touched: neither fix needed the wants() dirty-to-subsystem map to
move (see §1.3 and §2.4 for why that is the answer rather than a shortcut). DirtySurface.def
is not touched either, and §4 is the evidence that it did not need to be.
0. What the commit does, in one paragraph
Two shutters in Tracker.h could not see the state they exist to guard. glBindSampler moves
bit 12's generation and nothing else, so bit 13 — the bit bind_sampler_states is
emitted off — never fired for a sampler bind. And bits 6/7/8 (plus bit 14's program half)
read GetCurrentProgram(), which is null for the whole life of a bound separable program
pipeline, so after the first walk on a fresh context the entire program family latched 0 and
never moved again however the pipeline was restaged. Both are under-fires, which the file's own
rule calls the fatal direction; both are fixed by widening the shutter, which is where
over-firing is free. Four cases in TrackerTest.cpp pin them.
1. Fix 1 — glBindSampler now reaches bind_sampler_states (C-M4)
1.1 The defect, re-derived on this tree
PipeFill.cpp:2262-2263 gates EmitSamplerStates on wants(MGPipeDirty::NewSamplers) — bit
13. Bit 13's shutter was Mix(textureParams, ctx.GetSamplingResolutionGeneration()).
glBindSampler is GL_Sampler.cpp:360 BindSampler_State, and it makes exactly two state calls:
MG_State::pGLContext->NoteTextureUnitTouched((Int)unit)(GL_Sampler.cpp:369) →Core.h:139→TextureState.h:78 NoteUnitTouched, whosebindingChangeddefaults totrue, so it does++m_textureBindGenerationon every call — bit 12's counter;textureUnit.SetSamplerObject(...)(GL_Sampler.cpp:372/:384) →TextureUnit.cpp:28-39, which callspGLContext->BumpTextureBindGeneration()— bit 12's counter again.
The only two writers of BumpSamplingResolutionGeneration in the tree are parameter paths
(SamplerObject.cpp, TextureObject.cpp). So the review's failure scenario holds exactly as
written: glBindSampler(3, a); draw; glBindSampler(3, b); draw fires bit 12 twice and bit 13
zero times, and the server's BoundSamplerStates[3] keeps naming a's CSO. There is no pulled
twin to rescue it — bind_sampler_states has none, unlike the view set — and Espryt mixes
SamplerStatesSerial into a per-draw cache key (DirectGLES.cpp, the SamplerViewsSerial /
SamplerStatesSerial mix beside the set_sampler_views suppressor note), so the stale set is
also what its memo keys on.
1.2 The change
Tracker.h:515-517 (comment :496-514):
now[Index(MGPipeDirty::NewSamplers)] = MGPipeMixShutter(
MGPipeMixShutter(textureParams, ctx.GetSamplingResolutionGeneration()),
ctx.GetTextureBindGeneration());
1.3 Why the shutter and not PipeFill.cpp's gate — the choice, stated
The review offered two one-line fixes: mix bit 12's generation into bit 13's shutter, or gate
EmitSamplerStates on wants(NewSamplers) || wants(NewSamplerViews). The shutter is the
correct one, on the derivation of the three unit sets that the brief's D-G2 table gives:
- A sampler-state set entry is "the unit's sampler CSO, or the null handle when the unit has
no
SamplerObject— the texture's built-in sampler then applies". So the set is a function of which sampler object is bound at each unit, plus which texture is bound there whenever the unit has no sampler object and the built-in sampler is what applies.GetTextureBindGenerationis precisely the counter over which texture or sampler is bound at which unit:Core.h:143-146defines it as bumped whenever a texture bind/unbind/delete changes which texture is bound at a unit, andTextureState.h:88-99records that every texture and sampler bind entry point routes through theNoteUnitTouchedthat bumps it. It is an input to the set, not another bit's private business, so mixing it in is a correction to a shutter that was reading too little — not a coupling of two bits. - A sampler bind changes the sampler-state set and, correctly, also the view set (mipmap completeness depends on the effective sampler), which is why bit 12 was already right. A texture bind changes both too when the built-in sampler is in play. The asymmetry the review noted — bit 12 firing, bit 13 not — was never a design, only a gap.
- The gate variant leaves the shutter itself still wrong, and three other consumers read it:
gen_pipe_dirty_surface.pyderivesDirtySurface.def's bit answers from the shutter (§4), the per-bit fire tallies (m_fires) are published as a measurement, andMGPipeSubsystemForDirtymakes the push bitmask "a true per-subsystem A/B rather than approximately". A bit gated on another bit's shutter measures neither of those honestly.
Cost of the extra fires: bit 13 now also fires on every plain texture bind. That is bounded by
the emitter's own set-hash suppressor — MGPipeSetHashSuppressorInstance().ShouldEmit( BindSamplerStates, hash) in SamplerEmit.h's EmitSamplerStates — which MGPipeTypes.h:614 makes
mandatory for every kVarTail set_* for exactly this traffic (MC 26.2 rebinds the same sampler
at every texture-unit switch). An over-fire costs the 192-entry walk and one XXH64, not a wire
record.
2. Fix 2 — the program family under a separable pipeline (C-M5)
2.1 The defect
Tracker.h's old program block opened const auto& program = ctx.GetCurrentProgram(); and did
everything under if (program). Core.cpp:609-631 GetProgramForDraw shows what an application
that drives glUseProgram(0); glBindProgramPipeline(P) gets: m_currentProgram is null and the
draw program is the pipeline's composite. So bits 6, 7 and 8 all computed 0, matched the 0
they latched on the first (!m_primed) walk, and never fired again for the pipeline's whole
life. Tracker.h contained no reference to ProgramPipelineObject at all.
Rendering was not wrong, and the review is right about why: GetProgramForDraw is
emitted-and-still-pulled, the residual fill copies it at every verb, and that is exactly why
DirtySurface.def:319 rules BindProgramPipelineObject kPulledEveryVerb. What breaks at P4a
is the handle protocol: glUseProgramStages makes GetProgramForDraw build composite B,
EmitShaderState is never called, so B gets no ShaderCso handle and no create_shader_state
while set_draw_program keeps naming composite A — a program D and E will see that the handle
protocol never announced. And bit 8 never firing means set_global_constants is never sent for
a pipeline draw at all, where the pull rescues nothing.
2.2 The change
Tracker.h:361-421 adds an else if arm on the effective program source; the reasoning
paragraph is :305-344, and the file's own header summary is updated at :30-40.
} else if (const auto& pipeline = ctx.GetBoundProgramPipeline(); pipeline) {
using Pipeline = MG_State::GLState::ProgramPipelineObject;
static_assert(sizeof(Pipeline::DrawProgramSignature) == 2 * Pipeline::kGraphicsStageCount * sizeof(Uint64), ...);
static_assert(sizeof(Pipeline::UniformMirrorVersions) == 2 * Pipeline::kGraphicsStageCount * sizeof(Uint64), ...);
Uint64 stageLinks = static_cast<Uint64>(ctx.GetBoundProgramPipelineName());
Uint64 stageState = 0;
Uint64 stageImages = 0;
for (SizeT stage = 0; stage < Pipeline::kGraphicsStageCount; ++stage) {
const auto& staged = pipeline->GetStageProgram(static_cast<ShaderStage>(stage));
if (!staged) continue;
stageLinks = Mix(Mix(stageLinks, staged->GetLifetimeId()), staged->GetLinkVersion());
stageState = Mix(Mix(Mix(stageState, staged->GetBackendStateVersion()),
Mix(staged->GetUBOContentVersion(), staged->GetBlockBindingVersion())),
staged->GetUniformWriteSetVersion());
stageImages = Mix(stageImages, staged->GetImageUnitVersion());
}
shader = stageLinks;
stageState = Mix(stageLinks, stageState);
bindings = Mix(stageState, stageImages);
constants = stageState;
programImages = Mix(stageLinks, stageImages);
}
2.3 Why these fields, and why the loop instead of the two helper functions
{lifetimeId, linkVersion}per graphics stage ISComputeDrawProgramSignature()(ProgramPipelineObject.h:94-105), the key the composite cache is keyed on. Bit 6 therefore fires exactly whenGetProgramForDrawwould hand back a different composite — exactly when a newShaderCsohandle has to be minted. These are the same non-artefact fields the plain program arm reads and the onesCore.cpp:634-644calls out as not passing throughProgramObject's join gate, so the tracker's "must not force a compile" rule is intact: no join, no flatten, noLink().- The four per-stage counters are
ComputeUniformMirrorVersions()'s content (:123-141) —backendStateVersion,uboContentVersion,blockBindingVersion,uniformWriteSetVersion. Under SSO per-program state is written to the stage programs and only reaches the composite throughRefreshCompositeUniforms, so those are the counters bits 7 and 8 have to watch.GetImageUnitVersionis read per stage as well, because D-G4 asks bit 14's shutter to keep reading all three frontend counters rather than any server-side epoch. stageLinksis mixed intobindings,constantsandprogramImages. A composite rebuild hands back a brand-newProgramObjectwith an empty default uniform block and no backend state at all (SetCachedDrawProgramclears the mirror versions with it), so a shutter watching only the per-stage state counters would let a rebuilt composite inherit the bindings, the constants and the image units of the one it replaced.- The pipeline NAME is mixed in because two pipelines can carry the same stage set and each
caches its own composite object, so the signature alone would let a
glBindProgramPipelinebetween two such pipelines pass without a fire. - The two helper functions are not called, and that is a gate constraint rather than a
preference.
gen_pipe_dirty_surface.py'sresolve_readerfollows an accessor only throughreturn m_member;-shaped bodies; bothCompute*helpers build a local array and return it, which it cannot place. Calling them made bits 6/7/8/14UNRESOLVED, which costX(UseProgram, NEW_SHADER)its writer-taint reason and broke self-test negative control 6b (BumpTextureBindGeneration -> NEW_GLOBAL_CONSTANTSmust read UNDER-FIRING, and an unresolved shutter turns that verdict into UNDECIDED). Measured, not guessed: with the helper calls,--self-testprinted "negative control 6b did NOT trip". Reading the fields directly keeps every one of those bits derivable — which is the only mechanism that can catch the next under-fire here — and the twostatic_assertsare what tie the spelled-out pairs back to the functions they mirror.
2.4 The residual hole, recorded rather than hidden
A pipeline name recycled by glDeleteProgramPipelines + glGenProgramPipelines back onto
the same stage programs at the same link versions, with no other program-family change between
the two draws, produces the same shutter value for a different composite object. A
ProgramPipelineObject has no lifetime id and no wire object at all —
DirtySurface.def:348-353 says so where it rules MarkProgramPipelineForDeletion
kUnpublishedDestroy — so there is nothing else in Tracker.h's reach to mix. Closing it needs
a generation counter on the frontend object, i.e. an MG_State change, which is out of this
commit's file scope. It is stated in the header comment at Tracker.h:337-344.
2.5 Bit 14 moved too
programImages feeds NewShaderImages's shutter, so the same null-GetCurrentProgram() hole
made bit 14's program term constantly 0 under a pipeline. It is fixed by the same arm. This is
the same family as clientsp minor C-m1 (the emitters keying on GetProgramForDraw()), but it
is only the tracker half; C-m1's compute-pipeline half is still C's.
3. The tests (A-owned, MG_Test/Pipe/TrackerTest.cpp)
Four cases, all in the existing TrackerWalk fixture, and all four added to
MGL_TRACKER_TEST_LIST (:79-82) so G2's "the pull and push ctest name sets are identical"
holds — they are visible SKIPs in a pull build.
| case | line | what it drives, and what it pins |
|---|---|---|
TrackerWalk.ASamplerBindAloneFiresTheSamplerStateBit |
:635 |
Makes the two calls BindSampler_State makes, in its order (NoteTextureUnitTouched then SetSamplerObject), rebinding unit 3 from sampler 1 to sampler 2 with no parameter write anywhere. Asserts NEW_SAMPLERS and NEW_SAMPLER_VIEWS fire, and that the next walk is 0 (the widened shutter does not fire forever). |
TrackerWalk.ARestagedProgramPipelineFiresTheProgramBits |
:662 |
Binds a pipeline with no program in use (asserting GetCurrentProgram() == nullptr as the premise), reaches steady state, then does what glUseProgramStages ends in — one SetStageProgram. Asserts bits 6, 7 and 8, then 0. |
TrackerWalk.ARelinkOfAStageProgramFiresTheProgramBits |
:691 |
Same setup with a stage already installed, then a real ProgramObject::Link() through the entry point glLinkProgram drives. The link fails (no shaders attached) on purpose: the link-observable versions are bumped in Link()'s prologue, before every early-out, which is the invalidation contract. Asserts bits 6, 7, 8, then 0. |
TrackerWalk.UseProgramZeroLeavesTheBoundPipelineDrivingTheProgramBits |
:723 |
The shape an application writes: a program in use over a bound pipeline, then glUseProgram(0). Asserts bit 6 fires on the handover (the draw's program source changed), that it then settles, and that a subsequent stage change reaches bits 6/7/8 — i.e. the pipeline is the source now. |
All four pass in all three build dirs (build-linux pull, build-push, build-verify):
4/4, 100%, none skipped in the pull build (they are the MGL_DECLARE_PULL_SKIP stubs there and
report as passed).
4. Item (3): the two UNDECIDED dirty-surface rows stay marked
MGP_DIRTY_SURFACE_UNDECIDED_LIST still carries X(UseProgram, NEW_SHADER) and
X(BindVertexArray, NEW_VERTEX_ELEMENTS), and nothing this commit learned makes either
decidable, because neither mark is about the shutter side:
UNDECIDED, no verdict: BindVertexArray <- NEW_VERTEX_ELEMENTS (the write analysis is not complete
for this mutator: Bind() writes 'Access', which it never declares ...)
UNDECIDED, no verdict: UseProgram <- NEW_SHADER (the write analysis is not complete for this
mutator: DestroyProgramSlot() writes 'attachedShaders', which it never declares ...)
Both reasons are writer-side taints — a call resolved by name into a body with an
unplaceable non-m_ write — and they are properties of the scanner, not of the rows. Widening
bit 6's shutter cannot touch either. The reason strings after this commit are byte-identical
to the ones c0 left, --check still reports exactly 2 UNDECIDED, and self-test control 21
("the two P4a undecided marks are still needed") and control 18 ("a stale mark") both still trip.
So DirtySurface.def is unchanged: no row moved, and no mark outlived its reason.
One thing worth recording for whoever revisits this: the marks are one edit away from becoming
shutter-side (§2.3) — if a later change makes bit 6 read something resolve_reader cannot
place, the UseProgram mark silently changes meaning while staying green, and control 6b is what
notices, on a different bit.
5. Gates — every number
Run in ~/w7/p4a-contract, CCACHE_BASEDIR=/home/swung/w7, -j 8,
GLIBC_TUNABLES=glibc.malloc.tcache_count=0 for every ctest lane. All three build dirs already
existed and were rebuilt incrementally. 0 compiler errors, 0 warnings attributable to this
commit (grep -ci warning: over the whole build log = 0).
| gate | result |
|---|---|
(a) G1 symbol_report.py --before ~/w7/p4a-before-libMobileGL.so --after build-linux/libMobileGL.so --threshold 0 --fail-on-symbol-set-change --fail-on-added-bytes 0 |
rc 0 — 0 added / 0 removed / 0 resized / 0 renamed. .text 10806323 → 10806323 (+0, +0.000%); .data 76840 → 76840; .bss 1296872 → 1296872; .rodata 1536538 → 1536538; total 17226471 → 17226471; file 19114360 → 19114360 bytes. 27811 → 27811 defined symbols, 27072 → 27072 normalised names, 27072 unchanged. This is the check that says the fix is in push-only code: Tracker.h is inside #if MOBILEGL_PIPE_PUSH, so a pull-build symbol moving would mean it was placed wrongly. |
(b) unit, pull ctest --test-dir build-linux -L unit -j 8 |
rc 0, 100% passed, 0 failed out of 1642 |
(b) unit, push ctest --test-dir build-push -L unit -j 8 |
rc 0, 100% passed, 0 failed out of 1642 |
(b) unit, verify ctest --test-dir build-verify -L unit -j 8 |
rc 0, 100% passed, 0 failed out of 1642 |
| the four new cases, each lane | 4/4 passed in build-linux, build-push and build-verify |
| ctest names pull == push | diff empty, 2608 == 2608 |
names vs ~/w7/p4a-before-ctest-names.txt (LC_ALL=C on both sort and comm) |
0 removed, 20 added, 2588 → 2608. The 20 = c0's 13 + c0b's 1 + c0c's 2 + c0d's 4. |
(c) G5 p3a_untouched_regions.sh 37da3c3a HEAD (re-run on the commit, not the dirty tree) |
rc 0, the eleven pool / deferred-release / ring / flush-drain functions byte-identical |
(d) check_include_closure.py --mode both --compiler clang++ --self-test --require-all --expect-probes 4 |
rc 0 — 4 probes, 0 skipped, 0 problems, 6 negative controls tripped |
(e) gen_pipe_dirty_surface.py --check |
rc 0 — 79 mutators all mapped, no stale rows, 45 render-state answers derived, 10 other (mutator, bit) answers derived, 0 COARSE, 2 UNDECIDED (both marked, both with their pre-existing writer-taint reason), 26 prose answers |
gen_pipe_dirty_surface.py --self-test |
rc 0, 27 negative controls, all tripped; positive controls OK |
gen_pipe.py --check |
rc 0, generated files up to date; 71 calls, 72 verify payloads, 63 PipeInputs fields, 69 verbs, 477 inventory rows, 0 UNMAPPED |
gen_pipe.py --self-test |
rc 0, 7 negative controls tripped |
git diff --exit-code -- MobileGL/MG_Pipe/generated |
rc 0 |
5.1 integration-gpu -R DirectGLES, before and after
Both runs are the full 491-test selection, both under 30 s, so the before side was taken for
real rather than by subset: git stash push of the two files → cmake --build build-push →
run → git stash pop → rebuild → re-ran the push unit lane to confirm the restored binary
(100%, 0 failed out of 1642).
| tests | passed | failed | skipped | wall | |
|---|---|---|---|---|---|
before (17db7598, same build dir) |
491 | 100% | 0 | 63 | — |
after (9ea44389) |
491 | 100% | 0 | 63 | 27.4 s (216.85 s·proc) |
The skipped-test name sets are identical (diff of the two sorted name lists is empty),
which is the check that matters here — a fix that turned a real case into a skip would otherwise
read as "no regression". No regression.
6. What packages B / C / D / E must know — which bit now fires when
For C (clientsp / sampler-image-program) — the two majors it handed up are closed at the source, so C's rework must NOT re-fix them:
NEW_SAMPLERS(bit 13) now also fires on any texture or sampler bind at any unit (GetTextureBindGeneration), not only on a sampler/texture parameter change. SoEmitSamplerStatesis now reached forglBindSampler— the case C-M4 named — and also for plainglBindTexturetraffic. C's set-hash suppressor is now load-bearing, not an optimisation: without it MC 26.2's per-batch rebinds become a variable-length record per batch. C-m2's version-first skip in front of the CSO acquire is worth more after this commit than before it — the extra fires land exactly on that path. TheSamplerEmitTestcase that bumpsBumpTextureBindGeneration()by hand and then calls the emitter directly, now documents a path that really is reachable.NEW_SHADER/NEW_SHADER_BINDINGS/NEW_GLOBAL_CONSTANTS(bits 6/7/8) and the program term ofNEW_SHADER_IMAGES(bit 14) now fire under a bound pipeline, on: aglBindProgramPipelineto a different name; anyglUseProgramStagesthat changes a stage; a relink of any stage program; aglUniform*/glProgramUniform*/ block-binding write to a stage program; andglUseProgram(0)handing the draw to the pipeline. SoProgramEmit.h'sEmitShaderStateis now reached for composites, and the composite resolver is reached the wayCompositeResolver.hexpects — which is what makes C-M1 (theLive/Resetearly-return) and C-M2 (the never-invalidated(Cso, Version)latch) reachable in practice rather than in theory. C's rework should assume both are now on the hot path.- Nothing C owns needs to change because of this commit.
wants()'s map is untouched, the emitter entry points are untouched, and the subsystem assignment (kMGPipeSubsystemSamplers,kMGPipeSubsystemPrograms) is unchanged.
For B (clientfb / framebuffer-texture): bit 13 firing on texture binds means the sampler
family's emitters now run on batches where only a texture moved. B's built-in-sampler Acquire
through C's cache (ID-14 / ID-15) is therefore exercised more often; the ref-count ruling in
ID-17 is what keeps that safe.
For D (wire) and E (esprytdraw / esprytobj): the important consequence is a negative one
— a re-composited program pipeline now gets a ShaderCso handle and a create_shader_state
before set_draw_program names it, so D's re-keyed twin tables will not see a program the
handle protocol never announced (MGPipeSlots().FindByLifetimeId(ShaderCso, B) will hit). E can
rely on SamplerStatesSerial advancing on a sampler bind, which is what its per-draw memo at
DirectGLES.cpp (the SamplerViewsSerial / SamplerStatesSerial mix) keys on; before this
commit that serial stood still across a
glBindSampler. Fire rates go up for bits 13 and 6/7/8, so the P4a fire-rate measurements
recorded against c0c are not comparable to ones taken after c0d.
Rebase note: every package rebasing onto pipe after c0d integrates gets Tracker.h at
9ea44389. Nobody but A may edit that file; a package that finds itself wanting to is looking at
a contract defect and should say so rather than patch around it.