From 5c777b49e8d11a15acf1b6dda03d0ed96bc0ab74 Mon Sep 17 00:00:00 2001 From: Swung0x48 Date: Fri, 18 Sep 2026 11:59:28 -0400 Subject: [PATCH] [MG_Test] (Disaggregated): P5e mv - the multi-draw tiers get gated entries of their own - The resolved multi-draw tier is ONE process-wide read of MOBILEGL_ESPRYT_MULTIDRAW_MODE (MultiDraw.cpp's ResolveTierOnce) and the d1 block leaves it at "auto", which on this driver lands on "ext" - the one tier that asks the bound index buffer nothing. Three of the five sites the previous commit migrated therefore had no entry in the set the gate runs: ID-107's shape one level down, with the env knob in place of MG_Config::Transport. - Five blocks, one per tier "auto" cannot reach (basevertex, multiindirect, indirect, drawelements, compute), prefix DirectGLES.Split.MultiDrawTier., both labels, and MOBILEGL_ESPRYT_MULTIDRAW_MODE pinned as a ctest ENVIRONMENT property rather than a job-level export - review finding N-6's reason, and the PushMonolithArm block's precedent. - "ext" is deliberately NOT registered: the d1 block already IS the ext lane. Every other tier was confirmed to resolve to ITSELF here rather than falling back to ext, so no entry in this set is a green that silently means "ext again". - The filter is the tier-sensitive workload: MultiDrawScenario (minus the client-indices case d1 already excludes by name) plus IndexedDrawFamilyScenario's three MultiDraw cases. 12 entries per tier, 60 in total. - SplitLogPaths.cmake.in gives each of them a private log path. That is the rule every DirectGLES.Split. entry follows (SplitLogPaths.PrivateAndDistinct), and for these it also repairs the census blind spot: a third name segment means strict_census2.sh would re-run them without the very pin under test, so the marker is read where the lane wrote it. - integration-split 116 -> 176, integration-gpu 1294 -> 1354, both fully green. Under the strict lane all 60 stop on GetProgramForDraw@DrawArrays, which is pa's row: PrepareForDraw runs before the tier dispatch, so no new marker class appears and mv's row stays at 0. --- MobileGL/MG_IntegrationTest/CMakeLists.txt | 73 +++++++++++++++++++ .../Harness/SplitLogPaths.cmake.in | 11 +++ 2 files changed, 84 insertions(+) diff --git a/MobileGL/MG_IntegrationTest/CMakeLists.txt b/MobileGL/MG_IntegrationTest/CMakeLists.txt index f72d467a..23e13c74 100644 --- a/MobileGL/MG_IntegrationTest/CMakeLists.txt +++ b/MobileGL/MG_IntegrationTest/CMakeLists.txt @@ -2014,6 +2014,79 @@ if (MOBILEGL_BUILD_DISAGGREGATED) ) endforeach() + # ---- P5e mv: THE MULTI-DRAW TIERS, INSIDE THE GATED SET (ID-109's rule, one level down) -- + # + # WHY FIVE MORE LANES FOR ONE FILE. MultiDrawImpl asks the bound index buffer three questions + # and P5e (mv) moved all three onto the applier's record. Five of this driver's six tiers ask + # them from a DIFFERENT place in the batch - `RunIndirect` before any GL work, the rebased + # tier from the CPU shadow, `FlattenWithCompute` before PrepareForDraw has even run - and the + # resolved tier is ONE process-wide read of MOBILEGL_ESPRYT_MULTIDRAW_MODE (MultiDraw.cpp's + # ResolveTierOnce). The d1 block above leaves it at `auto`, and on every driver this gate has + # run against, `auto` lands on `ext` - a real multi-draw entry point that asks the index + # buffer nothing at all. Three of the five migrated sites therefore had no gated entry. + # + # That is ID-107's shape exactly one level down: code on a real arm, with no entry in the set + # the gate runs. The phase already paid 137 SEGFAULTs across 38 scenarios for the version of + # this that lived at the transport level, and the lesson ID-109 drew - "the gate runs the SET, + # so put the second arm in the set" - does not stop being true because the selector is an env + # knob rather than MG_Config::Transport. A manual sweep run once by one package decays to + # nothing by the next one. + # + # MOBILEGL_ESPRYT_MULTIDRAW_MODE IS A ctest ENVIRONMENT PROPERTY, not a job-level export, for + # review finding N-6's reason and the PushMonolithArm block's: the property overrides the job + # environment, so a gate that exported a mode of its own could not silently collapse these + # five lanes into five more copies of the `auto` one - the single failure mode a lane whose + # whole purpose is to pin a tier cannot survive. + # + # `ext` IS NOT REGISTERED HERE, deliberately: it is what `auto` already resolves to, so the + # d1 block above IS the ext lane and a sixth block would only run it twice. Every other tier + # was confirmed to resolve to ITSELF on this driver rather than falling back + # (`ResolveTier`'s "MOBILEGL_ESPRYT_MULTIDRAW_MODE= -> (driver supports: ext, + # basevertex, multiindirect, indirect, drawelements, compute (opt-in))"); a tier the driver + # refuses would resolve to `ext` and register an entry that quietly proves nothing, so if this + # list ever runs somewhere poorer, drop the refused tier rather than keeping a green that + # means "ext again". + # + # THE FILTER IS THE TIER-SENSITIVE WORKLOAD and nothing else, which is this file's own rule + # for an armed Split entry: MultiDrawScenario (its whole point is that a batch matches the + # unrolled draws, which is precisely what a wrong index buffer breaks quietly) and + # IndexedDrawFamilyScenario's three MultiDraw cases. The client-side-indices case keeps the + # d1 block's exclusion - it is refused by name under split before any tier is chosen. + # + # NOTE FOR THE STRICT-MARKER CENSUS (PREAMBLE-ADDENDUM-WAVE3 §4): these entries carry a THIRD + # name segment, so `strict_census2.sh` re-derives their gtest filter from the last two + # components and re-runs them WITHOUT the mode this block pins - which for these lanes is the + # whole point of the entry. They join Ct. / F1. / SmallRing. / PersistentMapArm. / NamedBlit. + # in that blind spot, so SplitLogPaths.cmake.in gives each of them a private log path: read + # the marker out of `build-split/MobileGL/MG_IntegrationTest/split-logs/.log`, which + # the LANE wrote under its own pin, instead of out of a re-run that lost it. + set(MGL_SPLIT_MULTIDRAW_TIERS basevertex multiindirect indirect drawelements compute) + set(MGL_SPLIT_MULTIDRAW_TIER_PREFIX_basevertex "BaseVertex") + set(MGL_SPLIT_MULTIDRAW_TIER_PREFIX_multiindirect "MultiIndirect") + set(MGL_SPLIT_MULTIDRAW_TIER_PREFIX_indirect "Indirect") + set(MGL_SPLIT_MULTIDRAW_TIER_PREFIX_drawelements "DrawElements") + set(MGL_SPLIT_MULTIDRAW_TIER_PREFIX_compute "Compute") + set(MGL_SPLIT_MULTIDRAW_TIER_FILTER + "MultiDrawScenario.*:IndexedDrawFamilyScenario.MultiDraw*-MultiDrawScenario.ClientSideIndicesBatchMatchesUnrolledDraws") + foreach(mglItestMultiDrawTier IN LISTS MGL_SPLIT_MULTIDRAW_TIERS) + mgl_itest_join_environment(MGL_ITEST_GLES_SPLIT_MULTIDRAW_ENVIRONMENT + "MOBILEGL_BACKEND_TYPE=DirectGLES" "MOBILEGL_TRANSPORT=inproc" + "MOBILEGL_IPC_SERVER_PATH=${MGL_ITEST_SPLIT_SERVER_PATH}" "MGITEST_SPLIT_LANE=1" + "MOBILEGL_ESPRYT_MULTIDRAW_MODE=${mglItestMultiDrawTier}" + ${MGL_ITEST_CAPABILITY_ENV} ${MGL_ITEST_COMMON_ENV}) + gtest_discover_tests(MobileGLIntegrationTest + TEST_PREFIX + "DirectGLES.Split.MultiDrawTier${MGL_SPLIT_MULTIDRAW_TIER_PREFIX_${mglItestMultiDrawTier}}." + TEST_LIST "MGL_SPLIT_MULTIDRAW_${mglItestMultiDrawTier}_TESTS" + TEST_FILTER "${MGL_SPLIT_MULTIDRAW_TIER_FILTER}" + DISCOVERY_TIMEOUT 30 + PROPERTIES + LABELS "integration-gpu\;integration-split" + TIMEOUT ${MGL_ITEST_TIMEOUT} + ENVIRONMENT "${MGL_ITEST_GLES_SPLIT_MULTIDRAW_ENVIRONMENT}" + ) + endforeach() + # ---- P5b package i1 (MG_Remote/CONTRACT-P5B.md §2 i1) -------------------------------- # # THE LANE CASE THAT PROVES THE RECORDS CROSSED, and it is a RESULT and not a probe (R-16: diff --git a/MobileGL/MG_IntegrationTest/Harness/SplitLogPaths.cmake.in b/MobileGL/MG_IntegrationTest/Harness/SplitLogPaths.cmake.in index 3bc1c1f6..d4117c39 100644 --- a/MobileGL/MG_IntegrationTest/Harness/SplitLogPaths.cmake.in +++ b/MobileGL/MG_IntegrationTest/Harness/SplitLogPaths.cmake.in @@ -26,6 +26,17 @@ foreach(scenario @MGL_SPLIT_D1_SCENARIOS@) endforeach() endforeach() +# P5e mv's five tier-pinned lanes, the same rule for the same reason - and here it also repairs +# the addendum §4 blind spot for them: these entries carry a third name segment, so the strict +# census cannot re-derive their MOBILEGL_ESPRYT_MULTIDRAW_MODE, but a private log per entry means +# its marker can be read where the LANE wrote it instead of from a re-run that lost the pin. +foreach(tier @MGL_SPLIT_MULTIDRAW_TIERS@) + foreach(entry IN LISTS MGL_SPLIT_MULTIDRAW_${tier}_TESTS) + set_tests_properties("${entry}" PROPERTIES ENVIRONMENT + "MOBILEGL_LOG_FILE_PATH=@CMAKE_CURRENT_BINARY_DIR@/split-logs/${entry}.log") + endforeach() +endforeach() + # P5b package i1's four scenarios, the same shape as the small-ring loop above: every # DirectGLES.Split. entry owns exactly one absolute log path and shares it with nobody, which # is what SplitLogPaths.PrivateAndDistinct checks over the discovered set.