20 KiB
P1 package A (p1-core) — c2..c6 on top of the contract
Tree ~/w7/p1-core, branch p1/core, base feat/disaggregated @ 087685d1, contract bf86b1ed (tag p1/contract, see core-contract.md). Nothing pushed. Working tree clean apart from the three untracked build directories.
Commits (oldest first, all on p1/core after p1/contract)
| sha | subject |
|---|---|
3aa4d8af1ff2ca6f95c9ab3e047e70bc0e0cf65f |
[Feat] (Pipe): fill PipeInputs per verb class from GLContext and stamp per-verb generations - a read of a field the verb did not fill is Fatal{UnmigratedPipeInput} |
a196ada4c11b59f23587596486d265124ea06a6f |
[Feat] (Impl): call MGP_FILL before every GLFunctionsTable entry - 83 statements over 69 verbs, a no-op in the pull build |
275dd3edb4909fe2a23af0f9a2667fb8215d24be |
[Feat] (Pipe): the MOBILEGL_PIPE_VERIFY shadow comparator - a per-verb entry compare over the fill set and a compare-at-read in every accessor, first differing field and verb serial, fatal by default |
83b16561c20428dd15995ed3b2b4ad5496a97bab |
[Feat] (Pipe): give the six value structs G4 field lists and assert the lists cover their members - the memcmp fallback is now a compile error, floats in vector types compare bitwise |
440d3c52534e2c227b8b4d83251d8afcb0849e3f |
[Test] (Pipe): pin the P1 poison and verify shapes - 63 fields, 69 verbs, the seven sticky fields, an omitted GenerateMipmap field leaves exactly that field stale, a corrupted snapshot names its field, reading an unfilled field aborts with SIGABRT |
git diff --stat p1/contract..HEAD: 17 files changed, 1587 insertions(+), 72 deletions(-). Files touched (all inside A's ownership row of C.5): MobileGL/MG_Backend/MGPipe/PipeInputs.{h,cpp}, MobileGL/MG_Impl/Pipe/PipeFill.{h,cpp}, the seven MobileGL/MG_Impl/GLImpl/{Drawing,Framebuffer,Texture,Getter,Program,Query,Sync}/*.cpp, MobileGL/MG_Pipe/PipeFields.def, MobileGL/MG_Pipe/generated/PipeVerify.inc, scripts/gen_pipe.py, MobileGL/MG_Test/Pipe/{CMakeLists.txt, PipeCatalogueTest.cpp, PipeInputsTest.cpp}. Not touched: MG_Backend/DirectGLES/**, MG_Backend/DirectVulkan/**, PipeCalls.def, Coverage.def, FillPoints.def, PipeInputsSwitch.h, CMakeLists.txt (root), Config.h/ConfigLoader.cpp, fixtures. No signature in PipeInputs.h / PipeFill.h / PipeInputsSwitch.h that B/C/E code against changed (the accessor set, MGB_CTX, MGP_FILL, the knob names and log lines are as in the contract); the additions are listed under deviations 5-7.
What each commit does
- c2 filler (
PipeFill.cpp):MGPipeFillForVerbwalkskMGPipeClassFieldMask[kMGPipeVerbClass[verb]];MGPipeFillAccess::CopyFieldis one switch over the 56 stored fields, each branch calling theGLContextaccessor of the same name (D4's fill column verbatim: loops of 8/16/32,GlobalBufferTargets/BufferBindPointTargetsfor the slot/point bases,&ctx.GetTextureUnitObject(0)/&ctx.GetImageTextureBinding(0)as array bases, Blend x8 + ScissorTest x16 for the indexed capabilities, all 35 capabilities incl.FramebufferSrgb's constant false); every copied field is stamped with the new serial; the seven sticky fields getFilledGen = 1on the first live fill.MOBILEGL_PIPE_POISON_OMIT(<Verb>:<Field>) is parsed once at the first fill;MGPipeSetPoisonOmission(verb, field)is the programmatic form; the omitted pair keeps its value copy and loses only its stamp; unknown names areFatal{PipeVerifyBadKnob}. - c3 fill points: the 83
MGP_FILL(X);statements of B.7 (36/11/8/3/1/18/6 per TU) plus#include <MG_Impl/Pipe/PipeFill.h>after each TU's lastMG_State/MG_Backendinclude, inserted by a patcher (scratchpad/wf4/core/patch_c3.py) that refused any target line not spelling its verb. - c4 comparator (
PipeFill.cpp,PipeInputs.{h,cpp}): entry compare at the end of every fill (SnapshotFromGLContextinto a file-static secondPipeInputs,MOBILEGL_PIPE_VERIFY_CORRUPTapplied to the snapshot arm,MGPipeVerifyInputsover the mask, first differing field); compare-at-read throughMGP_INPUT_VERIFY_READ->MGPipeVerifyReadHook(*this, field, i0, i1)(re-reads the field from the live context into a scratch block and compares against the live block only);MGLOG_F("MGPipe: Fatal{PipeVerifyDiffer, \"%s@%s\", verb=%llu, where=%s}")+abort()unlessMOBILEGL_PIPE_VERIFY_FATAL=0(counts,MGLOG_Esummary at teardown);MGLOG_I("MGPipe: verify armed - 63 fields, 69 verbs, fatal=N"),MGLOG_I("MGPipe: verify corruption armed - F"),MGLOG_I("MGPipe: poison omission armed - F@V"); a push build without the comparator answersMOBILEGL_PIPE_VERIFY=1with oneMGLOG_W_ONCE. - c5 G4 growth (
PipeFields.def,gen_pipe.py, regeneratedPipeVerify.inc): the six field lists (RenderStateParameters 65, PixelStoreParameters 8, PerBufferBlendState 7, StencilFaceState 7, DynamicBackendParameters 85, MGHostSpan 4),kMGPipeVerifiedPayloadCount63 -> 69;MEMCMP_FALLBACK_TYPESempty and the fallback branchstatic_assert(sizeof(T) == 0, "no field list in PipeFields.def for this type");Array<T,N>overload; VecBase detected by a probe and compared bitwise overdata;check_field_lists_cover_struct_members(),scan_live_accessors()(both modes),--self-testwith six negative controls and a positive one. - c6 tests: the four
PipeCatalogue.*additions and the fivePipeInputsTest.*cases (new unit target, ownmain()forMOBILEGL_LOG_FILE_PATH, fork/waitpid, neverEXPECT_DEATH).
Verification (WSL, ~/w7/p1-core; logs under ~/w7/p1-core-*.log)
Every command below was run on the final tree (440d3c52) unless a commit is named.
| command | actual output |
|---|---|
python3 scripts/gen_pipe.py --check |
gen_pipe: 71 calls (11 screen, 60 context), 69 verify payloads, 63 PipeInputs fields (7 sticky), 69 verbs, 9 classes / inventory 477 rows: ... 0 UNMAPPED / 1 accessor row(s) no backend reads: GetBoundTransformFeedbackName / generated files are up to date, rc=0 |
python3 scripts/gen_pipe.py --self-test |
six controls "tripped as expected" (struct member without F, F that is not a member, payload with no struct, verb missing from FillPoints.def, verb not in GLFunctionsTable, field row naming a non-accessor), positive control OK, rc=0. Before the whitespace-tolerant fix the three FillPoints controls reported DID NOT TRIP and the run exited 1 - the "zero trips is an error" arm was exercised. |
cmake --build build-linux + ctest -L unit --no-tests=error |
rc=0; 100% tests passed, 0 tests failed out of 1475 (1466 before c6 + 9 additions) |
python3 scripts/symbol_report.py --before ~/w7/p1-before-libMobileGL.so --after build-linux/libMobileGL.so --threshold 0 |
.text 10792579 -> 10792579 (+0, +0.000%), .data +0, .bss +0, .rodata +0, Total +0, 27799 -> 27799 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed, 27060 normalised names unchanged. G1 holds after every commit (checked at c3, c4, c5, final). readelf -S section sizes identical. cmp -l shows 34 differing bytes: 20 in .note.gnu.build-id, 14 in .rodata = the GIT@5d99ee4 -> GIT@087685d configure stamp and glslang's Timestamp: 2026-09-05T23:14:30 -> 2026-09-06T01:32:05 string - build stamps of equal length, not code. (Markdown/JSON: ~/w7/p1-core-symbol-final.{md,json}.) |
grep -rc "pGLContext" MobileGL/MG_Backend | sort | diff - ~/w7/p1-before-pglcontext.txt |
only the two contract files appear, both :0 (MG_Backend/MGPipe/PipeInputs.cpp:0, PipeInputs.h:0); every catalogued file's count unchanged - A converts no site |
grep -c "pGLContext" MobileGL/MG_Backend/MGPipe/PipeInputs.h PipeInputs.cpp |
0 0 |
grep -c "MGP_FILL(" MobileGL/MG_Impl/GLImpl/*/*.cpp | awk ... |
83 (Drawing 36, Framebuffer 11, Texture 8, Getter 3, Program 1, Query 18, Sync 6) |
cmake --build build-push + ctest -L unit --no-tests=error |
rc=0; 100% tests passed, 0 tests failed out of 1475; MOBILEGL_PIPE_PUSH=1 on every compile command, MOBILEGL_PIPE_VERIFY=1 on none |
cmake --build build-verify + ctest -L unit --no-tests=error |
rc=0; 100% tests passed, 0 tests failed out of 1475; MOBILEGL_PIPE_VERIFY=1 on all 497 compile commands |
ctest --test-dir build-push -L integration-gpu --no-tests=error -j 4 (at c3, a196ada4) |
99% tests passed, 1 tests failed out of 868; the one failure DirectVulkan.PointSizeDemotion.PointSizeDemotionScenario.TheDemotionIsActuallyArmedWhenTheEnvironmentPinsItOn (0.23 s) passes alone in build-push AND in build-linux (100% tests passed ... out of 4) - a -j 4 flake of an env-pinned lane, the case the integrator script's --rerun-failed -j 1 exists for; zero Fatal{ lines in the log |
ctest --test-dir build-push -L integration-gpu --no-tests=error -j 4 (final tree) |
ITEST_FINAL_PLACEHOLDER |
ctest -N name diff (pull): comm -23 ~/w7/p1-before-ctest-names.txt - |
2343 names, 0 removed, 9 added (PipeCatalogue.{VerbTableIsTheFunctionTable, StickyFieldsAreExactlyTheSeven, FloatVectorsCompareBitwise, SixValueStructsHaveFieldLists}, PipeInputsTest.{OmittingOneFieldForOneVerbLeavesExactlyThatFieldStale, ReadingAnOmittedFieldAbortsNamingTheVerb, ReadingAFilledFieldCompletes, CorruptedSnapshotFieldIsNamedWithItsSerial, EveryVerbFillsItsClassAndNothingElse}); the same 9 names exist in all three configurations (skips are visible, not vanishing). The padding-tolerant regex '^\s+Test\s+#[0-9]+:' is used, as in the contract report. |
G4 unit (build-verify, PipeInputsTest.CorruptedSnapshotFieldIsNamedWithItsSerial) |
Passed: clean snapshot compares equal over kDraw's mask; MGPipeApplyVerifyCorruption(snapshot, GetRenderStateParameters) -> MGPipeVerifyInputs false naming GetRenderStateParameters, whose stamp equals the fill serial; a corruption of a field outside the mask is not seen; a forwarded field cannot be corrupted. Skips visibly in build-push ("verify not compiled in") and build-linux ("push not compiled in"). |
G4 lane-level smoke (build-verify, MOBILEGL_PIPE_VERIFY=1 ctest -R 'DirectGLES\..*ClearThenReadPixels') |
clean: 100% tests passed ... out of 5, log has MGPipe: verify armed - 63 fields, 69 verbs, fatal=1, 0 Fatal{. With MOBILEGL_PIPE_VERIFY_CORRUPT=GetRenderStateParameters: 0% tests passed, 5 tests failed out of 5 (rc=8), log has MGPipe: verify corruption armed - GetRenderStateParameters and Fatal{PipeVerifyDiffer, "GetRenderStateParameters@Clear", verb=1, where=entry} |
G5 unit (build-verify, PipeInputsTest.{Omitting..., ReadingAnOmittedFieldAbortsNamingTheVerb, ReadingAFilledFieldCompletes}) |
all Passed: with SetPoisonOmission("GenerateMipmap","GetActiveTextureUnit") the GenerateMipmap fill leaves GetTextureUnitObject fresh and GetActiveTextureUnit stale, a following DrawArrays fill leaves it stale while GetBoundVertexArray is fresh, and a BindImageTexture fill (same class, different verb) heals it; the forked child that draws, reads a filled field, fills GenerateMipmap, reads the sibling and then the omitted field dies with WTERMSIG == SIGABRT and the log carries exactly Fatal{UnmigratedPipeInput, "GetActiveTextureUnit@GenerateMipmap"}, no @DrawArrays, no GetTextureUnitObject@; the sibling child without the omission _exit(0)s with no Fatal{. In build-push (Release/INFO, no POISON) the two poison cases skip visibly and ReadingAFilledFieldCompletes passes. |
nm -D --defined-only build-verify/libMobileGL.so | grep -c MGPipeVerifyInputs / same on build-push |
1 / 0 - the symbol E's retrace-verify job probes exists only in the verify library |
EveryVerbFillsItsClassAndNothingElse (build-verify) |
Passed: after each of the 69 fills a field is fresh iff its class bit is set (sticky included); ContextIdentity() is the live context address |
Not run: the 40-trace retrace under verify and the integration-verify lane (E's files; D.3 on the integrated tree). The verify-build integration-gpu was only smoked (5 ClearThenReadPixels entries) - on this tree no backend reads gPipeInputs, so its full run would only repeat build-push's proof.
Deviations from the brief (with reasons)
- Nine fill points precede a guarded expression rather than the bare call (D7 says "after every early return the call is behind; a verb whose table entry is null never bumps"):
GL_Query.cpp260/300 (if (handle && getQueryResult64 && !getQueryResult64(...))), 289 (outValue = (!f || f(h)) ? 1 : 0), 522/533/645 (handle = f ? f() : nullptr), 774 (supported = ... && f && f()),GL_Sync.cpp177 (signaled = !f || !h || f(h)) andGL_Drawing.cpp1331 (if (auto sync = backendGL.FenceSync()), inside theFenceSync && ClientWaitSyncguard so this one is exact). At the other eight the fill precedes the statement that holds both the null guard and the call, so a null entry bumps the serial once with nothing to read it (kQuery fills one field; no backend read happens between two fills without a fill). Chosen over a comma-expression ((MGP_FILL(X), f(...))) or splitting the statements because either would touch the code shape of the pull build, and G1 asks for byte identity. - Compare-at-read re-reads the WHOLE field, not only the indexed element (D8: "re-reads the same accessor with the same indices"). The hook copies the field from the live context into a scratch block through the same
CopyFieldthe filler uses and compares withMGPipeInputsFieldEqual; the indices decorate the report (MGLOG_Ebefore the Fatal). A superset: a divergence in an index the backend did not ask for is still a boundary-vs-live divergence. One copy switch instead of a second 56-way index-aware switch. MGPipeVerifyReadHooktakes the block as its first parameter ((const PipeInputs& self, field, i0, i1); the brief spells(f, i0, i1)): the macro expands inside member functions of anyPipeInputs(the snapshot's accessors run in the tests), and only the live block is verified; withoutselfthe hook could not tell them apart. No backend code spells the hook.- VecBase bitwise compare is a probe inside the generic
MGPipeFieldEqual, not an overload (D8 says "two overloads ... partial ordering picks these overconst T&"). ForFloatVec4the overload onconst VecBase<D,T,N>&needs a derived-to-base conversion and LOSES overload resolution to the exact-match generic template before partial ordering is consulted; theArray<T,N>overload is exact and does win, and is emitted as the brief says.PipeCatalogue.FloatVectorsCompareBitwisepins the behaviour (NaN equals itself, -0.0f != 0.0f,a == bis IEEE and disagrees). MGPipeInputsFieldEqualtakesconst PipeInputs&(the contract hadPipeInputs&), with a constVisitStorageoverload added; nobody outside A calls it.MGPipeVerifyInputscarries__attribute__((visibility("default")))(not in the brief): the library is built with hidden visibility, so without it E'snm -D build-linux/libMobileGL.so | grep -q MGPipeVerifyInputsstep (C.4 (c)) could never pass. No MGPipe symbol was in the dynamic table before; this is the only one now.- Pointer corruption flips the low bits instead of nulling (D8 says "swap a pointer for nullptr"): a pointer that is already null (an O-class field before the first fill, or a null
GetProgramForDraw) would make the corruption invisible to the compare; aSharedPtrbecomes an aliasing pointer with no control block. The snapshot is only ever compared, never dereferenced. SnapshotFromGLContextandMGPipeFillForVerbshareCopyFieldrather than being two copies of the copy logic; the snapshot is still its own function (the branch that survives P13) with its own file-static block.CurrentVertexAttributeValuecompares bitwise inPipeInputs.cppwith asizeof == 48static_assert: it isMG_Statestorage (three scalarArrays, no padding), not a payload, so it gets noPipeFields.defrow and the struct-member check does not searchCore.h.PipeInputsTestis a separate unit target (the brief allowed it "if the verify-only tests need it"): the fork cases need their ownmain()to pointMOBILEGL_LOG_FILE_PATHat a file before anything logs, and the fake-context cases needMobileGL_s;PipeCatalogueTeststays context-free. Its five cases areGTEST_SKIPin a pull build and the poison/verify cases skip in a push build without those switches.- A push build without POISON acknowledges
MOBILEGL_PIPE_POISON_OMITwithMGLOG_W_ONCE("no stamp exists to omit") instead of theMGLOG_I("poison omission armed")line, which is emitted only where the omission can act. - The sticky one-time stamp moved from an unconditional loop into the mask walk (every class mask carries the seven sticky bits, so the result is identical).
gen_pipe.py --self-testalso runs the field-list coverage check on the real inputs first (main()order: calls -> payloads -> coverage check -> coverage -> self-test), so a broken real list fails before the canned controls run.
Where the tree contradicted the brief's numbers
- B.7
GL_Drawing.cpp:907 MemoryBarrier (TextureBarrier): line 907 is the closing brace; thememoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT | GL_FRAMEBUFFER_BARRIER_BIT);call is at 906. Every other B.7 line number held (the patcher checks each target line for its verb; the six XFB sites use abbreviated captured namesbeginXfb/endXfb/pauseXfb/resumeXfb/deleteXfb/bindXfb,GL_Getter.cpp:1176spellsgetIntegeri(). - B.7 continuation lines: seven listed lines are the call's continuation line of a multi-line statement (
GL_Query.cpp261, 301, 523, 534, 646, 775;GL_Sync.cpp178 for the 177 entry) - the fill goes before the statement start (260, 300, 522, 533, 645, 774, 177). - D8 "all 67 members of
struct RenderStateParameters": the struct has 65 direct data members (MGPipeValueTypes.h:239-387,MAX_VIEWPORTSis static).DynamicBackendParametershas 85 (brief gives no count). - D4
IsCapabilityEnabled"37 entries,MGPipeValueTypes.h:168-204":CapabilityInputhas 35 enumerators beforeCapabilityInputCount; the storage is sized from the enum, so nothing depends on the number. - C.1 "7 files change" for c5's regeneration: only
PipeVerify.incchanges at c5 (the field lists feed G4 alone); the contract commit already regeneratedPipeFilled.incand createdPipeFillPoints.inc. - The integration-gpu count: 868 entries in build-push's
integration-gpulabel (the brief's "371 + 3 new cases" is E's post-integration figure). ctest -Nregex ('^\s+Test #', C.1): as recorded in the contract report, ctest right-aligns the test number, so the padding-tolerant regex is what produces the 2334/2343 name lists.
Unfinished / notes for the integrator
- Nothing in A's scope is unfinished. The verify library's full
integration-gpu, theintegration-verifylane and the 40-trace retrace under verify are D.3 items on the integrated tree (they need B/C's sites onMGB_CTXand E's lanes to mean anything). MGB_CTX_LIVE-guardedRecordErrorand the twoInvalidateCompileEnvcalls at backend init run before any fill; they are sticky and pass the poison from the first live fill on, as designed. If the verify lane finds an@<none>Fatal for any other field, the answer is a fill point at that boundary, never a sticky flag.- The
-j 4flake ofPointSizeDemotionScenario.TheDemotionIsActuallyArmedWhenTheEnvironmentPinsItOnreproduced neither alone nor in the pull build; it is not caused by this branch but the integrator's--rerun-failed -j 1step stays worth keeping. scan_live_accessors()will start reportingMGB_CTX->reads the day B/C land; today it reports one unread row (GetBoundTransformFeedbackName, dead by design).