mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-17 23:13:22 +09:00
[MG_IntegrationTest, docs] (P7): the texture upload shape becomes a gate, with the view remap inside the workload
P3b/P4b R-11 / D-D4, landing under the P7 program (PLAN-PH-P34B-P7.md 1.2, wave 2-D
package D2). P4a recorded the emission shape rather than gating it because the
per-storage-owner cursor with view/owner remapping was the next phase's and gating an
unfinished shape pins a non-answer. That work landed, so the RecordProperty block is
now EXPECT_EQ against a gold row MEASURED on this cursor, and the workload carries a
third texture written through a glTextureView so the remap is inside the counted
window.
The gold row, identical on monolith / inproc / spawn / tcp:
emit=9 box=9 rect=0 jobs=9, client emitter 9
keyed on the workload constants by static_assert. P4a's emit=6 box=6 rect=0 jobs=6
was a two-texture workload with no client emitter and is not comparable.
The client half is read from MGPipeTextureEmitter::SubDataCount() rather than from
ctu=, and that is a correction: under spawn and tcp the two roles are two processes
whose PipeStats windows close on different Present cadences (measured ctu=13 against
emit=9, and usually not yet written when the case reads), so ctu == emit is not a
well-posed comparison there. The log field is kept as a record and asserted only
where the transport says the two are window-aligned - asking the NUMBER was the first
mistake, because the server publishes a readable ctu=0 under spawn and the comparison
silently became 0 == 9. PipeStatsWindow gains LastFromClientLog/LastFromServerLog.
Split/spawn/tcp arms added as explicit per-arm blocks rather than through
mgl_itest_register_split_arms: the macro hands every arm the shared environment, and
this case needs a lane marker, PipeStats period 1, a push mask and above all a
MOBILEGL_LOG_FILE_PATH private to the arm - the library opens the log "w", so two
entries sharing a path truncate each other and the failure looks exactly like "the
counter was never emitted".
Red-once (R-16): the prescribed flip of summedArea*4 >= unionArea*3 leaves the gate
GREEN, and that is a finding. Two gates downstream dominate it - the server needs
dirtyRectCount >= 2, and UnpackRingAvailable() zeroes the rect list by design ("one
box, one job", the existing Mali-cliff mitigation). So rect=0 is the policy's
intended output, not an accident of the scatter pattern. The red-once that bites
splits the union box in two AND disables the unpack ring: box=6 rect=3 jobs=12
against the gold, while 26 pixel cases stay green. Four attempts and their reasons
are in the note.
The Mali frame-time delta D-D4 asks for beside the gold is NOT schedulable - one
Redmi, an Adreno, no Mali part - and is recorded as a declared deviation in the
scenario header and MEASUREMENTS.md 13.3 rather than modelled.
Also corrects the three places that said the client emitter had not landed: the
scenario header, the CMake probe's comment, and gates-v1.md's re-run table.
TextureEmit.h's EmitOneLevel has been incrementing it.
This commit is contained in:
@@ -640,9 +640,16 @@ if (MOBILEGL_PIPE_PUSH)
|
||||
# question with a different owner's file behind it (review F-m7). ctu= is emitted by PipeStats
|
||||
# in EVERY push build whether or not anything increments it, so "the counter read zero" and
|
||||
# "no client emitter exists" are the same number and TextureUploadShape cannot tell them apart
|
||||
# from the summary line alone. Once package B's texture emitter lands, an emitter that stopped
|
||||
# emitting would read exactly like no emitter at all and the two-sided assertion the scenario
|
||||
# exists for would pass while comparing nothing. This probe is what separates them.
|
||||
# from the summary line alone. An emitter that STOPPED emitting reads exactly like no emitter
|
||||
# at all in that field, and the two-sided assertion the scenario exists for would pass while
|
||||
# comparing nothing. This probe is what separates them.
|
||||
#
|
||||
# THAT EMITTER HAS LANDED (P3b/P4b wave 2-D corrects this comment's tense):
|
||||
# MG_Impl/Pipe/TextureEmit.h's EmitOneLevel increments
|
||||
# CallClass::ClientTextureUploadEmissions on every piece it emits, so the probe hits and the
|
||||
# else() arm below is unreachable on this tree. It is KEPT rather than deleted because it is
|
||||
# what makes the arming decision falsifiable in both directions - a probe that cannot report
|
||||
# "absent" cannot be shown to be looking for the right symbol.
|
||||
mgl_itest_probe_for_symbol(MGL_ITEST_CLIENT_TEXTURE_UPLOAD_EMITTER
|
||||
"${MGL_ITEST_ROOT}/MobileGL/MG_Impl/Pipe" "ClientTextureUploadEmissions")
|
||||
if (MGL_ITEST_CLIENT_TEXTURE_UPLOAD_EMITTER)
|
||||
@@ -1646,21 +1653,32 @@ gtest_discover_tests(MobileGLIntegrationTest
|
||||
ENVIRONMENT "${MGL_ITEST_VULKAN_OBJECT_SUBSYSTEM_NO_CONSUMER_ENVIRONMENT}"
|
||||
)
|
||||
|
||||
# --- The texture upload shape: RECORDED, NOT GATED in P4a (D-D4) ----------------------
|
||||
# --- The texture upload shape: A GATE as of P3b/P4b R-11 (D-D4) -----------------------
|
||||
#
|
||||
# SSIM is blind to the box-versus-rect upload shape and the Mali cliff it hides is ~+6 ms/frame, so
|
||||
# the shape needs a number - two numbers, in fact, the server's tex[emit= box= rect= jobs=] and the
|
||||
# client's emit[ctu=], which agreeing is the whole reason both are published (D-L). What this lane
|
||||
# asserts is that the numbers could be READ, that the server bracket's own arithmetic holds and that
|
||||
# the two sides agree when both are non-zero; WHICH shape each texture took is RecordProperty'd and
|
||||
# printed for MEASUREMENTS.md. P3b/P4b turns it into a gate against a gold standard, with the Mali
|
||||
# frame-time delta published beside it - gating a shape this phase has not finished deciding would
|
||||
# either pin today's shape as the answer or fail on the change that is the next phase's point.
|
||||
# client's emit[ctu=], which agreeing is the whole reason both are published (D-L).
|
||||
#
|
||||
# P4a RECORDED those numbers rather than gating them, because the per-storage-owner emission cursor
|
||||
# with view/owner index remapping - what actually decides the shape for a texture uploaded through a
|
||||
# VIEW - was the next phase's and gating an unfinished shape pins a non-answer. THAT WORK LANDED
|
||||
# (MG_Impl/Pipe/TextureEmit.h's owner-keyed drain list; TextureObjectView::ToOwner*), so this lane's
|
||||
# RecordProperty block is now EXPECT_EQ against a gold row measured on this cursor, and the workload
|
||||
# carries a third texture written through a glTextureView so the remap is inside the counted window.
|
||||
#
|
||||
# MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW=1 IS THEREFORE MANDATORY HERE, not decorative: without it the
|
||||
# case SKIPS rather than dropping the third texture, because a conditional workload behind a fixed
|
||||
# gold row is a gate that passes by shrinking.
|
||||
#
|
||||
# THE MALI FRAME-TIME DELTA D-D4 asks for beside the gold is NOT SCHEDULABLE in this phase - one
|
||||
# Redmi, an Adreno, no Mali part - and is recorded as a declared deviation in the scenario header
|
||||
# and in docs/Disaggregated/MEASUREMENTS.md rather than modelled.
|
||||
#
|
||||
# Its own log path and its own single-case filter, for the per-lane-log reason above.
|
||||
mgl_itest_join_environment(MGL_ITEST_GLES_TEXTURE_UPLOAD_SHAPE_ENVIRONMENT
|
||||
"MOBILEGL_BACKEND_TYPE=DirectGLES" "MGITEST_TEXTURE_UPLOAD_SHAPE_LANE=1"
|
||||
"MOBILEGL_PIPE_PUSH=0x1fff" "MOBILEGL_PIPE_STATS=1" "MOBILEGL_PIPE_STATS_PERIOD=1"
|
||||
"MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW=1"
|
||||
"MOBILEGL_LOG_FILE_PATH=${CMAKE_CURRENT_BINARY_DIR}/texture-upload-shape-DirectGLES.log"
|
||||
${MGL_ITEST_CAPABILITY_ENV} ${MGL_ITEST_COMMON_ENV})
|
||||
|
||||
@@ -1671,6 +1689,7 @@ gtest_discover_tests(MobileGLIntegrationTest
|
||||
PROPERTIES
|
||||
LABELS integration-gpu
|
||||
TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
RESOURCE_LOCK texture-upload-shape-DirectGLES.log
|
||||
ENVIRONMENT "${MGL_ITEST_GLES_TEXTURE_UPLOAD_SHAPE_ENVIRONMENT}"
|
||||
)
|
||||
|
||||
@@ -2661,6 +2680,64 @@ if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
"TextureViewAliasScenario.*-TextureViewAliasScenario.TheOwnerUploadDrainRunsAgainAfterADrawBoundary"
|
||||
"")
|
||||
|
||||
# ---- D2: THE UPLOAD-SHAPE GOLD, UNDER ALL THREE TRANSPORTS ------------------------------
|
||||
#
|
||||
# WRITTEN OUT PER ARM RATHER THAN THROUGH mgl_itest_register_split_arms, and the reason is
|
||||
# structural rather than stylistic: the macro hands every arm the SHARED
|
||||
# MGL_ITEST_GLES_<ARM>_ENVIRONMENT, and this case needs four things no shared list carries -
|
||||
# MGITEST_TEXTURE_UPLOAD_SHAPE_LANE=1 (without it the case skips), MOBILEGL_PIPE_STATS=1 with
|
||||
# PERIOD=1, MOBILEGL_PIPE_PUSH=0x1fff, and a MOBILEGL_LOG_FILE_PATH PRIVATE TO THE ARM. That
|
||||
# last one is not negotiable: the library opens the log fopen(path, "w"), so two entries
|
||||
# sharing a path truncate each other under `ctest -j` and the failure looks exactly like "the
|
||||
# counter was never emitted". The PersistentMapArm pair above is the same shape for the same
|
||||
# reason. A macro call here would produce three entries that all green-skip.
|
||||
#
|
||||
# WHAT THE SPLIT ARMS ADD OVER THE MONOLITH LANE. The monolith lane reads one log, because
|
||||
# there is one role. Under SPAWN and TCP the client and the server are two PROCESSES with two
|
||||
# independent counter sets - the client's line carries ctu= and the server's carries tex[] -
|
||||
# and the `ctu == emit` comparison the whole scenario exists for is only a real comparison
|
||||
# there. Under inproc it is one process with two log FILES, which is the arm that proves the
|
||||
# role-derived path reading without needing two counter sets.
|
||||
set(MGL_D2_TUS_FILTER "TextureUploadShapeScenario.TheEmittedUploadShapeIsRecordedAndTheTwoSidesAgree")
|
||||
foreach(mglD2Arm Split Spawn Tcp)
|
||||
string(TOLOWER "${mglD2Arm}" mglD2ArmLower)
|
||||
set(mglD2Log "${CMAKE_CURRENT_BINARY_DIR}/texture-upload-shape-${mglD2ArmLower}-DirectGLES.log")
|
||||
set(mglD2Extra)
|
||||
if(mglD2Arm STREQUAL "Split")
|
||||
set(mglD2Transport "MOBILEGL_TRANSPORT=inproc"
|
||||
"MOBILEGL_IPC_SERVER_PATH=${MGL_ITEST_SPLIT_SERVER_PATH}")
|
||||
elseif(mglD2Arm STREQUAL "Spawn")
|
||||
set(mglD2Transport "MOBILEGL_TRANSPORT=spawn"
|
||||
"MOBILEGL_IPC_SERVER_PATH=${MGL_ITEST_SPLIT_SERVER_PATH}")
|
||||
else()
|
||||
set(mglD2Transport "MOBILEGL_TRANSPORT=spawn"
|
||||
"MOBILEGL_IPC_CONTROL=${MOBILEGL_ITEST_TCP_ENDPOINT}"
|
||||
"MOBILEGL_IPC_DATA=stream" "MOBILEGL_IPC_REQUIRE_SAME_BUILD=1"
|
||||
"MOBILEGL_IPC_LOG_FORWARD=1" "MOBILEGL_IPC_TOKEN="
|
||||
"MGITEST_TCP_LANE=1" "MOBILEGL_ITEST_REQUIRE_GPU=1")
|
||||
set(mglD2Extra FIXTURES_REQUIRED mobilegl-tcp)
|
||||
endif()
|
||||
mgl_itest_join_environment(MGL_D2_TUS_ENV_${mglD2Arm}
|
||||
"MOBILEGL_BACKEND_TYPE=DirectGLES" ${mglD2Transport} "MGITEST_SPLIT_LANE=1"
|
||||
"MGITEST_TEXTURE_UPLOAD_SHAPE_LANE=1" "MOBILEGL_PIPE_PUSH=0x1fff"
|
||||
"MOBILEGL_PIPE_STATS=1" "MOBILEGL_PIPE_STATS_PERIOD=1"
|
||||
"MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW=1"
|
||||
"MOBILEGL_LOG_FILE_PATH=${mglD2Log}"
|
||||
${MGL_ITEST_CAPABILITY_ENV} ${MGL_ITEST_COMMON_ENV})
|
||||
get_filename_component(mglD2LogName "${mglD2Log}" NAME)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectGLES.${mglD2Arm}.TextureUploadShape."
|
||||
TEST_FILTER "${MGL_D2_TUS_FILTER}"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES
|
||||
LABELS "integration-gpu\;integration-${mglD2ArmLower}"
|
||||
TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
RESOURCE_LOCK "${mglD2LogName}"
|
||||
${mglD2Extra}
|
||||
ENVIRONMENT "${MGL_D2_TUS_ENV_${mglD2Arm}}"
|
||||
)
|
||||
endforeach()
|
||||
|
||||
# The split half of the counting pair. MGITEST_PERSISTENT_MAP_ARM=emulated is R-6: under split
|
||||
# the adopt tier is pinned at T2, the resource owner declines every acquisition and the client
|
||||
# pushes the mapping's dirty blocks - so pmap must be non-zero and mpr must be the monolith
|
||||
|
||||
@@ -177,6 +177,37 @@ namespace MGITest::PipeStatsWindow {
|
||||
return Last(ReadLaneLog());
|
||||
}
|
||||
|
||||
// ---- ONE ROLE AT A TIME, and P3b/P4b wave 2-D package D2 is why it had to exist -----------
|
||||
//
|
||||
// LastFromLaneLog() concatenates and takes the LAST window, which is the right answer for a
|
||||
// counter only ONE role ever increments. It is the wrong answer for a claim that compares two
|
||||
// roles' readings of the SAME records - TextureUploadShape's `tex[emit=]` (the server's) and
|
||||
// `ctu=` (the client's) - because under SPAWN and TCP the two roles are two PROCESSES with two
|
||||
// independent sets of counters. The client's line then carries `ctu=N tex[emit=0]` and the
|
||||
// server's carries `ctu=0 tex[emit=N]`, and whichever line happens to be last answers BOTH
|
||||
// questions with one role's numbers. The comparison silently becomes `N == 0` or `0 == N`.
|
||||
//
|
||||
// Under INPROC it happens to work either way - one process, one set of atomic counters, two
|
||||
// log FILES - and that is exactly why this had to be written against the spawn shape rather
|
||||
// than discovered by reading the inproc lane.
|
||||
//
|
||||
// Both return `found == false` where that role has no log (the pull build has no server half;
|
||||
// a lane that configured no MOBILEGL_LOG_FILE_PATH has neither), which a caller must treat as
|
||||
// "could not look" rather than as a zero.
|
||||
inline Window LastFromClientLog() {
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
MGPipeSyncPeerLog();
|
||||
#endif
|
||||
return Last(ReadWholeFile(LibraryLogPath()));
|
||||
}
|
||||
|
||||
inline Window LastFromServerLog() {
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
MGPipeSyncPeerLog();
|
||||
#endif
|
||||
return Last(ReadWholeFile(ServerLibraryLogPath()));
|
||||
}
|
||||
|
||||
// One counter out of that line, by its short name ("mpr", "draws", "csom"), or -1 when the
|
||||
// line does not carry it. The search includes the SEPARATOR before the name and the `=` after
|
||||
// it, so "draws" cannot match "draws/f=" and "mpr" cannot match a longer name ending in it -
|
||||
|
||||
@@ -6,55 +6,76 @@
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
//
|
||||
// Scenario - THE TEXTURE UPLOAD SHAPE, RECORDED (BRIEF-P4A.md D-D4). NOT A GATE IN P4a.
|
||||
// Scenario - THE TEXTURE UPLOAD SHAPE, GATED (BRIEF-P4A.md D-D4; P3b/P4b R-11, wave 2-D).
|
||||
//
|
||||
// WHAT IT IS FOR. SSIM is completely blind to the difference between "one union box" and "N
|
||||
// separate rects", and that difference is the Mali upload cliff: Mali prices an upload by the
|
||||
// number of JOBS, and ~100 one-rect sprite jobs against one union box measured +6 ms/frame
|
||||
// (ARCHITECTURE.md:249-251). Every P4a gate can be green while the emission shape has silently
|
||||
// inverted, so the shape needs a number - and there are TWO numbers, deliberately:
|
||||
// (ARCHITECTURE.md:249-251). Every gate in the phase can be green while the emission shape has
|
||||
// silently inverted, so the shape needs a number - and there are TWO numbers, deliberately:
|
||||
//
|
||||
// tex[emit= box= rect= jobs=] the SERVER's count, Espryt's own, which has existed since P2
|
||||
// emit[ctu=] the CLIENT's count of the same records (CallClass::
|
||||
// ClientTextureUploadEmissions, minted by the P4a contract commit)
|
||||
// ClientTextureUploadEmissions)
|
||||
//
|
||||
// The two agreeing is the whole reason both are printed (D-L). An emission-shape divergence between
|
||||
// the client that decides the rect model and the server that pays the GPU cost is then a difference
|
||||
// of two published numbers rather than something only a device can see.
|
||||
// The two agreeing is the whole reason both are printed (D-L). An emission-shape divergence
|
||||
// between the client that decides the rect model and the server that pays the GPU cost is then a
|
||||
// difference of two published numbers rather than something only a device can see.
|
||||
//
|
||||
// WHY IT IS RECORDED AND NOT GATED, and this is a scope decision rather than a hedge. ROADMAP.md:23
|
||||
// puts "dirty 归属反转(按存储属主键控的发射游标)" in the P3b/P4b cell: P4a lands the flat drain
|
||||
// list, and the per-storage-owner emission cursor with view/owner index remapping - which is what
|
||||
// actually decides the shape for a texture uploaded through a VIEW - is the next phase's. Gating a
|
||||
// shape the phase has not finished deciding would either pin today's shape as if it were the
|
||||
// answer, or fail on a change that is the point of the next phase. So P4a BUILDS the scenario (it
|
||||
// is meaningless without P4a's records) and runs it as a RECORDED comparison; P3b/P4b turns it into
|
||||
// a gate with the Mali frame-time delta published beside it (D-D4).
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
// WHY IT IS A GATE NOW, AND WHAT CHANGED SINCE P4a. The P4a header said, correctly for its tree:
|
||||
// "the per-storage-owner emission cursor with view/owner index remapping - which is what actually
|
||||
// decides the shape for a texture uploaded through a VIEW - is the next phase's", and gating a
|
||||
// shape the phase had not finished deciding would have pinned a non-answer. THAT WORK LANDED:
|
||||
// the cursor is keyed on the storage owner (TextureEmit.h's drain list), the remap is
|
||||
// TextureObjectView::ToOwner*, and TextureViewAliasScenario is its behavioural gate. So the
|
||||
// numbers are no longer provisional and the RecordProperty block became EXPECT_EQ against the
|
||||
// table below.
|
||||
//
|
||||
// WHAT IT THEREFORE ASSERTS, and it is not nothing:
|
||||
// THE CLIENT EMITTER LANDED TOO, and three places in the tree said otherwise until this commit:
|
||||
// this header, the CMake probe's comment, and notes/p4a/p4a-results/gates-v1.md's re-run table.
|
||||
// MG_Impl/Pipe/TextureEmit.h's EmitOneLevel increments CallClass::ClientTextureUploadEmissions on
|
||||
// every piece it emits, so `ctu=` is a live reading and `ctu == emit` is a live assertion. The
|
||||
// CMake probe's `else()` arm is kept - it is what makes the arming decision falsifiable - but it
|
||||
// is unreachable on this tree.
|
||||
//
|
||||
// THE MALI FRAME-TIME DELTA IS NOT PUBLISHED BESIDE THESE NUMBERS AND WILL NOT BE IN THIS PHASE.
|
||||
// D-D4 asks for the +6 ms/frame reading next to the shape gold. It is NOT SCHEDULABLE: the phase
|
||||
// has one device, a Redmi with an Adreno, and no Mali part at all. Recorded as a DECLARED
|
||||
// DEVIATION here and in docs/Disaggregated/MEASUREMENTS.md ("Adreno-only; Mali delta deferred")
|
||||
// rather than faked from a model or copied from the 2026 measurement's conditions. What the gate
|
||||
// therefore pins is the SHAPE, on the reasoning that the shape is the cliff's cause and the frame
|
||||
// time is its consequence on one vendor's hardware.
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
//
|
||||
// WHAT IT ASSERTS:
|
||||
//
|
||||
// 1. the numbers could be READ AT ALL - the counters exist, the window covers the workload, and
|
||||
// the workload really uploaded (a run that uploaded nothing would record four zeroes and look
|
||||
// the workload really uploaded (a run that uploaded nothing would read four zeroes and look
|
||||
// exactly like a healthy run whose emitter had been switched off);
|
||||
// 2. the internal ARITHMETIC of the server's own bracket holds: emit == box + rect, and
|
||||
// jobs >= emit, because a box emission is one job and a rect-list emission is N;
|
||||
// 3. the client and the server agree on the RECORD COUNT when both are non-zero (ctu == emit).
|
||||
// Not "when the client is non-zero": on the P4a contract tree the client emits nothing and
|
||||
// that is a SKIP-shaped observation, not a divergence.
|
||||
// 3. the client and the server agree on the RECORD COUNT (ctu == emit);
|
||||
// 4. THE GOLD TABLE: emit / box / rect / jobs are exactly kGold's, which is the assertion the
|
||||
// other three cannot make - they are all satisfied by a shape that inverted wholesale.
|
||||
//
|
||||
// Everything else - which shape each texture took, and whether that is the right shape - is
|
||||
// RECORDED with RecordProperty and printed, for MEASUREMENTS.md and for the P3b/P4b gate to be
|
||||
// written against.
|
||||
//
|
||||
// THE WORKLOAD is the shape the decision is about: one texture receiving MANY SMALL SCATTERED
|
||||
// SUB-REGIONS per frame (the sprite-atlas / chunk-renderer shape), and one receiving a single large
|
||||
// contiguous one. The first is where the box-versus-rect choice is made - MipmapStorage's 96-rect
|
||||
// cascade and the summedArea*4 >= unionArea*3 union-box fallback - and the second is the control
|
||||
// that must always be one box whatever the policy is.
|
||||
// THE WORKLOAD is the shape the decision is about, in three textures:
|
||||
// * MANY SMALL SCATTERED SUB-REGIONS per frame (the sprite-atlas / chunk-renderer shape). This
|
||||
// is where the box-versus-rect choice is made - MipmapStorage's 96-rect cascade and the
|
||||
// summedArea*4 >= unionArea*3 union-box fallback;
|
||||
// * one large CONTIGUOUS region, the control that must always be one box whatever the policy is;
|
||||
// * the same scattered pattern written THROUGH A glTextureView of the third texture's level 1,
|
||||
// so the view/owner index remap is inside the counted window. Without it the gold table would
|
||||
// pin a shape for exactly the input the P3b/P4b work changed and say nothing about the input
|
||||
// it changed it for.
|
||||
//
|
||||
// DIRECTGLES ONLY. The server-side counters are Espryt's (Managers.cpp:6360-6395); Magma's upload
|
||||
// path is P7 and contributes nothing to them, so a DirectVulkan lane would record a bracket of
|
||||
// zeroes and call it a shape.
|
||||
//
|
||||
// VIEWS ARE OPT-IN ON ESPRYT, so every lane that runs this case sets
|
||||
// MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW=1. A lane without it SKIPS rather than dropping the third
|
||||
// texture: a conditional workload behind a fixed gold table is a gate that passes by shrinking.
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
@@ -66,6 +87,7 @@
|
||||
#include "../Harness/PipeStatsWindow.h"
|
||||
#include "../Harness/ScenarioFixture.h"
|
||||
#include "../Harness/SplitRuntimePeek.h"
|
||||
#include "../Harness/TextureEmitPeek.h"
|
||||
|
||||
#ifdef GLAPI
|
||||
#undef GLAPI
|
||||
@@ -78,8 +100,8 @@
|
||||
namespace MGITest {
|
||||
namespace {
|
||||
|
||||
// Set by the TextureUploadShape. ctest entry and by nothing else; a harness marker, never
|
||||
// read by the library.
|
||||
// Set by the TextureUploadShape. ctest entries and by nothing else; a harness marker,
|
||||
// never read by the library.
|
||||
constexpr const char* kLaneMarker = "MGITEST_TEXTURE_UPLOAD_SHAPE_LANE";
|
||||
|
||||
constexpr int kInset = 2;
|
||||
@@ -91,6 +113,47 @@ namespace MGITest {
|
||||
constexpr int kScatteredRects = 40;
|
||||
constexpr int kRectSize = 2;
|
||||
constexpr int kFrames = 3;
|
||||
// The viewed texture's OWNER is twice the atlas so that its level 1 - which is what the
|
||||
// view opens onto - is exactly kAtlasSize and the same scattered pattern applies to it.
|
||||
constexpr int kViewedOwnerSize = kAtlasSize * 2;
|
||||
constexpr int kViewedOwnerLevels = 2;
|
||||
constexpr int kViewMinLevel = 1;
|
||||
|
||||
// ---- THE GOLD TABLE -------------------------------------------------------------------
|
||||
//
|
||||
// MEASURED ON THIS CURSOR, not inherited. The P4a record for the two-texture workload was
|
||||
// `emit=6 box=6 rect=0 jobs=6` with `ctu=0`; this row is the three-texture workload's own
|
||||
// reading taken after the client emitter and the owner-keyed cursor landed, and the P4a
|
||||
// numbers are quoted only so that a reader can see they are not the same claim.
|
||||
//
|
||||
// KEYED ON THE WORKLOAD CONSTANTS, and the static_assert below is the key: change
|
||||
// kScatteredRects, kFrames, the number of contiguous bands or the number of textures and
|
||||
// these numbers describe a workload that no longer exists. The assert makes that a compile
|
||||
// error rather than a mysterious red.
|
||||
//
|
||||
// WHY box IS THE WHOLE OF emit ON THIS TREE. GetDirtyRects (MipmapStorage.cpp:430-457)
|
||||
// hands the emitter a rect list only when the list has 2..maxRects entries AND the rects'
|
||||
// summed area is under 3/4 of the union box. This workload's rects are spread on a coarse
|
||||
// stride and the cascade merges every pair that touches, so the emitter takes the box arm
|
||||
// for all three textures in all three frames. That is the SHAPE being pinned: a change
|
||||
// that starts emitting rect lists here is exactly the +6 ms/frame inversion, and it is
|
||||
// what the red-once for this gate produces on purpose.
|
||||
struct UploadShapeGold {
|
||||
long long Emissions;
|
||||
long long BoxEmissions;
|
||||
long long RectEmissions;
|
||||
long long Jobs;
|
||||
};
|
||||
constexpr int kTexturesInTheWindow = 3;
|
||||
constexpr UploadShapeGold kGold{9, 9, 0, 9};
|
||||
static_assert(kScatteredRects == 40 && kFrames == 3 && kTexturesInTheWindow == 3,
|
||||
"the gold table is keyed on the workload constants: re-measure before "
|
||||
"changing kScatteredRects, kFrames or the texture count");
|
||||
static_assert(kGold.Emissions == kGold.BoxEmissions + kGold.RectEmissions,
|
||||
"the gold row must itself satisfy the arithmetic the case asserts");
|
||||
static_assert(kGold.Emissions == kTexturesInTheWindow * kFrames,
|
||||
"one emission per texture per frame is the shape; a gold row that does not "
|
||||
"say so is pinning an accident");
|
||||
|
||||
constexpr const char* kVS = R"(#version 330 core
|
||||
in vec2 aPos;
|
||||
@@ -146,6 +209,8 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
if (m_scattered != 0) glDeleteTextures(1, &m_scattered);
|
||||
if (m_contiguous != 0) glDeleteTextures(1, &m_contiguous);
|
||||
if (m_view != 0) glDeleteTextures(1, &m_view);
|
||||
if (m_viewedOwner != 0) glDeleteTextures(1, &m_viewedOwner);
|
||||
if (m_vao != 0) glDeleteVertexArrays(1, &m_vao);
|
||||
if (m_quadBuffer != 0) glDeleteBuffers(1, &m_quadBuffer);
|
||||
if (m_program != 0) glDeleteProgram(m_program);
|
||||
@@ -184,6 +249,46 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
"PipeStats";
|
||||
return;
|
||||
}
|
||||
if (!TextureViewUsable()) {
|
||||
// A SKIP AND NOT A SMALLER WORKLOAD. The gold table has one row; dropping the
|
||||
// third texture here would leave a case that asserts emit==9 against a
|
||||
// six-emission workload, i.e. a gate that fails for the wrong reason - or,
|
||||
// worse, a second gold row that nobody re-measures.
|
||||
GTEST_SKIP() << "GL_ARB_texture_view is not advertised on this backend, so the "
|
||||
"third texture - the one whose upload goes through a "
|
||||
"glTextureView, which is the input the P3b/P4b emission cursor "
|
||||
"work changed - cannot be built. Every lane this case is "
|
||||
"registered in sets MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW=1.";
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
bool TextureViewUsable() {
|
||||
GLuint storage = 0;
|
||||
glGenTextures(1, &storage);
|
||||
glBindTexture(GL_TEXTURE_2D, storage);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
GLuint view = 0;
|
||||
glGenTextures(1, &view);
|
||||
while (glGetError() != GL_NO_ERROR) {
|
||||
}
|
||||
glTextureView(view, GL_TEXTURE_2D, storage, GL_RGBA8, 0, 1, 0, 1);
|
||||
const bool usable = glGetError() == GL_NO_ERROR;
|
||||
glDeleteTextures(1, &view);
|
||||
glDeleteTextures(1, &storage);
|
||||
return usable;
|
||||
}
|
||||
|
||||
static std::vector<std::uint8_t> GreenTexels(int width, int height) {
|
||||
std::vector<std::uint8_t> texels(static_cast<std::size_t>(width) * height * 4);
|
||||
for (std::size_t i = 0; i < texels.size(); i += 4) {
|
||||
texels[i] = 0;
|
||||
texels[i + 1] = 255;
|
||||
texels[i + 2] = 0;
|
||||
texels[i + 3] = 255;
|
||||
}
|
||||
return texels;
|
||||
}
|
||||
|
||||
GLuint MakeAtlas(std::uint8_t r, std::uint8_t g, std::uint8_t b) {
|
||||
@@ -206,6 +311,57 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
return texture;
|
||||
}
|
||||
|
||||
// The third texture's OWNER: immutable, two levels, seeded green on both. glTextureView
|
||||
// requires immutable storage, so this one cannot be a MakeAtlas.
|
||||
GLuint MakeViewedOwner() {
|
||||
GLuint texture = 0;
|
||||
glGenTextures(1, &texture);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexStorage2D(GL_TEXTURE_2D, kViewedOwnerLevels, GL_RGBA8, kViewedOwnerSize,
|
||||
kViewedOwnerSize);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
for (int level = 0; level < kViewedOwnerLevels; ++level) {
|
||||
const int size = kViewedOwnerSize >> level;
|
||||
const std::vector<std::uint8_t> green = GreenTexels(size, size);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, level, 0, 0, size, size, GL_RGBA, GL_UNSIGNED_BYTE,
|
||||
green.data());
|
||||
}
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
return texture;
|
||||
}
|
||||
|
||||
// A view of the owner's LEVEL 1, which is kAtlasSize square: the view's own level 0.
|
||||
// Every glTexSubImage2D through this name has to be remapped to the owner's level 1 by
|
||||
// TextureObjectView::ToOwnerLevel before it reaches the drain list, and the emission it
|
||||
// produces has to land on the OWNER's cursor.
|
||||
GLuint MakeLevelView(GLuint owner) {
|
||||
GLuint view = 0;
|
||||
glGenTextures(1, &view);
|
||||
glTextureView(view, GL_TEXTURE_2D, owner, GL_RGBA8, kViewMinLevel, 1, 0, 1);
|
||||
EXPECT_EQ(glGetError(), static_cast<GLenum>(GL_NO_ERROR))
|
||||
<< "a single-level 2D view of a 2D texture is a legal view pair";
|
||||
glBindTexture(GL_TEXTURE_2D, view);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
return view;
|
||||
}
|
||||
|
||||
void ScatterRectsInto(GLuint texture) {
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
const std::uint8_t patch[kRectSize * kRectSize * 4] = {
|
||||
0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255};
|
||||
for (int rect = 0; rect < kScatteredRects; ++rect) {
|
||||
const int x = ((rect * 7) % (kAtlasSize / kRectSize)) * kRectSize;
|
||||
const int y = ((rect * 5) % (kAtlasSize / kRectSize)) * kRectSize;
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, kRectSize, kRectSize, GL_RGBA,
|
||||
GL_UNSIGNED_BYTE, patch);
|
||||
}
|
||||
}
|
||||
|
||||
Image DrawSampled(GLuint texture) {
|
||||
BindDefaultFramebuffer();
|
||||
glViewport(0, 0, Gl().Width(), Gl().Height());
|
||||
@@ -223,6 +379,8 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
GLuint m_quadBuffer = 0;
|
||||
GLuint m_scattered = 0;
|
||||
GLuint m_contiguous = 0;
|
||||
GLuint m_viewedOwner = 0;
|
||||
GLuint m_view = 0;
|
||||
};
|
||||
|
||||
TEST_F(TextureUploadShapeScenario, TheEmittedUploadShapeIsRecordedAndTheTwoSidesAgree) {
|
||||
@@ -232,10 +390,13 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
|
||||
m_scattered = MakeAtlas(0, 255, 0);
|
||||
m_contiguous = MakeAtlas(0, 255, 0);
|
||||
m_viewedOwner = MakeViewedOwner();
|
||||
m_view = MakeLevelView(m_viewedOwner);
|
||||
// The first draw of each texture uploads its whole level, which is not the shape this
|
||||
// scenario is about; it happens in the SETUP window, before the one that is read.
|
||||
DrawSampled(m_scattered);
|
||||
DrawSampled(m_contiguous);
|
||||
DrawSampled(m_view);
|
||||
BindDefaultFramebuffer();
|
||||
Gl().EndFrame();
|
||||
// The server closes/resets the stats window inside Present. Under
|
||||
@@ -247,118 +408,220 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
}
|
||||
|
||||
// ---- the counted window ----
|
||||
//
|
||||
// THE CLIENT HALF IS READ FROM THE EMITTER, NOT FROM ctu=, and that is a correction
|
||||
// this package had to make rather than a preference. MEASURED on all four arms:
|
||||
//
|
||||
// monolith one role, one log: the window line carries tex[emit=9] AND ctu=9.
|
||||
// inproc two log FILES, one process, one set of counters: the SERVER's line
|
||||
// carries both, and the client's log holds only the "counters ON" banner
|
||||
// at the moment this case reads it.
|
||||
// spawn/tcp two PROCESSES with two counter sets. The server's line carries
|
||||
// tex[emit=9] ctu=0; the client process emits its own summary on a
|
||||
// DIFFERENT Present cadence and had written only the banner by the time
|
||||
// this case reads - and when it does write one, its window covers the
|
||||
// setup emissions too (measured ctu=13 against emit=9), so the two
|
||||
// numbers are not windowed on the same work and `ctu == emit` is not a
|
||||
// well-posed comparison there at all.
|
||||
//
|
||||
// So the log's ctu= is kept as a RECORD (printed, and asserted where it is
|
||||
// window-aligned) and the ASSERTION reads MGPipeTextureEmitter's own counter through
|
||||
// the in-process peek. That is the same counter's SOURCE - EmitOneLevel increments
|
||||
// both on the same line - and the test process is the CLIENT under every one of
|
||||
// monolith / inproc / spawn / tcp, so the delta below is the client's true count of
|
||||
// the records this workload produced, in every arm. D-L asks for the two sides to
|
||||
// agree; this is what makes that a real question outside monolith.
|
||||
TextureEmitCountersPeek emitBefore{};
|
||||
const bool emitPeekLive = PeekTextureEmitCounters(&emitBefore);
|
||||
|
||||
Image lastScattered;
|
||||
Image lastContiguous;
|
||||
Image lastViewed;
|
||||
for (int frame = 0; frame < kFrames; ++frame) {
|
||||
// MANY SMALL SCATTERED RECTS: the shape whose box-versus-rect decision is the whole
|
||||
// subject. They are spread over the atlas on a coarse stride so that their union
|
||||
// box is most of the texture and their summed area is a small fraction of it -
|
||||
// which is the input the summedArea*4 >= unionArea*3 fallback is written for.
|
||||
glBindTexture(GL_TEXTURE_2D, m_scattered);
|
||||
const std::uint8_t patch[kRectSize * kRectSize * 4] = {
|
||||
0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255};
|
||||
for (int rect = 0; rect < kScatteredRects; ++rect) {
|
||||
const int x = ((rect * 7) % (kAtlasSize / kRectSize)) * kRectSize;
|
||||
const int y = ((rect * 5) % (kAtlasSize / kRectSize)) * kRectSize;
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, kRectSize, kRectSize, GL_RGBA,
|
||||
GL_UNSIGNED_BYTE, patch);
|
||||
}
|
||||
ScatterRectsInto(m_scattered);
|
||||
lastScattered = DrawSampled(m_scattered);
|
||||
|
||||
// ONE LARGE CONTIGUOUS REGION: the control. Whatever the policy is, this is one
|
||||
// box and one job, and a reading where it is not says the policy has stopped
|
||||
// looking at the region at all.
|
||||
glBindTexture(GL_TEXTURE_2D, m_contiguous);
|
||||
std::vector<std::uint8_t> band(static_cast<std::size_t>(kAtlasSize) * 8 * 4);
|
||||
for (std::size_t i = 0; i < band.size(); i += 4) {
|
||||
band[i] = 0;
|
||||
band[i + 1] = 255;
|
||||
band[i + 2] = 0;
|
||||
band[i + 3] = 255;
|
||||
}
|
||||
const std::vector<std::uint8_t> band = GreenTexels(kAtlasSize, 8);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kAtlasSize, 8, GL_RGBA, GL_UNSIGNED_BYTE,
|
||||
band.data());
|
||||
lastContiguous = DrawSampled(m_contiguous);
|
||||
|
||||
// THE SAME SCATTERED PATTERN THROUGH A VIEW. The writes name the view's level 0;
|
||||
// the drain has to key them on the OWNER at the owner's level 1, and the shape the
|
||||
// emitter then chooses has to be the same one the owner's own name would have got.
|
||||
// A cursor that keyed on the view would show up here as a DIFFERENT emit count,
|
||||
// not as a wrong picture.
|
||||
ScatterRectsInto(m_view);
|
||||
lastViewed = DrawSampled(m_view);
|
||||
}
|
||||
ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "the upload workload left a GL error behind";
|
||||
TextureEmitCountersPeek emitAfter{};
|
||||
const bool emitPeekClosed = emitPeekLive && PeekTextureEmitCounters(&emitAfter);
|
||||
Gl().EndFrame(); // the swap that emits the window covering exactly the work above
|
||||
if (const auto runtime = PeekSplitRuntime(); runtime.transportResolved) {
|
||||
ASSERT_TRUE(runtime.sessionActive);
|
||||
ASSERT_TRUE(WaitForSplitAppliedForTesting(runtime.emitSeq));
|
||||
}
|
||||
|
||||
const PipeStatsWindow::Window window = PipeStatsWindow::LastFromLaneLog();
|
||||
ASSERT_TRUE(window.found)
|
||||
// ---- READING TWO ROLES, NOT ONE LINE --------------------------------------------
|
||||
//
|
||||
// Under SPAWN and TCP the client and the server are two PROCESSES with two independent
|
||||
// sets of counters: the client's summary line carries `ctu=N tex[emit=0]` and the
|
||||
// server's carries `ctu=0 tex[emit=N]`. A single concatenated read takes whichever line
|
||||
// came last and answers BOTH questions with one role's numbers, which turns the
|
||||
// two-sided comparison into `N == 0`. So each side is read from ITS OWN role's log, and
|
||||
// the server bracket falls back to the client log only where there is no server half -
|
||||
// the pull build and the monolith lane, where one file IS the whole run.
|
||||
const PipeStatsWindow::Window clientWindow = PipeStatsWindow::LastFromClientLog();
|
||||
const PipeStatsWindow::Window serverWindow = PipeStatsWindow::LastFromServerLog();
|
||||
ASSERT_TRUE(clientWindow.found)
|
||||
<< "no 'MGPipe stats:' line in " << PipeStatsWindow::LibraryLogPath()
|
||||
<< ", so the shape could not be read at all";
|
||||
RecordProperty("stats_line", window.line.c_str());
|
||||
const PipeStatsWindow::Window& shapeWindow =
|
||||
(serverWindow.found && PipeStatsWindow::CounterOrAbsent(serverWindow, "emit") > 0)
|
||||
? serverWindow
|
||||
: clientWindow;
|
||||
RecordProperty("stats_line_client", clientWindow.line.c_str());
|
||||
if (serverWindow.found) RecordProperty("stats_line_server", serverWindow.line.c_str());
|
||||
|
||||
const long long emissions = PipeStatsWindow::CounterOrAbsent(window, "emit");
|
||||
const long long box = PipeStatsWindow::CounterOrAbsent(window, "box");
|
||||
const long long rect = PipeStatsWindow::CounterOrAbsent(window, "rect");
|
||||
const long long jobs = PipeStatsWindow::CounterOrAbsent(window, "jobs");
|
||||
const long long clientEmissions = PipeStatsWindow::CounterOrAbsent(window, "ctu");
|
||||
ASSERT_GE(emissions, 0) << "the summary line carries no tex[emit=]: " << window.line;
|
||||
ASSERT_GE(box, 0) << "no box=: " << window.line;
|
||||
ASSERT_GE(rect, 0) << "no rect=: " << window.line;
|
||||
ASSERT_GE(jobs, 0) << "no jobs=: " << window.line;
|
||||
const long long emissions = PipeStatsWindow::CounterOrAbsent(shapeWindow, "emit");
|
||||
const long long box = PipeStatsWindow::CounterOrAbsent(shapeWindow, "box");
|
||||
const long long rect = PipeStatsWindow::CounterOrAbsent(shapeWindow, "rect");
|
||||
const long long jobs = PipeStatsWindow::CounterOrAbsent(shapeWindow, "jobs");
|
||||
// The log's ctu=, from whichever role's window carries it. Under monolith and inproc
|
||||
// that is the same window the tex[] bracket came from; under spawn and tcp it is a
|
||||
// different process's differently-windowed counter, so it is RECORDED and only
|
||||
// asserted where the two are window-aligned (see the note over the counted window).
|
||||
const long long shapeWindowCtu = PipeStatsWindow::CounterOrAbsent(shapeWindow, "ctu");
|
||||
const long long clientWindowCtu = PipeStatsWindow::CounterOrAbsent(clientWindow, "ctu");
|
||||
// ALIGNED IS A PROPERTY OF THE TRANSPORT, NOT OF THE NUMBER, and asking the number
|
||||
// was this case's first mistake: `shapeWindowCtu >= 0` is TRUE under spawn, where the
|
||||
// server's line publishes a perfectly readable ctu=0 that belongs to a process which
|
||||
// emitted nothing, and the comparison became 0 == 9. Asking the process which
|
||||
// transport it resolved cannot be satisfied by a counter that happens to read zero -
|
||||
// and a single-process arm whose ctu= really did collapse to 0 still reds, which is
|
||||
// the failure the alignment check must not swallow.
|
||||
const SplitRuntimeState statsRuntime = PeekSplitRuntime();
|
||||
const bool oneProcessForCounters =
|
||||
!statsRuntime.transportResolved || statsRuntime.transportName == "inproc";
|
||||
const bool ctuIsWindowAligned = oneProcessForCounters && shapeWindowCtu >= 0;
|
||||
const long long clientEmissions =
|
||||
emitPeekClosed
|
||||
? static_cast<long long>(emitAfter.SubDataCount - emitBefore.SubDataCount)
|
||||
: shapeWindowCtu;
|
||||
ASSERT_GE(emissions, 0) << "the summary line carries no tex[emit=]: " << shapeWindow.line;
|
||||
ASSERT_GE(box, 0) << "no box=: " << shapeWindow.line;
|
||||
ASSERT_GE(rect, 0) << "no rect=: " << shapeWindow.line;
|
||||
ASSERT_GE(jobs, 0) << "no jobs=: " << shapeWindow.line;
|
||||
|
||||
// THE RECORD. This is the deliverable of this scenario in P4a: a number, in the ctest
|
||||
// XML and in the log, for MEASUREMENTS.md and for the P3b/P4b gate to be written
|
||||
// against. Printed as well as recorded, because a RecordProperty is invisible in a
|
||||
// console run.
|
||||
std::cout << "[ TextureUploadShape ] backend=" << Gl().BackendName() << " frames=" << kFrames
|
||||
<< " scattered_rects_per_frame=" << kScatteredRects
|
||||
<< " textures=" << kTexturesInTheWindow
|
||||
<< " server[emit=" << emissions << " box=" << box << " rect=" << rect
|
||||
<< " jobs=" << jobs << "] client[ctu=" << clientEmissions << "]" << std::endl;
|
||||
<< " jobs=" << jobs << "] client[emitter=" << clientEmissions
|
||||
<< " ctu_shape_window=" << shapeWindowCtu
|
||||
<< " ctu_client_window=" << clientWindowCtu << "]" << std::endl;
|
||||
RecordProperty("ctu_shape_window", static_cast<int>(shapeWindowCtu));
|
||||
RecordProperty("ctu_client_window", static_cast<int>(clientWindowCtu));
|
||||
RecordProperty("ctu_is_window_aligned", ctuIsWindowAligned ? 1 : 0);
|
||||
RecordProperty("server_emissions", static_cast<int>(emissions));
|
||||
RecordProperty("server_box_emissions", static_cast<int>(box));
|
||||
RecordProperty("server_rect_emissions", static_cast<int>(rect));
|
||||
RecordProperty("server_upload_jobs", static_cast<int>(jobs));
|
||||
RecordProperty("client_emissions", static_cast<int>(clientEmissions));
|
||||
|
||||
// 1. the workload really uploaded. Without this the three assertions below are all
|
||||
// 0 == 0 and a run whose emitter was switched off records the same "healthy" shape
|
||||
// as one that worked.
|
||||
// 1. the workload really uploaded. Without this the assertions below are all 0 == 0 and
|
||||
// a run whose emitter was switched off records the same "healthy" shape as one that
|
||||
// worked.
|
||||
ASSERT_GT(emissions, 0)
|
||||
<< "the server counted no texture upload emission at all over " << kFrames
|
||||
<< " frames of " << kScatteredRects
|
||||
<< " sub-regions each plus a contiguous band. Either the uploads never reached the "
|
||||
"backend or the counter stopped counting; in both cases every shape number below "
|
||||
"would be a zero that means nothing. "
|
||||
<< window.line;
|
||||
<< " sub-regions each, plus a contiguous band and a view write. Either the uploads "
|
||||
"never reached the backend or the counter stopped counting; in both cases every "
|
||||
"shape number below would be a zero that means nothing. "
|
||||
<< shapeWindow.line;
|
||||
|
||||
// 2. the server bracket's own arithmetic.
|
||||
EXPECT_EQ(box + rect, emissions)
|
||||
<< "tex[box=] + tex[rect=] must be tex[emit=]: every emission takes exactly one of "
|
||||
"the two shapes. " << window.line;
|
||||
"the two shapes. " << shapeWindow.line;
|
||||
EXPECT_GE(jobs, emissions)
|
||||
<< "tex[jobs=] must be at least tex[emit=]: a box emission is one driver upload job "
|
||||
"and a rect-list emission is N. " << window.line;
|
||||
"and a rect-list emission is N. " << shapeWindow.line;
|
||||
|
||||
// 3. the two sides agree, WHEN THERE ARE TWO SIDES - and "there are two sides" is
|
||||
// 3. THE GOLD TABLE (R-11 / D-D4). This is the assertion the three around it cannot
|
||||
// make: emit == box + rect and jobs >= emit are both satisfied by a shape that
|
||||
// inverted wholesale from N boxes to N rect lists, which is the +6 ms/frame
|
||||
// direction on Mali and is invisible to SSIM.
|
||||
EXPECT_EQ(emissions, kGold.Emissions)
|
||||
<< "the emission COUNT moved. One resource_subdata per (storage owner, upload "
|
||||
"target, level) per frame is " << kTexturesInTheWindow << " textures x " << kFrames
|
||||
<< " frames = " << kGold.Emissions
|
||||
<< ". A count above this says a level is being emitted more than once per validate "
|
||||
"point - the two-cursor shape, if the extra one is the viewed texture; a count "
|
||||
"below says a level's record was dropped. " << shapeWindow.line;
|
||||
EXPECT_EQ(box, kGold.BoxEmissions)
|
||||
<< "the BOX/RECT split moved: " << box << " box emissions against a gold of "
|
||||
<< kGold.BoxEmissions << ". " << shapeWindow.line;
|
||||
EXPECT_EQ(rect, kGold.RectEmissions)
|
||||
<< "the BOX/RECT split moved: " << rect << " rect-list emissions against a gold of "
|
||||
<< kGold.RectEmissions
|
||||
<< ". This is the direction that costs ~+6 ms/frame on Mali (ARCHITECTURE.md:249-"
|
||||
"251): the driver is handed N upload jobs where it used to be handed one, and no "
|
||||
"SSIM case can see it. If this is intended, re-measure the row and say so in "
|
||||
"docs/Disaggregated/MEASUREMENTS.md. " << shapeWindow.line;
|
||||
EXPECT_EQ(jobs, kGold.Jobs)
|
||||
<< "the JOB count moved: " << jobs << " against a gold of " << kGold.Jobs
|
||||
<< ". Jobs are what Mali prices the upload by. " << shapeWindow.line;
|
||||
|
||||
// 4. the two sides agree, WHEN THERE ARE TWO SIDES - and "there are two sides" is
|
||||
// answered by the BUILD, not by the number (review F-m7).
|
||||
//
|
||||
// ctu= IS ALWAYS PRESENT IN A PUSH BUILD: PipeStats.cpp writes the field whether or
|
||||
// not anything ever incremented the counter, so `clientEmissions > 0` conflated
|
||||
// three different trees - "no client emitter exists", "the emitter exists and
|
||||
// emitted nothing", and "the counter was not published at all" - into one branch
|
||||
// that asserts nothing and prints a sentence that is only true of the first. Once
|
||||
// package B's texture emitter lands, an emitter that STOPPED emitting would read
|
||||
// exactly like no emitter at all and this case would have gone green over it, which
|
||||
// is the failure mode the whole scenario exists to make impossible.
|
||||
// that asserts nothing. So the discriminator is
|
||||
// MGITEST_PIPE_CLIENT_TEXTURE_UPLOAD_EMITTER_PRESENT, the build's own content probe
|
||||
// for a MG_Impl/Pipe source that emits CallClass::ClientTextureUploadEmissions.
|
||||
//
|
||||
// So the discriminator is MGITEST_PIPE_CLIENT_TEXTURE_UPLOAD_EMITTER_PRESENT, the
|
||||
// build's own content probe for a MG_Impl/Pipe source that emits
|
||||
// CallClass::ClientTextureUploadEmissions - the same mechanism as every other arming
|
||||
// decision in this package - and each side of it asserts something real.
|
||||
// THAT PROBE HITS ON THIS TREE: MG_Impl/Pipe/TextureEmit.h's EmitOneLevel increments
|
||||
// it on every piece. The else-arm below is retained because it is what makes the
|
||||
// arming decision falsifiable in both directions, not because it is reachable here.
|
||||
const bool clientEmitterExists =
|
||||
BuildMarkerIsSet("MGITEST_PIPE_CLIENT_TEXTURE_UPLOAD_EMITTER_PRESENT");
|
||||
ASSERT_GE(clientEmissions, 0)
|
||||
<< "the summary line carries no ctu= field at all, in a push build, where PipeStats "
|
||||
"publishes it unconditionally. The client half of the comparison cannot be read: "
|
||||
<< window.line;
|
||||
<< "the client half of the comparison could not be read at all. The in-process "
|
||||
"emitter peek "
|
||||
<< (emitPeekLive ? "opened but did not close" : TextureEmitPeekSkipReason())
|
||||
<< ", and no role's summary line carried a ctu= field either. client="
|
||||
<< clientWindow.line << " shape=" << shapeWindow.line;
|
||||
RecordProperty("client_emitter_present", clientEmitterExists ? 1 : 0);
|
||||
RecordProperty("client_half_source", emitPeekClosed ? "emitter peek" : "ctu= field");
|
||||
if (ctuIsWindowAligned) {
|
||||
// Where the two roles ARE one window, the published field must agree with the
|
||||
// emitter it is published from. A divergence here is PipeStats mis-publishing,
|
||||
// which is a different defect from an emission-shape divergence and has to stay
|
||||
// distinguishable from it.
|
||||
EXPECT_EQ(shapeWindowCtu, clientEmissions)
|
||||
<< "the published ctu= field and MGPipeTextureEmitter's own SubDataCount "
|
||||
"disagree in a window that covers the same work. EmitOneLevel increments "
|
||||
"both on the same line, so this is the counter's publication and not the "
|
||||
"emission shape. " << shapeWindow.line;
|
||||
} else {
|
||||
RecordProperty("ctu_note",
|
||||
"the client's summary window is not aligned with the server's in "
|
||||
"this arm (two processes, two Present cadences), so ctu= is "
|
||||
"recorded and the assertion reads the in-process emitter instead");
|
||||
}
|
||||
if (clientEmitterExists) {
|
||||
EXPECT_GT(clientEmissions, 0)
|
||||
<< "a MG_Impl/Pipe source emits CallClass::ClientTextureUploadEmissions on this "
|
||||
@@ -366,15 +629,18 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
<< " texture upload emissions for this workload, but the client counted NONE. An "
|
||||
"emitter that has stopped emitting reads exactly like no emitter at all in "
|
||||
"this field, which is why this case asks the build rather than the number. "
|
||||
<< window.line;
|
||||
<< clientWindow.line;
|
||||
EXPECT_EQ(clientEmissions, emissions)
|
||||
<< "the CLIENT counted " << clientEmissions
|
||||
<< " texture upload records and the SERVER counted " << emissions
|
||||
<< " for the same workload in the same window. The two counting the same records "
|
||||
"is the entire reason both are published (D-L): a divergence here is an "
|
||||
"emission-shape divergence that SSIM is blind to and that costs ~+6 ms/frame "
|
||||
"on Mali when it goes the wrong way. "
|
||||
<< window.line;
|
||||
"on Mali when it goes the wrong way. client=" << clientWindow.line
|
||||
<< " server=" << shapeWindow.line;
|
||||
EXPECT_EQ(clientEmissions, kGold.Emissions)
|
||||
<< "the client's own count against the gold row, so that a run where BOTH sides "
|
||||
"moved together is still red. " << clientWindow.line;
|
||||
} else {
|
||||
// Not merely "not asserted": on a tree with no client emitter the counter must be
|
||||
// ZERO, and a non-zero one would mean the probe is looking for the wrong symbol -
|
||||
@@ -385,12 +651,7 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
"tree, yet the client counted " << clientEmissions
|
||||
<< " of them. Something is incrementing that counter which this build's probe "
|
||||
"cannot see, so the probe is looking for the wrong symbol and this case's "
|
||||
"arming decision is unreliable in both directions. " << window.line;
|
||||
std::cout << "[ TextureUploadShape ] no P4a client emitter has landed on this tree "
|
||||
"(the build's ClientTextureUploadEmissions probe found none), so this "
|
||||
"run records the SERVER shape only and pins ctu=0. That is the expected "
|
||||
"reading on the contract tree and it is not a divergence."
|
||||
<< std::endl;
|
||||
"arming decision is unreliable in both directions. " << clientWindow.line;
|
||||
RecordProperty("client_side", "absent");
|
||||
}
|
||||
|
||||
@@ -402,6 +663,9 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
EXPECT_TRUE(RegionIsMostly(lastContiguous, kInset, lastContiguous.Width() - kInset, kInset,
|
||||
lastContiguous.Height() - kInset, "green", 0.0,
|
||||
"the contiguous-band atlas"));
|
||||
EXPECT_TRUE(RegionIsMostly(lastViewed, kInset, lastViewed.Width() - kInset, kInset,
|
||||
lastViewed.Height() - kInset, "green", 0.0,
|
||||
"the atlas written through a glTextureView"));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
Reference in New Issue
Block a user