mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-20 16:31:57 +09:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
a078b6bcee |
@@ -61,40 +61,15 @@ if ! grep -Eq '^lib/[^/]+/libMobileGL\.so$' <<<"$plugin_contents"; then
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# The render server is not trace-only: both flavors carry the control screen, the offscreen
|
||||
# service, the on-screen display activity, and (split native builds) the supervisor executable.
|
||||
# The plugin APK ships to users, so its build keeps the three components private (manifest
|
||||
# placeholder serverComponentsExported=false); only the debuggable trace APK exports them for adb.
|
||||
for component in ServerControlActivity MobileGLServerService MobileGLDisplayActivity; do
|
||||
require "$component" "$plugin_manifest" "plugin render server component ($component)"
|
||||
require "$component" "$trace_manifest" "trace render server component ($component)"
|
||||
done
|
||||
if [[ "${MOBILEGL_CI_DISAGGREGATED:-OFF}" == "ON" ]]; then
|
||||
trace_contents=$(unzip -Z1 "$trace_apk")
|
||||
for entry in "plugin:${plugin_contents}" "trace:${trace_contents}"; do
|
||||
if ! grep -Eq '^lib/[^/]+/libMobileGLServer\.so$' <<<"${entry#*:}"; then
|
||||
echo "::error::${entry%%:*} APK does not contain libMobileGLServer.so (both flavors ship the render server)" >&2
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
require 'top.mobilegl.plugin.trace' "$trace_manifest" 'trace package name'
|
||||
require 'top.mobilegl.plugin.TRACE_REPLAY' "$trace_manifest" 'trace replay action'
|
||||
if grep -Fq 'fclPlugin' <<<"$trace_manifest"; then
|
||||
echo '::error::Trace APK must not advertise renderer-plugin metadata' >&2
|
||||
exit 1
|
||||
fi
|
||||
# The trace APK IS a launchable app now: PostActivity (the POST self-test screen) is its
|
||||
# entry icon and the bottom navigation bar switches to the render server screen. What is
|
||||
# left of the old "no launcher" contract is the count - exactly ONE MAIN activity, so a
|
||||
# screen that accidentally grows a launcher entry (ServerControlActivity was one for a day)
|
||||
# reds here instead of shipping two icons.
|
||||
main_count=$(grep -Fc 'android.intent.action.MAIN' <<<"$trace_manifest")
|
||||
if [[ "$main_count" -ne 1 ]]; then
|
||||
echo "::error::Trace APK must expose exactly one launcher activity (PostActivity); found ${main_count} android.intent.action.MAIN" >&2
|
||||
if grep -Fq 'android.intent.action.MAIN' <<<"$trace_manifest"; then
|
||||
echo '::error::Trace APK must not expose a launcher activity' >&2
|
||||
exit 1
|
||||
fi
|
||||
require 'PostActivity' "$trace_manifest" 'trace launcher activity (PostActivity)'
|
||||
|
||||
echo 'Validated unified MobileGL plugin APK and isolated trace APK.'
|
||||
|
||||
@@ -2042,13 +2042,6 @@ jobs:
|
||||
"PersistentCoherentMapScenario.TwoWritesThroughTheCoherentPointerEachReachTheirOwnDraw",
|
||||
"PersistentCoherentMapScenario.AWriteAfterAFrameBoundaryReachesTheNextFramesDraw",
|
||||
"StorageBufferRegrowScenario.AGrownStoreIsVisibleThroughItsExistingIndexedBinding",
|
||||
# P11 A2: the >= 16 MiB arena and its tier assertion (emulated).
|
||||
"LargeArenaAdoptionScenario.SubDataAfterAnInFlightDrawReachesTheNextDraw",
|
||||
"LargeArenaAdoptionScenario.RespecifiedVertexArenaKeepsVaoBindings",
|
||||
"LargeArenaAdoptionScenario.RespecifiedIndexArenaKeepsVaoBinding",
|
||||
"LargeArenaAdoptionScenario.ReadbackSeesTheLatestCpuWrite",
|
||||
"LargeArenaAdoptionScenario.GpuWriteIntoTheArenaIsReadBack",
|
||||
"LargeArenaAdoptionScenario.TheArenaLandsInTheTierItsLaneDeclares",
|
||||
]
|
||||
slp.require_green(json.load(open(sys.argv[2])), sys.argv[3],
|
||||
["DirectVulkan.Split.Buffers." + name for name in cases])
|
||||
@@ -2111,12 +2104,6 @@ jobs:
|
||||
"PersistentCoherentMapScenario.TwoWritesThroughTheCoherentPointerEachReachTheirOwnDraw",
|
||||
"PersistentCoherentMapScenario.AWriteAfterAFrameBoundaryReachesTheNextFramesDraw",
|
||||
"StorageBufferRegrowScenario.AGrownStoreIsVisibleThroughItsExistingIndexedBinding",
|
||||
"LargeArenaAdoptionScenario.SubDataAfterAnInFlightDrawReachesTheNextDraw",
|
||||
"LargeArenaAdoptionScenario.RespecifiedVertexArenaKeepsVaoBindings",
|
||||
"LargeArenaAdoptionScenario.RespecifiedIndexArenaKeepsVaoBinding",
|
||||
"LargeArenaAdoptionScenario.ReadbackSeesTheLatestCpuWrite",
|
||||
"LargeArenaAdoptionScenario.GpuWriteIntoTheArenaIsReadBack",
|
||||
"LargeArenaAdoptionScenario.TheArenaLandsInTheTierItsLaneDeclares",
|
||||
]
|
||||
required = [sys.argv[4] + name for name in cases]
|
||||
if sys.argv[5] == "tcp":
|
||||
|
||||
@@ -28,4 +28,3 @@ tools/trace_replay/work/
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
/.gradle
|
||||
/.trace-work/
|
||||
|
||||
+1
-16
@@ -607,15 +607,9 @@ if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
MobileGL/MG_Remote/Transport/InProcessTransport.cpp
|
||||
MobileGL/MG_Remote/Transport/SocketTransport.cpp
|
||||
MobileGL/MG_Remote/Transport/ControlInbox.cpp
|
||||
# P9 W3: the server's log forward - a queue and a sender thread, graded by severity
|
||||
# (<= WARN lossy, >= ERROR lossless and paced), so no logging thread writes the socket.
|
||||
MobileGL/MG_Remote/Transport/LogForward.cpp
|
||||
# Keeps MG_Util/Debug/Log.h - and through it the GL frontend's
|
||||
# umbrella header - out of the header-only wire code (WireLog.h).
|
||||
MobileGL/MG_Remote/Transport/WireLog.cpp
|
||||
# P11 A1: the adopt tier settled at the handshake from the knob and the data plane, by
|
||||
# both roles (so SERVER-partition code in the link ratchet, not the client's tracker).
|
||||
MobileGL/MG_Remote/Transport/AdoptTier.cpp
|
||||
# ---- P5: the three new directories ------------------------------
|
||||
# Wire/ the G3 codec: MGPWireRec_* in and out of SEG_CMD, blobs and
|
||||
# var-tails in and out of SEG_STAGE. [w1]
|
||||
@@ -656,9 +650,6 @@ if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
MobileGL/MG_Remote/Server/PipeApplier.cpp
|
||||
MobileGL/MG_Remote/Server/ServerLoop.cpp
|
||||
MobileGL/MG_Remote/Server/ServerMain.cpp
|
||||
# P11 PAIR: a socket client's control and aux connections paired by the nonce each
|
||||
# presents first (PairBind), not by arrival order - both unix supervisors take pairs here.
|
||||
MobileGL/MG_Remote/Server/PairAcceptor.cpp
|
||||
MobileGL/MG_Remote/Server/ServerSpawn.cpp
|
||||
# P5f fc: the value frame that replaced the control mailbox's function-pointer payload,
|
||||
# and its codec against protocol.fbs's SurfaceOp/SurfaceReply (the spawn arm's seam).
|
||||
@@ -691,7 +682,7 @@ if (ANDROID)
|
||||
MobileGL/MG_Util/SelfTest/DriverBenchJni.cpp
|
||||
)
|
||||
if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
# P12 (on-screen server window): the APK's MobileGLDisplayActivity - the in-process
|
||||
# P12 (on-screen server window): the trace APK's MobileGLDisplayActivity - the in-process
|
||||
# display server's thread, its SurfaceView's ANativeWindow in and out of ServerDisplay, and
|
||||
# the geometry up-call. Split build only: nothing else has an in-process server to drive.
|
||||
list(APPEND SOURCE_FILES
|
||||
@@ -991,12 +982,6 @@ if (ANDROID AND MOBILEGL_BUILD_INTEGRATION_TEST)
|
||||
add_subdirectory(MobileGL/MG_IntegrationTest)
|
||||
endif()
|
||||
|
||||
# The replay runner also builds for Android: an adb-shell executable that can
|
||||
# dial a render server on the device (unix or TCP) without any Activity.
|
||||
if (ANDROID AND MOBILEGL_BUILD_TRACE_REPLAY)
|
||||
add_subdirectory(tools/trace_replay)
|
||||
endif()
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# P0 spike A: the Android delivery chain for a second native executable.
|
||||
#
|
||||
|
||||
+7
-38
@@ -132,18 +132,6 @@ namespace MobileGL::MG_Config {
|
||||
Bool MagmaR11G11B10FFallback = false;
|
||||
// MOBILEGL_MAGMA_FRAMESINFLIGHT: requested Magma frames in flight, defaulting to 3.
|
||||
Uint32 MagmaFramesInFlight = 3;
|
||||
// MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER: GL draws and dispatches Magma records into
|
||||
// one command buffer before it submits it and continues on a fresh one. 0 = unbounded.
|
||||
// Drivers back a command buffer with GPU memory that is only returned when the buffer is
|
||||
// freed; Adreno maps it into the process in 16 KiB chunks, so one ~1M-draw loading frame
|
||||
// exhausts vm.max_map_count. See VulkanRenderer::SplitOversizedRecording.
|
||||
Uint32 MagmaMaxDrawsPerCommandBuffer = 16384;
|
||||
// MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES: how many consecutive frames (strictly, BeginFrame
|
||||
// epochs) a frame slot's descriptor pools must stay under a quarter full before Magma
|
||||
// hands the slot's whole set cache back and lets it re-grow. 0 = never trim. A loading
|
||||
// frame otherwise keeps its burst of sets (rd12: ~15k, where steady frames use a few dozen)
|
||||
// for the life of the process. See UniformManager::TrimFrameDescriptorPools.
|
||||
Uint32 MagmaDescriptorTrimFrames = 120;
|
||||
// MOBILEGL_ESPRYT_AVOID_SAMPLER_MIPMAP_MIN_FILTER: avoid mipmap min filters in samplers,
|
||||
// resolves certain rendering bugs on ANGLE + llvmpipe.
|
||||
Bool EsprytAvoidSamplerMipmapMinFilter = false;
|
||||
@@ -214,12 +202,9 @@ namespace MobileGL::MG_Config {
|
||||
// persistently+coherently mapped storage at definition time (negative control /
|
||||
// escape hatch). Frontend-scoped: it engages only where the active backend
|
||||
// provides AcquirePersistentMap. With adoption on, an app SubData into a busy
|
||||
// 128MB arena lands GPU-ordered through the backend's resident-subdata op
|
||||
// (BufferObject::LandBytesIntoResidentStore, since 0ee3384b: an in-place write
|
||||
// tore the frames still reading the old bytes) - still no driver-mediated write
|
||||
// into the busy mutable store, which on this class of Mali driver stalls the
|
||||
// thread or ghost-copies the whole arena, and the arena stops costing its size
|
||||
// again in RAM.
|
||||
// 128MB arena is a plain memcpy into GPU-visible memory; every driver-mediated
|
||||
// route for the same write stalls the thread or ghost-copies the whole arena on
|
||||
// this class of Mali driver, and the arena stops costing its size again in RAM.
|
||||
Bool DisableLargeBufferAdoption = false;
|
||||
// MOBILEGL_ESPRYT_FORCE_DS_READBACK_EMULATION: make DirectGLES skip the native ES
|
||||
// depth/stencil reads and always go through the shader-sampling emulation. Core GL
|
||||
@@ -610,26 +595,10 @@ namespace MobileGL::MG_Config {
|
||||
// flag keyed on wantReply would disable the very mechanism it exists to enable
|
||||
// (docs/Disaggregated/notes/p12/CREATE-WINDOW-MEASURED.md sections 7-11).
|
||||
Uint32 CreateWindow = 10;
|
||||
// MOBILEGL_IPC_PBO_READBACK_SYNC (P9 W1, MG_Remote/CONTRACT-P9.md §1): 1 = a glReadPixels
|
||||
// or glGetTexImage into a bound GL_PIXEL_PACK_BUFFER takes the reply-slot form again -
|
||||
// the client waits for the pixels and uploads them into the buffer itself, as before P9.
|
||||
// 0 (default) sends read_pixels_to_buffer / get_texture_image_to_buffer, waits for
|
||||
// nothing, and marks the buffer GPU-written. The 1 arm is the A/B control and the
|
||||
// red-once of the wait-count gate (PackBufferReadbackScenario): it must show a reply
|
||||
// wait per read.
|
||||
Uint32 PboReadbackSync = 0;
|
||||
// MOBILEGL_IPC_POLL_ESCALATE (P10, MG_Remote/CONTRACT-P10.md §1): a glClientWaitSync with a
|
||||
// zero timeout or a glGetSynciv(GL_SYNC_STATUS) is answered by the client from what the
|
||||
// server reported (kEventFenceSignaled) - "signaled" when it has been, "not yet" otherwise
|
||||
// - and only the Nth "not yet" in a row on one fence crosses as a real round trip, so a
|
||||
// poll loop cannot outlive a late report. 0 = every poll crosses, as before P10: the A/B
|
||||
// arm and the red-once of the no-reply gate (FencePollScenario).
|
||||
Uint32 PollEscalate = 64;
|
||||
// MOBILEGL_IPC_ADOPT_TIER: 2 = emulate (T2: client keeps the shadow and pushes), the
|
||||
// only implemented tier and the reason persistent-map-push can be non-zero at all
|
||||
// (R-6). 0 (T0) and 1 (T1) parse and are settled at the handshake (P11 A1,
|
||||
// MG_Remote/Transport/AdoptTier.h): a stream data plane refuses them by name and runs
|
||||
// T2; over shared segments the client dies by name before any record.
|
||||
// MOBILEGL_IPC_ADOPT_TIER: 2 = emulate (client keeps the shadow and pushes), which
|
||||
// is the only tier P5 implements and the reason persistent-map-push can be non-zero
|
||||
// at all (R-6). 0 and 1 parse and are Fatal at use with "P11"; they exist now so the
|
||||
// negative control has a spelling the day P11 writes it.
|
||||
Uint32 AdoptTier = 2;
|
||||
// MOBILEGL_IPC_VERB_BARRIER: 1 = the client blocks at every verb boundary until
|
||||
// appliedSeq reaches its emitSeq (R-1). 0 is the negative control: it is EXPECTED to
|
||||
|
||||
@@ -230,9 +230,6 @@ namespace MobileGL::MG_ConfigLoader {
|
||||
features.AdvertiseFp64 = QueryEnvFlag("MOBILEGL_ADVERTISE_FP64");
|
||||
features.MagmaR11G11B10FFallback = QueryEnvFlag("MOBILEGL_MAGMA_R11G11B10F_FALLBACK");
|
||||
features.MagmaFramesInFlight = QueryEnvUint32("MOBILEGL_MAGMA_FRAMESINFLIGHT", 3, 1, 64);
|
||||
features.MagmaMaxDrawsPerCommandBuffer =
|
||||
QueryEnvUint32("MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER", 16384, 0, 1u << 24);
|
||||
features.MagmaDescriptorTrimFrames = QueryEnvUint32("MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES", 120, 0, 1u << 20);
|
||||
features.EsprytAvoidSamplerMipmapMinFilter =
|
||||
QueryEnvFlag("MOBILEGL_ESPRYT_AVOID_SAMPLER_MIPMAP_MIN_FILTER");
|
||||
features.EsprytAvoidExplicitLodBias = QueryEnvFlag("MOBILEGL_ESPRYT_AVOID_EXPLICIT_LOD_BIAS");
|
||||
@@ -424,17 +421,13 @@ namespace MobileGL::MG_ConfigLoader {
|
||||
// cap of 4 (see WireTables.cpp's kCreateWindowMax). WireTables.cpp's static_assert and
|
||||
// StreamLink's crossing log are the checks on this number.
|
||||
ipc.CreateWindow = QueryEnvUint32("MOBILEGL_IPC_CREATE_WINDOW", 10, 1, 12);
|
||||
// P9 W1: the pack-buffer readback's A/B and red-once control (Config.h says both).
|
||||
ipc.PboReadbackSync = QueryEnvUint32("MOBILEGL_IPC_PBO_READBACK_SYNC", 0, 0, 1);
|
||||
// P10: fence polls answered locally; 0 is the A/B arm (Config.h).
|
||||
ipc.PollEscalate = QueryEnvUint32("MOBILEGL_IPC_POLL_ESCALATE", 64, 0, 1000000);
|
||||
// The verify harness compares the pushed block against the applier per verb; a
|
||||
// batched queue lets the comparer read a supplied field mid-apply, which is a
|
||||
// torn read rather than a divergence. The batch is therefore off whenever the
|
||||
// shadow comparer is armed.
|
||||
if (MG_Config::Features.PipeVerify) ipc.BatchWaits = 0;
|
||||
// 2 is the only implemented tier (R-6). 0 and 1 parse here and are settled at the
|
||||
// handshake from the data plane (P11 A1, MG_Remote/Transport/AdoptTier.h).
|
||||
// 2 is the only tier P5 implements (R-6). 0 and 1 parse here and are refused at the
|
||||
// point of use, which is where the "P11" in the message belongs.
|
||||
ipc.AdoptTier = QueryEnvUint32("MOBILEGL_IPC_ADOPT_TIER", 2, 0, 2);
|
||||
ipc.VerbBarrier = QueryEnvUint32("MOBILEGL_IPC_VERB_BARRIER", 1, 0, 1);
|
||||
// P5e (MG_Remote/CONTRACT-P5E.md §1). The wait rule's A/B, parsed here like every
|
||||
@@ -529,11 +522,11 @@ namespace MobileGL::MG_ConfigLoader {
|
||||
// changes the wall clock by seconds (the P12 sweep: 28.3 s at 1 down to 10.8 s at 6) a
|
||||
// log that does not name it makes every run ambiguous about its own configuration.
|
||||
MGLOG_I("Config: IPC ring=%uMiB stage=%uMiB wire-deferred=%uMiB spin=%uus event-wait=%ums "
|
||||
"persistent-block=%uKiB create-window=%u pbo-readback-sync=%u poll-escalate=%u "
|
||||
"persistent-block=%uKiB create-window=%u "
|
||||
"adopt-tier=%u verb-barrier=%u run-ahead=%u present-credit=%u control-timeout=%ums "
|
||||
"cold-start=%ums strict=%d audit=%d role-split-state=%d affinity='%s' surface=%s",
|
||||
ipc.RingMb, ipc.StageMb, ipc.WireDeferredMb, ipc.SpinUs, ipc.EventWaitMs,
|
||||
ipc.PersistentBlockKb, ipc.CreateWindow, ipc.PboReadbackSync, ipc.PollEscalate, ipc.AdoptTier,
|
||||
ipc.PersistentBlockKb, ipc.CreateWindow, ipc.AdoptTier,
|
||||
ipc.VerbBarrier, ipc.RunAhead, ipc.PresentCredit, ipc.ControlTimeoutMs, ipc.ColdStartMs,
|
||||
static_cast<int>(ipc.StrictErrors), static_cast<int>(ipc.Audit),
|
||||
static_cast<int>(ipc.RoleSplitState), ipc.ServerAffinity.c_str(),
|
||||
|
||||
@@ -4345,17 +4345,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
}
|
||||
const auto textureFormat = static_cast<TextureInternalFormat>(resource->Desc.InternalFormat);
|
||||
const TextureTarget textureTarget = PipeTextureTargetForHandle(view.Res);
|
||||
const GLenum access = GLAccessForImageView(view);
|
||||
// Before the sync, for the frontend arm's reason: the note may adopt a twin, and
|
||||
// `backendTexture` below is a reference into the same registry.
|
||||
if (access != GL_READ_ONLY) {
|
||||
NoteDriverSideTextureWriteByHandle(view.Res);
|
||||
}
|
||||
auto& backendTexture = SyncTextureToBackendByHandle(view.Res, /*imageBindableStorageRequired=*/true);
|
||||
if (!backendTexture) return;
|
||||
IssueImageTextureBind(unit, *backendTexture, textureTarget, textureFormat,
|
||||
static_cast<GLenum>(view.InternalFormat), static_cast<GLint>(view.Level),
|
||||
view.Layered != 0, static_cast<GLint>(view.Layer), access);
|
||||
view.Layered != 0, static_cast<GLint>(view.Layer),
|
||||
GLAccessForImageView(view));
|
||||
}
|
||||
#endif // MOBILEGL_PIPE_PUSH
|
||||
|
||||
@@ -4380,11 +4375,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
return;
|
||||
}
|
||||
|
||||
// Before the sync: `backendTexture` below is a reference into the registry, which the
|
||||
// lookup inside the note may reshuffle.
|
||||
if (imageBinding.Access != GL_READ_ONLY) {
|
||||
NoteDriverSideTextureWrite(imageBinding.Texture);
|
||||
}
|
||||
auto& backendTexture = SyncTextureObjectToBackend(imageBinding.Texture, true);
|
||||
if (!backendTexture) return;
|
||||
IssueImageTextureBind(unit, *backendTexture, imageBinding.Texture->GetTarget(),
|
||||
@@ -10939,7 +10929,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
continue;
|
||||
}
|
||||
|
||||
TextureImpl::NoteDriverSideTextureWrite(destinationTexture);
|
||||
auto backendSource = TextureImpl::SyncTextureObjectToBackend(sourceTexture);
|
||||
auto backendDestination = TextureImpl::SyncTextureObjectToBackend(destinationTexture);
|
||||
if (!backendSource || !backendDestination) continue;
|
||||
@@ -12602,7 +12591,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// touched unit happened to sync it as a side effect. The named narrowing (P5e-5) says
|
||||
// the union that still covers every texture includes "the waited texture ops", and
|
||||
// this is one of them: it syncs its own endpoint by handle.
|
||||
TextureImpl::NoteDriverSideTextureWriteByHandle(dstHandle);
|
||||
auto& backendTexture = TextureImpl::SyncTextureToBackendByHandle(dstHandle);
|
||||
if (!backendTexture || dstRecord == nullptr) {
|
||||
MGLOG_E_ONCE("CopyTexImage2D: the verb's destination texture {%u, %u} has no twin "
|
||||
@@ -12618,7 +12606,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
const auto& textureObject = MGB_CTX->GetTextureUnitObject((Int)activeTextureUnit)
|
||||
.GetBindingSlot(MG_Util::ConvertGLEnumToTextureTarget(target))
|
||||
.GetBoundObject();
|
||||
if (textureObject) TextureImpl::NoteDriverSideTextureWrite(textureObject);
|
||||
auto* backendTextureSlot = TextureImpl::g_backendTextureObjects.Find(textureObject.get());
|
||||
if (!backendTextureSlot || !*backendTextureSlot) {
|
||||
MGLOG_E_ONCE("CopyTexSubImage2D: No backend texture found for texture %u.",
|
||||
@@ -12721,7 +12708,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
const MG_Pipe::MGPipeHandle dstHandle = MG_Pipe::MGPipeApplier().VerbCopyTexDst;
|
||||
// P5e (tx2): synced by handle - see CopyTexImage2D's note. A copy destination is not
|
||||
// in the sampler-view window, so nothing else on this path would build its twin.
|
||||
TextureImpl::NoteDriverSideTextureWriteByHandle(dstHandle);
|
||||
auto& backendTexture = TextureImpl::SyncTextureToBackendByHandle(dstHandle);
|
||||
if (!backendTexture) {
|
||||
MGLOG_E_ONCE("CopyTexSubImage2D: the verb's destination texture {%u, %u} has no "
|
||||
@@ -12736,7 +12722,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
const auto& textureObject = MGB_CTX->GetTextureUnitObject(activeTextureUnit)
|
||||
.GetBindingSlot(MG_Util::ConvertGLEnumToTextureTarget(target))
|
||||
.GetBoundObject();
|
||||
if (textureObject) TextureImpl::NoteDriverSideTextureWrite(textureObject);
|
||||
auto* backendTextureSlot = TextureImpl::g_backendTextureObjects.Find(textureObject.get());
|
||||
if (!backendTextureSlot || !*backendTextureSlot) {
|
||||
MGLOG_E_ONCE("CopyTexSubImage2D: No backend texture found for texture %u.",
|
||||
@@ -12958,9 +12943,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// for GenerateMipmap move to kWaitNone.
|
||||
if (MG_Config::Transport != MG_Config::TransportMode::Monolith) {
|
||||
const auto mipRes = MG_Pipe::MGPipeApplier().VerbMipRes;
|
||||
// Every arm GenerateMipmapByRecord takes writes the levels above the base on the
|
||||
// driver only (its CPU filter is unmigrated and aborts), so the note is unconditional.
|
||||
TextureImpl::NoteDriverSideTextureWriteByHandle(mipRes);
|
||||
auto& backendTexture = TextureImpl::SyncTextureToBackendByHandle(mipRes);
|
||||
const auto* record = PipeTextureRecordForHandle(mipRes);
|
||||
if (!backendTexture || record == nullptr) {
|
||||
@@ -12988,8 +12970,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
TextureImpl::SyncTextureObjectToBackend(texture);
|
||||
return;
|
||||
}
|
||||
// Every path below writes the levels above the base on the driver only.
|
||||
TextureImpl::NoteDriverSideTextureWrite(texture);
|
||||
auto& backendTexture = TextureImpl::SyncTextureObjectToBackend(texture);
|
||||
|
||||
// Asked for before the format arms below, which are 2D-only emulations of the same
|
||||
@@ -13252,9 +13232,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
//
|
||||
// WHAT THE SKIP LOSES IS BOUNDED BY TWO FATALS, which is the whole reason it is allowed
|
||||
// to be a skip rather than a port: a later glGetTexImage of the destination served from
|
||||
// the shadow is class C wave 3 (Fatal{UnmigratedVerb, "GetTexImage"}, P9), and a texture
|
||||
// re-mint under a transport reads the GPU level itself (RequireImageBindableStorageByHandle,
|
||||
// P9 W2) rather than any shadow. Neither can silently read the un-mirrored shadow.
|
||||
// the shadow is class C wave 3 (Fatal{UnmigratedVerb, "GetTexImage"}, P9) and a texture
|
||||
// re-mint that re-uploads the level is Fatal{UnmigratedEmulation, "texture-remint-pull"}
|
||||
// (Managers.cpp:5634). Neither can silently read the un-mirrored shadow.
|
||||
//
|
||||
// BEHIND #if MOBILEGL_BUILD_DISAGGREGATED so the pull build's code does not move (G1),
|
||||
// and the arm is the TRANSPORT and not the build - build-split runs its unit and
|
||||
@@ -13336,16 +13316,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// dereference. The frontend validator is what keeps this unreachable and what reports
|
||||
// the error the application is owed; declining is only how a future gap up there stops
|
||||
// being a crash. See the level guard in VulkanRenderer::CopyImageSubData.
|
||||
if (!dstEndpoint.IsRenderbuffer() && dstEndpoint.Texture) {
|
||||
TextureImpl::NoteDriverSideTextureWrite(dstEndpoint.Texture);
|
||||
}
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
// The handle arm's endpoint names its texture by handle, and the server has no frontend
|
||||
// object to note.
|
||||
if (!dstEndpoint.IsRenderbuffer() && !MG_Pipe::MGPipeHandleIsNull(dstEndpoint.TextureHandle)) {
|
||||
TextureImpl::NoteDriverSideTextureWriteByHandle(dstEndpoint.TextureHandle);
|
||||
}
|
||||
#endif
|
||||
if (!MakeGLESCopyImageEndpoint(srcEndpoint, srcTarget, srcX, srcY, srcZ, src) ||
|
||||
!MakeGLESCopyImageEndpoint(dstEndpoint, dstTarget, dstX, dstY, dstZ, dst)) {
|
||||
MGLOG_E_ONCE("%s: source or destination image failed to sync; declining the copy", __func__);
|
||||
@@ -14982,10 +14952,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// Session::Fail entirely, which is the funnel the census gate watches.
|
||||
//
|
||||
// THE FUNNEL KEEPS ITS TEETH FOR THE OTHER SITES: MGPipeUnmigratedEmulation still
|
||||
// aborts for generate-mipmap-storage, generate-mipmap-cpu-fallback and
|
||||
// generate-mipmap-cpu-filter, which really do reach into a client address space. Only
|
||||
// this call site is retired here, and only because its own premise did not hold
|
||||
// (texture-remint-pull went the same way in P9 W2, for the same reason).
|
||||
// aborts for generate-mipmap-storage, generate-mipmap-cpu-fallback,
|
||||
// generate-mipmap-cpu-filter and texture-remint-pull, which really do reach into a
|
||||
// client address space. Only this call site is retired, and only because its own
|
||||
// premise did not hold.
|
||||
if (MG_Config::Transport != MG_Config::TransportMode::Monolith) {
|
||||
if (shadow == nullptr) {
|
||||
MGLOG_E_ONCE("GetTexImage: no level shadow on this side for target=0x%x level=%d, and under an "
|
||||
@@ -15199,7 +15169,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
return true;
|
||||
}
|
||||
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
#include "WireTextureReadback.inc"
|
||||
#endif
|
||||
|
||||
static Bool IsLegacyNativeReadPixelsFormat(GLenum format) {
|
||||
return format == GL_RGBA || format == GL_RGBA_INTEGER || format == GL_RED || format == GL_RED_INTEGER ||
|
||||
|
||||
@@ -23,21 +23,15 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// Content uploads use scratch bindings, so draws and dispatches call this after
|
||||
// texture synchronization.
|
||||
void BindCurrentTextures();
|
||||
// Driver-side color/depth level readback. Returns tightly packed, owned
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
Bool ReadTextureImageWire(const MG_Pipe::MGPReadbackInfo& info, Vector<Uint8>& bytes);
|
||||
// Native/server-only color level readback. Returns tightly packed, owned
|
||||
// bytes in the requested pair; never consults a frontend texture or PACK/PBO.
|
||||
// The caller supplies identity and extent, and whether the SOURCE allocation
|
||||
// already uses an image carrier.
|
||||
// The caller resolves identity/extent from its resource record and supplies
|
||||
// whether the SOURCE allocation already uses an image carrier.
|
||||
Bool ReadTextureLevelTight(GLuint texture, TextureTarget target, TextureUploadTarget uploadTarget,
|
||||
TextureInternalFormat logicalFormat, GLint level, const IntVec3& logicalExtent,
|
||||
Bool sourceUsesImageCarrier, GLenum format, GLenum type, Vector<Uint8>& bytes);
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
Bool ReadTextureImageWire(const MG_Pipe::MGPReadbackInfo& info, Vector<Uint8>& bytes);
|
||||
// Whether the NATIVE texture currently holds `level` of `uploadTarget` at `logicalExtent`
|
||||
// (glGetTexLevelParameteriv). False for a level the driver never allocated - one defined after
|
||||
// the texture's last sync - so a re-mint does not read what is not there. A query the driver
|
||||
// refuses answers true, keeping the caller on its readback path.
|
||||
Bool NativeTextureLevelHasExtent(GLuint texture, TextureTarget target, TextureUploadTarget uploadTarget,
|
||||
GLint level, const IntVec3& logicalExtent);
|
||||
#endif
|
||||
void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
|
||||
void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value);
|
||||
|
||||
@@ -6303,18 +6303,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
m_forceTextureParamsResync = true;
|
||||
return;
|
||||
}
|
||||
// P9 W2 (notes/p9/W2-REMINT.md): EVERY BYTE THIS RE-MINT REPLAYS IS ALREADY ON THE
|
||||
// SERVER. The GPU image holds what the GPU wrote (render targets, clears, copies,
|
||||
// generated mips, image stores) and the staged store holds what the client uploaded;
|
||||
// the client is never asked, so no pull protocol exists. Reading only the store would
|
||||
// be wrong: a GPU-written level's store run is stale or absent - both host corpus
|
||||
// re-mints (iris-photon, iris-derivative) are render targets with no staged bytes.
|
||||
const Bool hadBackendStorage = m_isInitialized;
|
||||
// The R-16 control for W2-b's fallback below: a readback the driver refuses cannot be
|
||||
// produced on the host (llvmpipe renders every image format), so the test lane forces
|
||||
// one. Read by the SERVER, like the MGITEST_MAGMA_FORCE_* knobs.
|
||||
static const Bool s_forceReadbackFailure =
|
||||
std::getenv("MGITEST_ESPRYT_FORCE_REMINT_READBACK_FAILURE") != nullptr;
|
||||
auto& store = MG_Remote::Server::ServerStagedTexture();
|
||||
const Uint64 key = MG_Remote::Server::StagedTextureStore::KeyForHandle(res);
|
||||
const auto target = BufferImpl::StagedTextureTargetForPipeTarget(record.Desc.Target);
|
||||
@@ -6343,46 +6331,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
const Bool pendingWhole = pending && (pending->Regions.empty()
|
||||
? coversWhole(pending->UnionBox)
|
||||
: std::any_of(pending->Regions.begin(), pending->Regions.end(), coversWhole));
|
||||
// W2-a: ONLY A LEVEL THE DRIVER ACTUALLY HOLDS IS READ BACK. The store's
|
||||
// Defined-ness follows the client's respecifies, the driver's follows this
|
||||
// twin's last sync, and the two differ for a level defined (null data, or null
|
||||
// data plus a partial upload) after that sync: the driver has no such level, so
|
||||
// the GPU cannot have written it. A covered level then replays its staged run
|
||||
// (the client's whole-level shadow, pending boxes included) and an uncovered one
|
||||
// is undefined content with nothing to preserve. Reading it anyway was
|
||||
// Fatal{ResourceUnavailable, "image-promotion-readback"} on legal GL.
|
||||
const Bool nativeLevel =
|
||||
m_isInitialized &&
|
||||
NativeTextureLevelHasExtent(m_backendTextureId, target, uploadTarget,
|
||||
static_cast<GLint>(level), extent);
|
||||
if (nativeLevel && !(covered && pendingWhole)) {
|
||||
if (m_isInitialized && !(covered && pendingWhole)) {
|
||||
Vector<Uint8> snapshot;
|
||||
const Bool readBack =
|
||||
!s_forceReadbackFailure &&
|
||||
ReadTextureLevelTight(m_backendTextureId, target, uploadTarget, format,
|
||||
static_cast<GLint>(level), extent,
|
||||
/*sourceUsesImageCarrier=*/false, canonicalFormat,
|
||||
canonicalType, snapshot);
|
||||
if (!readBack && !covered) {
|
||||
// The GPU holds this level, the driver will not hand it back, and no
|
||||
// CPU byte of it exists anywhere: the one case with no honest answer.
|
||||
if (!ReadTextureLevelTight(m_backendTextureId, target, uploadTarget, format,
|
||||
static_cast<GLint>(level), extent, /*sourceUsesImageCarrier=*/false,
|
||||
canonicalFormat, canonicalType, snapshot)) {
|
||||
MGLOG_F("MGPipe: Fatal{ResourceUnavailable, \"image-promotion-readback\"} {%u,%u} level=%u",
|
||||
res.Slot, res.Gen, level);
|
||||
std::abort();
|
||||
}
|
||||
if (!readBack) {
|
||||
// W2-b: the driver refused the readback (a format it cannot attach
|
||||
// to a framebuffer - SNORM without EXT_render_snorm, 16-bit norm
|
||||
// without EXT_texture_norm16, float without EXT_color_buffer_float)
|
||||
// but the store covers the level. Its staged run is exactly what the
|
||||
// monolith re-mint replays; texels the GPU wrote since that upload
|
||||
// are not preserved, which is monolith's answer too.
|
||||
MGLOG_W_ONCE("MGPipe: image promotion of texture {%u,%u} level %u: the driver "
|
||||
"refused the readback (internal format %u); replaying the level's "
|
||||
"staged bytes instead (remint-readback-fallback)",
|
||||
res.Slot, res.Gen, level, record.Desc.InternalFormat);
|
||||
}
|
||||
if (readBack && pending) {
|
||||
if (pending) {
|
||||
// Native contents include prior draws/image
|
||||
// writes; the pending stage owns ONLY its boxes.
|
||||
// Merge those boxes before adopting a whole-level
|
||||
@@ -6417,9 +6375,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
merge(box.X, box.Y, box.Z, box.W, box.H, box.D);
|
||||
}
|
||||
}
|
||||
if (readBack) {
|
||||
store.Adopt(key, targetCode, levelCode, extent, snapshot.data(), snapshot.size());
|
||||
}
|
||||
store.Adopt(key, targetCode, levelCode, extent, snapshot.data(), snapshot.size());
|
||||
}
|
||||
// Undefined contents have no byte run to preserve. A
|
||||
// first allocation can still be image-bindable without
|
||||
@@ -6433,12 +6389,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
}
|
||||
}
|
||||
}
|
||||
// W2-d: `trp=` counts a re-mint of storage the backend ALREADY held, on this arm as
|
||||
// on the frontend one (which counts in RequireImageBindableStorage). The keep path
|
||||
// above is not a re-mint and returns before this; a first allocation holds nothing.
|
||||
if (hadBackendStorage && MG_Util::PipeStats::Enabled()) {
|
||||
MG_Util::PipeStats::AddCalls(MG_Util::PipeStats::CallClass::TextureRemintPulls, 1);
|
||||
}
|
||||
}
|
||||
#else
|
||||
(void)res;
|
||||
@@ -6456,192 +6406,20 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
}
|
||||
#endif
|
||||
|
||||
// Replaces one level's shadow bytes with what the driver texture holds for it, then copies
|
||||
// back the client writes the driver has not been sent yet - exactly the texels written
|
||||
// (the level's dirty footprint), not the union box or the rect list, which also span texels
|
||||
// the client never wrote and which only the driver's copy holds correctly. Returns false,
|
||||
// leaving the shadow untouched, when the driver's copy cannot stand in for the shadow: the
|
||||
// client wrote every texel of the level, the level is stored compressed, the driver has no
|
||||
// image at this level and extent (defined after the last sync), or the readback cannot be
|
||||
// served (a multisample image, a format the driver will not attach to a framebuffer).
|
||||
//
|
||||
// P11 M, `pipePending` (push builds): THE CLIENT WRITES THE DRIVER HAS NOT BEEN SENT MAY
|
||||
// LIVE IN THE APPLIER'S PENDING SET INSTEAD. On the texture handle arm the client clears its
|
||||
// own dirty flags when it emits a level (D-D5), so the frontend model below answers "clean"
|
||||
// for a write that is still only in the shadow; the entry the applier accumulated for this
|
||||
// (uploadTarget, level) names the same shadow-grid boxes. Both are merged over the
|
||||
// snapshot. Only a box-only entry whose box IS the level owns every byte of it (dev's rule:
|
||||
// a union box spanning the level with gaps in it is not a whole-level write); an entry with
|
||||
// regions never short-circuits, since accumulated regions may overlap and their texels do
|
||||
// not add up - the readback and the merge below give the same bytes when they do cover it.
|
||||
// Null on the pull build's arm and the legacy arm.
|
||||
static Bool AdoptDriverLevelIntoShadow(GLuint backendTextureId, BackendTextureObject& backendTexture,
|
||||
const MG_State::GLState::ITextureObject& stateTextureObject,
|
||||
MG_State::GLState::TextureObjectMipmap& mipmapObject,
|
||||
TextureUploadTarget uploadTarget, Uint level
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
,
|
||||
const MG_Pipe::MGPipeResourceRecord::PendingUpload* pipePending
|
||||
#endif
|
||||
) {
|
||||
const IntVec3 texelSize = mipmapObject.GetMipmapTexelSize(uploadTarget, level);
|
||||
const IntVec3 extent{texelSize.x(), texelSize.y(), std::max(texelSize.z(), 1)};
|
||||
const SizeT texelCount =
|
||||
static_cast<SizeT>(extent.x()) * static_cast<SizeT>(extent.y()) * static_cast<SizeT>(extent.z());
|
||||
Vector<MG_State::GLState::MipmapDirtyRegion> pending;
|
||||
mipmapObject.GetStorageDirtyFootprint(uploadTarget, level, pending);
|
||||
// Disjoint boxes, so their texels add up; a union box spanning the level is not enough.
|
||||
SizeT pendingTexels = 0;
|
||||
for (const auto& box : pending) {
|
||||
pendingTexels += box.TexelCount();
|
||||
}
|
||||
if (!pending.empty() && pendingTexels >= texelCount) return false;
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
// Every box the entry names, checked against the level before anything is read: a box
|
||||
// outside it is a corrupt record, and the answer is the pre-readback one (keep the
|
||||
// shadow) rather than a copy out of bounds.
|
||||
const auto pipeBoxInLevel = [&](Int32 x, Int32 y, Int32 z, Uint32 w, Uint32 h, Uint32 d) {
|
||||
return x >= 0 && y >= 0 && z >= 0 && Uint64(x) + w <= Uint64(extent.x()) &&
|
||||
Uint64(y) + h <= Uint64(extent.y()) && Uint64(z) + d <= Uint64(extent.z());
|
||||
};
|
||||
if (pipePending != nullptr) {
|
||||
const auto& box = pipePending->UnionBox;
|
||||
if (!pipeBoxInLevel(box.X, box.Y, box.Z, box.W, box.H, box.D)) {
|
||||
MGLOG_E_ONCE("MGPipe: texture %u level %u: a pending upload's box lies outside the level; the "
|
||||
"image-bindable re-mint replays the shadow as it stands",
|
||||
stateTextureObject.GetExternalIndex(), level);
|
||||
return false;
|
||||
}
|
||||
for (const auto& region : pipePending->Regions) {
|
||||
if (!pipeBoxInLevel(region.X, region.Y, region.Z, region.W, region.H, region.D)) {
|
||||
MGLOG_E_ONCE("MGPipe: texture %u level %u: a pending upload's region lies outside the "
|
||||
"level; the image-bindable re-mint replays the shadow as it stands",
|
||||
stateTextureObject.GetExternalIndex(), level);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (pipePending->Regions.empty() && box.X == 0 && box.Y == 0 && box.Z == 0 &&
|
||||
box.W == static_cast<Uint32>(extent.x()) && box.H == static_cast<Uint32>(extent.y()) &&
|
||||
box.D == static_cast<Uint32>(extent.z())) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (mipmapObject.GetMipmapCompressedFormat(uploadTarget, level) != GL_NONE) return false;
|
||||
if (!g_GLESFuncs.glGetTexLevelParameteriv) return false;
|
||||
|
||||
const TextureTarget target = stateTextureObject.GetTarget();
|
||||
const GLenum nativeTarget = ConvertTextureTargetToBackendGLEnum(target);
|
||||
const GLenum faceTarget = ConvertTextureUploadTargetToBackendGLEnum(uploadTarget);
|
||||
const IntVec3 backendExtent = GetBackendUploadSize(target, texelSize);
|
||||
GLint driverWidth = 0, driverHeight = 0, driverDepth = 0;
|
||||
backendTexture.Bind(nativeTarget);
|
||||
g_GLESFuncs.glGetTexLevelParameteriv(faceTarget, static_cast<GLint>(level), GL_TEXTURE_WIDTH, &driverWidth);
|
||||
g_GLESFuncs.glGetTexLevelParameteriv(faceTarget, static_cast<GLint>(level), GL_TEXTURE_HEIGHT,
|
||||
&driverHeight);
|
||||
g_GLESFuncs.glGetTexLevelParameteriv(faceTarget, static_cast<GLint>(level), GL_TEXTURE_DEPTH, &driverDepth);
|
||||
if (driverWidth != backendExtent.x() || driverHeight != backendExtent.y() ||
|
||||
std::max(driverDepth, 1) != std::max(backendExtent.z(), 1)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const TextureInternalFormat format = stateTextureObject.GetFormat();
|
||||
GLenum shadowFormat = GL_NONE, shadowType = GL_NONE;
|
||||
MG_Util::TextureFormatProcessor::NormalizePixelFormat(MG_Util::ConvertTextureInternalFormatToGLEnum(format),
|
||||
{}, nullptr, &shadowFormat, &shadowType);
|
||||
Vector<Uint8> snapshot;
|
||||
if (!ReadTextureLevelTight(backendTextureId, target, uploadTarget, format, static_cast<GLint>(level),
|
||||
texelSize, /*sourceUsesImageCarrier=*/false, shadowFormat, shadowType,
|
||||
snapshot)) {
|
||||
return false;
|
||||
}
|
||||
const SizeT shadowBytes = mipmapObject.GetMipmapByteSize(uploadTarget, level);
|
||||
auto* shadow = static_cast<Uint8*>(mipmapObject.MapMipmapData(uploadTarget, level));
|
||||
if (shadow == nullptr || snapshot.size() != shadowBytes || texelCount == 0 || shadowBytes % texelCount) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!pending.empty()) {
|
||||
// The boxes index the SHADOW's texel grid (a 1D array's layers are its rows), which
|
||||
// is also the snapshot's byte order.
|
||||
const SizeT bpp = shadowBytes / texelCount;
|
||||
const SizeT rowBytes = static_cast<SizeT>(extent.x()) * bpp;
|
||||
const SizeT sliceBytes = static_cast<SizeT>(extent.y()) * rowBytes;
|
||||
for (const auto& box : pending) {
|
||||
if (box.Empty()) continue;
|
||||
const SizeT spanBytes = static_cast<SizeT>(box.hi.x() - box.lo.x()) * bpp;
|
||||
for (Int z = box.lo.z(); z < box.hi.z(); ++z) {
|
||||
for (Int y = box.lo.y(); y < box.hi.y(); ++y) {
|
||||
const SizeT offset = static_cast<SizeT>(z) * sliceBytes + static_cast<SizeT>(y) * rowBytes +
|
||||
static_cast<SizeT>(box.lo.x()) * bpp;
|
||||
Memcpy(snapshot.data() + offset, shadow + offset, spanBytes);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
if (pipePending != nullptr) {
|
||||
// The same merge for the applier's entry: its regions when it carries a list, its
|
||||
// union box when it does not (RegionCount 0 = "the box is the whole story", D-D3).
|
||||
const SizeT bpp = shadowBytes / texelCount;
|
||||
const SizeT rowBytes = static_cast<SizeT>(extent.x()) * bpp;
|
||||
const SizeT sliceBytes = static_cast<SizeT>(extent.y()) * rowBytes;
|
||||
const auto mergePipeBox = [&](Int32 x, Int32 y, Int32 z, Uint32 w, Uint32 h, Uint32 d) {
|
||||
for (Uint32 slice = 0; slice < d; ++slice) {
|
||||
for (Uint32 row = 0; row < h; ++row) {
|
||||
const SizeT offset = static_cast<SizeT>(z + static_cast<Int32>(slice)) * sliceBytes +
|
||||
static_cast<SizeT>(y + static_cast<Int32>(row)) * rowBytes +
|
||||
static_cast<SizeT>(x) * bpp;
|
||||
Memcpy(snapshot.data() + offset, shadow + offset, static_cast<SizeT>(w) * bpp);
|
||||
}
|
||||
}
|
||||
};
|
||||
if (pipePending->Regions.empty()) {
|
||||
const auto& box = pipePending->UnionBox;
|
||||
mergePipeBox(box.X, box.Y, box.Z, box.W, box.H, box.D);
|
||||
} else {
|
||||
for (const auto& region : pipePending->Regions) {
|
||||
mergePipeBox(region.X, region.Y, region.Z, region.W, region.H, region.D);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
Memcpy(shadow, snapshot.data(), shadowBytes);
|
||||
return true;
|
||||
}
|
||||
|
||||
void BackendTextureObject::RequireImageBindableStorage(
|
||||
const SharedPtr<MG_State::GLState::ITextureObject>& stateTextureObject) {
|
||||
if (m_imageBindableStorageRequired) {
|
||||
return;
|
||||
}
|
||||
// Read before the two flags below schedule the re-mint: whether the driver texture
|
||||
// already holds this object's levels, and so may hold texels the shadow never saw.
|
||||
// Also what `trp=` counts on the push builds: a transition that re-mints storage that
|
||||
// ALREADY EXISTED on the backend. A texture reaching here uninitialised is allocated
|
||||
// image-bindable up front and replays nothing.
|
||||
const Bool hadBackendStorage = m_isInitialized && m_backendTextureId != 0 &&
|
||||
m_contextGeneration == g_backendContextGeneration;
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
// Whether this transition re-mints storage that ALREADY EXISTED on the backend: that
|
||||
// is the remint PULL (the levels below are replayed from the client's shadow to fill
|
||||
// the new carrier), and it is what ROADMAP open question 2 counts. A texture reaching
|
||||
// here uninitialised is allocated image-bindable up front and pulls nothing.
|
||||
const Bool hadBackendStorage = m_isInitialized;
|
||||
#endif
|
||||
m_imageBindableStorageRequired = true;
|
||||
// ES only needs the storage to be immutable, so an immutable allocation that needs no
|
||||
// channel widening is already the one a re-mint would produce: keep it, and with it
|
||||
// every texel the GPU wrote. Pending uploads and real redefinitions still go through
|
||||
// the normal shape and dirty checks of the next sync.
|
||||
if (hadBackendStorage && m_backendStorageImmutable && !stateTextureObject->IsTextureView() &&
|
||||
!IsMultisampleTextureTarget(stateTextureObject->GetTarget()) &&
|
||||
!GetImageBindableStorageWidening(stateTextureObject->GetFormat())) {
|
||||
m_forceTextureParamsResync = true;
|
||||
return;
|
||||
}
|
||||
m_isInitialized = false;
|
||||
// A view owns no levels. Its sync hands the requirement to the storage texture
|
||||
// (SyncTextureViewToBackend), whose own transition below re-mints and replays them; a
|
||||
// re-dirty issued here, through the view, would reach that texture first and claim
|
||||
// every level for the shadow before the driver's copy could be read back.
|
||||
if (stateTextureObject->IsTextureView()) {
|
||||
m_forceTextureParamsResync = true;
|
||||
return;
|
||||
}
|
||||
// Every level this object has ALREADY uploaded has to be replayed, because the
|
||||
// regeneration this transition schedules re-mints the storage in the image carrier and
|
||||
// only uploads levels the shadow still calls dirty - which, for a texture that was
|
||||
@@ -6653,29 +6431,28 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// glGetTexImage, a draw that samples it, an FBO attach - which is why it survived so
|
||||
// long: the scenario that binds the image immediately after uploading never sees it.
|
||||
//
|
||||
// And the shadow is only the CLIENT's copy. Whatever the GPU wrote into a level - a
|
||||
// render or clear into it, a copy, a glGenerateMipmap - lives in the driver texture
|
||||
// alone, so replaying the shadow as it stands put the pre-render bytes (or the zeroes
|
||||
// of a null-data definition) into the new storage. The driver's levels are therefore
|
||||
// read back into the shadow first, with the client writes still pending merged over
|
||||
// them, while the old storage still exists; a level the driver cannot hand back keeps
|
||||
// the shadow, which is all this used to replay. (This was the known monolith defect of
|
||||
// W2-REMINT.md §6, the half of ID-P9-8 left to dev; dev's 568090f0 fixed it and P11 M
|
||||
// merged it.)
|
||||
// P4a (D-M): THIS RE-DIRTY IS AN EMULATION THAT CANNOT SURVIVE A SPLIT, and it is
|
||||
// the head of ARCHITECTURE.md:299-308's one new stall class. The server is reaching
|
||||
// BACK into the client's own dirty model to ask for texels it does not hold; under
|
||||
// split there is no client address space to reach into and the levels have to be
|
||||
// PULLED across the reverse channel. P4a supplies mitigation 1 - the prevention
|
||||
// half, MGPResourceDesc::ImageBindableHint on every create and respecify, so a
|
||||
// texture that has ever been image-bound is allocated in the carrier from the start
|
||||
// and never reaches this path - and NAMES the site. Mitigations 2-4 (the async pull,
|
||||
// the bounded retention and the ResourceSubDataComplete terminator) and
|
||||
// TextureRemintPullScenario are P9's, and P4a must not build half a terminator.
|
||||
//
|
||||
// THIS IS THE MONOLITH ARM ONLY. Under a transport the re-mint is the server's own
|
||||
// (RequireImageBindableStorageByHandle: the GPU level read back, the staged store for
|
||||
// what the client uploaded), and nothing selects this function there - the image
|
||||
// units sync from the record, the metadata respecify calls the by-handle overload, and
|
||||
// a frontend object reaching the loop below would meet the layer-1 guard
|
||||
// (Fatal{RoleViolation, "texture-legacy-arm"}) first. P9 W2 retired the
|
||||
// `texture-remint-pull` marker this comment used to describe: no pull protocol exists
|
||||
// because no byte of a re-mint has to come from the client (notes/p9/W2-REMINT.md).
|
||||
// The two arms now answer the same way: both read the GPU's level back first.
|
||||
// In monolith the code below keeps running exactly as it does today: the Fatal is a
|
||||
// split-only arm and the monolith body of MGPipeUnmigratedEmulation is a no-op.
|
||||
//
|
||||
// THE COUNT IS TAKEN WHERE A LEVEL IS ACTUALLY REPLAYED, not on entry (review N-4): a
|
||||
// glBindImageTexture on a texture whose storage is not yet defined reaches here, finds
|
||||
// no defined level and replays nothing.
|
||||
// THE MARKER IS RAISED WHERE A LEVEL IS ACTUALLY REPLAYED, not on entry (review
|
||||
// N-4). ImageBindableHint IS the prevention half of mitigation 1, and D's own
|
||||
// metadata-respecify arm makes the hint's ARRIVAL the trigger for entering this
|
||||
// function - so a glBindImageTexture on a texture whose storage is not yet defined
|
||||
// reaches here, finds no defined level, replays nothing, and would nevertheless have
|
||||
// counted (and, under split, aborted at) the very emulation the hint exists to
|
||||
// prevent. What the marker is about is stated in its own comment above: reaching
|
||||
// BACK into the client's dirty model for texels. No texels owed, nothing to mark.
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
// P4a (review M-1): ON THE HANDLE ARM THE RE-DIRTY HAS TO REACH THE APPLIER'S SET,
|
||||
// not only the frontend's model. The client cleared its own flags when it emitted
|
||||
@@ -6688,7 +6465,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// Both models are written, not one: the frontend's because the legacy arm reads it
|
||||
// and because the client's own NoteLevelDirty hook rides on it, the applier's
|
||||
// because that is what this arm consumes.
|
||||
Bool countedRemint = false;
|
||||
Bool markedRemintPull = false;
|
||||
const MG_Pipe::MGPipeHandle rearmRes =
|
||||
TextureResourceSubsystemEnabled()
|
||||
? [&]() {
|
||||
@@ -6708,6 +6485,41 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
"pending set - they would be allocated empty",
|
||||
stateTextureObject->GetExternalIndex());
|
||||
}
|
||||
#endif
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
// P5c (gt): under an active transport the replay loop below reaches the layer-1
|
||||
// texture guard (MarkStorageDirty on a frontend object is Fatal{RoleViolation,
|
||||
// "texture-legacy-arm"}) BEFORE the N-4 marker it owns - so the marker is hoisted
|
||||
// here, ahead of the first guarded contact, with its semantics unchanged: raised
|
||||
// only when a level would actually be replayed. The predicate is answered by the
|
||||
// server's own staged-texture store rather than the frontend's extent walk: a
|
||||
// Defined level has a non-zero extent and bytes on the frontend (the two conditions
|
||||
// the loop tests), and an undefined one reads {0,0,0} and is skipped. A texture with
|
||||
// no applier record (rearmRes null, the MGLOG_E_ONCE arm above) falls through to the
|
||||
// guard, which names the same violation one level down.
|
||||
if (MG_Config::Transport != MG_Config::TransportMode::Monolith &&
|
||||
!MG_Pipe::MGPipeHandleIsNull(rearmRes)) {
|
||||
const auto* rearmRecord = PipeTextureRecordForHandle(rearmRes);
|
||||
if (rearmRecord != nullptr) {
|
||||
auto& rearmStore = MG_Remote::Server::ServerStagedTexture();
|
||||
const Uint64 rearmKey = MG_Remote::Server::StagedTextureStore::KeyForHandle(rearmRes);
|
||||
Bool anyLevelWouldReplay = false;
|
||||
for (const auto& uploadTarget :
|
||||
BufferImpl::StagedUploadTargetsForPipeTarget(rearmRecord->Desc.Target)) {
|
||||
for (Uint32 level = 0; level < rearmRecord->Desc.Levels; ++level) {
|
||||
if (rearmStore.IsLevelDefined(rearmKey, static_cast<Uint16>(uploadTarget),
|
||||
static_cast<Uint16>(level))) {
|
||||
anyLevelWouldReplay = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (anyLevelWouldReplay) break;
|
||||
}
|
||||
if (anyLevelWouldReplay) {
|
||||
MG_Pipe::MGPipeUnmigratedEmulation("texture-remint-pull");
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (auto* mipmapObject = MG_State::GLState::AsMipmapTexture(stateTextureObject.get())) {
|
||||
const auto levelCount = mipmapObject->GetMipmapLevelCount();
|
||||
@@ -6716,37 +6528,15 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
const auto levelTexelSize = mipmapObject->GetMipmapTexelSize(uploadTarget, level);
|
||||
if (levelTexelSize.x() <= 0 || levelTexelSize.y() <= 0) continue;
|
||||
if (mipmapObject->GetMipmapByteSize(uploadTarget, level) == 0) continue;
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
// This level's entry in the applier's pending set, read BEFORE the re-arm
|
||||
// below turns it into a whole-level box: the client writes it still owes
|
||||
// (see AdoptDriverLevelIntoShadow). Resolved per level - the re-arm may grow
|
||||
// the record's set and move what an earlier pointer named.
|
||||
const MG_Pipe::MGPipeResourceRecord* rearmRecord =
|
||||
MG_Pipe::MGPipeHandleIsNull(rearmRes) ? nullptr : PipeTextureRecordForHandle(rearmRes);
|
||||
const MG_Pipe::MGPipeResourceRecord::PendingUpload* rearmPending =
|
||||
rearmRecord != nullptr ? FindPipeTextureUpload(*rearmRecord, static_cast<Uint16>(uploadTarget),
|
||||
static_cast<Uint16>(level))
|
||||
: nullptr;
|
||||
#endif
|
||||
if (hadBackendStorage &&
|
||||
!AdoptDriverLevelIntoShadow(m_backendTextureId, *this, *stateTextureObject,
|
||||
*mipmapObject, uploadTarget, level
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
,
|
||||
rearmPending
|
||||
#endif
|
||||
)) {
|
||||
MGLOG_D("Texture %u level %u: re-minting from the shadow, the driver's copy is not "
|
||||
"readable here",
|
||||
stateTextureObject->GetExternalIndex(), level);
|
||||
}
|
||||
mipmapObject->MarkStorageDirty(uploadTarget, level, true);
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
// THE COUNTER BEHIND ROADMAP OPEN QUESTION 2 (final review M-A): once per
|
||||
// transition that replays a level of storage the backend already held,
|
||||
// not once per level.
|
||||
if (!countedRemint) {
|
||||
countedRemint = true;
|
||||
// N-4: one level owed is what makes this an unmigrated emulation. Once
|
||||
// per transition, not once per level: the marker names the SITE.
|
||||
if (!markedRemintPull) {
|
||||
MG_Pipe::MGPipeUnmigratedEmulation("texture-remint-pull");
|
||||
markedRemintPull = true;
|
||||
// THE COUNTER BEHIND ROADMAP OPEN QUESTION 2 (final review M-A): one per
|
||||
// transition that replays a level of storage the backend already held.
|
||||
if (hadBackendStorage && MG_Util::PipeStats::Enabled()) {
|
||||
MG_Util::PipeStats::AddCalls(MG_Util::PipeStats::CallClass::TextureRemintPulls, 1);
|
||||
}
|
||||
@@ -6939,7 +6729,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// they use, so the type stays trivially default-constructible and the
|
||||
// declaration costs nothing on the levels that never reach the ring.
|
||||
struct UnpackStagingBlock {
|
||||
const Uint8* src; // top-left texel of the region in the level's upload bytes
|
||||
const Uint8* src; // top-left texel of the region in the level shadow
|
||||
SizeT rowBytes; // bytes per region row (region width * bpp)
|
||||
SizeT rows; // region height
|
||||
SizeT slices; // region depth (1 for 2D)
|
||||
@@ -8758,9 +8548,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
ApplyImageBindableStorageWidening(imageWidening, &glInternalFormat, &glFormat, &glType);
|
||||
const auto& uploadTargets = MGB_UPLOAD_TARGETS(textureMipmapObject);
|
||||
ScopedDefaultUnpackState unpackState;
|
||||
// Per-level scratch of the exact-footprint path, hoisted to reuse capacity.
|
||||
Vector<MG_State::GLState::MipmapDirtyRegion> dirtyFootprint;
|
||||
Vector<UnpackStagingBlock> stagingBlockOverflow;
|
||||
for (auto& uploadTarget : uploadTargets) {
|
||||
for (SizeT level = 0; level < mipmapCount; ++level) {
|
||||
if (!MGB_LEVEL_NEEDS_UPLOAD(textureMipmapObject, uploadTarget, level)) {
|
||||
@@ -8798,51 +8585,22 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
Vector<Uint8> packedUploadData;
|
||||
uploadData = PreparePackedNormUpload(MGB_STORAGE_FORMAT(textureMipmapObject), texelSize,
|
||||
uploadData, byteSize, &glType, packedUploadData);
|
||||
// Leaves `uploadData` pointing at its own buffer when it fires, with
|
||||
// texels four components wide where the shadow's are one or two.
|
||||
// Leaves `uploadData` pointing at its own buffer when it fires, which
|
||||
// is exactly what takes the sub-rect fast path below out of play: that
|
||||
// path strides into the SHADOW, and the widened texels are four
|
||||
// components wide where the shadow's are one or two.
|
||||
Vector<Uint8> imageWidenedUploadData;
|
||||
uploadData = PrepareImageWidenedUpload(imageWidening, texelSize, uploadData, byteSize,
|
||||
imageWidenedUploadData);
|
||||
const IntVec3 uploadSize =
|
||||
GetBackendUploadSize(MGB_TEXTURE_TARGET(stateTextureObject), texelSize);
|
||||
// Sub-rect upload: when only a region of the level changed (a
|
||||
// 16x16 sprite in a 1024x512 atlas, the per-frame lightmap), upload
|
||||
// just that region with UNPACK_ROW_LENGTH striding into the level.
|
||||
// Not an optimization alone: the shadow never sees a GPU write, so
|
||||
// the texels OUTSIDE the region may be stale there and must not go
|
||||
// up over what the GPU drew. Every conversion above rewrites the
|
||||
// whole level texel for texel into a tight buffer of its own, so the
|
||||
// region is taken from whichever buffer `uploadData` now names, at
|
||||
// that buffer's bytes per texel.
|
||||
//
|
||||
// THE SAME ON EVERY ARM (P11 M). `mipData` is the frontend shadow on
|
||||
// the pull and push-monolith arms and the server's staged level on the
|
||||
// split arms - the same tight client layout either way - and the
|
||||
// conversions run on whichever side uploads, so the handle arm takes
|
||||
// its region from the converted buffer exactly as the shadow arm
|
||||
// does. What it must NOT take from the record then is the carried
|
||||
// pitch and offset (below): those index the client's layout, not the
|
||||
// converted one.
|
||||
SizeT uploadBytes = 0;
|
||||
if (uploadData == mipData) {
|
||||
uploadBytes = byteSize;
|
||||
} else if (!imageWidenedUploadData.empty() &&
|
||||
uploadData == imageWidenedUploadData.data()) {
|
||||
uploadBytes = imageWidenedUploadData.size();
|
||||
} else if (!packedUploadData.empty() && uploadData == packedUploadData.data()) {
|
||||
uploadBytes = packedUploadData.size();
|
||||
} else if (!widenedUploadData.empty() && uploadData == widenedUploadData.data()) {
|
||||
uploadBytes = widenedUploadData.size();
|
||||
} else if (!convertedUploadData.empty() && uploadData == convertedUploadData.data()) {
|
||||
uploadBytes = convertedUploadData.size() * sizeof(Float);
|
||||
}
|
||||
// A 1D array's ES image is a 2D array one texel high with the layers
|
||||
// in depth, while the shadow keeps the layers as rows: same texels in
|
||||
// the same order, so a region maps across by moving its y to z. (The
|
||||
// target is the descriptor's on the split arms: the server may not
|
||||
// name the client's texture object.)
|
||||
const Bool layersAsRows =
|
||||
MGB_TEXTURE_TARGET(stateTextureObject) == TextureTarget::Texture1DArray;
|
||||
// 16x16 sprite in a 1024x512 atlas, the per-frame lightmap) and
|
||||
// the shadow bytes go to the driver unconverted, upload just that
|
||||
// region with UNPACK_ROW_LENGTH striding into the level shadow.
|
||||
// Conversion fallbacks rewrite the whole level into a fresh
|
||||
// buffer, so they stay on the full-level path, as do targets
|
||||
// whose backend upload size differs from the shadow's texel size.
|
||||
// P4a (D-D6, and ARCHITECTURE.md:321's ONE item moved out of the
|
||||
// Espryt do-not-touch list): the DECISION below is unchanged and
|
||||
// stays on the server - it is the side that pays the GPU cost, and
|
||||
@@ -8893,16 +8651,13 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
const SizeT texelCount = static_cast<SizeT>(texelSize.x()) *
|
||||
static_cast<SizeT>(texelSize.y()) *
|
||||
static_cast<SizeT>(std::max(texelSize.z(), 1));
|
||||
// Whether a box of the level can be addressed at all: whole texels in
|
||||
// the upload bytes, and an ES image shaped like the shadow.
|
||||
const Bool regionsAddressable =
|
||||
!dirtyRegion.Empty() && texelCount > 0 && uploadBytes > 0 &&
|
||||
uploadBytes % texelCount == 0 &&
|
||||
(layersAsRows ? std::max(texelSize.z(), 1) == 1
|
||||
: uploadSize.x() == texelSize.x() && uploadSize.y() == texelSize.y() &&
|
||||
std::max(uploadSize.z(), 1) == std::max(texelSize.z(), 1));
|
||||
const Bool subRectEligible = regionsAddressable && !dirtyRegion.CoversWholeLevel(texelSize);
|
||||
const SizeT bpp = regionsAddressable ? uploadBytes / texelCount : 0;
|
||||
const Bool subRectEligible =
|
||||
uploadData == mipData && !dirtyRegion.Empty() &&
|
||||
!dirtyRegion.CoversWholeLevel(texelSize) && texelCount > 0 &&
|
||||
byteSize % texelCount == 0 && uploadSize.x() == texelSize.x() &&
|
||||
uploadSize.y() == texelSize.y() &&
|
||||
std::max(uploadSize.z(), 1) == std::max(texelSize.z(), 1);
|
||||
const SizeT bpp = subRectEligible ? byteSize / texelCount : 0;
|
||||
const IntVec3 regionSize = {dirtyRegion.hi.x() - dirtyRegion.lo.x(),
|
||||
dirtyRegion.hi.y() - dirtyRegion.lo.y(),
|
||||
dirtyRegion.hi.z() - dirtyRegion.lo.z()};
|
||||
@@ -8942,21 +8697,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// P11 M: THE CARRIED PITCH AND OFFSET INDEX THE CLIENT'S LAYOUT - the
|
||||
// level shadow, or the server's staged copy of it, which is `mipData`.
|
||||
// A converted level's region is cut from the conversion's own tight
|
||||
// buffer (above), whose texels are wider, so there the record's numbers
|
||||
// name the wrong bytes and the pitch is derived from the upload
|
||||
// buffer's bpp instead - which is what the shadow arm does.
|
||||
const Bool carriedLayoutApplies = uploadData == mipData;
|
||||
const SizeT carriedRowBytes =
|
||||
(pendingUpload != nullptr && pendingStridesAgree && carriedLayoutApplies &&
|
||||
(pendingUpload != nullptr && pendingStridesAgree &&
|
||||
!pendingUpload->Regions.empty() &&
|
||||
pendingUpload->Regions.front().SrcRowStride != 0)
|
||||
? static_cast<SizeT>(pendingUpload->Regions.front().SrcRowStride)
|
||||
: 0;
|
||||
const SizeT carriedSliceBytes =
|
||||
(pendingUpload != nullptr && pendingStridesAgree && carriedLayoutApplies &&
|
||||
(pendingUpload != nullptr && pendingStridesAgree &&
|
||||
!pendingUpload->Regions.empty() &&
|
||||
pendingUpload->Regions.front().SrcSliceStride != 0)
|
||||
? static_cast<SizeT>(pendingUpload->Regions.front().SrcSliceStride)
|
||||
@@ -8971,14 +8719,13 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// refusal in the commit that started reading them while the offset -
|
||||
// which decides the ADDRESS glTexSubImage reads (w*bpp x h x d) bytes
|
||||
// from - was consumed raw. The cross-check is free, because
|
||||
// rectUploadPtr four lines down computes exactly the same number from
|
||||
// rectShadowPtr four lines down computes exactly the same number from
|
||||
// the region origin and the two pitches. A record whose regions
|
||||
// disagree with their own origins is corrupt, so on disagreement the
|
||||
// carried offsets are DROPPED - every use site falls back to the
|
||||
// derived pointer, which is what the legacy arm sends - and one named
|
||||
// line says so. Gated on subRectEligible because bpp is 0 otherwise
|
||||
// and the regions are not read at all, and on carriedLayoutApplies
|
||||
// because a converted level never reads them (MGB_RECT_SRC_PTR).
|
||||
// and the regions are not read at all.
|
||||
//
|
||||
// FIX A2 IS THE SECOND LEGITIMATE DISAGREEMENT, and the fallback is
|
||||
// exactly right for it: a level too large to stage whole crosses as
|
||||
@@ -8989,7 +8736,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// which is what the derived pointer names - and those piece-relative
|
||||
// offsets are precisely the ones that must not be used here.
|
||||
Bool pendingOffsetsAgree = true;
|
||||
if (pendingUpload != nullptr && subRectEligible && carriedLayoutApplies) {
|
||||
if (pendingUpload != nullptr && subRectEligible) {
|
||||
for (const auto& region : pendingUpload->Regions) {
|
||||
const SizeT derivedOffset = static_cast<SizeT>(region.Z) * levelSliceBytes +
|
||||
static_cast<SizeT>(region.Y) * levelRowBytes +
|
||||
@@ -9024,7 +8771,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// whole level while the touched texels are a few percent of
|
||||
// it. The storage's bounded rect list recovers the true
|
||||
// footprint; each rect is uploaded with the same
|
||||
// ROW_LENGTH striding into the level as the box
|
||||
// ROW_LENGTH striding into the level shadow as the box
|
||||
// path. The storage only hands the list out when its
|
||||
// summed area is materially smaller than the box (0
|
||||
// otherwise), so the extra calls always move fewer bytes.
|
||||
@@ -9038,27 +8785,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// whole story" (D-D3), which is the same statement the
|
||||
// frontend's GetStorageDirtyRects makes by returning 0 - so
|
||||
// both arms reach the box branch below by the same route.
|
||||
//
|
||||
// P11 M2: the record's list is the level's EXACT footprint now
|
||||
// (TextureEmit.h), which the storage's own rect list only
|
||||
// covered, and the storage withheld that list - "0 rects" - when
|
||||
// it held more rects than it keeps or when they added up to 3/4
|
||||
// of the union box (one driver call on nearly the same bytes).
|
||||
// Both cut-offs are this side's to apply now, so the box-or-rects
|
||||
// choice on a texture the GPU has not written is what it was.
|
||||
// (Once the GPU may have written it, the footprint below uploads
|
||||
// every region exactly, whatever this chose.) Never a partial
|
||||
// list: a truncated list is dropped writes.
|
||||
SizeT summedTexels = 0;
|
||||
for (const auto& region : pendingUpload->Regions) {
|
||||
summedTexels += static_cast<SizeT>(region.W) * static_cast<SizeT>(region.H) *
|
||||
static_cast<SizeT>(std::max<Uint32>(region.D, 1));
|
||||
}
|
||||
const Bool listWithheld =
|
||||
pendingUpload->Regions.size() < 2 ||
|
||||
pendingUpload->Regions.size() > MG_State::GLState::MipmapStorage::kMaxDirtyRects ||
|
||||
summedTexels * 4 >= dirtyRegion.TexelCount() * 3;
|
||||
dirtyRectCount = listWithheld ? 0 : pendingUpload->Regions.size();
|
||||
dirtyRectCount =
|
||||
std::min<SizeT>(pendingUpload->Regions.size(),
|
||||
MG_State::GLState::MipmapStorage::kMaxDirtyRects);
|
||||
for (SizeT r = 0; r < dirtyRectCount; ++r) {
|
||||
const auto& region = pendingUpload->Regions[r];
|
||||
dirtyRects[r] = MG_State::GLState::MipmapDirtyRegion{
|
||||
@@ -9089,51 +8818,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
dirtyRectCount = 0;
|
||||
}
|
||||
}
|
||||
// Everything above - the union box, the ring's one-box rule, the rect
|
||||
// list with its merges, fold and 3/4 cut-off - may upload shadow texels
|
||||
// the client did not write, which is only harmless while the driver
|
||||
// still holds those texels as they were last uploaded. Once it may hold
|
||||
// GPU writes, the level goes up as exactly the texels written, one box
|
||||
// (one ring job) each, whatever that costs: more boxes, and a union box
|
||||
// that spans the whole level no longer means a whole-level upload.
|
||||
const MG_State::GLState::MipmapDirtyRegion* uploadRects = dirtyRects;
|
||||
SizeT uploadRectCount = dirtyRectCount;
|
||||
if (m_driverMayHoldGpuWrites && regionsAddressable) {
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
if (pendingUpload != nullptr) {
|
||||
// The handle arm's footprint is the record's region list, all
|
||||
// of it and in order (MGB_RECT_SRC_PTR indexes the regions by
|
||||
// position); a box-only entry is its union box.
|
||||
dirtyFootprint.clear();
|
||||
for (const auto& region : pendingUpload->Regions) {
|
||||
dirtyFootprint.push_back(MG_State::GLState::MipmapDirtyRegion{
|
||||
IntVec3{region.X, region.Y, region.Z},
|
||||
IntVec3{region.X + static_cast<Int32>(region.W),
|
||||
region.Y + static_cast<Int32>(region.H),
|
||||
region.Z + static_cast<Int32>(region.D)}});
|
||||
}
|
||||
} else
|
||||
#endif
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
// With an active transport and no record behind the level, the
|
||||
// server's own whole-level GPU-dirty mark is the whole story (the
|
||||
// same reason the rect list above is not read here).
|
||||
if (MGB_STAGED_TEXTURE_LIVE) {
|
||||
dirtyFootprint.clear();
|
||||
} else
|
||||
#endif
|
||||
textureMipmapObject->GetStorageDirtyFootprint(uploadTarget, level, dirtyFootprint);
|
||||
// One box is the union box itself, which the branches below already
|
||||
// upload exactly (as the whole level when it is the whole level).
|
||||
if (dirtyFootprint.size() >= 2) {
|
||||
uploadRects = dirtyFootprint.data();
|
||||
uploadRectCount = dirtyFootprint.size();
|
||||
} else {
|
||||
uploadRectCount = 0;
|
||||
}
|
||||
}
|
||||
const Bool perRectUpload = regionsAddressable && uploadRectCount >= 2;
|
||||
const auto rectUploadPtr = [&](const MG_State::GLState::MipmapDirtyRegion& rect) {
|
||||
const auto rectShadowPtr = [&](const MG_State::GLState::MipmapDirtyRegion& rect) {
|
||||
return static_cast<const Uint8*>(uploadData) +
|
||||
static_cast<SizeT>(rect.lo.z()) * levelSliceBytes +
|
||||
static_cast<SizeT>(rect.lo.y()) * levelRowBytes +
|
||||
@@ -9142,10 +8827,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// m-1 / D-D3, "carried, never inferred": MGPSubRegion::SrcOffset is the byte offset of that
|
||||
// region's origin into the level shadow - the same number the lambda above derives from the
|
||||
// origin and the two strides - and on the handle arm it is READ rather than re-derived, after
|
||||
// the cross-check above has agreed that the two spellings say the same thing (N-5). It is read
|
||||
// only while carriedLayoutApplies (uploadData == mipData), so the base the offset is relative to
|
||||
// is the level shadow itself and never a conversion buffer: since dev's 8966d5c2 a converted
|
||||
// level is sub-rect eligible too, and its rects are cut at the conversion's bpp (rectUploadPtr).
|
||||
// the cross-check above has agreed that the two spellings say the same thing (N-5). Every site
|
||||
// that uses it is inside `subRectEligible`, which requires uploadData == mipData, so the base
|
||||
// the offset is relative to is the level shadow itself and never a conversion buffer.
|
||||
//
|
||||
// THREE USE SITES, AND THE FIRST OF THEM IS UNREACHABLE (N-5's second half, and the correction
|
||||
// to what esprytobj-v2.md m-1 claimed): dirtyRectCount is forced to 0 whenever
|
||||
@@ -9160,29 +8844,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// pre-P4a call with one pair of parentheses. #undef'd with the rest.
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
#define MGB_RECT_SRC_PTR(idx, rect) \
|
||||
((pendingUpload != nullptr && pendingOffsetsAgree && carriedLayoutApplies && \
|
||||
((pendingUpload != nullptr && pendingOffsetsAgree && \
|
||||
static_cast<SizeT>(idx) < pendingUpload->Regions.size()) \
|
||||
? static_cast<const Uint8*>(uploadData) + \
|
||||
static_cast<SizeT>(pendingUpload->Regions[static_cast<SizeT>(idx)].SrcOffset) \
|
||||
: rectUploadPtr(rect))
|
||||
: rectShadowPtr(rect))
|
||||
#else
|
||||
#define MGB_RECT_SRC_PTR(idx, rect) (rectUploadPtr(rect))
|
||||
#define MGB_RECT_SRC_PTR(idx, rect) (rectShadowPtr(rect))
|
||||
#endif
|
||||
// A shadow-grid box as the ES image addresses it, and the image height
|
||||
// that strides the source to match; they differ only for a 1D array
|
||||
// (layersAsRows), whose rows are ES layers of a one-texel-high image.
|
||||
struct BackendBox {
|
||||
GLint x, y, z;
|
||||
GLsizei w, h, d;
|
||||
};
|
||||
const auto ToBackendBox = [&](const MG_State::GLState::MipmapDirtyRegion& rect) {
|
||||
const GLsizei w = static_cast<GLsizei>(rect.hi.x() - rect.lo.x());
|
||||
const GLsizei h = static_cast<GLsizei>(rect.hi.y() - rect.lo.y());
|
||||
const GLsizei d = static_cast<GLsizei>(rect.hi.z() - rect.lo.z());
|
||||
return layersAsRows ? BackendBox{rect.lo.x(), 0, rect.lo.y(), w, 1, h}
|
||||
: BackendBox{rect.lo.x(), rect.lo.y(), rect.lo.z(), w, h, d};
|
||||
};
|
||||
const GLint imageHeight = layersAsRows ? 1 : texelSize.y();
|
||||
// Unpack-ring staging plan, decided ONCE for whichever branch
|
||||
// below runs: either every glTexSubImage of this level sources
|
||||
// from the ring or none does, so the pixel-unpack binding is
|
||||
@@ -9197,21 +8866,15 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// client-pointer path makes the driver walk, which strides over
|
||||
// the whole level width.
|
||||
UnpackStagingBlock
|
||||
stagingBlockArray[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
|
||||
UnpackStagingBlock* stagingBlocks = stagingBlockArray;
|
||||
stagingBlocks[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
|
||||
SizeT stagingBlockCount = 0;
|
||||
const Bool ringUsable = BufferImpl::UnpackRingAvailable();
|
||||
if (!ringUsable) {
|
||||
// Nothing to plan: every branch below keeps the client
|
||||
// pointer and its ROW_LENGTH striding, unchanged.
|
||||
} else if (perRectUpload) {
|
||||
// Only an exact footprint outgrows the array (see uploadRects).
|
||||
if (uploadRectCount > MG_State::GLState::MipmapStorage::kMaxDirtyRects) {
|
||||
stagingBlockOverflow.resize(uploadRectCount);
|
||||
stagingBlocks = stagingBlockOverflow.data();
|
||||
}
|
||||
for (SizeT r = 0; r < uploadRectCount; ++r) {
|
||||
const auto& rect = uploadRects[r];
|
||||
} else if (subRectEligible && dirtyRectCount >= 2) {
|
||||
for (SizeT r = 0; r < dirtyRectCount; ++r) {
|
||||
const auto& rect = dirtyRects[r];
|
||||
stagingBlocks[r] = {
|
||||
MGB_RECT_SRC_PTR(r, rect),
|
||||
static_cast<SizeT>(rect.hi.x() - rect.lo.x()) * bpp,
|
||||
@@ -9221,7 +8884,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
levelSliceBytes,
|
||||
0};
|
||||
}
|
||||
stagingBlockCount = uploadRectCount;
|
||||
stagingBlockCount = dirtyRectCount;
|
||||
} else if (subRectEligible) {
|
||||
stagingBlocks[0] = {regionPtr,
|
||||
static_cast<SizeT>(regionSize.x()) * bpp,
|
||||
@@ -9298,10 +8961,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
switch (MapToBackendTextureTarget(MGB_TEXTURE_TARGET(stateTextureObject))) {
|
||||
case TextureTarget::Texture2D:
|
||||
case TextureTarget::TextureCubeMap:
|
||||
if (perRectUpload) {
|
||||
if (subRectEligible && dirtyRectCount >= 2) {
|
||||
if (!ringStaged) g_GLESFuncs.glPixelStorei(GL_UNPACK_ROW_LENGTH, texelSize.x());
|
||||
for (SizeT r = 0; r < uploadRectCount; ++r) {
|
||||
const auto& rect = uploadRects[r];
|
||||
for (SizeT r = 0; r < dirtyRectCount; ++r) {
|
||||
const auto& rect = dirtyRects[r];
|
||||
g_GLESFuncs.glTexSubImage2D(
|
||||
glUploadTarget, static_cast<GLint>(level), rect.lo.x(),
|
||||
rect.lo.y(), static_cast<GLsizei>(rect.hi.x() - rect.lo.x()),
|
||||
@@ -9337,18 +9000,22 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// ES 3.2 has GL_TEXTURE_CUBE_MAP_ARRAY natively and it stores exactly
|
||||
// like a 2D array whose depth is 6 * the cube count.
|
||||
case TextureTarget::TextureCubeMapArray:
|
||||
if (perRectUpload) {
|
||||
if (subRectEligible && dirtyRectCount >= 2) {
|
||||
if (!ringStaged) {
|
||||
g_GLESFuncs.glPixelStorei(GL_UNPACK_ROW_LENGTH, texelSize.x());
|
||||
g_GLESFuncs.glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, imageHeight);
|
||||
g_GLESFuncs.glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, texelSize.y());
|
||||
}
|
||||
for (SizeT r = 0; r < uploadRectCount; ++r) {
|
||||
const auto box = ToBackendBox(uploadRects[r]);
|
||||
for (SizeT r = 0; r < dirtyRectCount; ++r) {
|
||||
const auto& rect = dirtyRects[r];
|
||||
g_GLESFuncs.glTexSubImage3D(
|
||||
glUploadTarget, static_cast<GLint>(level), box.x, box.y, box.z,
|
||||
box.w, box.h, box.d, glFormat, glType,
|
||||
glUploadTarget, static_cast<GLint>(level), rect.lo.x(),
|
||||
rect.lo.y(), rect.lo.z(),
|
||||
static_cast<GLsizei>(rect.hi.x() - rect.lo.x()),
|
||||
static_cast<GLsizei>(rect.hi.y() - rect.lo.y()),
|
||||
static_cast<GLsizei>(rect.hi.z() - rect.lo.z()), glFormat,
|
||||
glType,
|
||||
ringStaged ? UnpackRingPixelOffset(stagingBlocks[r].offset)
|
||||
: static_cast<const void*>(MGB_RECT_SRC_PTR(r, uploadRects[r])));
|
||||
: static_cast<const void*>(MGB_RECT_SRC_PTR(r, rect)));
|
||||
}
|
||||
if (!ringStaged) {
|
||||
g_GLESFuncs.glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
||||
@@ -9357,12 +9024,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
} else if (subRectEligible) {
|
||||
if (!ringStaged) {
|
||||
g_GLESFuncs.glPixelStorei(GL_UNPACK_ROW_LENGTH, texelSize.x());
|
||||
g_GLESFuncs.glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, imageHeight);
|
||||
g_GLESFuncs.glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, texelSize.y());
|
||||
}
|
||||
const auto box = ToBackendBox(dirtyRegion);
|
||||
g_GLESFuncs.glTexSubImage3D(
|
||||
glUploadTarget, static_cast<GLint>(level), box.x, box.y, box.z, box.w, box.h,
|
||||
box.d, glFormat, glType,
|
||||
glUploadTarget, static_cast<GLint>(level), dirtyRegion.lo.x(),
|
||||
dirtyRegion.lo.y(), dirtyRegion.lo.z(),
|
||||
static_cast<GLsizei>(regionSize.x()),
|
||||
static_cast<GLsizei>(regionSize.y()),
|
||||
static_cast<GLsizei>(regionSize.z()), glFormat, glType,
|
||||
ringStaged ? UnpackRingPixelOffset(stagingBlocks[0].offset)
|
||||
: static_cast<const void*>(regionPtr));
|
||||
if (!ringStaged) {
|
||||
@@ -10347,21 +10016,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
g_boundTexturesCache;
|
||||
TwinRegistry<MG_State::GLState::ITextureObject, BackendTextureObject, MG_Pipe::MGPipeKind::Texture> g_backendTextureObjects;
|
||||
|
||||
void NoteDriverSideTextureWrite(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject) {
|
||||
SharedPtr<MG_State::GLState::ITextureObject> storage = textureObject;
|
||||
// Bounded: GL resolves a view of a view to the original storage, so this takes one step.
|
||||
for (Uint hop = 0; storage && storage->IsTextureView() && hop < 4; ++hop) {
|
||||
storage = storage->GetViewStorageOwner();
|
||||
}
|
||||
if (!storage) return;
|
||||
auto* slot = g_backendTextureObjects.Find(storage.get());
|
||||
auto& backendObj = slot ? *slot : g_backendTextureObjects.GetOrCreate(storage);
|
||||
if (!backendObj) {
|
||||
backendObj = MakeShared<BackendTextureObject>();
|
||||
}
|
||||
backendObj->NoteDriverSideWrite();
|
||||
}
|
||||
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
// P5e (id), CONTRACT-P5E §4.1. See Managers.h for the contract.
|
||||
BackendTextureObject* ResolveTextureTwin(MG_Pipe::MGPipeHandle res) {
|
||||
@@ -10382,18 +10036,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
if (!*slot) *slot = MakeShared<BackendTextureObject>();
|
||||
return slot->get();
|
||||
}
|
||||
|
||||
void NoteDriverSideTextureWriteByHandle(MG_Pipe::MGPipeHandle res) {
|
||||
// The storage owner's handle, one hop per view like the frontend walk above (the
|
||||
// client composes a view of a view onto its root, so one hop is the real shape).
|
||||
MG_Pipe::MGPipeHandle storage = res;
|
||||
for (Uint hop = 0; hop < 4 && !MG_Pipe::MGPipeHandleIsNull(storage); ++hop) {
|
||||
const auto* record = PipeTextureRecordForHandle(storage);
|
||||
if (record == nullptr || MG_Pipe::MGPipeHandleIsNull(record->Desc.ViewOf)) break;
|
||||
storage = record->Desc.ViewOf;
|
||||
}
|
||||
if (auto* twin = ResolveTextureTwin(storage)) twin->NoteDriverSideWrite();
|
||||
}
|
||||
#endif
|
||||
} // namespace TextureImpl
|
||||
|
||||
@@ -10578,9 +10220,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
return false;
|
||||
}
|
||||
backendTextureObject->SyncMipmapsToBackend(textureObject);
|
||||
// From here on every draw, clear and blit into this framebuffer can write the
|
||||
// texture behind the shadow's back.
|
||||
TextureImpl::NoteDriverSideTextureWrite(textureObject);
|
||||
if (attachmentObject.IsLayered()) {
|
||||
g_GLESFuncs.glFramebufferTexture(glFBOTarget, glBackendAttachment,
|
||||
backendTextureObject->GetBackendTextureId(),
|
||||
@@ -10960,9 +10599,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
if (MG_Config::Transport != MG_Config::TransportMode::Monolith) {
|
||||
backendTextureObject->SyncMipmapsToBackendByHandle(surface.Res);
|
||||
// From here on every draw, clear and blit into this framebuffer can write the
|
||||
// texture behind the staged shadow's back (the frontend arm's note, by handle).
|
||||
TextureImpl::NoteDriverSideTextureWriteByHandle(surface.Res);
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
@@ -10979,9 +10615,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
return false;
|
||||
}
|
||||
backendTextureObject->SyncMipmapsToBackend(monolithTexture);
|
||||
// From here on every draw, clear and blit into this framebuffer can write the
|
||||
// texture behind the shadow's back.
|
||||
TextureImpl::NoteDriverSideTextureWrite(monolithTexture);
|
||||
}
|
||||
const auto uploadTarget = static_cast<TextureUploadTarget>(surface.UploadTarget);
|
||||
if (surface.Layered != 0) {
|
||||
|
||||
@@ -1963,10 +1963,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// allocation, or capture the old native contents, merge pending
|
||||
// upload regions and re-arm the server's whole-level replay set.
|
||||
// First allocations use staged bytes directly. No frontend dirty
|
||||
// flag, allocator or pixel-store object participates. P9 W2: a level
|
||||
// the driver does not hold (defined after the last sync) is never read
|
||||
// back, and a readback the driver refuses falls back to the staged
|
||||
// level when the store covers it (notes/p9/W2-REMINT.md).
|
||||
// flag, allocator or pixel-store object participates.
|
||||
void RequireImageBindableStorageByHandle(MG_Pipe::MGPipeHandle res,
|
||||
const MG_Pipe::MGPipeResourceRecord& record);
|
||||
#endif
|
||||
@@ -1975,9 +1972,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
// carrier the storage is an integer texture holding codes and glGetTexImage still owes
|
||||
// the application floats.
|
||||
Bool RequiresImageBindableStorage() const { return m_imageBindableStorageRequired; }
|
||||
// See m_driverMayHoldGpuWrites. Callers holding the STATE texture use
|
||||
// NoteDriverSideTextureWrite, which also reaches the storage behind a view.
|
||||
void NoteDriverSideWrite() { m_driverMayHoldGpuWrites = true; }
|
||||
void Bind(GLenum target, Uint unit = TempTextureUnit);
|
||||
Uint GetBackendTextureId() const;
|
||||
|
||||
@@ -2094,15 +2088,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
Bool m_isInitialized = false;
|
||||
Bool m_imageBindableStorageRequired = false;
|
||||
Bool m_backendStorageImmutable = false;
|
||||
// Whether the driver texture may hold texels the shadow never saw. Set the first time
|
||||
// anything other than a texel upload can write it - an application framebuffer
|
||||
// attachment, a writable image binding, a copy or blit into it, a driver-side mipmap
|
||||
// generation - and never cleared. Until then the driver holds, outside a level's
|
||||
// pending writes, exactly the shadow bytes it was last sent, so those writes may go up
|
||||
// as their union box (one unpack-ring job, which is what Mali needs); from then on
|
||||
// only the texels the client wrote may go up, since the shadow is stale everywhere
|
||||
// else. See SyncMipmapsToBackend.
|
||||
Bool m_driverMayHoldGpuWrites = false;
|
||||
// Latches the "this driver has no buffer textures" report to once per texture. The
|
||||
// report is emitted from the respecify path, which bails before recording the state
|
||||
// it was asked to apply - so without the latch the texture stays permanently dirty
|
||||
@@ -2272,11 +2257,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
SharedPtr<BackendTextureObject>& SyncTextureObjectToBackend(
|
||||
const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
|
||||
Bool imageBindableStorageRequired = false);
|
||||
// Every path that lets the DRIVER write a texture's texels calls this (see
|
||||
// BackendTextureObject::m_driverMayHoldGpuWrites): an application framebuffer attachment,
|
||||
// a writable image binding, a copy, blit or mipmap generation into it. A view writes its
|
||||
// storage texture's image, so the storage texture is the one marked.
|
||||
void NoteDriverSideTextureWrite(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject);
|
||||
#if MOBILEGL_PIPE_PUSH
|
||||
// ---- P5e SEAM (MG_Remote/CONTRACT-P5E.md §4.2, §5.2; declared by c0e, bodied by
|
||||
// id/tx2) --------------------------------------------------------------------------
|
||||
@@ -2293,12 +2273,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
|
||||
SharedPtr<BackendTextureObject>& SyncTextureToBackendByHandle(
|
||||
MG_Pipe::MGPipeHandle texture, Bool imageBindableStorageRequired = false);
|
||||
BackendTextureObject* ResolveTextureTwin(MG_Pipe::MGPipeHandle texture);
|
||||
// NoteDriverSideTextureWrite's HANDLE ARM, for the same paths when the caller holds a
|
||||
// Texture handle (a framebuffer surface's Res, an image unit's Res, VerbMipRes,
|
||||
// VerbCopyTexDst, a copy-image endpoint): the twin the handle's record names is marked, or
|
||||
// its storage owner's (Desc.ViewOf) for a view. Nothing on the apply thread reads a
|
||||
// frontend object for it.
|
||||
void NoteDriverSideTextureWriteByHandle(MG_Pipe::MGPipeHandle texture);
|
||||
#endif
|
||||
// Brings every texture the next draw reads - the touched units' bindings and the draw
|
||||
// FBO's texture attachments - onto the backend, through the two borrowed-pair memos
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
// Included in DirectGLES.cpp after the native packed-word readback helper.
|
||||
// A storage promotion needs the driver's own texels as owned tight rows, not
|
||||
// client PACK layout or a fallback into a frontend texture's potentially stale
|
||||
// shadow.
|
||||
// The server needs owned tight rows for a storage promotion, not client PACK
|
||||
// layout or a fallback into a frontend texture's potentially stale shadow.
|
||||
class ScopedWireTextureReadLevel {
|
||||
public:
|
||||
ScopedWireTextureReadLevel(GLuint texture, GLenum target, GLint level)
|
||||
@@ -281,45 +280,6 @@
|
||||
return true;
|
||||
}
|
||||
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
// P9 W2-a. The store's Defined-ness follows the client's respecifies; the driver's follows the
|
||||
// twin's last sync. A re-mint asks this before reading a level back, because a level defined
|
||||
// after that sync (null data, or null data plus a partial upload) is not on the driver yet and
|
||||
// its FBO attachment is incomplete - which used to end the session at
|
||||
// Fatal{ResourceUnavailable, "image-promotion-readback"} on legal GL.
|
||||
Bool NativeTextureLevelHasExtent(GLuint texture, TextureTarget target, TextureUploadTarget uploadTarget,
|
||||
GLint level, const IntVec3& logicalExtent) {
|
||||
if (!texture || level < 0 || !g_GLESFuncs.glGetTexLevelParameteriv) return true;
|
||||
const IntVec3 extent = TextureImpl::GetBackendUploadSize(target, logicalExtent);
|
||||
const GLenum nativeTarget = TextureImpl::ConvertTextureTargetToBackendGLEnum(target);
|
||||
GLenum binding = GL_NONE;
|
||||
switch (nativeTarget) {
|
||||
case GL_TEXTURE_2D: binding = GL_TEXTURE_BINDING_2D; break;
|
||||
case GL_TEXTURE_3D: binding = GL_TEXTURE_BINDING_3D; break;
|
||||
case GL_TEXTURE_2D_ARRAY: binding = GL_TEXTURE_BINDING_2D_ARRAY; break;
|
||||
case GL_TEXTURE_CUBE_MAP: binding = GL_TEXTURE_BINDING_CUBE_MAP; break;
|
||||
case GL_TEXTURE_CUBE_MAP_ARRAY: binding = GL_TEXTURE_BINDING_CUBE_MAP_ARRAY; break;
|
||||
default: return true;
|
||||
}
|
||||
// A cube's levels are per face; every other target answers for the whole level.
|
||||
const GLenum queryTarget = nativeTarget == GL_TEXTURE_CUBE_MAP
|
||||
? TextureImpl::ConvertTextureUploadTargetToBackendGLEnum(uploadTarget) : nativeTarget;
|
||||
DrainESErrors();
|
||||
GLint previous = 0;
|
||||
g_GLESFuncs.glGetIntegerv(binding, &previous);
|
||||
g_GLESFuncs.glBindTexture(nativeTarget, texture);
|
||||
GLint width = 0, height = 0, depth = 0;
|
||||
g_GLESFuncs.glGetTexLevelParameteriv(queryTarget, level, GL_TEXTURE_WIDTH, &width);
|
||||
g_GLESFuncs.glGetTexLevelParameteriv(queryTarget, level, GL_TEXTURE_HEIGHT, &height);
|
||||
g_GLESFuncs.glGetTexLevelParameteriv(queryTarget, level, GL_TEXTURE_DEPTH, &depth);
|
||||
const Bool answered = g_GLESFuncs.glGetError() == GL_NO_ERROR;
|
||||
g_GLESFuncs.glBindTexture(nativeTarget, static_cast<GLuint>(previous));
|
||||
if (!answered) return true;
|
||||
const Bool layered = nativeTarget == GL_TEXTURE_3D || nativeTarget == GL_TEXTURE_2D_ARRAY ||
|
||||
nativeTarget == GL_TEXTURE_CUBE_MAP_ARRAY;
|
||||
return width == extent.x() && height == extent.y() && (!layered || depth == extent.z());
|
||||
}
|
||||
|
||||
Bool ReadTextureImageWire(const MG_Pipe::MGPReadbackInfo& info, Vector<Uint8>& bytes) {
|
||||
const auto* record = PipeTextureRecordForHandle(info.Res);
|
||||
if (!record) return false;
|
||||
@@ -347,4 +307,3 @@
|
||||
bytes = Move(result);
|
||||
return true;
|
||||
}
|
||||
#endif // MOBILEGL_BUILD_DISAGGREGATED
|
||||
|
||||
@@ -345,10 +345,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
pVulkanRenderer.reset();
|
||||
ClearProgramResourceCaches();
|
||||
}
|
||||
// And the swap interval it asked for (DirectVulkan.h).
|
||||
if (MG_Config::Transport != MG_Config::TransportMode::Monolith) {
|
||||
ForgetRequestedSwapInterval();
|
||||
}
|
||||
}
|
||||
#else
|
||||
BackendObject_DirectVulkan::~BackendObject_DirectVulkan() = default;
|
||||
@@ -367,9 +363,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
// Any renderer instance this assignment replaces is destroyed here;
|
||||
// fence/timer-query handles stamped with the old generation go stale.
|
||||
BumpRendererGeneration();
|
||||
VulkanRendererConfig config;
|
||||
config.SwapInterval = GetRequestedSwapInterval();
|
||||
pVulkanRenderer = MakeUnique<MG_Backend::DirectVulkan::VulkanRenderer>(nativeWindow, config);
|
||||
pVulkanRenderer = MakeUnique<MG_Backend::DirectVulkan::VulkanRenderer>(nativeWindow);
|
||||
MOBILEGL_ASSERT(pVulkanRenderer != nullptr, "InitWindowSurface: VulkanRenderer creation failed");
|
||||
pVulkanRenderer->Initialize();
|
||||
return true;
|
||||
@@ -492,12 +486,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
return BackendObject::SwapEGLBuffers(dpy, draw);
|
||||
}
|
||||
|
||||
void BackendObject_DirectVulkan::SetEGLSwapInterval(Int interval) {
|
||||
// Same lock as SwapEGLBuffers: the renderer reads the request in Present.
|
||||
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
|
||||
BackendObject::SetEGLSwapInterval(interval);
|
||||
}
|
||||
|
||||
void BackendObject_DirectVulkan::ReleaseEGLSurface(EGLSurface surface) {
|
||||
const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
|
||||
BackendObject::ReleaseEGLSurface(surface);
|
||||
@@ -739,7 +727,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
static Bool funcsTableInitialized = false;
|
||||
if (!funcsTableInitialized) {
|
||||
funcsTable.Present = Present;
|
||||
funcsTable.SetSwapInterval = SetSwapInterval;
|
||||
funcsTable.GL.DrawArrays = DrawArrays;
|
||||
funcsTable.GL.DrawElements = DrawElements;
|
||||
funcsTable.GL.DrawElementsBaseVertex = DrawElementsBaseVertex;
|
||||
|
||||
@@ -34,7 +34,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
Bool CreateEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height) override;
|
||||
Bool MakeEGLCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) override;
|
||||
Bool SwapEGLBuffers(EGLDisplay dpy, EGLSurface draw) override;
|
||||
void SetEGLSwapInterval(Int interval) override;
|
||||
void ReleaseEGLSurface(EGLSurface surface) override;
|
||||
void ReleaseEGLResources() override;
|
||||
|
||||
|
||||
@@ -1,29 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_Backend/DirectVulkan/DescriptorPoolCensus.h
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
// A count of Magma's per-frame descriptor pools and the sets they hold (UniformManager), for
|
||||
// tests. Dependency-free on purpose: the integration scenarios include it next to the system GL
|
||||
// headers. They link the static library on desktop; the shipping shared library is built with
|
||||
// hidden visibility, so on Android nothing outside the library can call GetDescriptorPoolCensus.
|
||||
struct DescriptorPoolCensus {
|
||||
bool available = false; // false when no Magma renderer is live (e.g. the DirectGLES backend)
|
||||
uint32_t frameSlots = 0;
|
||||
uint32_t pools = 0; // descriptor pools across every frame slot
|
||||
uint32_t maxPoolsInOneSlot = 0;
|
||||
uint64_t capacitySets = 0; // sum of maxSets over those pools
|
||||
uint64_t cachedSets = 0; // sets allocated from them and held in the per-layout caches
|
||||
uint64_t slotTrims = 0; // whole-slot trims since the renderer came up
|
||||
};
|
||||
|
||||
DescriptorPoolCensus GetDescriptorPoolCensus();
|
||||
} // namespace MobileGL::MG_Backend::DirectVulkan
|
||||
@@ -1741,52 +1741,4 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
MG_Util::PipeStats::OnPresent();
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
Optional<Int> g_requestedSwapInterval;
|
||||
} // namespace
|
||||
|
||||
void SetSwapInterval(Int interval) {
|
||||
g_requestedSwapInterval = interval;
|
||||
if (pVulkanRenderer) {
|
||||
pVulkanRenderer->SetSwapInterval(interval);
|
||||
}
|
||||
}
|
||||
|
||||
Optional<Int> GetRequestedSwapInterval() {
|
||||
return g_requestedSwapInterval;
|
||||
}
|
||||
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
void ForgetRequestedSwapInterval() {
|
||||
g_requestedSwapInterval.reset();
|
||||
}
|
||||
#endif
|
||||
|
||||
DescriptorPoolCensus GetDescriptorPoolCensus() {
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
// P11 M2: UNDER A TRANSPORT THE POOLS ARE THE SERVER RENDERER'S, and its apply thread
|
||||
// grows, rewinds and trims them while the test thread would be reading - a census taken
|
||||
// after a swap the client ran ahead of, or mid-burst, walks a set cache BeginFrame may be
|
||||
// clearing. Inproc, the server is a thread of this process: the read is posted to it as
|
||||
// the test probe, which runs between drain batches, so it sees every record published
|
||||
// before it and none half-applied - without waiting on the GPU, which is the point of the
|
||||
// trim case (it gives a burst back with other slots' work in flight). Spawn and tcp keep
|
||||
// their pools in another process; the client has no renderer and answers unavailable.
|
||||
if (MG_Config::Transport != MG_Config::TransportMode::Monolith &&
|
||||
!MG_Remote::Server::ServerLoop::OnApplyThread()) {
|
||||
if (MG_Config::Transport != MG_Config::TransportMode::InProcess) return DescriptorPoolCensus{};
|
||||
DescriptorPoolCensus census{};
|
||||
const MobileGLResult result = MG_Remote::Server::ServerLoopInstance().RunProbeOnApplyThreadForTesting(
|
||||
+[](void* user) -> MobileGLResult {
|
||||
*static_cast<DescriptorPoolCensus*>(user) =
|
||||
pVulkanRenderer ? pVulkanRenderer->GetDescriptorPoolCensus() : DescriptorPoolCensus{};
|
||||
return MOBILEGL_OK;
|
||||
},
|
||||
&census);
|
||||
return result == MOBILEGL_OK ? census : DescriptorPoolCensus{};
|
||||
}
|
||||
#endif
|
||||
return pVulkanRenderer ? pVulkanRenderer->GetDescriptorPoolCensus() : DescriptorPoolCensus{};
|
||||
}
|
||||
} // namespace MobileGL::MG_Backend::DirectVulkan
|
||||
|
||||
@@ -147,14 +147,4 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
// only exist as vkCmdWriteTimestamp results); the frontend falls back.
|
||||
Int64 GetGpuTimestampNs();
|
||||
void Present();
|
||||
// eglSwapInterval. Remembered across renderers: one created for a later window surface
|
||||
// starts from the app's last request (GetRequestedSwapInterval) instead of the default.
|
||||
void SetSwapInterval(Int interval);
|
||||
Optional<Int> GetRequestedSwapInterval();
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
// The swap interval an ended server session asked for is not the next one's, the same rule as
|
||||
// DirectGLES::ForgetRequestedSwapInterval: under a transport ~BackendObject_DirectVulkan forgets
|
||||
// it, so the next session starts at the default until it asks.
|
||||
void ForgetRequestedSwapInterval();
|
||||
#endif
|
||||
} // namespace MobileGL::MG_Backend::DirectVulkan
|
||||
|
||||
@@ -8,8 +8,6 @@
|
||||
|
||||
#include "SwapchainObject.h"
|
||||
|
||||
#include <span>
|
||||
|
||||
#include "MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h"
|
||||
#include "MG_State/GLState/TextureState/TextureObject2D.h"
|
||||
|
||||
@@ -142,26 +140,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
}
|
||||
|
||||
VkPresentModeKHR SwapchainObject::ChooseSwapchainPresentMode(
|
||||
const Vector<VkPresentModeKHR>& availablePresentModes, Optional<Int> swapInterval) {
|
||||
static constexpr VkPresentModeKHR s_unthrottledPresentModes[]{
|
||||
VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR};
|
||||
static constexpr VkPresentModeKHR s_vsyncPresentModes[]{VK_PRESENT_MODE_FIFO_KHR};
|
||||
static constexpr VkPresentModeKHR s_adaptiveVsyncPresentModes[]{VK_PRESENT_MODE_FIFO_RELAXED_KHR,
|
||||
VK_PRESENT_MODE_FIFO_KHR};
|
||||
std::span<const VkPresentModeKHR> ranked = s_desiredPresentModes;
|
||||
if (swapInterval) {
|
||||
if (*swapInterval == 0) {
|
||||
ranked = s_unthrottledPresentModes;
|
||||
} else if (*swapInterval > 0) {
|
||||
ranked = s_vsyncPresentModes;
|
||||
} else {
|
||||
ranked = s_adaptiveVsyncPresentModes;
|
||||
}
|
||||
}
|
||||
for (auto desiredPresentMode : ranked) {
|
||||
if (std::find(availablePresentModes.begin(), availablePresentModes.end(), desiredPresentMode) !=
|
||||
availablePresentModes.end()) {
|
||||
return desiredPresentMode;
|
||||
const Vector<VkPresentModeKHR>& availablePresentModes) {
|
||||
for (auto desiredPresentMode : s_desiredPresentModes) {
|
||||
for (const auto& presentMode : availablePresentModes) {
|
||||
if (presentMode == desiredPresentMode) {
|
||||
return presentMode;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -169,13 +153,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
return availablePresentModes[0];
|
||||
}
|
||||
|
||||
const char* SwapchainObject::GetPresentModeName(VkPresentModeKHR presentMode) {
|
||||
return string_VkPresentModeKHR(presentMode);
|
||||
}
|
||||
|
||||
void SwapchainObject::Create(VkDevice device, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
|
||||
Uint32 graphicsQueueFamily, Uint32 presentQueueFamily, Uint32 minImageCountHint,
|
||||
VkExtent2D desiredExtent, Optional<Int> swapInterval) {
|
||||
VkExtent2D desiredExtent) {
|
||||
const auto swapchainCapabilities = GetSwapchainCapabilities(physicalDevice, surface);
|
||||
MOBILEGL_ASSERT(swapchainCapabilities.IsComplete(),
|
||||
"SwapchainObject::Create failed: incomplete swapchain capabilities");
|
||||
@@ -194,10 +174,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
MGLOG_D(" %s", string_VkPresentModeKHR(pm));
|
||||
}
|
||||
|
||||
const auto presentMode = ChooseSwapchainPresentMode(swapchainCapabilities.presentModes, swapInterval);
|
||||
const auto presentMode = ChooseSwapchainPresentMode(swapchainCapabilities.presentModes);
|
||||
MGLOG_I("Picked present mode: %s", string_VkPresentModeKHR(presentMode));
|
||||
m_presentMode = presentMode;
|
||||
m_supportedPresentModes = swapchainCapabilities.presentModes;
|
||||
|
||||
const auto& swapchainCaps = swapchainCapabilities.capabilities;
|
||||
Uint32 targetImageCount = std::max<Uint32>(minImageCountHint, swapchainCaps.minImageCount);
|
||||
|
||||
@@ -26,23 +26,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
|
||||
static SwapchainCapabilities GetSwapchainCapabilities(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface);
|
||||
static VkSurfaceFormatKHR ChooseSwapchainSurfaceFormat(const Vector<VkSurfaceFormatKHR>& availableFormats);
|
||||
// swapInterval is the app's eglSwapInterval, empty until it asks (s_desiredPresentModes
|
||||
// ranks the modes then). 0 wants IMMEDIATE, else MAILBOX, else FIFO; >= 1 wants FIFO,
|
||||
// which cannot skip vblanks, so 2 and up pace like 1; a negative interval (adaptive
|
||||
// vsync) wants FIFO_RELAXED, else FIFO.
|
||||
static VkPresentModeKHR ChooseSwapchainPresentMode(const Vector<VkPresentModeKHR>& availablePresentModes,
|
||||
Optional<Int> swapInterval = Nullopt);
|
||||
static const char* GetPresentModeName(VkPresentModeKHR presentMode);
|
||||
static VkPresentModeKHR ChooseSwapchainPresentMode(const Vector<VkPresentModeKHR>& availablePresentModes);
|
||||
|
||||
void Create(VkDevice device, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, Uint32 graphicsQueueFamily,
|
||||
Uint32 presentQueueFamily, Uint32 minImageCountHint, VkExtent2D desiredExtent,
|
||||
Optional<Int> swapInterval);
|
||||
Uint32 presentQueueFamily, Uint32 minImageCountHint, VkExtent2D desiredExtent);
|
||||
void Shutdown(VkDevice device);
|
||||
|
||||
VkSwapchainKHR GetHandle() const { return m_swapchain; }
|
||||
VkPresentModeKHR GetPresentMode() const { return m_presentMode; }
|
||||
// The surface's present modes as queried when this swapchain was created.
|
||||
const Vector<VkPresentModeKHR>& GetSupportedPresentModes() const { return m_supportedPresentModes; }
|
||||
const VkSurfaceFormatKHR& GetSurfaceFormat() const { return m_surfaceFormat; }
|
||||
VkExtent2D GetExtent() const { return m_extent; }
|
||||
// Surface-space extent (before the pre-rotation quarter-turn swap) this swapchain was
|
||||
@@ -89,8 +79,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
};
|
||||
|
||||
VkSwapchainKHR m_swapchain = VK_NULL_HANDLE;
|
||||
VkPresentModeKHR m_presentMode = VK_PRESENT_MODE_FIFO_KHR;
|
||||
Vector<VkPresentModeKHR> m_supportedPresentModes;
|
||||
VkSurfaceFormatKHR m_surfaceFormat{};
|
||||
VkExtent2D m_extent{};
|
||||
VkExtent2D m_surfaceExtent{};
|
||||
|
||||
@@ -591,11 +591,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
m_samplerResolveMemoHighWater = 0;
|
||||
m_setsPerFrame = setsPerFrame;
|
||||
m_peakDescriptorSetsObserved = 0;
|
||||
m_trimQuietEpochs = MG_Config::Features.MagmaDescriptorTrimFrames;
|
||||
// The renderer records its first frame into slot 0 before any BeginFrame runs.
|
||||
m_epochSlot = 0;
|
||||
m_epochOpen = true;
|
||||
m_descriptorSlotTrims = 0;
|
||||
m_textureManager = textureManager;
|
||||
m_samplerManager = samplerManager;
|
||||
|
||||
@@ -605,8 +600,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
frame.activeDescriptorPoolIndex = 0;
|
||||
frame.allocatedSetsThisFrame = 0;
|
||||
frame.peakAllocatedSetsThisFrame = 0;
|
||||
frame.capacitySets = m_setsPerFrame;
|
||||
frame.quietEpochs = 0;
|
||||
frame.descriptorPools.clear();
|
||||
|
||||
VkDescriptorPool initialPool = VK_NULL_HANDLE;
|
||||
@@ -661,8 +654,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
frame.activeDescriptorPoolIndex = 0;
|
||||
frame.allocatedSetsThisFrame = 0;
|
||||
frame.peakAllocatedSetsThisFrame = 0;
|
||||
frame.capacitySets = 0;
|
||||
frame.quietEpochs = 0;
|
||||
}
|
||||
m_frames.clear();
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
@@ -671,8 +662,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
m_wirePrivateStoragePlaceholders = 0;
|
||||
m_wireInvalidStorageImagesBindNull = false;
|
||||
#endif
|
||||
m_epochSlot = 0;
|
||||
m_epochOpen = false;
|
||||
|
||||
m_bufferManager = nullptr;
|
||||
m_programFactory = nullptr;
|
||||
@@ -712,20 +701,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
"UniformDescriptorBinder: new descriptor set peak observed=%u (base setsPerFrame=%u, frame=%u, pools=%zu)",
|
||||
m_peakDescriptorSetsObserved, m_setsPerFrame, frameIndex, frame.descriptorPools.size());
|
||||
}
|
||||
// The epoch that just ended is the one of the slot begun last - this slot again on the
|
||||
// drain path, the previous frame's slot on the Present path. Its peak is still unreset.
|
||||
if (m_epochOpen && m_epochSlot < m_frames.size()) {
|
||||
NoteEndedEpochForTrim(m_frames[m_epochSlot].peakAllocatedSetsThisFrame);
|
||||
}
|
||||
m_epochSlot = frameIndex;
|
||||
m_epochOpen = true;
|
||||
// No pending command buffer references this slot's sets here (see TrimFrameDescriptorPools
|
||||
// for why that holds at both of BeginFrame's call sites), so a quiet grown slot can be
|
||||
// handed back whole.
|
||||
if (m_trimQuietEpochs != 0 && frame.descriptorPools.size() > 1 &&
|
||||
frame.capacitySets >= kDescriptorTrimMinCapacity && frame.quietEpochs >= m_trimQuietEpochs) {
|
||||
TrimFrameDescriptorPools(frame, frameIndex);
|
||||
}
|
||||
frame.activeDescriptorPoolIndex = 0;
|
||||
frame.allocatedSetsThisFrame = 0;
|
||||
frame.peakAllocatedSetsThisFrame = 0;
|
||||
@@ -734,7 +709,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
}
|
||||
// The frame's descriptor sets are recycled above, so last frame's reuse targets
|
||||
// are gone: start the per-draw descriptor-reuse cache fresh this frame.
|
||||
InvalidateDescriptorSetMemos();
|
||||
for (auto& entry : m_descriptorReuseMemo) {
|
||||
entry.valid = false;
|
||||
}
|
||||
m_fastRebindMemo.valid = false;
|
||||
m_lastBindValid = false;
|
||||
// Re-fingerprint the bound sampler set fresh this frame so any GL object address
|
||||
// reuse cannot outlive a single frame (see SamplerResolveMemo). Only the entries a
|
||||
// resolve has actually written can be valid, so the high-water mark bounds the
|
||||
@@ -768,11 +747,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
entry.second.cursor = 0;
|
||||
}
|
||||
frame.allocatedSetsThisFrame = 0;
|
||||
// The PEAK is not reset: a rewind ends a window of the epoch, not the epoch. The trim scores
|
||||
// an epoch by the most sets the slot held at once in it (NoteEndedEpochForTrim at the next
|
||||
// BeginFrame), and on this arm that is the largest window - resetting here would score a
|
||||
// burst frame by its last window alone and trim a slot that re-grows every frame.
|
||||
InvalidateDescriptorSetMemos();
|
||||
frame.peakAllocatedSetsThisFrame = 0;
|
||||
for (auto& entry : m_descriptorReuseMemo) entry.valid = false;
|
||||
m_fastRebindMemo.valid = false;
|
||||
m_lastBindValid = false;
|
||||
const Uint32 touchedBindings =
|
||||
std::min<Uint32>(m_samplerResolveMemoHighWater, static_cast<Uint32>(m_samplerResolveMemo.size()));
|
||||
for (Uint32 binding = 0; binding < touchedBindings; ++binding) {
|
||||
@@ -783,68 +761,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
}
|
||||
#endif
|
||||
|
||||
void UniformManager::InvalidateDescriptorSetMemos() {
|
||||
// Every VkDescriptorSet handle held outside the per-layout caches - in this backend they all
|
||||
// live in this class. A trim can hand a destroyed set's handle value to a fresh allocation,
|
||||
// so the bind-dedup shadow must drop too, not only the two reuse memos.
|
||||
for (auto& entry : m_descriptorReuseMemo) {
|
||||
entry.valid = false;
|
||||
}
|
||||
m_fastRebindMemo.valid = false;
|
||||
m_lastBindValid = false;
|
||||
}
|
||||
|
||||
void UniformManager::NoteEndedEpochForTrim(Uint32 epochPeakSets) {
|
||||
for (auto& slot : m_frames) {
|
||||
if (static_cast<Uint64>(epochPeakSets) * kDescriptorTrimHeadroom > slot.capacitySets) {
|
||||
slot.quietEpochs = 0;
|
||||
} else if (slot.quietEpochs < std::numeric_limits<Uint32>::max()) {
|
||||
++slot.quietEpochs;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void UniformManager::TrimFrameDescriptorPools(FrameResources& frame, Uint32 frameIndex) {
|
||||
const SizeT poolsBefore = frame.descriptorPools.size();
|
||||
const Uint64 capacityBefore = frame.capacitySets;
|
||||
// Holders first: the per-layout cache and every memo that may name one of these sets.
|
||||
frame.descriptorSetCacheByLayout.clear();
|
||||
InvalidateDescriptorSetMemos();
|
||||
for (SizeT i = 1; i < frame.descriptorPools.size(); ++i) {
|
||||
if (frame.descriptorPools[i].handle != VK_NULL_HANDLE) {
|
||||
vkDestroyDescriptorPool(m_device, frame.descriptorPools[i].handle, nullptr);
|
||||
}
|
||||
}
|
||||
frame.descriptorPools.resize(1);
|
||||
auto& base = frame.descriptorPools[0];
|
||||
// Frees every set allocated from it; the spec defines no failure for vkResetDescriptorPool.
|
||||
vkResetDescriptorPool(m_device, base.handle, 0);
|
||||
base.allocatedSets = 0;
|
||||
frame.activeDescriptorPoolIndex = 0;
|
||||
frame.capacitySets = base.maxSets;
|
||||
frame.quietEpochs = 0;
|
||||
++m_descriptorSlotTrims;
|
||||
MGLOG_D("UniformDescriptorBinder: frame %u trimmed its descriptor pools (%zu pools / %llu sets -> 1 / %u)",
|
||||
frameIndex, poolsBefore, static_cast<unsigned long long>(capacityBefore), base.maxSets);
|
||||
}
|
||||
|
||||
DescriptorPoolCensus UniformManager::GetDescriptorPoolCensus() const {
|
||||
DescriptorPoolCensus census;
|
||||
census.available = true;
|
||||
census.frameSlots = static_cast<uint32_t>(m_frames.size());
|
||||
for (const auto& frame : m_frames) {
|
||||
const auto poolCount = static_cast<uint32_t>(frame.descriptorPools.size());
|
||||
census.pools += poolCount;
|
||||
census.maxPoolsInOneSlot = std::max(census.maxPoolsInOneSlot, poolCount);
|
||||
census.capacitySets += frame.capacitySets;
|
||||
for (const auto& cacheEntryPair : frame.descriptorSetCacheByLayout) {
|
||||
census.cachedSets += cacheEntryPair.second.sets.size();
|
||||
}
|
||||
}
|
||||
census.slotTrims = m_descriptorSlotTrims;
|
||||
return census;
|
||||
}
|
||||
|
||||
void UniformManager::OnDescriptorSetLayoutDestroyed(VkDescriptorSetLayout descriptorSetLayout) {
|
||||
SizeT purgedSets = 0;
|
||||
for (auto& frame : m_frames) {
|
||||
@@ -2915,49 +2831,32 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
return true;
|
||||
}
|
||||
|
||||
Uint32 UniformManager::NextDescriptorPoolMaxSets(const Vector<DescriptorPoolBucket>& pools, Bool updateAfterBind,
|
||||
Uint32 initialMaxSets) {
|
||||
const Uint32 minSets = std::max<Uint32>(1, initialMaxSets);
|
||||
const Uint32 maxSets = std::max(minSets, kMaxDescriptorPoolSets);
|
||||
Uint32 largest = 0;
|
||||
for (const auto& pool : pools) {
|
||||
if (pool.updateAfterBind == updateAfterBind) {
|
||||
largest = std::max(largest, pool.maxSets);
|
||||
}
|
||||
}
|
||||
if (largest == 0) {
|
||||
return minSets;
|
||||
}
|
||||
const Uint64 doubled = static_cast<Uint64>(largest) * 2;
|
||||
return static_cast<Uint32>(std::clamp<Uint64>(doubled, minSets, maxSets));
|
||||
}
|
||||
|
||||
Bool UniformManager::GrowFrameDescriptorPool(FrameResources& frame, Uint32 frameIndex, Bool updateAfterBind) {
|
||||
if (frame.descriptorPools.empty()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
Uint32 grownMaxSets = NextDescriptorPoolMaxSets(frame.descriptorPools, updateAfterBind, m_setsPerFrame);
|
||||
const auto matchingBucket = std::find_if(
|
||||
frame.descriptorPools.begin(), frame.descriptorPools.end(),
|
||||
[updateAfterBind](const DescriptorPoolBucket& candidate) { return candidate.updateAfterBind == updateAfterBind; });
|
||||
const Uint32 currentMaxSets = matchingBucket != frame.descriptorPools.end()
|
||||
? std::max<Uint32>(1, matchingBucket->maxSets)
|
||||
: m_setsPerFrame;
|
||||
const Uint32 grownMaxSets = currentMaxSets <= (std::numeric_limits<Uint32>::max() / 2) ? (currentMaxSets * 2)
|
||||
: currentMaxSets;
|
||||
|
||||
VkDescriptorPool grownPool = VK_NULL_HANDLE;
|
||||
// A large pool is a large driver allocation; if the device refuses one, settle for less
|
||||
// rather than failing the draw - halving down to the base size, where the old policy lived.
|
||||
while (!CreateDescriptorPool(grownMaxSets, updateAfterBind, grownPool)) {
|
||||
if (grownMaxSets <= m_setsPerFrame) {
|
||||
MGLOG_E_ONCE("UniformDescriptorBinder::GrowFrameDescriptorPool failed: cannot create grown pool (%u sets)",
|
||||
grownMaxSets);
|
||||
return false;
|
||||
}
|
||||
grownMaxSets = std::max(m_setsPerFrame, grownMaxSets / 2);
|
||||
if (!CreateDescriptorPool(grownMaxSets, updateAfterBind, grownPool)) {
|
||||
MGLOG_E_ONCE("UniformDescriptorBinder::GrowFrameDescriptorPool failed: cannot create grown pool (%u -> %u sets)",
|
||||
currentMaxSets, grownMaxSets);
|
||||
return false;
|
||||
}
|
||||
|
||||
frame.descriptorPools.push_back({grownPool, grownMaxSets, 0, updateAfterBind});
|
||||
frame.activeDescriptorPoolIndex = static_cast<Uint32>(frame.descriptorPools.size() - 1);
|
||||
frame.capacitySets += grownMaxSets;
|
||||
// Growing is the opposite of quiet: a trim must wait a full quiet run from here.
|
||||
frame.quietEpochs = 0;
|
||||
MGLOG_D("UniformDescriptorBinder: frame %u descriptor pool exhausted, grew a %u-set pool (updateAfterBind=%d), "
|
||||
"poolCount=%zu",
|
||||
frameIndex, grownMaxSets, updateAfterBind ? 1 : 0, frame.descriptorPools.size());
|
||||
MGLOG_D(
|
||||
"UniformDescriptorBinder: frame %u descriptor pool exhausted, grew pool (%u -> %u sets), poolCount=%zu",
|
||||
frameIndex, currentMaxSets, grownMaxSets, frame.descriptorPools.size());
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -14,7 +14,6 @@
|
||||
#include "VkSamplerManager.h"
|
||||
#include "VkTextureManager.h"
|
||||
#include "WirePlaceholderKey.h"
|
||||
#include "../DescriptorPoolCensus.h"
|
||||
#include "../VkIncludes.h"
|
||||
#include <Includes.h>
|
||||
|
||||
@@ -85,11 +84,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
// FREE_DESCRIPTOR_SET_BIT) and the pool accounting is credited, so program
|
||||
// churn recycles pool capacity instead of abandoning it. GPU-safe: the layout
|
||||
// only dies after >1024 idle frame boundaries, so no in-flight command buffer
|
||||
// references its sets. This is the only PER-LAYOUT eviction path for the
|
||||
// caches - a live layout's entry must never be purged on its own (its sets would be
|
||||
// unreachable pool slots), so there is deliberately no age-based sweep here. The
|
||||
// other path, TrimFrameDescriptorPools, drops a slot's whole cache together with
|
||||
// the pools behind it.
|
||||
// references its sets. This is the only eviction path for the per-layout
|
||||
// caches - a live layout's entry must never be purged (its sets would be
|
||||
// unreachable pool slots), so there is deliberately no age-based sweep here.
|
||||
void OnDescriptorSetLayoutDestroyed(VkDescriptorSetLayout descriptorSetLayout);
|
||||
// One record per visited CombinedImageSampler DESCRIPTOR (post fallback substitution,
|
||||
// in binding order, and within a binding in array-element order): the resolved texture
|
||||
@@ -161,46 +158,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
static Bool ProgramSamplesOnlySingleLevelTextures(const MagmaProgramSource& program,
|
||||
const ProgramFactory::VkProgramObject& programObj);
|
||||
|
||||
// ---- per-frame descriptor pools ----------------------------------------------------
|
||||
// Each frame slot owns a list of pools. The first is the base pool (non-update-after-bind,
|
||||
// setsPerFrame sets) and is never destroyed while the manager lives; every later one was
|
||||
// added by GrowFrameDescriptorPool when an allocation found no room. A pool serves one
|
||||
// updateAfterBind flavour, because a set can only come from a pool created with the flag
|
||||
// its layout was.
|
||||
private:
|
||||
struct DescriptorPoolBucket {
|
||||
VkDescriptorPool handle = VK_NULL_HANDLE;
|
||||
Uint32 maxSets = 0;
|
||||
Uint32 allocatedSets = 0;
|
||||
Bool updateAfterBind = false;
|
||||
};
|
||||
// One pool's maxSets never exceeds this. It bounds one pool's driver memory: CreateDescriptorPool
|
||||
// declares 8 descriptors of each of 6 types per set, so a 4096-set pool asks for 196,608
|
||||
// descriptors - about 12 MiB at 64 bytes each on a driver that backs every declared one.
|
||||
static constexpr Uint32 kMaxDescriptorPoolSets = 4096;
|
||||
// The growth policy, pure so the host tests can drive it: the size of the next pool a slot
|
||||
// adds for `updateAfterBind` layouts, given the slot's existing pools. Twice the LARGEST pool
|
||||
// of that flavour, capped at kMaxDescriptorPoolSets; `initialMaxSets` when the slot has no
|
||||
// pool of that flavour yet. So a frame that needs N sets adds O(log N) pools while N stays
|
||||
// under the cap, and one more pool per kMaxDescriptorPoolSets sets beyond it. Taking the
|
||||
// largest (not the first) pool is the point: the first same-flavour pool is the oldest,
|
||||
// smallest one, and doubling IT made every grown pool the same size.
|
||||
static Uint32 NextDescriptorPoolMaxSets(const Vector<DescriptorPoolBucket>& pools, Bool updateAfterBind,
|
||||
Uint32 initialMaxSets);
|
||||
// Trim policy (see TrimFrameDescriptorPools). A slot is "quiet" in an epoch whose peak set
|
||||
// count times kDescriptorTrimHeadroom still fits its capacity; a slot that has been quiet for
|
||||
// MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES consecutive epochs, and holds at least
|
||||
// kDescriptorTrimMinCapacity sets, is trimmed. The headroom is what keeps the trim from
|
||||
// thrashing: geometric growth leaves a re-grown slot at least a third full (the pool a growth
|
||||
// adds is at most twice the largest before it, so at most twice everything the slot held, and
|
||||
// the epoch that grew it needed more than that), so the epoch that grew a slot is never quiet
|
||||
// for it. The floor keeps a slot sized for ordinary
|
||||
// frames from being trimmed at all - the trim exists to give back a burst.
|
||||
static constexpr Uint32 kDescriptorTrimHeadroom = 4;
|
||||
static constexpr Uint32 kDescriptorTrimMinCapacity = 1024;
|
||||
// For tests (DescriptorPoolCensus.h): pools, capacity, cached sets and trims over every slot.
|
||||
DescriptorPoolCensus GetDescriptorPoolCensus() const;
|
||||
|
||||
private:
|
||||
|
||||
// A cached descriptor set together with the pool it was allocated from, so a
|
||||
// layout-destroyed purge can vkFreeDescriptorSets it back and credit the
|
||||
@@ -275,10 +239,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
void DestroyWirePlaceholderImage(WirePlaceholderImage& image) const;
|
||||
#endif
|
||||
|
||||
// descriptorSetCacheByLayout is the per-frame set cache: BeginFrame rewinds every cursor, so
|
||||
// a slot re-writes the sets it allocated in earlier frames instead of allocating new ones, and
|
||||
// the cache only ever grows - except through TrimFrameDescriptorPools, which gives a slot's
|
||||
// whole burst back at once (and OnDescriptorSetLayoutDestroyed, one dead layout at a time).
|
||||
struct FrameResources {
|
||||
Vector<DescriptorPoolBucket> descriptorPools;
|
||||
UnorderedMap<VkDescriptorSetLayout, DescriptorSetCacheEntry> descriptorSetCacheByLayout;
|
||||
@@ -292,10 +252,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
Uint32 activeDescriptorPoolIndex = 0;
|
||||
Uint32 allocatedSetsThisFrame = 0;
|
||||
Uint32 peakAllocatedSetsThisFrame = 0;
|
||||
// Sum of maxSets over descriptorPools, kept in step by Initialize, Grow and Trim.
|
||||
Uint64 capacitySets = 0;
|
||||
// Consecutive epochs (see NoteEndedEpochForTrim) that were quiet for THIS slot's capacity.
|
||||
Uint32 quietEpochs = 0;
|
||||
};
|
||||
|
||||
static Bool ResolveSamplerTexture(const MagmaProgramSource& program,
|
||||
@@ -439,28 +395,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
const Vector<Uint32>& dynamicOffsets);
|
||||
Bool CreateDescriptorPool(Uint32 maxSets, Bool updateAfterBind, VkDescriptorPool& outPool) const;
|
||||
Bool GrowFrameDescriptorPool(FrameResources& frame, Uint32 frameIndex, Bool updateAfterBind);
|
||||
// An epoch is the stretch between two BeginFrame calls: one frame, or the part of one between
|
||||
// two drains (VulkanRenderer::TryDrainFrameTransients). Called by BeginFrame with the epoch
|
||||
// that just ended, it updates every slot's quiet count - a burst in any slot counts against
|
||||
// all of them, so bursts that land in the other slots still hold a slot's trim off.
|
||||
void NoteEndedEpochForTrim(Uint32 epochPeakSets);
|
||||
// Gives a slot's whole descriptor burst back: clears its per-layout cache, destroys every
|
||||
// grown pool and resets the base pool, so the slot re-grows geometrically from setsPerFrame.
|
||||
// Whole-slot rather than per-set: vkFreeDescriptorSets fragments a pool and can never empty
|
||||
// a grown one. Called only from BeginFrame, which runs only when no pending command buffer
|
||||
// references the slot's sets:
|
||||
// - Present path (VulkanRenderer::Present, after WaitAndAcquireNextImage): the slot's
|
||||
// imageInFlightFence has been waited. That fence rides the slot's LAST submission - the
|
||||
// Present submit - and every mid-frame submission of the slot (FlushPendingCommands,
|
||||
// SplitOversizedRecording, readbacks) went to the same queue earlier, so the fence's
|
||||
// signal covers them (vkQueueSubmit's fence scope includes all earlier submissions).
|
||||
// - Drain path (VulkanRenderer::TryDrainFrameTransients): every submission has been
|
||||
// observed complete and no recording is open.
|
||||
// Sets are per slot: a slot's sets are only ever bound into recordings made while it is the
|
||||
// current slot, so trimming one slot never touches another slot's in-flight work.
|
||||
void TrimFrameDescriptorPools(FrameResources& frame, Uint32 frameIndex);
|
||||
// Drops every handle this class holds to a descriptor set outside the per-layout caches.
|
||||
void InvalidateDescriptorSetMemos();
|
||||
VkResult AllocateDescriptorSetsFromActivePool(
|
||||
Uint32 frameIndex, const ProgramFactory::VkProgramObject& programObj, VkDescriptorSet& outDescriptorSet);
|
||||
VkResult AcquireDescriptorSet(Uint32 frameIndex,
|
||||
@@ -478,13 +412,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
Uint32 m_maxBindings = 0;
|
||||
Uint32 m_setsPerFrame = 0;
|
||||
Uint32 m_peakDescriptorSetsObserved = 0;
|
||||
// MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES, latched at Initialize (0 = never trim).
|
||||
Uint32 m_trimQuietEpochs = 0;
|
||||
// The slot whose epoch is open (the last one BeginFrame was called for); valid once
|
||||
// m_epochOpen is set. Its peak is the ended epoch's peak at the next BeginFrame.
|
||||
Uint32 m_epochSlot = 0;
|
||||
Bool m_epochOpen = false;
|
||||
Uint64 m_descriptorSlotTrims = 0;
|
||||
VkTextureManager* m_textureManager = nullptr;
|
||||
VkSamplerManager* m_samplerManager = nullptr;
|
||||
mutable SharedPtr<MG_State::GLState::ITextureObject> m_fallbackTexture2D;
|
||||
|
||||
@@ -1333,42 +1333,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
}
|
||||
}
|
||||
|
||||
VkTextureManager::TextureResource* VkTextureManager::FindTextureResource(
|
||||
MG_State::GLState::ITextureObject& textureOrView) {
|
||||
auto it = m_textureResources.find(MakeTextureIdentity(&StorageTextureOf(textureOrView)));
|
||||
return it != m_textureResources.end() ? &it->second : nullptr;
|
||||
}
|
||||
|
||||
Bool VkTextureManager::HasLiveImage(MG_State::GLState::ITextureObject& textureOrView) const {
|
||||
auto it = m_textureResources.find(MakeTextureIdentity(&StorageTextureOf(textureOrView)));
|
||||
return it != m_textureResources.end() && it->second.image != VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
Bool VkTextureManager::HasPendingTexelUpload(MG_State::GLState::ITextureObject& textureOrView) const {
|
||||
auto& storage = StorageTextureOf(textureOrView);
|
||||
auto it = m_textureResources.find(MakeTextureIdentity(&storage));
|
||||
if (it == m_textureResources.end() || it->second.image == VK_NULL_HANDLE) {
|
||||
return false;
|
||||
}
|
||||
return it->second.syncedShapeVersion == storage.GetShapeVersion() &&
|
||||
it->second.syncedContentVersion != storage.GetContentVersion();
|
||||
}
|
||||
|
||||
Bool VkTextureManager::WasTextureWrittenThisRecording(MG_State::GLState::ITextureObject& textureOrView) const {
|
||||
auto it = m_textureResources.find(MakeTextureIdentity(&StorageTextureOf(textureOrView)));
|
||||
return it != m_textureResources.end() && it->second.lastRecordingWriteGeneration == m_recordingGeneration;
|
||||
}
|
||||
|
||||
void VkTextureManager::StampTextureRecordingWrite(MG_State::GLState::ITextureObject* texture) {
|
||||
if (texture == nullptr) {
|
||||
return;
|
||||
}
|
||||
auto it = m_textureResources.find(MakeTextureIdentity(&StorageTextureOf(*texture)));
|
||||
if (it != m_textureResources.end()) {
|
||||
StampResourceRecordingWrite(it->second);
|
||||
}
|
||||
}
|
||||
|
||||
void VkTextureManager::UpdateTrackedImageLayout(MG_State::GLState::ITextureObject* texture, VkImageLayout newLayout) {
|
||||
MOBILEGL_ASSERT(texture != nullptr, "UpdateTrackedImageLayout: texture is null");
|
||||
auto it = m_textureResources.find(MakeTextureIdentity(texture));
|
||||
@@ -1397,7 +1361,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
"UpdateTrackedImageLayoutAfterAttachmentWrite: textureId=%d mipLevel=%u out of range %u",
|
||||
texture->GetExternalIndex(), writtenMipLevel, resource.mipLevels);
|
||||
// Pre-pass stream bookkeeping: the render pass that just ended wrote this image.
|
||||
StampResourceRecordingWrite(resource);
|
||||
StampResourceRecordingUse(resource);
|
||||
|
||||
if (resource.layout != newLayout && resource.mipLevels > 1) {
|
||||
VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
|
||||
@@ -1511,9 +1475,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
resource->aspect, 0, resource->mipLevels);
|
||||
MOBILEGL_ASSERT(ok, "TransitionTextureForStorageImage: transition failed for textureId=%d",
|
||||
texture.GetExternalIndex());
|
||||
// Pre-pass stream bookkeeping: a command referencing the image was recorded, and an
|
||||
// image unit may store to it.
|
||||
StampResourceRecordingWrite(*resource);
|
||||
// Pre-pass stream bookkeeping: a command referencing the image was recorded.
|
||||
StampResourceRecordingUse(*resource);
|
||||
return ok;
|
||||
}
|
||||
|
||||
@@ -4114,17 +4077,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
VkDeviceSize offset = 0;
|
||||
// Sub-region upload (a small sprite in a big atlas): only the dirty box
|
||||
// is staged and copied. texelSize keeps the LEVEL extent - the staging
|
||||
// row copy needs it for the stride. Color formats only (an RGB-expanded
|
||||
// level is cut from its expanded bytes); the depth(+stencil) conversion
|
||||
// passes rewrite whole levels and stay full-size.
|
||||
// row copy needs it for the shadow's stride. Plain color formats only;
|
||||
// the RGB-expand and depth(+stencil) conversion passes rewrite whole
|
||||
// levels and stay full-size.
|
||||
Bool subRegion = false;
|
||||
IntVec3 regionLo = {0, 0, 0};
|
||||
IntVec3 regionSize = {0, 0, 0};
|
||||
SizeT texelBytes = 0;
|
||||
// The writes' exact footprint when it is more than one box (~100 sprites
|
||||
// whose union box spans the whole atlas): each rect is staged tightly and
|
||||
// copied with its own VkBufferImageCopy in ONE vkCmdCopyBufferToImage.
|
||||
// Empty means "stage the one box above". Only set while subRegion.
|
||||
// Scatter refinement of the single dirty box: when the storage's rect
|
||||
// list reports the writes' true footprint (~100 sprites whose union box
|
||||
// spans the whole atlas), each rect is staged tightly and copied with
|
||||
// its own VkBufferImageCopy in ONE vkCmdCopyBufferToImage. Empty means
|
||||
// "stage the one box above". Only set while subRegion.
|
||||
Vector<MG_State::GLState::MipmapDirtyRegion> rects;
|
||||
};
|
||||
|
||||
@@ -4136,7 +4100,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
targets.push_back(uploadTarget);
|
||||
}
|
||||
const TextureFormatInfo formatInfo = ResolveTextureFormatInfo(mipmapTexture.GetFormat());
|
||||
Vector<MG_State::GLState::MipmapDirtyRegion> dirtyFootprint;
|
||||
|
||||
VkDeviceSize stagingSize = 0;
|
||||
for (const TextureUploadTarget target : targets) {
|
||||
@@ -4179,48 +4142,34 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
uploadItem.source = source;
|
||||
uploadItem.offset = stagingSize;
|
||||
uploadItem.uploadByteSize = byteSize;
|
||||
// The RGB -> RGBA expansion rewrites the level texel for texel into a tight buffer
|
||||
// of its own, so it runs first and the dirty region below is taken from whichever
|
||||
// bytes are staged. Uploading an expanded level WHOLE put the shadow's stale texels
|
||||
// over whatever the GPU had drawn into the rest of it.
|
||||
if (formatInfo.expandRgbToRgba) {
|
||||
const Bool expanded = ExpandRgbSourceToRgba(source, byteSize, texelSize, formatInfo,
|
||||
uploadItem.expandedData);
|
||||
MOBILEGL_ASSERT(expanded,
|
||||
"UploadDirtyMipLevels: failed to expand RGB textureId=%d target=%s level=%u to RGBA staging data",
|
||||
mipmapTexture.GetExternalIndex(),
|
||||
MG_Util::ConvertTextureUploadTargetToString(target).c_str(), level);
|
||||
uploadItem.uploadByteSize = uploadItem.expandedData.size();
|
||||
}
|
||||
const SizeT levelBytes = uploadItem.uploadByteSize;
|
||||
if (GetAspectMaskForFormat(outResource.format) == VK_IMAGE_ASPECT_COLOR_BIT) {
|
||||
if (!formatInfo.expandRgbToRgba &&
|
||||
GetAspectMaskForFormat(outResource.format) == VK_IMAGE_ASPECT_COLOR_BIT) {
|
||||
const auto region = mipmapTexture.GetStorageDirtyRegion(target, level);
|
||||
const SizeT texelCount = static_cast<SizeT>(texelSize.x()) *
|
||||
static_cast<SizeT>(texelSize.y()) *
|
||||
static_cast<SizeT>(std::max(texelSize.z(), 1));
|
||||
// Exactly the texels the client wrote, never their union box or the storage's
|
||||
// rect list (which merges touching writes into their bounding box, folds when
|
||||
// full and is withheld past 3/4 of the box): the image may hold what the GPU
|
||||
// drew or cleared anywhere else, and the shadow is stale there. Each box is one
|
||||
// more VkBufferImageCopy in the same vkCmdCopyBufferToImage, which costs next
|
||||
// to nothing, so there is no cheaper shape worth being wrong for. A union box
|
||||
// that spans the level with gaps in it is not a whole-level write either.
|
||||
mipmapTexture.GetStorageDirtyFootprint(target, level, dirtyFootprint);
|
||||
if (!region.Empty() && (dirtyFootprint.size() >= 2 || !region.CoversWholeLevel(texelSize)) &&
|
||||
texelCount > 0 && levelBytes % texelCount == 0) {
|
||||
if (!region.Empty() && !region.CoversWholeLevel(texelSize) && texelCount > 0 &&
|
||||
byteSize % texelCount == 0) {
|
||||
uploadItem.subRegion = true;
|
||||
uploadItem.regionLo = region.lo;
|
||||
uploadItem.regionSize = {region.hi.x() - region.lo.x(), region.hi.y() - region.lo.y(),
|
||||
region.hi.z() - region.lo.z()};
|
||||
uploadItem.texelBytes = levelBytes / texelCount;
|
||||
uploadItem.texelBytes = byteSize / texelCount;
|
||||
uploadItem.uploadByteSize = static_cast<SizeT>(uploadItem.regionSize.x()) *
|
||||
static_cast<SizeT>(uploadItem.regionSize.y()) *
|
||||
static_cast<SizeT>(uploadItem.regionSize.z()) *
|
||||
uploadItem.texelBytes;
|
||||
// Several boxes: each is staged tightly and copied on its own. One box is
|
||||
// the union box above.
|
||||
if (dirtyFootprint.size() >= 2) {
|
||||
uploadItem.rects.assign(dirtyFootprint.begin(), dirtyFootprint.end());
|
||||
// Scatter refinement: the storage only hands out its rect list
|
||||
// when the rects' summed area is materially smaller than the
|
||||
// union box (0 otherwise), so taking it always stages fewer
|
||||
// bytes than the box - the very amplification this path exists
|
||||
// to avoid paying twice.
|
||||
MG_State::GLState::MipmapDirtyRegion
|
||||
dirtyRects[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
|
||||
const SizeT dirtyRectCount = mipmapTexture.GetStorageDirtyRects(
|
||||
target, level, dirtyRects, MG_State::GLState::MipmapStorage::kMaxDirtyRects);
|
||||
if (dirtyRectCount >= 2) {
|
||||
uploadItem.rects.assign(dirtyRects, dirtyRects + dirtyRectCount);
|
||||
SizeT rectTexels = 0;
|
||||
for (const auto& rect : uploadItem.rects) {
|
||||
rectTexels += rect.TexelCount();
|
||||
@@ -4246,6 +4195,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
}
|
||||
}
|
||||
}
|
||||
if (formatInfo.expandRgbToRgba) {
|
||||
const Bool expanded = ExpandRgbSourceToRgba(source, byteSize, texelSize, formatInfo,
|
||||
uploadItem.expandedData);
|
||||
MOBILEGL_ASSERT(expanded,
|
||||
"UploadDirtyMipLevels: failed to expand RGB textureId=%d target=%s level=%u to RGBA staging data",
|
||||
mipmapTexture.GetExternalIndex(),
|
||||
MG_Util::ConvertTextureUploadTargetToString(target).c_str(), level);
|
||||
uploadItem.uploadByteSize = uploadItem.expandedData.size();
|
||||
}
|
||||
uploadItems.push_back(Move(uploadItem));
|
||||
if (!uploadItems.back().expandedData.empty()) {
|
||||
uploadItems.back().source = uploadItems.back().expandedData.data();
|
||||
@@ -4480,7 +4438,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
const Bool depthSelectsArrayLayer = outResource.viewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY ||
|
||||
outResource.viewType == VK_IMAGE_VIEW_TYPE_2D_ARRAY ||
|
||||
outResource.viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
|
||||
Vector<VkBufferImageCopy> rectCopies;
|
||||
for (const auto& item : uploadItems) {
|
||||
if (!item.rects.empty()) {
|
||||
// Multi-rect item: one VkBufferImageCopy per rect, all submitted in a
|
||||
@@ -4488,7 +4445,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
// construction, so no two copies write the same texels. Multi-rect
|
||||
// implies subRegion, which implies a plain color aspect - the combined
|
||||
// depth-stencil split below can never see one of these.
|
||||
rectCopies.resize(item.rects.size());
|
||||
VkBufferImageCopy rectCopies[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
|
||||
Uint32 rectCopyCount = 0;
|
||||
VkDeviceSize runningOffset = item.offset;
|
||||
for (const auto& rect : item.rects) {
|
||||
@@ -4519,7 +4476,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
runningOffset += static_cast<VkDeviceSize>(rect.TexelCount() * item.texelBytes);
|
||||
}
|
||||
vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, outResource.image,
|
||||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, rectCopyCount, rectCopies.data());
|
||||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, rectCopyCount, rectCopies);
|
||||
continue;
|
||||
}
|
||||
const Uint32 depthOrLayers = item.texelSize.z() > 0 ? static_cast<Uint32>(item.texelSize.z()) : 1u;
|
||||
|
||||
@@ -332,11 +332,6 @@ public:
|
||||
// into the frame's PRE command buffer - which executes strictly before the
|
||||
// frame's commands - instead of splitting the active render pass.
|
||||
Uint64 lastRecordingGeneration = 0;
|
||||
// The same, for the last recorded command that WRITES the image (a render pass it is an
|
||||
// attachment of, a clear, a blit/copy into it, a mip generation, a storage-image binding).
|
||||
// An upload into an image written this recording has to be ordered after that write
|
||||
// (VulkanRenderer::OrderPendingUploadAfterRecording).
|
||||
Uint64 lastRecordingWriteGeneration = 0;
|
||||
// Snapshot of ITextureObject::GetContentVersion() at the last successful sync;
|
||||
// lets SyncTexture skip the whole re-check/re-upload when content is unchanged.
|
||||
Uint64 syncedContentVersion = 0;
|
||||
@@ -386,7 +381,6 @@ public:
|
||||
std::swap(this->storageUsageResolved, that.storageUsageResolved);
|
||||
std::swap(this->syncedTextureParamsVersion, that.syncedTextureParamsVersion);
|
||||
std::swap(this->lastRecordingGeneration, that.lastRecordingGeneration);
|
||||
std::swap(this->lastRecordingWriteGeneration, that.lastRecordingWriteGeneration);
|
||||
std::swap(this->syncedContentVersion, that.syncedContentVersion);
|
||||
std::swap(this->syncedMipLevelCount, that.syncedMipLevelCount);
|
||||
std::swap(this->syncedShapeVersion, that.syncedShapeVersion);
|
||||
@@ -629,26 +623,6 @@ public:
|
||||
Bool WasTouchedThisRecording(const TextureResource& resource) const {
|
||||
return resource.lastRecordingGeneration == m_recordingGeneration;
|
||||
}
|
||||
// A write is a use too. See TextureResource::lastRecordingWriteGeneration.
|
||||
void StampResourceRecordingWrite(TextureResource& resource) const {
|
||||
resource.lastRecordingGeneration = m_recordingGeneration;
|
||||
resource.lastRecordingWriteGeneration = m_recordingGeneration;
|
||||
}
|
||||
void StampTextureRecordingWrite(MG_State::GLState::ITextureObject* texture);
|
||||
// Upload-ordering queries (VulkanRenderer::OrderPendingUploadAfterRecording). None of them
|
||||
// syncs, so nothing pending is uploaded by asking. All answer for the STORAGE texture.
|
||||
//
|
||||
// Uploads are recorded into a batch submitted AHEAD of the frame's recording
|
||||
// (FlushPendingUploads), so an upload into an image the open recording already WROTE lands
|
||||
// before that write, which then overwrites the newer texels. (An image the recording only
|
||||
// read keeps the old trade: its earlier reads see the newer texels.)
|
||||
Bool HasLiveImage(MG_State::GLState::ITextureObject& textureOrView) const;
|
||||
// The next sync would record client texels into the image that is live now: same shape (a
|
||||
// shape change mints a new image instead) and content moved since the last sync.
|
||||
Bool HasPendingTexelUpload(MG_State::GLState::ITextureObject& textureOrView) const;
|
||||
Bool WasTextureWrittenThisRecording(MG_State::GLState::ITextureObject& textureOrView) const;
|
||||
// The live resource, or null.
|
||||
TextureResource* FindTextureResource(MG_State::GLState::ITextureObject& textureOrView);
|
||||
// Records that this texture is bound to a GL image unit, so its image must carry
|
||||
// VK_IMAGE_USAGE_STORAGE_BIT. Must be called before NeedsStorageImagePreparation, and
|
||||
// therefore before the render pass is committed: an image that has to be upgraded is
|
||||
|
||||
@@ -2003,9 +2003,6 @@ void main() {
|
||||
outBinding.label, texture->GetExternalIndex());
|
||||
return false;
|
||||
}
|
||||
if (!isReadFramebuffer) {
|
||||
textureManager.StampResourceRecordingWrite(*resource);
|
||||
}
|
||||
|
||||
outBinding.image = resource->image;
|
||||
outBinding.trackedLayout = &resource->layout;
|
||||
@@ -2122,9 +2119,6 @@ void main() {
|
||||
outBinding.label, texture->GetExternalIndex(), static_cast<Uint32>(requiredAspectMask));
|
||||
return false;
|
||||
}
|
||||
if (!isReadFramebuffer) {
|
||||
textureManager.StampResourceRecordingWrite(*resource);
|
||||
}
|
||||
|
||||
outBinding.image = resource->image;
|
||||
outBinding.trackedLayout = &resource->layout;
|
||||
@@ -2165,7 +2159,6 @@ void main() {
|
||||
texture.GetExternalIndex(), mipLevel, resource->mipLevels);
|
||||
return false;
|
||||
}
|
||||
textureManager.StampResourceRecordingWrite(*resource);
|
||||
|
||||
outBinding.image = resource->image;
|
||||
outBinding.trackedLayout = &resource->layout;
|
||||
@@ -3182,10 +3175,7 @@ void main() {
|
||||
}
|
||||
|
||||
VulkanRenderer::VulkanRenderer(NativeWindowType window, const VulkanRendererConfig& cfg)
|
||||
: m_window(window), m_config(cfg), m_presentsToAppWindow(window != NativeWindowType{}) {
|
||||
if (!m_presentsToAppWindow) {
|
||||
m_config.SwapInterval.reset();
|
||||
}
|
||||
: m_window(window), m_config(cfg) {
|
||||
// Initialize();
|
||||
}
|
||||
|
||||
@@ -7083,10 +7073,6 @@ void main() {
|
||||
Bool VulkanRenderer::SetupDraw(FrameContext::FrameData& frame, GLenum mode, Flags<DrawSetupAspect> aspects,
|
||||
const DrawCmdParam& drawParams,
|
||||
const IndexBufferView* pIndexBufferView) {
|
||||
// First, before anything of this draw is recorded or resolved - on the wire arm too: a
|
||||
// split server records every draw its client sends into the same frame command buffer, so
|
||||
// the same loading frame grows it the same way there.
|
||||
SplitOversizedRecording();
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
if (MG_Config::Transport != MG_Config::TransportMode::Monolith) {
|
||||
RewindWireDescriptorSetsIfDue();
|
||||
@@ -7395,15 +7381,6 @@ void main() {
|
||||
VkRenderPassManager::EndRenderPass(frame.commandBuffer);
|
||||
activeRenderPass = nullptr;
|
||||
}
|
||||
// The syncs below upload each sampled texture's pending texels into a batch that runs
|
||||
// ahead of this recording; one whose image the recording already cleared or drew into
|
||||
// would be overwritten by that earlier work. Submit it first, here, before anything below
|
||||
// records into the frame or decides from the active pass.
|
||||
for (auto* sampledTexture : sampledTextures) {
|
||||
if (sampledTexture != nullptr && OrderPendingUploadAfterRecording(frame, *sampledTexture)) {
|
||||
activeRenderPass = nullptr;
|
||||
}
|
||||
}
|
||||
Bool needSampledTextureTransitions = false;
|
||||
auto& sampledResources = m_sampledResourcesScratch;
|
||||
sampledResources.assign(sampledTextures.size(), nullptr);
|
||||
@@ -7722,8 +7699,6 @@ void main() {
|
||||
}
|
||||
|
||||
void VulkanRenderer::DispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ) {
|
||||
// Before the wire branch, for SetupDraw's reason.
|
||||
SplitOversizedRecording();
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
if (MG_Config::Transport != MG_Config::TransportMode::Monolith) {
|
||||
RewindWireDescriptorSetsIfDue();
|
||||
@@ -7785,7 +7760,6 @@ void main() {
|
||||
}
|
||||
|
||||
void VulkanRenderer::DispatchComputeIndirect(GLintptr indirect) {
|
||||
SplitOversizedRecording();
|
||||
m_textureManager->CollectGarbage();
|
||||
auto& frame = m_frameContext.GetCurrent();
|
||||
// See DispatchCompute: the dispatch accessor, not the draw one.
|
||||
@@ -8229,7 +8203,6 @@ void main() {
|
||||
m_renderPassManager->QueueRenderbufferClear(
|
||||
{.mask = GL_COLOR_BUFFER_BIT, .color = payload.color}, attachment);
|
||||
} else if (attachment.IsTexture()) {
|
||||
SettleTexelsBeforeQueuedClear(*fbo, attachment);
|
||||
m_clearManager->QueueClear({.mask = GL_COLOR_BUFFER_BIT, .color = payload.color},
|
||||
attachment);
|
||||
}
|
||||
@@ -8241,19 +8214,6 @@ void main() {
|
||||
return;
|
||||
}
|
||||
|
||||
if ((deferredMask & GL_COLOR_BUFFER_BIT) != 0) {
|
||||
for (const auto drawBuffer : fbo->GetDrawBuffers()) {
|
||||
if (drawBuffer != FramebufferAttachmentType::None) {
|
||||
SettleTexelsBeforeQueuedClear(*fbo, fbo->GetAttachment(drawBuffer));
|
||||
}
|
||||
}
|
||||
}
|
||||
if ((deferredMask & GL_DEPTH_BUFFER_BIT) != 0) {
|
||||
SettleTexelsBeforeQueuedClear(*fbo, fbo->GetAttachment(FramebufferAttachmentType::Depth));
|
||||
}
|
||||
if ((deferredMask & GL_STENCIL_BUFFER_BIT) != 0) {
|
||||
SettleTexelsBeforeQueuedClear(*fbo, fbo->GetAttachment(FramebufferAttachmentType::Stencil));
|
||||
}
|
||||
m_clearManager->QueueClear(deferredMask, payload, *fbo);
|
||||
m_renderPassManager->QueueRenderbufferClear(deferredMask, payload, *fbo);
|
||||
}
|
||||
@@ -8331,7 +8291,6 @@ void main() {
|
||||
if (!attachment.IsTexture()) {
|
||||
return;
|
||||
}
|
||||
SettleTexelsBeforeQueuedClear(framebuffer, attachment);
|
||||
m_clearManager->QueueClear(payload, attachment);
|
||||
};
|
||||
|
||||
@@ -8698,8 +8657,7 @@ void main() {
|
||||
}
|
||||
|
||||
Bool VulkanRenderer::MaterializePendingClearForTexture(VkCommandBuffer commandBuffer,
|
||||
MG_State::GLState::ITextureObject& texture,
|
||||
Bool uploadPendingTexels) {
|
||||
MG_State::GLState::ITextureObject& texture) {
|
||||
Vector<PendingClearEntry> pendingClears;
|
||||
if (!m_clearManager->GetPendingClears(&texture, pendingClears)) {
|
||||
return true;
|
||||
@@ -8711,9 +8669,8 @@ void main() {
|
||||
commandBuffer != m_frameContext.GetCurrent().commandBuffer,
|
||||
"MaterializePendingClearForTexture requires no active render pass on the target buffer");
|
||||
|
||||
auto* resource = uploadPendingTexels ? m_textureManager->SyncTextureAndGetDescriptor(texture)
|
||||
: m_textureManager->FindTextureResource(texture);
|
||||
if (resource == nullptr || resource->image == VK_NULL_HANDLE) {
|
||||
auto* resource = m_textureManager->SyncTextureAndGetDescriptor(texture);
|
||||
if (resource == nullptr) {
|
||||
// Declined sync (an incomplete texture, say). Nothing to clear into, and every line
|
||||
// below dereferences this - the assert that used to stand here is compiled out of
|
||||
// every build past DEBUG.
|
||||
@@ -8865,9 +8822,6 @@ void main() {
|
||||
"MaterializePendingClearForTexture: failed to transition textureId=%d to sampled layout",
|
||||
texture.GetExternalIndex());
|
||||
resource->layout = sampledLayout;
|
||||
// The clear is now a write in this recording, which is what orders a later upload into
|
||||
// the image after it (OrderPendingUploadAfterRecording).
|
||||
m_textureManager->StampResourceRecordingWrite(*resource);
|
||||
|
||||
m_clearManager->PopPendingClear(&texture);
|
||||
MGLOG_D("MaterializePendingClearForTexture: textureId=%d pending clear materialized",
|
||||
@@ -8875,62 +8829,6 @@ void main() {
|
||||
return true;
|
||||
}
|
||||
|
||||
Bool VulkanRenderer::OrderPendingUploadAfterRecording(FrameContext::FrameData& frame,
|
||||
MG_State::GLState::ITextureObject& texture) {
|
||||
if (!m_textureManager->HasPendingTexelUpload(texture)) {
|
||||
return false;
|
||||
}
|
||||
// An open pass drawing into the image stamps that write only when it ends.
|
||||
if (const auto* activeRenderPass = VkRenderPassManager::GetActiveRenderPass();
|
||||
activeRenderPass != nullptr && ActiveRenderPassUsesTexture(*activeRenderPass, texture)) {
|
||||
VkRenderPassManager::EndRenderPass(frame.commandBuffer);
|
||||
}
|
||||
const Bool clearFirst = m_clearManager->HasPendingClear(&texture);
|
||||
if (!clearFirst && !m_textureManager->WasTextureWrittenThisRecording(texture)) {
|
||||
// Nothing recorded writes the image: the upload may run ahead of the recording.
|
||||
return false;
|
||||
}
|
||||
if (!frame.isCommandRecording) {
|
||||
m_frameContext.BeginCommandRecording();
|
||||
}
|
||||
if (VkRenderPassManager::GetActiveRenderPass() != nullptr) {
|
||||
VkRenderPassManager::EndRenderPass(frame.commandBuffer);
|
||||
}
|
||||
if (clearFirst && !MaterializePendingClearForTexture(frame.commandBuffer, texture,
|
||||
/*uploadPendingTexels=*/false)) {
|
||||
MGLOG_E_ONCE("OrderPendingUploadAfterRecording: textureId=%d kept its queued clear; it may land over "
|
||||
"texels written after it",
|
||||
texture.GetExternalIndex());
|
||||
}
|
||||
if (!FlushPendingCommands()) {
|
||||
MGLOG_E_ONCE("OrderPendingUploadAfterRecording: submit failed; textureId=%d's upload may run ahead of "
|
||||
"earlier work on it",
|
||||
texture.GetExternalIndex());
|
||||
return false;
|
||||
}
|
||||
m_frameContext.BeginCommandRecording();
|
||||
// New command buffer: the same reset SetupDraw applies when it begins one.
|
||||
m_lastSampledSetValid = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
void VulkanRenderer::SettleTexelsBeforeQueuedClear(
|
||||
const MG_State::GLState::FramebufferObject& framebuffer,
|
||||
const MG_State::GLState::FramebufferAttachmentObject& attachment) {
|
||||
// The default framebuffer's attachments are placeholders: its clears land on the
|
||||
// swapchain image (MaterializePendingClearForDefaultFramebuffer) and it has no texels.
|
||||
if (framebuffer.IsDefaultFramebuffer() || !attachment.IsTexture() || attachment.IsRenderbuffer()) {
|
||||
return;
|
||||
}
|
||||
const auto texture = attachment.GetTexture();
|
||||
if (!texture || (m_textureManager->HasLiveImage(*texture) &&
|
||||
!m_textureManager->HasPendingTexelUpload(*texture))) {
|
||||
return;
|
||||
}
|
||||
OrderPendingUploadAfterRecording(m_frameContext.GetCurrent(), *texture);
|
||||
m_textureManager->SyncTextureAndGetDescriptor(*texture);
|
||||
}
|
||||
|
||||
Bool VulkanRenderer::MaterializeMultisamplePendingClear(VkCommandBuffer commandBuffer,
|
||||
MG_State::GLState::ITextureObject& texture,
|
||||
VkTextureManager::TextureResource& resource,
|
||||
@@ -10884,7 +10782,6 @@ void main() {
|
||||
const Bool dstClearReady = materializeClear(dstEndpoint);
|
||||
MOBILEGL_ASSERT(dstClearReady, "%s: failed to materialize pending clear for destination objectId=%u",
|
||||
__func__, CopyImageEndpointName(dstEndpoint));
|
||||
m_textureManager->StampTextureRecordingWrite(dstEndpoint.Texture.get());
|
||||
|
||||
const VkImageLayout srcOriginalLayout = *srcImage.trackedLayout;
|
||||
const VkImageLayout dstOriginalLayout = *dstImage.trackedLayout;
|
||||
@@ -11169,13 +11066,6 @@ void main() {
|
||||
}
|
||||
|
||||
auto& frame = m_frameContext.GetCurrent();
|
||||
if (!readFbo->IsDefaultFramebuffer()) {
|
||||
// The read syncs the source texture, whose pending texels must land after work already
|
||||
// recorded against it (see OrderPendingUploadAfterRecording).
|
||||
if (const auto readTexture = readFbo->GetAttachment(readFbo->GetReadBuffer()).GetTexture()) {
|
||||
OrderPendingUploadAfterRecording(frame, *readTexture);
|
||||
}
|
||||
}
|
||||
if (!frame.isCommandRecording) {
|
||||
m_frameContext.BeginCommandRecording();
|
||||
}
|
||||
@@ -11901,9 +11791,6 @@ void main() {
|
||||
return;
|
||||
}
|
||||
|
||||
// The sync below uploads pending texels, which must land after work already recorded
|
||||
// against this image (see OrderPendingUploadAfterRecording).
|
||||
OrderPendingUploadAfterRecording(m_frameContext.GetCurrent(), *textureObject);
|
||||
auto* resource = m_textureManager->SyncTextureAndGetDescriptor(*textureObject);
|
||||
// Two shapes end up in the same place, and for the same reason: the GL level being read has
|
||||
// no GPU storage, so UploadDirtyMipLevels never wrote it and the CPU shadow is the ONLY copy
|
||||
@@ -12249,7 +12136,6 @@ void main() {
|
||||
resource = m_textureManager->SyncTextureAndGetDescriptor(*texture);
|
||||
MOBILEGL_ASSERT(resource != nullptr && resource->image != VK_NULL_HANDLE,
|
||||
"GenerateMipmap failed to resync the backend texture after allocating mip storage.");
|
||||
m_textureManager->StampResourceRecordingWrite(*resource);
|
||||
if (resource->layout == VK_IMAGE_LAYOUT_UNDEFINED) {
|
||||
const VkImageLayout finalLayout = ResolveGenerateMipmapFinalLayout(resource->aspect);
|
||||
Bool transitioned = VkTextureManager::TransitionImageLayout(
|
||||
@@ -14205,54 +14091,6 @@ void main() {
|
||||
return FlushPendingCommands();
|
||||
}
|
||||
|
||||
void VulkanRenderer::SplitOversizedRecording() {
|
||||
const Uint32 maxDraws = MG_Config::Features.MagmaMaxDrawsPerCommandBuffer;
|
||||
if (maxDraws == 0) {
|
||||
return;
|
||||
}
|
||||
// Counted before the check, so a buffer carries at most maxDraws calls before the one
|
||||
// that splits it. OnFrameCommandRecordingBegan resets the count on every new recording.
|
||||
if (++m_drawsInRecording <= maxDraws || !HasPendingRecordedWork()) {
|
||||
return;
|
||||
}
|
||||
// Nothing of the current call is recorded yet, so the split falls between two GL calls,
|
||||
// exactly where a glFlush would put it: the render pass ends with STORE, the next draw
|
||||
// re-begins it with LOAD, and queries and transform feedback are bracketed per draw.
|
||||
if (!FlushPendingCommands()) {
|
||||
return;
|
||||
}
|
||||
// Fresh command buffer: the same reset every other mid-frame flush site applies.
|
||||
m_lastSampledSetValid = false;
|
||||
++m_oversizedRecordingSplits;
|
||||
MGLOG_I_ONCE("DirectVulkan: a frame recorded more than %u draws into one command buffer; submitting it and "
|
||||
"continuing on a fresh one (MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER, 0 = unbounded)",
|
||||
maxDraws);
|
||||
MGLOG_D("DirectVulkan: split an oversized recording (%llu so far, submit index %llu)",
|
||||
static_cast<unsigned long long>(m_oversizedRecordingSplits),
|
||||
static_cast<unsigned long long>(m_submitCounter));
|
||||
|
||||
// Splitting only bounds the driver's command memory if the submitted buffers are freed
|
||||
// as fast as they are produced. A GPU that falls behind would park them all on the
|
||||
// retired list, which is the same growth spread over more buffers - so hold the queue
|
||||
// to frames-in-flight + 1 outstanding submissions, the steady state of a pipelined
|
||||
// frame plus this split. Wait on the fence directly rather than through
|
||||
// WaitForSubmitIndex: its opportunistic TryDrainFrameTransients may rewind the transient
|
||||
// arena, and this runs at the start of a draw whose caller may already hold slices of it.
|
||||
const SizeT maxOutstanding = static_cast<SizeT>(m_frameContext.GetFrameCount()) + 1;
|
||||
while (m_inFlightSubmits.size() > maxOutstanding) {
|
||||
const SubmitRecord oldest = m_inFlightSubmits.front();
|
||||
if (oldest.fence == VK_NULL_HANDLE) {
|
||||
break;
|
||||
}
|
||||
const VkResult waitResult = vkWaitForFences(m_device, 1, &oldest.fence, VK_TRUE, UINT64_MAX);
|
||||
if (waitResult != VK_SUCCESS) {
|
||||
MGLOG_E_ONCE("SplitOversizedRecording: vkWaitForFences returned %d", waitResult);
|
||||
break;
|
||||
}
|
||||
OnSubmitsCompletedUpTo(oldest.submitIndex);
|
||||
}
|
||||
}
|
||||
|
||||
Bool VulkanRenderer::WaitForSubmitIndex(Uint64 submitIndex, Uint64 timeoutNs, Bool flushIfPending) {
|
||||
if (IsSubmitIndexComplete(submitIndex)) {
|
||||
return true;
|
||||
@@ -14298,7 +14136,6 @@ void main() {
|
||||
}
|
||||
|
||||
void VulkanRenderer::OnFrameCommandRecordingBegan(VkCommandBuffer commandBuffer) {
|
||||
m_drawsInRecording = 0;
|
||||
// Dynamic state does not survive a command-buffer boundary.
|
||||
ResetDynamicStateShadow();
|
||||
InvalidateSetupDrawSnapshots();
|
||||
@@ -14569,22 +14406,8 @@ void main() {
|
||||
if (!m_swapchainResizeRequested && SwapchainIsOutOfDate()) {
|
||||
m_swapchainResizeRequested = true;
|
||||
}
|
||||
// A new eglSwapInterval lands here too, between frames: this one is on screen and the
|
||||
// next has recorded nothing. Only a different present mode is worth the rebuild (it
|
||||
// drops every pipeline); otherwise the live swapchain already paces as asked.
|
||||
if (m_config.SwapInterval != m_swapchainSwapInterval) {
|
||||
if (SwapchainObject::ChooseSwapchainPresentMode(m_swapchainObject.GetSupportedPresentModes(),
|
||||
m_config.SwapInterval) !=
|
||||
m_swapchainObject.GetPresentMode()) {
|
||||
m_swapchainResizeRequested = true;
|
||||
} else {
|
||||
MGLOG_D("DirectVulkan: swap interval %d -> %s", *m_config.SwapInterval,
|
||||
SwapchainObject::GetPresentModeName(m_swapchainObject.GetPresentMode()));
|
||||
m_swapchainSwapInterval = m_config.SwapInterval;
|
||||
}
|
||||
}
|
||||
if (m_swapchainResizeRequested) {
|
||||
MGLOG_D("Present, processing requested swapchain rebuild (resize or swap interval)");
|
||||
MGLOG_D("Present, processing requested swapchain resize");
|
||||
if (!RecreateSwapchain()) {
|
||||
m_presentSuspended = true;
|
||||
m_swapchainResizeRequested = false;
|
||||
@@ -16262,12 +16085,7 @@ void main() {
|
||||
m_swapchainObject.Create(m_device, m_physicalDevice.handle, m_surface,
|
||||
static_cast<Uint32>(m_physicalDevice.queueFamilies.graphicsFamily),
|
||||
static_cast<Uint32>(m_physicalDevice.queueFamilies.presentFamily),
|
||||
m_config.MaxFramesInFlight, desiredExtent, m_config.SwapInterval);
|
||||
if (m_config.SwapInterval && m_config.SwapInterval != m_swapchainSwapInterval) {
|
||||
MGLOG_D("DirectVulkan: swap interval %d -> %s", *m_config.SwapInterval,
|
||||
SwapchainObject::GetPresentModeName(m_swapchainObject.GetPresentMode()));
|
||||
}
|
||||
m_swapchainSwapInterval = m_config.SwapInterval;
|
||||
m_config.MaxFramesInFlight, desiredExtent);
|
||||
// The FragCoordYFlip variants bake this height in; it is the only input to a shader
|
||||
// module that lives outside the GL program, so the factory has to learn it here (and on
|
||||
// every recreation, which is the only way it can change).
|
||||
@@ -16723,12 +16541,6 @@ void main() {
|
||||
m_swapchainResizeRequested = true;
|
||||
}
|
||||
|
||||
void VulkanRenderer::SetSwapInterval(Int interval) {
|
||||
if (m_presentsToAppWindow) {
|
||||
m_config.SwapInterval = interval;
|
||||
}
|
||||
}
|
||||
|
||||
VkInstance VulkanRenderer::GetInstance() const {
|
||||
return m_instance;
|
||||
}
|
||||
|
||||
@@ -327,10 +327,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
// signal as soon as the GPU actually finishes, which MC 1.21.5's
|
||||
// fence-paced ring buffers rely on to recycle their space.
|
||||
Uint64 GetSyncPointSubmitIndex() const;
|
||||
// For tests: the per-frame descriptor pools (see DescriptorPoolCensus.h).
|
||||
DescriptorPoolCensus GetDescriptorPoolCensus() const {
|
||||
return m_uniformManager ? m_uniformManager->GetDescriptorPoolCensus() : DescriptorPoolCensus{};
|
||||
}
|
||||
// Non-blocking: polls outstanding submission fences and reports
|
||||
// whether every submission up to `submitIndex` has completed.
|
||||
Bool IsSubmitIndexComplete(Uint64 submitIndex);
|
||||
@@ -394,12 +390,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
Bool ResolveOcclusionQueryResult(const Vector<Uint32>& slots, Uint64& outSamples);
|
||||
|
||||
void RequestSwapchainResize(Uint32 width, Uint32 height);
|
||||
// eglSwapInterval. Records the request; Present rebuilds the swapchain for it once the
|
||||
// current frame is on screen, and only when it maps to a different present mode. A
|
||||
// renderer created without an app window ignores it: its surface (headless, or an
|
||||
// AImageReader nobody consumes) is never displayed, and FIFO there would block once
|
||||
// the reader's queue fills.
|
||||
void SetSwapInterval(Int interval);
|
||||
// Re-query the surface and report whether the live swapchain no longer matches it
|
||||
// (size or orientation). This - not a VK_SUBOPTIMAL_KHR result - is what decides a
|
||||
// rebuild, so a surface the driver merely considers suboptimal cannot thrash.
|
||||
@@ -740,15 +730,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
// only), so the presenting path's frames-in-flight pipelining is
|
||||
// untouched. Returns true when the drain ran.
|
||||
Bool TryDrainFrameTransients();
|
||||
// Bounded recording: called at the top of every GL draw and dispatch, before anything
|
||||
// of that call is recorded. Once the open frame command buffer holds
|
||||
// MagmaMaxDrawsPerCommandBuffer draws/dispatches, submits it (FlushPendingCommands) so
|
||||
// the call continues on a fresh one, then waits until at most frames-in-flight + 1
|
||||
// submissions are outstanding. A driver backs a command buffer with GPU memory it only
|
||||
// returns when the buffer is freed (Adreno: one 16 KiB mapping per chunk), so a frame
|
||||
// that is never split grows it without bound - rd12's loading frame records ~1M draws
|
||||
// into one buffer and runs the process out of vm.max_map_count.
|
||||
void SplitOversizedRecording();
|
||||
|
||||
Vector<SubmitRecord> m_inFlightSubmits;
|
||||
Vector<VkFence> m_freeSubmitFences;
|
||||
@@ -760,10 +741,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
// aging clocks, while present-less loops still cross a boundary every few
|
||||
// iterations. Reset in Present.
|
||||
Uint32 m_drainsSinceLastPresent = 0;
|
||||
// GL draws/dispatches recorded into the open frame command buffer; reset whenever a
|
||||
// recording begins (OnFrameCommandRecordingBegan). See SplitOversizedRecording.
|
||||
Uint32 m_drawsInRecording = 0;
|
||||
Uint64 m_oversizedRecordingSplits = 0;
|
||||
|
||||
NativeWindowType m_window = 0;
|
||||
void* m_platformDisplay = nullptr;
|
||||
@@ -783,11 +760,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
// Shutdown() deletes it.
|
||||
void* m_fallbackImageReader = nullptr;
|
||||
VulkanRendererConfig m_config;
|
||||
// Constructed for the app's window rather than a pbuffer (m_window is later filled in
|
||||
// for the pbuffer fallbacks too, so it cannot tell them apart).
|
||||
Bool m_presentsToAppWindow = false;
|
||||
// The m_config.SwapInterval the live swapchain was built for; Present compares the two.
|
||||
Optional<Int> m_swapchainSwapInterval;
|
||||
Bool m_swapchainResizeRequested = false;
|
||||
// Presentation is suspended while the window is zero-area (minimized): the
|
||||
// swapchain is unusable/out of date, so Present drops frames instead of
|
||||
@@ -1889,28 +1861,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
MG_State::GLState::ITextureObject& texture, Uint32 mipLevel,
|
||||
Uint32 depthSlice, const VkClearValue& clearValue,
|
||||
VkImageLayout finalLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
||||
// Records the texture's queued clears. By default the texture is synced first, which
|
||||
// uploads any pending texels BEFORE the clear - right only for texels written before it.
|
||||
// `uploadPendingTexels = false` leaves them pending (OrderPendingUploadAfterRecording).
|
||||
Bool MaterializePendingClearForTexture(VkCommandBuffer commandBuffer,
|
||||
MG_State::GLState::ITextureObject& texture,
|
||||
Bool uploadPendingTexels = true);
|
||||
// Texture uploads run in a batch submitted ahead of the frame's recording, so the upload
|
||||
// the next sync of `texture` records would land BEFORE a write already recorded into the
|
||||
// same image (a render, clear, blit or copy), and before a clear still queued for it (such
|
||||
// a clear predates the texels: SettleTexelsBeforeQueuedClear). When either holds, this
|
||||
// records the queued clear without the texels and submits the recording, so the upload
|
||||
// follows both. An image the recording only READ keeps the old trade: no submit, and its
|
||||
// earlier reads see the newer texels. It may end the render pass and replace
|
||||
// frame.commandBuffer (recording again on return), so call it only where the caller holds
|
||||
// no render-pass or command-buffer state across it. Returns whether it submitted.
|
||||
Bool OrderPendingUploadAfterRecording(FrameContext::FrameData& frame,
|
||||
MG_State::GLState::ITextureObject& texture);
|
||||
// Called for each texture a glClear/glClearBuffer* is about to queue a clear on: uploads
|
||||
// whatever texels are still pending (and mints the image if there is none), so that any
|
||||
// texel pending when the clear is materialized was written after it.
|
||||
void SettleTexelsBeforeQueuedClear(const MG_State::GLState::FramebufferObject& framebuffer,
|
||||
const MG_State::GLState::FramebufferAttachmentObject& attachment);
|
||||
MG_State::GLState::ITextureObject& texture);
|
||||
// The multisample arm of the above. Split out rather than branched inline because it
|
||||
// shares none of the transfer path: a multisample image carries no TRANSFER_DST usage, so
|
||||
// neither the TRANSFER_DST transition nor vkCmdClearColorImage is legal on one.
|
||||
|
||||
@@ -22,9 +22,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
|
||||
Uint64 CacheVersion = MG_Config::CacheVersion;
|
||||
Uint32 SurfaceWidth = 1;
|
||||
Uint32 SurfaceHeight = 1;
|
||||
// The app's eglSwapInterval; empty until it asks. Window renderers only - see
|
||||
// VulkanRenderer::SetSwapInterval.
|
||||
Optional<Int> SwapInterval;
|
||||
Bool DisablePipelineCache = false;
|
||||
#if MOBILEGL_LOG_ACTIVE_LEVEL <= MOBILEGL_LOG_LEVEL_DEBUG
|
||||
Bool EnableValidationLayers = true;
|
||||
|
||||
@@ -81,10 +81,9 @@ namespace MobileGL::MG_Backend {
|
||||
// DirectGLES consumes all thirteen migrated families (P2's 0..6, P3a's 7..8, P4a's
|
||||
// 9..12): it registers the resource op table in Initialize()
|
||||
// (BackendObject_DirectGLES.cpp:849) and reads every other family out of gPipeInputs.
|
||||
// DirectVulkan registers its wire resource op table off monolith only
|
||||
// (VkBufferManager::RegisterWireResourceOps, VkBufferManager.cpp): under a transport it
|
||||
// owns buffer stores and claims bit 7 (the P4a mask, see ConsumedSubsystemsFor below);
|
||||
// under monolith it registers none and its buffers keep the legacy BufferBackendOps path.
|
||||
// DirectVulkan registers NO resource ops - MGPipeSetResourceOps has exactly one caller
|
||||
// in the whole tree and it is Managers.cpp:2594 - so bit 7 is CLEAR for it, which is
|
||||
// the same fact ObjectSubsystemControlScenario already pins from the client side.
|
||||
// P5e (MG_Remote/CONTRACT-P5E.md §6.2). THE ONE CONSTANT THE WHOLE PHASE HANGS ON.
|
||||
//
|
||||
// kCapRunAheadApply says "this server applies an unbarriered record without reading
|
||||
|
||||
@@ -146,34 +146,11 @@ namespace MobileGL::MG_Impl::EGLImpl {
|
||||
return EGL_NO_SURFACE;
|
||||
}
|
||||
|
||||
Uint32 requestedWidth = static_cast<Uint32>(std::max<EGLint>(GetAttribValue(attrib_list, EGL_WIDTH, 0), 0));
|
||||
Uint32 requestedHeight = static_cast<Uint32>(std::max<EGLint>(GetAttribValue(attrib_list, EGL_HEIGHT, 0), 0));
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED && defined(__ANDROID__)
|
||||
// P12: A GAME'S OWN WINDOW SIZE IS THE SIZE OF THE FRAMES IT RENDERS, and a server-owned
|
||||
// window has to take that size or clip. SDL (Minecraft's Android backend) creates the EGL
|
||||
// window surface with no EGL_WIDTH / EGL_HEIGHT, so the request went out as 0x0 - "use the
|
||||
// server window's own size" - and a landscape 2620x1280 game drawn into a portrait 1280x2620
|
||||
// server window came out clipped to its bottom-left 1280x1280 corner (Espryt and Magma
|
||||
// alike; the same game in a landscape window was right). The native window it handed us
|
||||
// knows the size the game believes it has: ask for THAT, and the server fixes its window
|
||||
// buffer to it and aspect-fits the view (MobileGLDisplayActivity), letterboxed.
|
||||
if (serverOwnedWindow && requestedWidth == 0 && requestedHeight == 0 && !IsNullNativeHandle(window)) {
|
||||
auto* native = reinterpret_cast<ANativeWindow*>(ToVoidHandle(window));
|
||||
const int32_t nativeWidth = ANativeWindow_getWidth(native);
|
||||
const int32_t nativeHeight = ANativeWindow_getHeight(native);
|
||||
if (nativeWidth > 0 && nativeHeight > 0) {
|
||||
requestedWidth = static_cast<Uint32>(nativeWidth);
|
||||
requestedHeight = static_cast<Uint32>(nativeHeight);
|
||||
MGLOG_I("eglCreateWindowSurface: no EGL_WIDTH/EGL_HEIGHT; the server-owned window is asked for the "
|
||||
"native window's %dx%d", nativeWidth, nativeHeight);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
const MG_Backend::WindowHandle windowHandle = {
|
||||
.Backend = DetectWindowBackend(),
|
||||
.Handle = ToVoidHandle(window),
|
||||
.Width = requestedWidth,
|
||||
.Height = requestedHeight,
|
||||
.Width = static_cast<Uint32>(std::max<EGLint>(GetAttribValue(attrib_list, EGL_WIDTH, 0), 0)),
|
||||
.Height = static_cast<Uint32>(std::max<EGLint>(GetAttribValue(attrib_list, EGL_HEIGHT, 0), 0)),
|
||||
};
|
||||
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
|
||||
@@ -41,18 +41,6 @@
|
||||
// call sites below are declarations only, exactly as the frontend's mutators are.
|
||||
#include <MG_Pipe/PipeMutation.h>
|
||||
|
||||
// P9 (W1, MG_Remote/CONTRACT-P9.md §1): AN UNPACK SOURCE IS READ FROM THE BUFFER'S CLIENT SHADOW,
|
||||
// and under a transport a GPU write into that buffer - a read_pixels_to_buffer, which is how a
|
||||
// glReadPixels into a pack buffer now crosses, or a shader store - reaches the shadow only through
|
||||
// SyncGpuWrites, exactly as glMapBufferRange and glGetBufferSubData already do. Monolith keeps its
|
||||
// read as it was: its ReadPixels maps the driver PBO back into the shadow inside the call, and the
|
||||
// pull build compiles this to nothing (G1).
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
#define MGL_SYNC_PIXEL_UNPACK_SOURCE(buffer) do { if (MG_Config::Transport != MG_Config::TransportMode::Monolith) (buffer)->SyncGpuWrites(); } while (0)
|
||||
#else
|
||||
#define MGL_SYNC_PIXEL_UNPACK_SOURCE(buffer) ((void)0)
|
||||
#endif
|
||||
|
||||
namespace MobileGL::MG_Impl::GLImpl {
|
||||
static SharedPtr<MG_State::GLState::ITextureObject> nullTextureObject;
|
||||
static UnorderedMap<Uint, Bool> g_autoGenerateMipmapByTextureId;
|
||||
@@ -1785,7 +1773,6 @@ namespace MobileGL::MG_Impl::GLImpl {
|
||||
const auto& unpackBuffer =
|
||||
MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::PixelUnpack).GetBoundObject();
|
||||
if (!unpackBuffer) return data;
|
||||
MGL_SYNC_PIXEL_UNPACK_SOURCE(unpackBuffer);
|
||||
return reinterpret_cast<const char*>(unpackBuffer->MappedData()) + reinterpret_cast<SizeT>(data);
|
||||
}
|
||||
|
||||
@@ -1832,7 +1819,6 @@ namespace MobileGL::MG_Impl::GLImpl {
|
||||
const auto& pixelUnpackBufferObject =
|
||||
MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::PixelUnpack).GetBoundObject();
|
||||
if (pixelUnpackBufferObject) {
|
||||
MGL_SYNC_PIXEL_UNPACK_SOURCE(pixelUnpackBufferObject);
|
||||
originalPixels = reinterpret_cast<const char*>(pixelUnpackBufferObject->MappedData()) +
|
||||
reinterpret_cast<SizeT>(pixels);
|
||||
}
|
||||
@@ -1955,7 +1941,6 @@ namespace MobileGL::MG_Impl::GLImpl {
|
||||
if (pixelUnpackBufferObject) {
|
||||
MGLOG_D("TexSubImage2D_State: Using Pixel Unpack Buffer Object ID: %u",
|
||||
pixelUnpackBufferObject->GetExternalIndex());
|
||||
MGL_SYNC_PIXEL_UNPACK_SOURCE(pixelUnpackBufferObject);
|
||||
originalPixels = reinterpret_cast<const char*>(pixelUnpackBufferObject->MappedData()) +
|
||||
reinterpret_cast<SizeT>(pixels);
|
||||
}
|
||||
@@ -2045,7 +2030,6 @@ namespace MobileGL::MG_Impl::GLImpl {
|
||||
const auto& pixelUnpackBufferObject =
|
||||
MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::PixelUnpack).GetBoundObject();
|
||||
if (pixelUnpackBufferObject) {
|
||||
MGL_SYNC_PIXEL_UNPACK_SOURCE(pixelUnpackBufferObject);
|
||||
originalPixels = reinterpret_cast<const char*>(pixelUnpackBufferObject->MappedData()) +
|
||||
reinterpret_cast<SizeT>(pixels);
|
||||
}
|
||||
@@ -2551,7 +2535,6 @@ namespace MobileGL::MG_Impl::GLImpl {
|
||||
if (pixelUnpackBufferObject) {
|
||||
MGLOG_D("%s: Using Pixel Unpack Buffer Object ID: %u", __func__,
|
||||
pixelUnpackBufferObject->GetExternalIndex());
|
||||
MGL_SYNC_PIXEL_UNPACK_SOURCE(pixelUnpackBufferObject);
|
||||
originalPixels = reinterpret_cast<const char*>(pixelUnpackBufferObject->MappedData()) +
|
||||
reinterpret_cast<SizeT>(pixels);
|
||||
}
|
||||
@@ -2699,7 +2682,6 @@ namespace MobileGL::MG_Impl::GLImpl {
|
||||
if (pixelUnpackBufferObject) {
|
||||
MGLOG_D("%s: Using Pixel Unpack Buffer Object ID: %u", __func__,
|
||||
pixelUnpackBufferObject->GetExternalIndex());
|
||||
MGL_SYNC_PIXEL_UNPACK_SOURCE(pixelUnpackBufferObject);
|
||||
originalPixels = reinterpret_cast<const char*>(pixelUnpackBufferObject->MappedData()) +
|
||||
reinterpret_cast<SizeT>(pixels);
|
||||
}
|
||||
@@ -2818,7 +2800,6 @@ namespace MobileGL::MG_Impl::GLImpl {
|
||||
const auto& pixelUnpackBufferObject =
|
||||
MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::PixelUnpack).GetBoundObject();
|
||||
if (pixelUnpackBufferObject) {
|
||||
MGL_SYNC_PIXEL_UNPACK_SOURCE(pixelUnpackBufferObject);
|
||||
originalPixels = reinterpret_cast<const char*>(pixelUnpackBufferObject->MappedData()) +
|
||||
reinterpret_cast<SizeT>(pixels);
|
||||
}
|
||||
@@ -6281,7 +6262,6 @@ namespace MobileGL::MG_Impl::GLImpl {
|
||||
const auto& pixelUnpackBufferObject =
|
||||
MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::PixelUnpack).GetBoundObject();
|
||||
if (pixelUnpackBufferObject) {
|
||||
MGL_SYNC_PIXEL_UNPACK_SOURCE(pixelUnpackBufferObject);
|
||||
originalPixels = reinterpret_cast<const char*>(pixelUnpackBufferObject->MappedData()) +
|
||||
reinterpret_cast<SizeT>(pixels);
|
||||
}
|
||||
|
||||
@@ -233,9 +233,9 @@ namespace MobileGL::MG_Pipe {
|
||||
desc.StorageKind = MGPipeTextureStorageKindForTarget(texture.GetTarget());
|
||||
desc.BindMask = bindMask;
|
||||
// STICKY AND FOREVER: everImageBound, the client-side answer MGPipeTypes.h asks for.
|
||||
// It PREVENTS the texture re-mint - a texture the server knows may be image-bound is
|
||||
// allocated image-bindable up front, so the server never has to read its levels back
|
||||
// and re-upload them into a new carrier (P9 W2).
|
||||
// It is the PREVENTION half of the texture-remint stall class - a texture the server
|
||||
// knows may be image-bound is allocated image-bindable up front, so the re-mint that
|
||||
// would have to pull its texels back never happens.
|
||||
desc.ImageBindableHint = (bindMask & kMGPipeBindShaderImage) != 0 ? 1 : 0;
|
||||
if (storageDefined) {
|
||||
const MGPipeTextureExtent extent = MGPipeTextureExtentOf(texture);
|
||||
@@ -702,7 +702,8 @@ namespace MobileGL::MG_Pipe {
|
||||
// mask rides resource_create and every resource_respecify - and an IMMUTABLE texture has
|
||||
// no further respecify, that being what immutable means - so for the canonical order
|
||||
// `glTexStorage2D(...); glBindImageTexture(...)` the applier's record kept
|
||||
// ImageBindableHint = 0 for ever and the re-mint PREVENTION never fired. So a mask that actually MOVES re-emits the stored descriptor with
|
||||
// ImageBindableHint = 0 for ever and the PREVENTION half of the texture-remint stall
|
||||
// class never fired. So a mask that actually MOVES re-emits the stored descriptor with
|
||||
// the new mask: every storage-defining field is byte-identical to what the applier
|
||||
// holds, which is exactly the shape wire applies as a METADATA UPDATE - the descriptor
|
||||
// is replaced, no reallocation is acked, and NO pending upload is dropped, so a mask
|
||||
@@ -1469,53 +1470,21 @@ namespace MobileGL::MG_Pipe {
|
||||
const MGPBox unionBox = MGPipeBoxOfDirtyRegion(mipmap->GetStorageDirtyRegion(uploadTarget, level));
|
||||
if (unionBox.W == 0 || unionBox.H == 0 || unionBox.D == 0) return false;
|
||||
|
||||
// THE REGION LIST BEHIND THE BOX IS THE LEVEL'S EXACT DIRTY FOOTPRINT (P11 M2, dev
|
||||
// 9524c688): disjoint boxes holding every texel written since the level was last
|
||||
// clean and no other. The storage's rect list this used to carry only COVERS the
|
||||
// writes - it merges touching rects into their bounding box, folds when full and is
|
||||
// withheld (0) past 3/4 of the union box - and once the far side's image may hold GPU
|
||||
// writes, whatever it uploads beyond the writes goes up over them. Both servers read
|
||||
// the list as the texels to upload: Magma always, Espryt once its driver texture may
|
||||
// hold GPU writes (and otherwise it re-applies the storage's box-or-rects choice
|
||||
// itself, so the Mali job count is the server's call as before).
|
||||
//
|
||||
// 0 IS NOW THE WHOLE-LEVEL SPELLING - a footprint that is the whole level - with one
|
||||
// exception (below). Every other write carries its boxes, a single one included, so the
|
||||
// applier's accumulation (boxes union, lists concatenate, "0 regions" makes the entry
|
||||
// box only) never widens two exact contributions into their union box. THE EXCEPTION:
|
||||
// a footprint larger than one record may carry (kMGPipeMaxPendingUploadRegions) falls
|
||||
// back to the storage's rect list - a COVER, stated once in the log - and when that list
|
||||
// is withheld (0: its rects fill 3/4 of the union box) this 0 is a PARTIAL, INEXACT
|
||||
// box. A reader that takes "box only" as "the client owns every texel of the box"
|
||||
// (AdoptDriverLevelIntoShadow's covering-box rule) is exact everywhere but here.
|
||||
// THE REGION LIST BEHIND THE BOX. 0 is legal and means "the union box is the whole
|
||||
// story" - it covers a single rect (identical to the box by construction), more
|
||||
// rects than the cap, and a summed area so close to the box's that one big upload
|
||||
// beats many small ones. The invariant that makes the server's choice safe is that
|
||||
// the two describe the SAME texels: every rect lies inside the box, and their union
|
||||
// is the box.
|
||||
//
|
||||
// READ AS BOXES, ONCE, because both shapes below want them in that form: the
|
||||
// whole-level record converts each one straight back through MGPipeBuildSubRegion,
|
||||
// and a piece clips each one to its own slab.
|
||||
mipmap->GetStorageDirtyFootprint(uploadTarget, level, m_footprint);
|
||||
m_rectBoxes.clear();
|
||||
const Bool wholeLevelWrite =
|
||||
m_footprint.size() == 1 && m_footprint.front().lo.x() <= 0 && m_footprint.front().lo.y() <= 0 &&
|
||||
m_footprint.front().lo.z() <= 0 && m_footprint.front().hi.x() >= levelSize.x() &&
|
||||
m_footprint.front().hi.y() >= levelSize.y() &&
|
||||
m_footprint.front().hi.z() >= std::max<Int>(levelSize.z(), 1);
|
||||
if (wholeLevelWrite) {
|
||||
// The box is the story.
|
||||
} else if (m_footprint.size() <= static_cast<SizeT>(kMGPipeMaxPendingUploadRegions)) {
|
||||
for (const auto& box : m_footprint) m_rectBoxes.push_back(MGPipeBoxOfDirtyRegion(box));
|
||||
} else {
|
||||
MGLOG_W_ONCE("MGPipe: texture {slot=%u, gen=%u} level %u has %zu disjoint dirty boxes, more than one "
|
||||
"record carries (%u); it goes out as the storage's rect list, which covers the writes "
|
||||
"but not exactly",
|
||||
pending.Handle.Slot, pending.Handle.Gen, static_cast<Uint>(level), m_footprint.size(),
|
||||
kMGPipeMaxPendingUploadRegions);
|
||||
MG_State::GLState::MipmapDirtyRegion rects[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
|
||||
const SizeT coverCount = mipmap->GetStorageDirtyRects(
|
||||
uploadTarget, level, rects, MG_State::GLState::MipmapStorage::kMaxDirtyRects);
|
||||
for (SizeT i = 0; i < coverCount; ++i) m_rectBoxes.push_back(MGPipeBoxOfDirtyRegion(rects[i]));
|
||||
}
|
||||
const SizeT rectCount = m_rectBoxes.size();
|
||||
const MGPBox* rectBoxes = m_rectBoxes.data();
|
||||
MG_State::GLState::MipmapDirtyRegion rects[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
|
||||
const SizeT rectCount = mipmap->GetStorageDirtyRects(
|
||||
uploadTarget, level, rects, MG_State::GLState::MipmapStorage::kMaxDirtyRects);
|
||||
MGPBox rectBoxes[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
|
||||
for (SizeT i = 0; i < rectCount; ++i) rectBoxes[i] = MGPipeBoxOfDirtyRegion(rects[i]);
|
||||
|
||||
Bool dispatched = false;
|
||||
Bool accepted = true;
|
||||
@@ -1655,10 +1624,6 @@ namespace MobileGL::MG_Pipe {
|
||||
Vector<Entry> m_renderbuffers;
|
||||
Vector<DrainEntry> m_drain;
|
||||
Vector<MGPSubRegion> m_regions;
|
||||
// EmitOneLevel's scratch, kept for its capacity: the level's exact footprint and the
|
||||
// boxes the record's regions are built from.
|
||||
Vector<MG_State::GLState::MipmapDirtyRegion> m_footprint;
|
||||
Vector<MGPBox> m_rectBoxes;
|
||||
Bool m_draining = false;
|
||||
|
||||
MGPResourceDesc m_lastDesc{};
|
||||
|
||||
@@ -84,11 +84,6 @@ add_executable(MobileGLIntegrationTest
|
||||
# P7 gate 5 (g5-readback): readbacks larger than one reply slot. Ordinary GL cases, so the
|
||||
# monolith arms run them too - that is the parity half of the split registrations below.
|
||||
Scenarios/BandedReadbackScenario.cpp
|
||||
# P9 (W1): reads into a pixel pack buffer answered by nothing. Ordinary GL cases too, plus
|
||||
# one wire case that skips where there is no wire.
|
||||
Scenarios/PackBufferReadbackScenario.cpp
|
||||
# P10 (A): fence polls answered from the server's reports.
|
||||
Scenarios/FencePollScenario.cpp
|
||||
Scenarios/PrimitiveRestartScenario.cpp
|
||||
Scenarios/FragCoordOriginScenario.cpp
|
||||
Scenarios/ClientVertexArrayScenario.cpp
|
||||
@@ -110,12 +105,9 @@ add_executable(MobileGLIntegrationTest
|
||||
Scenarios/ImageLoadStoreSsoScenario.cpp
|
||||
Scenarios/ImageTargetKindScenario.cpp
|
||||
Scenarios/ImageFormatQualifierScenario.cpp
|
||||
Scenarios/TextureRemintPullScenario.cpp
|
||||
Scenarios/NonCoreImageFormatScenario.cpp
|
||||
Scenarios/ImageSizeAfterRespecScenario.cpp
|
||||
Scenarios/EmptyTextureLevelScenario.cpp
|
||||
Scenarios/ImageBindableRemintScenario.cpp
|
||||
Scenarios/PartialUploadOverGpuContentScenario.cpp
|
||||
Scenarios/SsboDeclarationFormScenario.cpp
|
||||
Scenarios/Glsl420DeclarationScenario.cpp
|
||||
Scenarios/IoBlockNameCollisionScenario.cpp
|
||||
@@ -158,8 +150,6 @@ add_executable(MobileGLIntegrationTest
|
||||
Scenarios/ClearTexImageUndefinedLevelZeroScenario.cpp
|
||||
Scenarios/RenderbufferBlendFormatScenario.cpp
|
||||
Scenarios/DualSourceBlendScenario.cpp
|
||||
Scenarios/OversizedRecordingSplitScenario.cpp
|
||||
Scenarios/DescriptorPoolGrowthScenario.cpp
|
||||
Scenarios/PipeVerifyArmingScenario.cpp
|
||||
Scenarios/PoisonOmissionScenario.cpp
|
||||
Scenarios/HandleRecycleScenario.cpp
|
||||
@@ -755,12 +745,6 @@ mgl_itest_join_environment(MGL_ITEST_VULKAN_PRIMGEN_REROUTE_ENVIRONMENT
|
||||
"MOBILEGL_BACKEND_TYPE=DirectVulkan" "MOBILEGL_MAGMA_PRIMGEN_QUERY_REROUTE=1"
|
||||
"MOBILEGL_LOG_FILE_PATH=${CMAKE_CURRENT_BINARY_DIR}/primgen-query-reroute.log"
|
||||
${MGL_ITEST_VULKAN_ENV})
|
||||
# The command-buffer draw budget pinned far below one frame's draws, with the log path for the
|
||||
# split's latched MGLOG_I - the same arming reasoning as the two entries above.
|
||||
mgl_itest_join_environment(MGL_ITEST_VULKAN_SPLIT_RECORDING_ENVIRONMENT
|
||||
"MOBILEGL_BACKEND_TYPE=DirectVulkan" "MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER=64"
|
||||
"MOBILEGL_LOG_FILE_PATH=${CMAKE_CURRENT_BINARY_DIR}/oversized-recording-split.log"
|
||||
${MGL_ITEST_VULKAN_ENV})
|
||||
# The point-size demotion pinned on, per backend, with a per-lane log file for the arming
|
||||
# assertion - the same MOBILEGL_LOG_FILE_PATH reasoning as the UnlocatedIoBlocks lane above.
|
||||
# Two lanes because the demotion runs in the SHARED phase-B chain and each backend then
|
||||
@@ -1060,30 +1044,6 @@ gtest_discover_tests(MobileGLIntegrationTest
|
||||
ENVIRONMENT "${MGL_ITEST_VULKAN_PRIMGEN_REROUTE_ENVIRONMENT}"
|
||||
)
|
||||
|
||||
# OversizedRecordingSplitScenario with the command-buffer draw budget PINNED to 64. The ambient
|
||||
# registrations run its cases under the default budget, which never splits them; this entry
|
||||
# splits every case at least once between the draws that leave state (depth, stencil, a blend
|
||||
# destination, multisample samples, an open query, an active capture) and the draws that
|
||||
# consume it, so the results prove a split carries all of it, and the arming assertion (the
|
||||
# renderer's latched MGLOG_I) proves the split happened at all - on a renderer that records the
|
||||
# whole frame into one command buffer, it is the assertion that goes red. DirectVulkan only:
|
||||
# the budget steers nothing on DirectGLES, whose driver flushes on its own.
|
||||
#
|
||||
# P11 M2: RESOURCE_LOCK, for the UnlocatedIoBlocks lane's reason above - EVERY case here reads the
|
||||
# lane's one log back, and the library truncates it at each process's start, so under `ctest -j` a
|
||||
# sibling case wipes the line a reading case is looking for (measured on this tree: 5 of 8 red at
|
||||
# -j 6, a different five on the monolith and inproc runs).
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.SplitRecording."
|
||||
TEST_FILTER "OversizedRecordingSplitScenario.*"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES
|
||||
LABELS integration-gpu
|
||||
TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
RESOURCE_LOCK oversized-recording-split.log
|
||||
ENVIRONMENT "${MGL_ITEST_VULKAN_SPLIT_RECORDING_ENVIRONMENT}"
|
||||
)
|
||||
|
||||
# The packed16 copy scenarios again, with the 8-bit storage widening PINNED ON. The ambient
|
||||
# registrations above cover the narrow storage - on every CI driver the widening's POST
|
||||
# probe finds no field-order mirror, so Auto keeps the native 16-bit path - which means the
|
||||
@@ -1527,25 +1487,14 @@ gtest_discover_tests(MobileGLIntegrationTest
|
||||
# No log path: none of these three cases reads one, and giving them one would only add a file for
|
||||
# four processes to truncate. The fourth case skips in both lanes for exactly that reason, saying
|
||||
# so.
|
||||
#
|
||||
# P11 A2: both lanes pin monolith, so both DECLARE the adopted arm (MGITEST_PERSISTENT_MAP_ARM) and
|
||||
# LargeArenaAdoptionScenario.TheArenaLandsInTheTierItsLaneDeclares asserts the 24 MiB arena really
|
||||
# adopted on the handle arm (Ops_H_MapPersistentTracked) and on the legacy one. Red once with
|
||||
# MOBILEGL_DISABLE_LARGE_BUFFER_ADOPTION=1 in the job environment (CONTRACT-P11 §2).
|
||||
mgl_itest_join_environment(MGL_ITEST_GLES_ARENA_SUBSYSTEM_ON_ENVIRONMENT
|
||||
"MOBILEGL_TRANSPORT=monolith" "MGITEST_PERSISTENT_MAP_ARM=adopted"
|
||||
"MOBILEGL_TRANSPORT=monolith"
|
||||
"MOBILEGL_BACKEND_TYPE=DirectGLES" "MOBILEGL_PIPE_PUSH=0x1fff"
|
||||
${MGL_ITEST_CAPABILITY_ENV} ${MGL_ITEST_COMMON_ENV})
|
||||
mgl_itest_join_environment(MGL_ITEST_GLES_ARENA_SUBSYSTEM_OFF_ENVIRONMENT
|
||||
"MOBILEGL_TRANSPORT=monolith" "MGITEST_PERSISTENT_MAP_ARM=adopted"
|
||||
"MOBILEGL_TRANSPORT=monolith"
|
||||
"MOBILEGL_BACKEND_TYPE=DirectGLES" "MOBILEGL_PIPE_PUSH=0x7f"
|
||||
${MGL_ITEST_CAPABILITY_ENV} ${MGL_ITEST_COMMON_ENV})
|
||||
# ... and Magma's monolith half: the legacy AcquirePersistentMap (the wire resource table is
|
||||
# registered only off monolith, VkBufferManager.cpp RegisterWireResourceOps).
|
||||
mgl_itest_join_environment(MGL_ITEST_VULKAN_ARENA_ARM_ENVIRONMENT
|
||||
"MOBILEGL_TRANSPORT=monolith" "MGITEST_PERSISTENT_MAP_ARM=adopted"
|
||||
"MOBILEGL_BACKEND_TYPE=DirectVulkan" "MOBILEGL_ITEST_REQUIRE_GPU=1"
|
||||
${MGL_ITEST_CAPABILITY_ENV} ${MGL_ITEST_VULKAN_ENV})
|
||||
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectGLES.ResourceSubsystemOn."
|
||||
@@ -1565,15 +1514,6 @@ gtest_discover_tests(MobileGLIntegrationTest
|
||||
TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
ENVIRONMENT "${MGL_ITEST_GLES_ARENA_SUBSYSTEM_OFF_ENVIRONMENT}"
|
||||
)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.ArenaArm."
|
||||
TEST_FILTER "LargeArenaAdoptionScenario.TheArenaLandsInTheTierItsLaneDeclares"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES
|
||||
LABELS "integration-gpu\;integration-monolith-control"
|
||||
TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
ENVIRONMENT "${MGL_ITEST_VULKAN_ARENA_ARM_ENVIRONMENT}"
|
||||
)
|
||||
|
||||
# --- G12: the P4a subsystem A/B, and its dependency refusal ---------------------------
|
||||
#
|
||||
@@ -2459,30 +2399,6 @@ if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
mgl_itest_register_split_arms("ClearThenReadPixelsScenario.*" "")
|
||||
mgl_itest_register_split_arms("TriangleScenario.*" "")
|
||||
mgl_itest_register_split_arms("PersistentCoherentMapScenario.*" "")
|
||||
# P11 A2 (MG_Remote/CONTRACT-P11.md §2): the >= 16 MiB arena on all three arms. Its tier case
|
||||
# is declared emulated per entry by SplitLogPaths (T2: every acquisition declines); the mpr and
|
||||
# adopt-tier-refusal cases skip here for want of their lane markers. The Magma arms are the
|
||||
# gated `Arena.` block beside `Pbo.` / `Fence.` below, plus the Buffers lane.
|
||||
mgl_itest_register_split_arms("LargeArenaAdoptionScenario.*" "")
|
||||
# P11 A1 (CONTRACT-P11 §1): the tcp arm with MOBILEGL_IPC_ADOPT_TIER=0. A stream refuses the
|
||||
# tier by name at the client's handshake and runs T2, so the whole scenario is green here and
|
||||
# AStreamSessionRefusesTheAdoptTierOnceByName reads exactly one refusal line. TCP ONLY by
|
||||
# construction: over shared segments (split, spawn) the same knob dies at the handshake, which
|
||||
# is the unit gate RemoteClientControls.AdoptTier*OverSharedSegments*. The `.AdoptTier0.` tail is
|
||||
# what keeps these names out of spawn_lane_parity.py's case set (see MAGMA_TCP_ONLY there).
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectGLES.Tcp.AdoptTier0."
|
||||
TEST_LIST "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}"
|
||||
TEST_FILTER "LargeArenaAdoptionScenario.*"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES
|
||||
LABELS "integration-gpu\;integration-tcp"
|
||||
TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
ENVIRONMENT "${MGL_ITEST_GLES_TCP_ENVIRONMENT}\;MOBILEGL_IPC_ADOPT_TIER=0\;MGITEST_ADOPT_TIER_REFUSAL=T0"
|
||||
FIXTURES_REQUIRED mobilegl-tcp RESOURCE_LOCK mobilegl-tcp
|
||||
)
|
||||
list(APPEND MGL_SPLIT_ARM_TEST_LISTS "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}")
|
||||
math(EXPR MGL_SPLIT_ARM_INDEX "${MGL_SPLIT_ARM_INDEX} + 1")
|
||||
|
||||
# ---- P3b/P4b espryt D1 slice 1: THE ORPHANED XFB CAPTURE TARGET -------------------------
|
||||
#
|
||||
@@ -2531,18 +2447,6 @@ if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
# buffer, depth and packed depth/stencil, and glGetTexImage's windowed twin. The Magma arms of
|
||||
# the same cases are the `Band.` block after the Fm lane below.
|
||||
mgl_itest_register_split_arms("BandedReadbackScenario.*" "")
|
||||
# P9 (W1, MG_Remote/CONTRACT-P9.md §1): the pack-buffer readback crosses as
|
||||
# read_pixels_to_buffer / get_texture_image_to_buffer and is answered by nothing. Six parity
|
||||
# cases (every pack parameter, the map reader, a byte swap, a layered glGetTexImage, an upload
|
||||
# FROM the buffer the read filled, a later write over part of it) and the wire case (no
|
||||
# reply-slot record, one mark per read). The Magma arms are the `Pbo.` block after the Band
|
||||
# block below.
|
||||
mgl_itest_register_split_arms("PackBufferReadbackScenario.*" "")
|
||||
# P10 (A, MG_Remote/CONTRACT-P10.md §1): fence polls answered from kEventFenceSignaled - the
|
||||
# idiom's poll loops end (with and without the flush bit), a signaled fence's polls cross
|
||||
# nothing, and an idle server still reports a fence that finishes. The Magma arms are the
|
||||
# `Fence.` block beside the `Pbo.` block below.
|
||||
mgl_itest_register_split_arms("FencePollScenario.*" "")
|
||||
|
||||
# DepthStencilReadbackMatrixScenario GETS ITS OWN BLOCK, because it needs a variable the
|
||||
# registration macro cannot carry: MOBILEGL_ESPRYT_FORCE_DS_READBACK_EMULATION=1.
|
||||
@@ -2578,62 +2482,6 @@ if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
math(EXPR MGL_SPLIT_ARM_INDEX "${MGL_SPLIT_ARM_INDEX} + 1")
|
||||
endforeach()
|
||||
|
||||
# ---- P10 B: AsyncCompileScenario ON THE SPLIT ARMS, IN ITS THREE PINNED CONFIGURATIONS ----
|
||||
#
|
||||
# ITS OWN BLOCK, for the ForcedDs block's reason: every case needs a whole-process compiler
|
||||
# configuration (MOBILEGL_ASYNC_SHADER_COMPILE, MOBILEGL_ASYNC_OPTIMISTIC_SHADER_STATUS) and
|
||||
# the registration macro hands every arm the shared environment. The three monolith entries
|
||||
# near the top of this file - AsyncOn. (the whole scenario), AsyncOff. (the one case that
|
||||
# has anything to say with compilation inline) and OptimisticShaderStatus. (the Iris shape)
|
||||
# - are mirrored per arm, with one filter change: AsyncOn. leaves out the Iris case, which
|
||||
# skips without MOBILEGL_ASYNC_OPTIMISTIC_SHADER_STATUS and runs in its own entry, so every
|
||||
# entry here runs its case. The AMBIENT configuration is not registered here, for the
|
||||
# monolith block's own reason: it runs whatever the shipped default is, and the day that
|
||||
# flips it would stop covering the asynchronous half with nothing red.
|
||||
#
|
||||
# WHAT THE SPLIT ARM ADDS: the artifacts a worker built are shipped as program archives and
|
||||
# linked and drawn by the SERVER's backend, so a worker-built archive the server mis-binds is
|
||||
# a wrong quadrant here and nowhere in the monolith entries.
|
||||
#
|
||||
# THE SWITCH IS THE CLIENT'S ON ALL THREE ARMS, THE TCP ONE INCLUDED. The pool, its threads,
|
||||
# glMaxShaderCompilerThreadsKHR and GL_MAX_SHADER_COMPILER_THREADS_KHR are frontend state,
|
||||
# and the advertised GL_KHR_parallel_shader_compile is re-derived on the client from the same
|
||||
# switch (CapsMirror.cpp, ReconcileClientCompileExtensions). So unlike an MGITEST_MAGMA_FORCE_*
|
||||
# knob, the tcp fixture server not seeing the variable is exactly what that arm tests. Red
|
||||
# before that fix: AsyncOff.ExtensionStringMatchesTheConfiguration on the Tcp arm, both
|
||||
# backends - the string came from the default (async-on) fixture server.
|
||||
foreach(mglItestAsyncArm IN LISTS MGL_ITEST_MAGMA_ARMS)
|
||||
mgl_itest_magma_arm_shape(${mglItestAsyncArm})
|
||||
string(TOUPPER "${mglItestAsyncArm}" mglItestAsyncArmUpper)
|
||||
foreach(mglItestAsyncShape AsyncOn AsyncOff OptimisticShaderStatus)
|
||||
if(mglItestAsyncShape STREQUAL "AsyncOn")
|
||||
set(mglItestAsyncFilter
|
||||
"AsyncCompileScenario.*-AsyncCompileScenario.IrisShapedTwoPhaseBatchRendersCorrectly")
|
||||
set(mglItestAsyncKnobs "MOBILEGL_ASYNC_SHADER_COMPILE=1")
|
||||
elseif(mglItestAsyncShape STREQUAL "AsyncOff")
|
||||
set(mglItestAsyncFilter "AsyncCompileScenario.ExtensionStringMatchesTheConfiguration")
|
||||
set(mglItestAsyncKnobs "MOBILEGL_ASYNC_SHADER_COMPILE=0")
|
||||
else()
|
||||
set(mglItestAsyncFilter "AsyncCompileScenario.IrisShapedTwoPhaseBatchRendersCorrectly")
|
||||
set(mglItestAsyncKnobs
|
||||
"MOBILEGL_ASYNC_SHADER_COMPILE=1\;MOBILEGL_ASYNC_OPTIMISTIC_SHADER_STATUS=1")
|
||||
endif()
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectGLES.${mglItestAsyncArm}.${mglItestAsyncShape}."
|
||||
TEST_LIST "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}"
|
||||
TEST_FILTER "${mglItestAsyncFilter}"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES
|
||||
LABELS "integration-gpu\;integration-${mglItestArmLower}"
|
||||
TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
ENVIRONMENT "${MGL_ITEST_GLES_${mglItestAsyncArmUpper}_ENVIRONMENT}\;${mglItestAsyncKnobs}"
|
||||
${mglItestArmProperties}
|
||||
)
|
||||
list(APPEND MGL_SPLIT_ARM_TEST_LISTS "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}")
|
||||
math(EXPR MGL_SPLIT_ARM_INDEX "${MGL_SPLIT_ARM_INDEX} + 1")
|
||||
endforeach()
|
||||
endforeach()
|
||||
|
||||
|
||||
# ---- P5e fix1: THE PUSH-MONOLITH ARM, INSIDE THE GATED SET (ID-107) ----------------------
|
||||
#
|
||||
@@ -2830,64 +2678,6 @@ if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
# MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW=1, so it does not green-skip on these arms.
|
||||
mgl_itest_register_split_arms("InvalidImageUnitScenario.*" "")
|
||||
|
||||
# ---- P9 W2: A TEXTURE RE-MINT NEEDS NO BYTE FROM THE CLIENT ------------------------------
|
||||
#
|
||||
# The ROADMAP's `TextureRemintPullScenario`, and it proves the opposite of its name: the
|
||||
# server re-mints from the GPU level and its own staged store, so no pull protocol exists
|
||||
# (notes/p9/W2-REMINT.md). Espryt's three arms here; the Magma arms are laid by hand in the
|
||||
# `DirectVulkan.<arm>.Remint.` block, where the gated Magma flavour lives; both backends' monolith
|
||||
# entries come from the whole-binary discovery.
|
||||
mgl_itest_register_split_arms("TextureRemintPullScenario.*" "")
|
||||
|
||||
# W2-b's control. MGITEST_ESPRYT_FORCE_REMINT_READBACK_FAILURE is read by the SERVER (the
|
||||
# promotion in RequireImageBindableStorageByHandle), so it reaches inproc and spawn - the spawned
|
||||
# server copies this process's environment - and never the tcp lane's shared fixture: split and
|
||||
# spawn only, the MAGMA_SERVER_ENV_KNOB_NO_TCP reason. The entries carry their own label rather
|
||||
# than integration-{split,spawn} so the Espryt spawn-parity sets stay knob-free; integration-gpu
|
||||
# is what runs them in the gate. Only the uploaded-only cases: their levels are covered by the
|
||||
# store, so the fallback must still produce the right texels and the server log must name it.
|
||||
foreach(mglItestArm IN ITEMS Split Spawn)
|
||||
string(TOUPPER "${mglItestArm}" mglItestArmUpper)
|
||||
string(TOLOWER "${mglItestArm}" mglItestArmLower)
|
||||
foreach(remintFallbackCase AnUploadedMutableTextureKeepsItsTexelsAcrossTheImageBind
|
||||
AWidenedFormatsUploadSurvivesTheCarrierRemint
|
||||
AnRgba8SnormUploadSurvivesTheImageBind
|
||||
AnRgba16SnormImmutableUploadSurvivesTheCarrierRemint)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectGLES.${mglItestArm}.RemintFallback."
|
||||
TEST_FILTER "TextureRemintPullScenario.${remintFallbackCase}"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES
|
||||
LABELS "integration-gpu\\;integration-remint-fallback-${mglItestArmLower}"
|
||||
TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
ENVIRONMENT "${MGL_ITEST_GLES_${mglItestArmUpper}_ENVIRONMENT}\;MGITEST_ESPRYT_FORCE_REMINT_READBACK_FAILURE=1\;MOBILEGL_LOG_FILE_PATH=${CMAKE_CURRENT_BINARY_DIR}/p9-remint-fallback-${mglItestArmLower}-${remintFallbackCase}.log")
|
||||
endforeach()
|
||||
endforeach()
|
||||
|
||||
# ---- P11 M: DEV'S TWO GPU-CONTENT SCENARIOS ON THE SPLIT ARMS ----------------------------
|
||||
#
|
||||
# Merged from dev@c60639db with their monolith entries. ImageBindableRemintScenario is the
|
||||
# monolith twin of TextureRemintPullScenario above (568090f0 made Espryt's frontend re-mint
|
||||
# read the GPU level back as the server's already did); PartialUploadOverGpuContentScenario is
|
||||
# 8966d5c2's sub-rect upload over converted/reshaped levels (the server's handle arm cuts the
|
||||
# region from the conversion's buffer too) plus b1d60523's Magma ordering cases, which are
|
||||
# plain GL and run here on Espryt as well. The Magma arms are laid by hand in the
|
||||
# `DirectVulkan.<arm>.GpuContent.` block, where the gated Magma flavour lives.
|
||||
mgl_itest_register_split_arms("ImageBindableRemintScenario.*" "")
|
||||
mgl_itest_register_split_arms("PartialUploadOverGpuContentScenario.*" "")
|
||||
|
||||
# ---- P11 M2: DEV'S TWO MAGMA SCENARIOS ON THE SPLIT ARMS ---------------------------------
|
||||
#
|
||||
# Merged from dev@c14283ee with their monolith entries. Both are plain GL and check pixels on
|
||||
# every backend: OversizedRecordingSplitScenario draws frames whose state spans a command-buffer
|
||||
# split (d20c2d01), DescriptorPoolGrowthScenario draws a 4096-distinct-set frame and gives it
|
||||
# back (c2de6576/53fa16c2). On Espryt neither has anything else to check - the draw budget and
|
||||
# the pool census are Magma's - so every case runs on all three arms. The Magma arms are laid by
|
||||
# hand below (`DirectVulkan.<arm>.Oversized.`, `.SplitRecording64.`, `DirectVulkan.Split.DescPool.`),
|
||||
# where the gated flavour and the per-arm exceptions live.
|
||||
mgl_itest_register_split_arms("OversizedRecordingSplitScenario.*" "")
|
||||
mgl_itest_register_split_arms("DescriptorPoolGrowthScenario.*" "")
|
||||
|
||||
# ---- P5b t2: the transform-feedback spans, the XFB object bind, the patch parameter -------
|
||||
#
|
||||
# MG_Remote/CONTRACT-P5B.md §2 t2. The three P5 lanes above are the REDUCED PATH's targets
|
||||
@@ -2917,24 +2707,6 @@ if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
mgl_itest_register_split_arms("TessellationXfbCaptureScenario.*" "")
|
||||
mgl_itest_register_split_arms("XfbCaptureBufferReuseScenario.*" "")
|
||||
|
||||
# ---- P10 B: THE TWO XFB QUERY TARGETS ON ONE SPAN ---------------------------------------
|
||||
#
|
||||
# XfbPrimitiveQueryScenario asks GL_PRIMITIVES_GENERATED and GL_TRANSFORM_FEEDBACK_PRIMITIVES_
|
||||
# WRITTEN about one vertex-only capture, once with room for every point and once overflowing
|
||||
# (4 generated, 3 written), and reads the captured records back. Under a transport both
|
||||
# answers are query replies from the server and the records a readback of the server's
|
||||
# capture, so a WRITTEN that crossed as the GENERATED count, or a result read before the
|
||||
# span's end record was applied, is a wrong number here. The Magma arms are the
|
||||
# `DirectVulkan.<arm>.XfbQuery.` block after the Remint block.
|
||||
#
|
||||
# PrimitivesGeneratedNoXfbScenario IS NOT REGISTERED ON THESE ARMS, by name: every case in it
|
||||
# skips in SetUp on DirectGLES ("the stream-query defect and its reroute are DirectVulkan's"),
|
||||
# because ES has no GENERATED counter for a draw with no capture span and Espryt's CPU
|
||||
# accounting is a different mechanism. Three arms of guaranteed skips would be a green that
|
||||
# ran nothing. Its Magma arms are the `PrimGen.` / `PrimGenReroute.` entries in the same
|
||||
# block as the XfbQuery. ones.
|
||||
mgl_itest_register_split_arms("XfbPrimitiveQueryScenario.*" "")
|
||||
|
||||
# ---- P5e package vi (MG_Remote/CONTRACT-P5E.md §5.1, ID-82 / ruling 2) --------------------
|
||||
#
|
||||
# Client-memory vertices and indices now cross as owned ordinary buffers.
|
||||
@@ -3785,16 +3557,6 @@ endif()
|
||||
# Fatal{ReplyTooLarge, "ReadPixels 256x512 0x1908/0x1406 2097152 > 2097136"}. One entry per case
|
||||
# for a private log each - two processes append to it on the spawn arm.
|
||||
if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
# P11: LargeArenaAdoptionScenario's cases that run on every Magma arm - the five behavioural
|
||||
# cases and the tier assertion (the mpr and adopt-tier-refusal cases need lane markers of their
|
||||
# own). The `Arena.` block below and the Buffers lane both walk it.
|
||||
set(MGL_ITEST_ARENA_CASES
|
||||
SubDataAfterAnInFlightDrawReachesTheNextDraw
|
||||
RespecifiedVertexArenaKeepsVaoBindings
|
||||
RespecifiedIndexArenaKeepsVaoBinding
|
||||
ReadbackSeesTheLatestCpuWrite
|
||||
GpuWriteIntoTheArenaIsReadBack
|
||||
TheArenaLandsInTheTierItsLaneDeclares)
|
||||
set(MGL_ITEST_MAGMA_BAND_FLAVOUR_ENV
|
||||
"MOBILEGL_BACKEND_TYPE=DirectVulkan"
|
||||
"MOBILEGL_IPC_ROLE_SPLIT_STATE=1" "MOBILEGL_IPC_STRICT_ERRORS=1" "MOBILEGL_IPC_RUN_AHEAD=1"
|
||||
@@ -3819,264 +3581,6 @@ if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaBandEnvironment}\;MOBILEGL_LOG_FILE_PATH=${CMAKE_CURRENT_BINARY_DIR}/g5-band${mglItestArmLogTag}-${bandCase}.log")
|
||||
endforeach()
|
||||
# P9 (W1): the pack-buffer readback on Magma. The server half is backend-neutral - the
|
||||
# reply form's read, then the applier's buffer-write gate (WriteWireBuffer here) - so the
|
||||
# same seven cases, same flavour.
|
||||
foreach(pboCase ReadPixelsIntoAPackBufferMatchesClientMemoryUnderEveryPackState
|
||||
MapBufferRangeAfterAPackBufferReadSeesThePixels
|
||||
SwapBytesIntoAPackBufferMatchesClientMemory
|
||||
GetTexImageIntoAPackBufferMatchesClientMemory
|
||||
APackBufferReadFeedsAnUploadFromTheSameBuffer
|
||||
ALaterBufferSubDataWinsOverThePackReadWhereTheyOverlap
|
||||
APackBufferReadPostsNoReplyAndMarksTheBuffer)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.${mglItestArm}.Pbo."
|
||||
TEST_FILTER "PackBufferReadbackScenario.${pboCase}"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES LABELS "${mglItestMagmaLabels}" TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaBandEnvironment}\;MOBILEGL_LOG_FILE_PATH=${CMAKE_CURRENT_BINARY_DIR}/p9-pbo${mglItestArmLogTag}-${pboCase}.log")
|
||||
endforeach()
|
||||
# P10 (A): the fence polls on Magma. The server half is backend-neutral (the backend
|
||||
# table's FenceSync / GetSyncStatus / ClientWaitSync), so the same three cases.
|
||||
foreach(fenceCase ZeroTimeoutPollLoopsEndInBoundedTime
|
||||
PollsOfASignaledFenceCrossNothing
|
||||
AFenceThatFinishesWhileTheClientOnlyPollsIsReported
|
||||
PacedFrameFenceWaitsBench)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.${mglItestArm}.Fence."
|
||||
TEST_FILTER "FencePollScenario.${fenceCase}"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES LABELS "${mglItestMagmaLabels}" TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaBandEnvironment}\;MOBILEGL_LOG_FILE_PATH=${CMAKE_CURRENT_BINARY_DIR}/p10-fence${mglItestArmLogTag}-${fenceCase}.log")
|
||||
endforeach()
|
||||
# P11 A2 (MG_Remote/CONTRACT-P11.md §2): the >= 16 MiB arena on Magma's three arms, in the
|
||||
# same flavour. Declared emulated: every split acquisition declines (the wire resource
|
||||
# table's MapPersistent returns null, VkBufferManager.cpp), so the tier case asserts T2
|
||||
# on every arm; DirectVulkan.ArenaArm. is its monolith (adopted) half.
|
||||
foreach(arenaCase IN LISTS MGL_ITEST_ARENA_CASES)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.${mglItestArm}.Arena."
|
||||
TEST_FILTER "LargeArenaAdoptionScenario.${arenaCase}"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES LABELS "${mglItestMagmaLabels}" TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaBandEnvironment}\;MGITEST_PERSISTENT_MAP_ARM=emulated\;MOBILEGL_LOG_FILE_PATH=${CMAKE_CURRENT_BINARY_DIR}/p11-arena${mglItestArmLogTag}-${arenaCase}.log")
|
||||
endforeach()
|
||||
# P11 A1 (CONTRACT-P11 §1): the tcp arm with MOBILEGL_IPC_ADOPT_TIER=0 - refused by name at
|
||||
# the client's handshake, T2, the scenario green. TCP ONLY by construction (over shared
|
||||
# segments the knob dies at the handshake); spawn_lane_parity.py names the tail in
|
||||
# MAGMA_TCP_ONLY.
|
||||
if(mglItestArm STREQUAL "Tcp")
|
||||
foreach(arenaCase IN LISTS MGL_ITEST_ARENA_CASES ITEMS AStreamSessionRefusesTheAdoptTierOnceByName)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.Tcp.AdoptTier0."
|
||||
TEST_FILTER "LargeArenaAdoptionScenario.${arenaCase}"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES LABELS "${mglItestMagmaLabels}" TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaBandEnvironment}\;MOBILEGL_IPC_ADOPT_TIER=0\;MGITEST_ADOPT_TIER_REFUSAL=T0\;MGITEST_PERSISTENT_MAP_ARM=emulated\;MOBILEGL_LOG_FILE_PATH=${CMAKE_CURRENT_BINARY_DIR}/p11-adopt-tier0-tcp-${arenaCase}.log")
|
||||
endforeach()
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
# P9 W2: THE TEXTURE RE-MINT ON MAGMA, all three arms, GATED. A storage-usage upgrade recreates
|
||||
# the VkImage and copies the old one into it GPU to GPU (PreserveTextureContentsOnRecreate), so
|
||||
# no byte comes from the client here either (notes/p9/W2-REMINT.md). The gated band flavour
|
||||
# (role-split state, strict errors, run-ahead), one entry per case for a private log each.
|
||||
if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
foreach(mglItestArm IN LISTS MGL_ITEST_MAGMA_ARMS)
|
||||
mgl_itest_magma_arm_shape(${mglItestArm})
|
||||
mgl_itest_join_environment(mglItestMagmaRemintEnvironment
|
||||
${MGL_ITEST_MAGMA_BAND_FLAVOUR_ENV} ${mglItestArmTransportEnv})
|
||||
foreach(remintCase AnUploadedMutableTextureKeepsItsTexelsAcrossTheImageBind
|
||||
AGpuClearAfterTheUploadSurvivesTheImageBind
|
||||
AnImmutableTexturesGpuClearSurvivesTheImageBind
|
||||
ANullDefinedTextureWrittenOnlyByTheGpuSurvivesTheImageBind
|
||||
APendingPartialUploadMergesOverGpuWrittenTexels
|
||||
AGeneratedMipLevelSurvivesTheImageBind
|
||||
AGpuClearedMipLevelSurvivesTheImageBind
|
||||
ALevelDefinedWithoutDataAfterTheLastSyncDoesNotEndTheSession
|
||||
ALevelRedefinedLargerWithoutDataAfterTheLastSyncDoesNotEndTheSession
|
||||
APartialUploadIntoALevelDefinedAfterTheLastSyncReachesTheImage
|
||||
AWidenedFormatsGpuClearSurvivesTheCarrierRemint
|
||||
AWidenedFormatsUploadSurvivesTheCarrierRemint
|
||||
AnRgba8SnormUploadSurvivesTheImageBind
|
||||
AnRgba16SnormImmutableUploadSurvivesTheCarrierRemint)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.${mglItestArm}.Remint."
|
||||
TEST_FILTER "TextureRemintPullScenario.${remintCase}"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES LABELS "${mglItestMagmaLabels}" TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaRemintEnvironment}\;MOBILEGL_LOG_FILE_PATH=${CMAKE_CURRENT_BINARY_DIR}/p9-remint${mglItestArmLogTag}-${remintCase}.log")
|
||||
endforeach()
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
# P11 M: DEV'S TWO GPU-CONTENT SCENARIOS ON MAGMA, all three arms, GATED, in the band flavour -
|
||||
# ImageBindableRemintScenario (Magma is its control backend: a storage upgrade copies image to
|
||||
# image) and PartialUploadOverGpuContentScenario (8966d5c2's RGB->RGBA region cut and b1d60523's
|
||||
# upload-after-clear/draw ordering, both of which run in the server's renderer on these arms).
|
||||
# One entry per scenario and arm; every entry gets a private log through MGL_SPLIT_ARM_TEST_LISTS.
|
||||
if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
foreach(mglItestArm IN LISTS MGL_ITEST_MAGMA_ARMS)
|
||||
mgl_itest_magma_arm_shape(${mglItestArm})
|
||||
mgl_itest_join_environment(mglItestMagmaGpuContentEnvironment
|
||||
${MGL_ITEST_MAGMA_BAND_FLAVOUR_ENV} ${mglItestArmTransportEnv})
|
||||
foreach(mglItestGpuContentScenario ImageBindableRemintScenario PartialUploadOverGpuContentScenario)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.${mglItestArm}.GpuContent."
|
||||
TEST_LIST "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}"
|
||||
TEST_FILTER "${mglItestGpuContentScenario}.*"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES LABELS "${mglItestMagmaLabels}" TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaGpuContentEnvironment}")
|
||||
list(APPEND MGL_SPLIT_ARM_TEST_LISTS "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}")
|
||||
math(EXPR MGL_SPLIT_ARM_INDEX "${MGL_SPLIT_ARM_INDEX} + 1")
|
||||
endforeach()
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
# P11 M2: DEV'S TWO MAGMA SCENARIOS ON MAGMA'S ARMS, GATED, in the band flavour. Every entry gets a
|
||||
# private log through MGL_SPLIT_ARM_TEST_LISTS.
|
||||
#
|
||||
# Oversized. OversizedRecordingSplitScenario under the default draw budget (16384), all three
|
||||
# arms: every case's pixels, unsplit - dev's control. Its arming is not checked here (no
|
||||
# budget pinned).
|
||||
# SplitRecording64. The same cases with MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER=64, so every
|
||||
# case splits (d20c2d01's SplitOversizedRecording, which runs ahead of the wire arm's draw and
|
||||
# dispatch too) and asserts the renderer's latched MGLOG_I. SPLIT AND SPAWN ONLY, one entry per
|
||||
# case. The budget and the log line are the SERVER renderer's - the apply thread inproc, the
|
||||
# spawned server (which copies this entry's environment, log base included) under spawn - and
|
||||
# the scenario reads both role logs of its base (PipeStatsWindow). The tcp arm's server is
|
||||
# the lane fixture, which no per-entry property reaches: a tcp copy would run the default
|
||||
# budget under a name claiming 64 and its arming would find nothing (spawn_lane_parity.py,
|
||||
# MAGMA_SERVER_ENV_KNOB_NO_TCP). The line is latched once per process, hence one per case.
|
||||
# DescPool. DescriptorPoolGrowthScenario, SPLIT ONLY. Both cases read the pool census
|
||||
# (DirectVulkan::GetDescriptorPoolCensus), which is in-process: inproc it is taken on the
|
||||
# apply thread (the test probe, between drain batches); on spawn and tcp the pools live in the
|
||||
# server process and the census answers unavailable, so a copy there would check pixels
|
||||
# under a name claiming the pools (spawn_lane_parity.py, MAGMA_INPROC_ONLY). Those pixels run
|
||||
# on every arm in the Espryt entries above and in the Magma informational and full-suite tiers.
|
||||
if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
set(MGL_ITEST_OVERSIZED_CASES
|
||||
EveryDrawOfTheFrameLandsAcrossCommandBufferSplits
|
||||
ADepthOccluderDrawnBeforeTheSplitHidesADrawAfterIt
|
||||
AStencilMarkMadeBeforeTheSplitGatesADrawAfterIt
|
||||
BlendingAccumulatesOntoPixelsWrittenBeforeTheSplit
|
||||
AMultisampleTargetKeepsItsSamplesAcrossTheSplit
|
||||
OcclusionQueriesOpenAcrossTheSplitCountBothSides
|
||||
APrimitivesGeneratedQueryOpenAcrossTheSplitCountsBothSides
|
||||
ATransformFeedbackCaptureActiveAcrossTheSplitAppendsEveryDraw)
|
||||
foreach(mglItestArm IN LISTS MGL_ITEST_MAGMA_ARMS)
|
||||
mgl_itest_magma_arm_shape(${mglItestArm})
|
||||
mgl_itest_join_environment(mglItestMagmaM2Environment
|
||||
${MGL_ITEST_MAGMA_BAND_FLAVOUR_ENV} ${mglItestArmTransportEnv})
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.${mglItestArm}.Oversized."
|
||||
TEST_LIST "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}"
|
||||
TEST_FILTER "OversizedRecordingSplitScenario.*"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES LABELS "${mglItestMagmaLabels}" TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaM2Environment}")
|
||||
list(APPEND MGL_SPLIT_ARM_TEST_LISTS "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}")
|
||||
math(EXPR MGL_SPLIT_ARM_INDEX "${MGL_SPLIT_ARM_INDEX} + 1")
|
||||
if(NOT mglItestArm STREQUAL "Tcp")
|
||||
foreach(mglItestOversizedCase IN LISTS MGL_ITEST_OVERSIZED_CASES)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.${mglItestArm}.SplitRecording64."
|
||||
TEST_LIST "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}"
|
||||
TEST_FILTER "OversizedRecordingSplitScenario.${mglItestOversizedCase}"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES LABELS "${mglItestMagmaLabels}" TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaM2Environment}\;MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER=64")
|
||||
list(APPEND MGL_SPLIT_ARM_TEST_LISTS "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}")
|
||||
math(EXPR MGL_SPLIT_ARM_INDEX "${MGL_SPLIT_ARM_INDEX} + 1")
|
||||
endforeach()
|
||||
endif()
|
||||
if(mglItestArm STREQUAL "Split")
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.Split.DescPool."
|
||||
TEST_LIST "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}"
|
||||
TEST_FILTER "DescriptorPoolGrowthScenario.*"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES LABELS "${mglItestMagmaLabels}" TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaM2Environment}")
|
||||
list(APPEND MGL_SPLIT_ARM_TEST_LISTS "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}")
|
||||
math(EXPR MGL_SPLIT_ARM_INDEX "${MGL_SPLIT_ARM_INDEX} + 1")
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
# P10 B: ASYNC COMPILATION, THE XFB QUERY PAIR AND GL_PRIMITIVES_GENERATED ON MAGMA, all three
|
||||
# arms, GATED, in the band flavour (role-split state, strict errors, run-ahead). The DirectGLES
|
||||
# half of the first two is registered beside the other Espryt arms; the third is Magma's alone.
|
||||
# One registration per arm and shape, and every entry gets a private log through
|
||||
# MGL_SPLIT_ARM_TEST_LISTS (no name there matches a lane marker SplitLogPaths arms).
|
||||
#
|
||||
# AsyncOn. / AsyncOff. / OptimisticShaderStatus. AsyncCompileScenario, the monolith entries'
|
||||
# three configurations (AsyncOn. without the Iris case, which has its own entry), for the
|
||||
# reason the Espryt block states - including why the tcp arm keeps all three: the switch is
|
||||
# the client's, and so is the extension since this package.
|
||||
# XfbQuery. XfbPrimitiveQueryScenario, both cases.
|
||||
# PrimGen. PrimitivesGeneratedNoXfbScenario under the bring-up probe's Auto verdict, minus the
|
||||
# arming case, which skips unless the reroute is pinned (a guaranteed skip is not coverage).
|
||||
# PrimGenReroute. The same scenario with MOBILEGL_MAGMA_PRIMGEN_QUERY_REROUTE=1, arming case
|
||||
# included. SPLIT AND SPAWN ONLY: the renderer reads the knob on the SERVER, and the tcp
|
||||
# arm's server is the lane fixture, which no per-entry property reaches - a tcp copy would
|
||||
# run the Auto verdict under a name claiming the pin (spawn_lane_parity.py,
|
||||
# MAGMA_SERVER_ENV_KNOB_NO_TCP). One entry per case, as ctest runs every discovered case:
|
||||
# the arming line is LATCHED once per process, so a process that ran an earlier rerouted
|
||||
# case first reads nothing new (measured, running the scenario as one process).
|
||||
if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
foreach(mglItestArm IN LISTS MGL_ITEST_MAGMA_ARMS)
|
||||
mgl_itest_magma_arm_shape(${mglItestArm})
|
||||
mgl_itest_join_environment(mglItestMagmaP10bEnvironment
|
||||
${MGL_ITEST_MAGMA_BAND_FLAVOUR_ENV} ${mglItestArmTransportEnv})
|
||||
set(mglItestP10bShapes AsyncOn AsyncOff OptimisticShaderStatus XfbQuery PrimGen)
|
||||
if(NOT mglItestArm STREQUAL "Tcp")
|
||||
list(APPEND mglItestP10bShapes PrimGenReroute)
|
||||
endif()
|
||||
foreach(mglItestP10bShape IN LISTS mglItestP10bShapes)
|
||||
set(mglItestP10bKnobs "")
|
||||
if(mglItestP10bShape STREQUAL "AsyncOn")
|
||||
set(mglItestP10bFilter
|
||||
"AsyncCompileScenario.*-AsyncCompileScenario.IrisShapedTwoPhaseBatchRendersCorrectly")
|
||||
set(mglItestP10bKnobs "\;MOBILEGL_ASYNC_SHADER_COMPILE=1")
|
||||
elseif(mglItestP10bShape STREQUAL "AsyncOff")
|
||||
set(mglItestP10bFilter "AsyncCompileScenario.ExtensionStringMatchesTheConfiguration")
|
||||
set(mglItestP10bKnobs "\;MOBILEGL_ASYNC_SHADER_COMPILE=0")
|
||||
elseif(mglItestP10bShape STREQUAL "OptimisticShaderStatus")
|
||||
set(mglItestP10bFilter "AsyncCompileScenario.IrisShapedTwoPhaseBatchRendersCorrectly")
|
||||
set(mglItestP10bKnobs
|
||||
"\;MOBILEGL_ASYNC_SHADER_COMPILE=1\;MOBILEGL_ASYNC_OPTIMISTIC_SHADER_STATUS=1")
|
||||
elseif(mglItestP10bShape STREQUAL "XfbQuery")
|
||||
set(mglItestP10bFilter "XfbPrimitiveQueryScenario.*")
|
||||
elseif(mglItestP10bShape STREQUAL "PrimGen")
|
||||
set(mglItestP10bFilter
|
||||
"PrimitivesGeneratedNoXfbScenario.*-PrimitivesGeneratedNoXfbScenario.TheRerouteIsActuallyArmedWhenTheEnvironmentPinsItOn")
|
||||
else()
|
||||
set(mglItestP10bFilter "PrimitivesGeneratedNoXfbScenario.*")
|
||||
set(mglItestP10bKnobs "\;MOBILEGL_MAGMA_PRIMGEN_QUERY_REROUTE=1")
|
||||
endif()
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.${mglItestArm}.${mglItestP10bShape}."
|
||||
TEST_LIST "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}"
|
||||
TEST_FILTER "${mglItestP10bFilter}"
|
||||
DISCOVERY_TIMEOUT 30
|
||||
PROPERTIES LABELS "${mglItestMagmaLabels}" TIMEOUT ${MGL_ITEST_TIMEOUT}
|
||||
${mglItestArmProperties}
|
||||
ENVIRONMENT "${mglItestMagmaP10bEnvironment}${mglItestP10bKnobs}")
|
||||
list(APPEND MGL_SPLIT_ARM_TEST_LISTS "MGL_SPLIT_ARM_TESTS_${MGL_SPLIT_ARM_INDEX}")
|
||||
math(EXPR MGL_SPLIT_ARM_INDEX "${MGL_SPLIT_ARM_INDEX} + 1")
|
||||
endforeach()
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
@@ -4115,15 +3619,7 @@ if (MOBILEGL_BUILD_DISAGGREGATED)
|
||||
CrossFrameBufferScenario.IndexOrphanAndReupload
|
||||
PersistentCoherentMapScenario.TwoWritesThroughTheCoherentPointerEachReachTheirOwnDraw
|
||||
PersistentCoherentMapScenario.AWriteAfterAFrameBoundaryReachesTheNextFramesDraw
|
||||
StorageBufferRegrowScenario.AGrownStoreIsVisibleThroughItsExistingIndexedBinding
|
||||
# P11 A2: the >= 16 MiB arena, the flavour's MGITEST_PERSISTENT_MAP_ARM=emulated
|
||||
# asserted by its tier case (MG_Remote/CONTRACT-P11.md §2).
|
||||
LargeArenaAdoptionScenario.SubDataAfterAnInFlightDrawReachesTheNextDraw
|
||||
LargeArenaAdoptionScenario.RespecifiedVertexArenaKeepsVaoBindings
|
||||
LargeArenaAdoptionScenario.RespecifiedIndexArenaKeepsVaoBinding
|
||||
LargeArenaAdoptionScenario.ReadbackSeesTheLatestCpuWrite
|
||||
LargeArenaAdoptionScenario.GpuWriteIntoTheArenaIsReadBack
|
||||
LargeArenaAdoptionScenario.TheArenaLandsInTheTierItsLaneDeclares)
|
||||
StorageBufferRegrowScenario.AGrownStoreIsVisibleThroughItsExistingIndexedBinding)
|
||||
gtest_discover_tests(MobileGLIntegrationTest
|
||||
TEST_PREFIX "DirectVulkan.${mglItestArm}.Buffers."
|
||||
TEST_FILTER "${bufferCase}"
|
||||
|
||||
@@ -29,11 +29,9 @@ namespace MGITest {
|
||||
};
|
||||
bool PeekPipeTextureResourceRecord(unsigned glTextureName, PipeTextureResourceRecordPeek* out);
|
||||
|
||||
// The process-wide texture re-mint count (PipeStats "tex-remint-pulls", `trp=` on the
|
||||
// The process-wide texture-remint pull count (PipeStats "tex-remint-pulls", `trp=` on the
|
||||
// summary line; ROADMAP open question 2). Arms the PipeStats counters for this process on
|
||||
// the first call, which is what lets a case read the number without a stats-enabled lane.
|
||||
// Process-wide means it sees the SERVER's count only where the server is this process:
|
||||
// monolith and inproc, never spawn or tcp.
|
||||
bool PeekPipeStatsTextureRemintPulls(unsigned long long* out);
|
||||
// Espryt's count of texture uploads it actually issued (PipeStats "tex-upload-emissions"):
|
||||
// what tells a CONSUMED pending upload apart from a DROPPED one, since the record's set is
|
||||
|
||||
@@ -25,9 +25,6 @@ foreach(listName IN ITEMS @MGL_SPLIT_ARM_TEST_LISTS@)
|
||||
elseif(entry MATCHES "PersistentCoherentMapScenario.TheMapLandsInTheArmItsLaneDeclares$")
|
||||
set_tests_properties("${entry}" PROPERTIES ENVIRONMENT
|
||||
"MGITEST_PMAP_LANE=1;MGITEST_PERSISTENT_MAP_ARM=emulated;MOBILEGL_PIPE_STATS=1;MOBILEGL_PIPE_STATS_PERIOD=1")
|
||||
elseif(entry MATCHES "LargeArenaAdoptionScenario.TheArenaLandsInTheTierItsLaneDeclares$")
|
||||
# P11 A2: every split arm runs T2, so the arena is declared emulated.
|
||||
set_tests_properties("${entry}" PROPERTIES ENVIRONMENT "MGITEST_PERSISTENT_MAP_ARM=emulated")
|
||||
elseif(entry MATCHES "CtWireScenario\\.")
|
||||
set_tests_properties("${entry}" PROPERTIES ENVIRONMENT "MOBILEGL_TEST_SERVER_COUNTERS=1")
|
||||
endif()
|
||||
|
||||
@@ -20,7 +20,6 @@
|
||||
#include <MG_Remote/Client/CapsMirror.h>
|
||||
#include <MG_Remote/Client/ClientSession.h>
|
||||
#include <MG_Remote/Client/EmitTables.h>
|
||||
#include <MG_Remote/Client/GpuWritePending.h>
|
||||
#include <MG_Remote/Server/ServerLoop.h>
|
||||
#include <chrono>
|
||||
#include <atomic>
|
||||
@@ -165,14 +164,6 @@ namespace MGITest {
|
||||
state.cmdWrapPads = encoder.CmdWrapPads();
|
||||
state.cmdBytesWritten = encoder.CmdBytesWritten();
|
||||
state.stageReclaimWaits = encoder.StageReclaimWaits();
|
||||
state.replyPostings = session->ReplyPostings();
|
||||
state.packBufferReadbackMarks = MobileGL::MG_Remote::Client::ProducerMarkCount(
|
||||
MobileGL::MG_Remote::Client::GpuWriteProducer::ReadPixelsPackBuffer);
|
||||
const auto fences = MobileGL::MG_Remote::Client::ReadFencePollCounters();
|
||||
state.fenceLocalAnswers = fences.LocalAnswers;
|
||||
state.fenceEscalations = fences.Escalations;
|
||||
state.fenceRoundTrips = fences.RoundTrips;
|
||||
state.fenceServerReports = fences.ServerReports;
|
||||
}
|
||||
#endif
|
||||
return state;
|
||||
|
||||
@@ -119,26 +119,6 @@ namespace MGITest {
|
||||
unsigned long long cmdWrapPads = 0;
|
||||
unsigned long long cmdBytesWritten = 0;
|
||||
unsigned long long stageReclaimWaits = 0;
|
||||
|
||||
// ---- P9 (W1, CONTRACT-P9.md §1): the pack-buffer readback's two proofs -------------
|
||||
//
|
||||
// replyPostings: records this client published on a row that carries a reply slot
|
||||
// (ClientSession::ReplyPostings, always counted - it is the create window's clock, not a
|
||||
// stats counter). A read into a pack buffer that moves it went through the reply form.
|
||||
// packBufferReadbackMarks: GpuWritePending's row-4 producer count - the buffers a pack
|
||||
// read marked GPU-written. The reply form marks nothing, so the pair tells the two forms
|
||||
// apart from both sides.
|
||||
unsigned long long replyPostings = 0;
|
||||
unsigned long long packBufferReadbackMarks = 0;
|
||||
|
||||
// ---- P10 (CONTRACT-P10.md §1): what the fence polls cost ----------------------------
|
||||
// EmitTables.h FencePollCounters, verbatim: polls answered with no record, zero-timeout
|
||||
// polls escalated to a round trip, every fence answer that crossed, and the server's
|
||||
// kEventFenceSignaled reports consumed.
|
||||
unsigned long long fenceLocalAnswers = 0;
|
||||
unsigned long long fenceEscalations = 0;
|
||||
unsigned long long fenceRoundTrips = 0;
|
||||
unsigned long long fenceServerReports = 0;
|
||||
};
|
||||
|
||||
SplitRuntimeState PeekSplitRuntime();
|
||||
|
||||
@@ -257,7 +257,7 @@ namespace {
|
||||
// RESIDENT, residency comes only from AdoptPersistentMap, and every persistent-map
|
||||
// acquisition declines under split by R-6 (PipeApply.cpp's MGPipeApplyMapPersistent:
|
||||
// "A SPLIT BUILD RUNS AT TIER T2 AND DECLINES EVERY ACQUISITION, ALWAYS"; T0/T1 are
|
||||
// unimplemented, refused by name at the handshake since P11 A1). So the capability is wired
|
||||
// P11's and AdoptTierIsEmulate is a named Fatal for them). So the capability is wired
|
||||
// AHEAD of its consumer on purpose, and `rsd=` on the PipeStats line is the counter that
|
||||
// will show the records the day P11 lands a tier that adopts. See notes/p7/magma-c.md.
|
||||
TEST_F(CtWireScenario, TheServerPublishesTheResidentSubDataCapabilityFromItsOwnTable) {
|
||||
|
||||
@@ -1,378 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/DescriptorPoolGrowthScenario.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
//
|
||||
// Scenario - ONE FRAME THAT NEEDS THOUSANDS OF DISTINCT DESCRIPTOR SETS.
|
||||
//
|
||||
// DirectVulkan takes a draw's descriptor set from a per-frame-slot cache and adds a pool to the
|
||||
// slot when the cache runs dry (UniformManager). Two things went wrong with a burst like
|
||||
// Minecraft rd12's loading frame (15,016 sets in one slot):
|
||||
// - Growth was linear. The next pool was sized at twice the slot's FIRST pool of the flavour,
|
||||
// which is always its oldest and smallest, so every grown pool came out the same size: the
|
||||
// loading slot ended with 59 pools of 256 sets.
|
||||
// - The burst was kept forever. The cache only rewinds, so the slot held all 15k sets (and the
|
||||
// pools behind them) for the life of the process, while steady frames used a few dozen.
|
||||
// Now each pool doubles the slot's largest one (capped), and a slot whose pools stay under a
|
||||
// quarter full for MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES frames is handed back whole and re-grows.
|
||||
//
|
||||
// Each of kDraws draws paints its own pixel of a 64x64 target and samples one of kTextures
|
||||
// textures, a different one from each of the previous draws' so neither the renderer's per-draw
|
||||
// descriptor reuse memo (four entries) nor its dynamic-offset-only rebind can let two draws share
|
||||
// a set: one frame needs kDraws sets. Every pixel must hold its own draw's texture colour, on both
|
||||
// backends. On DirectVulkan the cases also read the pools through GetDescriptorPoolCensus - which
|
||||
// only the desktop build can reach, since the integration harness links the static library there
|
||||
// and the hidden-visibility shipping library on Android.
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "../Harness/HeadlessGL.h"
|
||||
#include "../Harness/ScenarioFixture.h"
|
||||
#include "../Harness/SplitRuntimePeek.h"
|
||||
|
||||
#if !defined(__ANDROID__)
|
||||
#include <MG_Backend/DirectVulkan/DescriptorPoolCensus.h>
|
||||
#endif
|
||||
|
||||
#ifdef GLAPI
|
||||
#undef GLAPI
|
||||
#endif
|
||||
#define GL_GLEXT_PROTOTYPES
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glcorearb.h>
|
||||
#undef GL_GLEXT_PROTOTYPES
|
||||
|
||||
namespace MGITest {
|
||||
namespace {
|
||||
|
||||
constexpr int kSide = 64;
|
||||
constexpr int kDraws = kSide * kSide; // well under the 16384-draw command-buffer split budget
|
||||
// More than the descriptor reuse memo's four entries, so the texture a draw samples is never
|
||||
// one of the last four draws'.
|
||||
constexpr int kTextures = 8;
|
||||
// The base pool size (VulkanRenderer's kDescriptorSetsPerFrame) and the growth cap
|
||||
// (UniformManager::kMaxDescriptorPoolSets).
|
||||
constexpr std::uint64_t kBaseSets = 64;
|
||||
constexpr std::uint64_t kMaxPoolSets = 4096;
|
||||
|
||||
constexpr const char* kVS = R"(#version 330 core
|
||||
in vec2 aPos;
|
||||
uniform int uIndex;
|
||||
void main() {
|
||||
vec2 cell = vec2(float(uIndex % 64), float(uIndex / 64));
|
||||
gl_Position = vec4((cell + aPos) / 32.0 - 1.0, 0.0, 1.0);
|
||||
}
|
||||
)";
|
||||
constexpr const char* kFS = R"(#version 330 core
|
||||
uniform sampler2D uTex;
|
||||
out vec4 o_color;
|
||||
void main() { o_color = texture(uTex, vec2(0.5)); }
|
||||
)";
|
||||
|
||||
// Texture t's single texel; every channel differs between any two textures.
|
||||
Rgba8 TextureColor(int t) {
|
||||
return Rgba8{static_cast<std::uint8_t>(16 + 32 * t), static_cast<std::uint8_t>(240 - 32 * t),
|
||||
static_cast<std::uint8_t>(8 + 29 * t), 255};
|
||||
}
|
||||
|
||||
std::string Describe(const Rgba8& c) {
|
||||
std::ostringstream os;
|
||||
os << "rgba(" << static_cast<int>(c.r) << ", " << static_cast<int>(c.g) << ", " << static_cast<int>(c.b)
|
||||
<< ", " << static_cast<int>(c.a) << ")";
|
||||
return os.str();
|
||||
}
|
||||
|
||||
unsigned long EnvUnsigned(const char* name, unsigned long fallback) {
|
||||
const char* value = std::getenv(name);
|
||||
if (value == nullptr || *value == '\0') return fallback;
|
||||
char* end = nullptr;
|
||||
const unsigned long parsed = std::strtoul(value, &end, 10);
|
||||
return (end != nullptr && *end == '\0') ? parsed : fallback;
|
||||
}
|
||||
|
||||
// P11 M2: HOW MANY OF THE BURST'S SETS ONE FRAME SLOT HOLDS AT ONCE. All kDraws of them on
|
||||
// the monolith arm. Under a split transport the server draws through the WIRE arm, which
|
||||
// rewinds a slot's set cursors every UniformManager::kWireDescriptorSetBudget (2048) sets once
|
||||
// it has proved the GPU done with them (VulkanRenderer::RewindWireDescriptorSetsIfDue), so its
|
||||
// cache holds the burst 2048 sets at a time: the burst still needs a set per draw, grows the
|
||||
// slot geometrically to that and is given back by the same trim, only the census counts the
|
||||
// sets held rather than the draws. (The census itself is in-process - inproc it is read on the
|
||||
// server's apply thread; spawn and tcp answer unavailable - see GetDescriptorPoolCensus.)
|
||||
constexpr std::uint64_t kWireDescriptorSetBudget = 2048;
|
||||
std::uint64_t BurstSetsHeldAtOnce() {
|
||||
const std::uint64_t draws = static_cast<std::uint64_t>(kDraws);
|
||||
return PeekSplitRuntime().transportResolved ? std::min(draws, kWireDescriptorSetBudget) : draws;
|
||||
}
|
||||
|
||||
// Pools a geometric policy adds for n sets from an empty flavour: 64, 128, ... up to the cap,
|
||||
// then one per cap. The old first-pool rule needed n/128 or n/256 of them.
|
||||
std::uint64_t GeometricPoolBound(std::uint64_t n) {
|
||||
std::uint64_t pools = 0, capacity = 0, size = kBaseSets;
|
||||
while (capacity < n) {
|
||||
capacity += size;
|
||||
++pools;
|
||||
size = std::min(size * 2, kMaxPoolSets);
|
||||
}
|
||||
return pools;
|
||||
}
|
||||
|
||||
struct Census {
|
||||
bool available = false;
|
||||
std::uint64_t pools = 0;
|
||||
std::uint64_t capacitySets = 0;
|
||||
std::uint64_t cachedSets = 0;
|
||||
std::uint64_t slotTrims = 0;
|
||||
};
|
||||
|
||||
Census ReadCensus() {
|
||||
Census out;
|
||||
#if !defined(__ANDROID__)
|
||||
// P11 M2: THE POOLS ARE THE SERVER RENDERER'S under a split transport, and under
|
||||
// run-ahead a swap - or a draw - returns here before the server has applied it: a census
|
||||
// taken right after the burst's swap read the pools as they were before the burst
|
||||
// (cachedSets=0, measured under load). So first the harness's applied-seq fence (the
|
||||
// TriangleScenario / MagmaWireReclaimScenario shape): every record this client emitted
|
||||
// is applied. Inproc only - the census is in-process, spawn and tcp answer unavailable
|
||||
// - and the read itself then runs on the apply thread (GetDescriptorPoolCensus).
|
||||
// The fence's default 5 s is not enough here: the burst is 4096 draws with a queue-idle
|
||||
// rewind in the middle, and on a loaded host lavapipe applies it in more than that
|
||||
// (measured: 21 of 40 runs past 5 s beside the retrace lane).
|
||||
if (const SplitRuntimeState runtime = PeekSplitRuntime();
|
||||
runtime.transportResolved && runtime.transportName == "inproc") {
|
||||
EXPECT_TRUE(WaitForSplitAppliedForTesting(runtime.emitSeq, 120000))
|
||||
<< "the server never applied record " << runtime.emitSeq << " before the census";
|
||||
}
|
||||
const auto census = MobileGL::MG_Backend::DirectVulkan::GetDescriptorPoolCensus();
|
||||
out.available = census.available;
|
||||
out.pools = census.pools;
|
||||
out.capacitySets = census.capacitySets;
|
||||
out.cachedSets = census.cachedSets;
|
||||
out.slotTrims = census.slotTrims;
|
||||
#endif
|
||||
return out;
|
||||
}
|
||||
|
||||
std::string Describe(const Census& c) {
|
||||
std::ostringstream os;
|
||||
os << "pools=" << c.pools << " capacity=" << c.capacitySets << " cachedSets=" << c.cachedSets
|
||||
<< " slotTrims=" << c.slotTrims;
|
||||
return os.str();
|
||||
}
|
||||
|
||||
::testing::AssertionResult EveryPixelHoldsItsDrawsTexture(const Image& image, const char* when) {
|
||||
int wrong = 0;
|
||||
int firstX = -1, firstY = -1;
|
||||
Rgba8 firstSeen{};
|
||||
for (int y = 0; y < kSide; ++y) {
|
||||
for (int x = 0; x < kSide; ++x) {
|
||||
const Rgba8 expected = TextureColor((y * kSide + x) % kTextures);
|
||||
const Rgba8 seen = image.At(x, y);
|
||||
if (seen != expected) {
|
||||
if (wrong == 0) {
|
||||
firstX = x;
|
||||
firstY = y;
|
||||
firstSeen = seen;
|
||||
}
|
||||
++wrong;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (wrong == 0) return ::testing::AssertionSuccess();
|
||||
const int draw = firstY * kSide + firstX;
|
||||
return ::testing::AssertionFailure()
|
||||
<< when << ": " << wrong << " of " << kDraws << " pixels do not hold their own draw's texture. "
|
||||
<< "First: (" << firstX << ", " << firstY << ") = " << Describe(firstSeen) << ", drawn by draw "
|
||||
<< draw << " with texture " << (draw % kTextures) << " = "
|
||||
<< Describe(TextureColor(draw % kTextures)) << " (a pixel no draw reached holds 0,0,0,0)";
|
||||
}
|
||||
|
||||
class DescriptorPoolGrowthScenario : public ScenarioTest {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
ScenarioTest::SetUp();
|
||||
if (!Ready()) return;
|
||||
static const float kVertices[] = {0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f};
|
||||
glGenVertexArrays(1, &m_vao);
|
||||
glBindVertexArray(m_vao);
|
||||
glGenBuffers(1, &m_vbo);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
|
||||
glBufferData(GL_ARRAY_BUFFER, sizeof(kVertices), kVertices, GL_STATIC_DRAW);
|
||||
glEnableVertexAttribArray(0);
|
||||
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), nullptr);
|
||||
|
||||
m_textures.resize(kTextures);
|
||||
glGenTextures(kTextures, m_textures.data());
|
||||
for (int t = 0; t < kTextures; ++t) {
|
||||
const Rgba8 c = TextureColor(t);
|
||||
const std::uint8_t texel[4] = {c.r, c.g, c.b, c.a};
|
||||
glBindTexture(GL_TEXTURE_2D, m_textures[t]);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, texel);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
}
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
if (Ready()) {
|
||||
glUseProgram(0);
|
||||
glBindVertexArray(0);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
BindDefaultFramebuffer();
|
||||
if (m_program != 0) glDeleteProgram(m_program);
|
||||
if (!m_textures.empty()) glDeleteTextures(static_cast<GLsizei>(m_textures.size()), m_textures.data());
|
||||
if (m_vbo != 0) glDeleteBuffers(1, &m_vbo);
|
||||
if (m_vao != 0) glDeleteVertexArrays(1, &m_vao);
|
||||
DestroyColorFbo(m_target);
|
||||
}
|
||||
ScenarioTest::TearDown();
|
||||
}
|
||||
|
||||
::testing::AssertionResult Prepare() {
|
||||
std::string error;
|
||||
m_program = CompileProgram(kVS, kFS, &error);
|
||||
if (m_program == 0) return ::testing::AssertionFailure() << error;
|
||||
m_indexLocation = glGetUniformLocation(m_program, "uIndex");
|
||||
m_target = MakeColorFbo(kSide, kSide);
|
||||
if (m_target.fbo == 0) return ::testing::AssertionFailure() << "MakeColorFbo failed";
|
||||
glUseProgram(m_program);
|
||||
glUniform1i(glGetUniformLocation(m_program, "uTex"), 0);
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glBindVertexArray(m_vao);
|
||||
BindFbo(m_target);
|
||||
glDisable(GL_SCISSOR_TEST);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
glDisable(GL_BLEND);
|
||||
return ::testing::AssertionSuccess();
|
||||
}
|
||||
|
||||
// Draw i paints pixel (i % 64, i / 64) with texture i % kTextures.
|
||||
void Draw(int i) {
|
||||
glBindTexture(GL_TEXTURE_2D, m_textures[i % kTextures]);
|
||||
glUniform1i(m_indexLocation, i);
|
||||
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
|
||||
}
|
||||
|
||||
// The burst: every pixel, one draw and one descriptor set each.
|
||||
void DrawBurst() {
|
||||
ClearTo(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
for (int i = 0; i < kDraws; ++i) Draw(i);
|
||||
}
|
||||
|
||||
static bool IsVulkan() { return Gl().BackendName() == std::string("DirectVulkan"); }
|
||||
|
||||
GLuint m_vao = 0;
|
||||
GLuint m_vbo = 0;
|
||||
GLuint m_program = 0;
|
||||
GLint m_indexLocation = -1;
|
||||
std::vector<GLuint> m_textures;
|
||||
ColorFbo m_target;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
// One frame, kDraws distinct sets. Every pixel lands, and the frame slot grows O(log N) pools
|
||||
// for it, not N / 128.
|
||||
TEST_F(DescriptorPoolGrowthScenario, AFrameOfDistinctSetsLandsWholeAndGrowsItsPoolsGeometrically) {
|
||||
if (!Ready()) return;
|
||||
ASSERT_TRUE(Prepare());
|
||||
|
||||
const Census before = ReadCensus();
|
||||
DrawBurst();
|
||||
const Image image = ReadPixels(kSide, kSide);
|
||||
const Census after = ReadCensus();
|
||||
|
||||
EXPECT_TRUE(EveryPixelHoldsItsDrawsTexture(image, "one frame of distinct descriptor sets"));
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
|
||||
RecordProperty("census_checked", (IsVulkan() && after.available) ? "yes" : "no");
|
||||
if (!IsVulkan() || !after.available) return;
|
||||
// Falsifiability first: had the renderer's memos collapsed the draws onto shared sets, the
|
||||
// slot would never have needed to grow and the bound below would pass on any policy.
|
||||
const std::uint64_t held = BurstSetsHeldAtOnce();
|
||||
ASSERT_GE(after.cachedSets, before.cachedSets + held)
|
||||
<< "the frame did not allocate one descriptor set per draw, so it does not exercise growth. Before: "
|
||||
<< Describe(before) << "; after: " << Describe(after);
|
||||
const std::uint64_t added = after.pools - before.pools;
|
||||
RecordProperty("census_before", Describe(before));
|
||||
RecordProperty("census_after", Describe(after));
|
||||
EXPECT_LE(added, GeometricPoolBound(held + 1))
|
||||
<< "a frame needing " << held << " descriptor sets at once added " << added << " pools; doubling the "
|
||||
<< "slot's largest pool needs at most " << GeometricPoolBound(held + 1) << ". Before: " << Describe(before)
|
||||
<< "; after: " << Describe(after);
|
||||
}
|
||||
|
||||
// Burst, then quiet frames until the renderer hands the burst back, then the burst again while
|
||||
// the quiet frames are still in flight. Nothing waits between frames except where noted, so the
|
||||
// trim runs with other frame slots' work outstanding.
|
||||
TEST_F(DescriptorPoolGrowthScenario, AGivenBackBurstLeavesNoStaleSetBehind) {
|
||||
if (!Ready()) return;
|
||||
ASSERT_TRUE(Prepare());
|
||||
const unsigned long trimFrames = EnvUnsigned("MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES", 120);
|
||||
const unsigned long framesInFlight = EnvUnsigned("MOBILEGL_MAGMA_FRAMESINFLIGHT", 3);
|
||||
// The trim fires once trimFrames quiet frames have followed the burst, at the burst slot's next
|
||||
// turn; past this many frames it is not coming.
|
||||
const unsigned long quietFrameLimit = trimFrames + 2 * framesInFlight + 16;
|
||||
|
||||
DrawBurst();
|
||||
Gl().EndFrame();
|
||||
const Census afterBurst = ReadCensus();
|
||||
|
||||
// Quiet frames: one draw each, the same pixel and texture the burst gave draw 0.
|
||||
const bool observe = IsVulkan() && afterBurst.available && trimFrames != 0;
|
||||
unsigned long quietFrames = 0;
|
||||
Census afterQuiet = afterBurst;
|
||||
for (; quietFrames < quietFrameLimit; ++quietFrames) {
|
||||
Draw(0);
|
||||
Gl().EndFrame();
|
||||
if (observe) {
|
||||
afterQuiet = ReadCensus();
|
||||
if (afterQuiet.slotTrims > afterBurst.slotTrims) {
|
||||
++quietFrames;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The burst again, straight away. The slot it lands in re-grows from its base pool.
|
||||
DrawBurst();
|
||||
const Image image = ReadPixels(kSide, kSide);
|
||||
const Census afterSecondBurst = ReadCensus();
|
||||
|
||||
EXPECT_TRUE(EveryPixelHoldsItsDrawsTexture(image, "the burst drawn after the first one was given back"));
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
|
||||
RecordProperty("census_checked", observe ? "yes" : "no");
|
||||
if (!observe) return;
|
||||
RecordProperty("census_after_burst", Describe(afterBurst));
|
||||
RecordProperty("quiet_frames", std::to_string(quietFrames));
|
||||
RecordProperty("census_after_quiet", Describe(afterQuiet));
|
||||
RecordProperty("census_after_second_burst", Describe(afterSecondBurst));
|
||||
const std::uint64_t held = BurstSetsHeldAtOnce();
|
||||
ASSERT_GE(afterBurst.cachedSets, held)
|
||||
<< "the burst did not allocate one descriptor set per draw: " << Describe(afterBurst);
|
||||
EXPECT_GT(afterQuiet.slotTrims, afterBurst.slotTrims)
|
||||
<< quietFrames << " frames of one draw each followed a " << kDraws << "-set frame, but no frame slot was "
|
||||
<< "trimmed (MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES=" << trimFrames << "). After the burst: "
|
||||
<< Describe(afterBurst) << "; after the quiet frames: " << Describe(afterQuiet);
|
||||
EXPECT_LE(afterQuiet.cachedSets + held / 2, afterBurst.cachedSets)
|
||||
<< "the trim did not give the burst's sets back. After the burst: " << Describe(afterBurst)
|
||||
<< "; after the quiet frames: " << Describe(afterQuiet);
|
||||
EXPECT_LT(afterQuiet.pools, afterBurst.pools)
|
||||
<< "the trim did not give the burst's pools back. After the burst: " << Describe(afterBurst)
|
||||
<< "; after the quiet frames: " << Describe(afterQuiet);
|
||||
EXPECT_GE(afterSecondBurst.cachedSets, afterQuiet.cachedSets + held)
|
||||
<< "the second burst was not served by freshly allocated sets: " << Describe(afterSecondBurst);
|
||||
}
|
||||
|
||||
} // namespace MGITest
|
||||
@@ -1,199 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/FencePollScenario.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
//
|
||||
// P10 (A, MG_Remote/CONTRACT-P10.md §1): FENCE POLLS ANSWERED FROM THE REVERSE CHANNEL.
|
||||
//
|
||||
// A glClientWaitSync / glGetSynciv(GL_SYNC_STATUS) used to be a kWaitReply record: its answer
|
||||
// came back only after the server had applied every record before it, so a poll was a full
|
||||
// pipeline drain and, over TCP, a round trip - once per frame in Minecraft's fence use. Now the
|
||||
// server reports each fence the GPU finishes (kEventFenceSignaled) and the client answers polls
|
||||
// from those reports; the Nth unanswered zero-timeout poll in a row (MOBILEGL_IPC_POLL_ESCALATE)
|
||||
// still crosses, which is what bounds a loop whose report is late.
|
||||
//
|
||||
// Three cases. The first is ordinary GL - the idiom's two poll loops end - and its flush-bit arm
|
||||
// runs on the monolith lanes too. The other two are about the wire and skip where there is none.
|
||||
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <deque>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
|
||||
#include "../Harness/ScenarioFixture.h"
|
||||
#include "../Harness/SplitRuntimePeek.h"
|
||||
#ifdef GLAPI
|
||||
#undef GLAPI
|
||||
#endif
|
||||
#define GL_GLEXT_PROTOTYPES
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glcorearb.h>
|
||||
#undef GL_GLEXT_PROTOTYPES
|
||||
|
||||
namespace MGITest {
|
||||
namespace {
|
||||
using Clock = std::chrono::steady_clock;
|
||||
constexpr auto kLoopBound = std::chrono::seconds(10);
|
||||
|
||||
class FencePollScenario : public ScenarioTest {
|
||||
protected:
|
||||
// Some GPU work for a fence to wait behind.
|
||||
static void QueueWork() {
|
||||
glClearColor(0.25f, 0.5f, 0.75f, 1.0f);
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
}
|
||||
};
|
||||
|
||||
// The GL idiom: `while (glClientWaitSync(s, flags, 0) == GL_TIMEOUT_EXPIRED) {}` and the
|
||||
// glGetSynciv twin. With nothing else in the loop, no record would ever be published if
|
||||
// the poll were not a doorbell point, and a local "not yet" would be repeated for ever if
|
||||
// nothing made it true - so the loop ending, bounded, is the property.
|
||||
//
|
||||
// WITHOUT GL_SYNC_FLUSH_COMMANDS_BIT GL itself does not promise the loop ends (the fence
|
||||
// may sit unflushed in the driver), so that arm is split-only: there the transport
|
||||
// promises it, because the poll flushes the link and an idle server submits.
|
||||
TEST_F(FencePollScenario, ZeroTimeoutPollLoopsEndInBoundedTime) {
|
||||
if (!Ready()) return;
|
||||
const bool split = SplitRuntimeSkipReason().empty();
|
||||
for (const GLbitfield flags : {GLbitfield(GL_SYNC_FLUSH_COMMANDS_BIT), GLbitfield(0)}) {
|
||||
if (flags == 0 && !split) continue;
|
||||
QueueWork();
|
||||
GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
|
||||
ASSERT_NE(sync, nullptr);
|
||||
const auto start = Clock::now();
|
||||
GLenum status = GL_TIMEOUT_EXPIRED;
|
||||
unsigned long long polls = 0;
|
||||
while ((status = glClientWaitSync(sync, flags, 0)) == GL_TIMEOUT_EXPIRED &&
|
||||
Clock::now() - start < kLoopBound) {
|
||||
++polls;
|
||||
}
|
||||
EXPECT_TRUE(status == GL_ALREADY_SIGNALED || status == GL_CONDITION_SATISFIED)
|
||||
<< "glClientWaitSync(flags 0x" << std::hex << flags << std::dec << ", 0) still "
|
||||
<< status << " after " << polls << " polls";
|
||||
glDeleteSync(sync);
|
||||
}
|
||||
QueueWork();
|
||||
GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
|
||||
ASSERT_NE(sync, nullptr);
|
||||
const auto start = Clock::now();
|
||||
GLint value = GL_UNSIGNALED;
|
||||
while (value != GL_SIGNALED && Clock::now() - start < kLoopBound) {
|
||||
glGetSynciv(sync, GL_SYNC_STATUS, 1, nullptr, &value);
|
||||
}
|
||||
EXPECT_EQ(value, GL_SIGNALED) << "glGetSynciv(GL_SYNC_STATUS) never read signaled";
|
||||
glDeleteSync(sync);
|
||||
EXPECT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR));
|
||||
}
|
||||
|
||||
// THE WIRE HALF: once a fence is known signaled, polling it costs nothing - no reply-slot
|
||||
// record, no round trip - however often it is asked. MOBILEGL_IPC_POLL_ESCALATE=0 puts the
|
||||
// round trip back and must fail both counters (its red-once).
|
||||
TEST_F(FencePollScenario, PollsOfASignaledFenceCrossNothing) {
|
||||
if (!Ready()) return;
|
||||
const std::string why = SplitRuntimeSkipReason();
|
||||
if (!why.empty()) GTEST_SKIP() << why;
|
||||
QueueWork();
|
||||
GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
|
||||
ASSERT_NE(sync, nullptr);
|
||||
const GLenum waited = glClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, 5000000000ull);
|
||||
ASSERT_TRUE(waited == GL_ALREADY_SIGNALED || waited == GL_CONDITION_SATISFIED) << waited;
|
||||
|
||||
constexpr unsigned kPolls = 100;
|
||||
const SplitRuntimeState before = PeekSplitRuntime();
|
||||
for (unsigned i = 0; i < kPolls; ++i) {
|
||||
EXPECT_EQ(glClientWaitSync(sync, 0, 0), static_cast<GLenum>(GL_ALREADY_SIGNALED));
|
||||
GLint value = GL_UNSIGNALED;
|
||||
glGetSynciv(sync, GL_SYNC_STATUS, 1, nullptr, &value);
|
||||
EXPECT_EQ(value, GL_SIGNALED);
|
||||
}
|
||||
const SplitRuntimeState after = PeekSplitRuntime();
|
||||
glDeleteSync(sync);
|
||||
EXPECT_EQ(after.replyPostings - before.replyPostings, 0u)
|
||||
<< "polling a signaled fence published reply-slot records (MOBILEGL_IPC_POLL_ESCALATE=0 "
|
||||
"does this on purpose)";
|
||||
EXPECT_EQ(after.fenceRoundTrips - before.fenceRoundTrips, 0u);
|
||||
EXPECT_EQ(after.fenceLocalAnswers - before.fenceLocalAnswers, 2ull * kPolls);
|
||||
}
|
||||
|
||||
// THE SERVER'S HALF: a fence the GPU finishes while the client sends nothing - it only
|
||||
// polls - is still reported. The apply thread is idle then; it must submit what the driver
|
||||
// holds and keep re-checking rather than park for ever, or the only way out of the loop is
|
||||
// the escalation. The polls are paced (10 ms apart) so the escalation cannot come first by
|
||||
// rate: 64 of them is 640 ms, far more than a clear takes. Red-once: take the idle
|
||||
// re-check out of ServerLoop and this case escalates.
|
||||
TEST_F(FencePollScenario, AFenceThatFinishesWhileTheClientOnlyPollsIsReported) {
|
||||
if (!Ready()) return;
|
||||
const std::string why = SplitRuntimeSkipReason();
|
||||
if (!why.empty()) GTEST_SKIP() << why;
|
||||
QueueWork();
|
||||
GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
|
||||
ASSERT_NE(sync, nullptr);
|
||||
const SplitRuntimeState before = PeekSplitRuntime();
|
||||
const auto start = Clock::now();
|
||||
GLenum status = GL_TIMEOUT_EXPIRED;
|
||||
while ((status = glClientWaitSync(sync, 0, 0)) == GL_TIMEOUT_EXPIRED &&
|
||||
Clock::now() - start < kLoopBound) {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
||||
}
|
||||
const SplitRuntimeState after = PeekSplitRuntime();
|
||||
glDeleteSync(sync);
|
||||
EXPECT_TRUE(status == GL_ALREADY_SIGNALED || status == GL_CONDITION_SATISFIED) << status;
|
||||
EXPECT_EQ(after.fenceEscalations - before.fenceEscalations, 0u)
|
||||
<< "the loop needed an escalated round trip: the server did not report the fence on its "
|
||||
"own while the client only polled";
|
||||
EXPECT_GE(after.fenceServerReports - before.fenceServerReports, 1u);
|
||||
}
|
||||
|
||||
// P10 A's PAIRED RECORD - a measurement, not a gate: it skips unless
|
||||
// MGITEST_FENCE_PACE_BENCH=1. Minecraft's shape, isolated (in the replay corpus only
|
||||
// improved-transparency-minecraft-26.3 carries timed fence waits): every frame queues work
|
||||
// and a fence, swaps, and waits - with a timeout - on the fence it made two frames earlier.
|
||||
// The same entry run with MOBILEGL_IPC_POLL_ESCALATE=0 and with the default is the A/B; it
|
||||
// prints frames, wall time, reply-slot records and the fence counters.
|
||||
TEST_F(FencePollScenario, PacedFrameFenceWaitsBench) {
|
||||
if (!Ready()) return;
|
||||
const char* bench = std::getenv("MGITEST_FENCE_PACE_BENCH");
|
||||
if (bench == nullptr || std::string(bench) != "1") {
|
||||
GTEST_SKIP() << "a measurement: set MGITEST_FENCE_PACE_BENCH=1";
|
||||
}
|
||||
const std::string why = SplitRuntimeSkipReason();
|
||||
if (!why.empty()) GTEST_SKIP() << why;
|
||||
constexpr int kFrames = 600;
|
||||
// MGITEST_FENCE_PACE_LAG: how many frames back the waited fence is (default 2).
|
||||
const char* lagEnv = std::getenv("MGITEST_FENCE_PACE_LAG");
|
||||
const size_t lag = lagEnv != nullptr && std::atoi(lagEnv) > 0 ? static_cast<size_t>(std::atoi(lagEnv)) : 2;
|
||||
std::deque<GLsync> inFlight;
|
||||
const SplitRuntimeState before = PeekSplitRuntime();
|
||||
const auto start = Clock::now();
|
||||
for (int frame = 0; frame < kFrames; ++frame) {
|
||||
QueueWork();
|
||||
inFlight.push_back(glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0));
|
||||
Gl().EndFrame();
|
||||
if (inFlight.size() > lag) {
|
||||
GLsync old = inFlight.front();
|
||||
inFlight.pop_front();
|
||||
const GLenum waited = glClientWaitSync(old, GL_SYNC_FLUSH_COMMANDS_BIT, 1000000000ull);
|
||||
EXPECT_TRUE(waited == GL_ALREADY_SIGNALED || waited == GL_CONDITION_SATISFIED) << waited;
|
||||
glDeleteSync(old);
|
||||
}
|
||||
}
|
||||
const double ms = std::chrono::duration<double, std::milli>(Clock::now() - start).count();
|
||||
const SplitRuntimeState after = PeekSplitRuntime();
|
||||
for (GLsync sync : inFlight) glDeleteSync(sync);
|
||||
const char* escalate = std::getenv("MOBILEGL_IPC_POLL_ESCALATE");
|
||||
std::printf("P10BENCH transport=%s poll-escalate=%s lag=%zu frames=%d ms=%.1f ms/frame=%.3f "
|
||||
"reply-records=%llu fence-round-trips=%llu fence-local=%llu fence-reports=%llu\n",
|
||||
after.transportName.c_str(), escalate != nullptr ? escalate : "(default)", lag, kFrames, ms,
|
||||
ms / kFrames, after.replyPostings - before.replyPostings,
|
||||
after.fenceRoundTrips - before.fenceRoundTrips,
|
||||
after.fenceLocalAnswers - before.fenceLocalAnswers,
|
||||
after.fenceServerReports - before.fenceServerReports);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
} // namespace MGITest
|
||||
@@ -1,591 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/ImageBindableRemintScenario.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
//
|
||||
// Scenario - THE FIRST glBindImageTexture OF A TEXTURE THE GPU HAS ALREADY WRITTEN.
|
||||
//
|
||||
// ES only allows immutable storage on an image unit, and a few formats need a wider carrier on
|
||||
// top (TextureImpl::GetImageBindableStorageWidening), so Espryt re-mints a texture the first time
|
||||
// it is image-bound after it already has driver storage (RequireImageBindableStorage). The new
|
||||
// storage has to hold what the old one held. The re-mint used to fill it from the frontend's
|
||||
// shadow - the CLIENT's copy of each level - and the shadow never sees a GPU write: a render or
|
||||
// clear into the level, a glGenerateMipmap, a null-data definition only the GPU ever filled. Every
|
||||
// such level came back as the bytes the application last uploaded, or zeroes. That is the
|
||||
// ~26.9k-pixel iris-derivative difference: an RGBA16F render target, first image-bound after it
|
||||
// was rendered into.
|
||||
//
|
||||
// Every case gives a texture its content by one means, lets the backend create its storage (a
|
||||
// sampling draw, or the FBO attach of a GPU clear), writes it on the GPU where the case says so,
|
||||
// and then binds it to an image unit for the first time: a compute imageLoad copies the level into
|
||||
// a destination that was image-bound before it was ever synced (so the destination itself never
|
||||
// re-mints), and the destination is read back through an FBO. The expectation is the GL answer.
|
||||
//
|
||||
// The controls are the other half: levels the GPU never wrote (including formats whose driver
|
||||
// readback may be refused), levels the driver does not have yet because they were defined after
|
||||
// the last sync, and a pending client write that has to land on top of GPU content. Magma never
|
||||
// re-mints from a shadow (it copies image to image) and is the control backend.
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "../Harness/HeadlessGL.h"
|
||||
#include "../Harness/ScenarioFixture.h"
|
||||
|
||||
#ifdef GLAPI
|
||||
#undef GLAPI
|
||||
#endif
|
||||
#define GL_GLEXT_PROTOTYPES
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glcorearb.h>
|
||||
#undef GL_GLEXT_PROTOTYPES
|
||||
|
||||
namespace MGITest {
|
||||
namespace {
|
||||
constexpr int kEdge = 8;
|
||||
|
||||
constexpr const char* kVS = R"(#version 430 core
|
||||
void main() {
|
||||
vec2 positions[3] = vec2[3](vec2(-1.0, -1.0), vec2(3.0, -1.0), vec2(-1.0, 3.0));
|
||||
gl_Position = vec4(positions[gl_VertexID], 0.0, 1.0);
|
||||
}
|
||||
)";
|
||||
constexpr const char* kSampleFS = R"(#version 430 core
|
||||
uniform sampler2D u_tex;
|
||||
out vec4 o_color;
|
||||
void main() { o_color = texelFetch(u_tex, ivec2(gl_FragCoord.xy) % 4, 0); }
|
||||
)";
|
||||
|
||||
// Copies an image into an RGBA8 image with imageLoad; a signed-normalized source is mapped
|
||||
// to [0, 1] so it survives the unsigned destination.
|
||||
std::string CopyCS(const char* srcFormat, bool snorm) {
|
||||
std::string s = "#version 430 core\nlayout(local_size_x = 8, local_size_y = 8) in;\n";
|
||||
s += std::string("layout(") + srcFormat + ", binding = 0) readonly uniform image2D u_src;\n";
|
||||
s += "layout(rgba8, binding = 1) writeonly uniform image2D u_dst;\n";
|
||||
s += "void main() { ivec2 p = ivec2(gl_GlobalInvocationID.xy); vec4 v = imageLoad(u_src, p);\n";
|
||||
if (snorm) s += " v = v * 0.5 + 0.5;\n";
|
||||
s += " imageStore(u_dst, p, v); }\n";
|
||||
return s;
|
||||
}
|
||||
|
||||
std::vector<GLubyte> Pattern(int edge, GLubyte magic) {
|
||||
std::vector<GLubyte> t(static_cast<std::size_t>(edge * edge) * 4u);
|
||||
for (int y = 0; y < edge; ++y)
|
||||
for (int x = 0; x < edge; ++x) {
|
||||
const std::size_t at = static_cast<std::size_t>((y * edge + x) * 4);
|
||||
t[at + 0] = magic;
|
||||
t[at + 1] = static_cast<GLubyte>(16 * (x + 1));
|
||||
t[at + 2] = static_cast<GLubyte>(16 * (y + 1));
|
||||
t[at + 3] = 0xFF;
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
std::vector<GLubyte> Solid(int edge, GLubyte r, GLubyte g, GLubyte b, GLubyte a) {
|
||||
std::vector<GLubyte> t(static_cast<std::size_t>(edge * edge) * 4u);
|
||||
for (std::size_t i = 0; i < t.size(); i += 4) {
|
||||
t[i] = r;
|
||||
t[i + 1] = g;
|
||||
t[i + 2] = b;
|
||||
t[i + 3] = a;
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
const GLfloat kGreen[4] = {0.0f, 1.0f, 0.0f, 1.0f};
|
||||
|
||||
class ImageBindableRemintScenario : public ScenarioTest {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
ScenarioTest::SetUp();
|
||||
if (!Ready()) return;
|
||||
std::string error;
|
||||
m_sampleProgram = CompileProgram(kVS, kSampleFS, &error);
|
||||
ASSERT_NE(m_sampleProgram, 0u) << error;
|
||||
m_scratch = MakeColorFbo(4, 4);
|
||||
glGenVertexArrays(1, &m_vao);
|
||||
FirstGLError();
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
if (!Ready()) return;
|
||||
glUseProgram(0);
|
||||
glBindImageTexture(0, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
|
||||
glBindImageTexture(1, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
|
||||
if (m_sampleProgram) glDeleteProgram(m_sampleProgram);
|
||||
if (m_vao) glDeleteVertexArrays(1, &m_vao);
|
||||
if (!m_textures.empty()) glDeleteTextures(static_cast<GLsizei>(m_textures.size()), m_textures.data());
|
||||
if (m_fbo) glDeleteFramebuffers(1, &m_fbo);
|
||||
BindDefaultFramebuffer();
|
||||
DestroyColorFbo(m_scratch);
|
||||
glViewport(0, 0, Gl().Width(), Gl().Height());
|
||||
FirstGLError();
|
||||
}
|
||||
|
||||
GLuint NewTexture() {
|
||||
GLuint t = 0;
|
||||
glGenTextures(1, &t);
|
||||
m_textures.push_back(t);
|
||||
return t;
|
||||
}
|
||||
|
||||
static void Nearest(GLenum target, GLuint tex, int maxLevel) {
|
||||
glBindTexture(target, tex);
|
||||
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, maxLevel);
|
||||
glBindTexture(target, 0);
|
||||
}
|
||||
|
||||
// A draw that samples the texture: the backend now holds storage for it.
|
||||
void SyncBySampling(GLuint tex) {
|
||||
BindFbo(m_scratch);
|
||||
glUseProgram(m_sampleProgram);
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glBindTexture(GL_TEXTURE_2D, tex);
|
||||
glUniform1i(glGetUniformLocation(m_sampleProgram, "u_tex"), 0);
|
||||
glBindVertexArray(m_vao);
|
||||
glDrawArrays(GL_TRIANGLES, 0, 3);
|
||||
glBindVertexArray(0);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
glUseProgram(0);
|
||||
BindDefaultFramebuffer();
|
||||
glFinish();
|
||||
}
|
||||
|
||||
// A GPU write the frontend's shadow never sees. A layer >= 0 names one layer of an
|
||||
// array texture.
|
||||
void GpuClear(GLuint tex, int level, const GLfloat* color, int layer = -1) {
|
||||
if (!m_fbo) glGenFramebuffers(1, &m_fbo);
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
|
||||
if (layer >= 0) {
|
||||
glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex, level, layer);
|
||||
} else {
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, level);
|
||||
}
|
||||
EXPECT_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), GLenum(GL_FRAMEBUFFER_COMPLETE))
|
||||
<< "the clear target is incomplete";
|
||||
glClearBufferfv(GL_COLOR, 0, color);
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
|
||||
BindDefaultFramebuffer();
|
||||
}
|
||||
|
||||
// The first image binding of (src, level[, layer]): an imageLoad copy into a fresh RGBA8
|
||||
// destination, read back through an FBO.
|
||||
std::vector<GLubyte> ImageCopy(GLuint src, int level, GLenum unitFormat, const char* glslFormat,
|
||||
bool snorm = false, int layer = 0) {
|
||||
const GLuint dst = NewTexture();
|
||||
glBindTexture(GL_TEXTURE_2D, dst);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge, kEdge);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
glBindImageTexture(1, dst, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
|
||||
glBindImageTexture(0, src, level, GL_FALSE, layer, GL_READ_ONLY, unitFormat);
|
||||
EXPECT_EQ(FirstGLError(), 0u) << "glBindImageTexture";
|
||||
const std::string cs = CopyCS(glslFormat, snorm);
|
||||
const char* csp = cs.c_str();
|
||||
const GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
|
||||
glShaderSource(shader, 1, &csp, nullptr);
|
||||
glCompileShader(shader);
|
||||
const GLuint program = glCreateProgram();
|
||||
glAttachShader(program, shader);
|
||||
glLinkProgram(program);
|
||||
glDeleteShader(shader);
|
||||
GLint linked = GL_FALSE;
|
||||
glGetProgramiv(program, GL_LINK_STATUS, &linked);
|
||||
EXPECT_EQ(linked, GL_TRUE) << "the copy program did not link";
|
||||
glUseProgram(program);
|
||||
// P11 M: A BARRIER THE SPEC DOES NOT ASK FOR, pinned for the reason
|
||||
// TextureRemintPullScenario's twin gives (ID-P9-11, DEBTS "待归因"): on llvmpipe the
|
||||
// kept-allocation case (GpuClearOverAnImmutableUploadSurvives - no re-mint to
|
||||
// serialize anything) read the pre-clear upload once on the push-monolith arm under
|
||||
// load, the same shape P9 measured 3/30 on the split arm. The cases ask what the
|
||||
// storage HOLDS after the first image binding, not how a clear orders against an
|
||||
// image load, so the ordering is pinned here.
|
||||
glMemoryBarrier(GL_ALL_BARRIER_BITS);
|
||||
glDispatchCompute(1, 1, 1);
|
||||
glMemoryBarrier(GL_ALL_BARRIER_BITS);
|
||||
glUseProgram(0);
|
||||
glDeleteProgram(program);
|
||||
glBindImageTexture(0, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
|
||||
glBindImageTexture(1, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
|
||||
if (!m_fbo) glGenFramebuffers(1, &m_fbo);
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, dst, 0);
|
||||
std::vector<GLubyte> out(static_cast<std::size_t>(kEdge * kEdge) * 4u, 0xA5);
|
||||
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
||||
glReadPixels(0, 0, kEdge, kEdge, GL_RGBA, GL_UNSIGNED_BYTE, out.data());
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
|
||||
BindDefaultFramebuffer();
|
||||
EXPECT_EQ(FirstGLError(), 0u) << "copy/readback";
|
||||
return out;
|
||||
}
|
||||
|
||||
// The edge x edge corner of `got` against an RGBA8 expectation, the first `channels`
|
||||
// channels only, within 2 codes (a normalized value's round trip).
|
||||
static void ExpectImage(const std::vector<GLubyte>& got, int edge, const std::vector<GLubyte>& want,
|
||||
int channels = 4) {
|
||||
int bad = 0;
|
||||
std::ostringstream first;
|
||||
for (int y = 0; y < edge; ++y)
|
||||
for (int x = 0; x < edge; ++x) {
|
||||
const std::size_t g = static_cast<std::size_t>((y * kEdge + x) * 4);
|
||||
const std::size_t w = static_cast<std::size_t>((y * edge + x) * 4);
|
||||
bool texelBad = false;
|
||||
for (int c = 0; c < channels; ++c)
|
||||
texelBad |= std::abs(int(got[g + c]) - int(want[w + c])) > 2;
|
||||
if (texelBad && bad++ == 0) {
|
||||
first << "(" << x << "," << y << ") got " << int(got[g]) << "," << int(got[g + 1]) << ","
|
||||
<< int(got[g + 2]) << "," << int(got[g + 3]) << " want " << int(want[w]) << ","
|
||||
<< int(want[w + 1]) << "," << int(want[w + 2]) << "," << int(want[w + 3]);
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(bad, 0) << bad << " of " << edge * edge << " texels differ; first " << first.str();
|
||||
}
|
||||
|
||||
// One glTexSubImage of opaque blue per {x, y, w, h} box, left pending.
|
||||
static void WriteBlueBoxes(GLuint tex, const std::vector<std::array<int, 4>>& boxes) {
|
||||
glBindTexture(GL_TEXTURE_2D, tex);
|
||||
for (const auto& b : boxes) {
|
||||
std::vector<GLubyte> blue(static_cast<std::size_t>(b[2] * b[3]) * 4u, 0);
|
||||
for (std::size_t i = 0; i < blue.size(); i += 4) {
|
||||
blue[i + 2] = 255;
|
||||
blue[i + 3] = 255;
|
||||
}
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, b[0], b[1], b[2], b[3], GL_RGBA, GL_UNSIGNED_BYTE, blue.data());
|
||||
}
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
}
|
||||
|
||||
// kEdge x kEdge green, blue inside the boxes.
|
||||
static std::vector<GLubyte> GreenWithBlueBoxes(const std::vector<std::array<int, 4>>& boxes) {
|
||||
auto want = Solid(kEdge, 0, 255, 0, 255);
|
||||
for (const auto& b : boxes)
|
||||
for (int y = b[1]; y < b[1] + b[3]; ++y)
|
||||
for (int x = b[0]; x < b[0] + b[2]; ++x) {
|
||||
const std::size_t at = static_cast<std::size_t>((y * kEdge + x) * 4);
|
||||
want[at] = 0;
|
||||
want[at + 1] = 0;
|
||||
want[at + 2] = 255;
|
||||
want[at + 3] = 255;
|
||||
}
|
||||
return want;
|
||||
}
|
||||
|
||||
GLuint m_sampleProgram = 0, m_vao = 0, m_fbo = 0;
|
||||
ColorFbo m_scratch{};
|
||||
std::vector<GLuint> m_textures;
|
||||
};
|
||||
|
||||
// Control: the shadow and the driver agree.
|
||||
TEST_F(ImageBindableRemintScenario, UploadedLevelKeepsItsUpload) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
const auto p = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, p.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8, "rgba8"), kEdge, p);
|
||||
}
|
||||
|
||||
TEST_F(ImageBindableRemintScenario, GpuClearOverAnUploadSurvives) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
const auto p = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, p.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
GpuClear(t, 0, kGreen);
|
||||
SyncBySampling(t);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8, "rgba8"), kEdge, Solid(kEdge, 0, 255, 0, 255));
|
||||
}
|
||||
|
||||
// Immutable in a core image format: the storage is already what an image unit needs.
|
||||
TEST_F(ImageBindableRemintScenario, GpuClearOverAnImmutableUploadSurvives) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
const auto p = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge, kEdge);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kEdge, kEdge, GL_RGBA, GL_UNSIGNED_BYTE, p.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
GpuClear(t, 0, kGreen);
|
||||
SyncBySampling(t);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8, "rgba8"), kEdge, Solid(kEdge, 0, 255, 0, 255));
|
||||
}
|
||||
|
||||
// A null-data definition only the GPU ever filled: the shadow holds zeroes.
|
||||
TEST_F(ImageBindableRemintScenario, GpuClearOfANullDefinitionSurvives) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
GpuClear(t, 0, kGreen);
|
||||
SyncBySampling(t);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8, "rgba8"), kEdge, Solid(kEdge, 0, 255, 0, 255));
|
||||
}
|
||||
|
||||
// A client write still pending when the bind comes lands on top of the GPU's content,
|
||||
// and only inside its own box.
|
||||
TEST_F(ImageBindableRemintScenario, PendingSubImageLandsOnTheGpuClear) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
const auto p = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, p.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
GpuClear(t, 0, kGreen);
|
||||
SyncBySampling(t);
|
||||
const auto blue = Solid(2, 0, 0, 255, 255);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 2, 2, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, blue.data());
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
auto want = Solid(kEdge, 0, 255, 0, 255);
|
||||
for (int y = 2; y < 4; ++y)
|
||||
for (int x = 2; x < 4; ++x) {
|
||||
const std::size_t at = static_cast<std::size_t>((y * kEdge + x) * 4);
|
||||
want[at] = 0;
|
||||
want[at + 1] = 0;
|
||||
want[at + 2] = 255;
|
||||
want[at + 3] = 255;
|
||||
}
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8, "rgba8"), kEdge, want);
|
||||
}
|
||||
|
||||
// Several pending writes: only their texels land on the GPU's clear, never the gaps between
|
||||
// them. The re-mint merged the union box of the shadow over the readback whenever the rect
|
||||
// list was withheld, and kept the shadow outright when that box spanned the level.
|
||||
|
||||
// Two 3x7 columns with a one-texel gap: 42 of their union's 49 texels, past the 3/4 at which
|
||||
// the storage withholds its rect list.
|
||||
TEST_F(ImageBindableRemintScenario, PendingSubImagesFillingThreeQuartersOfTheirUnionLandOnTheGpuClear) {
|
||||
if (!Ready()) return;
|
||||
const std::vector<std::array<int, 4>> boxes = {{0, 0, 3, 7}, {4, 0, 3, 7}};
|
||||
const GLuint t = NewTexture();
|
||||
const auto p = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, p.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
GpuClear(t, 0, kGreen);
|
||||
SyncBySampling(t);
|
||||
WriteBlueBoxes(t, boxes);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8, "rgba8"), kEdge, GreenWithBlueBoxes(boxes));
|
||||
}
|
||||
|
||||
// Three quadrants: the union box is the whole level; the fourth quadrant is the GPU's.
|
||||
TEST_F(ImageBindableRemintScenario, PendingSubImagesWhoseUnionSpansTheLevelLandOnTheGpuClear) {
|
||||
if (!Ready()) return;
|
||||
const std::vector<std::array<int, 4>> boxes = {{0, 0, 4, 4}, {4, 0, 4, 4}, {0, 4, 4, 4}};
|
||||
const GLuint t = NewTexture();
|
||||
const auto p = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, p.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
GpuClear(t, 0, kGreen);
|
||||
SyncBySampling(t);
|
||||
WriteBlueBoxes(t, boxes);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8, "rgba8"), kEdge, GreenWithBlueBoxes(boxes));
|
||||
}
|
||||
|
||||
TEST_F(ImageBindableRemintScenario, GeneratedMipLevelSurvives) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
const auto s = Solid(kEdge, 200, 100, 50, 255);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, s.data());
|
||||
glGenerateMipmap(GL_TEXTURE_2D);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
SyncBySampling(t);
|
||||
ExpectImage(ImageCopy(t, 1, GL_RGBA8, "rgba8"), kEdge / 2, Solid(kEdge / 2, 200, 100, 50, 255));
|
||||
}
|
||||
|
||||
TEST_F(ImageBindableRemintScenario, GpuClearOfAnUploadedMipLevelSurvives) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
const auto s0 = Solid(kEdge, 200, 100, 50, 255);
|
||||
const auto s1 = Solid(kEdge / 2, 10, 20, 30, 255);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, s0.data());
|
||||
glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge / 2, kEdge / 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, s1.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 1);
|
||||
SyncBySampling(t);
|
||||
GpuClear(t, 1, kGreen);
|
||||
SyncBySampling(t);
|
||||
ExpectImage(ImageCopy(t, 1, GL_RGBA8, "rgba8"), kEdge / 2, Solid(kEdge / 2, 0, 255, 0, 255));
|
||||
}
|
||||
|
||||
// Control: a level defined (null data) after the last sync is not on the driver yet, so
|
||||
// there is nothing to read back for it; the bound level 0 must still be the upload.
|
||||
TEST_F(ImageBindableRemintScenario, LevelDefinedAfterTheSyncDoesNotDisturbTheOthers) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
const auto p = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, p.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge / 2, kEdge / 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8, "rgba8"), kEdge, p);
|
||||
}
|
||||
|
||||
// Control: the same late level, partly uploaded - the shadow is the only copy of it.
|
||||
TEST_F(ImageBindableRemintScenario, LevelDefinedAndUploadedAfterTheSyncKeepsTheUpload) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
const auto p = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, p.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge / 2, kEdge / 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
const auto blue = Solid(2, 0, 0, 255, 255);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 1, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, blue.data());
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
ExpectImage(ImageCopy(t, 1, GL_RGBA8, "rgba8"), 2, blue);
|
||||
}
|
||||
|
||||
// GL_RG8 is not an ESSL image format, so the re-mint also WIDENS the storage (to RGBA8)
|
||||
// and cannot keep the old allocation even though it is immutable.
|
||||
TEST_F(ImageBindableRemintScenario, GpuClearSurvivesAWideningRemint) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
std::vector<GLubyte> rg(static_cast<std::size_t>(kEdge * kEdge) * 2u, 0x33);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RG8, kEdge, kEdge);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kEdge, kEdge, GL_RG, GL_UNSIGNED_BYTE, rg.data());
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
const GLfloat c[4] = {0.5f, 0.25f, 0.0f, 1.0f};
|
||||
GpuClear(t, 0, c);
|
||||
SyncBySampling(t);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RG8, "rg8"), kEdge, Solid(kEdge, 128, 64, 0, 255), 2);
|
||||
}
|
||||
|
||||
// Control: widened, uploaded only.
|
||||
TEST_F(ImageBindableRemintScenario, UploadSurvivesAWideningRemint) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
std::vector<GLubyte> rg(static_cast<std::size_t>(kEdge * kEdge) * 2u);
|
||||
for (std::size_t i = 0; i < rg.size(); i += 2) {
|
||||
rg[i] = 0x33;
|
||||
rg[i + 1] = 0x99;
|
||||
}
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RG8, kEdge, kEdge);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kEdge, kEdge, GL_RG, GL_UNSIGNED_BYTE, rg.data());
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RG8, "rg8"), kEdge, Solid(kEdge, 0x33, 0x99, 0, 255), 2);
|
||||
}
|
||||
|
||||
// Control: a signed-normalized level (not colour-renderable on every ES driver, so its
|
||||
// readback may be refused and the shadow used instead), uploaded only.
|
||||
TEST_F(ImageBindableRemintScenario, SnormUploadSurvives) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
std::vector<GLbyte> s(static_cast<std::size_t>(kEdge * kEdge) * 4u);
|
||||
for (std::size_t i = 0; i < s.size(); i += 4) {
|
||||
s[i] = 127;
|
||||
s[i + 1] = 0;
|
||||
s[i + 2] = -127;
|
||||
s[i + 3] = 127;
|
||||
}
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8_SNORM, kEdge, kEdge, 0, GL_RGBA, GL_BYTE, s.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8_SNORM, "rgba8_snorm", true), kEdge, Solid(kEdge, 255, 128, 0, 255),
|
||||
3);
|
||||
}
|
||||
|
||||
// Control: RGBA16_SNORM is desktop-only as an image format, so this re-mint widens too.
|
||||
TEST_F(ImageBindableRemintScenario, Snorm16UploadSurvivesAWideningRemint) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
std::vector<GLshort> s(static_cast<std::size_t>(kEdge * kEdge) * 4u);
|
||||
for (std::size_t i = 0; i < s.size(); i += 4) {
|
||||
s[i] = 32767;
|
||||
s[i + 1] = 0;
|
||||
s[i + 2] = -32767;
|
||||
s[i + 3] = 32767;
|
||||
}
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16_SNORM, kEdge, kEdge);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kEdge, kEdge, GL_RGBA, GL_SHORT, s.data());
|
||||
Nearest(GL_TEXTURE_2D, t, 0);
|
||||
SyncBySampling(t);
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA16_SNORM, "rgba16_snorm", true), kEdge,
|
||||
Solid(kEdge, 255, 128, 0, 255), 3);
|
||||
}
|
||||
|
||||
// An array texture is read back one layer at a time: the GPU-cleared layer and the
|
||||
// uploaded one both have to come through. The clear's FBO attach is what gives the
|
||||
// texture its driver storage here.
|
||||
TEST_F(ImageBindableRemintScenario, GpuClearOfOneArrayLayerSurvivesBesideTheUploadedLayer) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewTexture();
|
||||
const auto p = Pattern(kEdge, 0x40);
|
||||
std::vector<GLubyte> layers(p);
|
||||
layers.insert(layers.end(), p.begin(), p.end());
|
||||
glBindTexture(GL_TEXTURE_2D_ARRAY, t);
|
||||
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, kEdge, kEdge, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
|
||||
layers.data());
|
||||
glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
|
||||
Nearest(GL_TEXTURE_2D_ARRAY, t, 0);
|
||||
GpuClear(t, 0, kGreen, /*layer=*/1);
|
||||
glFinish();
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8, "rgba8", false, /*layer=*/1), kEdge, Solid(kEdge, 0, 255, 0, 255));
|
||||
ExpectImage(ImageCopy(t, 0, GL_RGBA8, "rgba8", false, /*layer=*/0), kEdge, p);
|
||||
}
|
||||
|
||||
// A view owns no storage, so its first image binding is the VIEWED texture's transition,
|
||||
// and the GPU's texels there have to come through it. Needs glTextureView, which Espryt
|
||||
// only has where the ES driver does (not on llvmpipe).
|
||||
TEST_F(ImageBindableRemintScenario, GpuClearSurvivesTheFirstImageBindingOfAView) {
|
||||
if (!Ready()) return;
|
||||
const GLuint owner = NewTexture();
|
||||
const auto p = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, owner);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge, kEdge);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kEdge, kEdge, GL_RGBA, GL_UNSIGNED_BYTE, p.data());
|
||||
Nearest(GL_TEXTURE_2D, owner, 0);
|
||||
SyncBySampling(owner);
|
||||
GpuClear(owner, 0, kGreen);
|
||||
SyncBySampling(owner);
|
||||
const GLuint view = NewTexture();
|
||||
FirstGLError();
|
||||
glTextureView(view, GL_TEXTURE_2D, owner, GL_RGBA8, 0, 1, 0, 1);
|
||||
if (const GLenum error = FirstGLError()) {
|
||||
GTEST_SKIP() << "glTextureView is unavailable on backend " << Gl().BackendName() << " ("
|
||||
<< GLErrorName(error) << ")";
|
||||
}
|
||||
Nearest(GL_TEXTURE_2D, view, 0);
|
||||
SyncBySampling(view);
|
||||
ExpectImage(ImageCopy(view, 0, GL_RGBA8, "rgba8"), kEdge, Solid(kEdge, 0, 255, 0, 255));
|
||||
}
|
||||
} // namespace
|
||||
} // namespace MGITest
|
||||
@@ -49,10 +49,8 @@
|
||||
#include <vector>
|
||||
|
||||
#include "../Harness/HeadlessGL.h"
|
||||
#include "../Harness/PersistentMapPeek.h"
|
||||
#include "../Harness/PipeStatsWindow.h"
|
||||
#include "../Harness/ScenarioFixture.h"
|
||||
#include "../Harness/SplitLane.h"
|
||||
|
||||
#ifdef GLAPI
|
||||
#undef GLAPI
|
||||
@@ -96,9 +94,6 @@ void main() { word = 0xC0FFEEu; }
|
||||
// Set by the MapPersistentRoundtrips. ctest entry and by nothing else; a harness marker,
|
||||
// never read by the library.
|
||||
constexpr const char* kLaneMarker = "MGITEST_MPR_LANE";
|
||||
// P11 A1: set (to the tier the lane names, "T0") only by the `.AdoptTier0.` tcp entries,
|
||||
// which also set MOBILEGL_IPC_ADOPT_TIER=0; a harness marker, never read by the library.
|
||||
constexpr const char* kAdoptTierRefusalMarker = "MGITEST_ADOPT_TIER_REFUSAL";
|
||||
// Draws issued against the arena inside the counted window. One definition, many draws:
|
||||
// "one per definition" (1) and "one per draw" (kDrawsInTheWindow) have to be different
|
||||
// numbers or the assertion cannot tell them apart.
|
||||
@@ -265,27 +260,6 @@ void main() { word = 0xC0FFEEu; }
|
||||
return px;
|
||||
}
|
||||
|
||||
// P11 A2: the arena's tier as the frontend object records it, against the lane's
|
||||
// declaration. Adopted = the resource owner minted a persistent coherent mapping and
|
||||
// the CPU shadow was released; emulated = the owner declined (T2) and the shadow is
|
||||
// the truth. Pixels cannot tell them apart - every case above is green on both.
|
||||
void ExpectDeclaredArm(const std::string& declared, const char* when) {
|
||||
bool adopted = false;
|
||||
ASSERT_TRUE(PeekBufferIsAdoptedPersistentMap(m_arena, &adopted))
|
||||
<< "no frontend BufferObject behind the arena " << when;
|
||||
const std::string landed = adopted ? "adopted" : "emulated";
|
||||
RecordProperty(std::string("arena_arm_") + (m_armPeeks++ == 0 ? "defined" : "used"),
|
||||
landed.c_str());
|
||||
EXPECT_EQ(declared, landed)
|
||||
<< "the lane declared the " << declared << " arm and the " << (kArenaBytes >> 20)
|
||||
<< " MiB arena is " << landed << " " << when
|
||||
<< ". Monolith lanes adopt on both backends (Espryt's handle arm mints through "
|
||||
"Ops_H_MapPersistentTracked, Magma's legacy AcquirePersistentMap); split lanes "
|
||||
"run T2, where every acquisition declines.";
|
||||
}
|
||||
|
||||
int m_armPeeks = 0;
|
||||
|
||||
unsigned int m_program = 0;
|
||||
unsigned int m_compute = 0;
|
||||
unsigned int m_vao = 0;
|
||||
@@ -531,92 +505,4 @@ void main() { word = 0xC0FFEEu; }
|
||||
<< window.line;
|
||||
}
|
||||
|
||||
// P11 A2 (MG_Remote/CONTRACT-P11.md §2): WHICH TIER THE ARENA REALLY LANDED IN. The cases above
|
||||
// are green whether the arena adopted or stayed emulated, so the lane declares the arm
|
||||
// (MGITEST_PERSISTENT_MAP_ARM) and this case asserts it, the way
|
||||
// PersistentCoherentMapScenario.TheMapLandsInTheArmItsLaneDeclares does for a sub-16-MiB map.
|
||||
// Asked twice: after the NULL-data definition (TryAdoptLargeStorage's door) and after a frame
|
||||
// of use that ends in an SSBO binding and a dispatch (the storage-binding door,
|
||||
// EnsureGpuResidentStorage, which Magma's server walk opens). Lanes that declare nothing - the
|
||||
// ambient entries, which run under whatever transport the job exports - skip.
|
||||
TEST_F(LargeArenaAdoptionScenario, TheArenaLandsInTheTierItsLaneDeclares) {
|
||||
if (!Ready() || IsSkipped()) return;
|
||||
const std::string declared = SplitLane::DeclaredPersistentMapArm();
|
||||
if (declared.empty()) {
|
||||
GTEST_SKIP() << "this lane declares no arm: MGITEST_PERSISTENT_MAP_ARM is set only by the "
|
||||
"lanes that pin their transport (monolith: adopted; the split arms: "
|
||||
"emulated)";
|
||||
}
|
||||
if (!PersistentMapPeekAvailable()) {
|
||||
GTEST_SKIP() << "this lane declares the " << declared << " arm but Harness/PersistentMapPeek "
|
||||
"cannot look in this build (on Android this module links the shipping "
|
||||
"library, built -fvisibility=hidden). 'Could not look' is not 'it was "
|
||||
<< declared << "'.";
|
||||
}
|
||||
ExpectDeclaredArm(declared, "right after its NULL-data definition");
|
||||
if (HasFatalFailure()) return;
|
||||
|
||||
UploadQuad(1.f, 0.f, 0.f);
|
||||
DrawQuad();
|
||||
EXPECT_GT(CenterPixel()[0], 200) << "the draw from the arena never landed";
|
||||
Gl().EndFrame();
|
||||
|
||||
GLint maxComputeStorageBlocks = 0;
|
||||
glGetIntegerv(GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS, &maxComputeStorageBlocks);
|
||||
if (maxComputeStorageBlocks >= 1) {
|
||||
const GLuint compute = CompileStage(GL_COMPUTE_SHADER, kMarkerComputeSource);
|
||||
ASSERT_NE(compute, 0u) << m_buildLog;
|
||||
m_compute = glCreateProgram();
|
||||
glAttachShader(m_compute, compute);
|
||||
glLinkProgram(m_compute);
|
||||
glDeleteShader(compute);
|
||||
glBindBufferRange(GL_SHADER_STORAGE_BUFFER, 0, m_arena, 0, sizeof(unsigned int));
|
||||
glUseProgram(m_compute);
|
||||
glDispatchCompute(1, 1, 1);
|
||||
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT | GL_BUFFER_UPDATE_BARRIER_BIT);
|
||||
unsigned int marker = 0;
|
||||
glBindBuffer(GL_ARRAY_BUFFER, m_arena);
|
||||
glGetBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(marker), &marker);
|
||||
EXPECT_EQ(marker, 0xC0FFEEu) << "the dispatch through the arena's SSBO binding never landed";
|
||||
} else {
|
||||
RecordProperty("arena_arm_used", "not asked: no compute shader storage blocks");
|
||||
}
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
ExpectDeclaredArm(declared, "after a frame of draws, an SSBO binding and a dispatch");
|
||||
}
|
||||
|
||||
// P11 A1 (MG_Remote/CONTRACT-P11.md §1): THE TCP LANE WITH MOBILEGL_IPC_ADOPT_TIER=0. A stream
|
||||
// data plane has no memory the two sides share, so the client refuses the knob by name at its
|
||||
// handshake - exactly one `Refuse{AdoptTierOnStream, "T0"}` line in its log - and the session
|
||||
// runs T2: the other cases in the same `.AdoptTier0.` lane are green and the arena is emulated.
|
||||
// Before A1 this lane ran T2 silently. Everywhere else it skips.
|
||||
TEST_F(LargeArenaAdoptionScenario, AStreamSessionRefusesTheAdoptTierOnceByName) {
|
||||
if (!Ready() || IsSkipped()) return;
|
||||
const char* tier = std::getenv(kAdoptTierRefusalMarker);
|
||||
if (tier == nullptr || tier[0] == '\0') {
|
||||
GTEST_SKIP() << "runs only in the `.AdoptTier0.` tcp entries, which set "
|
||||
"MOBILEGL_IPC_ADOPT_TIER=0 and " << kAdoptTierRefusalMarker << "=T0";
|
||||
}
|
||||
if (PipeStatsWindow::LibraryLogPath().empty()) {
|
||||
GTEST_SKIP() << "the lane configured no MOBILEGL_LOG_FILE_PATH, and the client's log is "
|
||||
"where the refusal is written";
|
||||
}
|
||||
// A frame of the arena's work first: a refusal is only worth reading from a session that
|
||||
// then ran - and an armed split lane requires the case to move the record ordinal anyway.
|
||||
UploadQuad(0.f, 1.f, 0.f);
|
||||
DrawQuad();
|
||||
EXPECT_GT(CenterPixel()[1], 200) << "the session that refused the tier did not render";
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
Gl().EndFrame();
|
||||
|
||||
const std::string log = PipeStatsWindow::ReadWholeFile(PipeStatsWindow::LibraryLogPath());
|
||||
const std::string line = std::string("Refuse{AdoptTierOnStream, \"") + tier + "\"}";
|
||||
std::size_t count = 0;
|
||||
for (auto at = log.find(line); at != std::string::npos; at = log.find(line, at + 1)) ++count;
|
||||
RecordProperty("adopt_tier_refusals", static_cast<int>(count));
|
||||
EXPECT_EQ(count, 1u) << "the client names MOBILEGL_IPC_ADOPT_TIER on a stream exactly once, at "
|
||||
"its handshake (" << line << "), in " << PipeStatsWindow::LibraryLogPath();
|
||||
EXPECT_EQ(log.find("Fatal{UnimplementedAdoptTier"), std::string::npos) << log;
|
||||
}
|
||||
|
||||
} // namespace MGITest
|
||||
|
||||
@@ -1,765 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/OversizedRecordingSplitScenario.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
//
|
||||
// Scenario - A FRAME WITH MORE DRAWS THAN ONE COMMAND BUFFER MAY HOLD IS SPLIT, AND LOSES NOTHING.
|
||||
//
|
||||
// DirectVulkan records a frame into one command buffer, and used to submit it only at Present.
|
||||
// A driver keeps a command buffer's GPU memory until the buffer is freed, and the Adreno 830
|
||||
// driver maps that memory into the process in 16 KiB chunks. Minecraft rd12's loading frame
|
||||
// records 981,654 draws (3.1M commands) into one buffer. It grew to ~40k such mappings and
|
||||
// aborted inside the driver's own calloc once vm.max_map_count (65530) was spent. The renderer
|
||||
// now submits the open buffer after MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER draws and goes
|
||||
// on recording into a fresh one (VulkanRenderer::SplitOversizedRecording).
|
||||
//
|
||||
// The first case writes each pixel of a 32x32 target with its own draw and its own uniform
|
||||
// value, so it pins that no draw is lost and no per-draw state is left behind on either side of
|
||||
// a split. The rest put GL state that one draw leaves for a later one ACROSS the split: a depth
|
||||
// occluder, a stencil mark, a blend destination, the samples of a multisample target, an
|
||||
// occlusion or primitives-generated query that is still open, and a transform-feedback capture
|
||||
// that is still active. Each draws its "before" part, then kFillers draws, then its "after"
|
||||
// part. kFillers is more than twice the SplitRecording lane's budget of 64, so at least one
|
||||
// split lands between the two parts wherever the recording's count stood.
|
||||
//
|
||||
// The ambient registrations run the same draws unsplit, because the default budget is far above
|
||||
// any of these frames; that is the control. The DirectVulkan.SplitRecording. entry pins the
|
||||
// budget to 64, and there every case also asserts the renderer's latched MGLOG_I - the one
|
||||
// assertion that is red on a renderer that never splits.
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <iterator>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "../Harness/HeadlessGL.h"
|
||||
#include "../Harness/PipeStatsWindow.h"
|
||||
#include "../Harness/ScenarioFixture.h"
|
||||
|
||||
#ifdef GLAPI
|
||||
#undef GLAPI
|
||||
#endif
|
||||
#define GL_GLEXT_PROTOTYPES
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glcorearb.h>
|
||||
#undef GL_GLEXT_PROTOTYPES
|
||||
|
||||
namespace MGITest {
|
||||
namespace {
|
||||
|
||||
constexpr int kSide = 32;
|
||||
constexpr int kDraws = kSide * kSide;
|
||||
// More than twice the SplitRecording lane's budget (64): wherever the count stands when
|
||||
// they start, at least one split lands among them.
|
||||
constexpr int kFillers = 150;
|
||||
// Draws inside the query and capture spans: also more than twice the budget.
|
||||
constexpr int kSpanDraws = 200;
|
||||
|
||||
// aPos spans the unit square; the uniform moves it onto cell (i % 32, i / 32) of a
|
||||
// 32x32 grid, which is exactly one pixel of a 32x32 target.
|
||||
constexpr const char* kVS = R"(#version 330 core
|
||||
in vec2 aPos;
|
||||
uniform int uIndex;
|
||||
void main() {
|
||||
vec2 cell = vec2(float(uIndex % 32), float(uIndex / 32));
|
||||
gl_Position = vec4((cell + aPos) / 16.0 - 1.0, 0.0, 1.0);
|
||||
}
|
||||
)";
|
||||
|
||||
// Multiples of 8/255 survive an RGBA8 round trip exactly, so the readback bytes are
|
||||
// (8x, 8y, 255, 255) for the pixel at (x, y) and nothing else can produce them.
|
||||
constexpr const char* kFS = R"(#version 330 core
|
||||
uniform int uIndex;
|
||||
out vec4 o_color;
|
||||
void main() {
|
||||
o_color = vec4(float(uIndex % 32) * 8.0 / 255.0, float(uIndex / 32) * 8.0 / 255.0, 1.0, 1.0);
|
||||
}
|
||||
)";
|
||||
|
||||
// The state cases: the unit-square vertices (or a triangle of them) stretched over an
|
||||
// NDC rectangle at a given depth, in a uniform colour. A zero rectangle makes a
|
||||
// zero-area primitive - a draw that reaches the renderer and rasterizes nothing.
|
||||
constexpr const char* kRectVS = R"(#version 330 core
|
||||
in vec2 aPos;
|
||||
uniform vec4 uRect;
|
||||
uniform float uDepth;
|
||||
void main() { gl_Position = vec4(mix(uRect.xy, uRect.zw, aPos), uDepth, 1.0); }
|
||||
)";
|
||||
constexpr const char* kRectFS = R"(#version 330 core
|
||||
uniform vec4 uColor;
|
||||
out vec4 o_color;
|
||||
void main() { o_color = uColor; }
|
||||
)";
|
||||
|
||||
// The capture case: one point per draw, carrying 2 * uIndex + 1.
|
||||
constexpr const char* kCaptureVS = R"(#version 330 core
|
||||
uniform int uIndex;
|
||||
out float vs_value;
|
||||
void main() {
|
||||
vs_value = float(uIndex) * 2.0 + 1.0;
|
||||
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
}
|
||||
)";
|
||||
constexpr const char* kCaptureFS = R"(#version 330 core
|
||||
out vec4 o_color;
|
||||
void main() { o_color = vec4(1.0); }
|
||||
)";
|
||||
|
||||
constexpr float kCapturePoison = -12345.0f;
|
||||
|
||||
// The budget the process was launched with, or 0 when it is unset or not a number.
|
||||
unsigned long PinnedDrawBudget() {
|
||||
const char* value = std::getenv("MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER");
|
||||
if (value == nullptr || *value == '\0') return 0;
|
||||
char* end = nullptr;
|
||||
const unsigned long parsed = std::strtoul(value, &end, 10);
|
||||
return (end != nullptr && *end == '\0') ? parsed : 0;
|
||||
}
|
||||
|
||||
// The library log, for the arming assertion. MOBILEGL_LOG_FILE_PATH is read at log-init,
|
||||
// every process in the lane appends to it, and only bytes appended after the snapshot
|
||||
// count. P11 M2: ON A SPLIT BUILD IT IS A BASE NAME - the library writes one file per role
|
||||
// (PipeStatsWindow.h) - and the latched line comes from the RENDERER, which under a
|
||||
// transport is the server role: the apply thread under inproc, the spawned server process
|
||||
// under spawn (it inherits this entry's environment, budget and log base included). So the
|
||||
// mark and the read cover both roles, as PrimitivesGeneratedNoXfbScenario's arming does; a
|
||||
// read of the literal base found no file and reported an unsplit renderer. In the pull
|
||||
// build the client role is the whole log.
|
||||
std::string LibraryLogPath() { return PipeStatsWindow::LibraryLogPath(); }
|
||||
|
||||
PipeStatsWindow::LogMark LibraryLogSize() { return PipeStatsWindow::MarkLaneLog(); }
|
||||
|
||||
std::string LibraryLogSince(const PipeStatsWindow::LogMark& mark) {
|
||||
return PipeStatsWindow::ReadLaneLogSince(mark);
|
||||
}
|
||||
|
||||
std::string Describe(const Rgba8& c) {
|
||||
std::ostringstream os;
|
||||
os << "rgba(" << static_cast<int>(c.r) << ", " << static_cast<int>(c.g) << ", " << static_cast<int>(c.b)
|
||||
<< ", " << static_cast<int>(c.a) << ")";
|
||||
return os.str();
|
||||
}
|
||||
|
||||
::testing::AssertionResult EveryPixelHoldsItsOwnDraw(const Image& image) {
|
||||
int wrong = 0;
|
||||
int firstX = -1, firstY = -1;
|
||||
Rgba8 firstSeen{};
|
||||
for (int y = 0; y < kSide; ++y) {
|
||||
for (int x = 0; x < kSide; ++x) {
|
||||
const Rgba8 expected{static_cast<std::uint8_t>(8 * x), static_cast<std::uint8_t>(8 * y), 255, 255};
|
||||
const Rgba8 seen = image.At(x, y);
|
||||
if (seen != expected) {
|
||||
if (wrong == 0) {
|
||||
firstX = x;
|
||||
firstY = y;
|
||||
firstSeen = seen;
|
||||
}
|
||||
++wrong;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (wrong == 0) {
|
||||
return ::testing::AssertionSuccess();
|
||||
}
|
||||
return ::testing::AssertionFailure()
|
||||
<< wrong << " of " << kDraws << " pixels do not hold their own draw's colour. First: (" << firstX
|
||||
<< ", " << firstY << ") = " << firstSeen << ", drawn by draw " << (firstY * kSide + firstX)
|
||||
<< " (a pixel no draw reached still holds the clear colour 0,0,0,0)";
|
||||
}
|
||||
|
||||
// Every pixel of columns [x0, x1] (all rows) is `expected`, each channel within `tolerance`.
|
||||
::testing::AssertionResult ColumnsAre(const Image& image, int x0, int x1, const Rgba8& expected,
|
||||
int tolerance, const char* what) {
|
||||
int wrong = 0;
|
||||
int firstX = -1, firstY = -1;
|
||||
Rgba8 firstSeen{};
|
||||
for (int y = 0; y < kSide; ++y) {
|
||||
for (int x = x0; x <= x1; ++x) {
|
||||
const Rgba8 seen = image.At(x, y);
|
||||
const bool close = std::abs(seen.r - expected.r) <= tolerance &&
|
||||
std::abs(seen.g - expected.g) <= tolerance &&
|
||||
std::abs(seen.b - expected.b) <= tolerance &&
|
||||
std::abs(seen.a - expected.a) <= tolerance;
|
||||
if (!close) {
|
||||
if (wrong == 0) {
|
||||
firstX = x;
|
||||
firstY = y;
|
||||
firstSeen = seen;
|
||||
}
|
||||
++wrong;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (wrong == 0) return ::testing::AssertionSuccess();
|
||||
return ::testing::AssertionFailure()
|
||||
<< what << ": " << wrong << " pixels of columns " << x0 << ".." << x1 << " are not "
|
||||
<< Describe(expected) << "; first (" << firstX << ", " << firstY << ") = " << Describe(firstSeen);
|
||||
}
|
||||
|
||||
class OversizedRecordingSplitScenario : public ScenarioTest {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
ScenarioTest::SetUp();
|
||||
if (!Ready()) return;
|
||||
// Taken before the case draws anything, so the line the arming check looks for
|
||||
// can only have been written by this case. The renderer latches it at its first
|
||||
// split, and ctest gives every case a process of its own.
|
||||
m_logBefore = LibraryLogSize();
|
||||
|
||||
// 0..3: the unit square as a strip. 4..6: its lower-left triangle. 7..9: its
|
||||
// upper-right triangle - the two share the diagonal, so together they cover every
|
||||
// sample of the square exactly once.
|
||||
static const float kVertices[] = {0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
|
||||
1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f};
|
||||
glGenVertexArrays(1, &m_vao);
|
||||
glBindVertexArray(m_vao);
|
||||
glGenBuffers(1, &m_vbo);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
|
||||
glBufferData(GL_ARRAY_BUFFER, sizeof(kVertices), kVertices, GL_STATIC_DRAW);
|
||||
glEnableVertexAttribArray(0);
|
||||
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), nullptr);
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
if (Ready()) {
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
glDisable(GL_STENCIL_TEST);
|
||||
glDisable(GL_BLEND);
|
||||
glDisable(GL_RASTERIZER_DISCARD);
|
||||
glDepthMask(GL_TRUE);
|
||||
glStencilMask(0xFF);
|
||||
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
||||
glUseProgram(0);
|
||||
glBindVertexArray(0);
|
||||
BindDefaultFramebuffer();
|
||||
if (m_rectProgram != 0) glDeleteProgram(m_rectProgram);
|
||||
if (m_vbo != 0) glDeleteBuffers(1, &m_vbo);
|
||||
if (m_vao != 0) glDeleteVertexArrays(1, &m_vao);
|
||||
for (GLuint rbo : m_renderbuffers) glDeleteRenderbuffers(1, &rbo);
|
||||
for (GLuint fbo : m_framebuffers) glDeleteFramebuffers(1, &fbo);
|
||||
for (ColorFbo& target : m_colorTargets) DestroyColorFbo(target);
|
||||
}
|
||||
ScenarioTest::TearDown();
|
||||
}
|
||||
|
||||
// In the SplitRecording lane (budget pinned below what every case draws, DirectVulkan,
|
||||
// a log to read), a split must have happened during this case. Elsewhere this case is
|
||||
// the unsplit control and there is nothing to arm.
|
||||
void ExpectTheRecordingWasSplitWhereTheBudgetIsPinned() {
|
||||
const unsigned long budget = PinnedDrawBudget();
|
||||
const bool splitExpected = budget > 0 && budget * 2 < static_cast<unsigned long>(kFillers) &&
|
||||
Gl().BackendName() == std::string("DirectVulkan") &&
|
||||
!LibraryLogPath().empty();
|
||||
RecordProperty("arming_checked", splitExpected ? "yes" : "no");
|
||||
if (!splitExpected) return;
|
||||
const std::string appended = LibraryLogSince(m_logBefore);
|
||||
EXPECT_NE(appended.find("draws into one command buffer; submitting it"), std::string::npos)
|
||||
<< "MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER=" << budget << " and this case recorded more "
|
||||
<< "than " << kFillers << " draws in one frame, but DirectVulkan never reported splitting the "
|
||||
"recording. A renderer that does not split grows a single command buffer without bound "
|
||||
"(rd12 on Adreno: ~40k driver mappings, then SIGABRT). See "
|
||||
"VulkanRenderer::SplitOversizedRecording. Log appended by this case:\n"
|
||||
<< appended;
|
||||
}
|
||||
|
||||
bool BuildRectProgram(std::string* error) {
|
||||
m_rectProgram = CompileProgram(kRectVS, kRectFS, error);
|
||||
if (m_rectProgram == 0) return false;
|
||||
m_rectLoc = glGetUniformLocation(m_rectProgram, "uRect");
|
||||
m_depthLoc = glGetUniformLocation(m_rectProgram, "uDepth");
|
||||
m_colorLoc = glGetUniformLocation(m_rectProgram, "uColor");
|
||||
glUseProgram(m_rectProgram);
|
||||
glBindVertexArray(m_vao);
|
||||
return true;
|
||||
}
|
||||
|
||||
// The rectangle [x0, x1] x [y0, y1] in NDC; `first`/`count` pick the strip or a triangle.
|
||||
void DrawRect(float x0, float y0, float x1, float y1, float depth, float r, float g, float b, float a,
|
||||
GLenum mode = GL_TRIANGLE_STRIP, GLint first = 0, GLsizei count = 4) {
|
||||
glUniform4f(m_rectLoc, x0, y0, x1, y1);
|
||||
glUniform1f(m_depthLoc, depth);
|
||||
glUniform4f(m_colorLoc, r, g, b, a);
|
||||
glDrawArrays(mode, first, count);
|
||||
}
|
||||
|
||||
// One pixel of the 32x32 grid, by index.
|
||||
void DrawPixel(int index, float r, float g, float b, float a) {
|
||||
const float x = static_cast<float>(index % kSide);
|
||||
const float y = static_cast<float>(index / kSide);
|
||||
DrawRect(x / 16.0f - 1.0f, y / 16.0f - 1.0f, (x + 1.0f) / 16.0f - 1.0f, (y + 1.0f) / 16.0f - 1.0f, 0.0f,
|
||||
r, g, b, a);
|
||||
}
|
||||
|
||||
// Draws that reach the renderer and rasterize nothing: zero-area strips.
|
||||
void DrawFillers(int count) {
|
||||
for (int i = 0; i < count; ++i) {
|
||||
DrawRect(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
}
|
||||
|
||||
// A kSide x kSide RGBA8 target, optionally with a DEPTH24_STENCIL8 renderbuffer.
|
||||
// Returns fbo 0 when the driver will not complete it.
|
||||
ColorFbo MakeTarget(bool withDepthStencil) {
|
||||
ColorFbo target = MakeColorFbo(kSide, kSide);
|
||||
if (target.fbo == 0) return target;
|
||||
m_colorTargets.push_back(target);
|
||||
if (withDepthStencil) {
|
||||
GLuint rbo = 0;
|
||||
glGenRenderbuffers(1, &rbo);
|
||||
m_renderbuffers.push_back(rbo);
|
||||
glBindRenderbuffer(GL_RENDERBUFFER, rbo);
|
||||
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, kSide, kSide);
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, target.fbo);
|
||||
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo);
|
||||
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
|
||||
target.fbo = 0;
|
||||
}
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
||||
Image ReadTarget(const ColorFbo& target) {
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, target.fbo);
|
||||
return ReadPixels(kSide, kSide);
|
||||
}
|
||||
|
||||
PipeStatsWindow::LogMark m_logBefore{};
|
||||
GLuint m_vao = 0;
|
||||
GLuint m_vbo = 0;
|
||||
GLuint m_rectProgram = 0;
|
||||
GLint m_rectLoc = -1;
|
||||
GLint m_depthLoc = -1;
|
||||
GLint m_colorLoc = -1;
|
||||
std::vector<ColorFbo> m_colorTargets;
|
||||
std::vector<GLuint> m_renderbuffers;
|
||||
std::vector<GLuint> m_framebuffers;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
// kDraws single-pixel quads into a fresh target, one uniform value per draw, with no
|
||||
// readback, flush or rebind in between. Every pixel must hold its own draw's colour.
|
||||
TEST_F(OversizedRecordingSplitScenario, EveryDrawOfTheFrameLandsAcrossCommandBufferSplits) {
|
||||
if (!Ready()) return;
|
||||
|
||||
std::string error;
|
||||
const unsigned int program = CompileProgram(kVS, kFS, &error);
|
||||
ASSERT_NE(program, 0u) << error;
|
||||
ColorFbo target = MakeTarget(false);
|
||||
ASSERT_NE(target.fbo, 0u) << "MakeColorFbo failed";
|
||||
|
||||
BindFbo(target);
|
||||
glDisable(GL_SCISSOR_TEST);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
glDisable(GL_BLEND);
|
||||
ClearTo(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
glUseProgram(program);
|
||||
glBindVertexArray(m_vao);
|
||||
const GLint indexLocation = glGetUniformLocation(program, "uIndex");
|
||||
for (int i = 0; i < kDraws; ++i) {
|
||||
glUniform1i(indexLocation, i);
|
||||
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
|
||||
}
|
||||
const Image image = ReadPixels(kSide, kSide);
|
||||
glUseProgram(0);
|
||||
glDeleteProgram(program);
|
||||
|
||||
EXPECT_TRUE(EveryPixelHoldsItsOwnDraw(image));
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
ExpectTheRecordingWasSplitWhereTheBudgetIsPinned();
|
||||
}
|
||||
|
||||
// (a) An occluder drawn before the split must still fail the depth test of a draw after it:
|
||||
// the depth attachment's contents have to survive the render pass ending and re-beginning.
|
||||
TEST_F(OversizedRecordingSplitScenario, ADepthOccluderDrawnBeforeTheSplitHidesADrawAfterIt) {
|
||||
if (!Ready()) return;
|
||||
std::string error;
|
||||
ASSERT_TRUE(BuildRectProgram(&error)) << error;
|
||||
ColorFbo target = MakeTarget(true);
|
||||
if (target.fbo == 0) GTEST_SKIP() << "no complete RGBA8 + DEPTH24_STENCIL8 target on this driver";
|
||||
|
||||
BindFbo(target);
|
||||
glClearDepth(1.0);
|
||||
ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glDepthFunc(GL_LESS);
|
||||
glDepthMask(GL_TRUE);
|
||||
|
||||
DrawRect(-1.0f, -1.0f, 0.0f, 1.0f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f); // left half, near, red
|
||||
DrawFillers(kFillers);
|
||||
DrawRect(-1.0f, -1.0f, 1.0f, 1.0f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f); // everything, far, green
|
||||
|
||||
const Image image = ReadTarget(target);
|
||||
EXPECT_TRUE(ColumnsAre(image, 0, kSide / 2 - 1, Rgba8{255, 0, 0, 255}, 0,
|
||||
"the near occluder drawn before the split must hide the far draw after it"));
|
||||
EXPECT_TRUE(ColumnsAre(image, kSide / 2, kSide - 1, Rgba8{0, 255, 0, 255}, 0,
|
||||
"where nothing occludes, the far draw after the split must land"));
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
ExpectTheRecordingWasSplitWhereTheBudgetIsPinned();
|
||||
}
|
||||
|
||||
// (b) A stencil mark made before the split must gate a draw after it.
|
||||
TEST_F(OversizedRecordingSplitScenario, AStencilMarkMadeBeforeTheSplitGatesADrawAfterIt) {
|
||||
if (!Ready()) return;
|
||||
std::string error;
|
||||
ASSERT_TRUE(BuildRectProgram(&error)) << error;
|
||||
ColorFbo target = MakeTarget(true);
|
||||
if (target.fbo == 0) GTEST_SKIP() << "no complete RGBA8 + DEPTH24_STENCIL8 target on this driver";
|
||||
|
||||
BindFbo(target);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
glStencilMask(0xFF);
|
||||
glClearStencil(0);
|
||||
glClear(GL_STENCIL_BUFFER_BIT);
|
||||
ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
|
||||
glEnable(GL_STENCIL_TEST);
|
||||
|
||||
glStencilFunc(GL_ALWAYS, 1, 0xFF);
|
||||
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
|
||||
DrawRect(-1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f); // left half: stencil 1, blue
|
||||
glStencilFunc(GL_EQUAL, 1, 0xFF);
|
||||
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
|
||||
DrawFillers(kFillers);
|
||||
DrawRect(-1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f); // everything, green, where stencil == 1
|
||||
|
||||
const Image image = ReadTarget(target);
|
||||
EXPECT_TRUE(ColumnsAre(image, 0, kSide / 2 - 1, Rgba8{0, 255, 0, 255}, 0,
|
||||
"where the mark was made before the split, the draw after it must pass"));
|
||||
EXPECT_TRUE(ColumnsAre(image, kSide / 2, kSide - 1, Rgba8{0, 0, 0, 255}, 0,
|
||||
"where no mark was made, the draw after the split must be stencilled out"));
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
ExpectTheRecordingWasSplitWhereTheBudgetIsPinned();
|
||||
}
|
||||
|
||||
// (c) Additive blending onto pixels written before the split: every one of kSpanDraws
|
||||
// full-target draws adds exactly 1/255 of red onto a target whose green was written first,
|
||||
// so the result counts every draw on both sides of every split.
|
||||
TEST_F(OversizedRecordingSplitScenario, BlendingAccumulatesOntoPixelsWrittenBeforeTheSplit) {
|
||||
if (!Ready()) return;
|
||||
std::string error;
|
||||
ASSERT_TRUE(BuildRectProgram(&error)) << error;
|
||||
ColorFbo target = MakeTarget(false);
|
||||
ASSERT_NE(target.fbo, 0u) << "MakeColorFbo failed";
|
||||
|
||||
BindFbo(target);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
ClearTo(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
glEnable(GL_BLEND);
|
||||
glBlendEquation(GL_FUNC_ADD);
|
||||
glBlendFunc(GL_ONE, GL_ONE);
|
||||
|
||||
DrawRect(-1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 55.0f / 255.0f, 0.0f, 0.0f);
|
||||
for (int i = 0; i < kSpanDraws; ++i) {
|
||||
DrawRect(-1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f / 255.0f, 0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
|
||||
const Image image = ReadTarget(target);
|
||||
EXPECT_TRUE(ColumnsAre(image, 0, kSide - 1, Rgba8{static_cast<std::uint8_t>(kSpanDraws), 55, 0, 0}, 1,
|
||||
"every additive draw, and the green written before any split, must be in the sum"));
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
ExpectTheRecordingWasSplitWhereTheBudgetIsPinned();
|
||||
}
|
||||
|
||||
// (d) A multisample target drawn on both sides of the split, then resolved. Before the
|
||||
// split a triangle covers the lower-left half of the target; after it, the complementary
|
||||
// triangle covers the upper-right half. On the diagonal each pixel's samples are shared
|
||||
// between the two, so only a target that kept every SAMPLE across the split resolves them to
|
||||
// red + green = 255. One that was resolved or re-broadcast at the split gives about 190
|
||||
// there, and one whose samples were dropped gives black or garbage.
|
||||
TEST_F(OversizedRecordingSplitScenario, AMultisampleTargetKeepsItsSamplesAcrossTheSplit) {
|
||||
if (!Ready()) return;
|
||||
std::string error;
|
||||
ASSERT_TRUE(BuildRectProgram(&error)) << error;
|
||||
|
||||
GLint maxSamples = 0;
|
||||
glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);
|
||||
if (maxSamples < 2) {
|
||||
GTEST_SKIP() << "GL_MAX_SAMPLES is " << maxSamples << "; this needs a multisample renderbuffer";
|
||||
}
|
||||
const GLsizei samples = std::min<GLint>(4, maxSamples);
|
||||
GLuint msFbo = 0, msRbo = 0;
|
||||
glGenFramebuffers(1, &msFbo);
|
||||
m_framebuffers.push_back(msFbo);
|
||||
glGenRenderbuffers(1, &msRbo);
|
||||
m_renderbuffers.push_back(msRbo);
|
||||
glBindRenderbuffer(GL_RENDERBUFFER, msRbo);
|
||||
glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples, GL_RGBA8, kSide, kSide);
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, msFbo);
|
||||
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, msRbo);
|
||||
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
|
||||
GTEST_SKIP() << "no complete " << samples << "x multisample RGBA8 renderbuffer on this driver";
|
||||
}
|
||||
ColorFbo resolved = MakeTarget(false);
|
||||
ASSERT_NE(resolved.fbo, 0u) << "MakeColorFbo failed";
|
||||
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, msFbo);
|
||||
glViewport(0, 0, kSide, kSide);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
|
||||
DrawRect(-1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, GL_TRIANGLES, 4, 3); // lower-left, red
|
||||
DrawFillers(kFillers);
|
||||
DrawRect(-1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, GL_TRIANGLES, 7, 3); // upper-right, green
|
||||
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, msFbo);
|
||||
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, resolved.fbo);
|
||||
glBlitFramebuffer(0, 0, kSide, kSide, 0, 0, kSide, kSide, GL_COLOR_BUFFER_BIT, GL_NEAREST);
|
||||
const Image image = ReadTarget(resolved);
|
||||
|
||||
int wrong = 0;
|
||||
std::string first;
|
||||
for (int y = 0; y < kSide && wrong < 1000; ++y) {
|
||||
for (int x = 0; x < kSide; ++x) {
|
||||
const Rgba8 seen = image.At(x, y);
|
||||
bool ok = false;
|
||||
// The diagonal x + y = kSide in pixel units passes through the pixels whose
|
||||
// x + y == kSide - 1; every other pixel lies wholly on one side of it.
|
||||
if (x + y < kSide - 1) {
|
||||
ok = seen == Rgba8{255, 0, 0, 255};
|
||||
} else if (x + y > kSide - 1) {
|
||||
ok = seen == Rgba8{0, 255, 0, 255};
|
||||
} else {
|
||||
ok = seen.b == 0 && seen.a == 255 && seen.r > 0 && seen.g > 0 &&
|
||||
std::abs(static_cast<int>(seen.r) + static_cast<int>(seen.g) - 255) <= 3;
|
||||
}
|
||||
if (!ok) {
|
||||
if (wrong == 0) {
|
||||
std::ostringstream os;
|
||||
os << "(" << x << ", " << y << ") = " << Describe(seen);
|
||||
first = os.str();
|
||||
}
|
||||
++wrong;
|
||||
}
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(wrong, 0) << wrong << " resolved pixels are wrong; first " << first
|
||||
<< ". Lower-left of the diagonal must be red, upper-right green, and a pixel on it "
|
||||
"red + green = 255 with both present (its samples were split between a draw before "
|
||||
"the command-buffer split and one after it)";
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
ExpectTheRecordingWasSplitWhereTheBudgetIsPinned();
|
||||
}
|
||||
|
||||
// (e) Occlusion queries open across the split. GL_SAMPLES_PASSED counts kSpanDraws
|
||||
// single-pixel draws on both sides of it; GL_ANY_SAMPLES_PASSED is answered by the one draw
|
||||
// made before the split, the fillers after it pass nothing - with a fillers-only control
|
||||
// that must answer false.
|
||||
TEST_F(OversizedRecordingSplitScenario, OcclusionQueriesOpenAcrossTheSplitCountBothSides) {
|
||||
if (!Ready()) return;
|
||||
std::string error;
|
||||
ASSERT_TRUE(BuildRectProgram(&error)) << error;
|
||||
ColorFbo target = MakeTarget(false);
|
||||
ASSERT_NE(target.fbo, 0u) << "MakeColorFbo failed";
|
||||
BindFbo(target);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
|
||||
|
||||
GLuint queries[3] = {};
|
||||
glGenQueries(3, queries);
|
||||
FirstGLError();
|
||||
|
||||
// Any samples: control first (fillers only), then one real pixel before the split.
|
||||
glBeginQuery(GL_ANY_SAMPLES_PASSED, queries[0]);
|
||||
const unsigned int anyBeginError = FirstGLError();
|
||||
if (anyBeginError != 0u) {
|
||||
glDeleteQueries(3, queries);
|
||||
GTEST_SKIP() << Gl().BackendName() << " does not accept GL_ANY_SAMPLES_PASSED ("
|
||||
<< GLErrorName(anyBeginError) << ")";
|
||||
}
|
||||
DrawFillers(kFillers);
|
||||
glEndQuery(GL_ANY_SAMPLES_PASSED);
|
||||
glBeginQuery(GL_ANY_SAMPLES_PASSED, queries[1]);
|
||||
DrawPixel(0, 1.0f, 1.0f, 1.0f, 1.0f);
|
||||
DrawFillers(kFillers);
|
||||
glEndQuery(GL_ANY_SAMPLES_PASSED);
|
||||
GLuint anyControl = 7, anyAcross = 7;
|
||||
glGetQueryObjectuiv(queries[0], GL_QUERY_RESULT, &anyControl);
|
||||
glGetQueryObjectuiv(queries[1], GL_QUERY_RESULT, &anyAcross);
|
||||
EXPECT_EQ(anyControl, static_cast<GLuint>(GL_FALSE)) << "fillers alone rasterize nothing";
|
||||
EXPECT_EQ(anyAcross, static_cast<GLuint>(GL_TRUE))
|
||||
<< "the only passing draw was made before the split; the query that spans it lost that answer";
|
||||
|
||||
// Samples passed: kSpanDraws distinct single-sample pixels, spanning at least one split.
|
||||
glBeginQuery(GL_SAMPLES_PASSED, queries[2]);
|
||||
const unsigned int samplesBeginError = FirstGLError();
|
||||
if (samplesBeginError == 0u) {
|
||||
for (int i = 0; i < kSpanDraws; ++i) {
|
||||
DrawPixel(i, 1.0f, 1.0f, 1.0f, 1.0f);
|
||||
}
|
||||
glEndQuery(GL_SAMPLES_PASSED);
|
||||
GLuint samplesPassed = 0;
|
||||
glGetQueryObjectuiv(queries[2], GL_QUERY_RESULT, &samplesPassed);
|
||||
if (Gl().BackendName() == std::string("DirectGLES")) {
|
||||
// OpenGL ES has no sample-counting occlusion query, only ANY_SAMPLES_PASSED*, so
|
||||
// DirectGLES answers GL_SAMPLES_PASSED with a 0/1 approximation (DirectGLES.cpp,
|
||||
// the occlusion-query result path). The exact count is not this backend's to give.
|
||||
RecordProperty("samples_passed", "0/1 approximation on OpenGL ES; exact count not checked");
|
||||
EXPECT_EQ(samplesPassed, 1u) << "samples passed, so the approximation must read 1";
|
||||
} else {
|
||||
EXPECT_EQ(samplesPassed, static_cast<GLuint>(kSpanDraws))
|
||||
<< "each of the " << kSpanDraws << " draws covers exactly one single-sample pixel";
|
||||
}
|
||||
} else {
|
||||
RecordProperty("samples_passed", std::string("not accepted: ") + GLErrorName(samplesBeginError));
|
||||
}
|
||||
glDeleteQueries(3, queries);
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
ExpectTheRecordingWasSplitWhereTheBudgetIsPinned();
|
||||
}
|
||||
|
||||
// (e) GL_PRIMITIVES_GENERATED open across the split: kSpanDraws strips of two triangles.
|
||||
// A one-draw query first establishes that this stack counts at all.
|
||||
TEST_F(OversizedRecordingSplitScenario, APrimitivesGeneratedQueryOpenAcrossTheSplitCountsBothSides) {
|
||||
if (!Ready()) return;
|
||||
std::string error;
|
||||
ASSERT_TRUE(BuildRectProgram(&error)) << error;
|
||||
ColorFbo target = MakeTarget(false);
|
||||
ASSERT_NE(target.fbo, 0u) << "MakeColorFbo failed";
|
||||
BindFbo(target);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
|
||||
|
||||
GLuint queries[2] = {};
|
||||
glGenQueries(2, queries);
|
||||
FirstGLError();
|
||||
glBeginQuery(GL_PRIMITIVES_GENERATED, queries[0]);
|
||||
const unsigned int beginError = FirstGLError();
|
||||
if (beginError != 0u) {
|
||||
glDeleteQueries(2, queries);
|
||||
GTEST_SKIP() << Gl().BackendName() << " does not accept GL_PRIMITIVES_GENERATED ("
|
||||
<< GLErrorName(beginError) << ")";
|
||||
}
|
||||
DrawPixel(0, 1.0f, 1.0f, 1.0f, 1.0f);
|
||||
glEndQuery(GL_PRIMITIVES_GENERATED);
|
||||
GLuint control = 0;
|
||||
glGetQueryObjectuiv(queries[0], GL_QUERY_RESULT, &control);
|
||||
if (control == 0u) {
|
||||
glDeleteQueries(2, queries);
|
||||
GTEST_SKIP() << "GL_PRIMITIVES_GENERATED reads 0 for a single unsplit strip on " << Gl().BackendName()
|
||||
<< " (" << Gl().RendererString() << "): nothing this stack counts, so nothing to carry";
|
||||
}
|
||||
ASSERT_EQ(control, 2u) << "one strip of four vertices is two triangles";
|
||||
|
||||
glBeginQuery(GL_PRIMITIVES_GENERATED, queries[1]);
|
||||
for (int i = 0; i < kSpanDraws; ++i) {
|
||||
DrawPixel(i, 1.0f, 1.0f, 1.0f, 1.0f);
|
||||
}
|
||||
glEndQuery(GL_PRIMITIVES_GENERATED);
|
||||
GLuint generated = 0;
|
||||
glGetQueryObjectuiv(queries[1], GL_QUERY_RESULT, &generated);
|
||||
EXPECT_EQ(generated, static_cast<GLuint>(2 * kSpanDraws))
|
||||
<< kSpanDraws << " strips of two triangles each, drawn across at least one split";
|
||||
glDeleteQueries(2, queries);
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
ExpectTheRecordingWasSplitWhereTheBudgetIsPinned();
|
||||
}
|
||||
|
||||
// (f) Transform feedback active across the split: kSpanDraws one-point draws, draw i
|
||||
// capturing 2i + 1, must append in order into one buffer with nothing past the end, and
|
||||
// GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN must count every one.
|
||||
TEST_F(OversizedRecordingSplitScenario, ATransformFeedbackCaptureActiveAcrossTheSplitAppendsEveryDraw) {
|
||||
if (!Ready()) return;
|
||||
|
||||
auto compile = [](GLenum stage, const char* source, std::string* log) -> GLuint {
|
||||
const GLuint shader = glCreateShader(stage);
|
||||
glShaderSource(shader, 1, &source, nullptr);
|
||||
glCompileShader(shader);
|
||||
GLint ok = 0;
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
|
||||
if (!ok) {
|
||||
char buffer[2048] = {};
|
||||
glGetShaderInfoLog(shader, sizeof(buffer) - 1, nullptr, buffer);
|
||||
*log = buffer;
|
||||
glDeleteShader(shader);
|
||||
return 0;
|
||||
}
|
||||
return shader;
|
||||
};
|
||||
std::string log;
|
||||
const GLuint vs = compile(GL_VERTEX_SHADER, kCaptureVS, &log);
|
||||
ASSERT_NE(vs, 0u) << log;
|
||||
const GLuint fs = compile(GL_FRAGMENT_SHADER, kCaptureFS, &log);
|
||||
ASSERT_NE(fs, 0u) << log;
|
||||
const GLuint program = glCreateProgram();
|
||||
glAttachShader(program, vs);
|
||||
glAttachShader(program, fs);
|
||||
const char* varyings[] = {"vs_value"};
|
||||
glTransformFeedbackVaryings(program, 1, varyings, GL_INTERLEAVED_ATTRIBS);
|
||||
glLinkProgram(program);
|
||||
glDeleteShader(vs);
|
||||
glDeleteShader(fs);
|
||||
GLint linked = 0;
|
||||
glGetProgramiv(program, GL_LINK_STATUS, &linked);
|
||||
if (!linked) {
|
||||
char buffer[2048] = {};
|
||||
glGetProgramInfoLog(program, sizeof(buffer) - 1, nullptr, buffer);
|
||||
glDeleteProgram(program);
|
||||
FAIL() << "capture program failed to link: " << buffer;
|
||||
}
|
||||
|
||||
constexpr int kSlack = 4;
|
||||
std::vector<float> poison(kSpanDraws + kSlack, kCapturePoison);
|
||||
GLuint buffer = 0;
|
||||
glGenBuffers(1, &buffer);
|
||||
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buffer);
|
||||
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, static_cast<GLsizeiptr>(poison.size() * sizeof(float)),
|
||||
poison.data(), GL_STATIC_COPY);
|
||||
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buffer);
|
||||
GLuint written = 0;
|
||||
glGenQueries(1, &written);
|
||||
|
||||
glUseProgram(program);
|
||||
glBindVertexArray(m_vao);
|
||||
const GLint indexLocation = glGetUniformLocation(program, "uIndex");
|
||||
glEnable(GL_RASTERIZER_DISCARD);
|
||||
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, written);
|
||||
glBeginTransformFeedback(GL_POINTS);
|
||||
for (int i = 0; i < kSpanDraws; ++i) {
|
||||
glUniform1i(indexLocation, i);
|
||||
glDrawArrays(GL_POINTS, 0, 1);
|
||||
}
|
||||
glEndTransformFeedback();
|
||||
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
|
||||
glDisable(GL_RASTERIZER_DISCARD);
|
||||
glUseProgram(0);
|
||||
|
||||
GLuint primitivesWritten = 0;
|
||||
glGetQueryObjectuiv(written, GL_QUERY_RESULT, &primitivesWritten);
|
||||
std::vector<float> captured(poison.size(), 0.0f);
|
||||
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buffer);
|
||||
glGetBufferSubData(GL_TRANSFORM_FEEDBACK_BUFFER, 0, static_cast<GLsizeiptr>(captured.size() * sizeof(float)),
|
||||
captured.data());
|
||||
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
|
||||
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, 0);
|
||||
glDeleteQueries(1, &written);
|
||||
glDeleteBuffers(1, &buffer);
|
||||
glDeleteProgram(program);
|
||||
|
||||
EXPECT_EQ(primitivesWritten, static_cast<GLuint>(kSpanDraws));
|
||||
int wrong = 0;
|
||||
std::string first;
|
||||
for (int i = 0; i < static_cast<int>(captured.size()); ++i) {
|
||||
const float expected = i < kSpanDraws ? static_cast<float>(2 * i + 1) : kCapturePoison;
|
||||
if (captured[i] != expected) {
|
||||
if (wrong == 0) {
|
||||
std::ostringstream os;
|
||||
os << "record " << i << " = " << captured[i] << ", expected " << expected;
|
||||
first = os.str();
|
||||
}
|
||||
++wrong;
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(wrong, 0) << wrong << " of " << captured.size() << " records are wrong; first " << first
|
||||
<< " (records past " << kSpanDraws << " must keep the poison)";
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
ExpectTheRecordingWasSplitWhereTheBudgetIsPinned();
|
||||
}
|
||||
|
||||
} // namespace MGITest
|
||||
@@ -33,7 +33,7 @@
|
||||
// must see it too.
|
||||
// M-A Nothing produced kMGPipeBindSampler / kMGPipeBindShaderImage, so ImageBindableHint was
|
||||
// dead: the applier never saw a texture become image-bound, the metadata respecify
|
||||
// (ID-18 M4) had no live trigger, and the re-mint the hint exists to prevent was
|
||||
// (ID-18 M4) had no live trigger, and the remint pull the hint exists to prevent was
|
||||
// neither prevented nor counted. The case here reads the applier's record around a
|
||||
// glBindImageTexture: the hint arrives as a metadata update that keeps the pending upload
|
||||
// standing beside it, and the picture after the transition is the texels that upload
|
||||
@@ -537,12 +537,9 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
return;
|
||||
}
|
||||
|
||||
// THE NUMBER ROADMAP OPEN QUESTION 2 ASKS FOR, on a texture Espryt allocated BEFORE the
|
||||
// hint reached it. An immutable RGBA8 allocation is already what an image unit needs,
|
||||
// so neither arm re-mints it and the counter does not move: the server has kept it
|
||||
// since P9 W2, and the monolith re-mint has had the same keep path since dev's
|
||||
// 568090f0 (merged in P11 M), where it used to re-mint from the shadow and count one.
|
||||
// A counted re-mint is TextureRemintPullScenario's A and H. Arming the counter here is
|
||||
// THE NUMBER ROADMAP OPEN QUESTION 2 ASKS FOR: a texture Espryt allocated BEFORE the
|
||||
// hint reached it is re-minted image-bindable at the bind and its levels replayed
|
||||
// from the client's shadow - one remint pull, counted. Arming the counter here is
|
||||
// what makes it readable without a stats-enabled lane.
|
||||
unsigned long long pullsBefore = 0;
|
||||
const bool pullsReadable = PeekPipeStatsTextureRemintPulls(&pullsBefore);
|
||||
@@ -583,10 +580,11 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
|
||||
// THE TRANSITION. An immutable texture has no storage-defining respecify left, so the
|
||||
// hint can only arrive as a metadata update (ID-18 M4). Espryt syncs the texture
|
||||
// eagerly inside glBindImageTexture and KEEPS the allocation (above), so the standing
|
||||
// upload is consumed by the kept storage's own sync and the picture that follows is
|
||||
// blue - the KEPT property of the record is proved further down, on a texture that is
|
||||
// image-bindable already.
|
||||
// eagerly inside glBindImageTexture and the widening re-mints its storage, replaying
|
||||
// every defined level from the shadow (the remint pull the counter below counts), so
|
||||
// the standing upload is consumed by that regeneration here and the picture that
|
||||
// follows is blue whatever the metadata respecify did to the record - the KEPT
|
||||
// property is proved further down, on a texture no remint stands in front of.
|
||||
(void)uploadsBeforeBind;
|
||||
(void)uploadsReadable;
|
||||
glBindImageTexture(0, texture, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
|
||||
@@ -610,10 +608,14 @@ void main() { oColor = texture(uTex, vUv); }
|
||||
const auto runtime = PeekSplitRuntime();
|
||||
if (runtime.transportResolved && runtime.transportName == "inproc") {
|
||||
ASSERT_TRUE(runtime.sessionActive);
|
||||
EXPECT_EQ(pullsAfter, pullsBefore)
|
||||
<< "the server must preserve this already immutable RGBA8 allocation; "
|
||||
"image binding needs no remint pull";
|
||||
} else {
|
||||
EXPECT_EQ(pullsAfter, pullsBefore + 1)
|
||||
<< "the monolith re-mint of a texture allocated before its hint was not counted "
|
||||
"as a remint pull (trp= on the stats line is ROADMAP open question 2's number)";
|
||||
}
|
||||
EXPECT_EQ(pullsAfter, pullsBefore)
|
||||
<< "an already immutable RGBA8 allocation must be kept on every arm; image binding "
|
||||
"needs no re-mint (trp= on the stats line is ROADMAP open question 2's number)";
|
||||
}
|
||||
|
||||
// THE PREVENTION HALF, measured the other way round: a texture whose hint arrives at
|
||||
|
||||
@@ -1,454 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/PackBufferReadbackScenario.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
//
|
||||
// P9 (W1, MG_Remote/CONTRACT-P9.md §1): READS INTO A PIXEL PACK BUFFER ARE ANSWERED BY NOTHING.
|
||||
//
|
||||
// Under a transport a glReadPixels / glGetTexImage whose destination is a bound
|
||||
// GL_PIXEL_PACK_BUFFER no longer waits for its pixels: it crosses as read_pixels_to_buffer /
|
||||
// get_texture_image_to_buffer, the server lands the rows in the buffer at the client's PACK
|
||||
// layout, and the client marks the buffer GPU-written so that the next CPU read of it - a
|
||||
// glGetBufferSubData, a glMapBufferRange, or a texture upload that uses it as the UNPACK source -
|
||||
// fetches the bytes through resource_readback.
|
||||
//
|
||||
// THE CASES ARE ORDINARY GL AND RUN ON THE MONOLITH ARMS TOO. Each one compares the pack buffer
|
||||
// against the same read into client memory under the same pack state, both destinations
|
||||
// pre-filled with the same byte, so the padding the pack state skips has to survive as well: the
|
||||
// monolith and every split arm must agree with themselves, and therefore with each other. The
|
||||
// one exception is the last case, which is about the WIRE (the read posted no reply and marked
|
||||
// the buffer) and skips where there is no wire to ask.
|
||||
//
|
||||
// Every image is POSITION-DEPENDENT, so a row landed at the wrong stride, a band at the wrong
|
||||
// offset or a byte swapped the wrong way cannot look right.
|
||||
|
||||
#include <array>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "../Harness/HeadlessGL.h"
|
||||
#include "../Harness/ScenarioFixture.h"
|
||||
#include "../Harness/SplitRuntimePeek.h"
|
||||
|
||||
#ifdef GLAPI
|
||||
#undef GLAPI
|
||||
#endif
|
||||
#define GL_GLEXT_PROTOTYPES
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glcorearb.h>
|
||||
#undef GL_GLEXT_PROTOTYPES
|
||||
|
||||
namespace MGITest {
|
||||
namespace {
|
||||
|
||||
constexpr GLubyte kFill = 0xAB;
|
||||
|
||||
// A texel that names its own position (and its layer), so nothing misplaced can match.
|
||||
std::array<GLubyte, 4> PatternRgba8(int x, int y, int layer) {
|
||||
return {static_cast<GLubyte>(x * 7 + layer * 31), static_cast<GLubyte>(y * 11 + layer),
|
||||
static_cast<GLubyte>((x ^ y) + layer * 5), static_cast<GLubyte>(0x80 | (x + y))};
|
||||
}
|
||||
|
||||
// Integers below 2^24 in every component, so float storage is exact and a byte swap of
|
||||
// any of them is visibly different from the value.
|
||||
std::array<GLfloat, 4> PatternRgba32f(int x, int y) {
|
||||
return {static_cast<GLfloat>(x + 1), static_cast<GLfloat>(y + 3),
|
||||
static_cast<GLfloat>(x * 64 + y), static_cast<GLfloat>(1000 + x * y)};
|
||||
}
|
||||
|
||||
struct PackState {
|
||||
const char* name;
|
||||
GLint alignment;
|
||||
GLint rowLength;
|
||||
GLint skipPixels;
|
||||
GLint skipRows;
|
||||
GLboolean swapBytes;
|
||||
};
|
||||
|
||||
// Neutral, then each PACK parameter that changes the layout, then all of them at once.
|
||||
constexpr PackState kPackStates[] = {
|
||||
{"neutral", 4, 0, 0, 0, GL_FALSE},
|
||||
{"alignment 1", 1, 0, 0, 0, GL_FALSE},
|
||||
{"alignment 8", 8, 0, 0, 0, GL_FALSE},
|
||||
{"row length 53", 4, 53, 0, 0, GL_FALSE},
|
||||
{"skip pixels 3, skip rows 2", 4, 0, 3, 2, GL_FALSE},
|
||||
{"everything", 8, 47, 5, 3, GL_FALSE},
|
||||
};
|
||||
|
||||
class PackBufferReadbackScenario : public ScenarioTest {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
ScenarioTest::SetUp();
|
||||
if (!Ready()) return;
|
||||
DrainErrors();
|
||||
glGenFramebuffers(1, &m_fbo);
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
|
||||
glDisable(GL_SCISSOR_TEST);
|
||||
ResetPack();
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
if (!Ready()) return;
|
||||
ResetPack();
|
||||
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||||
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
|
||||
for (GLuint buffer : m_buffers) glDeleteBuffers(1, &buffer);
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
||||
if (m_fbo != 0) glDeleteFramebuffers(1, &m_fbo);
|
||||
for (GLuint texture : m_textures) glDeleteTextures(1, &texture);
|
||||
m_buffers.clear();
|
||||
m_textures.clear();
|
||||
m_fbo = 0;
|
||||
DrainErrors();
|
||||
ScenarioTest::TearDown();
|
||||
}
|
||||
|
||||
static void ResetPack() {
|
||||
glPixelStorei(GL_PACK_ALIGNMENT, 4);
|
||||
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
|
||||
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
|
||||
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
|
||||
glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
|
||||
glPixelStorei(GL_PACK_SKIP_IMAGES, 0);
|
||||
glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
||||
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
||||
}
|
||||
|
||||
static void ApplyPack(const PackState& pack) {
|
||||
glPixelStorei(GL_PACK_ALIGNMENT, pack.alignment);
|
||||
glPixelStorei(GL_PACK_ROW_LENGTH, pack.rowLength);
|
||||
glPixelStorei(GL_PACK_SKIP_PIXELS, pack.skipPixels);
|
||||
glPixelStorei(GL_PACK_SKIP_ROWS, pack.skipRows);
|
||||
glPixelStorei(GL_PACK_SWAP_BYTES, pack.swapBytes);
|
||||
}
|
||||
|
||||
static void DrainErrors() {
|
||||
for (int i = 0; i < 16 && glGetError() != GL_NO_ERROR; ++i) {
|
||||
}
|
||||
}
|
||||
|
||||
// The bytes a pack state makes a width x height read occupy, from the first byte the
|
||||
// read may touch (GL 4.6 §8.4.4.1 / §18.2): the skips, then the padded rows, the last
|
||||
// row tight.
|
||||
static std::size_t PackedExtent(const PackState& pack, int width, int height, std::size_t bpp) {
|
||||
const std::size_t rowPixels = pack.rowLength > 0 ? static_cast<std::size_t>(pack.rowLength)
|
||||
: static_cast<std::size_t>(width);
|
||||
const std::size_t align = static_cast<std::size_t>(pack.alignment);
|
||||
const std::size_t stride = (rowPixels * bpp + align - 1) / align * align;
|
||||
return static_cast<std::size_t>(pack.skipRows) * stride + static_cast<std::size_t>(pack.skipPixels) * bpp +
|
||||
static_cast<std::size_t>(height - 1) * stride + static_cast<std::size_t>(width) * bpp;
|
||||
}
|
||||
|
||||
GLuint NewTexture() {
|
||||
GLuint texture = 0;
|
||||
glGenTextures(1, &texture);
|
||||
m_textures.push_back(texture);
|
||||
return texture;
|
||||
}
|
||||
|
||||
GLuint NewBuffer(GLenum target, std::size_t size, GLubyte fill) {
|
||||
GLuint buffer = 0;
|
||||
glGenBuffers(1, &buffer);
|
||||
m_buffers.push_back(buffer);
|
||||
glBindBuffer(target, buffer);
|
||||
const std::vector<GLubyte> initial(size, fill);
|
||||
glBufferData(target, static_cast<GLsizeiptr>(size), initial.data(), GL_DYNAMIC_READ);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
// An RGBA8 texture holding the pattern, attached as COLOR_ATTACHMENT0 for reading.
|
||||
GLuint AttachPatternRgba8(int width, int height) {
|
||||
std::vector<GLubyte> texels(static_cast<std::size_t>(width) * height * 4);
|
||||
for (int y = 0; y < height; ++y)
|
||||
for (int x = 0; x < width; ++x) {
|
||||
const auto t = PatternRgba8(x, y, 0);
|
||||
std::memcpy(texels.data() + (static_cast<std::size_t>(y) * width + x) * 4, t.data(), 4);
|
||||
}
|
||||
const GLuint texture = NewTexture();
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, width, height);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, texels.data());
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
|
||||
glReadBuffer(GL_COLOR_ATTACHMENT0);
|
||||
EXPECT_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE));
|
||||
EXPECT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR)) << "pattern upload";
|
||||
return texture;
|
||||
}
|
||||
|
||||
// glReadPixels of (x, y, width, height) under `pack` into client memory and into a
|
||||
// pack buffer at `offset`, both pre-filled with kFill; the buffer's bytes are then
|
||||
// read back by `readBack` and the two must be identical, byte for byte, padding
|
||||
// included - and the bytes in front of `offset` must still be kFill.
|
||||
template <typename ReadBack>
|
||||
void ExpectPackBufferMatchesClientMemory(const PackState& pack, int x, int y, int width, int height,
|
||||
GLenum type, std::size_t bpp, ReadBack&& readBack) {
|
||||
ApplyPack(pack);
|
||||
const std::size_t extent = PackedExtent(pack, width, height, bpp);
|
||||
std::vector<GLubyte> host(extent, kFill);
|
||||
glReadPixels(x, y, width, height, GL_RGBA, type, host.data());
|
||||
ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR)) << pack.name << ": client-memory read";
|
||||
|
||||
constexpr std::size_t kOffset = 64;
|
||||
NewBuffer(GL_PIXEL_PACK_BUFFER, kOffset + extent, kFill);
|
||||
glReadPixels(x, y, width, height, GL_RGBA, type, reinterpret_cast<void*>(kOffset));
|
||||
ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR)) << pack.name << ": pack-buffer read";
|
||||
std::vector<GLubyte> actual(kOffset + extent, 0);
|
||||
readBack(actual);
|
||||
ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR)) << pack.name << ": buffer read-back";
|
||||
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||||
ResetPack();
|
||||
|
||||
std::size_t lead = 0;
|
||||
for (std::size_t i = 0; i < kOffset; ++i) lead += actual[i] != kFill ? 1 : 0;
|
||||
EXPECT_EQ(lead, 0u) << pack.name << ": " << lead << " bytes in front of the read's offset moved";
|
||||
std::size_t bad = 0, first = 0;
|
||||
for (std::size_t i = 0; i < extent; ++i) {
|
||||
if (actual[kOffset + i] != host[i] && bad++ == 0) first = i;
|
||||
}
|
||||
EXPECT_EQ(bad, 0u) << pack.name << ": " << bad << " of " << extent
|
||||
<< " bytes differ from the client-memory read, first at byte " << first
|
||||
<< " (buffer " << static_cast<int>(actual[kOffset + first]) << ", host "
|
||||
<< static_cast<int>(host[first]) << ")";
|
||||
}
|
||||
|
||||
GLuint m_fbo = 0;
|
||||
std::vector<GLuint> m_buffers;
|
||||
std::vector<GLuint> m_textures;
|
||||
};
|
||||
|
||||
TEST_F(PackBufferReadbackScenario, ReadPixelsIntoAPackBufferMatchesClientMemoryUnderEveryPackState) {
|
||||
if (!Ready()) return;
|
||||
AttachPatternRgba8(37, 23);
|
||||
if (HasFatalFailure()) return;
|
||||
for (const PackState& pack : kPackStates) {
|
||||
ExpectPackBufferMatchesClientMemory(pack, 2, 1, 31, 19, GL_UNSIGNED_BYTE, 4, [](std::vector<GLubyte>& out) {
|
||||
glGetBufferSubData(GL_PIXEL_PACK_BUFFER, 0, static_cast<GLsizeiptr>(out.size()), out.data());
|
||||
});
|
||||
if (HasFatalFailure()) return;
|
||||
}
|
||||
}
|
||||
|
||||
// The map is the OTHER CPU reader, and the one an application that streams readbacks
|
||||
// through a PBO actually uses: glMapBufferRange(GL_MAP_READ_BIT) must see the pixels the
|
||||
// server landed, not the bytes the client shadow held before the read.
|
||||
TEST_F(PackBufferReadbackScenario, MapBufferRangeAfterAPackBufferReadSeesThePixels) {
|
||||
if (!Ready()) return;
|
||||
AttachPatternRgba8(37, 23);
|
||||
if (HasFatalFailure()) return;
|
||||
for (const PackState& pack : {kPackStates[0], kPackStates[5]}) {
|
||||
ExpectPackBufferMatchesClientMemory(pack, 0, 0, 37, 23, GL_UNSIGNED_BYTE, 4, [](std::vector<GLubyte>& out) {
|
||||
void* mapped = glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0, static_cast<GLsizeiptr>(out.size()),
|
||||
GL_MAP_READ_BIT);
|
||||
ASSERT_NE(mapped, nullptr);
|
||||
std::memcpy(out.data(), mapped, out.size());
|
||||
glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
|
||||
});
|
||||
if (HasFatalFailure()) return;
|
||||
}
|
||||
}
|
||||
|
||||
// GL_PACK_SWAP_BYTES reverses every component's bytes; the client carries the group
|
||||
// width and the server swaps, so a wrong width or a skipped swap is a different float.
|
||||
TEST_F(PackBufferReadbackScenario, SwapBytesIntoAPackBufferMatchesClientMemory) {
|
||||
if (!Ready()) return;
|
||||
constexpr int kWidth = 13, kHeight = 9;
|
||||
std::vector<GLfloat> texels(static_cast<std::size_t>(kWidth) * kHeight * 4);
|
||||
for (int y = 0; y < kHeight; ++y)
|
||||
for (int x = 0; x < kWidth; ++x) {
|
||||
const auto t = PatternRgba32f(x, y);
|
||||
std::memcpy(texels.data() + (static_cast<std::size_t>(y) * kWidth + x) * 4, t.data(), sizeof(t));
|
||||
}
|
||||
const GLuint texture = NewTexture();
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, kWidth, kHeight);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kWidth, kHeight, GL_RGBA, GL_FLOAT, texels.data());
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
|
||||
glReadBuffer(GL_COLOR_ATTACHMENT0);
|
||||
ASSERT_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE));
|
||||
const PackState swapped{"swap bytes, row length 17", 4, 17, 1, 1, GL_TRUE};
|
||||
ExpectPackBufferMatchesClientMemory(swapped, 0, 0, kWidth, kHeight, GL_FLOAT, 16, [](std::vector<GLubyte>& out) {
|
||||
glGetBufferSubData(GL_PIXEL_PACK_BUFFER, 0, static_cast<GLsizeiptr>(out.size()), out.data());
|
||||
});
|
||||
}
|
||||
|
||||
// glGetTexImage into a pack buffer, 2D and layered: the layered case is the one whose
|
||||
// layout has an image stride (GL_PACK_IMAGE_HEIGHT) and a skip in the third dimension.
|
||||
TEST_F(PackBufferReadbackScenario, GetTexImageIntoAPackBufferMatchesClientMemory) {
|
||||
if (!Ready()) return;
|
||||
constexpr int kWidth = 11, kHeight = 7, kLayers = 3;
|
||||
std::vector<GLubyte> texels(static_cast<std::size_t>(kWidth) * kHeight * kLayers * 4);
|
||||
for (int layer = 0; layer < kLayers; ++layer)
|
||||
for (int y = 0; y < kHeight; ++y)
|
||||
for (int x = 0; x < kWidth; ++x) {
|
||||
const auto t = PatternRgba8(x, y, layer);
|
||||
std::memcpy(texels.data() + ((static_cast<std::size_t>(layer) * kHeight + y) * kWidth + x) * 4,
|
||||
t.data(), 4);
|
||||
}
|
||||
const GLuint flat = NewTexture();
|
||||
glBindTexture(GL_TEXTURE_2D, flat);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kWidth, kHeight);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, texels.data());
|
||||
const GLuint layered = NewTexture();
|
||||
glBindTexture(GL_TEXTURE_2D_ARRAY, layered);
|
||||
glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, kWidth, kHeight, kLayers);
|
||||
glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, kWidth, kHeight, kLayers, GL_RGBA, GL_UNSIGNED_BYTE,
|
||||
texels.data());
|
||||
ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR)) << "texture upload";
|
||||
|
||||
struct Shape {
|
||||
const char* name;
|
||||
GLenum target;
|
||||
GLuint texture;
|
||||
int depth;
|
||||
GLint rowLength, alignment, imageHeight, skipImages;
|
||||
};
|
||||
const Shape shapes[] = {
|
||||
{"2D, row length 13, alignment 8", GL_TEXTURE_2D, flat, 1, 13, 8, 0, 0},
|
||||
{"2D array, image height 9, skip images 1", GL_TEXTURE_2D_ARRAY, layered, kLayers, 0, 4, 9, 1},
|
||||
};
|
||||
for (const Shape& shape : shapes) {
|
||||
glBindTexture(shape.target, shape.texture);
|
||||
glPixelStorei(GL_PACK_ROW_LENGTH, shape.rowLength);
|
||||
glPixelStorei(GL_PACK_ALIGNMENT, shape.alignment);
|
||||
glPixelStorei(GL_PACK_IMAGE_HEIGHT, shape.imageHeight);
|
||||
glPixelStorei(GL_PACK_SKIP_IMAGES, shape.skipImages);
|
||||
const std::size_t rowPixels = shape.rowLength > 0 ? static_cast<std::size_t>(shape.rowLength) : kWidth;
|
||||
const std::size_t stride = (rowPixels * 4 + shape.alignment - 1) / shape.alignment * shape.alignment;
|
||||
const std::size_t imageRows = shape.imageHeight > 0 ? static_cast<std::size_t>(shape.imageHeight) : kHeight;
|
||||
const std::size_t imageStride = stride * imageRows;
|
||||
const std::size_t extent = static_cast<std::size_t>(shape.skipImages) * imageStride +
|
||||
static_cast<std::size_t>(shape.depth - 1) * imageStride +
|
||||
static_cast<std::size_t>(kHeight - 1) * stride + kWidth * 4u;
|
||||
std::vector<GLubyte> host(extent, kFill);
|
||||
glGetTexImage(shape.target, 0, GL_RGBA, GL_UNSIGNED_BYTE, host.data());
|
||||
ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR)) << shape.name << ": client-memory read";
|
||||
|
||||
constexpr std::size_t kOffset = 32;
|
||||
NewBuffer(GL_PIXEL_PACK_BUFFER, kOffset + extent, kFill);
|
||||
glGetTexImage(shape.target, 0, GL_RGBA, GL_UNSIGNED_BYTE, reinterpret_cast<void*>(kOffset));
|
||||
ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR)) << shape.name << ": pack-buffer read";
|
||||
std::vector<GLubyte> actual(kOffset + extent, 0);
|
||||
glGetBufferSubData(GL_PIXEL_PACK_BUFFER, 0, static_cast<GLsizeiptr>(actual.size()), actual.data());
|
||||
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||||
ResetPack();
|
||||
std::size_t bad = 0, first = 0;
|
||||
for (std::size_t i = 0; i < kOffset; ++i) bad += actual[i] != kFill ? 1 : 0;
|
||||
EXPECT_EQ(bad, 0u) << shape.name << ": bytes in front of the offset moved";
|
||||
bad = 0;
|
||||
for (std::size_t i = 0; i < extent; ++i)
|
||||
if (actual[kOffset + i] != host[i] && bad++ == 0) first = i;
|
||||
EXPECT_EQ(bad, 0u) << shape.name << ": " << bad << " of " << extent
|
||||
<< " bytes differ from the client-memory read, first at byte " << first;
|
||||
}
|
||||
}
|
||||
|
||||
// THE UNPACK HALF. A read into a buffer followed by an upload FROM that buffer is a
|
||||
// GPU-to-GPU copy an application expects to work; under a transport the upload reads the
|
||||
// client's shadow of the buffer, which the pack read did not touch, so this is exactly
|
||||
// the case that goes wrong if the upload path forgets that the buffer was GPU-written.
|
||||
TEST_F(PackBufferReadbackScenario, APackBufferReadFeedsAnUploadFromTheSameBuffer) {
|
||||
if (!Ready()) return;
|
||||
constexpr int kWidth = 29, kHeight = 17;
|
||||
AttachPatternRgba8(kWidth, kHeight);
|
||||
if (HasFatalFailure()) return;
|
||||
const GLuint buffer = NewBuffer(GL_PIXEL_PACK_BUFFER, static_cast<std::size_t>(kWidth) * kHeight * 4, kFill);
|
||||
glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
|
||||
|
||||
const GLuint copy = NewTexture();
|
||||
glBindTexture(GL_TEXTURE_2D, copy);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kWidth, kHeight);
|
||||
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
|
||||
ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR)) << "read into the buffer, then upload from it";
|
||||
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, copy, 0);
|
||||
std::vector<GLubyte> actual(static_cast<std::size_t>(kWidth) * kHeight * 4, 0);
|
||||
glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, actual.data());
|
||||
std::size_t bad = 0;
|
||||
std::string first;
|
||||
for (int y = 0; y < kHeight; ++y)
|
||||
for (int x = 0; x < kWidth; ++x) {
|
||||
const auto expected = PatternRgba8(x, y, 0);
|
||||
if (std::memcmp(actual.data() + (static_cast<std::size_t>(y) * kWidth + x) * 4, expected.data(), 4) != 0 &&
|
||||
bad++ == 0)
|
||||
first = "(" + std::to_string(x) + "," + std::to_string(y) + ")";
|
||||
}
|
||||
EXPECT_EQ(bad, 0u) << bad << " texels of the uploaded copy differ from the pattern, first at " << first;
|
||||
}
|
||||
|
||||
// ORDER AGAINST LATER WRITES. A glBufferSubData into part of the buffer AFTER the read
|
||||
// must win over the read's bytes there and leave the rest of the read alone - on the
|
||||
// server the pixels and the later write are two queued ranges of one store, drained in
|
||||
// record order.
|
||||
TEST_F(PackBufferReadbackScenario, ALaterBufferSubDataWinsOverThePackReadWhereTheyOverlap) {
|
||||
if (!Ready()) return;
|
||||
constexpr int kWidth = 16, kHeight = 8;
|
||||
AttachPatternRgba8(kWidth, kHeight);
|
||||
if (HasFatalFailure()) return;
|
||||
const std::size_t size = static_cast<std::size_t>(kWidth) * kHeight * 4;
|
||||
std::vector<GLubyte> host(size, kFill);
|
||||
glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, host.data());
|
||||
NewBuffer(GL_PIXEL_PACK_BUFFER, size, kFill);
|
||||
glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
const std::vector<GLubyte> overwrite(40, 0x5A);
|
||||
glBufferSubData(GL_PIXEL_PACK_BUFFER, 100, static_cast<GLsizeiptr>(overwrite.size()), overwrite.data());
|
||||
std::vector<GLubyte> actual(size, 0);
|
||||
glGetBufferSubData(GL_PIXEL_PACK_BUFFER, 0, static_cast<GLsizeiptr>(size), actual.data());
|
||||
ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR));
|
||||
std::memcpy(host.data() + 100, overwrite.data(), overwrite.size());
|
||||
std::size_t bad = 0, first = 0;
|
||||
for (std::size_t i = 0; i < size; ++i)
|
||||
if (actual[i] != host[i] && bad++ == 0) first = i;
|
||||
EXPECT_EQ(bad, 0u) << bad << " bytes differ, first at " << first;
|
||||
}
|
||||
|
||||
// THE WIRE HALF, and the one case that is about the transport rather than the pixels:
|
||||
// under a transport a pack-buffer read posts NO reply-slot record and marks the buffer
|
||||
// GPU-written, once per read. MOBILEGL_IPC_PBO_READBACK_SYNC=1 puts the reply form back,
|
||||
// and this case must then fail on both counters - that is its red-once, recorded in
|
||||
// docs/Disaggregated/notes/p9/.
|
||||
TEST_F(PackBufferReadbackScenario, APackBufferReadPostsNoReplyAndMarksTheBuffer) {
|
||||
if (!Ready()) return;
|
||||
const std::string split = SplitRuntimeSkipReason();
|
||||
if (!split.empty()) GTEST_SKIP() << split;
|
||||
constexpr int kWidth = 24, kHeight = 12;
|
||||
AttachPatternRgba8(kWidth, kHeight);
|
||||
if (HasFatalFailure()) return;
|
||||
NewBuffer(GL_PIXEL_PACK_BUFFER, static_cast<std::size_t>(kWidth) * kHeight * 4, kFill);
|
||||
// A warm-up read, so every state record the read's fill has to publish once is out
|
||||
// of the way before the counted window opens.
|
||||
glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR));
|
||||
constexpr int kReads = 4;
|
||||
const SplitRuntimeState before = PeekSplitRuntime();
|
||||
for (int i = 0; i < kReads; ++i) glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
const SplitRuntimeState after = PeekSplitRuntime();
|
||||
ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR));
|
||||
EXPECT_EQ(after.replyPostings - before.replyPostings, 0u)
|
||||
<< "a read into a pack buffer published a reply-slot record: it took the reply form "
|
||||
"(MOBILEGL_IPC_PBO_READBACK_SYNC=1 does this on purpose)";
|
||||
EXPECT_EQ(after.packBufferReadbackMarks - before.packBufferReadbackMarks,
|
||||
static_cast<unsigned long long>(kReads + 1))
|
||||
<< "every pack-buffer read marks its buffer GPU-written exactly once";
|
||||
// And the bytes are still right after all of that.
|
||||
std::vector<GLubyte> actual(static_cast<std::size_t>(kWidth) * kHeight * 4, 0);
|
||||
glGetBufferSubData(GL_PIXEL_PACK_BUFFER, 0, static_cast<GLsizeiptr>(actual.size()), actual.data());
|
||||
const auto corner = PatternRgba8(kWidth - 1, kHeight - 1, 0);
|
||||
EXPECT_EQ(std::memcmp(actual.data() + actual.size() - 4, corner.data(), 4), 0);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
} // namespace MGITest
|
||||
@@ -1,600 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/PartialUploadOverGpuContentScenario.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
//
|
||||
// Scenario - A SMALL glTexSubImage INTO A LEVEL THE GPU HAS WRITTEN.
|
||||
//
|
||||
// Espryt keeps a CPU shadow of every level and syncs a pending client write by uploading the
|
||||
// region it covers (SyncMipmapsToBackend's sub-rect path). The shadow never sees a GPU write, so
|
||||
// only the region may go up: anything more puts the shadow's stale texels over what the GPU drew.
|
||||
// The region upload used to be skipped whenever the shadow's bytes had to be CONVERTED on the way
|
||||
// to the driver - a three-channel format the driver cannot render is stored four-channel and every
|
||||
// upload is repacked - and whenever the ES upload is shaped differently from the shadow (a 1D
|
||||
// array, stored as a 2D array one texel high): those levels went up WHOLE, and a 2x2 write erased
|
||||
// the rest of the level.
|
||||
//
|
||||
// Every case uploads a level, lets the GPU clear it, writes one 2x2 box, and reads the level back:
|
||||
// the clear outside the box, the write inside. The formats are picked by what they cost the ES
|
||||
// upload, which is per driver - on Mesa llvmpipe GL_SRGB8, GL_RGB8_SNORM and GL_RGB8UI are stored
|
||||
// four-channel (see ThreeChannelAttachmentScenario) while GL_RGB16F is native; ES has no renderable
|
||||
// three-channel format at all, so on a phone all four are converted. GL_RGBA8 is the control that
|
||||
// never converts. A format a backend cannot attach is skipped, not failed.
|
||||
//
|
||||
// The second half is about ORDER, with GL_RGBA8. Magma queues a clear until the texture's next
|
||||
// use and records texel uploads into a batch submitted ahead of the frame's recorded commands, so
|
||||
// a write issued after a clear of (or a draw into) the level reached the image FIRST and the
|
||||
// earlier clear or draw landed over it: the box read back green. Each order is covered - the
|
||||
// clear already recorded, still queued, synced by a draw or by the readback, the reverse order
|
||||
// in which the clear must win, and a draw instead of a clear.
|
||||
//
|
||||
// The last part is about SCATTER: several boxes written between two syncs, with the GPU's clear in
|
||||
// the gaps between them. Everything a backend has to go on is the union box and the storage's
|
||||
// rect list, and both describe more than the writes - the box spans the gaps, the list merges
|
||||
// touching rects into their bounding box, folds once it holds 96, and is withheld once its rects
|
||||
// fill 3/4 of the box; a box spanning the level went up as the whole level. Espryt also uploaded
|
||||
// the union box whenever its unpack ring was in use. Each case below reaches one of those: two
|
||||
// distant boxes, a hundred of them, boxes filling more than 3/4 of their union, and boxes whose
|
||||
// union spans the level.
|
||||
|
||||
#include <cmath>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "../Harness/HeadlessGL.h"
|
||||
#include "../Harness/ScenarioFixture.h"
|
||||
|
||||
#ifdef GLAPI
|
||||
#undef GLAPI
|
||||
#endif
|
||||
#define GL_GLEXT_PROTOTYPES
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glcorearb.h>
|
||||
#undef GL_GLEXT_PROTOTYPES
|
||||
|
||||
namespace MGITest {
|
||||
namespace {
|
||||
constexpr int kEdge = 8;
|
||||
constexpr int kBoxAt = 2;
|
||||
constexpr int kBoxEdge = 2;
|
||||
|
||||
constexpr const char* kVS = R"(#version 430 core
|
||||
void main() {
|
||||
vec2 positions[3] = vec2[3](vec2(-1.0, -1.0), vec2(3.0, -1.0), vec2(-1.0, 3.0));
|
||||
gl_Position = vec4(positions[gl_VertexID], 0.0, 1.0);
|
||||
}
|
||||
)";
|
||||
|
||||
// How a value in [0, 1] is spelled in the client data, and how the level is cleared and
|
||||
// read back. Integer levels spell 1 as kIntegerOne.
|
||||
enum class Encoding { Unorm8, Snorm8, Float32, Uint8 };
|
||||
constexpr unsigned kIntegerOne = 9;
|
||||
|
||||
struct Format {
|
||||
GLenum internalFormat;
|
||||
GLenum clientFormat;
|
||||
GLenum clientType;
|
||||
int components;
|
||||
Encoding encoding;
|
||||
};
|
||||
|
||||
std::vector<std::uint8_t> Fill(const Format& f, int texels, float r, float g, float b) {
|
||||
const float rgba[4] = {r, g, b, 1.0f};
|
||||
const std::size_t componentBytes = f.encoding == Encoding::Float32 ? 4u : 1u;
|
||||
std::vector<std::uint8_t> out(static_cast<std::size_t>(texels) * f.components * componentBytes);
|
||||
for (int t = 0; t < texels; ++t) {
|
||||
for (int c = 0; c < f.components; ++c) {
|
||||
std::uint8_t* dst = out.data() + (static_cast<std::size_t>(t) * f.components + c) * componentBytes;
|
||||
const float v = rgba[c];
|
||||
switch (f.encoding) {
|
||||
case Encoding::Unorm8: *dst = static_cast<std::uint8_t>(std::lround(v * 255.0f)); break;
|
||||
case Encoding::Snorm8:
|
||||
*dst = static_cast<std::uint8_t>(static_cast<std::int8_t>(std::lround(v * 127.0f)));
|
||||
break;
|
||||
case Encoding::Float32: std::memcpy(dst, &v, sizeof(v)); break;
|
||||
case Encoding::Uint8: *dst = static_cast<std::uint8_t>(std::lround(v * kIntegerOne)); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
class PartialUploadOverGpuContentScenario : public ScenarioTest {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
ScenarioTest::SetUp();
|
||||
if (!Ready()) return;
|
||||
m_scratch = MakeColorFbo(4, 4);
|
||||
glGenVertexArrays(1, &m_vao);
|
||||
glGenFramebuffers(1, &m_fbo);
|
||||
FirstGLError();
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
if (!Ready()) return;
|
||||
glUseProgram(0);
|
||||
for (GLuint p : m_programs) glDeleteProgram(p);
|
||||
if (!m_textures.empty()) glDeleteTextures(static_cast<GLsizei>(m_textures.size()), m_textures.data());
|
||||
if (m_vao) glDeleteVertexArrays(1, &m_vao);
|
||||
if (m_fbo) glDeleteFramebuffers(1, &m_fbo);
|
||||
BindDefaultFramebuffer();
|
||||
DestroyColorFbo(m_scratch);
|
||||
glViewport(0, 0, Gl().Width(), Gl().Height());
|
||||
FirstGLError();
|
||||
}
|
||||
|
||||
GLuint NewTexture(GLenum target) {
|
||||
GLuint t = 0;
|
||||
glGenTextures(1, &t);
|
||||
m_textures.push_back(t);
|
||||
glBindTexture(target, t);
|
||||
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, 0);
|
||||
glBindTexture(target, 0);
|
||||
return t;
|
||||
}
|
||||
|
||||
// A draw that samples the texture, which is what syncs its pending writes to the
|
||||
// driver (an FBO attach alone may find the framebuffer already synced).
|
||||
void SyncBySampling(GLenum target, GLuint tex, const char* samplerType, const char* coord) {
|
||||
std::string fs = std::string("#version 430 core\nuniform ") + samplerType +
|
||||
" u_tex;\nout vec4 o_color;\nvoid main() { o_color = vec4(texelFetch(u_tex, " + coord +
|
||||
", 0)); }\n";
|
||||
std::string error;
|
||||
const GLuint program = CompileProgram(kVS, fs.c_str(), &error);
|
||||
ASSERT_NE(program, 0u) << error;
|
||||
m_programs.push_back(program);
|
||||
BindFbo(m_scratch);
|
||||
glUseProgram(program);
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glBindTexture(target, tex);
|
||||
glUniform1i(glGetUniformLocation(program, "u_tex"), 0);
|
||||
glBindVertexArray(m_vao);
|
||||
glDrawArrays(GL_TRIANGLES, 0, 3);
|
||||
glBindVertexArray(0);
|
||||
glBindTexture(target, 0);
|
||||
glUseProgram(0);
|
||||
BindDefaultFramebuffer();
|
||||
glFinish();
|
||||
EXPECT_EQ(FirstGLError(), 0u) << "sampling sync";
|
||||
}
|
||||
|
||||
// Attaches (tex, layer) to the scratch framebuffer; false when this backend cannot.
|
||||
bool Attach(GLuint tex, int layer) {
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
|
||||
if (layer >= 0) {
|
||||
glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex, 0, layer);
|
||||
} else {
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
|
||||
}
|
||||
return glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
|
||||
}
|
||||
|
||||
void Detach() {
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
|
||||
BindDefaultFramebuffer();
|
||||
}
|
||||
|
||||
// The GPU write the shadow never sees: the whole level (or layer) to green.
|
||||
void GpuClearGreen(const Format& f) {
|
||||
if (f.encoding == Encoding::Uint8) {
|
||||
const GLuint green[4] = {0u, kIntegerOne, 0u, 1u};
|
||||
glClearBufferuiv(GL_COLOR, 0, green);
|
||||
} else {
|
||||
const GLfloat green[4] = {0.0f, 1.0f, 0.0f, 1.0f};
|
||||
glClearBufferfv(GL_COLOR, 0, green);
|
||||
}
|
||||
}
|
||||
|
||||
// The attached image's rgb, in units of "one", width x height texels.
|
||||
std::vector<float> ReadRgb(const Format& f, int width, int height) {
|
||||
std::vector<float> rgb(static_cast<std::size_t>(width * height) * 3u);
|
||||
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
||||
if (f.encoding == Encoding::Uint8) {
|
||||
std::vector<GLuint> texels(static_cast<std::size_t>(width * height) * 4u, 0xA5A5A5A5u);
|
||||
glReadPixels(0, 0, width, height, GL_RGBA_INTEGER, GL_UNSIGNED_INT, texels.data());
|
||||
for (int i = 0; i < width * height; ++i)
|
||||
for (int c = 0; c < 3; ++c)
|
||||
rgb[i * 3 + c] = static_cast<float>(texels[i * 4 + c]) / kIntegerOne;
|
||||
} else {
|
||||
std::vector<GLfloat> texels(static_cast<std::size_t>(width * height) * 4u, -7.0f);
|
||||
glReadPixels(0, 0, width, height, GL_RGBA, GL_FLOAT, texels.data());
|
||||
for (int i = 0; i < width * height; ++i)
|
||||
for (int c = 0; c < 3; ++c) rgb[i * 3 + c] = texels[i * 4 + c];
|
||||
}
|
||||
EXPECT_EQ(FirstGLError(), 0u) << "readback";
|
||||
return rgb;
|
||||
}
|
||||
|
||||
// Green everywhere but blue inside [boxX, boxX + boxW) x [boxY, boxY + boxH).
|
||||
static void ExpectClearAroundBox(const std::vector<float>& rgb, int width, int height, int boxX, int boxY,
|
||||
int boxW, int boxH) {
|
||||
int bad = 0;
|
||||
std::ostringstream first;
|
||||
for (int y = 0; y < height; ++y)
|
||||
for (int x = 0; x < width; ++x) {
|
||||
const bool inBox = x >= boxX && x < boxX + boxW && y >= boxY && y < boxY + boxH;
|
||||
const float want[3] = {0.0f, inBox ? 0.0f : 1.0f, inBox ? 1.0f : 0.0f};
|
||||
const float* got = &rgb[static_cast<std::size_t>(y * width + x) * 3u];
|
||||
bool texelBad = false;
|
||||
for (int c = 0; c < 3; ++c) texelBad |= std::fabs(got[c] - want[c]) > 0.02f;
|
||||
if (texelBad && bad++ == 0) {
|
||||
first << "(" << x << "," << y << ") got " << got[0] << "," << got[1] << "," << got[2]
|
||||
<< " want " << want[0] << "," << want[1] << "," << want[2];
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(bad, 0) << bad << " of " << width * height << " texels wrong; first " << first.str()
|
||||
<< " (red outside the box: the stale shadow went back up; green inside it: the "
|
||||
"write landed before the clear or draw)";
|
||||
}
|
||||
|
||||
// Upload red, sync, clear green on the GPU, sync, write a blue 2x2 box, sync, read.
|
||||
void Run2D(const Format& f) {
|
||||
const GLuint t = NewTexture(GL_TEXTURE_2D);
|
||||
const bool integer = f.encoding == Encoding::Uint8;
|
||||
const char* sampler = integer ? "usampler2D" : "sampler2D";
|
||||
const auto red = Fill(f, kEdge * kEdge, 1.0f, 0.0f, 0.0f);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, static_cast<GLint>(f.internalFormat), kEdge, kEdge, 0, f.clientFormat,
|
||||
f.clientType, red.data());
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
ASSERT_EQ(FirstGLError(), 0u) << "definition";
|
||||
SyncBySampling(GL_TEXTURE_2D, t, sampler, "ivec2(0)");
|
||||
if (!Attach(t, -1)) {
|
||||
Detach();
|
||||
GTEST_SKIP() << "the format does not attach on backend " << Gl().BackendName();
|
||||
}
|
||||
GpuClearGreen(f);
|
||||
Detach();
|
||||
SyncBySampling(GL_TEXTURE_2D, t, sampler, "ivec2(0)");
|
||||
const auto blue = Fill(f, kBoxEdge * kBoxEdge, 0.0f, 0.0f, 1.0f);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, kBoxAt, kBoxAt, kBoxEdge, kBoxEdge, f.clientFormat, f.clientType,
|
||||
blue.data());
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
||||
SyncBySampling(GL_TEXTURE_2D, t, sampler, "ivec2(0)");
|
||||
ASSERT_TRUE(Attach(t, -1));
|
||||
const auto rgb = ReadRgb(f, kEdge, kEdge);
|
||||
Detach();
|
||||
ExpectClearAroundBox(rgb, kEdge, kEdge, kBoxAt, kBoxAt, kBoxEdge, kBoxEdge);
|
||||
}
|
||||
|
||||
// P11 M: TWO SCATTERED WRITES INTO ONE LEVEL, so the level carries a rect list (their
|
||||
// area is well under 3/4 of their union box) and not just a box. Under a transport
|
||||
// (and on the push builds' monolith arm) the list crosses in the client's record,
|
||||
// whose regions state their source pitch and offset in the CLIENT's layout; a level
|
||||
// whose upload is converted is cut from the conversion's wider buffer, so those
|
||||
// numbers must not address it (Managers.cpp, carriedLayoutApplies). The whole level
|
||||
// is uploaded green first, so every texel the union box spans outside the two boxes
|
||||
// is green in the shadow too: this case is about WHERE the boxes land, not about GPU
|
||||
// content between them. Green everywhere but the two blue boxes.
|
||||
void Run2DScatter(const Format& f) {
|
||||
constexpr int kFirstAt = 1, kSecondAt = 5;
|
||||
const GLuint t = NewTexture(GL_TEXTURE_2D);
|
||||
const bool integer = f.encoding == Encoding::Uint8;
|
||||
const char* sampler = integer ? "usampler2D" : "sampler2D";
|
||||
const auto green = Fill(f, kEdge * kEdge, 0.0f, 1.0f, 0.0f);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, static_cast<GLint>(f.internalFormat), kEdge, kEdge, 0, f.clientFormat,
|
||||
f.clientType, green.data());
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
ASSERT_EQ(FirstGLError(), 0u) << "definition";
|
||||
SyncBySampling(GL_TEXTURE_2D, t, sampler, "ivec2(0)");
|
||||
if (!Attach(t, -1)) {
|
||||
Detach();
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
||||
GTEST_SKIP() << "the format does not attach on backend " << Gl().BackendName();
|
||||
}
|
||||
Detach();
|
||||
const auto blue = Fill(f, kBoxEdge * kBoxEdge, 0.0f, 0.0f, 1.0f);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, kFirstAt, kFirstAt, kBoxEdge, kBoxEdge, f.clientFormat, f.clientType,
|
||||
blue.data());
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, kSecondAt, kSecondAt, kBoxEdge, kBoxEdge, f.clientFormat,
|
||||
f.clientType, blue.data());
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
||||
SyncBySampling(GL_TEXTURE_2D, t, sampler, "ivec2(0)");
|
||||
ASSERT_TRUE(Attach(t, -1));
|
||||
const auto rgb = ReadRgb(f, kEdge, kEdge);
|
||||
Detach();
|
||||
int bad = 0;
|
||||
std::ostringstream first;
|
||||
for (int y = 0; y < kEdge; ++y)
|
||||
for (int x = 0; x < kEdge; ++x) {
|
||||
const auto inBox = [&](int at) {
|
||||
return x >= at && x < at + kBoxEdge && y >= at && y < at + kBoxEdge;
|
||||
};
|
||||
const bool blueHere = inBox(kFirstAt) || inBox(kSecondAt);
|
||||
const float want[3] = {0.0f, blueHere ? 0.0f : 1.0f, blueHere ? 1.0f : 0.0f};
|
||||
const float* got = &rgb[static_cast<std::size_t>(y * kEdge + x) * 3u];
|
||||
bool texelBad = false;
|
||||
for (int c = 0; c < 3; ++c) texelBad |= std::fabs(got[c] - want[c]) > 0.02f;
|
||||
if (texelBad && bad++ == 0) {
|
||||
first << "(" << x << "," << y << ") got " << got[0] << "," << got[1] << "," << got[2]
|
||||
<< " want " << want[0] << "," << want[1] << "," << want[2];
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(bad, 0) << bad << " of " << kEdge * kEdge << " texels wrong; first " << first.str()
|
||||
<< " (a box read at the wrong pitch or offset lands the wrong bytes)";
|
||||
}
|
||||
|
||||
// Building blocks of the RGBA8 ordering cases: the same texels, issued in the orders
|
||||
// a backend that defers work may get wrong.
|
||||
static Format Rgba8() { return {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, 4, Encoding::Unorm8}; }
|
||||
|
||||
GLuint NewRedRgba8() {
|
||||
const GLuint t = NewTexture(GL_TEXTURE_2D);
|
||||
const auto red = Fill(Rgba8(), kEdge * kEdge, 1.0f, 0.0f, 0.0f);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, red.data());
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
EXPECT_EQ(FirstGLError(), 0u) << "definition";
|
||||
return t;
|
||||
}
|
||||
|
||||
void SampleRgba8(GLuint t) { SyncBySampling(GL_TEXTURE_2D, t, "sampler2D", "ivec2(0)"); }
|
||||
|
||||
void ClearRgba8Green(GLuint t) {
|
||||
ASSERT_TRUE(Attach(t, -1));
|
||||
GpuClearGreen(Rgba8());
|
||||
Detach();
|
||||
}
|
||||
|
||||
// A draw that writes green over the whole level.
|
||||
void DrawRgba8Green(GLuint t) {
|
||||
std::string error;
|
||||
const GLuint program = CompileProgram(
|
||||
kVS, "#version 430 core\nout vec4 o_color;\nvoid main() { o_color = vec4(0.0, 1.0, 0.0, 1.0); }\n",
|
||||
&error);
|
||||
ASSERT_NE(program, 0u) << error;
|
||||
m_programs.push_back(program);
|
||||
ASSERT_TRUE(Attach(t, -1));
|
||||
glViewport(0, 0, kEdge, kEdge);
|
||||
glUseProgram(program);
|
||||
glBindVertexArray(m_vao);
|
||||
glDrawArrays(GL_TRIANGLES, 0, 3);
|
||||
glBindVertexArray(0);
|
||||
glUseProgram(0);
|
||||
Detach();
|
||||
glViewport(0, 0, Gl().Width(), Gl().Height());
|
||||
}
|
||||
|
||||
void WriteRgba8BlueBox(GLuint t) {
|
||||
const auto blue = Fill(Rgba8(), kBoxEdge * kBoxEdge, 0.0f, 0.0f, 1.0f);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, kBoxAt, kBoxAt, kBoxEdge, kBoxEdge, GL_RGBA, GL_UNSIGNED_BYTE,
|
||||
blue.data());
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
}
|
||||
|
||||
// Green everywhere, and blue in the box when `boxWins`.
|
||||
void ExpectRgba8(GLuint t, bool boxWins) {
|
||||
ASSERT_TRUE(Attach(t, -1));
|
||||
const auto rgb = ReadRgb(Rgba8(), kEdge, kEdge);
|
||||
Detach();
|
||||
ExpectClearAroundBox(rgb, kEdge, kEdge, kBoxAt, kBoxAt, boxWins ? kBoxEdge : 0, boxWins ? kBoxEdge : 0);
|
||||
}
|
||||
|
||||
struct Box {
|
||||
int x, y, w, h;
|
||||
};
|
||||
|
||||
// An edge x edge RGBA8 level uploaded red, cleared green on the GPU, then written blue in
|
||||
// every box by one glTexSubImage each, with no sync in between; read back after a sync.
|
||||
// Blue inside the boxes, green everywhere else.
|
||||
void RunScatteredWrites(int edge, const std::vector<Box>& boxes) {
|
||||
const GLuint t = NewTexture(GL_TEXTURE_2D);
|
||||
const auto red = Fill(Rgba8(), edge * edge, 1.0f, 0.0f, 0.0f);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, edge, edge, 0, GL_RGBA, GL_UNSIGNED_BYTE, red.data());
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
ASSERT_EQ(FirstGLError(), 0u) << "definition";
|
||||
SampleRgba8(t);
|
||||
ClearRgba8Green(t);
|
||||
SampleRgba8(t);
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
for (const Box& box : boxes) {
|
||||
const auto blue = Fill(Rgba8(), box.w * box.h, 0.0f, 0.0f, 1.0f);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, box.x, box.y, box.w, box.h, GL_RGBA, GL_UNSIGNED_BYTE,
|
||||
blue.data());
|
||||
}
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
||||
ASSERT_EQ(FirstGLError(), 0u) << "writes";
|
||||
SampleRgba8(t);
|
||||
ASSERT_TRUE(Attach(t, -1));
|
||||
const auto rgb = ReadRgb(Rgba8(), edge, edge);
|
||||
Detach();
|
||||
int bad = 0, stale = 0;
|
||||
std::ostringstream first;
|
||||
for (int y = 0; y < edge; ++y)
|
||||
for (int x = 0; x < edge; ++x) {
|
||||
bool inBox = false;
|
||||
for (const Box& box : boxes)
|
||||
inBox |= x >= box.x && x < box.x + box.w && y >= box.y && y < box.y + box.h;
|
||||
const float want[3] = {0.0f, inBox ? 0.0f : 1.0f, inBox ? 1.0f : 0.0f};
|
||||
const float* got = &rgb[static_cast<std::size_t>(y * edge + x) * 3u];
|
||||
bool texelBad = false;
|
||||
for (int c = 0; c < 3; ++c) texelBad |= std::fabs(got[c] - want[c]) > 0.02f;
|
||||
if (!texelBad) continue;
|
||||
stale += got[0] > 0.5f;
|
||||
if (bad++ == 0) {
|
||||
first << "(" << x << "," << y << ") got " << got[0] << "," << got[1] << "," << got[2]
|
||||
<< " want " << want[0] << "," << want[1] << "," << want[2];
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(bad, 0) << bad << " of " << edge * edge << " texels wrong, " << stale
|
||||
<< " of them red - the stale shadow went up outside the writes; first "
|
||||
<< first.str();
|
||||
}
|
||||
|
||||
GLuint m_vao = 0, m_fbo = 0;
|
||||
ColorFbo m_scratch{};
|
||||
std::vector<GLuint> m_programs;
|
||||
std::vector<GLuint> m_textures;
|
||||
};
|
||||
|
||||
// Control: the shadow's bytes go to the driver as they are.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, Rgba8SubImageKeepsTheGpuClear) {
|
||||
if (!Ready()) return;
|
||||
Run2D({GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, 4, Encoding::Unorm8});
|
||||
}
|
||||
|
||||
TEST_F(PartialUploadOverGpuContentScenario, Srgb8SubImageKeepsTheGpuClear) {
|
||||
if (!Ready()) return;
|
||||
Run2D({GL_SRGB8, GL_RGB, GL_UNSIGNED_BYTE, 3, Encoding::Unorm8});
|
||||
}
|
||||
|
||||
TEST_F(PartialUploadOverGpuContentScenario, Rgb8SnormSubImageKeepsTheGpuClear) {
|
||||
if (!Ready()) return;
|
||||
Run2D({GL_RGB8_SNORM, GL_RGB, GL_BYTE, 3, Encoding::Snorm8});
|
||||
}
|
||||
|
||||
TEST_F(PartialUploadOverGpuContentScenario, Rgb16fSubImageKeepsTheGpuClear) {
|
||||
if (!Ready()) return;
|
||||
Run2D({GL_RGB16F, GL_RGB, GL_FLOAT, 3, Encoding::Float32});
|
||||
}
|
||||
|
||||
TEST_F(PartialUploadOverGpuContentScenario, Rgb8uiSubImageKeepsTheGpuClear) {
|
||||
if (!Ready()) return;
|
||||
Run2D({GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE, 3, Encoding::Uint8});
|
||||
}
|
||||
|
||||
// P11 M: the rect-list shape of the same upload (Run2DScatter). RGBA8 is the control whose
|
||||
// record pitch does address the uploaded bytes; the other two are stored four-channel on
|
||||
// llvmpipe and on every ES driver, so their boxes are cut from the conversion's buffer.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, Rgba8ScatteredSubImagesLandWhereWritten) {
|
||||
if (!Ready()) return;
|
||||
Run2DScatter({GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, 4, Encoding::Unorm8});
|
||||
}
|
||||
|
||||
TEST_F(PartialUploadOverGpuContentScenario, Srgb8ScatteredSubImagesLandWhereWritten) {
|
||||
if (!Ready()) return;
|
||||
Run2DScatter({GL_SRGB8, GL_RGB, GL_UNSIGNED_BYTE, 3, Encoding::Unorm8});
|
||||
}
|
||||
|
||||
TEST_F(PartialUploadOverGpuContentScenario, Rgb8uiScatteredSubImagesLandWhereWritten) {
|
||||
if (!Ready()) return;
|
||||
Run2DScatter({GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE, 3, Encoding::Uint8});
|
||||
}
|
||||
|
||||
// A 1D array's ES image is a 2D array one texel high with the layers in depth, so the
|
||||
// upload is shaped differently from the shadow (layers as rows) even with no conversion.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, OneDimensionalArraySubImageKeepsTheGpuClearedLayer) {
|
||||
if (!Ready()) return;
|
||||
constexpr int kLayers = 2;
|
||||
const Format f{GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, 4, Encoding::Unorm8};
|
||||
const GLuint t = NewTexture(GL_TEXTURE_1D_ARRAY);
|
||||
const auto red = Fill(f, kEdge * kLayers, 1.0f, 0.0f, 0.0f);
|
||||
glBindTexture(GL_TEXTURE_1D_ARRAY, t);
|
||||
glTexImage2D(GL_TEXTURE_1D_ARRAY, 0, GL_RGBA8, kEdge, kLayers, 0, GL_RGBA, GL_UNSIGNED_BYTE, red.data());
|
||||
glBindTexture(GL_TEXTURE_1D_ARRAY, 0);
|
||||
ASSERT_EQ(FirstGLError(), 0u) << "definition";
|
||||
SyncBySampling(GL_TEXTURE_1D_ARRAY, t, "sampler1DArray", "ivec2(0)");
|
||||
if (!Attach(t, 1)) {
|
||||
Detach();
|
||||
GTEST_SKIP() << "a 1D array layer does not attach on backend " << Gl().BackendName();
|
||||
}
|
||||
GpuClearGreen(f);
|
||||
Detach();
|
||||
SyncBySampling(GL_TEXTURE_1D_ARRAY, t, "sampler1DArray", "ivec2(0)");
|
||||
const auto blue = Fill(f, kBoxEdge, 0.0f, 0.0f, 1.0f);
|
||||
glBindTexture(GL_TEXTURE_1D_ARRAY, t);
|
||||
glTexSubImage2D(GL_TEXTURE_1D_ARRAY, 0, kBoxAt, 1, kBoxEdge, 1, GL_RGBA, GL_UNSIGNED_BYTE, blue.data());
|
||||
glBindTexture(GL_TEXTURE_1D_ARRAY, 0);
|
||||
SyncBySampling(GL_TEXTURE_1D_ARRAY, t, "sampler1DArray", "ivec2(0)");
|
||||
ASSERT_TRUE(Attach(t, 1));
|
||||
const auto layer1 = ReadRgb(f, kEdge, 1);
|
||||
Detach();
|
||||
ExpectClearAroundBox(layer1, kEdge, 1, kBoxAt, 0, kBoxEdge, 1);
|
||||
}
|
||||
|
||||
// The orders below matter to a backend that defers GPU work (Magma queues clears and runs
|
||||
// texel uploads in a batch ahead of the frame's recorded commands); every one is plain GL.
|
||||
|
||||
// The clear is still queued when the write arrives: it has to reach the level first.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, SubImageAfterAQueuedClearLandsOnTheClear) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewRedRgba8();
|
||||
SampleRgba8(t);
|
||||
ClearRgba8Green(t);
|
||||
WriteRgba8BlueBox(t);
|
||||
SampleRgba8(t);
|
||||
ExpectRgba8(t, true);
|
||||
}
|
||||
|
||||
// Same, with the readback as the first thing to sync the write.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, SubImageAfterAQueuedClearLandsOnTheClearForAReadback) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewRedRgba8();
|
||||
SampleRgba8(t);
|
||||
ClearRgba8Green(t);
|
||||
WriteRgba8BlueBox(t);
|
||||
ExpectRgba8(t, true);
|
||||
}
|
||||
|
||||
// The other order: the write is still pending when the clear arrives, and the clear wins.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, ClearAfterAPendingSubImageWins) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewRedRgba8();
|
||||
SampleRgba8(t);
|
||||
WriteRgba8BlueBox(t);
|
||||
ClearRgba8Green(t);
|
||||
SampleRgba8(t);
|
||||
ExpectRgba8(t, false);
|
||||
}
|
||||
|
||||
// A draw into the level instead of a clear.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, SubImageAfterADrawIntoTheLevelLandsOnTheDraw) {
|
||||
if (!Ready()) return;
|
||||
const GLuint t = NewRedRgba8();
|
||||
SampleRgba8(t);
|
||||
DrawRgba8Green(t);
|
||||
WriteRgba8BlueBox(t);
|
||||
SampleRgba8(t);
|
||||
ExpectRgba8(t, true);
|
||||
}
|
||||
|
||||
// Two boxes in opposite corners: their union box is 7x7, of which the writes are 8 texels.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, TwoDistantSubImagesKeepTheGpuClearBetweenThem) {
|
||||
if (!Ready()) return;
|
||||
RunScatteredWrites(kEdge, {{0, 0, 2, 2}, {5, 5, 2, 2}});
|
||||
}
|
||||
|
||||
// A hundred 2x2 boxes two texels apart: more than the 96 rects the storage keeps, so its
|
||||
// list folds neighbours together, gaps and all.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, AHundredSubImagesKeepTheGpuClearBetweenThem) {
|
||||
if (!Ready()) return;
|
||||
std::vector<Box> boxes;
|
||||
for (int j = 0; j < 10; ++j)
|
||||
for (int i = 0; i < 10; ++i) boxes.push_back({4 * i + 1, 4 * j + 1, 2, 2});
|
||||
RunScatteredWrites(40, boxes);
|
||||
}
|
||||
|
||||
// Four 4x4 boxes around a one-texel cross: 64 of their union's 81 texels, past the 3/4 at
|
||||
// which the storage stops handing its rect list out.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, SubImagesFillingThreeQuartersOfTheirUnionKeepTheGpuClearBetweenThem) {
|
||||
if (!Ready()) return;
|
||||
RunScatteredWrites(16, {{2, 2, 4, 4}, {7, 2, 4, 4}, {2, 7, 4, 4}, {7, 7, 4, 4}});
|
||||
}
|
||||
|
||||
// Three quadrants: the union box is the whole level, and the list merges the touching
|
||||
// boxes into it; the fourth quadrant is still the GPU's.
|
||||
TEST_F(PartialUploadOverGpuContentScenario, SubImagesWhoseUnionSpansTheLevelKeepTheGpuClearInTheGap) {
|
||||
if (!Ready()) return;
|
||||
RunScatteredWrites(kEdge, {{0, 0, 4, 4}, {4, 0, 4, 4}, {0, 4, 4, 4}});
|
||||
}
|
||||
} // namespace
|
||||
} // namespace MGITest
|
||||
@@ -30,9 +30,7 @@ TEST_F(SyncWireScenario, FenceWaitStatusAndDeletionCrossAndPreserveRenderedPixel
|
||||
glWaitSync(sync, 0, GL_TIMEOUT_IGNORED);
|
||||
glDeleteSync(sync);
|
||||
EXPECT_FALSE(glIsSync(sync));
|
||||
// Create, the server-side wait and the delete always cross; since P10 the two polls may be
|
||||
// answered from the server's fence report instead (FencePollScenario), so they are not counted.
|
||||
EXPECT_GE(PeekSplitRuntime().emitSeq, before + 3);
|
||||
EXPECT_GE(PeekSplitRuntime().emitSeq, before + 5);
|
||||
GLubyte pixel[4]{};
|
||||
glReadPixels(1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixel);
|
||||
const int expected[4] = {64, 128, 191, 255};
|
||||
|
||||
@@ -1,610 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/TextureRemintPullScenario.cpp
|
||||
// Copyright (c) 2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
//
|
||||
// Scenario - A TEXTURE RE-MINT NEEDS NO BYTE FROM THE CLIENT (P9 W2, notes/p9/W2-REMINT.md).
|
||||
//
|
||||
// The name is the ROADMAP's: P4a named `texture-remint-pull` the one new stall class of the
|
||||
// split - a texture first bound to an image unit AFTER the backend allocated it has to be
|
||||
// re-minted in image-bindable (possibly channel-widened) storage, and design/04 §8.4 assumed the
|
||||
// server held no texels to fill it with, so the levels would be PULLED back from the client. P9
|
||||
// W2 measured the opposite on both backends: Espryt's server reads each level back from the old
|
||||
// GPU texture and replays its own staged store for what is still pending
|
||||
// (RequireImageBindableStorageByHandle), Magma copies the old image into the new one GPU to GPU
|
||||
// (PreserveTextureContentsOnRecreate). No pull protocol exists, and this scenario is what says
|
||||
// the re-mint is right without one.
|
||||
//
|
||||
// EVERY CASE HAS ONE SHAPE. Give a texture its content by one means, sync it to the backend with
|
||||
// a sampling draw (so the backend really holds storage when the bind arrives - a texture whose
|
||||
// first sync comes after the bind is allocated image-bindable up front and re-mints nothing),
|
||||
// optionally write it on the GPU, then glBindImageTexture it and copy it with imageLoad into a
|
||||
// destination that was image-bound BEFORE its own first sync (so the destination never re-mints),
|
||||
// and read the destination back through a framebuffer. The expectation is the GL answer, never
|
||||
// "what monolith does": the cases exist exactly where the arms can differ.
|
||||
//
|
||||
// A mutable, uploaded, synced the store and the GPU agree
|
||||
// B mutable, uploaded, then cleared on the GPU the store is STALE, the GPU holds it
|
||||
// C immutable RGBA8, uploaded, then cleared Espryt's split keeps the allocation
|
||||
// D null-defined, only ever cleared on the GPU the store has NO bytes
|
||||
// E cleared, then an unsynced partial upload GPU texels merged with the pending box
|
||||
// F glGenerateMipmap's level 1 GPU-generated, no bytes ever crossed
|
||||
// F2 an uploaded level 1, then cleared on the GPU as B, one level down
|
||||
// G level 1 null-defined AFTER the last sync the driver does not hold the level
|
||||
// G2 level 0 redefined larger, null, after the sync the driver holds the OLD extent
|
||||
// G3 G, plus a partial upload into that level the store holds the whole level
|
||||
// H widened rg8 immutable, uploaded, then cleared the carrier re-mint (Espryt promotes)
|
||||
// H2 widened rg8, uploaded only
|
||||
// I RGBA8_SNORM mutable, uploaded only
|
||||
// J RGBA16_SNORM immutable (widened), uploaded only
|
||||
//
|
||||
// G and G3 were Fatal{ResourceUnavailable, "image-promotion-readback"} on Espryt's split arms
|
||||
// until W2-a: the promotion read a level the driver never allocated.
|
||||
//
|
||||
// ARMS. Both backends on the monolith arm and on Split / Spawn / Tcp, every case. The monolith
|
||||
// DirectGLES arm used to be skipped for B, C, D, E, F, F2 and H: its re-mint replayed the client's
|
||||
// shadow over texels the GPU wrote (W2-REMINT.md §6, the half of ID-P9-8 left to dev). Dev's
|
||||
// 568090f0 made it read the GPU level back first (AdoptDriverLevelIntoShadow), P11 M merged it,
|
||||
// and the skip is retired; E is also what holds the push builds' monolith arm to merging the
|
||||
// applier's pending boxes, which the frontend's dirty model no longer names there.
|
||||
//
|
||||
// W2-d's COUNTER. `trp=` (TextureRemintPulls) counts a re-mint of storage the backend already
|
||||
// held on BOTH Espryt arms now. The peek is process-wide, so it sees the server's count only
|
||||
// where the server is this process: monolith and inproc. A/H assert +1 there, C asserts +0 on
|
||||
// inproc (the kept allocation is not a re-mint).
|
||||
//
|
||||
// W2-b's CONTROL. MGITEST_ESPRYT_FORCE_REMINT_READBACK_FAILURE=1 (read by the SERVER) makes every
|
||||
// promotion readback fail, which a host driver cannot be made to do for real. The
|
||||
// `DirectGLES.{Split,Spawn}.RemintFallback.` entries run the uploaded-only cases under it: the
|
||||
// store covers those levels, so the pixels stay right and the server log names the fallback.
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "../Harness/HeadlessGL.h"
|
||||
#include "../Harness/P4aFinalFixPeek.h"
|
||||
#include "../Harness/PipeStatsWindow.h"
|
||||
#include "../Harness/ScenarioFixture.h"
|
||||
#include "../Harness/SplitRuntimePeek.h"
|
||||
|
||||
#ifdef GLAPI
|
||||
#undef GLAPI
|
||||
#endif
|
||||
#define GL_GLEXT_PROTOTYPES
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glcorearb.h>
|
||||
#undef GL_GLEXT_PROTOTYPES
|
||||
|
||||
namespace MGITest {
|
||||
namespace {
|
||||
|
||||
constexpr int kEdge = 8;
|
||||
constexpr const char* kForceReadbackFailure = "MGITEST_ESPRYT_FORCE_REMINT_READBACK_FAILURE";
|
||||
constexpr const char* kFallbackMarker = "remint-readback-fallback";
|
||||
|
||||
constexpr const char* kVertexSource = R"(#version 430 core
|
||||
void main() {
|
||||
vec2 positions[3] = vec2[3](vec2(-1.0, -1.0), vec2(3.0, -1.0), vec2(-1.0, 3.0));
|
||||
gl_Position = vec4(positions[gl_VertexID], 0.0, 1.0);
|
||||
}
|
||||
)";
|
||||
// The sync: any draw that samples the texture makes the backend allocate and upload it.
|
||||
constexpr const char* kSampleSource = R"(#version 430 core
|
||||
uniform sampler2D u_texture;
|
||||
out vec4 o_color;
|
||||
void main() { o_color = texelFetch(u_texture, ivec2(gl_FragCoord.xy) % 4, 0); }
|
||||
)";
|
||||
|
||||
std::string CopyComputeSource(const char* sourceFormat, bool signedNormalized) {
|
||||
std::string source = "#version 430 core\nlayout(local_size_x = 8, local_size_y = 8) in;\n";
|
||||
source += std::string("layout(") + sourceFormat + ", binding = 0) readonly uniform image2D u_source;\n";
|
||||
source += "layout(rgba8, binding = 1) writeonly uniform image2D u_destination;\n";
|
||||
source += "void main() {\n ivec2 p = ivec2(gl_GlobalInvocationID.xy);\n";
|
||||
source += " vec4 v = imageLoad(u_source, p);\n";
|
||||
if (signedNormalized) source += " v = v * 0.5 + 0.5;\n";
|
||||
source += " imageStore(u_destination, p, v);\n}\n";
|
||||
return source;
|
||||
}
|
||||
|
||||
std::vector<GLubyte> Pattern(int edge, GLubyte magic) {
|
||||
std::vector<GLubyte> texels(static_cast<std::size_t>(edge * edge) * 4u);
|
||||
for (int y = 0; y < edge; ++y) {
|
||||
for (int x = 0; x < edge; ++x) {
|
||||
const std::size_t at = static_cast<std::size_t>((y * edge + x) * 4);
|
||||
texels[at + 0] = magic;
|
||||
texels[at + 1] = static_cast<GLubyte>(16 * (x + 1));
|
||||
texels[at + 2] = static_cast<GLubyte>(16 * (y + 1));
|
||||
texels[at + 3] = 0xFF;
|
||||
}
|
||||
}
|
||||
return texels;
|
||||
}
|
||||
|
||||
std::vector<GLubyte> Solid(int edge, GLubyte r, GLubyte g, GLubyte b, GLubyte a) {
|
||||
std::vector<GLubyte> texels(static_cast<std::size_t>(edge * edge) * 4u);
|
||||
for (std::size_t i = 0; i < texels.size(); i += 4) {
|
||||
texels[i] = r;
|
||||
texels[i + 1] = g;
|
||||
texels[i + 2] = b;
|
||||
texels[i + 3] = a;
|
||||
}
|
||||
return texels;
|
||||
}
|
||||
|
||||
const GLfloat kGreen[4] = {0.0f, 1.0f, 0.0f, 1.0f};
|
||||
|
||||
class TextureRemintPullScenario : public ScenarioTest {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
ScenarioTest::SetUp();
|
||||
if (!Ready()) return;
|
||||
GLint computeImages = 0;
|
||||
glGetIntegerv(GL_MAX_COMPUTE_IMAGE_UNIFORMS, &computeImages);
|
||||
FirstGLError();
|
||||
if (computeImages < 2) {
|
||||
GTEST_SKIP() << "the compute stage has fewer than two image uniforms";
|
||||
}
|
||||
m_wire = SplitRuntimeSkipReason().empty();
|
||||
m_inproc = m_wire && PeekSplitRuntime().transportName == "inproc";
|
||||
m_espryt = Gl().BackendName() == "DirectGLES";
|
||||
m_forced = std::getenv(kForceReadbackFailure) != nullptr;
|
||||
std::string error;
|
||||
m_sampleProgram = CompileProgram(kVertexSource, kSampleSource, &error);
|
||||
ASSERT_NE(m_sampleProgram, 0u) << error;
|
||||
m_scratch = MakeColorFbo(4, 4);
|
||||
ASSERT_NE(m_scratch.fbo, 0u) << "could not create the sampling target";
|
||||
glGenVertexArrays(1, &m_vao);
|
||||
glGenFramebuffers(1, &m_fbo);
|
||||
ASSERT_EQ(FirstGLError(), 0u);
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
if (!Ready()) return;
|
||||
glUseProgram(0);
|
||||
glBindImageTexture(0, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
|
||||
glBindImageTexture(1, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
if (m_sampleProgram != 0) glDeleteProgram(m_sampleProgram);
|
||||
if (m_vao != 0) glDeleteVertexArrays(1, &m_vao);
|
||||
if (m_fbo != 0) glDeleteFramebuffers(1, &m_fbo);
|
||||
if (!m_textures.empty()) {
|
||||
glDeleteTextures(static_cast<GLsizei>(m_textures.size()), m_textures.data());
|
||||
}
|
||||
BindDefaultFramebuffer();
|
||||
if (m_scratch.fbo != 0) DestroyColorFbo(m_scratch);
|
||||
glViewport(0, 0, Gl().Width(), Gl().Height());
|
||||
FirstGLError();
|
||||
}
|
||||
|
||||
GLuint NewTexture() {
|
||||
GLuint texture = 0;
|
||||
glGenTextures(1, &texture);
|
||||
m_textures.push_back(texture);
|
||||
return texture;
|
||||
}
|
||||
|
||||
static void NearestWithMaxLevel(GLuint texture, int maxLevel) {
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, maxLevel);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
}
|
||||
|
||||
// A draw that samples the texture: from here on the backend holds storage for it.
|
||||
void SyncBySampling(GLuint texture) {
|
||||
BindFbo(m_scratch);
|
||||
glUseProgram(m_sampleProgram);
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glUniform1i(glGetUniformLocation(m_sampleProgram, "u_texture"), 0);
|
||||
glBindVertexArray(m_vao);
|
||||
glDrawArrays(GL_TRIANGLES, 0, 3);
|
||||
glBindVertexArray(0);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
glUseProgram(0);
|
||||
BindDefaultFramebuffer();
|
||||
glFinish();
|
||||
}
|
||||
|
||||
// A GPU write the client's shadow never sees.
|
||||
void ClearOnTheGpu(GLuint texture, int level, const GLfloat* color) {
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, level);
|
||||
ASSERT_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), GLenum(GL_FRAMEBUFFER_COMPLETE));
|
||||
glClearBufferfv(GL_COLOR, 0, color);
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
|
||||
BindDefaultFramebuffer();
|
||||
}
|
||||
|
||||
// THE TRANSITION AND THE READ. The destination is image-bound before its first sync,
|
||||
// so only the source can re-mint; the copy goes through imageLoad, which reads the
|
||||
// re-minted storage and nothing else.
|
||||
std::vector<GLubyte> ImageCopy(GLuint source, int level, GLenum unitFormat, const char* glslFormat,
|
||||
bool signedNormalized = false) {
|
||||
const GLuint destination = NewTexture();
|
||||
glBindTexture(GL_TEXTURE_2D, destination);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge, kEdge);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
glBindImageTexture(1, destination, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
|
||||
glBindImageTexture(0, source, level, GL_FALSE, 0, GL_READ_ONLY, unitFormat);
|
||||
EXPECT_EQ(FirstGLError(), 0u) << "glBindImageTexture raised a GL error";
|
||||
const std::string computeSource = CopyComputeSource(glslFormat, signedNormalized);
|
||||
const char* text = computeSource.c_str();
|
||||
const GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
|
||||
glShaderSource(shader, 1, &text, nullptr);
|
||||
glCompileShader(shader);
|
||||
const GLuint program = glCreateProgram();
|
||||
glAttachShader(program, shader);
|
||||
glLinkProgram(program);
|
||||
glDeleteShader(shader);
|
||||
GLint linked = GL_FALSE;
|
||||
glGetProgramiv(program, GL_LINK_STATUS, &linked);
|
||||
EXPECT_EQ(linked, GL_TRUE) << "the imageLoad copy did not link";
|
||||
glUseProgram(program);
|
||||
// A BARRIER THE SPEC DOES NOT ASK FOR, AND IT IS HERE ON PURPOSE. GL orders a
|
||||
// framebuffer write (the GPU clears above) before a later shader image load without
|
||||
// one, yet on the Espryt split arm the kept-allocation case (C, no re-mint to
|
||||
// serialize anything) read the pre-clear texels in 3 of 30 runs without it and 0 of
|
||||
// 30 with it, while every server-side decision was identical in passing and failing
|
||||
// runs (W2-REMINT.md §7). That ordering gap is not the re-mint's question; this case
|
||||
// asks what the re-minted storage HOLDS, so the ordering is pinned here.
|
||||
glMemoryBarrier(GL_ALL_BARRIER_BITS);
|
||||
glDispatchCompute(1, 1, 1);
|
||||
glMemoryBarrier(GL_ALL_BARRIER_BITS);
|
||||
glUseProgram(0);
|
||||
glDeleteProgram(program);
|
||||
glBindImageTexture(0, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
|
||||
glBindImageTexture(1, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, destination, 0);
|
||||
std::vector<GLubyte> read(static_cast<std::size_t>(kEdge * kEdge) * 4u, 0xA5);
|
||||
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
||||
glReadPixels(0, 0, kEdge, kEdge, GL_RGBA, GL_UNSIGNED_BYTE, read.data());
|
||||
glPixelStorei(GL_PACK_ALIGNMENT, 4);
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
|
||||
BindDefaultFramebuffer();
|
||||
EXPECT_EQ(FirstGLError(), 0u) << "the copy or its readback raised a GL error";
|
||||
return read;
|
||||
}
|
||||
|
||||
// The `edge` x `edge` corner of the read against `want`, `channels` channels, within 2.
|
||||
void ExpectTexels(const char* what, const std::vector<GLubyte>& read, int edge,
|
||||
const std::vector<GLubyte>& want, int channels = 4) {
|
||||
int wrong = 0;
|
||||
int firstX = -1, firstY = -1;
|
||||
for (int y = 0; y < edge; ++y) {
|
||||
for (int x = 0; x < edge; ++x) {
|
||||
for (int c = 0; c < channels; ++c) {
|
||||
const int got = read[static_cast<std::size_t>((y * kEdge + x) * 4 + c)];
|
||||
const int expected = want[static_cast<std::size_t>((y * edge + x) * 4 + c)];
|
||||
if (std::abs(got - expected) > 2 && wrong++ == 0) {
|
||||
firstX = x;
|
||||
firstY = y;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
const std::size_t readAt = static_cast<std::size_t>((std::max(firstY, 0) * kEdge + std::max(firstX, 0)) * 4);
|
||||
const std::size_t wantAt = static_cast<std::size_t>((std::max(firstY, 0) * edge + std::max(firstX, 0)) * 4);
|
||||
EXPECT_EQ(wrong, 0) << what << ": " << wrong << " channel(s) differ; first at (" << firstX << ", "
|
||||
<< firstY << ") read " << int(read[readAt]) << "," << int(read[readAt + 1]) << ","
|
||||
<< int(read[readAt + 2]) << "," << int(read[readAt + 3]) << " want "
|
||||
<< int(want[wantAt]) << "," << int(want[wantAt + 1]) << ","
|
||||
<< int(want[wantAt + 2]) << "," << int(want[wantAt + 3]) << " (backend "
|
||||
<< Gl().BackendName() << ", " << (m_wire ? "split" : "monolith") << ")";
|
||||
}
|
||||
|
||||
// W2-d: where the peek can see the server's count (monolith, inproc) - and only on a
|
||||
// push build, which is where PipeStats exists; the pull build's peek answers false (P11
|
||||
// M: the skip retired above now runs H there too, and A always did).
|
||||
bool RemintCountVisible() const {
|
||||
unsigned long long ignored = 0;
|
||||
return m_espryt && (!m_wire || m_inproc) && PeekPipeStatsTextureRemintPulls(&ignored);
|
||||
}
|
||||
unsigned long long RemintCount() {
|
||||
unsigned long long count = 0;
|
||||
EXPECT_TRUE(PeekPipeStatsTextureRemintPulls(&count));
|
||||
return count;
|
||||
}
|
||||
|
||||
// W2-b: under the forced-failure knob the server must have named its fallback.
|
||||
void ExpectFallbackNamedSince(const PipeStatsWindow::LogMark& mark) {
|
||||
if (!m_forced) return;
|
||||
const std::string log = PipeStatsWindow::ReadServerLogSince(mark);
|
||||
EXPECT_NE(log.find(kFallbackMarker), std::string::npos)
|
||||
<< kForceReadbackFailure << " is set but the server log after the image bind carries no '"
|
||||
<< kFallbackMarker << "' line: either the knob did not reach the server (the entry "
|
||||
<< "proves nothing) or the promotion took no readback at all";
|
||||
}
|
||||
|
||||
bool m_wire = false;
|
||||
bool m_inproc = false;
|
||||
bool m_espryt = false;
|
||||
bool m_forced = false;
|
||||
GLuint m_sampleProgram = 0;
|
||||
GLuint m_vao = 0;
|
||||
GLuint m_fbo = 0;
|
||||
ColorFbo m_scratch{};
|
||||
std::vector<GLuint> m_textures;
|
||||
};
|
||||
|
||||
TEST_F(TextureRemintPullScenario, AnUploadedMutableTextureKeepsItsTexelsAcrossTheImageBind) {
|
||||
if (!Ready()) return;
|
||||
const bool counted = RemintCountVisible() && !m_forced;
|
||||
const unsigned long long before = counted ? RemintCount() : 0;
|
||||
const GLuint texture = NewTexture();
|
||||
const auto pattern = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, pattern.data());
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
const auto mark = PipeStatsWindow::MarkLaneLog();
|
||||
ExpectTexels("an uploaded mutable texture", ImageCopy(texture, 0, GL_RGBA8, "rgba8"), kEdge, pattern);
|
||||
ExpectFallbackNamedSince(mark);
|
||||
if (counted) {
|
||||
EXPECT_EQ(RemintCount(), before + 1)
|
||||
<< "the re-mint of a mutable texture the backend already held was not counted (trp=)";
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(TextureRemintPullScenario, AGpuClearAfterTheUploadSurvivesTheImageBind) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
const auto pattern = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, pattern.data());
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
ClearOnTheGpu(texture, 0, kGreen);
|
||||
SyncBySampling(texture);
|
||||
ExpectTexels("a GPU clear after the upload", ImageCopy(texture, 0, GL_RGBA8, "rgba8"), kEdge,
|
||||
Solid(kEdge, 0, 255, 0, 255));
|
||||
}
|
||||
|
||||
TEST_F(TextureRemintPullScenario, AnImmutableTexturesGpuClearSurvivesTheImageBind) {
|
||||
if (!Ready()) return;
|
||||
const bool counted = RemintCountVisible() && m_inproc;
|
||||
const unsigned long long before = counted ? RemintCount() : 0;
|
||||
const GLuint texture = NewTexture();
|
||||
const auto pattern = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge, kEdge);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kEdge, kEdge, GL_RGBA, GL_UNSIGNED_BYTE, pattern.data());
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
ClearOnTheGpu(texture, 0, kGreen);
|
||||
SyncBySampling(texture);
|
||||
ExpectTexels("an immutable texture's GPU clear", ImageCopy(texture, 0, GL_RGBA8, "rgba8"), kEdge,
|
||||
Solid(kEdge, 0, 255, 0, 255));
|
||||
if (counted) {
|
||||
EXPECT_EQ(RemintCount(), before)
|
||||
<< "an immutable core-format allocation is KEPT by the server, not re-minted, and must "
|
||||
"not count (trp=)";
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(TextureRemintPullScenario, ANullDefinedTextureWrittenOnlyByTheGpuSurvivesTheImageBind) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
ClearOnTheGpu(texture, 0, kGreen);
|
||||
SyncBySampling(texture);
|
||||
ExpectTexels("a null-defined texture only the GPU wrote", ImageCopy(texture, 0, GL_RGBA8, "rgba8"),
|
||||
kEdge, Solid(kEdge, 0, 255, 0, 255));
|
||||
}
|
||||
|
||||
TEST_F(TextureRemintPullScenario, APendingPartialUploadMergesOverGpuWrittenTexels) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
const auto pattern = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, pattern.data());
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
ClearOnTheGpu(texture, 0, kGreen);
|
||||
SyncBySampling(texture);
|
||||
const auto blue = Solid(2, 0, 0, 255, 255);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 2, 2, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, blue.data());
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
auto want = Solid(kEdge, 0, 255, 0, 255);
|
||||
for (int y = 2; y < 4; ++y) {
|
||||
for (int x = 2; x < 4; ++x) {
|
||||
const std::size_t at = static_cast<std::size_t>((y * kEdge + x) * 4);
|
||||
want[at] = 0;
|
||||
want[at + 1] = 0;
|
||||
want[at + 2] = 255;
|
||||
}
|
||||
}
|
||||
ExpectTexels("a pending partial upload over GPU texels", ImageCopy(texture, 0, GL_RGBA8, "rgba8"),
|
||||
kEdge, want);
|
||||
}
|
||||
|
||||
TEST_F(TextureRemintPullScenario, AGeneratedMipLevelSurvivesTheImageBind) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
const auto solid = Solid(kEdge, 200, 100, 50, 255);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, solid.data());
|
||||
glGenerateMipmap(GL_TEXTURE_2D);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
SyncBySampling(texture);
|
||||
ExpectTexels("glGenerateMipmap's level 1", ImageCopy(texture, 1, GL_RGBA8, "rgba8"), kEdge / 2,
|
||||
Solid(kEdge / 2, 200, 100, 50, 255));
|
||||
}
|
||||
|
||||
TEST_F(TextureRemintPullScenario, AGpuClearedMipLevelSurvivesTheImageBind) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
const auto level0 = Solid(kEdge, 200, 100, 50, 255);
|
||||
const auto level1 = Solid(kEdge / 2, 10, 20, 30, 255);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, level0.data());
|
||||
glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge / 2, kEdge / 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, level1.data());
|
||||
NearestWithMaxLevel(texture, 1);
|
||||
SyncBySampling(texture);
|
||||
ClearOnTheGpu(texture, 1, kGreen);
|
||||
SyncBySampling(texture);
|
||||
ExpectTexels("a GPU-cleared level 1", ImageCopy(texture, 1, GL_RGBA8, "rgba8"), kEdge / 2,
|
||||
Solid(kEdge / 2, 0, 255, 0, 255));
|
||||
}
|
||||
|
||||
// W2-a. Level 1 exists in the store (a null-data respecify) and on no driver: the texture's
|
||||
// last sync predates it. The promotion must not read it back.
|
||||
TEST_F(TextureRemintPullScenario, ALevelDefinedWithoutDataAfterTheLastSyncDoesNotEndTheSession) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
const auto pattern = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, pattern.data());
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge / 2, kEdge / 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
ExpectTexels("level 0 beside a level defined after the last sync",
|
||||
ImageCopy(texture, 0, GL_RGBA8, "rgba8"), kEdge, pattern);
|
||||
}
|
||||
|
||||
// W2-a's extent half: the driver holds level 0 at its OLD extent. The new contents are
|
||||
// undefined (GL 4.6 core 8.5), so only "no Fatal, no GL error" is asserted.
|
||||
TEST_F(TextureRemintPullScenario, ALevelRedefinedLargerWithoutDataAfterTheLastSyncDoesNotEndTheSession) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
const auto pattern = Pattern(kEdge / 2, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge / 2, kEdge / 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
|
||||
pattern.data());
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
(void)ImageCopy(texture, 0, GL_RGBA8, "rgba8");
|
||||
EXPECT_EQ(FirstGLError(), 0u);
|
||||
}
|
||||
|
||||
// W2-a's store half: the level is on no driver, but its whole staged run is in the store
|
||||
// (the client's level shadow, the partial upload inside it), and that is what replays.
|
||||
TEST_F(TextureRemintPullScenario, APartialUploadIntoALevelDefinedAfterTheLastSyncReachesTheImage) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
const auto pattern = Pattern(kEdge, 0x40);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kEdge, kEdge, 0, GL_RGBA, GL_UNSIGNED_BYTE, pattern.data());
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kEdge / 2, kEdge / 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
const auto blue = Solid(2, 0, 0, 255, 255);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 1, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, blue.data());
|
||||
// Level 1 inside [BASE_LEVEL, MAX_LEVEL], or the image access is invalid (8.26).
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
ExpectTexels("a partial upload into a level defined after the last sync",
|
||||
ImageCopy(texture, 1, GL_RGBA8, "rgba8"), 2, blue);
|
||||
}
|
||||
|
||||
TEST_F(TextureRemintPullScenario, AWidenedFormatsGpuClearSurvivesTheCarrierRemint) {
|
||||
if (!Ready()) return;
|
||||
const bool counted = RemintCountVisible();
|
||||
const unsigned long long before = counted ? RemintCount() : 0;
|
||||
const GLuint texture = NewTexture();
|
||||
std::vector<GLubyte> rg(static_cast<std::size_t>(kEdge * kEdge) * 2u, 0x33);
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RG8, kEdge, kEdge);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kEdge, kEdge, GL_RG, GL_UNSIGNED_BYTE, rg.data());
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
const GLfloat halfQuarter[4] = {0.5f, 0.25f, 0.0f, 1.0f};
|
||||
ClearOnTheGpu(texture, 0, halfQuarter);
|
||||
SyncBySampling(texture);
|
||||
ExpectTexels("a widened rg8 texture's GPU clear", ImageCopy(texture, 0, GL_RG8, "rg8"), kEdge,
|
||||
Solid(kEdge, 128, 64, 0, 255), 2);
|
||||
if (counted) {
|
||||
EXPECT_EQ(RemintCount(), before + 1)
|
||||
<< "the carrier re-mint of a widened texture the backend already held was not counted "
|
||||
"(trp=)";
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(TextureRemintPullScenario, AWidenedFormatsUploadSurvivesTheCarrierRemint) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
std::vector<GLubyte> rg(static_cast<std::size_t>(kEdge * kEdge) * 2u);
|
||||
for (std::size_t i = 0; i < rg.size(); i += 2) {
|
||||
rg[i] = 0x33;
|
||||
rg[i + 1] = 0x99;
|
||||
}
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RG8, kEdge, kEdge);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kEdge, kEdge, GL_RG, GL_UNSIGNED_BYTE, rg.data());
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
const auto mark = PipeStatsWindow::MarkLaneLog();
|
||||
ExpectTexels("a widened rg8 upload", ImageCopy(texture, 0, GL_RG8, "rg8"), kEdge,
|
||||
Solid(kEdge, 0x33, 0x99, 0, 255), 2);
|
||||
ExpectFallbackNamedSince(mark);
|
||||
}
|
||||
|
||||
TEST_F(TextureRemintPullScenario, AnRgba8SnormUploadSurvivesTheImageBind) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
std::vector<GLbyte> texels(static_cast<std::size_t>(kEdge * kEdge) * 4u);
|
||||
for (std::size_t i = 0; i < texels.size(); i += 4) {
|
||||
texels[i] = 127;
|
||||
texels[i + 1] = 0;
|
||||
texels[i + 2] = -127;
|
||||
texels[i + 3] = 127;
|
||||
}
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8_SNORM, kEdge, kEdge, 0, GL_RGBA, GL_BYTE, texels.data());
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
const auto mark = PipeStatsWindow::MarkLaneLog();
|
||||
ExpectTexels("an RGBA8_SNORM upload", ImageCopy(texture, 0, GL_RGBA8_SNORM, "rgba8_snorm", true), kEdge,
|
||||
Solid(kEdge, 255, 128, 0, 255), 3);
|
||||
ExpectFallbackNamedSince(mark);
|
||||
}
|
||||
|
||||
TEST_F(TextureRemintPullScenario, AnRgba16SnormImmutableUploadSurvivesTheCarrierRemint) {
|
||||
if (!Ready()) return;
|
||||
const GLuint texture = NewTexture();
|
||||
std::vector<GLshort> texels(static_cast<std::size_t>(kEdge * kEdge) * 4u);
|
||||
for (std::size_t i = 0; i < texels.size(); i += 4) {
|
||||
texels[i] = 32767;
|
||||
texels[i + 1] = 0;
|
||||
texels[i + 2] = -32767;
|
||||
texels[i + 3] = 32767;
|
||||
}
|
||||
glBindTexture(GL_TEXTURE_2D, texture);
|
||||
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16_SNORM, kEdge, kEdge);
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kEdge, kEdge, GL_RGBA, GL_SHORT, texels.data());
|
||||
NearestWithMaxLevel(texture, 0);
|
||||
SyncBySampling(texture);
|
||||
const auto mark = PipeStatsWindow::MarkLaneLog();
|
||||
ExpectTexels("an RGBA16_SNORM immutable upload",
|
||||
ImageCopy(texture, 0, GL_RGBA16_SNORM, "rgba16_snorm", true), kEdge,
|
||||
Solid(kEdge, 255, 128, 0, 255), 3);
|
||||
ExpectFallbackNamedSince(mark);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
} // namespace MGITest
|
||||
@@ -163,10 +163,7 @@
|
||||
X(QueryDestroy, DeleteBackendQuery) \
|
||||
X(QueryCounter, QueryCounterTimestamp) \
|
||||
X(QueryTimestamp, GetGpuTimestampNs) \
|
||||
X(DeleteStreamOutput, DeleteTransformFeedback) \
|
||||
/* P9 (CONTRACT-P9.md §1): the pack-buffer halves stamp as the verb they reproduce. */ \
|
||||
X(ReadPixelsToBuffer, ReadPixels) \
|
||||
X(GetTextureImageToBuffer, GetTextureImage)
|
||||
X(DeleteStreamOutput, DeleteTransformFeedback)
|
||||
|
||||
// X(Op, Why) - verb-shaped calls that are deliberately NOT stamp points.
|
||||
//
|
||||
|
||||
@@ -15,20 +15,12 @@
|
||||
// The backend -> frontend reverse channel, named (plan B section 7.1).
|
||||
//
|
||||
// Today this traffic is 95 call sites across 17 methods poked directly into frontend
|
||||
// objects. gallium has no vocabulary for shadow writeback, GPU-write notification or
|
||||
// default-framebuffer geometry, because in Mesa the state tracker and the driver share an
|
||||
// address space. Naming them as callbacks is the deliberate deviation (D8).
|
||||
// objects. gallium has no vocabulary for shadow writeback, GPU-write notification, texture
|
||||
// re-send requests or default-framebuffer geometry, because in Mesa the state tracker and
|
||||
// the driver share an address space. Naming them as nine callbacks plus one forward
|
||||
// terminator (MGPipeContext::ResourceSubDataComplete) is the deliberate deviation (D8).
|
||||
//
|
||||
// SEVEN, NOT THE TEN PLAN B WROTE. Three went, each because nothing produces it.
|
||||
//
|
||||
// OnTexturePullRequest, the server asking the client to re-send a texture's levels after
|
||||
// re-minting it (with op 50 ResourceSubDataComplete as the forward terminator). P9 W2 measured
|
||||
// that no re-mint needs the client: Espryt's server reads the GPU level back and replays its own
|
||||
// staged store, Magma copies GPU to GPU, on every arm (notes/p9/W2-REMINT.md). So the callback
|
||||
// went; op 50 stays in the opcode table as a retired row (opcodes only ever grow) and its decoder
|
||||
// still declines it.
|
||||
//
|
||||
// OnXfbScatterReady went with the
|
||||
// NINE, NOT THE TEN PLAN B WROTE. The tenth was OnXfbScatterReady, and it went with the
|
||||
// design it belonged to: plan B put the XFB scatter on the CLIENT (the server would hand
|
||||
// back the packed scratch and the client would run the patch loop over its own shadow), so
|
||||
// there had to be a callback that told the client the layout. P5c/P5f went the other way -
|
||||
@@ -39,13 +31,6 @@
|
||||
// reader of this file has to rule out by hand, and the size assertion below made it look
|
||||
// load-bearing.
|
||||
//
|
||||
// And OnLog, deleted in P9 W3 for the same reason: zero producers, zero consumers, no
|
||||
// EventKind. Plan B pictured the server's log lines as reverse-channel records; they never
|
||||
// were. They travel the CONTROL plane as LogLine frames (protocol.fbs), written by the server's
|
||||
// logger through its log forward (MG_Remote/Transport/LogForward.h) - which is also where the
|
||||
// severity policy this entry's comment promised ("<= WARN lossy, >= ERROR lossless and rate
|
||||
// limited") now lives, on the level LogLine has always carried.
|
||||
//
|
||||
// Installed at context creation. In a monolith these are direct calls; under split they are
|
||||
// records on the reverse channel, and their ORDER is a correctness requirement rather than
|
||||
// an optimization (section 7.4).
|
||||
@@ -58,6 +43,11 @@ namespace MobileGL::MG_Pipe {
|
||||
void (*OnGpuWritten)(MGPipeHandle res, Uint rangeCount, const MGPRange* ranges);
|
||||
void (*OnBufferWriteback)(MGPipeHandle res, Uint64 offset, MGPBlobRef bytes);
|
||||
void (*OnTextureWriteback)(MGPipeHandle res, const MGPBox* box, MGPBlobRef bytes);
|
||||
// The one new stall class in this design (D-B6): the server recast a texture and
|
||||
// needs its texels back. The client answers with zero or more ResourceSubData
|
||||
// records terminated by ResourceSubDataComplete carrying the same pullSerial.
|
||||
void (*OnTexturePullRequest)(MGPipeHandle res, Uint16 target, Uint16 firstLevel, Uint16 levelCount,
|
||||
Uint64 pullSerial);
|
||||
// SHAPE ONLY, never bytes: the client owns the CPU shadow and allocates the levels
|
||||
// itself.
|
||||
void (*OnMipLevelsGenerated)(MGPipeHandle res, Uint16 base, Uint16 count);
|
||||
@@ -65,11 +55,13 @@ namespace MobileGL::MG_Pipe {
|
||||
// pDefaultFramebufferInfo.
|
||||
void (*OnSurfaceChanged)(const MGPSurfaceInfo* info);
|
||||
void (*OnCapsInvalidated)();
|
||||
// <= WARN is lossy, >= ERROR is lossless and rate limited.
|
||||
void (*OnLog)(Uint8 level, const char* text);
|
||||
};
|
||||
|
||||
// Seven, and the count is asserted so an eighth cannot be added without touching the
|
||||
// Nine, and the count is asserted so a tenth cannot be added without touching the
|
||||
// transport's reverse-channel record table.
|
||||
inline constexpr SizeT kMGPipeCallbackCount = 7;
|
||||
inline constexpr SizeT kMGPipeCallbackCount = 9;
|
||||
static_assert(sizeof(MGPipeCallbacks) == kMGPipeCallbackCount * sizeof(void (*)()),
|
||||
"MGPipeCallbacks gained or lost a callback");
|
||||
|
||||
|
||||
@@ -1625,38 +1625,6 @@ namespace MobileGL::MG_Pipe {
|
||||
};
|
||||
MGP_ASSERT_POD(MGPReadbackInfo, 64);
|
||||
|
||||
// P9 (W1, MG_Remote/CONTRACT-P9.md §1): read_pixels_to_buffer / get_texture_image_to_buffer,
|
||||
// the two readbacks whose destination is a bound GL_PIXEL_PACK_BUFFER. The destination is
|
||||
// the pack buffer's RESOURCE HANDLE (CONTRACT-P5 row 23: "a PBO destination is a resource
|
||||
// handle and needs no Seg field"), so nothing comes back and the client does not wait: the
|
||||
// server reads exactly the tight pixels the reply-slot form would have answered and writes
|
||||
// them into Dst row by row through the applier's ordinary buffer-write gate, and the client
|
||||
// marks Dst GPU-written (GpuWritePending.h row 4). A later CPU read of Dst reaches the bytes
|
||||
// through resource_readback, like any other buffer the GPU wrote.
|
||||
//
|
||||
// Src the reply form's record, unchanged: the box, format, type, target and
|
||||
// level; Src.DstOffset / Src.DstSize are 0 / the tight w*h*d*bpp extent
|
||||
// and are checked, not used for placement.
|
||||
// Dst the pack buffer.
|
||||
// DstBase byte offset in Dst of the first texel of the first row of the first image:
|
||||
// the application's offset plus GL_PACK_SKIP_{PIXELS,ROWS,IMAGES} already
|
||||
// applied, because the layout arithmetic is the client's (ReadbackLayout).
|
||||
// RowStride bytes between two rows in Dst (GL_PACK_ROW_LENGTH and GL_PACK_ALIGNMENT
|
||||
// applied). Never smaller than a tight row.
|
||||
// ImageStride bytes between two images in Dst (GL_PACK_IMAGE_HEIGHT applied). Only read
|
||||
// when Src.Box.D > 1.
|
||||
// SwapGroup GL_PACK_SWAP_BYTES as the width of the byte group to reverse (2, 4 or 8),
|
||||
// 0 for no swap - the client's ApplyReadbackByteSwap rule, precomputed there so
|
||||
// the server does not re-derive the type table.
|
||||
struct MGPReadbackToBuffer {
|
||||
MGPReadbackInfo Src;
|
||||
MGPipeHandle Dst;
|
||||
Uint64 DstBase, RowStride, ImageStride;
|
||||
Uint32 SwapGroup;
|
||||
Uint32 Pad0;
|
||||
};
|
||||
MGP_ASSERT_POD(MGPReadbackToBuffer, 104);
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
// Commands
|
||||
// ---------------------------------------------------------------------------------
|
||||
|
||||
@@ -901,22 +901,9 @@ namespace MobileGL::MG_Pipe {
|
||||
for (MGPipeResourceRecord::PendingUpload& entry : stored.PendingUploads) {
|
||||
if (entry.UploadTarget != record.Target || entry.Level != record.Level) continue;
|
||||
entry.UnionBox = UnionOfBoxes(entry.UnionBox, record.UnionBox);
|
||||
if (record.RegionCount == 0 || entry.Regions.empty()) {
|
||||
// A whole-level contribution (the emitter's box-only spelling since P11 M2)
|
||||
// owns every texel of the level, so the entry is that box, exactly. The one
|
||||
// other box-only record is the emitter's oversize fallback (a footprint past
|
||||
// kMGPipeMaxPendingUploadRegions goes out as the storage's cover, which it
|
||||
// withholds as 0 at 3/4 of the box), a partial box spanning gaps - already
|
||||
// inexact, and logged once where it is emitted (TextureEmit.h).
|
||||
entry.Regions.clear();
|
||||
return true;
|
||||
}
|
||||
if (static_cast<Uint64>(entry.Regions.size()) + record.RegionCount > kMGPipeMaxPendingUploadRegions) {
|
||||
// The one lossy answer left: the box covers every texel the list named, and
|
||||
// also the gaps between them (see kMGPipeMaxPendingUploadRegions).
|
||||
MGLOG_W_ONCE("MGPipe: a texture level's pending upload outgrew %u regions and becomes its union "
|
||||
"box, which spans the gaps between the writes",
|
||||
kMGPipeMaxPendingUploadRegions);
|
||||
if (record.RegionCount == 0 || entry.Regions.empty() ||
|
||||
static_cast<Uint64>(entry.Regions.size()) + record.RegionCount >
|
||||
kMGPipeMaxPendingUploadRegions) {
|
||||
entry.Regions.clear();
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -229,18 +229,12 @@ namespace MobileGL::MG_Pipe {
|
||||
// unbounded growth a corrupt Uint16 would otherwise buy.
|
||||
inline constexpr Uint32 kMGPipeMaxPendingUploads = 256;
|
||||
|
||||
// The rect list behind one pending entry, and the most regions one record may carry. The
|
||||
// list is the level's EXACT dirty footprint since P11 M2 (TextureEmit.h, dev 9524c688): one
|
||||
// box per disjoint piece of the writes, however many, where it used to be MipmapStorage's
|
||||
// bounded cover (kMaxDirtyRects = 96, "0 rects" past it). An accumulation that would exceed
|
||||
// this still collapses to BOX ONLY - never a dropped region, since the box covers every
|
||||
// texel the list named - but a box is no longer the same answer: it spans the gaps between
|
||||
// the writes, and a server whose image may hold GPU writes there uploads the stale shadow
|
||||
// over them. So the bound is set far above what a frame's writes to one level come to (a
|
||||
// hundred atlas sprites is ~100), and the collapse is the rare case it was before rather
|
||||
// than the ordinary one. 4096 regions of 40 bytes is a 160 KiB tail, a small fraction of
|
||||
// the half of SEG_CMD one record may take.
|
||||
inline constexpr Uint32 kMGPipeMaxPendingUploadRegions = 4096;
|
||||
// The rect list behind one pending entry. The frontend keeps at most MipmapStorage's
|
||||
// kMaxDirtyRects = 96 per level and answers "0 rects" for everything it cannot describe
|
||||
// that way, which is the model this mirrors: an accumulation that would exceed this
|
||||
// collapses to BOX ONLY - the same answer, with the same meaning, and never a dropped
|
||||
// region. 256 is that bound with room for several emissions accumulating behind a bail.
|
||||
inline constexpr Uint32 kMGPipeMaxPendingUploadRegions = 256;
|
||||
|
||||
// The default uniform block's image, the one allocation P4a adds per program. The size
|
||||
// comes from the program's own MGPProgramDesc::GlobalUboSize, so it is checked ONCE at
|
||||
@@ -1223,8 +1217,8 @@ namespace MobileGL::MG_Pipe {
|
||||
// BindMask / ImageBindableHint bit reaches the applier only on a respecify, and an
|
||||
// IMMUTABLE texture has no further one - that is what immutable means - so the canonical
|
||||
// order (glTexStorage2D, then glBindImageTexture or an FBO attachment) would leave the
|
||||
// record's hint at 0 for ever, and the hint is what PREVENTS the texture re-mint (a
|
||||
// server-side readback and re-upload, P9 W2). So B re-emits the descriptor when the mask moves, and a record whose
|
||||
// record's hint at 0 for ever, and the hint is the PREVENTION half of the texture-remint
|
||||
// stall class. So B re-emits the descriptor when the mask moves, and a record whose
|
||||
// STORAGE-DEFINING fields all equal the stored descriptor's is applied as a metadata
|
||||
// update:
|
||||
//
|
||||
|
||||
@@ -140,14 +140,9 @@
|
||||
// this one describes what happened to it since. It lands with a NULL ROUTE and a sink that
|
||||
// refuses it by name until package pg wires the emitter, exactly as set_shader_buffers has
|
||||
// sat catalogued-and-dead since P4a. 80 unique records.
|
||||
// - delete_stream_output (opcode 81) took the XFB object's deletion across; 81 records.
|
||||
// - P9 (MG_Remote/CONTRACT-P9.md §1) appended TWO more (opcodes 82..83):
|
||||
// read_pixels_to_buffer and get_texture_image_to_buffer, the pack-buffer halves of the two
|
||||
// readbacks, answered by nothing (ID-57's fire-and-forget). Like P5b's five they reach
|
||||
// WireVerbSink only and have no monolith producer. 83 unique records.
|
||||
// ---------------------------------------------------------------------------------------
|
||||
|
||||
#define MGP_CALL_LIST_DOCUMENTED_COUNT 83
|
||||
#define MGP_CALL_LIST_DOCUMENTED_COUNT 81
|
||||
|
||||
// clang-format off
|
||||
#define MGP_CALL_LIST(X) \
|
||||
@@ -344,18 +339,7 @@
|
||||
/* ---- names only handles and values is exactly what rule F admits. ---- */ \
|
||||
X(SetProgramBindings, MGPProgramBindings, kCtxState, kVarTail|kHostSpan, kWaitNone) \
|
||||
/* Deletion carries the GL argument and its never-reused capture identity. */ \
|
||||
X(DeleteStreamOutput, MGPStreamOutputBind, kCtxVerb, kNone, kWaitNone) \
|
||||
/* ---- APPENDED BY P9 (MG_Remote/CONTRACT-P9.md §1), opcodes 82..83: the pack-buffer ---- */ \
|
||||
/* ---- halves of read_pixels and get_texture_image. The reply-slot rows above keep every ---- */ \
|
||||
/* ---- read into client memory; a read whose destination is a bound PIXEL_PACK_BUFFER ---- */ \
|
||||
/* ---- crosses as one of these instead, names the buffer by handle, and is answered by ---- */ \
|
||||
/* ---- nothing - the server lands the rows in the buffer and the client marks it ---- */ \
|
||||
/* ---- GPU-written (ID-57's fire-and-forget). kWaitNone: the apply reads only server ---- */ \
|
||||
/* ---- state and the record, and no BARRIER_PULLED row is left for it to read. Neither ---- */ \
|
||||
/* ---- has an MGPipeApply* entry point or a monolith producer: monolith reads into its ---- */ \
|
||||
/* ---- driver PBO inside the backend's own ReadPixels, as before (G1). ---- */ \
|
||||
X(ReadPixelsToBuffer, MGPReadbackToBuffer, kCtxVerb, kNone, kWaitNone) \
|
||||
X(GetTextureImageToBuffer, MGPReadbackToBuffer, kCtxObject, kNone, kWaitNone)
|
||||
X(DeleteStreamOutput, MGPStreamOutputBind, kCtxVerb, kNone, kWaitNone)
|
||||
// clang-format on
|
||||
|
||||
// Explicitly NOT migrated (plan 4.4.6 / appendix A "explicit deletions"):
|
||||
|
||||
@@ -230,10 +230,6 @@
|
||||
#define MGP_FIELDS_MGPReadbackInfo(F) \
|
||||
F(Res) F(Box) F(Format) F(Type) F(Target) F(Level) F(DstOffset) F(DstSize)
|
||||
|
||||
// P9 (CONTRACT-P9.md §1): the pack-buffer readback. Src is one field, as MGPSubData's box is.
|
||||
#define MGP_FIELDS_MGPReadbackToBuffer(F) \
|
||||
F(Src) F(Dst) F(DstBase) F(RowStride) F(ImageStride) F(SwapGroup)
|
||||
|
||||
#define MGP_FIELDS_MGPDrawInfo(F) \
|
||||
F(Mode) F(IndexSize) F(Flags) F(InstanceCount) F(StartInstance) F(RestartIndex) F(DrawIdOffset) \
|
||||
F(IndexResource) F(MinIndex) F(MaxIndex) F(XfbCpuCapturedVertices) F(NumDraws)
|
||||
@@ -416,8 +412,7 @@
|
||||
P(MGPStreamOutputTargets) P(MGPGlobalConstants) P(MGPAttribValue) P(MGPVertexAttribDefaults) \
|
||||
P(MGPPixelPackState) P(MGPPatchState) P(ResidualValueBlock) P(MGPResidualValueState) \
|
||||
P(MGPSubRegion) P(MGPSubData) P(MGPSubDataComplete) P(MGPFlushRange) P(MGPReadback) \
|
||||
P(MGPCopyRegion) P(MGPBlit) P(MGPClear) P(MGPMipPlan) P(MGPReadbackInfo) P(MGPReadbackToBuffer) \
|
||||
P(MGPDrawInfo) \
|
||||
P(MGPCopyRegion) P(MGPBlit) P(MGPClear) P(MGPMipPlan) P(MGPReadbackInfo) P(MGPDrawInfo) \
|
||||
P(MGPDrawRange) P(MGPDrawIndirect) P(MGPGridInfo) P(MGPMemoryBarrier) P(MGPStreamOutputBegin) \
|
||||
P(MGPXfbAccounting) P(MGPStreamOutputControl) P(MGPFlush) P(MGPPresent) P(MGPSwapInterval) \
|
||||
P(MGPSurfaceInfo) \
|
||||
|
||||
@@ -430,16 +430,15 @@ namespace MobileGL::MG_Pipe {
|
||||
// all, glBindImageTexture's state setter (TextureState.h, MG_State), which may include no
|
||||
// emit header at all. So the note goes through this door, exactly as the birth hooks do.
|
||||
// Nothing produced either bit before the fix round: ImageBindableHint was always 0, the
|
||||
// metadata respecify (ID-18 M4) had no live trigger, and the re-mint the hint exists to
|
||||
// metadata respecify (ID-18 M4) had no live trigger, and the remint pull the hint exists to
|
||||
// prevent was neither prevented nor counted.
|
||||
//
|
||||
// UNCONDITIONAL IN A PUSH BUILD, like the mints: the mask is CLIENT state the framebuffer
|
||||
// emitter ORs into whether or not the texture family is on, and the emission a mask move
|
||||
// causes (the metadata respecify) is gated inside the emitter on the family's own pair.
|
||||
void MGPipeNoteTextureBoundAs(MGPipeHandle texture, Uint32 bindBit);
|
||||
// glBindImageTexture. The hint PREVENTS the texture re-mint (a server-side readback and
|
||||
// re-upload of every defined level, P9 W2) - a texture the server knows may be image-bound is
|
||||
// allocated image-bindable up front - so it
|
||||
// glBindImageTexture. The hint is the PREVENTION half of the texture-remint stall class -
|
||||
// a texture the server knows may be image-bound is allocated image-bindable up front - so it
|
||||
// has to reach the applier before the texture's first sync, i.e. at the bind itself, not at
|
||||
// the validate point's image walk (which notes it as well, D-A4's letter).
|
||||
void MGPipeNoteTextureImageBound(MG_State::GLState::ITextureObject& texture);
|
||||
|
||||
@@ -301,14 +301,12 @@ constexpr MGPipeVerb MGPipeVerbForWireOp(MGPWireOp op) {
|
||||
case MGPWireOp::QueryCounter: return MGPipeVerb::QueryCounterTimestamp;
|
||||
case MGPWireOp::QueryTimestamp: return MGPipeVerb::GetGpuTimestampNs;
|
||||
case MGPWireOp::DeleteStreamOutput: return MGPipeVerb::DeleteTransformFeedback;
|
||||
case MGPWireOp::ReadPixelsToBuffer: return MGPipeVerb::ReadPixels;
|
||||
case MGPWireOp::GetTextureImageToBuffer: return MGPipeVerb::GetTextureImage;
|
||||
default:
|
||||
return MGPipeVerb::kVerbCount;
|
||||
}
|
||||
}
|
||||
|
||||
inline constexpr SizeT kMGPipeVerbBoundaryOpCount = 34;
|
||||
inline constexpr SizeT kMGPipeVerbBoundaryOpCount = 32;
|
||||
inline constexpr SizeT kMGPipeVerbBoundaryExemptCount = 3;
|
||||
|
||||
// ---- THE §7 ALLOWLIST, DERIVED RATHER THAN WRITTEN (ID-116) --------------------------
|
||||
|
||||
@@ -29,7 +29,7 @@ struct MGPipeScreen {
|
||||
void (*ApplierReset)(const MGPApplierReset* payload);
|
||||
};
|
||||
|
||||
// context: 71 calls. A null entry means the backend does not implement this
|
||||
// context: 69 calls. A null entry means the backend does not implement this
|
||||
// call and the frontend keeps its own path (plan B section 4.1).
|
||||
struct MGPipeContext {
|
||||
void (*QueryCreate)(const MGPQueryDesc* payload);
|
||||
@@ -101,13 +101,11 @@ struct MGPipeContext {
|
||||
void (*SetContextValues)(const MGPContextValues* payload);
|
||||
void (*SetProgramBindings)(const MGPProgramBindings* payload, const void* varTail, Uint32 varTailCount);
|
||||
void (*DeleteStreamOutput)(const MGPStreamOutputBind* payload);
|
||||
void (*ReadPixelsToBuffer)(const MGPReadbackToBuffer* payload);
|
||||
void (*GetTextureImageToBuffer)(const MGPReadbackToBuffer* payload);
|
||||
};
|
||||
|
||||
inline constexpr SizeT kMGPipeScreenCallCount = 12;
|
||||
inline constexpr SizeT kMGPipeContextCallCount = 71;
|
||||
inline constexpr SizeT kMGPipeCallCount = 83;
|
||||
inline constexpr SizeT kMGPipeContextCallCount = 69;
|
||||
inline constexpr SizeT kMGPipeCallCount = 81;
|
||||
|
||||
// A table that is not exactly its call count of function pointers has grown a
|
||||
// member that no generator knows about.
|
||||
|
||||
@@ -340,11 +340,3 @@ inline void MGP_SetProgramBindings(const MGPProgramBindings* payload, const void
|
||||
inline void MGP_DeleteStreamOutput(const MGPStreamOutputBind* payload) {
|
||||
gMGPipeContext.DeleteStreamOutput(payload);
|
||||
}
|
||||
|
||||
inline void MGP_ReadPixelsToBuffer(const MGPReadbackToBuffer* payload) {
|
||||
gMGPipeContext.ReadPixelsToBuffer(payload);
|
||||
}
|
||||
|
||||
inline void MGP_GetTextureImageToBuffer(const MGPReadbackToBuffer* payload) {
|
||||
gMGPipeContext.GetTextureImageToBuffer(payload);
|
||||
}
|
||||
|
||||
@@ -95,7 +95,6 @@ inline Bool MGPipeVerify(const MGPBlit& a, const MGPBlit& b, const char** outFie
|
||||
inline Bool MGPipeVerify(const MGPClear& a, const MGPClear& b, const char** outField);
|
||||
inline Bool MGPipeVerify(const MGPMipPlan& a, const MGPMipPlan& b, const char** outField);
|
||||
inline Bool MGPipeVerify(const MGPReadbackInfo& a, const MGPReadbackInfo& b, const char** outField);
|
||||
inline Bool MGPipeVerify(const MGPReadbackToBuffer& a, const MGPReadbackToBuffer& b, const char** outField);
|
||||
inline Bool MGPipeVerify(const MGPDrawInfo& a, const MGPDrawInfo& b, const char** outField);
|
||||
inline Bool MGPipeVerify(const MGPDrawRange& a, const MGPDrawRange& b, const char** outField);
|
||||
inline Bool MGPipeVerify(const MGPDrawIndirect& a, const MGPDrawIndirect& b, const char** outField);
|
||||
@@ -231,8 +230,6 @@ struct MGPipeHasFieldVerifier<MGPMipPlan> : std::true_type {};
|
||||
template <>
|
||||
struct MGPipeHasFieldVerifier<MGPReadbackInfo> : std::true_type {};
|
||||
template <>
|
||||
struct MGPipeHasFieldVerifier<MGPReadbackToBuffer> : std::true_type {};
|
||||
template <>
|
||||
struct MGPipeHasFieldVerifier<MGPDrawInfo> : std::true_type {};
|
||||
template <>
|
||||
struct MGPipeHasFieldVerifier<MGPDrawRange> : std::true_type {};
|
||||
@@ -595,11 +592,6 @@ inline Bool MGPipeVerify(const MGPReadbackInfo& a, const MGPReadbackInfo& b, con
|
||||
return true;
|
||||
}
|
||||
|
||||
inline Bool MGPipeVerify(const MGPReadbackToBuffer& a, const MGPReadbackToBuffer& b, const char** outField) {
|
||||
MGP_FIELDS_MGPReadbackToBuffer(MGP_VERIFY_FIELD)
|
||||
return true;
|
||||
}
|
||||
|
||||
inline Bool MGPipeVerify(const MGPDrawInfo& a, const MGPDrawInfo& b, const char** outField) {
|
||||
MGP_FIELDS_MGPDrawInfo(MGP_VERIFY_FIELD)
|
||||
return true;
|
||||
@@ -757,4 +749,4 @@ inline Bool MGPipeVerify(const MGPVertexBindingPointWire& a, const MGPVertexBind
|
||||
|
||||
#undef MGP_VERIFY_FIELD
|
||||
|
||||
inline constexpr SizeT kMGPipeVerifiedPayloadCount = 83;
|
||||
inline constexpr SizeT kMGPipeVerifiedPayloadCount = 82;
|
||||
|
||||
@@ -151,9 +151,7 @@ enum class MGPWireOp : Uint16 {
|
||||
SetContextValues = 79,
|
||||
SetProgramBindings = 80,
|
||||
DeleteStreamOutput = 81,
|
||||
ReadPixelsToBuffer = 82,
|
||||
GetTextureImageToBuffer = 83,
|
||||
kOpCount = 84,
|
||||
kOpCount = 82,
|
||||
};
|
||||
|
||||
// THE FLAGS, EXPORTED ONCE, INDEXED BY OPCODE (P5 R-13.4). MGPWireRecHeader::Flags is
|
||||
@@ -256,8 +254,6 @@ inline constexpr Uint32 kMGPipeCallFlags[static_cast<SizeT>(MGPWireOp::kOpCount)
|
||||
/* 79 SetContextValues */ static_cast<Uint32>(kNone),
|
||||
/* 80 SetProgramBindings */ static_cast<Uint32>(kVarTail | kHostSpan),
|
||||
/* 81 DeleteStreamOutput */ static_cast<Uint32>(kNone),
|
||||
/* 82 ReadPixelsToBuffer */ static_cast<Uint32>(kNone),
|
||||
/* 83 GetTextureImageToBuffer */ static_cast<Uint32>(kNone),
|
||||
};
|
||||
static_assert(sizeof(kMGPipeCallFlags) / sizeof(kMGPipeCallFlags[0]) ==
|
||||
static_cast<SizeT>(MGPWireOp::kOpCount),
|
||||
@@ -359,8 +355,6 @@ inline constexpr Uint8 kMGPipeCallClasses[static_cast<SizeT>(MGPWireOp::kOpCount
|
||||
/* 79 SetContextValues */ static_cast<Uint8>(kCtxState),
|
||||
/* 80 SetProgramBindings */ static_cast<Uint8>(kCtxState),
|
||||
/* 81 DeleteStreamOutput */ static_cast<Uint8>(kCtxVerb),
|
||||
/* 82 ReadPixelsToBuffer */ static_cast<Uint8>(kCtxVerb),
|
||||
/* 83 GetTextureImageToBuffer */ static_cast<Uint8>(kCtxObject),
|
||||
};
|
||||
static_assert(sizeof(kMGPipeCallClasses) / sizeof(kMGPipeCallClasses[0]) ==
|
||||
static_cast<SizeT>(MGPWireOp::kOpCount),
|
||||
@@ -466,8 +460,6 @@ inline constexpr Uint8 kMGPipeWaitClasses[static_cast<SizeT>(MGPWireOp::kOpCount
|
||||
/* 79 SetContextValues */ static_cast<Uint8>(kWaitNone),
|
||||
/* 80 SetProgramBindings */ static_cast<Uint8>(kWaitNone),
|
||||
/* 81 DeleteStreamOutput */ static_cast<Uint8>(kWaitNone),
|
||||
/* 82 ReadPixelsToBuffer */ static_cast<Uint8>(kWaitNone),
|
||||
/* 83 GetTextureImageToBuffer */ static_cast<Uint8>(kWaitNone),
|
||||
};
|
||||
static_assert(sizeof(kMGPipeWaitClasses) / sizeof(kMGPipeWaitClasses[0]) ==
|
||||
static_cast<SizeT>(MGPWireOp::kOpCount),
|
||||
@@ -1182,22 +1174,6 @@ static_assert(sizeof(MGPWireRec_DeleteStreamOutput) ==
|
||||
((sizeof(MGPWireRecHeader) + sizeof(MGPStreamOutputBind) + 7u) & ~SizeT(7u)),
|
||||
"MGPWireRec_DeleteStreamOutput gained padding; the wire format moved");
|
||||
|
||||
struct alignas(8) MGPWireRec_ReadPixelsToBuffer {
|
||||
MGPWireRecHeader Header;
|
||||
MGPReadbackToBuffer Payload;
|
||||
};
|
||||
static_assert(sizeof(MGPWireRec_ReadPixelsToBuffer) ==
|
||||
((sizeof(MGPWireRecHeader) + sizeof(MGPReadbackToBuffer) + 7u) & ~SizeT(7u)),
|
||||
"MGPWireRec_ReadPixelsToBuffer gained padding; the wire format moved");
|
||||
|
||||
struct alignas(8) MGPWireRec_GetTextureImageToBuffer {
|
||||
MGPWireRecHeader Header;
|
||||
MGPReadbackToBuffer Payload;
|
||||
};
|
||||
static_assert(sizeof(MGPWireRec_GetTextureImageToBuffer) ==
|
||||
((sizeof(MGPWireRecHeader) + sizeof(MGPReadbackToBuffer) + 7u) & ~SizeT(7u)),
|
||||
"MGPWireRec_GetTextureImageToBuffer gained padding; the wire format moved");
|
||||
|
||||
[[noreturn]] inline void MGPipeWireProtocolFatal(const char* call, Uint64 size, Uint64 remaining) {
|
||||
MGLOG_F("MGPipe: protocol corruption applying %s: size=%llu remaining=%llu", call,
|
||||
static_cast<unsigned long long>(size), static_cast<unsigned long long>(remaining));
|
||||
@@ -1490,12 +1466,6 @@ inline Bool MGPipeApplyWireRecord(MGPWireOp op, const void* record, Uint64 size,
|
||||
case MGPWireOp::DeleteStreamOutput:
|
||||
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_DeleteStreamOutput, "DeleteStreamOutput");
|
||||
break;
|
||||
case MGPWireOp::ReadPixelsToBuffer:
|
||||
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_ReadPixelsToBuffer, "ReadPixelsToBuffer");
|
||||
break;
|
||||
case MGPWireOp::GetTextureImageToBuffer:
|
||||
MGP_WIRE_CHECK_BOUNDS(MGPWireRec_GetTextureImageToBuffer, "GetTextureImageToBuffer");
|
||||
break;
|
||||
case MGPWireOp::kInvalid:
|
||||
case MGPWireOp::kOpCount:
|
||||
default:
|
||||
|
||||
@@ -329,13 +329,6 @@ inline constexpr WireLayoutMember kMGPipeWireLayoutMembers[] = {
|
||||
{"MGPReadbackInfo.Level", offsetof(MGPReadbackInfo, Level), sizeof(((MGPReadbackInfo*)nullptr)->Level)},
|
||||
{"MGPReadbackInfo.DstOffset", offsetof(MGPReadbackInfo, DstOffset), sizeof(((MGPReadbackInfo*)nullptr)->DstOffset)},
|
||||
{"MGPReadbackInfo.DstSize", offsetof(MGPReadbackInfo, DstSize), sizeof(((MGPReadbackInfo*)nullptr)->DstSize)},
|
||||
{"MGPReadbackToBuffer", 0, sizeof(MGPReadbackToBuffer)},
|
||||
{"MGPReadbackToBuffer.Src", offsetof(MGPReadbackToBuffer, Src), sizeof(((MGPReadbackToBuffer*)nullptr)->Src)},
|
||||
{"MGPReadbackToBuffer.Dst", offsetof(MGPReadbackToBuffer, Dst), sizeof(((MGPReadbackToBuffer*)nullptr)->Dst)},
|
||||
{"MGPReadbackToBuffer.DstBase", offsetof(MGPReadbackToBuffer, DstBase), sizeof(((MGPReadbackToBuffer*)nullptr)->DstBase)},
|
||||
{"MGPReadbackToBuffer.RowStride", offsetof(MGPReadbackToBuffer, RowStride), sizeof(((MGPReadbackToBuffer*)nullptr)->RowStride)},
|
||||
{"MGPReadbackToBuffer.ImageStride", offsetof(MGPReadbackToBuffer, ImageStride), sizeof(((MGPReadbackToBuffer*)nullptr)->ImageStride)},
|
||||
{"MGPReadbackToBuffer.SwapGroup", offsetof(MGPReadbackToBuffer, SwapGroup), sizeof(((MGPReadbackToBuffer*)nullptr)->SwapGroup)},
|
||||
{"MGPDrawInfo", 0, sizeof(MGPDrawInfo)},
|
||||
{"MGPDrawInfo.Mode", offsetof(MGPDrawInfo, Mode), sizeof(((MGPDrawInfo*)nullptr)->Mode)},
|
||||
{"MGPDrawInfo.IndexSize", offsetof(MGPDrawInfo, IndexSize), sizeof(((MGPDrawInfo*)nullptr)->IndexSize)},
|
||||
@@ -760,6 +753,4 @@ inline constexpr WireCallLayout kMGPipeWireCallLayouts[] = {
|
||||
{"SetContextValues", "MGPContextValues", static_cast<Uint64>(MGPWireOp::SetContextValues), static_cast<Uint64>(kNone), static_cast<Uint64>(kWaitNone)},
|
||||
{"SetProgramBindings", "MGPProgramBindings", static_cast<Uint64>(MGPWireOp::SetProgramBindings), static_cast<Uint64>(kVarTail | kHostSpan), static_cast<Uint64>(kWaitNone)},
|
||||
{"DeleteStreamOutput", "MGPStreamOutputBind", static_cast<Uint64>(MGPWireOp::DeleteStreamOutput), static_cast<Uint64>(kNone), static_cast<Uint64>(kWaitNone)},
|
||||
{"ReadPixelsToBuffer", "MGPReadbackToBuffer", static_cast<Uint64>(MGPWireOp::ReadPixelsToBuffer), static_cast<Uint64>(kNone), static_cast<Uint64>(kWaitNone)},
|
||||
{"GetTextureImageToBuffer", "MGPReadbackToBuffer", static_cast<Uint64>(MGPWireOp::GetTextureImageToBuffer), static_cast<Uint64>(kNone), static_cast<Uint64>(kWaitNone)},
|
||||
};
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
# P10:sync / query / present 节奏
|
||||
|
||||
2026-09-29。依据 `docs/Disaggregated/notes/p10/`(计划与范围重划 [`PLAN-P10.md`](../../docs/Disaggregated/notes/p10/PLAN-P10.md)、裁定 `INTEGRATOR-DECISIONS-P10.md`)。本文只记实现所需的协议与行为;验证结果以 notes 里的运行证据为准。
|
||||
|
||||
## 范围
|
||||
|
||||
fence 轮询不再是往返(§1);最后一个 class-C 与 split 覆盖(§2);credit 与往返的测量记录(§3)。路线图原文里已做完或前提已变的项(client 铸造 query handle、present 1:1、credit 默认 1、无 present 负载的 `SEG_STAGE` 饥饿)见计划 §1。
|
||||
|
||||
## 1. fence 轮询从 server 的报告作答(A)
|
||||
|
||||
### 线上格式
|
||||
|
||||
- `EventKind` 追加 `kEventFenceSignaled = 5`,载荷 `EventFenceSignaledHead { EventHandle Fence; }`(8 字节):server 看到该 client fence 已 signaled,每个 fence 至多一条。opcode 与控制协议修订号不变。
|
||||
|
||||
### server
|
||||
|
||||
- `ServerVerbSink` 按**创建顺序**记下尚未报告的 fence(`FenceCreate` 入队;被删的出队时跳过)。`ReportSignaledFences(flush)` 从最老的一个开始查,查到第一个未完成的就停(同一 context 的 GPU 按提交顺序完成),每个已完成的发一条 `kEventFenceSignaled` 并立即发布。
|
||||
- `OnPresent` 在归还 present credit **之前**调用一次(状态查询,不提交):credit 放行的 client 会立刻去等一两帧前的 fence,报告必须先于放行。
|
||||
- apply 线程在**每个 drain 批次之后**调用(后端表 `GL.GetSyncStatus`,不提交);**将要空闲**且还有未报告的 fence 时先调一次 `flush=true`——最老的 pending fence 改用 `GL.ClientWaitSync(GL_SYNC_FLUSH_COMMANDS_BIT, 0)`,这是两个后端都会提交所持命令的唯一后端无关方式——仍有未报告的就**限时停车 1 ms**(`kFenceIdlePollMs`)后再查,否则照旧无限期停车。`SEG_EVENT` 满时不报告(与既有"环满不 apply"同一规矩)。
|
||||
- 与后端无关:两个后端都实现 `GL.FenceSync / GetSyncStatus / ClientWaitSync`。没有原生 fence 的(`FenceSync` 为空或返回空)视为已 signaled。
|
||||
|
||||
### client
|
||||
|
||||
- 事件排空时记下已报告的 fence(`{slot → gen}`,独立互斥锁:排空发生在持有 `g_fenceMutex` 的发射函数内部);往返答"已 signaled"的也记下;`glDeleteSync` 时忘掉。
|
||||
- `glClientWaitSync` / `glGetSynciv(GL_SYNC_STATUS)` 先做一次**轮询入口**(`ClientSession::PollEntry`:刷出已发布的记录、排空反向通道),然后:
|
||||
- 已知 signaled → 本地答 `GL_ALREADY_SIGNALED` / `GL_SIGNALED`;
|
||||
- 未知且调用不能等(timeout = 0、`glGetSynciv`)→ 本地答 `GL_TIMEOUT_EXPIRED` / `GL_UNSIGNALED`;同一 fence 连续第 N 次(`MOBILEGL_IPC_POLL_ESCALATE`,默认 64)改为一次真往返,计数归零;
|
||||
- 未知且调用可以等(timeout > 0)→ 真往返,语义不变。
|
||||
- `MOBILEGL_IPC_POLL_ESCALATE=0`:每次轮询都往返,即 P10 之前的行为(A/B 臂)。设备丢失后一律走往返臂(其 DECLINED 答复是既有的 no-op)。
|
||||
- 计数:`ReadFencePollCounters()`(本地作答、升级、往返、server 报告),经 `SplitRuntimePeek` 给车道。
|
||||
|
||||
### 门
|
||||
|
||||
- `FencePollScenario`(两后端 × 单进程 / Split / Spawn / Tcp):零超时轮询循环有界结束(带 / 不带 flush 位,后者仅 split);已 signaled 的 fence 轮询不产生回复槽记录;只轮询不发记录时,空闲 server 仍会报告后来完成的 fence(无升级)。单元控制 `RemoteClientControls.AnUnreportedFencePollCrossesOnlyEveryPollEscalateTimes` 钉住"第 N 次才过线"。
|
||||
- red-once:`POLL_ESCALATE=0` → 200 条回复槽记录 / 200 次往返;去掉空闲复查 → Espryt 需 1 次升级、Magma 升级 15 次仍等不到(Magma 的 fence 不会自己提交);client 关掉本地作答 → 单元控制 exit 163。
|
||||
|
||||
### 测量
|
||||
|
||||
`PacedFrameFenceWaitsBench`(手动开启,不设门)的配对结果在 [`A-FENCE-POLL.md`](../../docs/Disaggregated/notes/p10/A-FENCE-POLL.md):Magma 走 tcp 时每帧耗时降 37%、fence 往返为 0;Espryt 在主机 llvmpipe 上没有收益,因为只有阻塞等待才能让 fence 可见。在 Adreno 830 上两后端都是 0 次往返、598 / 598 次本地作答([`C-MEASUREMENTS.md`](../../docs/Disaggregated/notes/p10/C-MEASUREMENTS.md) §1)。
|
||||
|
||||
## 2. 最后一个 class-C 与 split 覆盖(B)
|
||||
|
||||
- 发射表的 `SetSwapInterval` 槽 = server 转发器(与 `eglSwapInterval` 经 `SurfaceControlOp::SetSwapInterval` 的同一路);`SetSwapInterval_Unmigrated` 与 `BackendObject_Remote` 的覆盖删除。class C 为空:69 已实现 / 0 未迁移。单元控制:`ServerLoopTest.TheEmitTableSwapIntervalSlotCrossesAsOneDispatchedFrame`(经表调用,恰好一个控制帧到达)。
|
||||
- caps mirror 采纳 server 快照时,`GL_KHR_parallel_shader_compile` 按 **client** 的 `MOBILEGL_ASYNC_SHADER_COMPILE` 重算:编译池与 `GL_MAX_SHADER_COMPILER_THREADS_KHR` 都在 client。red-once:去掉重算 → 两后端 Tcp 的 `AsyncOff` 扩展串用例红。
|
||||
- 登记(全部进门):`AsyncCompileScenario`(`AsyncOn.` / `AsyncOff.` / `OptimisticShaderStatus.`)与 `XfbPrimitiveQueryScenario` × 两后端 × Split / Spawn / Tcp;`PrimitivesGeneratedNoXfbScenario` 只在 Magma(`PrimGen.` 三臂,`PrimGenReroute.` 仅 Split / Spawn:tcp 的共享 server 读不到改道开关)。red-once:client 查询结果加一 → 101 条里 49 条红(全部 XfbQuery / PrimGen / PrimGenReroute),同名 monolith 条目仍绿。
|
||||
|
||||
## 3. 测量(只记录)
|
||||
|
||||
见 [`C-MEASUREMENTS.md`](../../docs/Disaggregated/notes/p10/C-MEASUREMENTS.md),包括真机 fence bench、设备上 TCP loopback 的 `PRESENT_CREDIT` 1/2/3、以及主机 retrace 往返普查。在 loopback 上 credit 没有噪声以外的影响(rd12 51.4 / 51.6 / 52.4 fps),默认值保持 1。
|
||||
|
||||
## 不变量
|
||||
|
||||
- G1:新代码全在 `MOBILEGL_BUILD_DISAGGREGATED` 下(`MG_Remote`、`Config` 的 IPC 段)。
|
||||
- `EventKind` 只追加;控制协议修订号不变(3)。
|
||||
@@ -1,223 +0,0 @@
|
||||
# P11:persistent map 采纳档位诚实化(A 包主机半)
|
||||
|
||||
2026-09-29。依据 [`PLAN-P11.md`](../../docs/Disaggregated/notes/p11/PLAN-P11.md) §2 的 A1、A2 与 C 的文档修正。档位名按 `design/07`:T0 = client 分配 `AHardwareBuffer`、server 导入;T1 = server 导出 opaque fd;T2 = 拒绝,client 保留 shadow 并推送。本文只记实现所需的行为与门;A3 / A4(设备)与 B(T0)不在本文。
|
||||
|
||||
## 范围
|
||||
|
||||
档位在握手时定下(§1);断言 arena 落在哪一档、三臂登记(§2);文档漂移(§3)。
|
||||
|
||||
## 1. 档位由知道数据面的一侧在握手时定下(A1)
|
||||
|
||||
### 线上格式
|
||||
|
||||
- 无变化。LinkTerms、`RefuseCode`、控制协议修订号(3)都不动:每一侧只判自己的旋钮,不需要把档位带过线。
|
||||
|
||||
### 规则(`Transport/AdoptTier.cpp` `SettleAdoptTierAtHandshake`)
|
||||
|
||||
| 数据面 | 侧 | `MOBILEGL_IPC_ADOPT_TIER=0/1` |
|
||||
|---|---|---|
|
||||
| Stream(tcp) | client / server | 一行 W `Refuse{AdoptTierOnStream, "T<n>"}`,本会话 T2;从不 Fatal |
|
||||
| SharedSegments(inproc、fork / unix spawn) | client | `Fatal{UnimplementedAdoptTier, "T<n>"}`,握手期、任何记录之前 |
|
||||
| SharedSegments | server | 一行 W(档位由 client 定),T2 |
|
||||
|
||||
- 调用点:client `StartOverTransportPair`(Welcome 校验后)与 `StartOverSocket`(link terms 定下 `stream` 后、开数据连接前);server `ServerSession::Accept`(后端检查后、Welcome 前)。
|
||||
- 使用处 `Client::AdoptTierIsEmulate`(`PipeApply.cpp`、`PipeWireCodec.cpp` 仍问它):旋钮 2 → true;本进程已有握手定档 → true,不再打印;没有握手定过档的调用者 → 仍 `Fatal{UnimplementedAdoptTier}`("no handshake settled")。旋钮 > 2(解析器不收)→ Fatal。
|
||||
- `ServerSpawn` 从它拉起的子进程环境剔除 `MOBILEGL_IPC_*`(五个 server 自有旋钮除外),所以 fork / unix spawn 的 server 看不到 client 的旋钮;tcp 的 server 读自己的环境。
|
||||
|
||||
### 普查
|
||||
|
||||
新的死亡走 `SessionFail`:abort 站点仍 79,family 词仍 45(复用 `UnimplementedAdoptTier`);refusal 词 3 → 4,`AdoptTierOnStream` 进 `fatal_census.py` 的 `LOCAL_REFUSAL_WORDS`(本地拒绝,不成为 Refuse 帧)。
|
||||
|
||||
### 门
|
||||
|
||||
- 单元:`AdoptTierStream.*`(真 tcp 会话:client 0/1 → 会话起、一行拒绝、`map_persistent` 得 DECLINED、之后仍 apply;进程内显示 server 0 → 每会话一行、不死);`RemoteClientControls.AdoptTier{Zero,One}OverSharedSegmentsDiesAtTheHandshakeBeforeAnyMapPersistent`(inproc 真握手,子进程在 `Start` 返回前死、具名);`SplitBufferSet.OnlyAdoptTierTwoIsImplemented`(函数级矩阵);`PipeWireCodecTest.AdoptTier{Zero,One}AfterAStreamHandshakeIsADeclineOnTheWirePath` 与 `AnUnsettledAdoptTierStillDiesByNameOnTheWirePath`。
|
||||
- 集成:`{DirectGLES,DirectVulkan}.Tcp.AdoptTier0.LargeArenaAdoptionScenario.*`(`MOBILEGL_IPC_ADOPT_TIER=0`;`integration-tcp` / `integration-magma-tcp`),`AStreamSessionRefusesTheAdoptTierOnceByName` 读 client 日志恰一行,其余用例绿。tcp 专属:共享段上同一旋钮在握手期死(`spawn_lane_parity.py` 的 `MAGMA_TCP_ONLY`)。
|
||||
- red-once:删 Stream 分支 → 两后端 tcp 条目 client 握手期 `Fatal{UnimplementedAdoptTier}`、无拒绝行,单元 `AdoptTierStream` 两例、codec 两例、`SplitBufferSet` 一例红;把检查挪回使用处 → inproc 会话起来、`map_persistent` 发出后才在 apply 线程死(子进程写出 `S`),spawn 臂则静默跑 T2(server 环境被剔除)。
|
||||
|
||||
## 2. arena 落在哪一档(A2)
|
||||
|
||||
- `LargeArenaAdoptionScenario.TheArenaLandsInTheTierItsLaneDeclares`:`PersistentMapPeek` 读 arena 的 `IsBackendPersistentMapped`,与车道的 `MGITEST_PERSISTENT_MAP_ARM` 比;问两次(NULL 定义后;一帧绘制 + SSBO 绑定 + dispatch 后)。未声明的车道跳过。
|
||||
- 声明:monolith = adopted(`DirectGLES.ResourceSubsystemOn/Off.`、新 `DirectVulkan.ArenaArm.`,都钉 monolith);split = emulated(Espryt 三臂经 `SplitLogPaths` 按条目声明;Magma `Arena.` 块与 Buffers 车道)。
|
||||
- 登记:`mgl_itest_register_split_arms("LargeArenaAdoptionScenario.*")`(Espryt 进门、Magma 进信息层);Magma 进门:`DirectVulkan.<arm>.Arena.`(band 口味,六例)与 Buffers 车道(加六例,`test.yml` 的 require-green 名单同步)。
|
||||
- red-once:monolith 车道加 `MOBILEGL_DISABLE_LARGE_BUFFER_ADOPTION=1` → 三条红;split 车道改声明 adopted → 两后端 8 条红。删 `PipeApply.cpp` 的 R-6 拒绝**不会**让 Espryt inproc 采纳(实测仍 emulated):split 下 client 的采纳门经线路走,codec 不调 applier 就答 DECLINED;applier 只在 server 角色自己发射时被问到(只有 Magma 的 `EnsureGpuResidentStorage`),而 Magma 的线路表 `MapPersistent` 恒返回空。
|
||||
|
||||
## 3. 文档漂移(C)
|
||||
|
||||
- `Config.h`:大 buffer 采纳下的 SubData 自 `0ee3384b` 起经 resident-subdata GPU 有序落地,不是"plain memcpy"。
|
||||
- `MG_Backend/Init.cpp`:DirectVulkan 在非 monolith 下注册线路资源表(`VkBufferManager::RegisterWireResourceOps`)并声明 bit 7。
|
||||
- 档位命名按 `design/07`:`PersistentMapTracker.h` 注释已改。`protocol.fbs` 的 `Adopt = 6 // server-owned adopted store` 注释**没改**:`protocol_revision_pin.py` 对整文件取 sha256,改注释要 bump 修订号。
|
||||
- `CONTRACT-P6.md`、`design/06`、`design/07` 的"stream 上具名拒绝"现为真,已指向本节代码。
|
||||
|
||||
## 不变量
|
||||
|
||||
- G1:新代码全在 `MOBILEGL_BUILD_DISAGGREGATED` 下(`MG_Remote`)。
|
||||
- 线上格式与控制协议修订号不变(3)。(A 包;PAIR 包把修订号升到 4,见下节。)
|
||||
|
||||
## PAIR:socket client 的两条连接按身份配对(B0 F2)
|
||||
|
||||
依据 [`B0-CROSS-APP.md`](../../docs/Disaggregated/notes/p11/B0-CROSS-APP.md) F2:server 按到达顺序配对(`AcceptPair`,"先到是控制、后到是 aux"),设备上 server app 的就绪探测(一次空 `connect()` + `close()`)成了下一个真 client 的控制连接,会话读到探测的套接字后退出(`control peer closed before sending a first frame`),client `no Welcome … (rc=6)`;两个 client 同时连也会互换半边。
|
||||
|
||||
### 线上格式
|
||||
|
||||
- `protocol.fbs` 追加 `table PairBind { nonce: [ubyte]; aux: bool; }` 与 `CtrlMsg` 末尾的 `PairBind`。**控制协议修订号 3 → 4**(`mg_protocol_base.h`,`protocol_revision_pins.json` 已钉),`wireFingerprint` 随之变。
|
||||
- `SocketTransport::ConnectTo`(`unix:` 与 fork spawn 两条 client 路径都走它;`tcp://` 上只有测试用):CSPRNG 取 16 字节 nonce,控制、aux 两条连接各以一帧 `PairBind{nonce, aux}` 开头;控制连接上 Hello 在它之后。编解码在 `Transport/PairBind.h`。
|
||||
- TCP 产品路径不变:`ConnectControl` 单连接,数据连接凭 server 发的 `Welcome.dataNonce` 绑定(`DataBind`,PH-7 (4)),`TcpSupervisor` 的预认证门本来就丢探测。
|
||||
|
||||
### 规则(`Server/PairAcceptor.{h,cpp}`,取代已删的 `SocketTransport::AcceptPair`)
|
||||
|
||||
| 连接的首帧 / 状态 | 处置 |
|
||||
|---|---|
|
||||
| 一字节未发就关(就绪探测) | 关闭,D 级日志 |
|
||||
| `PairBind`,另一角色同 nonce 已在等 | 成对交出(控制作流、aux 作描述符通道) |
|
||||
| `PairBind`,同 nonce 同角色已在等 | `Refuse{Authentication}`,关新来者 |
|
||||
| `Hello`(修订号 < 4 的 client) | 按 `RunSession` 的顺序问:token → 线上格式;旧 client 得 `Refuse{WireFingerprint}`,都过的仍 `Refuse{MalformedHello}`;从不配对 |
|
||||
| `DataBind` / 其它 | `Refuse{Authentication}` "data connection names no live session" / `Refuse{MalformedHello}` + 形状细节 |
|
||||
| 自 accept 起 2000 ms 内未发 `PairBind`,或伙伴未到 | 控制与未识别者 `Refuse{Authentication}` 后关;aux 直接关(其 client 在那里只收描述符);W 日志 |
|
||||
| 同时未配对的超过 16 条 | 丢最老的未识别者(没有则最老者),`Refuse{Busy}` |
|
||||
|
||||
- 从不读过 `PairBind` 一个字节(`FirstFrameAssembler`):控制连接后面的 Hello 归会话读,aux 后面是 `SCM_RIGHTS`。
|
||||
- 有状态:A-control、B-control、B-aux、A-aux 时先交出 B,A-control 留给下一次 `Accept`。`Accept(timeoutMs)` 超时返回 `TIMEOUT`,未配对的留着。
|
||||
- 调用点:`UnixInProcessSupervisor`(成员)与 `mobilegl_server_main` 的 unix 分支。`--serve` 的会话子进程 `CloseInForkedChild`(只 `close`,不 `shutdown`);单会话形状配对后即析构,其余等待者得 `Refuse{Busy}`。`RefuseBusy` 不变(Hello 仍在套接字里)。
|
||||
|
||||
### 版本互通
|
||||
|
||||
| | 修订 3 server | 修订 4 server |
|
||||
|---|---|---|
|
||||
| 修订 3 client | — | `PairAcceptor` 代答 `Refuse{WireFingerprint}`,从不配对 |
|
||||
| 修订 4 client | 旧 server 按顺序配对后首帧是 `PairBind` → `Refuse{MalformedHello}` "first control frame is not a verifiable Hello";旧会话退出若抢在 client 发 Hello 之前,client 只见发送失败 | 正常 |
|
||||
|
||||
### 门
|
||||
|
||||
- 单元 `Endpoints/PairAcceptorTest.*/{unix,tcp}`(8 例):(1) 探测后紧跟 client;(2) 四条交错;(3) 孤儿 aux 过预算被关、下一个 client 成对;(4) Hello 先到的旧 client 具名拒绝。每例用 `ServesExactly` 证身份(控制双向各一帧 + 该 client 的 aux 字节是 server aux 上的头几个字节)。
|
||||
- 端到端 `ServerSpawnTest.AStrayConnectionAheadOfTheClientDoesNotTakeItsSession`:单会话 unix server,探测之后真 client 握手成功、server 退出 0。
|
||||
- red-once:`PairAcceptor::Accept` 换回到达顺序配对(仍读掉首帧,只差配对规则)→ 单元 8/8 红((1) 控制连接是已关的探测;(2) aux 读到的不是本 client 的字节),端到端握手 rc=6(与设备上 `no Welcome … (rc=6)` 同);对照 `StartsAServerProcessAndHandshakesAcrossIt` 仍绿。拷回原文件、`cmp` 字节相同后复绿。
|
||||
|
||||
### 不变量
|
||||
|
||||
- G1:新代码全在 `MG_Remote`(`MOBILEGL_BUILD_DISAGGREGATED` 下)。
|
||||
- 未改:`TcpSupervisor`、预认证门、`DataBind`、会话读 Hello 的路径。
|
||||
|
||||
## B1:同机外部 client 经 app_process helper 与令牌 broker 走共享内存
|
||||
|
||||
依据 [`PLAN-P11.md`](../../docs/Disaggregated/notes/p11/PLAN-P11.md) §2 B、[`B0-CROSS-APP.md`](../../docs/Disaggregated/notes/p11/B0-CROSS-APP.md)、[`HSPIKE.md`](../../docs/Disaggregated/notes/p11/HSPIKE.md)(ID-P11-13)。消费者:同一台手机上从另一个 app(Termux、adb shell)启动、没有 Java `Context` 的原生 GL 程序。证据根 `~/w7/notes/p11/evidence/b1/`(下文的 `evidence/b1/…`、`m-probe*`、`freeze-*` 都在它下面),报告 `~/w7/notes/p11/b1-report.md`。
|
||||
|
||||
### 链路
|
||||
|
||||
| 步 | 谁 | 做什么 |
|
||||
|---|---|---|
|
||||
| 1 | 用户 | `MOBILEGL_IPC_TOKEN=<令牌> CLASSPATH=<server APK> app_process / top.mobilegl.plugin.ExternalClientHelper [--server <包名>] [--timeout-ms <n>] [--keep-affinity] -- <程序> [参数…]`(server 界面给出可复制的整行:APK 路径取 `getApplicationInfo().sourceDir`,不靠 `pm path`——包可见性会过滤 app uid 的查询) |
|
||||
| 2 | helper(`app_process`,client 自己的 uid) | 令牌取自 `MOBILEGL_IPC_TOKEN`,否则取 `MOBILEGL_IPC_TOKEN_FILE` 指的文件;**从不取 argv**(`--token` 具名拒绝)。`--server` 缺省为 `BuildConfig.APPLICATION_ID`(加载它的那个 APK 的包名) |
|
||||
| 3 | helper | 经隐藏的 `IActivityManager.broadcastIntentWithFeature`(null caller,参数按类型填,末位 int = user id)发显式广播:组件 `<包名>/top.mobilegl.plugin.ExternalClientBroker`,action `top.mobilegl.plugin.EXTERNAL_CLIENT_CONNECT`,`FLAG_RECEIVER_FOREGROUND \| FLAG_INCLUDE_STOPPED_PACKAGES`,extra `mobilegl_broker` = Bundle{`callback`: helper 自建的 Binder,`token`,`version`=2} |
|
||||
| 4 | broker(导出的 receiver,两个口味都有,跑在 `:mglsrv`) | 按下表逐条检查;通过则连两次 server 的 unix 端点(`@name` 或路径;相对路径按 `filesDir` 解析)。server 只听 `tcp://` 时,`MobileGLServerService` 在旁边多起一个 supervisor,听私有抽象名 `@<包名>.broker.<8 位 hex>`(同一二进制、同一环境与令牌),broker 连它。连上后**立即写 PairBind 对**(ID-P11-12:谁开连接谁出示;新 nonce,控制 `aux=false`、辅助 `aux=true`;字节见下「交接时配对」) |
|
||||
| 5 | broker → helper | **每个请求都回话**,单向 `transact`:`FIRST_CALL_TRANSACTION` = int version(2)+ 控制 PFD + 辅助 PFD + long applyCore(在跑的 supervisor 启动时宣布的保留核,0 = 无)+ int flags(bit 0 = 已在交接时配对);`FIRST_CALL_TRANSACTION+1` = String 拒绝名 + String 说明 |
|
||||
| 6 | helper | 两个 fd 清 `FD_CLOEXEC`,`execve` 程序(applyCore ≠ 0 且没给 `--keep-affinity` 时经 `/system/bin/taskset <在线 & ~applyCore>`);环境 = 原环境 − `CLASSPATH` + `MOBILEGL_TRANSPORT=spawn`、`MOBILEGL_IPC_CONTROL=fd:<控制>,<辅助>`、`MOBILEGL_IPC_DATA=shm`、`MOBILEGL_IPC_TOKEN=<令牌>`,flags bit 0 时再加 `MOBILEGL_IPC_FD_PAIRED=1` |
|
||||
| 7 | client(`fd:` 端点) | 见下;之后与 `unix:` 完全相同:Hello(dial = Connect)、Welcome、7 个 fd 经 `SCM_RIGHTS`、SharedSegments |
|
||||
|
||||
### `fd:<控制>,<辅助>` 端点(`ClientSession::StartSpawned`,`SocketTransport::AdoptConnectedPair`)
|
||||
|
||||
- 文本严格:两个十进制数、一个逗号,别的都不收;`MOBILEGL_IPC_DATA` 只收 `auto` / `shm`。违者 `Refuse{ProtocolMismatch}` 具名、`MOBILEGL_ERR_UNSUPPORTED`。
|
||||
- 两个描述符必须互不相同、在本进程打开、是 `AF_UNIX` + `SOCK_STREAM`、已连接(`getpeername`);否则 `Refuse{ProtocolMismatch}` 说明哪一条,`MOBILEGL_ERR_INVALID_ARGUMENT`,**一个字节不写**。TCP 套接字被拒(没有描述符通道,用 `tcp://`)。
|
||||
- 收养后两个 fd 设 `FD_CLOEXEC`(程序自己的子进程不继承)。
|
||||
- `MOBILEGL_IPC_FD_PAIRED=1`(helper 按 broker 的 flags 设):PairBind 已由 broker 在交接时出示,本端点**不再写**(`SocketTransport.cpp:492`),直接 Hello。没有这个标记时本端点自己出示一对(CSPRNG 16 字节 nonce,控制 `aux=false`、辅助 `aux=true`,然后 Hello——与 `ConnectTo` 同),供裸连接交来的 fd(测试、旧 broker)。
|
||||
- 自己出示时发送失败(server 已拒绝并关掉这一对):两个 fd 留给调用方,client 读控制连接上待读的拒绝帧并具名报出(如 `peer Refuse{Authentication} no PairBind within the pairing budget`),不只是一个发送错误。
|
||||
- 一对 fd 只够一个会话:会话结束(或同一进程再起会话)时 fd 已关,第二次收养具名失败。
|
||||
|
||||
### 交接时配对与等 Hello 的时限(ID-P11-12)
|
||||
|
||||
- broker 连上两条连接后立即写 PairBind 对(`PairBindFrames.java`:帧头 magic `0x464C474D` + 长度,小端;负载是原生 `EncodePairBind` 的输出,16 字节 nonce 在最后)。两个前缀是编码器的字节;`ServerSpawnTest.TheBrokersPairBindTemplatesAreTheEncoders` 从 Java 源文件读出前缀、对 32 个随机 nonce 与 `AppendFrame(EncodePairBind(…))` 逐字节比较,`protocol.fbs` 一改就红。`PairAcceptor` 的 2000 ms 配对预算(`PairAcceptor.h:63`)因此在 broker 手里满足,不再等程序跑到第一个 EGL 调用。
|
||||
- **配对之后等 Hello:没有时限,靠 EOF。** 之前是 10 s(`RunSession` 的 `helloWaitMs`,`ServerMain.cpp:385` 的读);现在 unix 端点的 `--serve` 会话子进程与单会话形状都用 `kPairedUnixHelloWaitMs = kWaitForever`(`ServerMain.cpp:136`,调用点 `:1537`、`:1562`)。理由:配对时身份已定(nonce),unix 端点只有本用户 / 本 app 能连(Android 上 SELinux,路径上 0600;开发机 Linux 上一个 `@abstract` 名同一 network namespace 内谁都能连——这是产品设备上的论证),而一个先加载资源的程序要多久没有上界;程序退出或关掉描述符 → EOF → `control peer closed before sending a first frame`,会话子进程干净退出。代价:程序活着但迟迟不 Hello 时,它占着唯一的会话槽(与一个正在渲染的会话相同):别的 client 在配对后 2 s 内说 Hello 时得 `Refuse{Busy}`;更慢的那个只见到 Hello 发送失败——`RefuseBusy` 写完 Busy 就关了连接,而 Hello 发送失败的路径不读待读的拒绝帧(`AdoptConnectedPair` 那条路径会读);未修,见 B1 报告附录。TCP 保留预认证时限(`PreAuthKnobs`);进程内显示 server(`:mglwin`,`ServerMain.cpp:1395`)保留 10 s(它停止时要等会话线程)。
|
||||
|
||||
### 令牌
|
||||
|
||||
- broker 比对的是**正在运行的 server 自己的** `MOBILEGL_IPC_TOKEN`(启动 server 时界面上的 Auth token),常量时间比较。
|
||||
- server 的令牌不足 16 字节(含空)→ `server-no-token`:不接同机外部 client。unix 端点对同 app client 仍然不要令牌(行为不变)。
|
||||
- helper 把令牌放进被 exec 程序的环境,Hello 也带它:server 配了令牌时 `AuthenticatePeerToken` 在 unix 会话上照样核对(`Refuse{Authentication}`)。
|
||||
- 令牌只经环境、令牌文件、Binder 事务传;不进任何进程的 argv。
|
||||
|
||||
### 拒绝
|
||||
|
||||
| 名 | 条件 | helper 退出码 |
|
||||
|---|---|---|
|
||||
| `bad-request` | 没有 `mobilegl_broker` Bundle / callback(只能记日志)或 version ≠ 2 | 64 |
|
||||
| `token-missing` | 未出示令牌 | 65 |
|
||||
| `token-wrong` | 令牌不符;不连、不给 fd | 66 |
|
||||
| `server-no-token` | server 令牌 < 16 字节 | 67 |
|
||||
| `server-not-running` | `:mglsrv` 里没有在跑的 server(广播可以把 `:mglsrv` 进程拉起来——server app 被强停后也一样,设备实测——但 Android 12+ 不许后台 receiver 起前台服务,所以答"先在 MobileGL 的 server 界面启动 server",不挂起)。只认离屏服务;`:mglwin` 显示 server 在跑时也答它 | 68 |
|
||||
| `broker-busy` | 另一个请求正在 broker 里连接,或 server 的监听 3000 ms 内没接受两条连接 | 69 |
|
||||
| `connect-failed` | server 在跑但它的端点拒绝连接,或 PairBind 写不进去 | 70 |
|
||||
| (helper 本地)无应答 | `--timeout-ms`(缺省 10000)内 broker 没回话:包没装,或系统没把停止的 app 拉起来(自启动管控) | 71 |
|
||||
| (helper 本地)广播发不出 | 反射拿不到 `IActivityManager` / 调用抛异常(见"依赖 ROM") | 72 |
|
||||
| (helper 本地)exec 失败 | | 73 |
|
||||
| 用法错 | 无程序、未知选项、`--token` | 2 |
|
||||
|
||||
### apply 线程的亲和 / 自旋(`Server/ApplyThreadPolicy.h`)
|
||||
|
||||
`ServerSession::Accept` 记下 Hello 的 dial mode 与数据面;`ServerLoop` 的 apply 线程按它们解析 `MOBILEGL_IPC_SERVER_AFFINITY=auto`:
|
||||
|
||||
| peer | 数据面 | `auto` |
|
||||
|---|---|---|
|
||||
| in-process(inproc,dial No) | — | 全部大核、配置的自旋(不变) |
|
||||
| forked(同 app fork spawn,dial Fork) | 共享段 | 同上(不变) |
|
||||
| connected(dial Connect:`tcp://` / `unix:` / `fd:`) | stream | 同上(不变:io 线程喂 apply 线程,B0 实测 apply 7.9 ms/帧 vs shm 26.8) |
|
||||
| connected | 共享段 | 一个核,`ReservedApplyCore(big, prime, online)`(`ApplyThreadPolicy.h:120`):≥ 2 个 prime 核(峰值主频)→ 最低编号的 prime 核;只有 1 个 prime 核 → 它旁边最低编号的其他大核;只有 1 个 prime 核且无其他大核 → 不设亲和;无非对称(全是大核或读不到拓扑)→ 不设亲和。**从不把唯一的 prime 核给自旋的 apply 线程**。自旋 `kConnectedPeerSpinUs` = 50 µs(`MOBILEGL_IPC_SPIN_US` 显式设了则用它) |
|
||||
|
||||
- **一个来源**:保留核只由原生规则算。supervisor 启动时(`ServerMain.cpp:1485`)按本机拓扑与 `MOBILEGL_IPC_SERVER_AFFINITY`(显式掩码 / `off` → 0)算出 `ReservedApplyCoreForThisProcess`(`ServerLoop.cpp:210`),在 stdout 打印 `MG_Remote server: apply core reserved for dialled-in shared-segment clients: 0x40 (<规则>)`;`MobileGLServerService` 逐行读 supervisor 输出(`ServerEnvironment.parseReservedApplyCore`),broker 把它放进答复;helper 经 `/system/bin/taskset <在线 & ~applyCore>` exec 程序(亲和跨 exec 继承);`--keep-affinity` 不设。Java 不再重算规则。代价:整个程序少用一个核。
|
||||
- 显式掩码或 `off` 对所有 peer 生效(与以前相同);`MOBILEGL_IPC_SPIN_US` 设了就用设的值。
|
||||
- 启动日志 `mgl-srv-apply started … RESOLVED mask 0x…, spin N us; peer <in-process|forked|connected> on <shared segments|stream>, policy <规则>`,规则名写明是哪一种(最低 prime / 唯一 prime 旁的大核 / 唯一 prime 留给 client 而不设亲和 / 无非对称)。
|
||||
- P12 的进程内显示 server(`:mglwin`)的 client 也是 dial Connect:它们走 stream 时不变,走 unix 共享段时得到本规则。
|
||||
|
||||
选择依据(红米,rd12 稳态 fps,helper 路线,默认落位、定频;`evidence/b1/m-policy.tables.md`):
|
||||
|
||||
| 候选(apply 掩码, 自旋) | a shm Espryt | a tcp Espryt | b shm Espryt | b tcp Espryt | a shm Magma | a tcp Magma |
|
||||
|---|---|---|---|---|---|---|
|
||||
| 旧 auto(0xc0, 50) | 21.5 | — | 62.5 | — | 22.1 | — |
|
||||
| 最高大核(0x80, 50) | 26.7 | — | **6.5** | — | — | — |
|
||||
| 最低大核(0x40, 50)= q1 | 26.5 | 51.1 | **119.9** | 40.3 | 21.9 | 20.3 |
|
||||
| 0x40, 不自旋 | 16.9 | — | 73.6 | — | 22.5 | — |
|
||||
| 不设亲和, 50 | 21.7 | — | 64.9 | — | 23.3 | — |
|
||||
| 不设亲和, 不自旋 | 20.2 | — | 12.8 | — | 20.7 | — |
|
||||
| 非大核(0x3f, 50)= q3 | 49.0 | 27.0 | 50.3 | 29.2 | 18.4 | 13.9 |
|
||||
|
||||
- 前台 app 的 GL 线程被调度器放在**最高**大核(cpu7,44 次采样中 43 次):把 apply 线程钉在 cpu7 就与它同核(6.5 fps);钉在 cpu6 得到 B0 手工定核的布局(120)。
|
||||
- 不自旋(0)在每一格都输:保留 50 µs。
|
||||
- adb shell 的 client 被放在 cpu6(与 apply 线程同核):q1 下路线 a 的 shm 26.5 < tcp 51.1。q3(apply 放非大核)能让 shm ≥ tcp,是因为它**同样**把 tcp 会话的 apply 线程放到慢核(tcp 51 → 27),会拖慢所有同机 TCP client(FCL loopback、`:mglwin`),所以不用;改为数据面分流(stream 不变)+ helper 让程序避开保留核。
|
||||
|
||||
### 保活
|
||||
|
||||
- server 仍是前台服务(`dataSync`,带 partial wake lock);broker 从不启动它。前台服务本身挡不住 HyperOS 的冻结(greeze / SmartPower,B0 F1)。
|
||||
- **用户必须设**:server app 与 client 所在 app 的"省电策略"都选"**无限制**"(HyperOS:设置 → 应用 → 应用管理 → <app> → 省电策略 → 无限制;powerkeeper 记为 `bgControl=noRestrict`,并进 deviceidle 白名单),再在 server 界面设 Auth token(≥ 16 字节)、以离屏模式启动。
|
||||
- 设了(红米,`evidence/b1/freeze-{a,b}`):路线 a、b 各熄屏 180 s,在飞会话(rd12 + 200 s 保持)**存活**(正常结束,0 个 Fatal),熄屏期间每 45 s 新起的 3 个路线 a 会话都通过(ssim 1.0);两 app 所有进程的 cgroup.freeze 采样 0 / 103 与 0 / 143,无 `do_freezer_trap`;系统日志 `PolicyMaker: uid=… pkg=<server> reason=NO_RESTRICT_APP`。
|
||||
- 不设(缺省"智能限制后台运行")时具名失败的样子:client app 在前、server app 在后,greeze 对 server uid `setUidState allow=false`、停用其 wake lock,路线 b 的会话 `no Welcome from the spawned server within 5000 ms (rc=7)`(`m-probe2-defaultbattery`,屏亮时就发生,非必现);熄屏约 7 s 后冻结整个 server uid,在飞会话 120 s 后 `Fatal{BarrierTimeout}`(B0 F1、HSPIKE §7)。
|
||||
- 已知:这台机上旧包 `top.mobilegl.plugin.trace` 的"省电策略"页不显示选项(原因未查),门改用新装的 `top.mobilegl.plugin.b1.trace`(像用户新装一样)。
|
||||
|
||||
### 依赖 ROM
|
||||
|
||||
- 直接跑的 `app_process` 不是 zygote fork 出来的,不受 app 的隐藏 API 黑名单约束,`IActivityManager.broadcastIntentWithFeature` 才能反射调用(HyperOS / Android 16 上 `hiddenapi` 日志 0 条,shell 与 app uid 都通)。若某 ROM 对它也强制执行,helper 以退出码 72 具名失败;没有替代(`am broadcast` 带不了 Binder)。
|
||||
- HyperOS 的冻结(greeze / SmartPower)不看前台服务:见"保活"。
|
||||
|
||||
### 线上格式
|
||||
|
||||
无变化(控制协议修订 4,PAIR)。`fd:` 只是 client 端点的一种写法;broker 协议是 Android Binder 上的 Bundle / Parcel,不属于 MobileGL 线上格式。
|
||||
|
||||
### 门
|
||||
|
||||
- 单元:`ApplyThreadPolicy.*`(8 例:每个 peer × 数据面的 `auto`、最低大核与非连续大核集、对称 / 单大核 / 读不到拓扑、显式掩码 / `off` / 显式自旋、认不出的文本);`ServerSpawnTest.AnFdPairTheBrokerConnectedBringsASharedSegmentSessionUp`(真 server 进程,两次裸连接交给 `fd:`,会话起、fd 为 CLOEXEC、server 退出 0)、`…AnAdoptedFdPairPresentsOnePairBindPairBeforeAnythingElse`(在 server 侧读:每条连接恰一帧 PairBind,同 nonce,aux 标志正确)、`…AnFdEndpointThatIsNotAConnectedUnixPairIsRefusedByNameAndWritesNothing`(管道、同一 fd 两次、未打开、未连接、八种坏文本、`stream`,都具名拒绝且一字节不写);Java 镜像 `ServerEnvironmentTest`(`reservedApplyCore` 7 条,`test_android_lifecycle.py`)。
|
||||
- red-once:`AdoptConnectedPair` 不写 PairBind → 端到端例红,client 日志 `peer Refuse{MalformedHello} the control connection's first frame is a Hello, not a PairBind (control revision 4 pairs by nonce)`,PairBind 例红(控制连接上无帧);保留核取最高大核(设备否决的规则)→ 3 例红;策略不看数据面 → stream 例红。每次拷回原文件、`cmp` 相同后复绿。
|
||||
- 跟进(交接时配对、唯一 prime 核、单一来源):`ServerSpawnTest.TheBrokersPairBindTemplatesAreTheEncoders`(Java 前缀 = 编码器字节,32 个随机 nonce × 两个角色)、`…APairTheBrokerPresentedAtHandoffWaitsForAHelloThatComesSecondsLater`(broker 的字节在交接时写出,Hello 5 s 后才来,会话起)、`…APairPresentedOnlyWhenTheProgramStartsIsRefusedByNameOnceThePairingBudgetIsGone`(旧流程:3 s 后才出示 → client 日志 `peer Refuse{Authentication} no PairBind within the pairing budget`);`ApplyThreadPolicy.*` 10 例(加唯一 prime 核旁有 / 无其他大核、无非对称、`ReservedApplyCoreForConfig`);Java `PairBindFramesTest`、`ServerEnvironmentTest`(宣布行解析 5 条)。red-once:交接步骤拿掉(今天的 client 侧配对)→ 交接例红,`Refuse{Authentication} no PairBind within the pairing budget`;Hello 时限改回有限的 3 s → 红,`Refuse{Authentication} no authenticated first frame within the pre-auth deadline`;client 不看标记、再出示一对 → 红,`Refuse{MalformedHello} first control frame is not a verifiable Hello`;保留核不看 prime 集 → 唯一 prime 的两例红;Java 前缀改一个字节 → 模板例红。每次拷回、`cmp` 相同后复绿(`~/w7/logs/p11/b1/redonce4.out`)。
|
||||
- 设备门(红米 `2f7cbe2e`,HEAD `3519a21b` 的 APK,两 app "无限制",默认环境:不手工定核、无解冻守护;CPU 定频并回读只为可重复,`evidence/b1/m-gate.summary.md`):16 个 ssim 格全过(rd12 0.99988 / 0.999884,openra 1.0);shm(helper)对 tcp 的稳态 fps 中位数:
|
||||
|
||||
| 路线 | 后端 | rd12 shm / tcp | openra shm / tcp |
|
||||
|---|---|---|---|
|
||||
| a(shell uid) | Espryt | 119.2 / 53.1(2.25×) | 927.6 / 427.5(2.17×) |
|
||||
| a | Magma | 36.8 / 20.2(1.82×) | 281.2 / 278.6(1.01×,8 次) |
|
||||
| b(另一 app,在前) | Espryt | 119.9 / 39.0(3.07×) | 923.4 / 377.4(2.45×) |
|
||||
| b | Magma | 31.5 / 20.2(1.56×) | **285.3 / 286.6(1.00×,8 次,差 0.5%)** |
|
||||
|
||||
15 / 16 格 shm ≥ tcp;Magma openra 路线 b 按合并中位数差 0.5%(逐次配对 shm 赢 6 / 8,区间完全重叠):该负载两个数据面都受 server 端限制,shm 不增益。拒绝(token-wrong a/b、token-missing、server-not-running a/b 与强停后、server-no-token)都按名、退出码对、无会话。同 app spawn+shm / inproc 的 rd12 p50 与 A4 相同(策略对 Forked / InProcess 不变,日志 `mask 0xc0`)。
|
||||
|
||||
- 重定基后的设备复测(`df826f42` 的 APK,两 app "无限制",默认环境;`evidence/b1/m-pass2.summary.md`、`m-openra3.summary.md`):rd12 八格 ssim 全过;shm / tcp 中位数(3 次交错)路线 a Espryt 119.3 / 53.2、Magma 36.4 / 20.3,路线 b Espryt 118.7 / 39.8、Magma 32.5 / 20.4;22 个 shm 运行全部"交接时配对"。Magma openra 在干净设备上重测:路线 a 296.4 / 284.4、路线 b 292.7 / 281.6(都 1.04×)——首轮门那一格的 5 次补测与一个失控的采样子进程(root `tr`,占满一个核约 65 分钟)同时跑过,不作数。慢启动:helper exec 一个先睡 10 s 的包装再 exec retrace,broker 交接后 10.2 s 才 Hello,两后端会话都起、ssim 过。plugin 口味(`.b1p`,界面上 Generate token + Start server):helper 路线 openra ssim 1.0、rd12 0.99988,HyperOS 省电策略页显示四个选项。
|
||||
|
||||
### 不变量
|
||||
|
||||
- G1:原生改动全在 `MG_Remote`(`MOBILEGL_BUILD_DISAGGREGATED` 下);pull 构建符号增 0 减 0。
|
||||
- 线上格式与控制协议修订号不变(4)。
|
||||
@@ -1,64 +0,0 @@
|
||||
# P12:server 自有屏幕窗口
|
||||
|
||||
2026-09-29。依据 `docs/Disaggregated/notes/p12/`([`PLAN-P12.md`](../../docs/Disaggregated/notes/p12/PLAN-P12.md)、裁定 `INTEGRATOR-DECISIONS-P12.md` ID-P12-1..15、验收 [`CROSSHOST-ACCEPTANCE.md`](../../docs/Disaggregated/notes/p12/CROSSHOST-ACCEPTANCE.md) / [`FCL-ACCEPTANCE.md`](../../docs/Disaggregated/notes/p12/FCL-ACCEPTANCE.md))。本文只记实现所需的协议与行为;验证结果以那些文件里的运行证据为准。
|
||||
|
||||
## 范围
|
||||
|
||||
server 应用自己拥有一个窗口,把 client 渲染的帧直接上屏;client 不需要窗口。**离屏(pbuffer)路径不变**,两条路径**每会话只有一条活跃**。不在本阶段:X11 / Win32 / None 窗口种类的白名单(D8)、cached-app freezer 的完整处理、多 context、TLS、把触摸转发给 client。
|
||||
|
||||
## 配置
|
||||
|
||||
- client:`MOBILEGL_IPC_SURFACE=offscreen|server`(默认 `offscreen`)。`server` 让 `eglCreateWindowSurface` 向远端 server 要它自己的窗口;没有远端 server 时忽略并说一次。
|
||||
- server:进程是否拥有显示由宿主决定(`ServerDisplay` 钩子已安装 = 拥有)。fork 出的离屏 supervisor 不拥有。
|
||||
|
||||
## 线上格式(控制面修订 3)
|
||||
|
||||
- `WindowKind.ServerOwned = 7`,只在 `CreateWindowSurface` 上合法;`nativeToken` 恒为 0,**没有任何指针过线**(Rule G / H)。`SetWindowHandle` 不得指名它(`SurfaceRefusal::ServerOwnedOnSetWindowHandle`)。
|
||||
- `SurfaceReply` 追加 `width`、`height`(server 窗口实际尺寸)与 `refusal`。`SurfaceRefusal`:`NoServerDisplay`(server 没有显示)、`NoServerWindow`(有显示但等不到窗口)、`SurfaceModeMismatch`(会话已被另一种表面模式闩定)、`ServerOwnedOnSetWindowHandle`。拒绝是具名的 `ok=false` 应答,**不闩会话**。
|
||||
- 修订号 2 → 3,`wireFingerprint` 随之移动:client 与 server 一起重装。
|
||||
- client 的 `SetWindowHandle` 不再无条件发送(server-owned 模式下不发)。
|
||||
|
||||
## 表面模式
|
||||
|
||||
会话的表面模式在**第一次成功的表面创建**时闩定:ServerOwned 窗口 → 上屏,pbuffer → 离屏;之后另一种具名拒绝(`SurfaceModeMismatch`)。client 自己命名的窗口(X11 / Win32 / None)既不闩也不拒(D8 未关)。
|
||||
|
||||
## 窗口租约与失窗
|
||||
|
||||
- `ServerDisplay` 持有窗口引用与租约;创建表面时 apply 线程按需取租约。窗口没有时等(有界),同时按 `SurfaceProgress` 心跳,client 读作"还在跑"而不是"活着但沉默"。
|
||||
- **失窗的顺序即契约**(`surfaceDestroyed` → `Detach`):apply 线程先让后端放掉窗口(Espryt 销毁 EGL surface / context,Magma 销毁 swapchain / VkSurface),再以 `Fatal{ServerWindowLost}` 闩会话,**最后**才结束租约、让回调返回。`Detach` 有界 3 s,超时不抽走窗口。失窗请求在 `DrainRing` 每次 pop 之前也检查。
|
||||
- 窗口属于显示进程,不属于会话:会话结束后窗口还在,下一个会话接着用;Espryt 的孪生对象与单元影子随会话清空(`DropEveryTwinForEndedServerSession`),下一会话从空表开始。
|
||||
|
||||
## 几何
|
||||
|
||||
- client 请求 `W×H`:`W,H > 0` → server 显示 `SurfaceHolder.setFixedSize(W,H)`,视图**等比缩放、留黑边**放进屏幕;`0/0` → `setSizeFromLayout`(窗口自己的大小)。请求是异步应答,server 等布局回报(ID-P12-9)。
|
||||
- **请求尺寸的来源**:`eglCreateWindowSurface` 的 `EGL_WIDTH/EGL_HEIGHT`;两者缺省(SDL 就是这样)且传入了 native window 时,取 `ANativeWindow_getWidth/Height`(Android、split 构建、server-owned)。缺这一步时游戏按自己的窗口渲染、server 窗口取屏幕尺寸,横屏游戏在竖屏窗口里被裁成左下角。
|
||||
- `ResizeEGLWindowSurface` 走同一条几何请求,后端表面随窗口**真实**尺寸,reply 带回该尺寸,client 采用它(ID-P12-10)。`kEventSurfaceChanged` 携带宽高(Espryt 以前只发格式,client 的默认帧缓冲会停在 512×512 占位值)。
|
||||
|
||||
## 死亡与 device-lost
|
||||
|
||||
- device-lost 只由对端**挂断**闩住,从不由超时闩住(CONTRACT-P6 §5.4 不变)。杀 server 进程后 client 在毫秒级闩住,随后每个 verb 被 DECLINED,`glGetGraphicsResetStatus` 报 `GL_UNKNOWN_CONTEXT_RESET`。
|
||||
- 闩锁的 `DEVICE LOST` 说一次;闩住之后 DECLINED 的 verb **不再逐条打 ERROR**(一个 FCL 游戏几千次/秒)。
|
||||
|
||||
## server 的形态
|
||||
|
||||
- **进程内显示 server**(`MobileGLDisplayActivity`,进程 `:mglwin`):TCP / unix 监听线程 + 会话线程(`TcpSupervisor::Handoff::Thread`),预认证 / Busy / DataBind 路由与 fork 形状是同一份代码;会话串行;后端**按进程钉住**(无 `MOBILEGL_BACKEND_TYPE` 时取第一个会话的);会话间 `ResetSessionLatch`。以崩溃隔离换窗口可达:会话里一个未武装的 `SessionFail` 会带走整个显示进程。
|
||||
- **离屏 supervisor**(`MobileGLServerService`):每会话 fork 一个子进程,子进程 `PR_SET_PDEATHSIG` 随 supervisor 去。
|
||||
- **同一设备一个 server**:显示 Activity 与离屏 service 互相替换(谁后启谁拥有端口)。Render Server 屏(`ServerControlActivity`)是两种形态的入口,字段与 extras:`listen` / `token` / `env`(`KEY=VALUE;KEY`)/ `onscreen` / `start` / `stop`。
|
||||
- 停止推流中的进程内 server 时,会话在 `loop.Stop()` 前放弃队列里剩余记录(`AbandonQueuedRecords`);正常的 client EOF 仍 drain 完。
|
||||
- 转发日志:进程内 server 只有会话线程与选择加入的线程转发,且在释放日志互斥之后、在独立转发互斥下发送。
|
||||
|
||||
## FCL 集成(FCL fork,不在本仓库)
|
||||
|
||||
- FCL 的界面一退后台就把游戏暂停;server 窗口要在屏幕上,FCL 必然在后台。版本设置 **`keepRunningInBackground`**("游戏退到后台时不暂停",默认关):强制 TextureView 并保留它的 SurfaceTexture,界面离开前台时不通知 SDL 暂停、不撤销 GLFW focused / visible。
|
||||
- FCL 默认的 spawn(游戏进程派生 server 子进程)把自己的窗口指针发给 server,按 Rule H 被拒(`UnmigratedSurface`):**只能接外部 render server**,`MOBILEGL_IPC_CONTROL=tcp://127.0.0.1:<port>`、`MOBILEGL_IPC_DATA=stream`、`MOBILEGL_IPC_SURFACE=server`;后端由 `mg_env.txt` 里的 `MOBILEGL_BACKEND_TYPE` 选。
|
||||
- 时序:FCL 的游戏界面出现后要再等约 10 s 才能把 server 窗口切到前台。
|
||||
|
||||
## 不变量
|
||||
|
||||
- G1:pull 构建符号 0/0/0/0,`.text` 不变(全部新代码在 `MOBILEGL_BUILD_DISAGGREGATED` 下;`EGLImpl` 的新分支还要 `__ANDROID__`)。
|
||||
- 离屏路径仍是门(gate 3 跑 `--use-pbuffer`)。`RefuseCode` 只追加。
|
||||
- 会话里 server-owned 表面之外的表面(`SurfaceModeMismatch`)具名拒绝,会话继续。
|
||||
|
||||
## 仍开放
|
||||
|
||||
D8 窗口种类白名单(X11 / Win32 / None 仍被接受并把 token 强转为指针);freezer 的完整处理;多 context;TLS;server 窗口不转发输入;DirectGLES 的 `g_Display/g_Surface/g_Context` 仍是全局(每进程一个会话时不需要);修后的横屏 server 窗口没有重测。
|
||||
@@ -431,8 +431,7 @@ The wave-3 tail no P5b package owns, by name, so nobody discovers it by grep: `B
|
||||
`GetSyncStatus`, `BeginTimeElapsedQuery`, `EndTimeElapsedQuery`, `QueryCounterTimestamp`,
|
||||
`IsQueryResultAvailable`, `GetQueryResult64`, `DeleteBackendQuery`, `BeginOcclusionQuery`,
|
||||
`EndOcclusionQuery`, `BeginXfbPrimitivesQuery`, `EndXfbPrimitivesQuery`, `GetGpuTimestampNs`,
|
||||
`SetSwapInterval` - P9 (readbacks), P10 (queries, syncs, swap interval). (2026-09-29: all are
|
||||
emitted now; the last one, `SetSwapInterval`, went in P10 - `CONTRACT-P10.md` §2.)
|
||||
`SetSwapInterval` - P9 (readbacks), P10 (queries, syncs, swap interval).
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -140,11 +140,7 @@ The client shadow for such levels is stale and that is CORRECT: the two readers
|
||||
observe the staleness are both named refusals under split — `glGetTexImage` served from the
|
||||
client shadow (class C, P9) and `texture-remint-pull` (`Fatal{UnmigratedEmulation}`). This is
|
||||
i1's copy-image-shadow-mirror ruling (CONTRACT-P5B §2) applied to the mip chain, and tx
|
||||
reports which scenarios reach either Fatal. **AMENDED (P9 W2):** the second reader is gone rather
|
||||
than refused — under a transport a re-mint reads the GPU level itself
|
||||
(`RequireImageBindableStorageByHandle`) and never the client shadow, so a GPU-generated level
|
||||
survives it; the marker and `OnTexturePullRequest` were deleted
|
||||
(`docs/Disaggregated/notes/p9/W2-REMINT.md`).
|
||||
reports which scenarios reach either Fatal.
|
||||
|
||||
### 2.4 The audit gate (E-P5c #2)
|
||||
|
||||
|
||||
@@ -494,12 +494,7 @@ per unit, not every slot of every touched unit; coverage is unchanged (views ∪
|
||||
attachment lists ∪ the waited texture ops). `RequireImageBindableStorage`'s re-dirty arm
|
||||
(`Managers.cpp:5930-5962`, already aborting three frames deep) becomes a NAMED refusal at its
|
||||
entry under a transport, `Fatal{UnmigratedEmulation, "image-bindable-redirty"}`; `ImageBindableHint`
|
||||
is the prevention, P9 owns the pull. **AMENDED (P9 W2):** there is no pull. `c1bf7e15` (P5f) made the
|
||||
by-handle arm a server-owned promotion (`RequireImageBindableStorageByHandle`: GPU level read back,
|
||||
staged store for pending boxes, immutable core formats kept) and the frontend re-dirty arm is
|
||||
monolith-only; P9 W2 closed its two holes (a level the driver does not hold is not read; a refused
|
||||
readback falls back to a covered staged level) and deleted `OnTexturePullRequest` and the
|
||||
`texture-remint-pull` marker (`docs/Disaggregated/notes/p9/W2-REMINT.md`). `GenerateMipmap(target)` under a transport resolves the
|
||||
is the prevention, P9 owns the pull. `GenerateMipmap(target)` under a transport resolves the
|
||||
texture from `VerbMipRes` (as `EnsureGenerateMipmapStorageAllocated` already does, `DirectGLES.cpp:8736`),
|
||||
never the active unit (`:9563-9566`), and its row flips to `kWaitNone`. `m_force*Resync` are
|
||||
server-set and never cleared by the wire; the wire bits are never cleared by the server (D-E2, now
|
||||
|
||||
@@ -659,8 +659,6 @@ Negative controls, each run red once:
|
||||
7. **"The 511 class-C entries" in §11** is the P5-joint census
|
||||
(`docs/Disaggregated/notes/p6/census-classC.md`). At this head the `MGR_UNMIGRATED_*` lists are
|
||||
empty; `SetSwapInterval` (P10) and `DeleteTransformFeedback` (P9) are the two that remain.
|
||||
(2026-09-29: both are gone. P10 made the `SetSwapInterval` slot the server forwarder, so class C
|
||||
is empty - `CONTRACT-P10.md` §2.)
|
||||
|
||||
---
|
||||
|
||||
@@ -673,8 +671,7 @@ readback and the reply-slot pool (P9); `DynamicBackendParameters`' fixed-width r
|
||||
|
||||
**The two-axis transport stack — control × data, TCP-capable, cross-build — is P6.5** and is the
|
||||
IPC track's next stage (§10.3). P9 builds its reply semantics on P6.5's message replies rather than
|
||||
on a slot pool, and P11's T0/T1 are refused by name on a stream data plane (landed by P11 A1 at
|
||||
the handshake: `Transport/AdoptTier.cpp`, `SettleAdoptTierAtHandshake`; CONTRACT-P11 §1).
|
||||
on a slot pool, and P11's T0/T1 are refused by name on a stream data plane.
|
||||
**Untrusted-guest hardening is `Ph`**, and it must land before any shipping server app accepts a
|
||||
connection from a guest it did not produce — including the `Fatal`-policy flip (§5.2), the
|
||||
handle-slot budget, and the caps in §12.
|
||||
|
||||
@@ -1,71 +0,0 @@
|
||||
# P9:反向通道
|
||||
|
||||
2026-09-29。依据 `docs/Disaggregated/notes/p9/`(交接 [`HANDOFF-P9.md`](../../docs/Disaggregated/notes/p9/HANDOFF-P9.md)、裁定 `INTEGRATOR-DECISIONS-P9.md`)。本文只记实现所需的协议与行为;验证结果以 notes 里的运行证据为准。
|
||||
|
||||
## 范围
|
||||
|
||||
server → client 的结果回传在 split 下不阻塞、不丢、不乱序。本阶段落地:PACK-PBO 回读不等回复(§1);server 日志按级别转发、不阻塞(§2);`OnGlError` 的观察时点写成契约(§3);两条故障注入(§4);纹理重铸不需要拉取(§5)。事件量的批处理 / 收窄没有实测需求,不做(ID-P9-7)。路线图原文里已由前序阶段做完的(异步 reply、2 MiB 回复槽与分带回读、XFB 删除)不重做,见交接 §2。
|
||||
|
||||
## 1. 读进 pack buffer 的回读(W1)
|
||||
|
||||
### 线上格式
|
||||
|
||||
- 追加两个 op(只追加,序号 82、83):`ReadPixelsToBuffer`(kCtxVerb,verb = ReadPixels)、`GetTextureImageToBuffer`(kCtxObject,verb = GetTextureImage)。标志 `kNone`(无回复槽、无 blob、无尾),等待类 `kWaitNone`。
|
||||
- 载荷 `MGPReadbackToBuffer`(104 字节):`Src` 是回复形式的 `MGPReadbackInfo` 原样(`Src.DstOffset = 0`、`Src.DstSize` = 紧排 w·h·d·bpp,只校验不定位);`Dst` 是 pack buffer 的资源句柄;`DstBase` = 应用偏移 + `GL_PACK_SKIP_{PIXELS,ROWS,IMAGES}`;`RowStride`(行长与对齐已算入);`ImageStride`(只在 `Src.Box.D > 1` 时读);`SwapGroup` = `GL_PACK_SWAP_BYTES` 要反转的字节组宽(2/4/8,0 = 不换)。布局算术只在 client(`ReadbackLayout`)。
|
||||
|
||||
### client
|
||||
|
||||
- 目的是 pack buffer 且 `PackBufferReadbackTarget` 给出句柄时走新形式:先 `MarkReadPixelsPackBuffer()`(`GpuWritePending` 第 4 行,把 buffer 标成 GPU 写过),再发记录,**不等**。`glReadPixels` 仍按回复槽上限分带(为了 server 的 scratch 有界,不是为了线路);`glGetTexImage` 整级一条。
|
||||
- 不走新形式(回到回复形式:等回复、client 自己把行 `UploadSubData` 进 buffer)的五种情况:`MOBILEGL_IPC_PBO_READBACK_SYNC=1`;buffer 没有回读路径(`BufferWritebackIsReachable` 为假);buffer **已映射**(只有持久映射能跨读存活,它的读者直接读指针,永远不会触发同步);范围超出 `MGPSubData` 能表达的 buffer 偏移(2³¹−1);buffer 还没上过线(无句柄)。
|
||||
- 此后对该 buffer 的任何 CPU 读(`glGetBufferSubData`、`glMapBufferRange`、以它为 UNPACK 源的纹理上传)经 `SyncGpuWrites` → `resource_readback` → `OnBufferWriteback` 取回字节。**UNPACK 源读取在 split 下先 `SyncGpuWrites`**(`GL_Texture.cpp` 的 `MGL_SYNC_PIXEL_UNPACK_SOURCE`,pull 构建展开为空)。
|
||||
- monolith 不变:后端在自己的 `ReadPixels` 里映射驱动 PBO 回影子。
|
||||
|
||||
### server
|
||||
|
||||
- 读取与回复形式逐字节相同(`ReadBoundFramebufferTight`:中性 PACK 读进 scratch;`ReadTextureImageTight`:两后端各自的 `ReadTextureImageWire`);`ReadPixelsToBuffer` 的紧排大小仍受本端 `maxReplyBytes` 约束(PH-3)。
|
||||
- 落地走 applier 的 buffer 写入口:按 `SwapGroup` 反转后,每段连续区间合成一条 buffer 半边的 `MGPSubData`(`HasLiveHostWrites = 0`)调 `MGPipeApplyResourceSubData`——布局紧排时整读一条、行紧排时每层一条、否则每行一条;行间 padding 不写。于是两后端都与"client 写了同样字节的 `glBufferSubData`"同形:Espryt 进 R-11 暂存影子并排队范围,Magma `WriteWireBuffer` 与在飞读取排序;serial、epoch 与后续记录的顺序都照旧。**不用驱动的 PBO 读**:它只写后端存储,下一次从暂存影子排空的范围会把旧字节盖回去。
|
||||
- **读之前**先查完全部形状:盒与格式、紧排大小是否溢出、PH-3 上限、`Src.DstOffset/DstSize`、布局(`RowStride` 不小于紧排行、`ImageStride` 不小于行、`SwapGroup` ∈ {0,2,4,8}、最后一行的起点 ≤ 2³¹−1、紧排宽度 ≤ 2³²−1)。任何一条不过 → 每个 sink 唯一的闩锁点 `Fatal{ProtocolCorruption, "ReadPixelsToBuffer.shape"}` / `"GetTextureImageToBuffer.shape"`(原因写在其后)。查过之后落地不会再遇到要拒绝的范围;范围是否落在 buffer 内由 applier 自己的写入口判。
|
||||
- 读失败是响亮的:无 `GL.ReadPixels` → `Fatal{ReadbackDeclined, "ReadPixelsToBuffer"}`;纹理级读不出 → `Fatal{ReplyError, "GetTextureImageToBuffer"}`。回复形式的这些情况在 client 端以同名 Fatal 结束,新形式没有回复可载,就在 server 端闩。三组闩锁点各有 `PeerLatchTest` 行或不可达论证(`ph_latch_sites.py`)。
|
||||
- 准入推导:一个 verb 只有在**盖它戳的每个 op**都等待时才算静态屏障(`gen_pipe_field_ownership.py`);`ReadPixelsToBuffer` 盖 ReadPixels 戳而不等,所以 ReadPixels 不再静态屏障(现有生产表无 BARRIER_PULLED 字段,只影响合成夹具)。
|
||||
- 计数:`ServerVerbSink::BufferReadbacks()` / `BufferReadbackWrites()`。
|
||||
|
||||
## 2. server 日志转发(W3)
|
||||
|
||||
- **级别端到端**:`LogForwarder` 为 `void(*)(void* user, int level, const char* line)`(`SetLogForwarder` 与 `SetSessionLogForwarder` 两种),`level` 是 `MOBILEGL_LOG_LEVEL_*`,由 `Log()` 已收到的 Android 优先级映射(`Log()` 签名不变,G1)。线上用 `LogLine.level`(`protocol.fbs` 本来就有,**不改 schema、不动控制修订号**);未知线上级别按 ERROR 收,不降级。client 写 `<base>.server.log` 时保留级别:server 格式化过的行原样,裸行加 `[peer/LEVEL]: `。
|
||||
- **不阻塞任何打日志的线程**:server 装的转发器是 `Transport/LogForward` 的队列 + 独立发送线程(`mgl-log-fwd`);打日志的线程只加锁、拷贝,不碰 socket。
|
||||
|
||||
| 级别 | 行为 |
|
||||
|---|---|
|
||||
| ≤ WARN | 有损:队列里这类行满 1 MiB 后丢弃并计数;每段缺口在流内补一行 `LogForward{Dropped} - N line(s) …` |
|
||||
| ERROR | 无损:限速 256 行/s、突发 1024,超速的按序等待;超过 8 MiB 上限时多出的合成一行 ERROR `LogForward{Coalesced} - N …`,不静默消失 |
|
||||
| FATAL | 最多等 2 s 把本行写出;若上一次 FATAL 等待已超时且其后无任何写出,后续 FATAL 不再等(树里 `MGLOG_F` 也用于可恢复的 EGL 加载消息) |
|
||||
|
||||
- `LogFlush` 的 ack 经同一队列排在此前所有已转发行之后(`MGPipeSyncPeerLog` 的承诺不变)。会话每个出口:先清转发器,再最多 2 s 排空,发送线程仍卡在写上就切断控制 socket 让它返回。会话结束时 server 本地记一行计数(`forwarded / dropped(<=WARN) / coalesced(ERROR) / paced(ERROR) / notices / abandoned / fatal-flush-timeouts / transport-failed / max-offer-us`;有损失为 WARN,否则 DEBUG)。
|
||||
- `MGPipeCallbacks::OnLog` 删除(零生产者、零消费者、无 `EventKind`)。
|
||||
|
||||
## 3. `OnGlError` 的观察时点(W5)
|
||||
|
||||
保持 P5e 的放宽(`CONTRACT-P5E.md` §"glGetError relaxation"、`CONTRACT-P5C.md` §4.2):run-ahead 下一个动词产生的 GL 错误在**下一个 drain 点**被 client 观察到,最迟晚一个 present credit;`glGetError` 不触发强制追平。收紧(`glGetError` 前 `WaitForApplyToCatchUp`)会新增同步点,需用户裁定。
|
||||
|
||||
## 4. 故障注入
|
||||
|
||||
- **F1**:pack buffer 读已发出、server 在落地前死亡,随后 client 读该 buffer。device lost 使 `resource_readback` 被 DECLINED,影子仍是读之前的字节;`AwaitBufferWriteback` 在 `ClientSession::DeviceLost()` 时以 `Fatal{ReadbackDeclined, "buffer-writeback"}` 结束,**不把旧字节当像素返回**(与回复形式的 `ReadbackDeclined` 同名)。门:`RemoteClientControls.APackReadOwedWhenTheDeviceIsLostNeverReadsBackAsTheOldBytes`。
|
||||
|
||||
- **F2**:client 停读控制 socket(`ClientSession::PauseControlReaderForTest`),server 以测试旋钮 `MOBILEGL_TEST_APPLY_LOG_FLOOD=<n>` 让 apply 线程每条记录打 n 行 WARN + 1 行 ERROR。apply 线程不被日志卡住(约 16 MiB / 400 条记录 0.4 s 过完,单行交接最长 53–148 µs);≤ WARN 的丢弃全部有流内说明;≥ ERROR 全部按序到达。控制与 SEG_EVENT 都不排空时,会话经既有 `ReverseChannelForfeit{NotDraining}` 以 exit 0 结束,同一 supervisor 接下一个连接。门:`LogForwardTest`(15 例)、`EventForfeitPeer.StreamLogFlood*`(2 例)。
|
||||
|
||||
## 5. 纹理重铸(W2)
|
||||
|
||||
- **没有纹理拉取**。重铸(为 image 绑定把纹理升级成可绑定存储)是 server 本地路径,反向通道不含任何"向 client 要纹素"的请求:
|
||||
- Espryt(`RequireImageBindableStorageByHandle`):只读回驱动上**确实存在且尺寸相符**的层(`NativeTextureLevelHasExtent`),pending 盒用 `StagedTextureStore` 合并;驱动没有的层——store 覆盖就重放 store,否则跳过(GL 里其内容本就未定义);驱动拒绝读回而 store 覆盖该层时退回 store(记一次 `remint-readback-fallback`),两者都没有才 `Fatal`;已 immutable 且无需加宽的核心格式原样保留。
|
||||
- Magma:重建带 `STORAGE` 用途的 VkImage,`PreserveTextureContentsOnRecreate` GPU→GPU 拷贝。
|
||||
- `TextureRemintPulls`(`trp=`)在 server 路径计数(重铸了已持有的存储时;保留路径不计)。
|
||||
- `MGPipeCallbacks` 删去 `OnTexturePullRequest`;op 50 `ResourceSubDataComplete` 留作退役行(解码仍拒收),`protocol.fbs` 不变。两处 `Fatal{UnmigratedEmulation, "texture-remint-pull"}` 删除(`EveryUnmigratedEmulationIsNamedOnce` 5 → 4)。
|
||||
- 测试旋钮 `MGITEST_ESPRYT_FORCE_REMINT_READBACK_FAILURE`(server 读)强制读回失败,驱动 fallback 用例。
|
||||
- 门:`TextureRemintPullScenario`(14 例)× 两后端 × monolith/Split/Spawn/Tcp,外加 Espryt Split/Spawn 的 4 条强制失败条目;monolith Espryt 上 7 个 GPU 写过的用例按名跳过,指向 dev 缺陷(ID-P9-8)。
|
||||
|
||||
## 不变量
|
||||
|
||||
- G1:pull 构建符号增 0 减 0、`.text` 不变(新代码全在 `MOBILEGL_BUILD_DISAGGREGATED` 下;`GL_Texture.cpp` 的宏在 pull 构建里为空)。
|
||||
- 目录只追加:`MGP_CALL_LIST_DOCUMENTED_COUNT` 81 → 83,`kMGPipeVerifiedPayloadCount` 82 → 83,stamp 表 32 → 34 行。
|
||||
- 回调 9 → 7(`OnLog`、`OnTexturePullRequest` 删除;剩 `OnGlError`、`OnGpuWritten`、`OnBufferWriteback`、`OnTextureWriteback`、`OnMipLevelsGenerated`、`OnSurfaceChanged`、`OnCapsInvalidated`,其中后三个仍无生产者,不在本阶段)。
|
||||
- 控制协议修订号不变(3);`protocol.fbs` 未改。
|
||||
@@ -32,8 +32,7 @@ namespace MobileGL::MG_Remote::Client {
|
||||
|
||||
// ---- the EGL seam ------------------------------------------------------------------
|
||||
//
|
||||
// THE EGL VIRTUALS CALL v1's TWELVE FORWARDERS AND NOTHING ELSE (the swap interval's
|
||||
// since P10 through the emit table's slot, not an override here). c1 round 1 built
|
||||
// THE NINE EGL VIRTUALS CALL v1's TWELVE FORWARDERS AND NOTHING ELSE. c1 round 1 built
|
||||
// its own trampolines over ServerLoop's control channel and ServerLoop::Backend(),
|
||||
// which ran the right driver call on the right thread and was still wrong, because
|
||||
// three of the twelve do MORE than forward:
|
||||
@@ -404,8 +403,15 @@ namespace MobileGL::MG_Remote::Client {
|
||||
return MG_Backend::BackendObject::SwapEGLBuffers(dpy, draw);
|
||||
}
|
||||
|
||||
// No SetEGLSwapInterval here any more (P10 B): the base class calls the emit table's slot,
|
||||
// which is now Server::ServerSetEGLSwapInterval itself (EmitTables.cpp).
|
||||
void BackendObject_Remote::SetEGLSwapInterval(Int interval) {
|
||||
// OVERRIDDEN BECAUSE THE BASE WOULD FATAL. BackendObject.cpp:402 null-checks
|
||||
// GetBackendFunctions().SetSwapInterval and calls it when non-null - one of the 41
|
||||
// null checks R-4 turns into "always supported" - and SetSwapInterval is class C, so
|
||||
// the base implementation would abort on every eglSwapInterval. The answer is the
|
||||
// caps-mirror-read rule's general shape: the question "can the presentation path take
|
||||
// an interval" belongs to the server, so it is asked of the server.
|
||||
Server::ServerSetEGLSwapInterval(interval);
|
||||
}
|
||||
|
||||
void BackendObject_Remote::ReleaseEGLSurface(EGLSurface surface) {
|
||||
// P12: a released server-owned surface stops taking the server window's geometry.
|
||||
|
||||
@@ -40,11 +40,11 @@
|
||||
// function-pointer mailbox before it), and then lets the
|
||||
// base class keep the client-side books.
|
||||
//
|
||||
// SetEGLSwapInterval IS NOT OVERRIDDEN (P10 B). It used to be, because the base implementation
|
||||
// calls GetBackendFunctions().SetSwapInterval (BackendObject.cpp:402) and that slot was the last
|
||||
// class-C Fatal in the emit table. The slot is now the forwarder the override called
|
||||
// (Server::ServerSetEGLSwapInterval, EmitTables.cpp), so the base's route IS the forward and a
|
||||
// second spelling of it here would only be a second place for the two to drift apart.
|
||||
// SetEGLSwapInterval IS THE ONE THAT MUST NOT REACH THE TABLE. The base implementation
|
||||
// null-checks GetBackendFunctions().SetSwapInterval (BackendObject.cpp:402) - one of the 41
|
||||
// null checks R-4 turns into "always supported" - and SetSwapInterval is class C, so the base
|
||||
// implementation would Fatal on every eglSwapInterval. It is overridden to forward instead,
|
||||
// which is the caps-mirror-read rule's shape for a slot whose answer is "ask the server".
|
||||
|
||||
#pragma once
|
||||
#include <Includes.h>
|
||||
@@ -68,13 +68,14 @@ namespace MobileGL::MG_Remote::Client {
|
||||
const MG_Backend::DynamicBackendParameters& GetDynamicParameters() const override;
|
||||
BackendType GetBackendType() const override;
|
||||
|
||||
// ---- the EGL lifecycle virtuals (SetEGLSwapInterval is the base's: see above) -----
|
||||
// ---- the nine EGL lifecycle virtuals ---------------------------------------------
|
||||
Bool InitializeEGLDisplay(EGLDisplay dpy, EGLint* major, EGLint* minor) override;
|
||||
Bool CreateEGLWindowSurface(EGLSurface surface, const MG_Backend::WindowHandle& handle) override;
|
||||
Bool ResizeEGLWindowSurface(EGLSurface surface, Uint32 width, Uint32 height) override;
|
||||
Bool CreateEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height) override;
|
||||
Bool MakeEGLCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) override;
|
||||
Bool SwapEGLBuffers(EGLDisplay dpy, EGLSurface draw) override;
|
||||
void SetEGLSwapInterval(Int interval) override;
|
||||
void ReleaseEGLSurface(EGLSurface surface) override;
|
||||
void ReleaseEGLResources() override;
|
||||
|
||||
|
||||
@@ -36,10 +36,8 @@
|
||||
#include <Config.h> // MG_Config::SplitTransportRequestedByConfig
|
||||
#include <MG_Backend/MGPipe/PipeInputs.h> // MGPipeServerArm, D1c's role predicate
|
||||
#include <MG_State/GLState/Core.h>
|
||||
#include <MG_Util/Async/ShaderCompilePool.h>
|
||||
#include <MG_Util/Debug/Log.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <atomic>
|
||||
|
||||
namespace MobileGL::MG_Remote::Client {
|
||||
@@ -68,36 +66,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
"beat the handshake",
|
||||
what);
|
||||
}
|
||||
|
||||
// P10 B: GL_KHR_parallel_shader_compile IS THE CLIENT'S EXTENSION, SO THE CLIENT DECIDES
|
||||
// IT. Both backends put it in their list when THEIR process compiles asynchronously
|
||||
// (BackendObject_DirectGLES.cpp / BackendObject_DirectVulkan.cpp, "MobileGL's own
|
||||
// capability"), but under split the process that compiles is this one: the pool, its
|
||||
// threads, glMaxShaderCompilerThreadsKHR and GL_MAX_SHADER_COMPILER_THREADS_KHR
|
||||
// (GL_Getter.cpp) all live in the frontend, and the server only ever sees the archive.
|
||||
// Taking the server's word advertised the string from the SERVER's configuration -
|
||||
// under inproc and spawn the server inherits this process's environment and the two
|
||||
// agree by accident; a tcp server is started on its own and they need not. Measured:
|
||||
// AsyncCompileScenario.ExtensionStringMatchesTheConfiguration with
|
||||
// MOBILEGL_ASYNC_SHADER_COMPILE=0 on the client and a default (async-on) tcp server
|
||||
// read the string advertised and the thread count 0, on both backends. So the entry is
|
||||
// re-derived here from this process's switch, on every adoption.
|
||||
void ReconcileClientCompileExtensions(RendererInfo& renderer) {
|
||||
Vector<GLExtension>& extensions = renderer.RendererGLInfo.Extensions;
|
||||
const auto found =
|
||||
std::find(extensions.begin(), extensions.end(), E_GL_KHR_parallel_shader_compile);
|
||||
const Bool advertised = found != extensions.end();
|
||||
const Bool compilesAsync = MG_Util::Async::AsyncShaderCompileEnabled();
|
||||
if (advertised == compilesAsync) return;
|
||||
if (compilesAsync) {
|
||||
extensions.push_back(E_GL_KHR_parallel_shader_compile);
|
||||
} else {
|
||||
extensions.erase(found);
|
||||
}
|
||||
MGLOG_D("MG_Remote client: GL_KHR_parallel_shader_compile %s - the server's list said the "
|
||||
"opposite, and the compile pool it describes is this process's",
|
||||
compilesAsync ? "advertised" : "withdrawn");
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void CapsMirror::Adopt(const MG_Pipe::MGPCaps& caps, const MG_Backend::FormatCapabilityCache& formats,
|
||||
@@ -112,7 +80,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
m_caps.RendererInfo = MG_Pipe::MGPBlobRef{};
|
||||
m_formats = formats;
|
||||
m_renderer = renderer;
|
||||
ReconcileClientCompileExtensions(m_renderer);
|
||||
m_apiVersion = apiVersion;
|
||||
m_backend = backend;
|
||||
++m_generation;
|
||||
|
||||
@@ -13,17 +13,16 @@
|
||||
#include <MG_Remote/FatalFunnel.h>
|
||||
#include <MG_Remote/Handshake.h>
|
||||
#include <MG_Remote/Transport/LinkMetrics.h>
|
||||
#include <MG_Remote/Transport/StreamLink.h>
|
||||
|
||||
#include "../CapsCodec.h"
|
||||
#include "../Protocol/generated/protocol_generated.h"
|
||||
#include "../Server/ServerLoop.h"
|
||||
#include "../Server/ServerSession.h"
|
||||
#include "../Protocol/SurfaceOpCodec.h"
|
||||
#include "../Transport/AdoptTier.h"
|
||||
#include "../Transport/FdPassing.h"
|
||||
#include "../Transport/InProcessTransport.h"
|
||||
#include "WireTables.h"
|
||||
#include "EmitTables.h"
|
||||
|
||||
#include <MGGitHash.h>
|
||||
#include <MG_Backend/MGPipe/PipeInputs.h>
|
||||
@@ -67,21 +66,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
return static_cast<std::uint32_t>(::getpid());
|
||||
#endif
|
||||
}
|
||||
|
||||
// P11 B1: `fd:<control>,<aux>` - two decimal descriptor numbers, one comma, nothing else.
|
||||
// Strict on purpose: a stray space or sign is an operator's typo, and a typo that parsed
|
||||
// would name some other descriptor of this process.
|
||||
bool ParseFdEndpoint(const std::string& spec, int* outControl, int* outAux) {
|
||||
const auto comma = spec.find(',');
|
||||
if (comma == std::string::npos || spec.find(',', comma + 1) != std::string::npos) return false;
|
||||
const auto number = [](const std::string& text, int* out) {
|
||||
if (text.empty() || text.size() > 9 || text.find_first_not_of("0123456789") != std::string::npos)
|
||||
return false;
|
||||
*out = std::atoi(text.c_str());
|
||||
return true;
|
||||
};
|
||||
return number(spec.substr(0, comma), outControl) && number(spec.substr(comma + 1), outAux);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
#define MGP5_C0_STUB(what) \
|
||||
@@ -499,22 +483,9 @@ namespace MobileGL::MG_Remote::Client {
|
||||
++delivered;
|
||||
break;
|
||||
}
|
||||
case Transport::kEventFenceSignaled: {
|
||||
// P10 (CONTRACT-P10.md §1): remembered for every later poll of that fence.
|
||||
if (view.payloadSize < sizeof(Transport::EventFenceSignaledHead)) {
|
||||
SessionFail(MGFatalFamily::ProtocolCorruption, "MGPipe: Fatal{ProtocolCorruption, \"kEventFenceSignaled\"} - "
|
||||
"a %llu-byte record is shorter than the fence handle it carries",
|
||||
static_cast<unsigned long long>(view.payloadSize));
|
||||
}
|
||||
const auto* head =
|
||||
static_cast<const Transport::EventFenceSignaledHead*>(view.payload);
|
||||
NoteFenceSignaledByServer(MG_Pipe::MGPipeHandle{head->Fence.Slot, head->Fence.Gen});
|
||||
++delivered;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
MGLOG_W("MG_Remote client: reverse-channel record kind %u is not one this "
|
||||
"build consumes",
|
||||
MGLOG_W("MG_Remote client: reverse-channel record kind %u is not consumed in "
|
||||
"P5c (four of the ten callbacks are armed; the rest are P9's)",
|
||||
static_cast<unsigned>(view.kind));
|
||||
break;
|
||||
}
|
||||
@@ -806,11 +777,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
Stop();
|
||||
return result;
|
||||
}
|
||||
// P11 A1: the adopt tier, settled by the side that holds the knob once the link terms
|
||||
// say which plane this is (inproc is shared segments by construction), before any
|
||||
// record. T0/T1 over shared segments die here by name (Transport/AdoptTier.h).
|
||||
(void)Transport::SettleAdoptTierAtHandshake(
|
||||
terms->dataPlane() == ::MobileGL::Wire::DataPlane::Stream, Transport::AdoptTierSide::Client);
|
||||
// The four SegmentRefs are what a spawn client MAPS (P6). Under inproc the mapping
|
||||
// already exists, so what they are good for here is the cross-check that the two
|
||||
// sides agree about the geometry at all - which is the assertion that would
|
||||
@@ -858,57 +824,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
return MOBILEGL_ERR_INVALID_ARGUMENT;
|
||||
}
|
||||
const std::string configured(MG_Config::Ipc.Control.c_str());
|
||||
// P11 B1 (CONTRACT-P11 B1): a PRE-CONNECTED PAIR, fd:<control>,<aux>. A client in another
|
||||
// app (or the shell) may not connect() to the server app's endpoint - SELinux `connectto`
|
||||
// (B0-CROSS-APP.md) - so the server app's broker connected both sockets and an app_process
|
||||
// helper passed the client ends in, inherited across its execve. This process only ADOPTS
|
||||
// them: it presents its own PairBind pair (the broker wrote nothing) and says Hello. Connect
|
||||
// dial, and no data endpoint - the aux socket carries the Welcome's descriptors, so the plane
|
||||
// is shared segments exactly as for `unix:`.
|
||||
if (configured.compare(0, 3, "fd:") == 0) {
|
||||
const std::string data(MG_Config::Ipc.Data.c_str());
|
||||
int control = -1;
|
||||
int aux = -1;
|
||||
if (!ParseFdEndpoint(configured.substr(3), &control, &aux)) {
|
||||
MGLOG_E("MG_Remote: Refuse{ProtocolMismatch} MOBILEGL_IPC_CONTROL='%s' is not fd:<control>,<aux> "
|
||||
"(two descriptor numbers and one comma)",
|
||||
configured.c_str());
|
||||
return MOBILEGL_ERR_UNSUPPORTED;
|
||||
}
|
||||
if (data != "auto" && data != "shm") {
|
||||
MGLOG_E("MG_Remote: Refuse{ProtocolMismatch} unsupported control/data pair %s/%s - an fd: pair is "
|
||||
"a unix connection and carries shared segments only",
|
||||
configured.c_str(), data.c_str());
|
||||
return MOBILEGL_ERR_UNSUPPORTED;
|
||||
}
|
||||
m_connectDial = true;
|
||||
m_dataEndpoint.clear();
|
||||
// ID-P11-12: the broker that connected the pair presents its PairBinds at hand-off, and the
|
||||
// helper says so; then this process must not present a second pair (the server would read
|
||||
// it where the Hello belongs).
|
||||
const char* pairedText = std::getenv("MOBILEGL_IPC_FD_PAIRED");
|
||||
const bool pairedAtHandoff = pairedText != nullptr && std::strcmp(pairedText, "1") == 0;
|
||||
std::unique_ptr<Transport::SocketTransport> socket;
|
||||
const auto adopted = Transport::SocketTransport::AdoptConnectedPair(control, aux, socket, pairedAtHandoff);
|
||||
if (adopted == MOBILEGL_ERR_TRANSPORT_CLOSED) {
|
||||
// The PairBinds could not be sent: the server had already closed the pair. Its reason
|
||||
// is usually still on the control connection - a pair presented past the pairing budget
|
||||
// gets Refuse{Authentication} - so it is read and named rather than left as a send error.
|
||||
Transport::SocketTransport closedPair(control, aux, Transport::TransportRole::Client);
|
||||
std::vector<Uint8> frame;
|
||||
if (ReceiveEnvelope(closedPair, frame, 500) == MOBILEGL_OK && LogPeerRefusal(ParseEnvelope(frame)))
|
||||
return MOBILEGL_ERR_PROTOCOL_MISMATCH;
|
||||
MGLOG_E("MG_Remote: the server closed the fd: pair before it was presented, and left no refusal");
|
||||
return adopted;
|
||||
}
|
||||
if (adopted != MOBILEGL_OK) return adopted;
|
||||
const auto started = StartOverSocket(std::move(socket));
|
||||
if (started == MOBILEGL_OK) {
|
||||
MGLOG_I("MG_Remote client: control=fd data=shm server=fd:%d,%d pid=%u dial=connect paired=%s", control,
|
||||
aux, m_peerServerPid, pairedAtHandoff ? "handoff" : "client");
|
||||
}
|
||||
return started;
|
||||
}
|
||||
if (configured != "fork") {
|
||||
const bool tcp = configured.compare(0, 6, "tcp://") == 0;
|
||||
const bool unixSocket = configured.compare(0, 5, "unix:") == 0;
|
||||
@@ -1098,10 +1013,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
return result;
|
||||
}
|
||||
stream = terms->dataPlane() == ::MobileGL::Wire::DataPlane::Stream;
|
||||
// P11 A1: as in StartOverTransportPair - the knob against the plane the link terms
|
||||
// settled, before the data connection and before any record. A stream refuses T0/T1
|
||||
// by name and runs T2; shared segments die here by name (Transport/AdoptTier.h).
|
||||
(void)Transport::SettleAdoptTierAtHandshake(stream, Transport::AdoptTierSide::Client);
|
||||
if (stream) {
|
||||
// PH-7 (4). A Stream Welcome without a nonce of exactly the minted width names no
|
||||
// data connection this client could open; refused rather than guessed at.
|
||||
@@ -2144,13 +2055,9 @@ namespace MobileGL::MG_Remote::Client {
|
||||
// ReadPixels intentionally refuses this with Fatal{ReadbackDeclined, "ReadPixels"}:
|
||||
// unlike acceptance rows it cannot return successfully without complete pixels.
|
||||
if (statusOut != nullptr) *statusOut = Wire::ReplySink::kStatusDeclined;
|
||||
// Said while it is news. Once the device-lost latch is up (it logged the hangup), every
|
||||
// later verb lands here too - an FCL game issues thousands per second - and one line
|
||||
// each buried the log (113,080 lines in 48 s on the phone).
|
||||
if (!DeviceLost())
|
||||
MGLOG_E("MG_Remote client: the barrier for %s (seq %llu) woke on a dead doorbell; the "
|
||||
"server is gone and this verb did not happen (reported as DECLINED, not ERROR)",
|
||||
Wire::WireOpName(op), static_cast<unsigned long long>(seq));
|
||||
MGLOG_E("MG_Remote client: the barrier for %s (seq %llu) woke on a dead doorbell; the "
|
||||
"server is gone and this verb did not happen (reported as DECLINED, not ERROR)",
|
||||
Wire::WireOpName(op), static_cast<unsigned long long>(seq));
|
||||
return seq;
|
||||
}
|
||||
if (wait != Transport::SessionWait::Reached) {
|
||||
@@ -2290,9 +2197,8 @@ namespace MobileGL::MG_Remote::Client {
|
||||
}
|
||||
// The doorbell died: teardown, not a fault - the same answer EmitAndWaitTails
|
||||
// gives, and for the same reason.
|
||||
if (!DeviceLost()) // see the barrier above: the latch already said it
|
||||
MGLOG_E("MG_Remote client: the forced wait for %s woke on a dead doorbell; the "
|
||||
"server is gone", why);
|
||||
MGLOG_E("MG_Remote client: the forced wait for %s woke on a dead doorbell; the "
|
||||
"server is gone", why);
|
||||
return;
|
||||
}
|
||||
if (wait != Transport::SessionWait::Reached) {
|
||||
@@ -2325,12 +2231,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
}
|
||||
}
|
||||
|
||||
void ClientSession::PollEntry() {
|
||||
if (!m_started || m_events == nullptr || DeviceLost()) return;
|
||||
Flush();
|
||||
DrainEventRing(*m_events);
|
||||
}
|
||||
|
||||
void ClientSession::Finish() {
|
||||
// glFinish. Nothing goes on the wire - Flush and Finish have no record (ARCHITECTURE
|
||||
// §11) - and under lockstep there was nothing to do, because the client had already
|
||||
@@ -2400,7 +2300,7 @@ namespace MobileGL::MG_Remote::Client {
|
||||
const double creditMs =
|
||||
static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(
|
||||
std::chrono::steady_clock::now() - paceStarted).count()) / 1e6;
|
||||
const auto io = Transport::LinkMetricsTakeSendStats();
|
||||
const auto io = Transport::StreamLink::TakeSendStats();
|
||||
MGLOG_I("P65ClientPace present=%llu credit_wait_ms=%.1f | io: %llu B in %llu sendmsg "
|
||||
"send_ms=%.1f total_ms=%.1f",
|
||||
static_cast<unsigned long long>(serial), creditMs,
|
||||
|
||||
@@ -99,15 +99,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
// m_remoteControlMutex and drains first; a caller of this does neither, which is the
|
||||
// point. Null unless spawned.
|
||||
Transport::SocketTransport* ControlSocketForTest() { return m_socketTransport.get(); }
|
||||
// P9 W3's fault injection F2 ONLY (EventForfeitPeerTest): the control READER, so a TCP peer
|
||||
// can stop taking anything off its control connection - the server's forwarded log lines
|
||||
// included - and later resume (ControlInbox::PauseReadingForTest). False when there is no
|
||||
// reader to pause (not a stream session).
|
||||
bool PauseControlReaderForTest(bool paused) {
|
||||
if (!m_controlInbox) return false;
|
||||
m_controlInbox->PauseReadingForTest(paused);
|
||||
return true;
|
||||
}
|
||||
|
||||
// CONTRACT-P6 4.3: THE PID THE SERVER STATED IN ITS Welcome, which is not the same fact
|
||||
// as the pid this session's launcher recorded - that one is local knowledge, this one
|
||||
@@ -281,12 +272,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
// true while a run-ahead queue still holds them, so under run-ahead glFinish becomes
|
||||
// exactly WaitForApplyToCatchUp + the drain that comes with it.
|
||||
void Finish();
|
||||
// P10 (CONTRACT-P10.md §1): a polling entry point (glClientWaitSync, glGetSynciv(
|
||||
// GL_SYNC_STATUS)) is a doorbell point. Everything published so far - the polled fence's
|
||||
// own create record above all - is flushed to the server, and the reverse channel is
|
||||
// drained, so a fence the server has since reported is known before the poll answers.
|
||||
// Publishes nothing and waits for nothing.
|
||||
void PollEntry();
|
||||
// Submit published commands without waiting for application. This is
|
||||
// glFlush's contract and the frame-submit boundary for Present.
|
||||
void Flush();
|
||||
|
||||
@@ -34,8 +34,6 @@
|
||||
#include "GpuWritePending.h"
|
||||
#include "PersistentMapTracker.h"
|
||||
|
||||
#include "../Server/ServerLoop.h"
|
||||
|
||||
#include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
|
||||
#include <MG_Util/Converters/MGToGL/TextureEnumConverter.h>
|
||||
#include <MG_Util/Debug/Log.h>
|
||||
@@ -863,23 +861,15 @@ namespace MobileGL::MG_Remote::Client {
|
||||
ReadbackBytesPerPixel(format, type);
|
||||
}
|
||||
|
||||
// GL_PACK_SWAP_BYTES as the width of the byte group it reverses for `type`, 0 when there
|
||||
// is nothing to reverse. One rule for both places a swap happens: the reply form swaps
|
||||
// here, and the pack-buffer form (P9) carries the number to the server, which swaps there.
|
||||
Uint32 ReadbackSwapGroup(GLenum type, const PixelStoreParameters& pack) {
|
||||
if (!pack.SwapBytes) return 0;
|
||||
void ApplyReadbackByteSwap(void* pixels, Uint64 bytes, GLenum type,
|
||||
const PixelStoreParameters& pack) {
|
||||
if (!pack.SwapBytes || pixels == nullptr) return;
|
||||
const auto dataType = MG_Util::ConvertGLEnumToTexturePixelDataType(type);
|
||||
SizeT group = MG_Util::GetSizedTexturePixelDataTypeSize(dataType);
|
||||
if (group == 0) group = MG_Util::GetBaseTexturePixelDataTypeSize(dataType);
|
||||
// This packed depth/stencil type contains two independent 32-bit words.
|
||||
if (type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) group = 4;
|
||||
return group <= 1 ? 0 : static_cast<Uint32>(group);
|
||||
}
|
||||
|
||||
void ApplyReadbackByteSwap(void* pixels, Uint64 bytes, GLenum type,
|
||||
const PixelStoreParameters& pack) {
|
||||
const SizeT group = ReadbackSwapGroup(type, pack);
|
||||
if (group == 0 || pixels == nullptr) return;
|
||||
if (group <= 1) return;
|
||||
auto* data = static_cast<Uint8*>(pixels);
|
||||
for (Uint64 at = 0; at + group <= bytes; at += group) {
|
||||
for (SizeT i = 0; i < group / 2; ++i) {
|
||||
@@ -973,56 +963,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
return;
|
||||
}
|
||||
|
||||
// One band's source record, the same for both destinations below.
|
||||
const auto bandInfo = [&](const ReadbackBand& band, Uint64 bandBytes) {
|
||||
MG_Pipe::MGPReadbackInfo info{};
|
||||
info.Res = MG_Pipe::kMGPipeNullHandle; // "the bound read surface answers"
|
||||
info.Box = MG_Pipe::MGPBox{ReadbackBandOrigin(x, band.FirstColumn),
|
||||
ReadbackBandOrigin(y, band.FirstRow), 0,
|
||||
static_cast<Uint32>(band.Columns),
|
||||
static_cast<Uint32>(band.Rows), 1};
|
||||
info.Format = static_cast<Uint32>(format);
|
||||
info.Type = static_cast<Uint32>(type);
|
||||
info.Target = 0;
|
||||
info.Level = 0;
|
||||
info.DstOffset = 0;
|
||||
info.DstSize = bandBytes;
|
||||
return info;
|
||||
};
|
||||
|
||||
// P9 (W1, CONTRACT-P9.md §1): A PACK BUFFER IS ANSWERED BY NOTHING. Each band crosses
|
||||
// as read_pixels_to_buffer naming the buffer and the band's place in it - the
|
||||
// layout above, per band - and the client neither waits nor copies: the server lands
|
||||
// the rows, and the mark (taken first, like every producer row's) is what sends the
|
||||
// next CPU read of the buffer through resource_readback. The bands are the reply
|
||||
// form's for the SERVER's sake, not the wire's: the server reads each one into its
|
||||
// scratch before landing it, and the reply cap is the bound it already enforces on
|
||||
// that scratch (PH-3). The monolith arm is untouched - it maps the driver PBO back
|
||||
// inside its own ReadPixels, as it always has.
|
||||
if (pbo) {
|
||||
const MG_Pipe::MGPipeHandle target = PackBufferReadbackTarget(pbo, pboOffset + layout.End);
|
||||
if (!MG_Pipe::MGPipeHandleIsNull(target)) {
|
||||
MarkReadPixelsPackBuffer();
|
||||
const Uint32 swapGroup = ReadbackSwapGroup(type, pack);
|
||||
ForEachReadbackBand(static_cast<Uint64>(width), static_cast<Uint64>(height), plan,
|
||||
[&](const ReadbackBand& band) {
|
||||
MG_Pipe::MGPReadbackToBuffer record{};
|
||||
record.Src = bandInfo(band, TightReadbackBytes(static_cast<GLsizei>(band.Columns),
|
||||
static_cast<GLsizei>(band.Rows),
|
||||
format, type));
|
||||
record.Dst = target;
|
||||
record.DstBase = pboOffset + layout.Start + band.FirstRow * layout.RowStride +
|
||||
band.FirstColumn * bytesPerPixel;
|
||||
record.RowStride = layout.RowStride;
|
||||
record.ImageStride = 0;
|
||||
record.SwapGroup = swapGroup;
|
||||
session.EmitAndWait(MG_Pipe::MGPWireOp::ReadPixelsToBuffer, &record,
|
||||
sizeof(record), nullptr, 0, nullptr, 0, nullptr);
|
||||
});
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// THE COMMON CASE KEEPS THE ZERO-COPY. A neutral pack state means the destination
|
||||
// layout IS the tight layout, so each band's reply lands straight in the
|
||||
// application's buffer at the band's tight offset (whole-width bands and single-row
|
||||
@@ -1043,7 +983,18 @@ namespace MobileGL::MG_Remote::Client {
|
||||
const Uint64 bandBytes = TightReadbackBytes(static_cast<GLsizei>(band.Columns),
|
||||
static_cast<GLsizei>(band.Rows),
|
||||
format, type);
|
||||
MG_Pipe::MGPReadbackInfo info = bandInfo(band, bandBytes);
|
||||
MG_Pipe::MGPReadbackInfo info{};
|
||||
info.Res = MG_Pipe::kMGPipeNullHandle; // "the bound read surface answers"
|
||||
info.Box = MG_Pipe::MGPBox{ReadbackBandOrigin(x, band.FirstColumn),
|
||||
ReadbackBandOrigin(y, band.FirstRow), 0,
|
||||
static_cast<Uint32>(band.Columns),
|
||||
static_cast<Uint32>(band.Rows), 1};
|
||||
info.Format = static_cast<Uint32>(format);
|
||||
info.Type = static_cast<Uint32>(type);
|
||||
info.Target = 0;
|
||||
info.Level = 0;
|
||||
info.DstOffset = 0;
|
||||
info.DstSize = bandBytes;
|
||||
|
||||
// CHECKED BEFORE THE EMISSION, not after the answer (ID-47), through S1's
|
||||
// helper, for every record. The plan makes it true by construction; it stays
|
||||
@@ -1594,87 +1545,15 @@ namespace MobileGL::MG_Remote::Client {
|
||||
// =============================================================================
|
||||
// The frontend sees a local opaque token; neither this address nor the driver's
|
||||
// BackendSyncHandle is serialized. The Fence-kind slot allocator supplies wire identity.
|
||||
struct RemoteFenceProxy {
|
||||
MG_Pipe::MGPipeHandle Handle;
|
||||
// P10: zero-timeout polls answered "not yet" in a row since the last escalation.
|
||||
Uint32 Unanswered = 0;
|
||||
};
|
||||
struct RemoteFenceProxy { MG_Pipe::MGPipeHandle Handle; };
|
||||
std::mutex g_fenceMutex;
|
||||
UnorderedMap<MG_Backend::BackendSyncHandle, UniquePtr<RemoteFenceProxy>> g_fenceProxies;
|
||||
|
||||
RemoteFenceProxy& FenceProxy(MG_Backend::BackendSyncHandle proxy) {
|
||||
MG_Pipe::MGPipeHandle FenceHandle(MG_Backend::BackendSyncHandle proxy) {
|
||||
const auto it = g_fenceProxies.find(proxy);
|
||||
if (it == g_fenceProxies.end())
|
||||
Wire::WireProtocolFatal("Fence.proxy", "unknown client fence proxy");
|
||||
return *it->second;
|
||||
}
|
||||
|
||||
MG_Pipe::MGPipeHandle FenceHandle(MG_Backend::BackendSyncHandle proxy) { return FenceProxy(proxy).Handle; }
|
||||
|
||||
// ---- P10 (CONTRACT-P10.md §1): WHAT THE SERVER HAS SAID IS SIGNALED -----------------
|
||||
//
|
||||
// {slot -> gen} of every fence a kEventFenceSignaled named, or a round trip answered
|
||||
// signaled. ITS OWN MUTEX, NOT g_fenceMutex: the report arrives in the event drain, and
|
||||
// the drain runs INSIDE the emitters below while they hold g_fenceMutex (EmitAndWait and
|
||||
// PollEntry both drain), so taking g_fenceMutex there would deadlock the GL thread on
|
||||
// itself. A report for a fence already deleted leaves a {slot, old gen} entry that no live
|
||||
// handle matches; the slot's next occupant overwrites it.
|
||||
std::mutex g_signaledFenceMutex;
|
||||
UnorderedMap<Uint32, Uint32> g_signaledFences;
|
||||
std::atomic<Uint64> g_fenceLocalAnswers{0};
|
||||
std::atomic<Uint64> g_fenceEscalations{0};
|
||||
std::atomic<Uint64> g_fenceRoundTrips{0};
|
||||
std::atomic<Uint64> g_fenceServerReports{0};
|
||||
|
||||
Bool FenceKnownSignaled(MG_Pipe::MGPipeHandle handle) {
|
||||
const std::lock_guard<std::mutex> lock(g_signaledFenceMutex);
|
||||
const auto it = g_signaledFences.find(handle.Slot);
|
||||
return it != g_signaledFences.end() && it->second == handle.Gen;
|
||||
}
|
||||
|
||||
void RememberFenceSignaled(MG_Pipe::MGPipeHandle handle) {
|
||||
const std::lock_guard<std::mutex> lock(g_signaledFenceMutex);
|
||||
g_signaledFences[handle.Slot] = handle.Gen;
|
||||
}
|
||||
|
||||
void ForgetFence(MG_Pipe::MGPipeHandle handle) {
|
||||
const std::lock_guard<std::mutex> lock(g_signaledFenceMutex);
|
||||
const auto it = g_signaledFences.find(handle.Slot);
|
||||
if (it != g_signaledFences.end() && it->second == handle.Gen) g_signaledFences.erase(it);
|
||||
}
|
||||
|
||||
// MOBILEGL_IPC_POLL_ESCALATE=0 is the A/B control: every poll crosses, as before P10. A lost
|
||||
// device takes the round-trip arm too, whose DECLINED answer is the no-op a dead fence gets.
|
||||
Bool FencePollsAnswerLocally() {
|
||||
return MG_Config::Ipc.PollEscalate != 0 && !ClientSession::DeviceLost();
|
||||
}
|
||||
|
||||
// THE LOCAL ANSWER, OR "CROSS". A poll is a doorbell point first (PollEntry: flush what is
|
||||
// published, drain the reverse channel), so the fence's own create record has reached the
|
||||
// server and every report it has posted is in. Known signaled -> answered here. Not known
|
||||
// and the call may not wait (a zero timeout, glGetSynciv) -> answered "not yet" here,
|
||||
// unless this fence has had POLL_ESCALATE such answers in a row, in which case the poll
|
||||
// takes one real round trip: the server's own reports are what make a local "not yet"
|
||||
// eventually true, and the escalation is the bound that holds even if one is late. A call
|
||||
// that may wait (a non-zero timeout) is never answered "not yet" here - it crosses and
|
||||
// waits on the server, as the GL call asks.
|
||||
enum class FencePollAnswer { Signaled, NotYet, Cross };
|
||||
FencePollAnswer AnswerFencePollLocally(ClientSession& session, RemoteFenceProxy& fence, Bool mayWait) {
|
||||
if (!FencePollsAnswerLocally()) return FencePollAnswer::Cross;
|
||||
session.PollEntry();
|
||||
if (FenceKnownSignaled(fence.Handle)) {
|
||||
fence.Unanswered = 0;
|
||||
g_fenceLocalAnswers.fetch_add(1, std::memory_order_relaxed);
|
||||
return FencePollAnswer::Signaled;
|
||||
}
|
||||
if (mayWait) return FencePollAnswer::Cross;
|
||||
if (++fence.Unanswered < MG_Config::Ipc.PollEscalate) {
|
||||
g_fenceLocalAnswers.fetch_add(1, std::memory_order_relaxed);
|
||||
return FencePollAnswer::NotYet;
|
||||
}
|
||||
fence.Unanswered = 0;
|
||||
g_fenceEscalations.fetch_add(1, std::memory_order_relaxed);
|
||||
return FencePollAnswer::Cross;
|
||||
return it->second->Handle;
|
||||
}
|
||||
|
||||
MG_Backend::BackendSyncHandle EmitFenceSync() {
|
||||
@@ -1743,33 +1622,16 @@ namespace MobileGL::MG_Remote::Client {
|
||||
GLenum EmitClientWaitSync(MG_Backend::BackendSyncHandle proxy, GLbitfield flags, GLuint64 timeout) {
|
||||
ClientSession& session = RequireSession("ClientWaitSync");
|
||||
const std::lock_guard<std::mutex> lock(g_fenceMutex);
|
||||
RemoteFenceProxy& fence = FenceProxy(proxy);
|
||||
switch (AnswerFencePollLocally(session, fence, /*mayWait=*/timeout != 0)) {
|
||||
case FencePollAnswer::Signaled: return GL_ALREADY_SIGNALED;
|
||||
case FencePollAnswer::NotYet: return GL_TIMEOUT_EXPIRED;
|
||||
case FencePollAnswer::Cross: break;
|
||||
}
|
||||
g_fenceRoundTrips.fetch_add(1, std::memory_order_relaxed);
|
||||
const MG_Pipe::MGPFenceWait request{fence.Handle, timeout, flags, 0};
|
||||
const Uint32 result = ReadFenceReply(session, MG_Pipe::MGPWireOp::FenceWait, &request, sizeof(request));
|
||||
if (result == GL_ALREADY_SIGNALED || result == GL_CONDITION_SATISFIED) RememberFenceSignaled(fence.Handle);
|
||||
return result;
|
||||
const MG_Pipe::MGPFenceWait request{FenceHandle(proxy), timeout, flags, 0};
|
||||
return ReadFenceReply(session, MG_Pipe::MGPWireOp::FenceWait, &request, sizeof(request));
|
||||
}
|
||||
|
||||
Bool EmitGetSyncStatus(MG_Backend::BackendSyncHandle proxy) {
|
||||
ClientSession& session = RequireSession("GetSyncStatus");
|
||||
const std::lock_guard<std::mutex> lock(g_fenceMutex);
|
||||
RemoteFenceProxy& fence = FenceProxy(proxy);
|
||||
switch (AnswerFencePollLocally(session, fence, /*mayWait=*/false)) {
|
||||
case FencePollAnswer::Signaled: return true;
|
||||
case FencePollAnswer::NotYet: return false;
|
||||
case FencePollAnswer::Cross: break;
|
||||
}
|
||||
g_fenceRoundTrips.fetch_add(1, std::memory_order_relaxed);
|
||||
const MG_Pipe::MGPHandleOnly desc{fence.Handle, static_cast<Uint32>(MG_Pipe::MGPipeKind::Fence), 0};
|
||||
const MG_Pipe::MGPHandleOnly desc{FenceHandle(proxy), static_cast<Uint32>(MG_Pipe::MGPipeKind::Fence), 0};
|
||||
const Uint32 result = ReadFenceReply(session, MG_Pipe::MGPWireOp::FenceStatus, &desc, sizeof(desc));
|
||||
if (result > 1) Wire::WireProtocolFatal("FenceStatus.reply", "status must be boolean");
|
||||
if (result != 0) RememberFenceSignaled(fence.Handle);
|
||||
return result != 0;
|
||||
}
|
||||
|
||||
@@ -1792,7 +1654,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
nullptr, 0, nullptr, 0, nullptr);
|
||||
}
|
||||
MG_Pipe::MGPipeSlots().Free(MG_Pipe::MGPipeKind::Fence, handle);
|
||||
ForgetFence(handle);
|
||||
g_fenceProxies.erase(proxy);
|
||||
}
|
||||
|
||||
@@ -1809,8 +1670,8 @@ namespace MobileGL::MG_Remote::Client {
|
||||
// per-package ownership assertions below then still hold, the totals stay arithmetic,
|
||||
// and a slot that changes class without changing the arithmetic is a build break. The
|
||||
// X-macro shape is kept so the DEFINITION and the ASSIGNMENT cannot drift apart. Three
|
||||
// slots carried a body the macro cannot (DispatchCompute, DispatchComputeIndirect,
|
||||
// SetSwapInterval) and were written out by hand below; all three are class B now.
|
||||
// slots carry a body the macro cannot (DispatchCompute, DispatchComputeIndirect,
|
||||
// SetSwapInterval) and are written out by hand below.
|
||||
//
|
||||
// d1 indexed / instanced / multi-draw / indirect draws -> draw_vbo (59), its
|
||||
// kDrawIsIndirect tail and its kDrawHasUserIndices span
|
||||
@@ -1851,8 +1712,7 @@ namespace MobileGL::MG_Remote::Client {
|
||||
|
||||
#define MGR_UNMIGRATED_F1_SLOTS(X)
|
||||
|
||||
// The wave-3 tail. Empty since P10 B retired SetSwapInterval (it was not a GL.* slot and
|
||||
// was never a row here).
|
||||
// The wave-3 tail. SetSwapInterval is hand-written below (it is not a GL.* slot).
|
||||
#define MGR_UNMIGRATED_TAIL_SLOTS(X)
|
||||
|
||||
// The non-void ones, kept apart only because the macro body differs: a [[noreturn]]
|
||||
@@ -1883,13 +1743,8 @@ namespace MobileGL::MG_Remote::Client {
|
||||
// hook before their Fatal so that the package flipping them would inherit a call site
|
||||
// that was already correct, and EmitDispatchCompute / EmitDispatchComputeIndirect above
|
||||
// are that inheritance - same two calls, same order, the record where the Fatal was.
|
||||
//
|
||||
// THE LAST HAND-WRITTEN STUB, SetSwapInterval_Unmigrated, IS GONE TOO (P10 B), and class C
|
||||
// is empty. It was never reachable: eglSwapInterval reaches the table only through
|
||||
// BackendObject::SetEGLSwapInterval, and BackendObject_Remote overrode that to call
|
||||
// Server::ServerSetEGLSwapInterval - a SurfaceControlFrame on the control channel, which
|
||||
// crosses processes. The slot now IS that forwarder (assigned in the class-B block), the
|
||||
// override is deleted, and there is one route from eglSwapInterval to the server.
|
||||
|
||||
void SetSwapInterval_Unmigrated(Int) { UnmigratedVerbFatal("SetSwapInterval"); }
|
||||
|
||||
// The counts, as arithmetic. MGR_COUNT_ONE expands to `+ 1` per row.
|
||||
#define MGR_COUNT_ONE(Name, Ret, Sig) +1
|
||||
@@ -1898,8 +1753,9 @@ namespace MobileGL::MG_Remote::Client {
|
||||
constexpr Uint32 kUnmigratedI1 = 0 MGR_UNMIGRATED_I1_SLOTS(MGR_COUNT_ONE);
|
||||
constexpr Uint32 kUnmigratedT2 = 0 MGR_UNMIGRATED_T2_SLOTS(MGR_COUNT_ONE);
|
||||
constexpr Uint32 kUnmigratedF1 = 0 MGR_UNMIGRATED_F1_SLOTS(MGR_COUNT_ONE);
|
||||
// + SetSwapInterval, written out by hand.
|
||||
constexpr Uint32 kUnmigratedTail =
|
||||
0 MGR_UNMIGRATED_TAIL_SLOTS(MGR_COUNT_ONE) MGR_UNMIGRATED_TAIL_VALUE_SLOTS(MGR_COUNT_ONE);
|
||||
0 MGR_UNMIGRATED_TAIL_SLOTS(MGR_COUNT_ONE) MGR_UNMIGRATED_TAIL_VALUE_SLOTS(MGR_COUNT_ONE) + 1;
|
||||
#undef MGR_COUNT_ONE
|
||||
constexpr Uint32 kUnmigratedSlots =
|
||||
kUnmigratedD1 + kUnmigratedI1 + kUnmigratedT2 + kUnmigratedF1 + kUnmigratedTail;
|
||||
@@ -1910,9 +1766,7 @@ namespace MobileGL::MG_Remote::Client {
|
||||
constexpr Uint32 kEmittedSlotsI1 = 7;
|
||||
constexpr Uint32 kEmittedSlotsT2 = 7;
|
||||
constexpr Uint32 kEmittedSlotsF1 = 11;
|
||||
// BlitNamedFramebuffer, both texture readbacks, and SetSwapInterval (P10 B) - the one
|
||||
// class-B slot that crosses as a surface control frame rather than a SEG_CMD record.
|
||||
constexpr Uint32 kEmittedSlotsTail = 4;
|
||||
constexpr Uint32 kEmittedSlotsTail = 3; // BlitNamedFramebuffer, both texture readbacks
|
||||
constexpr Uint32 kEmittedSlotsSync = 5;
|
||||
constexpr Uint32 kEmittedSlotsQueries = 11;
|
||||
constexpr Uint32 kEmittedSlots =
|
||||
@@ -1947,6 +1801,7 @@ namespace MobileGL::MG_Remote::Client {
|
||||
MGR_UNMIGRATED_GL_SLOTS(MGR_ASSIGN_UNMIGRATED)
|
||||
MGR_UNMIGRATED_GL_VALUE_SLOTS(MGR_ASSIGN_UNMIGRATED)
|
||||
#undef MGR_ASSIGN_UNMIGRATED
|
||||
table.SetSwapInterval = &SetSwapInterval_Unmigrated;
|
||||
|
||||
table.GL.FenceSync = &EmitFenceSync;
|
||||
table.GL.ClientWaitSync = &EmitClientWaitSync;
|
||||
@@ -2004,11 +1859,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
table.GL.BlitFramebuffer = &EmitBlitFramebuffer;
|
||||
table.GL.BlitNamedFramebuffer = &EmitBlitNamedFramebuffer;
|
||||
table.Present = &EmitPresent;
|
||||
// P10 B: the swap interval is the server's presentation-path question, so the slot
|
||||
// forwards it there as a SurfaceControlFrame (ServerLoop.cpp's SetSwapInterval arm),
|
||||
// across processes on spawn and tcp - the forwarder BackendObject_Remote's deleted
|
||||
// SetEGLSwapInterval override used to call.
|
||||
table.SetSwapInterval = &Server::ServerSetEGLSwapInterval;
|
||||
// ---- class B, P5b t2. Assigned AFTER the class-C block above, which is what makes
|
||||
// the flip a single-line change per slot: the Fatal thunk is overwritten, and a slot
|
||||
// whose row is removed from MGR_UNMIGRATED_T2_SLOTS but not assigned here would be
|
||||
@@ -2049,20 +1899,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
|
||||
} // namespace
|
||||
|
||||
void NoteFenceSignaledByServer(MG_Pipe::MGPipeHandle fence) {
|
||||
RememberFenceSignaled(fence);
|
||||
g_fenceServerReports.fetch_add(1, std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
FencePollCounters ReadFencePollCounters() {
|
||||
FencePollCounters counters;
|
||||
counters.LocalAnswers = g_fenceLocalAnswers.load(std::memory_order_relaxed);
|
||||
counters.Escalations = g_fenceEscalations.load(std::memory_order_relaxed);
|
||||
counters.RoundTrips = g_fenceRoundTrips.load(std::memory_order_relaxed);
|
||||
counters.ServerReports = g_fenceServerReports.load(std::memory_order_relaxed);
|
||||
return counters;
|
||||
}
|
||||
|
||||
const MG_Backend::GlobalBackendFunctionsTable& RemoteEmitTable() {
|
||||
// Leaked at exit like every other MG_Remote singleton (ID-8): MG_Backend::Init()
|
||||
// copies it into gBackendFunctionsTable and MobileGL::Destroy() clears that copy from
|
||||
|
||||
@@ -38,10 +38,7 @@
|
||||
// Present has ZERO MG_Impl call sites: it is reached through EGLImpl.cpp:178 ->
|
||||
// BackendObject.cpp:396, so mirroring GLImpl will not find it.
|
||||
// C. Fatal{UnmigratedVerb} - the remaining 64, SetSwapInterval and GetGpuTimestampNs among
|
||||
// them. (That was P5's partition. P5b..P10 moved every one of them to B; the last,
|
||||
// SetSwapInterval, is a forward to the server's control channel since P10, and class C is
|
||||
// empty. UnmigratedVerbFatal below remains the named refusal of a class-B emitter's
|
||||
// unrepresentable SHAPE - "<slot>+<QUALIFIER>".)
|
||||
// them.
|
||||
//
|
||||
// AND THE RULE R-4 WOULD OTHERWISE BREAK. 41 of the 69 slots are null-checked at their call
|
||||
// site, and several of those checks are CAPABILITY PROBES, not safety checks - BeginOcclusionQuery
|
||||
@@ -287,23 +284,4 @@ namespace MobileGL::MG_Remote::Client {
|
||||
GLsizei drawCount, GLsizei stride,
|
||||
GLintptr parameterOffset, Bool hasParameterBuffer);
|
||||
|
||||
// ---- P10 (CONTRACT-P10.md §1): fence polls answered from the reverse channel ----------
|
||||
//
|
||||
// The event drain's half: the server reported `fence` signaled (kEventFenceSignaled). Every
|
||||
// later glClientWaitSync / glGetSynciv(GL_SYNC_STATUS) on it answers without a round trip.
|
||||
void NoteFenceSignaledByServer(MG_Pipe::MGPipeHandle fence);
|
||||
|
||||
// What the fence polls cost, for the lanes. `LocalAnswers` = polls answered with no record
|
||||
// (signaled or not); `Escalations` = zero-timeout polls that had gone unanswered
|
||||
// MOBILEGL_IPC_POLL_ESCALATE times in a row and took a round trip; `RoundTrips` = every
|
||||
// fence answer that crossed (escalations, non-zero timeouts, POLL_ESCALATE=0);
|
||||
// `ServerReports` = kEventFenceSignaled records consumed.
|
||||
struct FencePollCounters {
|
||||
Uint64 LocalAnswers = 0;
|
||||
Uint64 Escalations = 0;
|
||||
Uint64 RoundTrips = 0;
|
||||
Uint64 ServerReports = 0;
|
||||
};
|
||||
FencePollCounters ReadFencePollCounters();
|
||||
|
||||
} // namespace MobileGL::MG_Remote::Client
|
||||
|
||||
@@ -253,19 +253,6 @@ namespace MobileGL::MG_Remote::Client {
|
||||
// UnmigratedVerbFatal), and it is what gives the hole a red spelling before the
|
||||
// transport arrives.
|
||||
if (!buffer.HasOutstandingGpuWrite()) return;
|
||||
// P9 F1 (CONTRACT-P9.md §4): THE DEVICE WENT AWAY WITH THE WRITE STILL OWED. A lost device
|
||||
// DECLINES every record, so the readback that was to bring the GPU's bytes back was never
|
||||
// sent - and the shadow the caller is about to read holds whatever the buffer held BEFORE
|
||||
// the write (for a pack-buffer read, the bytes before the pixels). Returning it would be the
|
||||
// one outcome the reverse channel exists to prevent: stale bytes that look like a
|
||||
// successful read. It is the reply form's ReadbackDeclined, arriving one call later.
|
||||
if (ClientSession::DeviceLost()) {
|
||||
SessionFail(MGFatalFamily::ReadbackDeclined, "MGPipe: Fatal{ReadbackDeclined, \"buffer-writeback\"} - buffer %u "
|
||||
"still owes a GPU write (a pack-buffer read or a shader store) and the device is "
|
||||
"lost, so its readback was declined; its shadow holds the bytes from before the "
|
||||
"write and is not returned as the GPU's",
|
||||
buffer.GetExternalIndex());
|
||||
}
|
||||
SessionFail(MGFatalFamily::UnimplementedWritebackWait, "MGPipe: Fatal{UnimplementedWritebackWait} - a ClientSession is active and buffer %u "
|
||||
"still has an outstanding GPU write after its readback was emitted. The wait is "
|
||||
"ClientSession::EmitAndWait's (R-3: the reply slot id IS the record seq); P5 package "
|
||||
|
||||
@@ -8,7 +8,6 @@
|
||||
|
||||
#include "PersistentMapTracker.h"
|
||||
#include <MG_Remote/FatalFunnel.h>
|
||||
#include <MG_Remote/Transport/AdoptTier.h>
|
||||
|
||||
#include <MG_Pipe/MGPipeTypes.h>
|
||||
#include <MG_State/GLState/BufferState/BufferObject.h>
|
||||
@@ -1247,23 +1246,27 @@ namespace MobileGL::MG_Remote::Client {
|
||||
Bool AdoptTierIsEmulate() {
|
||||
const Uint32 tier = MG_Config::Ipc.AdoptTier;
|
||||
if (tier == 2) return true;
|
||||
// P11 A1 (CONTRACT-P11 §1): THE VERDICT IS THE HANDSHAKE'S, NOT THIS CALL'S. Both roles
|
||||
// settle the tier from the knob and the data plane before the first record
|
||||
// (Transport/AdoptTier.cpp): a stream refuses T0/T1 by name and runs T2, a client over
|
||||
// shared segments dies by name there, and a server over shared segments serves the T2
|
||||
// its client settled. So a settled session reaching this with 0/1 is a T2 session and
|
||||
// says nothing more - the one line was the handshake's.
|
||||
if (tier <= 1 && Transport::AdoptTierSettledAtHandshake()) return true;
|
||||
// A map_persistent NO handshake settled (a session-free caller) is still a NAMED
|
||||
// refusal rather than a silent T2: falling back would make `MOBILEGL_IPC_ADOPT_TIER=0`
|
||||
// look like a working T0 run and silently produce pmap bytes it must not produce.
|
||||
// Anything above 2 is not a tier at all.
|
||||
// `dl` (CONTRACT-P6 5.2): the family word every death here carries.
|
||||
// A NAMED refusal, not a silent fall back to T2. T0 (a real cross-process shared
|
||||
// mapping) and T1 (a server-side staging map) are P11's, and the reason the knob
|
||||
// parses them today is that the negative control needs a spelling before the thing
|
||||
// it controls exists. Falling back would make `MOBILEGL_IPC_ADOPT_TIER=0` look like
|
||||
// a working T0 run and silently produce pmap bytes it must not produce.
|
||||
// 0 and 1 are the two CONTRACT §5 promises - a real cross-process shared mapping and a
|
||||
// server-side staging map - and they name P11. Anything else is not a tier at all, and
|
||||
// saying "P11 implements it" of a 7 would be a lie the operator then repeats. Both die
|
||||
// here rather than at parse, which is late: the abort lands at the first
|
||||
// map_persistent, so a mis-set run gets through EGL bring-up and a frame of setup
|
||||
// first. Moving it to the parse means a knob-validity rule in ConfigLoader, which is
|
||||
// c0's file; filed for the integrator rather than taken here.
|
||||
// `dl` (CONTRACT-P6 5.2): THE FAMILY WORD THIS SITE NEVER CARRIED. a6 found two aborts
|
||||
// under MG_Remote/ with no Fatal{ marker at all, so "the log stays verbatim" was not true
|
||||
// of them and no family grep could see them - this is one. (The other, WireLog.cpp's, is
|
||||
// the sanctioned funnel: every one of its callers passes a Fatal{ string of its own.)
|
||||
if (tier <= 1) {
|
||||
SessionFail(MGFatalFamily::UnimplementedAdoptTier,
|
||||
"MGPipe: Fatal{UnimplementedAdoptTier, \"T%u\"} - MOBILEGL_IPC_ADOPT_TIER=%u "
|
||||
"reached a map_persistent that no handshake settled; T0 and T1 are not "
|
||||
"implemented and only T2 (emulate) runs.",
|
||||
"names an adoption tier P11 implements and P5 does not; P5 runs at T2 "
|
||||
"(emulate) only.",
|
||||
static_cast<unsigned>(tier), static_cast<unsigned>(tier));
|
||||
} else {
|
||||
SessionFail(MGFatalFamily::UnimplementedAdoptTier,
|
||||
|
||||
@@ -268,13 +268,10 @@ namespace MobileGL::MG_Remote::Client {
|
||||
// draw-path binding walks move to the client.
|
||||
void PushPersistentMapsBeforeVerb();
|
||||
|
||||
// R-6's tier gate, read at use. True for MOBILEGL_IPC_ADOPT_TIER=2, the only implemented
|
||||
// tier. The tiers are design/07's: T0 = the client allocates an AHardwareBuffer and the
|
||||
// server imports it (P11 package B), T1 = the server exports an opaque fd (closed), T2 =
|
||||
// decline and push. 0 and 1 are SETTLED AT THE HANDSHAKE (P11 A1, Transport/AdoptTier.h):
|
||||
// a stream refuses them by name and runs T2, a client over shared segments dies by name
|
||||
// there. So a settled session answers true here; only a map_persistent no handshake
|
||||
// settled is still a named refusal. It is asked
|
||||
// R-6's tier gate, and the ONE spelling of it. True for MOBILEGL_IPC_ADOPT_TIER=2, the
|
||||
// only tier P5 implements; 0 (a real cross-process shared mapping) and 1 (a server-side
|
||||
// staging map) parse - so the negative control has a name before the thing it controls
|
||||
// exists - and are a NAMED refusal here rather than a silent fall back to T2. It is asked
|
||||
// by MGPipeApplyMapPersistent, which is where the decline is decided, so the client's
|
||||
// three adoption call sites keep their existing "null means declined" branch and the
|
||||
// map-persistent-roundtrips counter keeps counting ATTEMPTS in both arms (E3(c) asserts
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
// Included in EmitTables.cpp's client-only anonymous namespace.
|
||||
// The server returns owned tight pixels. Only the client interprets PACK state
|
||||
// and application pointers. A pack-buffer destination (P9) is answered by nothing: the
|
||||
// client sends the layout it computed and the server lands the rows in the buffer; the
|
||||
// reply form's "PBO rows are ordinary buffer uploads after the reply" remains the arm for
|
||||
// a buffer PackBufferReadbackTarget refuses.
|
||||
// and application pointers; PBO rows are ordinary buffer uploads after the reply.
|
||||
struct ReadbackLayout {
|
||||
Uint64 RowBytes = 0, RowStride = 0, ImageStride = 0, Start = 0, End = 0, Tight = 0;
|
||||
};
|
||||
@@ -44,30 +41,6 @@
|
||||
"Pixel packing exceeds the destination or its addressable range."));
|
||||
}
|
||||
|
||||
// P9 (W1, MG_Remote/CONTRACT-P9.md §1): MAY A READ INTO THIS PACK BUFFER GO WITHOUT A
|
||||
// REPLY? The answer is the buffer's handle when it may - the read then crosses as
|
||||
// read_pixels_to_buffer / get_texture_image_to_buffer, lands server-side, and the buffer
|
||||
// is marked GPU-written - and the null handle when the reply-slot form has to carry it.
|
||||
// `end` is the last byte past the application's offset the read touches.
|
||||
//
|
||||
// Each refusal is a case the mark cannot keep its promise in, not a preference:
|
||||
// - MOBILEGL_IPC_PBO_READBACK_SYNC=1, the A/B and red-once arm;
|
||||
// - no readback route (BufferWritebackIsReachable: no size, or the resource family
|
||||
// is not on the wire), so SyncGpuWrites would clear the mark with nothing fetched;
|
||||
// - a MAPPED buffer. Only a persistent mapping can be live across a read, and its
|
||||
// reader takes the bytes straight from the pointer through no call this side sees:
|
||||
// no SyncGpuWrites would ever run for it, and the pixels would never arrive;
|
||||
// - a range MGPSubData cannot name (a buffer offset stops at 2^31-1);
|
||||
// - a buffer that never crossed: it has no handle for the server to write into, and
|
||||
// the reply form's UploadSubData is what creates it.
|
||||
MG_Pipe::MGPipeHandle PackBufferReadbackTarget(const SharedPtr<MG_State::GLState::BufferObject>& pbo,
|
||||
Uint64 end) {
|
||||
if (!pbo || MG_Config::Ipc.PboReadbackSync != 0) return MG_Pipe::kMGPipeNullHandle;
|
||||
if (!BufferWritebackIsReachable(*pbo) || pbo->IsMapped()) return MG_Pipe::kMGPipeNullHandle;
|
||||
if (end > 0x7FFFFFFFull) return MG_Pipe::kMGPipeNullHandle;
|
||||
return MG_Pipe::MGPipeSlots().FindByLifetimeId(MG_Pipe::MGPipeKind::Buffer, pbo->GetLifetimeId());
|
||||
}
|
||||
|
||||
void EmitGetTextureImage(const SharedPtr<MG_State::GLState::ITextureObject>& texture,
|
||||
TextureUploadTarget uploadTarget, GLint level, GLenum format,
|
||||
GLenum type, GLsizei bufSize, void* pixels) {
|
||||
@@ -107,29 +80,6 @@
|
||||
info.Type = type;
|
||||
info.Target = wholeCube ? GL_TEXTURE_CUBE_MAP : MG_Util::ConvertTextureUploadTargetToGLEnum(uploadTarget);
|
||||
info.Level = static_cast<Uint16>(level);
|
||||
// P9 (W1): into a pack buffer, ONE record and no wait. The whole level crosses at
|
||||
// once - there is no reply slot to fit, and the server reads the whole level for
|
||||
// every window of the reply form anyway - and the rows land in the buffer at the
|
||||
// layout computed above. The mark goes first, like every producer row's: the set
|
||||
// describes the work the record is about to start.
|
||||
if (pbo) {
|
||||
const MG_Pipe::MGPipeHandle target = PackBufferReadbackTarget(pbo, pboOffset + layout.End);
|
||||
if (!MG_Pipe::MGPipeHandleIsNull(target)) {
|
||||
MarkReadPixelsPackBuffer();
|
||||
MG_Pipe::MGPReadbackToBuffer record{};
|
||||
record.Src = info;
|
||||
record.Src.DstOffset = 0;
|
||||
record.Src.DstSize = tight;
|
||||
record.Dst = target;
|
||||
record.DstBase = pboOffset + layout.Start;
|
||||
record.RowStride = layout.RowStride;
|
||||
record.ImageStride = layout.ImageStride;
|
||||
record.SwapGroup = ReadbackSwapGroup(type, pack);
|
||||
session.EmitAndWait(MG_Pipe::MGPWireOp::GetTextureImageToBuffer, &record,
|
||||
sizeof(record), nullptr, 0, nullptr, 0, nullptr);
|
||||
return;
|
||||
}
|
||||
}
|
||||
Vector<Uint8> bytes(static_cast<SizeT>(tight));
|
||||
const Uint64 capacity = session.MaxReplyBytes();
|
||||
if (!capacity) Wire::WireProtocolFatal("GetTextureImage.reply", "zero reply capacity");
|
||||
|
||||
@@ -50,9 +50,6 @@ struct WelcomeBuilder;
|
||||
struct DataBind;
|
||||
struct DataBindBuilder;
|
||||
|
||||
struct PairBind;
|
||||
struct PairBindBuilder;
|
||||
|
||||
struct CapsSnapshot;
|
||||
struct CapsSnapshotBuilder;
|
||||
|
||||
@@ -555,12 +552,11 @@ enum class CtrlMsg : uint8_t {
|
||||
LogFlush = 12,
|
||||
DataBind = 13,
|
||||
SurfaceProgress = 14,
|
||||
PairBind = 15,
|
||||
MIN = NONE,
|
||||
MAX = PairBind
|
||||
MAX = SurfaceProgress
|
||||
};
|
||||
|
||||
inline const CtrlMsg (&EnumValuesCtrlMsg())[16] {
|
||||
inline const CtrlMsg (&EnumValuesCtrlMsg())[15] {
|
||||
static const CtrlMsg values[] = {
|
||||
CtrlMsg::NONE,
|
||||
CtrlMsg::Hello,
|
||||
@@ -576,14 +572,13 @@ inline const CtrlMsg (&EnumValuesCtrlMsg())[16] {
|
||||
CtrlMsg::Refuse,
|
||||
CtrlMsg::LogFlush,
|
||||
CtrlMsg::DataBind,
|
||||
CtrlMsg::SurfaceProgress,
|
||||
CtrlMsg::PairBind
|
||||
CtrlMsg::SurfaceProgress
|
||||
};
|
||||
return values;
|
||||
}
|
||||
|
||||
inline const char * const *EnumNamesCtrlMsg() {
|
||||
static const char * const names[17] = {
|
||||
static const char * const names[16] = {
|
||||
"NONE",
|
||||
"Hello",
|
||||
"Welcome",
|
||||
@@ -599,14 +594,13 @@ inline const char * const *EnumNamesCtrlMsg() {
|
||||
"LogFlush",
|
||||
"DataBind",
|
||||
"SurfaceProgress",
|
||||
"PairBind",
|
||||
nullptr
|
||||
};
|
||||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNameCtrlMsg(CtrlMsg e) {
|
||||
if (::flatbuffers::IsOutRange(e, CtrlMsg::NONE, CtrlMsg::PairBind)) return "";
|
||||
if (::flatbuffers::IsOutRange(e, CtrlMsg::NONE, CtrlMsg::SurfaceProgress)) return "";
|
||||
const size_t index = static_cast<size_t>(e);
|
||||
return EnumNamesCtrlMsg()[index];
|
||||
}
|
||||
@@ -671,10 +665,6 @@ template<> struct CtrlMsgTraits<MobileGL::Wire::SurfaceProgress> {
|
||||
static const CtrlMsg enum_value = CtrlMsg::SurfaceProgress;
|
||||
};
|
||||
|
||||
template<> struct CtrlMsgTraits<MobileGL::Wire::PairBind> {
|
||||
static const CtrlMsg enum_value = CtrlMsg::PairBind;
|
||||
};
|
||||
|
||||
template <bool B = false>
|
||||
bool VerifyCtrlMsg(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, CtrlMsg type);
|
||||
template <bool B = false>
|
||||
@@ -1488,76 +1478,6 @@ inline ::flatbuffers::Offset<DataBind> CreateDataBindDirect(
|
||||
nonce__);
|
||||
}
|
||||
|
||||
struct PairBind FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef PairBindBuilder Builder;
|
||||
struct Traits;
|
||||
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
||||
VT_NONCE = 4,
|
||||
VT_AUX = 6
|
||||
};
|
||||
const ::flatbuffers::Vector<uint8_t> *nonce() const {
|
||||
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_NONCE);
|
||||
}
|
||||
bool aux() const {
|
||||
return GetField<uint8_t>(VT_AUX, 0) != 0;
|
||||
}
|
||||
template <bool B = false>
|
||||
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyOffset(verifier, VT_NONCE) &&
|
||||
verifier.VerifyVector(nonce()) &&
|
||||
VerifyField<uint8_t>(verifier, VT_AUX, 1) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct PairBindBuilder {
|
||||
typedef PairBind Table;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
::flatbuffers::uoffset_t start_;
|
||||
void add_nonce(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> nonce) {
|
||||
fbb_.AddOffset(PairBind::VT_NONCE, nonce);
|
||||
}
|
||||
void add_aux(bool aux) {
|
||||
fbb_.AddElement<uint8_t>(PairBind::VT_AUX, static_cast<uint8_t>(aux), 0);
|
||||
}
|
||||
explicit PairBindBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
::flatbuffers::Offset<PairBind> Finish() {
|
||||
const auto end = fbb_.EndTable(start_);
|
||||
auto o = ::flatbuffers::Offset<PairBind>(end);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
inline ::flatbuffers::Offset<PairBind> CreatePairBind(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> nonce = 0,
|
||||
bool aux = false) {
|
||||
PairBindBuilder builder_(_fbb);
|
||||
builder_.add_nonce(nonce);
|
||||
builder_.add_aux(aux);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct PairBind::Traits {
|
||||
using type = PairBind;
|
||||
static auto constexpr Create = CreatePairBind;
|
||||
};
|
||||
|
||||
inline ::flatbuffers::Offset<PairBind> CreatePairBindDirect(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
const std::vector<uint8_t> *nonce = nullptr,
|
||||
bool aux = false) {
|
||||
auto nonce__ = nonce ? _fbb.CreateVector<uint8_t>(*nonce) : 0;
|
||||
return MobileGL::Wire::CreatePairBind(
|
||||
_fbb,
|
||||
nonce__,
|
||||
aux);
|
||||
}
|
||||
|
||||
struct CapsSnapshot FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef CapsSnapshotBuilder Builder;
|
||||
struct Traits;
|
||||
@@ -2496,9 +2416,6 @@ struct CtrlEnvelope FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
const MobileGL::Wire::SurfaceProgress *msg_as_SurfaceProgress() const {
|
||||
return msg_type() == MobileGL::Wire::CtrlMsg::SurfaceProgress ? static_cast<const MobileGL::Wire::SurfaceProgress *>(msg()) : nullptr;
|
||||
}
|
||||
const MobileGL::Wire::PairBind *msg_as_PairBind() const {
|
||||
return msg_type() == MobileGL::Wire::CtrlMsg::PairBind ? static_cast<const MobileGL::Wire::PairBind *>(msg()) : nullptr;
|
||||
}
|
||||
template <bool B = false>
|
||||
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
@@ -2565,10 +2482,6 @@ template<> inline const MobileGL::Wire::SurfaceProgress *CtrlEnvelope::msg_as<Mo
|
||||
return msg_as_SurfaceProgress();
|
||||
}
|
||||
|
||||
template<> inline const MobileGL::Wire::PairBind *CtrlEnvelope::msg_as<MobileGL::Wire::PairBind>() const {
|
||||
return msg_as_PairBind();
|
||||
}
|
||||
|
||||
struct CtrlEnvelopeBuilder {
|
||||
typedef CtrlEnvelope Table;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
@@ -2667,10 +2580,6 @@ inline bool VerifyCtrlMsg(::flatbuffers::VerifierTemplate<B> &verifier, const vo
|
||||
auto ptr = reinterpret_cast<const MobileGL::Wire::SurfaceProgress *>(obj);
|
||||
return verifier.VerifyTable(ptr);
|
||||
}
|
||||
case CtrlMsg::PairBind: {
|
||||
auto ptr = reinterpret_cast<const MobileGL::Wire::PairBind *>(obj);
|
||||
return verifier.VerifyTable(ptr);
|
||||
}
|
||||
default: return true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -67,9 +67,7 @@ extern "C" {
|
||||
// 2 P7 (p7/spawnhang): the SurfaceProgress message.
|
||||
// 3 P12 (on-screen server window): WindowKind.ServerOwned, the SurfaceRefusal enum and
|
||||
// SurfaceReply.width/height/refusal.
|
||||
// 4 P11 PAIR: the PairBind message - a socket client's control and aux connections pair by
|
||||
// the nonce each presents first, not by arrival order.
|
||||
#define MOBILEGL_PROTOCOL_CONTROL_REVISION 4
|
||||
#define MOBILEGL_PROTOCOL_CONTROL_REVISION 3
|
||||
|
||||
#define MOBILEGL_ABI_VERSION(major, minor) (((uint32_t)(major) << 16) | (uint32_t)(minor))
|
||||
#define MOBILEGL_ABI_MAJOR_OF(version) ((uint32_t)(version) >> 16)
|
||||
|
||||
@@ -142,19 +142,6 @@ table DataBind {
|
||||
nonce: [ubyte];
|
||||
}
|
||||
|
||||
// P11 PAIR. The FIRST frame on each of the two connections a socket client opens with
|
||||
// SocketTransport::ConnectTo - control, then aux (the SCM_RIGHTS socket; the data connection on a
|
||||
// tcp:// ConnectTo) - and on control the only frame before the Hello. `nonce` is 128 bits from the
|
||||
// client's CSPRNG, the same on both; `aux` says which of the two this connection is. The server
|
||||
// holds every accepted connection until it has presented this and pairs the two halves by the
|
||||
// nonce, never by arrival order (Server/PairAcceptor.h): a stray connection, or a second client
|
||||
// connecting at the same moment, cannot become half of this client's session. A control connection
|
||||
// whose first frame is a Hello is a peer from before this message and is refused by name.
|
||||
table PairBind {
|
||||
nonce: [ubyte];
|
||||
aux: bool;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Capabilities
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -414,7 +401,6 @@ union CtrlMsg {
|
||||
LogFlush,
|
||||
DataBind,
|
||||
SurfaceProgress,
|
||||
PairBind,
|
||||
}
|
||||
|
||||
table CtrlEnvelope {
|
||||
|
||||
@@ -1,200 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_Remote/Server/ApplyThreadPolicy.h
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
|
||||
// P11 B1 (CONTRACT-P11 B1): WHERE THE APPLY THREAD RUNS AND HOW LONG IT SPINS, CHOSEN PER SESSION
|
||||
// FROM WHO THE CLIENT IS AND WHICH DATA PLANE IT USES.
|
||||
//
|
||||
// `auto` used to mean one thing for every session: the apply thread pinned to every big core
|
||||
// (DetectBigCoreMask, 0xc0 on the workload device) and spinning MOBILEGL_IPC_SPIN_US before each
|
||||
// park. That is right for inproc and the same-app fork spawn (A4's measured shapes), and for a client
|
||||
// on the stream plane, whose records an io thread feeds to the apply thread. It is wrong for a
|
||||
// client that DIALLED IN from another process over SHARED SEGMENTS - an app_process-launched
|
||||
// program (the fd: endpoint), a Termux one, a root or same-app one on `unix:`: the apply thread
|
||||
// spins on the ring that client writes directly, the client's GL thread lands on the same two prime
|
||||
// cores, and on the Redmi rd12 ran 23-26 fps over shared memory against 45-54 over tcp, 118 when the
|
||||
// two were placed apart by hand (B0-CROSS-APP.md, HSPIKE.md). So `auto` now reads the peer's Hello:
|
||||
//
|
||||
// peer, plane `auto` resolves to
|
||||
// in-process (No) every big core, the configured spin - unchanged
|
||||
// forked (Fork) every big core, the configured spin - unchanged
|
||||
// dialled in (Connect), stream every big core, the configured spin - unchanged
|
||||
// dialled in, shared segments ONE core, ReservedApplyCore's: the lowest of several prime cores,
|
||||
// a big core beside a lone prime core, or none - never the only
|
||||
// prime core - and kConnectedPeerSpinUs unless MOBILEGL_IPC_SPIN_US
|
||||
//
|
||||
// The lowest prime core, not the highest, by measurement (CONTRACT-P11 B1): the scheduler puts a
|
||||
// foreground app's hot GL thread on the HIGHEST prime core (cpu7 in 43 of 44 samples); pinning the
|
||||
// apply thread there shared that core with it (rd12 6.5 fps), pinning it to the lowest gave 120. A
|
||||
// client launched through ExternalClientHelper is also kept off the reserved core (the supervisor
|
||||
// announces it, the broker hands it to the helper), so a client the scheduler would otherwise place
|
||||
// on it - an adb-shell one - is not starved either.
|
||||
//
|
||||
// An explicit mask or `off` wins for every peer, exactly as before: the operator's word is the
|
||||
// policy. A pure function, so the unit suite can hold every row without a thread or a cpufreq tree.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <Includes.h>
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
|
||||
namespace MobileGL::MG_Remote::Server {
|
||||
|
||||
// Who the session's client is, from its Hello (protocol.fbs DialMode).
|
||||
enum class ApplyPeer : Uint8 {
|
||||
InProcess = 0, // DialMode::No - inproc: the client is another thread of this process
|
||||
Forked = 1, // DialMode::Fork - the client launched this server (same app, same build)
|
||||
Connected = 2, // DialMode::Connect - the client dialled a standing server: another process,
|
||||
// possibly another app (tcp://, unix:, fd:)
|
||||
};
|
||||
|
||||
// The apply thread's spin before it parks, for a dialled-in shared-segment peer when
|
||||
// MOBILEGL_IPC_SPIN_US is not set. 50 us - the global default - by measurement: parking at once
|
||||
// (0) lost in every cell measured (rd12 Espryt 120 -> 74 fps on the helper route, 27 -> 17 from the
|
||||
// shell), so the short spin stays (CONTRACT-P11 B1).
|
||||
inline constexpr Uint32 kConnectedPeerSpinUs = 50;
|
||||
|
||||
struct ApplyThreadPolicy {
|
||||
Uint64 requestedMask = 0; // 0 = make no affinity call
|
||||
Uint32 spinUs = 0;
|
||||
Bool recognised = true; // false: the affinity text was not `auto`, `off` or a number
|
||||
const char* rule = ""; // what the log line names
|
||||
};
|
||||
|
||||
inline const char* ApplyPeerName(ApplyPeer peer) {
|
||||
switch (peer) {
|
||||
case ApplyPeer::InProcess: return "in-process";
|
||||
case ApplyPeer::Forked: return "forked";
|
||||
case ApplyPeer::Connected: return "connected";
|
||||
}
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
inline Uint32 PopCount64(Uint64 mask) {
|
||||
Uint32 count = 0;
|
||||
for (; mask != 0; mask &= mask - 1) ++count;
|
||||
return count;
|
||||
}
|
||||
|
||||
inline Uint64 LowestBit64(Uint64 mask) { return mask & (~mask + 1); }
|
||||
|
||||
// Why ReservedApplyCore answered what it did - the log line names it.
|
||||
enum class ReservedCoreReason : Uint8 {
|
||||
LowestOfSeveralPrimeCores = 0, // two or more cores at the peak clock: the lowest of them
|
||||
BigCoreBesideTheOnlyPrime = 1, // one core at the peak clock: the lowest OTHER big core
|
||||
OnlyPrimeCoreLeftAlone = 2, // one core at the peak clock and no other big core: none
|
||||
NoAsymmetry = 3, // every cpu is big, or the topology was unreadable: none
|
||||
};
|
||||
|
||||
inline const char* ReservedCoreReasonText(ReservedCoreReason reason) {
|
||||
switch (reason) {
|
||||
case ReservedCoreReason::LowestOfSeveralPrimeCores:
|
||||
return "auto: the lowest of the prime cores, the rest left to the dialled-in shared-segment client";
|
||||
case ReservedCoreReason::BigCoreBesideTheOnlyPrime:
|
||||
return "auto: a big core beside the only prime core, which is left to the dialled-in shared-segment client";
|
||||
case ReservedCoreReason::OnlyPrimeCoreLeftAlone:
|
||||
return "auto: unpinned - the only prime core is left to the dialled-in shared-segment client and there "
|
||||
"is no other big core";
|
||||
case ReservedCoreReason::NoAsymmetry:
|
||||
return "auto: unpinned - no asymmetric big/prime topology to split";
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
// The core `auto` reserves for a dialled-in shared-segment peer's apply thread, which spins there.
|
||||
// `bigCoreMask` = cpus within 15% of the peak clock, `primeMask` = cpus AT the peak clock (both
|
||||
// DetectCoreTopology's), `onlineMask` = one bit per cpu counted. The rule never hands the spinning
|
||||
// apply thread the ONLY prime core - a foreground client's GL thread wants it:
|
||||
// several prime cores -> the lowest prime core (the client takes a higher one)
|
||||
// one prime core, other big cores -> the lowest of those other big cores
|
||||
// one prime core and nothing else big -> none (unpinned)
|
||||
// no asymmetry (every cpu big, or 0) -> none (unpinned)
|
||||
// The supervisor logs the answer at start-up and the broker hands it to the helper (the core the
|
||||
// client is kept off), so this function is the one source of that core.
|
||||
inline Uint64 ReservedApplyCore(Uint64 bigCoreMask, Uint64 primeMask, Uint64 onlineMask,
|
||||
ReservedCoreReason* outReason = nullptr) {
|
||||
ReservedCoreReason reason = ReservedCoreReason::NoAsymmetry;
|
||||
Uint64 core = 0;
|
||||
primeMask &= bigCoreMask;
|
||||
const Bool asymmetric = bigCoreMask != 0 && (bigCoreMask & onlineMask) != onlineMask && primeMask != 0;
|
||||
if (asymmetric) {
|
||||
if (PopCount64(primeMask) >= 2) {
|
||||
core = LowestBit64(primeMask);
|
||||
reason = ReservedCoreReason::LowestOfSeveralPrimeCores;
|
||||
} else if ((bigCoreMask & ~primeMask) != 0) {
|
||||
core = LowestBit64(bigCoreMask & ~primeMask);
|
||||
reason = ReservedCoreReason::BigCoreBesideTheOnlyPrime;
|
||||
} else {
|
||||
reason = ReservedCoreReason::OnlyPrimeCoreLeftAlone;
|
||||
}
|
||||
}
|
||||
if (outReason != nullptr) *outReason = reason;
|
||||
return core;
|
||||
}
|
||||
|
||||
// `affinity` is MOBILEGL_IPC_SERVER_AFFINITY's raw text (null or empty = `auto`); `spinExplicit`
|
||||
// says MOBILEGL_IPC_SPIN_US was set in this process's environment and `configuredSpinUs` is its
|
||||
// value (ConfigLoader's, 50 when unset); `sharedSegments` is the session's data plane (false =
|
||||
// stream); `bigCoreMask` / `primeMask` are DetectCoreTopology()'s answer (0 when the topology is
|
||||
// unreadable) and `onlineMask` one bit per cpu the process could see.
|
||||
inline ApplyThreadPolicy SelectApplyThreadPolicy(const char* affinity, Bool spinExplicit, Uint32 configuredSpinUs,
|
||||
ApplyPeer peer, Bool sharedSegments, Uint64 bigCoreMask,
|
||||
Uint64 primeMask, Uint64 onlineMask) {
|
||||
ApplyThreadPolicy policy;
|
||||
policy.spinUs = configuredSpinUs;
|
||||
const Bool automatic = affinity == nullptr || affinity[0] == '\0' || std::strcmp(affinity, "auto") == 0;
|
||||
if (!automatic) {
|
||||
if (std::strcmp(affinity, "off") == 0) {
|
||||
policy.rule = "off";
|
||||
return policy;
|
||||
}
|
||||
char* end = nullptr;
|
||||
const unsigned long long parsed = std::strtoull(affinity, &end, 0);
|
||||
if (end == affinity || (end != nullptr && *end != '\0')) {
|
||||
policy.recognised = false;
|
||||
policy.rule = "unrecognised";
|
||||
return policy;
|
||||
}
|
||||
policy.requestedMask = static_cast<Uint64>(parsed);
|
||||
policy.rule = "explicit mask";
|
||||
return policy;
|
||||
}
|
||||
if (peer != ApplyPeer::Connected) {
|
||||
policy.requestedMask = bigCoreMask;
|
||||
policy.rule = "auto: every big core (in-process / forked peer)";
|
||||
return policy;
|
||||
}
|
||||
if (!sharedSegments) {
|
||||
// The stream plane: an io thread feeds the apply thread, which does not spin on the
|
||||
// client's writes - B0 measured 7.9 ms/frame of apply CPU there against 26.8 on shm.
|
||||
policy.requestedMask = bigCoreMask;
|
||||
policy.rule = "auto: every big core (dialled-in peer on the stream plane)";
|
||||
return policy;
|
||||
}
|
||||
policy.spinUs = spinExplicit ? configuredSpinUs : kConnectedPeerSpinUs;
|
||||
ReservedCoreReason reason = ReservedCoreReason::NoAsymmetry;
|
||||
policy.requestedMask = ReservedApplyCore(bigCoreMask, primeMask, onlineMask, &reason);
|
||||
policy.rule = ReservedCoreReasonText(reason);
|
||||
return policy;
|
||||
}
|
||||
|
||||
// What the supervisor announces at start-up and the broker relays to the helper: the core this
|
||||
// process's configuration reserves for a dialled-in shared-segment peer's apply thread. An operator's
|
||||
// affinity (a mask or `off`) reserves nothing - the client is then not kept off any core.
|
||||
inline Uint64 ReservedApplyCoreForConfig(const char* affinity, Uint64 bigCoreMask, Uint64 primeMask,
|
||||
Uint64 onlineMask, ReservedCoreReason* outReason = nullptr) {
|
||||
const Bool automatic = affinity == nullptr || affinity[0] == '\0' || std::strcmp(affinity, "auto") == 0;
|
||||
if (!automatic) {
|
||||
if (outReason != nullptr) *outReason = ReservedCoreReason::NoAsymmetry;
|
||||
return 0;
|
||||
}
|
||||
return ReservedApplyCore(bigCoreMask, primeMask, onlineMask, outReason);
|
||||
}
|
||||
|
||||
} // namespace MobileGL::MG_Remote::Server
|
||||
@@ -8,7 +8,7 @@
|
||||
|
||||
// P12 (on-screen server window), D3/D5/D6/D7. THE JNI GLUE OF THE IN-PROCESS DISPLAY SERVER.
|
||||
//
|
||||
// The APK's MobileGLDisplayActivity (android:process=":mglwin") owns a SurfaceView and runs
|
||||
// The trace APK's MobileGLDisplayActivity (android:process=":mglwin") owns a SurfaceView and runs
|
||||
// the TCP server on a thread of its own process, so a headless client (MOBILEGL_IPC_SURFACE=server)
|
||||
// renders straight onto that SurfaceView. This file is the whole native half of that Activity:
|
||||
//
|
||||
|
||||
@@ -32,14 +32,12 @@
|
||||
|
||||
extern "C" {
|
||||
|
||||
// Serves `endpoint` on the CALLING thread until mobilegl_server_stop_inprocess is called and the
|
||||
// live session (if any) has ended, then returns 0. The endpoint is tcp://host:port, or - for a
|
||||
// same-device client - a unix @abstract name or filesystem path, whose control+data pair and
|
||||
// SCM_RIGHTS shm segments make it the fastest on-device shape. Other returns, all logged by
|
||||
// name: 64 / 65 (the environment preconditions above), 71 (empty endpoint), 72 (could not
|
||||
// listen - EADDRINUSE is retried for up to ~5 s first, the previous server may still be dying),
|
||||
// 73 (the listener failed), 74 (a server is already serving in this process). Re-callable after
|
||||
// it returned.
|
||||
// Serves `endpoint` (tcp://host:port only) on the CALLING thread until mobilegl_server_stop_inprocess
|
||||
// is called and the live session (if any) has ended, then returns 0. Other returns, all logged by
|
||||
// name: 64 / 65 (the environment preconditions above), 71 (not a tcp:// endpoint), 72 (could not
|
||||
// listen - EADDRINUSE is retried for up to ~5 s first, the previous server may still be dying), 73
|
||||
// (the listener failed), 74 (a server is already serving in this process). Re-callable after it
|
||||
// returned.
|
||||
__attribute__((visibility("default"))) int mobilegl_server_serve_inprocess(const char* endpoint);
|
||||
|
||||
// Asks the in-process server to stop and returns at once (it does not wait: call it from a UI
|
||||
|
||||
@@ -1,291 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_Remote/Server/PairAcceptor.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
|
||||
// P11 PAIR: see PairAcceptor.h for what is paired, what is refused and why.
|
||||
|
||||
#include "PairAcceptor.h"
|
||||
|
||||
#if !defined(_WIN32)
|
||||
|
||||
#include "../Handshake.h" // AuthenticatePeerToken / ValidatePeerHandshake, for a Hello sent first
|
||||
#include "../Transport/WireLog.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cerrno>
|
||||
#include <cstring>
|
||||
|
||||
#include <poll.h>
|
||||
#include <sys/socket.h>
|
||||
#include <unistd.h>
|
||||
|
||||
namespace MobileGL::MG_Remote::Server {
|
||||
|
||||
namespace {
|
||||
namespace Protocol = ::MobileGL::Wire;
|
||||
using Transport::SocketTransport;
|
||||
using Transport::TransportRole;
|
||||
using Step = FirstFrameAssembler::Step;
|
||||
|
||||
// A pause after accept(2) ran out of descriptors or memory: the connection waits in the
|
||||
// backlog and the listener is fine (TcpSupervisor pauses the same way).
|
||||
constexpr std::uint32_t kAcceptPauseMs = 100;
|
||||
|
||||
std::int64_t MillisecondsUntil(PairAcceptor::Clock::time_point when, PairAcceptor::Clock::time_point now) {
|
||||
return std::chrono::duration_cast<std::chrono::milliseconds>(when - now).count();
|
||||
}
|
||||
|
||||
// Whatever the peer already sent, read and dropped (non-blocking, bounded), so the close
|
||||
// after a refusal does not become an RST that discards the refusal (ServerMain.cpp's
|
||||
// DrainUnread; RefuseBusy's comment has the reason).
|
||||
void DrainUnread(int fd) {
|
||||
char sink[4096];
|
||||
for (int rounds = 0; rounds < 256; ++rounds) {
|
||||
if (::recv(fd, sink, sizeof(sink), MSG_DONTWAIT) <= 0) return;
|
||||
}
|
||||
}
|
||||
|
||||
void Refuse(SocketTransport& connection, Protocol::RefuseCode code, const char* detail) {
|
||||
::flatbuffers::FlatBufferBuilder builder(256);
|
||||
auto refusal = Protocol::CreateRefuseDirect(builder, code, detail);
|
||||
auto envelope = Protocol::CreateCtrlEnvelope(builder, Protocol::CtrlMsg::Refuse, refusal.Union());
|
||||
Protocol::FinishCtrlEnvelopeBuffer(builder, envelope);
|
||||
(void)connection.SendFrame({builder.GetBufferPointer(), builder.GetSize()});
|
||||
Transport::WireLogError("MG_Remote server: Refuse{%s} %s", Protocol::EnumNameRefuseCode(code), detail);
|
||||
}
|
||||
|
||||
// Refuses a connection held as a bare descriptor, and closes it (with shutdown(2): here the
|
||||
// descriptor is only ever the supervisor's).
|
||||
void RefuseAndClose(int fd, Protocol::RefuseCode code, const char* detail) {
|
||||
SocketTransport connection(fd, -1, TransportRole::Server);
|
||||
DrainUnread(fd);
|
||||
Refuse(connection, code, detail);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
PairAcceptor::PairAcceptor(int listenFd, std::uint32_t budgetMs) : m_listener(listenFd), m_budgetMs(budgetMs) {}
|
||||
|
||||
PairAcceptor::~PairAcceptor() {
|
||||
for (auto& waiting : m_waiting) Drop(waiting, true, kPairStopped);
|
||||
for (const auto& pair : m_ready) {
|
||||
RefuseAndClose(pair.first, Protocol::RefuseCode::Busy, kPairStopped);
|
||||
::close(pair.second);
|
||||
}
|
||||
}
|
||||
|
||||
void PairAcceptor::CloseInForkedChild() {
|
||||
for (auto& waiting : m_waiting)
|
||||
if (waiting.fd >= 0) ::close(waiting.fd);
|
||||
for (const auto& pair : m_ready) {
|
||||
::close(pair.first);
|
||||
::close(pair.second);
|
||||
}
|
||||
m_waiting.clear();
|
||||
m_ready.clear();
|
||||
}
|
||||
|
||||
MobileGLResult PairAcceptor::Accept(std::uint32_t timeoutMs, std::unique_ptr<SocketTransport>& outServer) {
|
||||
outServer.reset();
|
||||
if (m_listener < 0) return MOBILEGL_ERR_INVALID_ARGUMENT;
|
||||
const auto until = Clock::now() + std::chrono::milliseconds(timeoutMs);
|
||||
std::vector<pollfd> fds;
|
||||
std::vector<std::size_t> polled; // index into m_waiting of fds[1..]
|
||||
for (;;) {
|
||||
if (!m_ready.empty()) {
|
||||
const auto pair = m_ready.front();
|
||||
m_ready.pop_front();
|
||||
outServer = std::make_unique<SocketTransport>(pair.first, pair.second, TransportRole::Server);
|
||||
return MOBILEGL_OK;
|
||||
}
|
||||
auto now = Clock::now();
|
||||
Expire(now);
|
||||
// While accepting is paused the listener sits out the poll (it stays readable and would
|
||||
// spin the loop), and the pause's end is a wakeup.
|
||||
const bool acceptPaused = now < m_acceptResumeAt;
|
||||
fds.clear();
|
||||
polled.clear();
|
||||
fds.push_back({acceptPaused ? -1 : m_listener, POLLIN, 0});
|
||||
std::int64_t wait = std::clamp<std::int64_t>(MillisecondsUntil(until, now), 0, 1 << 30);
|
||||
for (std::size_t index = 0; index < m_waiting.size(); ++index) {
|
||||
const Waiting& waiting = m_waiting[index];
|
||||
wait = std::clamp<std::int64_t>(MillisecondsUntil(waiting.deadline, now) + 1, 0, wait);
|
||||
// A bound connection is not read again: on control its Hello follows, and that is
|
||||
// the session's to read. It only waits for its partner or its deadline.
|
||||
if (waiting.bound) continue;
|
||||
fds.push_back({waiting.fd, POLLIN, 0});
|
||||
polled.push_back(index);
|
||||
}
|
||||
if (acceptPaused) wait = std::clamp<std::int64_t>(MillisecondsUntil(m_acceptResumeAt, now) + 1, 0, wait);
|
||||
const int ready = ::poll(fds.data(), static_cast<nfds_t>(fds.size()), static_cast<int>(wait));
|
||||
if (ready < 0 && errno != EINTR) {
|
||||
Transport::WireLogError("MG_Remote server: the pairing poll failed: %s", std::strerror(errno));
|
||||
return MOBILEGL_ERR_TRANSPORT_CLOSED;
|
||||
}
|
||||
if (ready > 0) {
|
||||
for (std::size_t slot = 0; slot < polled.size(); ++slot)
|
||||
if (fds[slot + 1].revents != 0) Read(m_waiting[polled[slot]]);
|
||||
Compact();
|
||||
if ((fds[0].revents & (POLLIN | POLLERR | POLLHUP)) != 0) {
|
||||
const MobileGLResult accepted = AcceptNew(Clock::now());
|
||||
if (accepted != MOBILEGL_OK) return accepted;
|
||||
}
|
||||
}
|
||||
if (m_ready.empty() && Clock::now() >= until) return MOBILEGL_ERR_TIMEOUT;
|
||||
}
|
||||
}
|
||||
|
||||
// Accepts everything the listener has; each connection waits in the set until it identifies.
|
||||
MobileGLResult PairAcceptor::AcceptNew(Clock::time_point now) {
|
||||
for (int burst = 0; burst < 64; ++burst) {
|
||||
int fd = -1;
|
||||
const MobileGLResult accepted = SocketTransport::AcceptOne(m_listener, 0, &fd);
|
||||
if (accepted == MOBILEGL_ERR_TIMEOUT) return MOBILEGL_OK;
|
||||
if (accepted == MOBILEGL_ERR_OUT_OF_MEMORY) {
|
||||
m_acceptResumeAt = now + std::chrono::milliseconds(kAcceptPauseMs);
|
||||
MGLOG_W("MG_Remote server: accept paused for %u ms: out of descriptors or memory with %zu "
|
||||
"connections waiting to be paired",
|
||||
kAcceptPauseMs, m_waiting.size());
|
||||
return MOBILEGL_OK;
|
||||
}
|
||||
if (accepted != MOBILEGL_OK) {
|
||||
Transport::WireLogError("MG_Remote server: the listener failed while pairing (rc=%d)",
|
||||
static_cast<int>(accepted));
|
||||
return MOBILEGL_ERR_TRANSPORT_CLOSED;
|
||||
}
|
||||
if (m_waiting.size() >= kPairMaxUnpaired) {
|
||||
// The oldest connection that has not said who it is goes first; with none, the oldest.
|
||||
auto victim = std::find_if(m_waiting.begin(), m_waiting.end(),
|
||||
[](const Waiting& waiting) { return !waiting.bound; });
|
||||
if (victim == m_waiting.end()) victim = m_waiting.begin();
|
||||
MGLOG_W("MG_Remote server: %zu connections are waiting to be paired; the oldest %s one is dropped",
|
||||
m_waiting.size(), victim->bound ? "identified" : "unidentified");
|
||||
Drop(*victim, true, kPairFull);
|
||||
m_waiting.erase(victim);
|
||||
}
|
||||
Waiting waiting;
|
||||
waiting.fd = fd;
|
||||
waiting.deadline = now + std::chrono::milliseconds(m_budgetMs);
|
||||
m_waiting.push_back(std::move(waiting));
|
||||
}
|
||||
return MOBILEGL_OK;
|
||||
}
|
||||
|
||||
void PairAcceptor::Read(Waiting& waiting) {
|
||||
switch (waiting.frame.Pump(waiting.fd)) {
|
||||
case Step::NeedMore:
|
||||
return;
|
||||
case Step::Complete:
|
||||
Judge(waiting);
|
||||
return;
|
||||
case Step::EndedEmpty:
|
||||
// A readiness probe - a connect() and a close() - costs an accept and nothing else.
|
||||
MGLOG_D("MG_Remote server: a connection closed before presenting a PairBind (a probe); dropped");
|
||||
::close(waiting.fd);
|
||||
waiting.fd = -1;
|
||||
return;
|
||||
case Step::NotAFrame:
|
||||
RefuseAndClose(waiting.fd, Protocol::RefuseCode::MalformedHello, kFirstFrameNotAFrame);
|
||||
waiting.fd = -1;
|
||||
return;
|
||||
case Step::EndedPartial:
|
||||
RefuseAndClose(waiting.fd, Protocol::RefuseCode::MalformedHello, kFirstFrameTruncated);
|
||||
waiting.fd = -1;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// A complete first frame. A PairBind either completes a pair or waits for its partner.
|
||||
void PairAcceptor::Judge(Waiting& waiting) {
|
||||
std::uint8_t nonce[Transport::kPairNonceBytes] = {};
|
||||
bool aux = false;
|
||||
if (!Transport::DecodePairBind(waiting.frame.Payload(), nonce, &aux)) {
|
||||
RefuseUnpairable(waiting);
|
||||
return;
|
||||
}
|
||||
for (auto& other : m_waiting) {
|
||||
if (&other == &waiting || other.fd < 0 || !other.bound ||
|
||||
!Transport::ConstantTimeNonceMatch(other.nonce, nonce))
|
||||
continue;
|
||||
if (other.aux == aux) {
|
||||
MGLOG_W("MG_Remote server: a second %s connection presented a pair nonce that is already waiting",
|
||||
aux ? "aux" : "control");
|
||||
Drop(waiting, false, kPairDuplicate);
|
||||
return;
|
||||
}
|
||||
m_ready.emplace_back(aux ? other.fd : waiting.fd, aux ? waiting.fd : other.fd);
|
||||
other.fd = -1;
|
||||
waiting.fd = -1;
|
||||
return;
|
||||
}
|
||||
waiting.bound = true;
|
||||
waiting.aux = aux;
|
||||
std::memcpy(waiting.nonce, nonce, sizeof(nonce));
|
||||
}
|
||||
|
||||
// A first frame that is not a PairBind. Nothing can be paired with it, and it is told so by name.
|
||||
void PairAcceptor::RefuseUnpairable(Waiting& waiting) {
|
||||
const auto& payload = waiting.frame.Payload();
|
||||
const int fd = waiting.fd;
|
||||
waiting.fd = -1;
|
||||
SocketTransport connection(fd, -1, TransportRole::Server);
|
||||
DrainUnread(fd);
|
||||
const FirstFrameShape shape = ClassifyFirstFrame(payload.data(), payload.size());
|
||||
if (shape == FirstFrameShape::Hello) {
|
||||
// A client from before PairBind (control revision < 4) writes its Hello first. It is
|
||||
// asked what RunSession would ask, in RunSession's order - the token, then the wire - so
|
||||
// an older client hears Refuse{WireFingerprint} exactly as a session would answer it.
|
||||
const auto* hello = Protocol::GetCtrlEnvelope(payload.data())->msg_as_Hello();
|
||||
if (AuthenticatePeerToken(connection, hello->token()) != MOBILEGL_OK) return;
|
||||
if (ValidatePeerHandshake(connection, hello->abiMajor(), hello->abiMinor(), hello->wireFingerprint(),
|
||||
hello->buildFingerprint() ? hello->buildFingerprint()->c_str() : nullptr,
|
||||
hello->dialMode()) != MOBILEGL_OK)
|
||||
return;
|
||||
Refuse(connection, Protocol::RefuseCode::MalformedHello, kPairHelloFirst);
|
||||
return;
|
||||
}
|
||||
if (shape == FirstFrameShape::DataBind) {
|
||||
// RunSession's own words for a DataBind that reaches a listener with no session for it.
|
||||
Refuse(connection, Protocol::RefuseCode::Authentication, "data connection names no live session");
|
||||
return;
|
||||
}
|
||||
Refuse(connection, Protocol::RefuseCode::MalformedHello, FirstFrameRefusalDetail(shape));
|
||||
}
|
||||
|
||||
// Past its deadline a connection is dropped; nothing that is still inside its budget is touched.
|
||||
void PairAcceptor::Expire(Clock::time_point now) {
|
||||
for (auto& waiting : m_waiting) {
|
||||
if (waiting.fd < 0 || now < waiting.deadline) continue;
|
||||
if (waiting.bound)
|
||||
MGLOG_W("MG_Remote server: a%s connection's partner never presented its pair nonce within %u ms; "
|
||||
"dropped",
|
||||
waiting.aux ? "n aux" : " control", m_budgetMs);
|
||||
Drop(waiting, false, waiting.bound ? kPairNoPartner : kPairNoBind);
|
||||
}
|
||||
Compact();
|
||||
}
|
||||
|
||||
void PairAcceptor::Drop(Waiting& waiting, bool busy, const char* detail) {
|
||||
if (waiting.fd < 0) return;
|
||||
if (waiting.bound && waiting.aux) {
|
||||
::shutdown(waiting.fd, SHUT_RDWR);
|
||||
::close(waiting.fd);
|
||||
} else {
|
||||
RefuseAndClose(waiting.fd, busy ? Protocol::RefuseCode::Busy : Protocol::RefuseCode::Authentication,
|
||||
detail);
|
||||
}
|
||||
waiting.fd = -1;
|
||||
}
|
||||
|
||||
void PairAcceptor::Compact() {
|
||||
m_waiting.erase(std::remove_if(m_waiting.begin(), m_waiting.end(),
|
||||
[](const Waiting& waiting) { return waiting.fd < 0; }),
|
||||
m_waiting.end());
|
||||
}
|
||||
|
||||
} // namespace MobileGL::MG_Remote::Server
|
||||
|
||||
#endif
|
||||
@@ -1,131 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_Remote/Server/PairAcceptor.h
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
|
||||
// P11 PAIR. A SOCKET CLIENT'S TWO CONNECTIONS ARE PAIRED BY WHO THEY ARE, NOT BY WHEN THEY ARRIVED.
|
||||
//
|
||||
// SocketTransport::ConnectTo opens two connections to one listener - control, then aux (the
|
||||
// SCM_RIGHTS socket; on tcp:// the data connection). The server used to take "the next two accepted
|
||||
// connections, first is control" (SocketTransport::AcceptPair). That was a protocol only while
|
||||
// nothing else could reach the listener, and on the device it was not (B0-CROSS-APP.md F2): the
|
||||
// server app's readiness probe - one connect() and close() - became the next client's control
|
||||
// connection, that session read the probe's socket and ended ("control peer closed before sending
|
||||
// a first frame"), and the client got no Welcome. Two clients connecting at the same moment could
|
||||
// just as well swap halves.
|
||||
//
|
||||
// Now each connection's first frame is a PairBind (protocol.fbs, control revision 4): the client's
|
||||
// nonce, the same on both, and which half it is. This acceptor keeps every accepted connection in a
|
||||
// small set until it has presented one, and hands out a control and an aux connection only when
|
||||
// their nonces match. What it does with everything else:
|
||||
// - a connection that closes having sent nothing (a readiness probe) is closed, quietly;
|
||||
// - a first frame that is not a PairBind is refused by name. A Hello is a client from before
|
||||
// PairBind: it is asked what the session would ask, in the session's order - the token, then the
|
||||
// wire (Handshake.h) - so it hears Refuse{WireFingerprint} as it would from any session, and one
|
||||
// that passes both is still refused, because it cannot be paired;
|
||||
// - a connection that has not presented a PairBind, or whose partner has not presented the same
|
||||
// nonce, within the budget is dropped - a control connection with a refusal, an aux connection
|
||||
// (whose client reads descriptors there, not frames) by closing it - and nobody else's
|
||||
// connection is touched;
|
||||
// - past kPairMaxUnpaired connections the oldest one that has not identified itself (else the
|
||||
// oldest) is dropped the same way.
|
||||
//
|
||||
// It never reads a byte past a PairBind (FirstFrameAssembler): on control the Hello follows it, and
|
||||
// the session reads that itself; on aux the descriptors follow it.
|
||||
//
|
||||
// Stateful because pairs complete out of order: with A-control, B-control, B-aux, A-aux, B is
|
||||
// handed out first and A-control has to still be here for the call that hands out A.
|
||||
|
||||
#pragma once
|
||||
|
||||
#if !defined(_WIN32)
|
||||
|
||||
#include "../Transport/PairBind.h"
|
||||
#include "../Transport/SocketTransport.h"
|
||||
#include "PreAuthGate.h" // FirstFrameAssembler
|
||||
|
||||
#include <chrono>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <deque>
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace MobileGL::MG_Remote::Server {
|
||||
|
||||
// How long an accepted connection may stay unpaired: to present its PairBind, and then to be
|
||||
// joined by its partner. The old AcceptPair's wait for a second connection, and ConnectTo's
|
||||
// budget for opening it.
|
||||
inline constexpr std::uint32_t kPairBudgetMs = 2000;
|
||||
// Connections held unpaired at once. A client needs two, and the rendezvous is local.
|
||||
inline constexpr std::size_t kPairMaxUnpaired = 16;
|
||||
|
||||
// The refusal details a peer (and the log) sees.
|
||||
inline constexpr const char* kPairNoBind = "no PairBind within the pairing budget";
|
||||
inline constexpr const char* kPairNoPartner =
|
||||
"no aux connection presented this connection's pair nonce within the pairing budget";
|
||||
inline constexpr const char* kPairHelloFirst =
|
||||
"the control connection's first frame is a Hello, not a PairBind (control revision 4 pairs by nonce)";
|
||||
inline constexpr const char* kPairDuplicate = "a connection with this pair nonce and role is already waiting";
|
||||
inline constexpr const char* kPairFull = "too many connections are waiting to be paired";
|
||||
inline constexpr const char* kPairStopped = "the server stopped accepting before this connection was paired";
|
||||
|
||||
class PairAcceptor {
|
||||
public:
|
||||
using Clock = std::chrono::steady_clock;
|
||||
|
||||
// `listenFd` stays the caller's. `budgetMs` is kPairBudgetMs outside the unit test.
|
||||
explicit PairAcceptor(int listenFd, std::uint32_t budgetMs = kPairBudgetMs);
|
||||
// Every connection still held is let go of (kPairStopped, Busy), with shutdown(2).
|
||||
~PairAcceptor();
|
||||
PairAcceptor(const PairAcceptor&) = delete;
|
||||
PairAcceptor& operator=(const PairAcceptor&) = delete;
|
||||
|
||||
// One client's pair, waiting at most `timeoutMs` for it: OK with `outServer` holding the
|
||||
// control connection as its stream and the aux connection; MOBILEGL_ERR_TIMEOUT when no pair
|
||||
// completed in time (connections still unpaired are KEPT for the next call); and
|
||||
// MOBILEGL_ERR_TRANSPORT_CLOSED when the listener itself failed.
|
||||
MobileGLResult Accept(std::uint32_t timeoutMs, std::unique_ptr<Transport::SocketTransport>& outServer);
|
||||
|
||||
// A forked session child's copy of every held descriptor, closed WITHOUT shutdown(2) - that
|
||||
// would disconnect the supervisor's copy too - and without a word: they are the supervisor's.
|
||||
void CloseInForkedChild();
|
||||
|
||||
// Connections accepted and not yet handed out as a pair.
|
||||
std::size_t Unpaired() const { return m_waiting.size(); }
|
||||
|
||||
private:
|
||||
struct Waiting {
|
||||
int fd = -1;
|
||||
Clock::time_point deadline{};
|
||||
FirstFrameAssembler frame;
|
||||
bool bound = false; // its PairBind has arrived
|
||||
bool aux = false;
|
||||
std::uint8_t nonce[Transport::kPairNonceBytes] = {};
|
||||
};
|
||||
|
||||
MobileGLResult AcceptNew(Clock::time_point now);
|
||||
void Read(Waiting& waiting);
|
||||
void Judge(Waiting& waiting);
|
||||
void RefuseUnpairable(Waiting& waiting);
|
||||
void Expire(Clock::time_point now);
|
||||
// A control connection, or one that never said which it is, is refused (Busy when it was
|
||||
// crowded out or the server stopped, else Authentication) and closed; an aux connection is
|
||||
// closed - its client reads descriptors there, never frames.
|
||||
void Drop(Waiting& waiting, bool busy, const char* detail);
|
||||
void Compact();
|
||||
|
||||
int m_listener;
|
||||
std::uint32_t m_budgetMs;
|
||||
std::vector<Waiting> m_waiting; // accept order, oldest first
|
||||
std::deque<std::pair<int, int>> m_ready; // {control, aux}, not yet handed out
|
||||
Clock::time_point m_acceptResumeAt{};
|
||||
};
|
||||
|
||||
} // namespace MobileGL::MG_Remote::Server
|
||||
|
||||
#endif
|
||||
@@ -155,8 +155,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
entry.Live = true;
|
||||
// GL_Sync.cpp treats an absent slot or a null creation result as always signaled.
|
||||
entry.Native = table->GL.FenceSync == nullptr ? nullptr : table->GL.FenceSync();
|
||||
// P10: in creation order, for ReportSignaledFences - the order the GPU finishes them in.
|
||||
m_unreportedFences.push_back(handle);
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -218,58 +216,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
}
|
||||
}
|
||||
m_fences.clear();
|
||||
m_unreportedFences.clear();
|
||||
}
|
||||
|
||||
// P10 (CONTRACT-P10.md §1): WHICH OF THE CLIENT'S FENCES HAS THE GPU FINISHED.
|
||||
//
|
||||
// The client answers a poll of a fence it knows is signaled without asking - that is the
|
||||
// whole of package A - and it learns what is signaled only from here. Walked in CREATION
|
||||
// order and stopped at the first one still pending: one context's GPU work completes in
|
||||
// the order it was submitted, so a later fence cannot be done while an earlier one is not,
|
||||
// and the steady-state cost is one status query per drain batch. (Were a backend ever to
|
||||
// finish them out of order, the later fence would only be reported late - an answer the
|
||||
// client then gets by its own round trip - never early.)
|
||||
//
|
||||
// `flush`: the apply thread is about to go idle. A fence whose commands the driver still
|
||||
// holds never signals on its own, and an idle server submits nothing more, so the first
|
||||
// pending fence is asked through ClientWaitSync(GL_SYNC_FLUSH_COMMANDS_BIT, 0) - the one
|
||||
// backend-neutral way both backends take to submit what they hold - instead of the plain
|
||||
// status query. Only when idle: mid-stream the next records flush soon enough, and a
|
||||
// submit per batch would cost Magma its command-buffer batching.
|
||||
Uint32 ServerVerbSink::ReportSignaledFences(Bool flush) {
|
||||
if (m_unreportedFences.empty()) return 0;
|
||||
ServerSession* session = ServerSession::Active();
|
||||
if (session == nullptr || m_backend == nullptr) return 0;
|
||||
const MG_Backend::GLFunctionsTable& gl = m_backend->GetBackendFunctions().GL;
|
||||
Uint32 reported = 0;
|
||||
while (!m_unreportedFences.empty()) {
|
||||
const MG_Pipe::MGPipeHandle handle = m_unreportedFences.front();
|
||||
const auto it = m_fences.find(handle.Slot);
|
||||
if (it == m_fences.end() || !it->second.Live || it->second.Gen != handle.Gen) {
|
||||
// Deleted before it was seen signaled: nobody can poll it any more.
|
||||
m_unreportedFences.pop_front();
|
||||
continue;
|
||||
}
|
||||
const FenceEntry& entry = it->second;
|
||||
Bool signaled = entry.Native == nullptr;
|
||||
if (!signaled) {
|
||||
if (flush && gl.ClientWaitSync != nullptr) {
|
||||
const GLenum status = gl.ClientWaitSync(entry.Native, GL_SYNC_FLUSH_COMMANDS_BIT, 0);
|
||||
signaled = status == GL_ALREADY_SIGNALED || status == GL_CONDITION_SATISFIED;
|
||||
flush = false; // one submit is all an idle server owes
|
||||
++m_fenceIdleFlushes;
|
||||
} else {
|
||||
signaled = gl.GetSyncStatus == nullptr || gl.GetSyncStatus(entry.Native);
|
||||
}
|
||||
}
|
||||
if (!signaled) break;
|
||||
m_unreportedFences.pop_front();
|
||||
session->PostFenceSignaled(handle);
|
||||
++reported;
|
||||
}
|
||||
m_fencesReported += reported;
|
||||
return reported;
|
||||
}
|
||||
|
||||
#include "QueryServer.inc"
|
||||
@@ -425,11 +371,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
// swap and not the record's apply. It advances presentAckSerial AND rings the client's
|
||||
// bell - a client parked in WaitForPresentAck(kWaitForever) needs the pair.
|
||||
if (ServerSession* session = ServerSession::Active()) {
|
||||
// P10 (CONTRACT-P10.md §1): the fences finished by now are reported BEFORE the credit
|
||||
// goes back - a client released by the credit polls or waits on the fence of a frame
|
||||
// or two ago at once, and a report posted only after this batch would race it. A
|
||||
// status query, no submit: the swap has just submitted.
|
||||
if (session->EventRingHasRoom()) ReportSignaledFences(/*flush=*/false);
|
||||
session->ReturnPresentCredit(m_lastPresentSerial);
|
||||
}
|
||||
return true;
|
||||
@@ -452,7 +393,14 @@ namespace MobileGL::MG_Remote::Server {
|
||||
image.DstOffset = 0;
|
||||
image.DstSize = tight;
|
||||
Vector<Uint8> bytes;
|
||||
const Bool ok = ReadTextureImageTight(image, bytes);
|
||||
Bool ok = false;
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
if (m_backend && m_backend->GetBackendType() == BackendType::DirectGLES)
|
||||
ok = MG_Backend::DirectGLES::ReadTextureImageWire(image, bytes);
|
||||
else if (m_backend && m_backend->GetBackendType() == BackendType::DirectVulkan &&
|
||||
MG_Backend::DirectVulkan::pVulkanRenderer)
|
||||
ok = MG_Backend::DirectVulkan::pVulkanRenderer->ReadTextureImageWire(image, bytes);
|
||||
#endif
|
||||
if (!ok || bytes.size() != tight) {
|
||||
replies->PostReply(seq, Wire::ReplySink::kStatusError, nullptr, 0);
|
||||
return false;
|
||||
@@ -522,29 +470,13 @@ namespace MobileGL::MG_Remote::Server {
|
||||
static_cast<unsigned long long>(bpp));
|
||||
}
|
||||
|
||||
if (!ReadBoundFramebufferTight(info, tight)) {
|
||||
const MG_Backend::GlobalBackendFunctionsTable* table = Table("read_pixels");
|
||||
if (table == nullptr || table->GL.ReadPixels == nullptr) {
|
||||
// A well-formed call can still be unsupported by this server; return the
|
||||
// established decline status after the peer-controlled size has been checked.
|
||||
replies->PostReply(seq, Wire::ReplySink::kStatusDeclined, nullptr, 0);
|
||||
return false;
|
||||
}
|
||||
|
||||
// m-7: the answer is written into the slot HERE, mid-apply, while the verb stamp is still
|
||||
// up - and that is safe for exactly one reason, which is the contract's and is stated so it
|
||||
// is not mistaken for luck: the client reaches a reply slot ONLY through appliedSeq
|
||||
// (ReplySlot.h's ORDERING clause), never by polling the slot's own stamp, and s1's
|
||||
// SessionConsumer::ApplyOne publishes appliedSeq only AFTER PipeApplier::ApplyOne has run
|
||||
// LeaveApplier() and (on the joint tree) dropped the ScopedApplierEntry. So by the time the
|
||||
// client is allowed to look at this slot, the apply-side gPipeInputs flag is already down.
|
||||
replies->PostReply(seq, Wire::ReplySink::kStatusOk, m_readbackScratch.data(), tight);
|
||||
m_readbackBytes += tight;
|
||||
++m_readbacks;
|
||||
return true;
|
||||
}
|
||||
|
||||
Bool ServerVerbSink::ReadBoundFramebufferTight(const MG_Pipe::MGPReadbackInfo& info, Uint64 tight) {
|
||||
const MG_Backend::GlobalBackendFunctionsTable* table = Table("read_pixels");
|
||||
if (table == nullptr || table->GL.ReadPixels == nullptr) return false;
|
||||
if (tight > m_readbackScratch.size()) {
|
||||
m_readbackScratch.resize(static_cast<SizeT>(tight));
|
||||
}
|
||||
@@ -569,198 +501,20 @@ namespace MobileGL::MG_Remote::Server {
|
||||
MG_Pipe::MGPPixelPackState restorePack{};
|
||||
restorePack.Pack = savedPack;
|
||||
MG_Pipe::MGPipeApplySetPixelPackState(restorePack);
|
||||
|
||||
// m-7: the answer is written into the slot HERE, mid-apply, while the verb stamp is still
|
||||
// up - and that is safe for exactly one reason, which is the contract's and is stated so it
|
||||
// is not mistaken for luck: the client reaches a reply slot ONLY through appliedSeq
|
||||
// (ReplySlot.h's ORDERING clause), never by polling the slot's own stamp, and s1's
|
||||
// SessionConsumer::ApplyOne publishes appliedSeq only AFTER PipeApplier::ApplyOne has run
|
||||
// LeaveApplier() and (on the joint tree) dropped the ScopedApplierEntry. So by the time the
|
||||
// client is allowed to look at this slot, the apply-side gPipeInputs flag is already down.
|
||||
replies->PostReply(seq, Wire::ReplySink::kStatusOk, m_readbackScratch.data(), tight);
|
||||
m_readbackBytes += tight;
|
||||
++m_readbacks;
|
||||
return true;
|
||||
}
|
||||
|
||||
Bool ServerVerbSink::ReadTextureImageTight(const MG_Pipe::MGPReadbackInfo& image, Vector<Uint8>& bytes) {
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
if (m_backend && m_backend->GetBackendType() == BackendType::DirectGLES)
|
||||
return MG_Backend::DirectGLES::ReadTextureImageWire(image, bytes);
|
||||
if (m_backend && m_backend->GetBackendType() == BackendType::DirectVulkan &&
|
||||
MG_Backend::DirectVulkan::pVulkanRenderer)
|
||||
return MG_Backend::DirectVulkan::pVulkanRenderer->ReadTextureImageWire(image, bytes);
|
||||
#endif
|
||||
(void)image;
|
||||
(void)bytes;
|
||||
return false;
|
||||
}
|
||||
|
||||
// ---- P9 (W1, MG_Remote/CONTRACT-P9.md §1): the pack-buffer readbacks ------------------------
|
||||
//
|
||||
// WHY THE ROWS GO THROUGH THE APPLIER'S BUFFER-WRITE GATE AND NOT THROUGH THE DRIVER'S OWN
|
||||
// PBO READ. Monolith binds the driver buffer as GL_PIXEL_PACK_BUFFER and lets glReadPixels
|
||||
// write it, then maps the whole store back into the frontend shadow (DirectGLES.cpp's
|
||||
// "PBO used, mapping buffer to client memory"). A server has two stores per buffer - the
|
||||
// backend's (GL buffer / VkBuffer) and R-11's staged shadow that every later drain uploads
|
||||
// from - and a driver-side write reaches only the first: the next queued range drained from
|
||||
// the shadow would then land OLD bytes over the pixels on Espryt, and Magma has no pack path
|
||||
// in its ReadPixels at all. MGPipeApplyResourceSubData is the one write both backends already
|
||||
// take from the server (Ops_H_SubData adopts into the staged shadow and queues the range;
|
||||
// WriteWireBuffer orders the copy against in-flight reads), so the rows are exactly what a
|
||||
// client glBufferSubData of the same bytes would have been - same serial bump, same epoch
|
||||
// bump, same ordering against the records that follow.
|
||||
//
|
||||
// THE READ IS THE REPLY FORM'S, byte for byte (ReadBoundFramebufferTight /
|
||||
// ReadTextureImageTight), so the two forms cannot disagree about what a pixel is; only the
|
||||
// destination moved. The PACK layout is the client's arithmetic (ReadbackLayout) carried in
|
||||
// the record, and the byte swap is applied to the tight bytes first, exactly where the client
|
||||
// applied it to its reply.
|
||||
//
|
||||
// A FAILED READ IS LOUD. The reply form's failures reach the client as ERROR / DECLINED and
|
||||
// end in a named Fatal there (RequireReadbackReplyComplete: "a blocking readback has no pixels
|
||||
// to return"); this form has no reply to carry them, and a pack buffer left holding its old
|
||||
// bytes is the same silently wrong answer. So the refusal latches here, under the same family
|
||||
// words.
|
||||
|
||||
// Every number here is the peer's, and they are checked BEFORE the read, so a corrupt record
|
||||
// costs no GPU work - and completely enough that LandReadbackInBuffer cannot meet a range it
|
||||
// would have to refuse: every run it writes starts at or before the LAST row's offset and is
|
||||
// no wider than the tight extent, and both are bounded here by what one MGPSubData can name
|
||||
// (MGPipeSetSubDataBufferRange: an offset up to 2^31-1, a width up to 2^32-1). Whether the
|
||||
// range fits the buffer is the applier's own gate, the one every buffer write meets.
|
||||
static const char* ReadbackToBufferLayoutFault(const MG_Pipe::MGPReadbackToBuffer& record,
|
||||
Uint64 bytesPerPixel) {
|
||||
const MG_Pipe::MGPBox& box = record.Src.Box;
|
||||
const Uint64 rowBytes = static_cast<Uint64>(box.W) * bytesPerPixel;
|
||||
const Uint64 tightBytes = rowBytes * box.H * box.D; // the caller proved this fits
|
||||
if (record.RowStride < rowBytes) return "the row stride is narrower than a tight row";
|
||||
if (box.D > 1 && record.ImageStride < record.RowStride) return "the image stride is narrower than a row";
|
||||
if (record.SwapGroup != 0 && record.SwapGroup != 2 && record.SwapGroup != 4 && record.SwapGroup != 8)
|
||||
return "the swap group is not a byte group GL_PACK_SWAP_BYTES reverses (2, 4 or 8)";
|
||||
constexpr Uint64 kMaxOffset = 0x7FFFFFFFull;
|
||||
const Uint64 lastImage = box.D - 1;
|
||||
const Uint64 lastRow = box.H - 1;
|
||||
if (record.DstBase > kMaxOffset) return "the first row starts past 2^31-1";
|
||||
if (lastImage != 0 && record.ImageStride > (kMaxOffset - record.DstBase) / lastImage)
|
||||
return "the last image starts past 2^31-1";
|
||||
const Uint64 imageBase = record.DstBase + lastImage * record.ImageStride;
|
||||
if (lastRow != 0 && record.RowStride > (kMaxOffset - imageBase) / lastRow)
|
||||
return "the last row starts past 2^31-1";
|
||||
if (tightBytes > 0xFFFFFFFFull) return "the read is wider than one buffer write can name";
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
Bool ServerVerbSink::LandReadbackInBuffer(const MG_Pipe::MGPReadbackToBuffer& record, Uint8* tight,
|
||||
Uint64 bytesPerPixel) {
|
||||
const MG_Pipe::MGPBox& box = record.Src.Box;
|
||||
const Uint64 rowBytes = static_cast<Uint64>(box.W) * bytesPerPixel;
|
||||
const Uint64 rows = box.H;
|
||||
const Uint64 images = box.D;
|
||||
const Uint64 tightBytes = rowBytes * rows * images;
|
||||
if (record.SwapGroup != 0) {
|
||||
const Uint64 group = record.SwapGroup;
|
||||
for (Uint64 at = 0; at + group <= tightBytes; at += group) {
|
||||
for (Uint64 i = 0; i < group / 2; ++i) std::swap(tight[at + i], tight[at + group - 1 - i]);
|
||||
}
|
||||
}
|
||||
|
||||
// ONE WRITE PER CONTIGUOUS RUN: the whole read when the layout is tight (the common
|
||||
// case - a neutral pack state, or an image-packed read of whole images), one per image
|
||||
// when only the rows are tight, one per row otherwise. The bytes between rows are the
|
||||
// application's (GL_PACK_ROW_LENGTH / ALIGNMENT padding) and are never written.
|
||||
const Bool rowsTight = record.RowStride == rowBytes;
|
||||
const Bool imagesTight = images == 1 || record.ImageStride == rowBytes * rows;
|
||||
const Uint64 runBytes = rowsTight ? (imagesTight ? tightBytes : rowBytes * rows) : rowBytes;
|
||||
const Uint64 runsPerImage = rowsTight ? 1 : rows;
|
||||
const Uint64 imageRuns = rowsTight && imagesTight ? 1 : images;
|
||||
for (Uint64 z = 0; z < imageRuns; ++z) {
|
||||
for (Uint64 r = 0; r < runsPerImage; ++r) {
|
||||
// No overflow and no refusal below: ReadbackToBufferLayoutFault bounded the last
|
||||
// offset and the widest run before the read.
|
||||
const Uint64 offset = record.DstBase + z * record.ImageStride + r * record.RowStride;
|
||||
MG_Pipe::MGPSubData write{};
|
||||
write.Res = record.Dst;
|
||||
write.Target = MG_Pipe::kMGPipeResourceTargetBuffer;
|
||||
// HasLiveHostWrites stays 0 and that is the client's fact, not a default: the
|
||||
// client takes this form only for a pack buffer it does not map
|
||||
// (TextureReadbackEmit.inc, PackBufferReadbackTarget), so "no live host writer" is
|
||||
// what a glBufferSubData of the same bytes would have said.
|
||||
if (!MG_Pipe::MGPipeSetSubDataBufferRange(write, offset, runBytes)) return false;
|
||||
const Uint8* bytes = tight + (z * runsPerImage + r) * runBytes;
|
||||
++m_bufferReadbackWrites;
|
||||
// The acceptance is the applier's (a dead handle is a counted no-op, a range
|
||||
// past the store a trip wire), so a refused write ends the landing here.
|
||||
if (!MG_Pipe::MGPipeApplyResourceSubData(write, bytes, nullptr)) return false;
|
||||
}
|
||||
}
|
||||
++m_bufferReadbacks;
|
||||
return true;
|
||||
}
|
||||
|
||||
Bool ServerVerbSink::OnReadPixelsToBuffer(const MG_Pipe::MGPReadbackToBuffer& record) {
|
||||
const MG_Pipe::MGPReadbackInfo& info = record.Src;
|
||||
const Uint64 bpp = static_cast<Uint64>(MG_Util::GetInputBytesPerPixel(
|
||||
MG_Util::ConvertGLEnumToTextureInputFormat(static_cast<GLenum>(info.Format)),
|
||||
MG_Util::ConvertGLEnumToTexturePixelDataType(static_cast<GLenum>(info.Type))));
|
||||
// The reply form's shape checks and its PH-3 bound: the scratch is sized from the record,
|
||||
// so the SERVER's own maxReplyBytes caps it exactly as it caps an answer - the client bands
|
||||
// this form by the same number (PlanReadbackBands), so no correct client is refused by it.
|
||||
// ONE latch site for every shape fault (PeerLatchTest's row names it once).
|
||||
constexpr Uint64 kUint64Max = std::numeric_limits<Uint64>::max();
|
||||
const char* fault = nullptr;
|
||||
Uint64 tight = 0;
|
||||
if (bpp == 0 || info.Box.W == 0 || info.Box.H == 0 || info.Box.D != 1 ||
|
||||
info.Box.W > static_cast<Uint32>(std::numeric_limits<GLsizei>::max()) ||
|
||||
info.Box.H > static_cast<Uint32>(std::numeric_limits<GLsizei>::max())) {
|
||||
fault = "the read box or its format is invalid";
|
||||
} else if (static_cast<Uint64>(info.Box.W) > kUint64Max / info.Box.H ||
|
||||
static_cast<Uint64>(info.Box.W) * info.Box.H > kUint64Max / bpp) {
|
||||
fault = "the tight extent overflows";
|
||||
} else {
|
||||
tight = static_cast<Uint64>(info.Box.W) * info.Box.H * bpp;
|
||||
if (m_maxReplyBytes == 0 || tight > m_maxReplyBytes ||
|
||||
tight > static_cast<Uint64>(std::numeric_limits<SizeT>::max())) {
|
||||
fault = "the tight extent is past this server's maxReplyBytes (PH-3)";
|
||||
} else if (info.DstOffset != 0 || info.DstSize != tight) {
|
||||
fault = "Src.DstOffset / Src.DstSize are not 0 / the tight extent";
|
||||
} else {
|
||||
fault = ReadbackToBufferLayoutFault(record, bpp);
|
||||
}
|
||||
}
|
||||
if (fault != nullptr) {
|
||||
return SessionLatch(MGFatalFamily::ProtocolCorruption, "MGPipe: Fatal{ProtocolCorruption, \"ReadPixelsToBuffer.shape\"} %s", fault);
|
||||
}
|
||||
if (!ReadBoundFramebufferTight(info, tight)) {
|
||||
return SessionLatch(MGFatalFamily::ReadbackDeclined, "MGPipe: Fatal{ReadbackDeclined, \"ReadPixelsToBuffer\"} - the server "
|
||||
"has no GL.ReadPixels; the pack buffer would keep bytes the application is "
|
||||
"about to read as pixels, and there is no reply to carry the decline");
|
||||
}
|
||||
return LandReadbackInBuffer(record, m_readbackScratch.data(), bpp);
|
||||
}
|
||||
|
||||
Bool ServerVerbSink::OnGetTextureImageToBuffer(const MG_Pipe::MGPReadbackToBuffer& record) {
|
||||
const MG_Pipe::MGPReadbackInfo& info = record.Src;
|
||||
const Uint64 bpp = static_cast<Uint64>(MG_Util::GetInputBytesPerPixel(
|
||||
MG_Util::ConvertGLEnumToTextureInputFormat(info.Format),
|
||||
MG_Util::ConvertGLEnumToTexturePixelDataType(info.Type)));
|
||||
const char* fault = nullptr;
|
||||
Uint64 tight = 0;
|
||||
if (!bpp || !info.Box.W || !info.Box.H || !info.Box.D || info.Box.X || info.Box.Y || info.Box.Z) {
|
||||
fault = "the image extent is not a whole level's";
|
||||
} else {
|
||||
tight = static_cast<Uint64>(info.Box.W) * info.Box.H * info.Box.D * bpp;
|
||||
if (tight / bpp / info.Box.W / info.Box.H != info.Box.D) {
|
||||
fault = "the tight extent overflows";
|
||||
} else if (info.DstOffset != 0 || info.DstSize != tight) {
|
||||
fault = "Src.DstOffset / Src.DstSize are not 0 / the tight extent";
|
||||
} else {
|
||||
fault = ReadbackToBufferLayoutFault(record, bpp);
|
||||
}
|
||||
}
|
||||
if (fault != nullptr) {
|
||||
return SessionLatch(MGFatalFamily::ProtocolCorruption, "MGPipe: Fatal{ProtocolCorruption, \"GetTextureImageToBuffer.shape\"} %s", fault);
|
||||
}
|
||||
Vector<Uint8> bytes;
|
||||
if (!ReadTextureImageTight(info, bytes) || bytes.size() != tight) {
|
||||
return SessionLatch(MGFatalFamily::ReplyError, "MGPipe: Fatal{ReplyError, \"GetTextureImageToBuffer\"} - the level "
|
||||
"could not be read (%llu of %llu bytes); the reply form answers ERROR here, and "
|
||||
"this form has no reply to carry it",
|
||||
static_cast<unsigned long long>(bytes.size()),
|
||||
static_cast<unsigned long long>(tight));
|
||||
}
|
||||
return LandReadbackInBuffer(record, bytes.data(), bpp);
|
||||
}
|
||||
|
||||
// P5b's server-side stub shape (CONTRACT-P5B.md): the same line the client's class-C table
|
||||
// raises (EmitTables.cpp UnmigratedVerbFatal) and the same family the census greps, so a
|
||||
// slot flipped on the client ahead of its server half aborts BY NAME on the apply thread
|
||||
|
||||
@@ -46,8 +46,6 @@
|
||||
#include "../Transport/Ring.h"
|
||||
#include "../Wire/PipeWireCodec.h"
|
||||
|
||||
#include <deque>
|
||||
|
||||
namespace MobileGL::MG_Remote::Server {
|
||||
|
||||
// P5e (gl, ID-111): DOES THIS SERVER PUBLISH kCapRunAheadApply? Asked of the server's OWN
|
||||
@@ -159,15 +157,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
Bool OnFenceWait(const MG_Pipe::MGPFenceWait&, Uint32&) override;
|
||||
Bool OnFenceWaitServer(const MG_Pipe::MGPFenceWait&) override;
|
||||
void ReleaseFences();
|
||||
// P10 (CONTRACT-P10.md §1): post kEventFenceSignaled for each client fence, in creation
|
||||
// order, that the GPU has finished, up to the first one still pending. `flush` = the
|
||||
// apply thread is going idle: submit what the driver holds first. Apply thread only.
|
||||
Uint32 ReportSignaledFences(Bool flush);
|
||||
// True while a created fence has not been reported: the loop then parks with a deadline
|
||||
// instead of for ever, so a fence that finishes while no record arrives is still seen.
|
||||
Bool HasUnreportedFences() const { return !m_unreportedFences.empty(); }
|
||||
Uint64 FencesReported() const { return m_fencesReported; }
|
||||
Uint64 FenceIdleFlushes() const { return m_fenceIdleFlushes; }
|
||||
Bool OnQueryCreate(const MG_Pipe::MGPQueryDesc&) override;
|
||||
Bool OnQueryBegin(const MG_Pipe::MGPQueryDesc&) override;
|
||||
Bool OnQueryEnd(const MG_Pipe::MGPQueryDesc&) override;
|
||||
@@ -184,10 +173,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
Wire::ReplySink* replies) override;
|
||||
Bool OnGetTextureImage(const MG_Pipe::MGPReadbackInfo& info, Uint64 seq,
|
||||
Wire::ReplySink* replies) override;
|
||||
// P9 (CONTRACT-P9.md §1): the pack-buffer halves. Nothing is answered; the tight pixels
|
||||
// land in record.Dst through the applier's buffer-write gate.
|
||||
Bool OnReadPixelsToBuffer(const MG_Pipe::MGPReadbackToBuffer& record) override;
|
||||
Bool OnGetTextureImageToBuffer(const MG_Pipe::MGPReadbackToBuffer& record) override;
|
||||
Bool OnDrawVbo(const MG_Pipe::MGPDrawInfo& info, const MG_Pipe::MGPDrawRange* ranges,
|
||||
const MG_Pipe::MGHostSpan* userIndices,
|
||||
const MG_Pipe::MGPDrawIndirect* indirect) override;
|
||||
@@ -262,10 +247,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
Uint64 Presents() const { return m_presents; }
|
||||
Uint64 LastPresentSerial() const { return m_lastPresentSerial; }
|
||||
Uint64 ReadbackBytes() const { return m_readbackBytes; }
|
||||
// P9: pack-buffer readbacks that landed in their buffer (both ops), and the buffer-write
|
||||
// records they took. Readbacks() above counts only the reply-slot form.
|
||||
Uint64 BufferReadbacks() const { return m_bufferReadbacks; }
|
||||
Uint64 BufferReadbackWrites() const { return m_bufferReadbackWrites; }
|
||||
// ---- P5b package i1's tallies. R-16: a probe may not arm against a stub, and on a
|
||||
// split build "the scenario passed" is also what a scenario that never left the
|
||||
// monolith path looks like - so the lane asserts the number that only this sink can
|
||||
@@ -313,18 +294,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
private:
|
||||
const MG_Backend::GlobalBackendFunctionsTable* Table(const char* verb) const;
|
||||
|
||||
// read_pixels' read, shared by the reply form and the pack-buffer form: the bound read
|
||||
// framebuffer, NEUTRAL pack state (ID-49), `tight` bytes into m_readbackScratch. False
|
||||
// when this server has no GL.ReadPixels - the caller owns what that means.
|
||||
Bool ReadBoundFramebufferTight(const MG_Pipe::MGPReadbackInfo& info, Uint64 tight);
|
||||
// get_texture_image's read, shared the same way: the whole level into `bytes`.
|
||||
Bool ReadTextureImageTight(const MG_Pipe::MGPReadbackInfo& image, Vector<Uint8>& bytes);
|
||||
// P9: `tight` holds Src's pixels, tightly packed; land them in record.Dst at the
|
||||
// record's layout through MGPipeApplyResourceSubData, one write per contiguous run. The
|
||||
// layout was checked before the read (PipeApplier.cpp ReadbackToBufferLayoutFault).
|
||||
Bool LandReadbackInBuffer(const MG_Pipe::MGPReadbackToBuffer& record, Uint8* tight,
|
||||
Uint64 bytesPerPixel);
|
||||
|
||||
struct FenceEntry {
|
||||
Uint32 Gen = 0;
|
||||
Bool Live = false;
|
||||
@@ -332,10 +301,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
};
|
||||
FenceEntry& FindFence(MG_Pipe::MGPipeHandle handle);
|
||||
UnorderedMap<Uint32, FenceEntry> m_fences;
|
||||
// P10: created and not yet reported signaled, oldest first.
|
||||
std::deque<MG_Pipe::MGPipeHandle> m_unreportedFences;
|
||||
Uint64 m_fencesReported = 0;
|
||||
Uint64 m_fenceIdleFlushes = 0;
|
||||
struct QueryEntry {
|
||||
Uint32 Gen = 0;
|
||||
Uint32 Kind = 0;
|
||||
@@ -356,8 +321,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
Uint64 m_presents = 0;
|
||||
Uint64 m_lastPresentSerial = 0;
|
||||
Uint64 m_readbackBytes = 0;
|
||||
Uint64 m_bufferReadbacks = 0;
|
||||
Uint64 m_bufferReadbackWrites = 0;
|
||||
Uint64 m_imageBinds = 0;
|
||||
Uint64 m_dispatches = 0;
|
||||
Uint64 m_memoryBarriers = 0;
|
||||
|
||||
@@ -9,9 +9,8 @@
|
||||
// P5 package v1: the apply thread, its affinity, its parking, and the EGL ownership move.
|
||||
|
||||
#include "ServerLoop.h"
|
||||
#include "ApplyThreadPolicy.h"
|
||||
#include <MG_Remote/FatalFunnel.h>
|
||||
#include <MG_Remote/Transport/LinkMetrics.h>
|
||||
#include <MG_Remote/Transport/StreamLink.h>
|
||||
#include <MG_Backend/MGPipe/PipeInputs.h>
|
||||
|
||||
#include <Config.h>
|
||||
@@ -24,7 +23,6 @@
|
||||
#include <chrono>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <thread>
|
||||
|
||||
#if defined(__linux__) || defined(__ANDROID__)
|
||||
@@ -66,39 +64,40 @@ namespace MobileGL::MG_Remote::Server {
|
||||
// the topology cannot be read - Windows, macOS, a container that hides the cpufreq
|
||||
// tree, or a partially readable one - because with no asymmetry information the honest
|
||||
// answer is "do not pin", not "pin to a guess".
|
||||
// P11 B1: and the PRIME set beside it - the cpus AT the peak ceiling - which the dialled-in
|
||||
// shared-segment rule needs so it never hands the spinning apply thread the only prime core.
|
||||
void DetectCoreTopology(Uint64* outBig, Uint64* outPrime) {
|
||||
*outBig = *outPrime = 0;
|
||||
Uint64 DetectBigCoreMask() {
|
||||
const Uint cpuCount = std::min(64u, std::max(1u, std::thread::hardware_concurrency()));
|
||||
Uint64 frequencies[64] = {};
|
||||
for (Uint cpu = 0; cpu < cpuCount; ++cpu) {
|
||||
frequencies[cpu] = ReadCpuMaxFrequencyKHz(cpu);
|
||||
if (frequencies[cpu] == 0) return;
|
||||
if (frequencies[cpu] == 0) return 0;
|
||||
}
|
||||
Uint64 peak = 0;
|
||||
for (Uint cpu = 0; cpu < cpuCount; ++cpu) peak = std::max(peak, frequencies[cpu]);
|
||||
if (peak == 0) return;
|
||||
if (peak == 0) return 0;
|
||||
const Uint64 threshold = peak * kBigCoreFrequencyPercent / 100;
|
||||
Uint64 mask = 0;
|
||||
for (Uint cpu = 0; cpu < cpuCount; ++cpu) {
|
||||
if (frequencies[cpu] >= threshold) *outBig |= (1ull << cpu);
|
||||
if (frequencies[cpu] == peak) *outPrime |= (1ull << cpu);
|
||||
if (frequencies[cpu] >= threshold) mask |= (1ull << cpu);
|
||||
}
|
||||
return mask;
|
||||
}
|
||||
|
||||
// One bit per cpu the process can count, the same count DetectCoreTopology walks - what
|
||||
// lets ApplyThreadPolicy tell a real prime set from a symmetric machine's "every cpu".
|
||||
Uint64 OnlineCpuMask() {
|
||||
const Uint cpuCount = std::min(64u, std::max(1u, std::thread::hardware_concurrency()));
|
||||
return cpuCount >= 64 ? ~0ull : ((1ull << cpuCount) - 1);
|
||||
}
|
||||
|
||||
// Whether MOBILEGL_IPC_SPIN_US was set at all: ConfigLoader answers 50 for "unset" and
|
||||
// for "50", and the dialled-in peer's default spin (ApplyThreadPolicy.h) applies only to
|
||||
// the first.
|
||||
Bool SpinSetExplicitly() {
|
||||
const char* text = std::getenv("MOBILEGL_IPC_SPIN_US");
|
||||
return text != nullptr && text[0] != '\0';
|
||||
// MOBILEGL_IPC_SERVER_AFFINITY = `auto` | `off` | an explicit mask (0x... or decimal).
|
||||
// The RAW STRING is what Config keeps, because the resolved mask is what gets logged -
|
||||
// "an affinity that silently did nothing looks exactly like one that worked"
|
||||
// (CONTRACT-P5 5).
|
||||
Uint64 RequestedAffinityMask(const char* raw, Bool* outRecognised) {
|
||||
*outRecognised = true;
|
||||
if (raw == nullptr || raw[0] == '\0') return DetectBigCoreMask();
|
||||
if (std::strcmp(raw, "auto") == 0) return DetectBigCoreMask();
|
||||
if (std::strcmp(raw, "off") == 0) return 0;
|
||||
char* end = nullptr;
|
||||
const unsigned long long parsed = std::strtoull(raw, &end, 0);
|
||||
if (end == raw || (end != nullptr && *end != '\0')) {
|
||||
*outRecognised = false;
|
||||
return 0;
|
||||
}
|
||||
return static_cast<Uint64>(parsed);
|
||||
}
|
||||
|
||||
void NameThisThread(const char* name) {
|
||||
@@ -163,60 +162,8 @@ namespace MobileGL::MG_Remote::Server {
|
||||
#endif
|
||||
}
|
||||
|
||||
// P9 W3, FAULT INJECTION F2 (HANDOFF-P9 §4): THE APPLY THREAD AS A LOG FIREHOSE.
|
||||
//
|
||||
// MOBILEGL_TEST_APPLY_LOG_FLOOD=<n> makes the apply thread log, after EVERY record it applies,
|
||||
// `n` WARN lines of about 600 bytes and one ERROR line, each numbered in its own series
|
||||
// ("flood warn #k", "flood error #k"). It is the one producer F2 needs and nothing in the
|
||||
// tree otherwise is: production logging is not allowed to repeat on a per-record path
|
||||
// (Log.h), so no real verb can be made to fill a TCP control connection with lines at will -
|
||||
// and "the apply thread is not held by logging while its client does not read" can only be
|
||||
// asserted about a thread that is logging a lot. The numbering is what lets the test prove
|
||||
// every ERROR line arrived (in order) while WARN lines were dropped.
|
||||
//
|
||||
// Meant for a server in its OWN process (a `--serve` session child). A TEST knob: read once
|
||||
// per Start(), 0 unless set, capped, and it says so in the log when it is set.
|
||||
Uint32 ApplyLogFloodLinesForTest() {
|
||||
const char* text = std::getenv("MOBILEGL_TEST_APPLY_LOG_FLOOD");
|
||||
if (text == nullptr || *text == '\0') return 0;
|
||||
const long lines = std::strtol(text, nullptr, 10);
|
||||
if (lines <= 0) return 0;
|
||||
const Uint32 capped = static_cast<Uint32>(std::min<long>(lines, 4096));
|
||||
MGLOG_W("MG_Remote server: MOBILEGL_TEST_APPLY_LOG_FLOOD=%u - every applied record logs that many "
|
||||
"WARN lines and one ERROR line. A test-only lever (fault injection F2); never set it in a "
|
||||
"measured run",
|
||||
static_cast<unsigned>(capped));
|
||||
return capped;
|
||||
}
|
||||
|
||||
void FloodLogForTest(Uint32 warnLines) {
|
||||
// One apply thread per process (ServerLoopInstance's), so plain counters are enough.
|
||||
static unsigned long long s_warn = 0;
|
||||
static unsigned long long s_error = 0;
|
||||
static const std::string kFiller(560, 'w');
|
||||
for (Uint32 i = 0; i < warnLines; ++i) {
|
||||
MGLOG_W("MG_Remote server: MOBILEGL_TEST_APPLY_LOG_FLOOD flood warn #%llu %s", ++s_warn,
|
||||
kFiller.c_str());
|
||||
}
|
||||
MGLOG_E("MG_Remote server: MOBILEGL_TEST_APPLY_LOG_FLOOD flood error #%llu", ++s_error);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// P11 B1: the one place the reserved core is computed for anybody outside the apply thread - the
|
||||
// supervisor announces it at start-up and the server app's broker relays it to the helper. The
|
||||
// supervisor has not loaded MG_Config (its session children do), so the knob is read from the
|
||||
// environment the children inherit.
|
||||
Uint64 ReservedApplyCoreForThisProcess(const char** outRule) {
|
||||
Uint64 big = 0, prime = 0;
|
||||
DetectCoreTopology(&big, &prime);
|
||||
ReservedCoreReason reason = ReservedCoreReason::NoAsymmetry;
|
||||
const Uint64 core = ReservedApplyCoreForConfig(std::getenv("MOBILEGL_IPC_SERVER_AFFINITY"), big, prime,
|
||||
OnlineCpuMask(), &reason);
|
||||
if (outRule != nullptr) *outRule = ReservedCoreReasonText(reason);
|
||||
return core;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
// The private backend object
|
||||
// ---------------------------------------------------------------------------------
|
||||
@@ -289,7 +236,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
m_serverOwnedSurfaces.clear();
|
||||
m_windowLostRequested.store(false, std::memory_order_release);
|
||||
m_serverWindowsLost.store(0, std::memory_order_release);
|
||||
m_testLogFloodLines = ApplyLogFloodLinesForTest();
|
||||
{
|
||||
const std::lock_guard<std::mutex> lock(m_exitMutex);
|
||||
m_exited = false;
|
||||
@@ -421,21 +367,9 @@ namespace MobileGL::MG_Remote::Server {
|
||||
// forwarder (the in-process display server's) sends to the client. Inert otherwise.
|
||||
MG_Util::Debug::SetThreadForwardsLogToPeer(true);
|
||||
|
||||
// MOBILEGL_IPC_SERVER_AFFINITY = `auto` | `off` | an explicit mask (0x... or decimal).
|
||||
// The RAW STRING is what Config keeps, because the resolved mask is what gets logged -
|
||||
// "an affinity that silently did nothing looks exactly like one that worked"
|
||||
// (CONTRACT-P5 5). P11 B1: `auto` now depends on who the client is (ApplyThreadPolicy.h),
|
||||
// and so does the spin before each park.
|
||||
ServerSession& session = *m_session;
|
||||
Bool recognised = true;
|
||||
const char* raw = AffinityStringFromConfig();
|
||||
const Bool automatic = raw == nullptr || raw[0] == '\0' || std::strcmp(raw, "auto") == 0;
|
||||
Uint64 bigCores = 0, primeCores = 0;
|
||||
if (automatic) DetectCoreTopology(&bigCores, &primeCores);
|
||||
const ApplyThreadPolicy policy =
|
||||
SelectApplyThreadPolicy(raw, SpinSetExplicitly(), SpinUsFromConfig(), session.Peer(),
|
||||
session.PeerSharedSegments(), bigCores, primeCores, OnlineCpuMask());
|
||||
const Bool recognised = policy.recognised;
|
||||
const Uint64 requested = policy.requestedMask;
|
||||
const Uint64 requested = RequestedAffinityMask(raw, &recognised);
|
||||
m_affinityMask = ApplyAffinity(requested);
|
||||
if (!recognised) {
|
||||
MGLOG_E("MG_Remote server: MOBILEGL_IPC_SERVER_AFFINITY='%s' is not `auto`, `off` or "
|
||||
@@ -448,11 +382,11 @@ namespace MobileGL::MG_Remote::Server {
|
||||
// an operator typed and the mask is what the kernel took.
|
||||
MGLOG_I("MG_Remote server: mgl-srv-apply started. MOBILEGL_IPC_SERVER_AFFINITY='%s' "
|
||||
"requested mask 0x%llx, RESOLVED mask 0x%llx (0 = no affinity applied), spin "
|
||||
"%u us; peer %s on %s, policy %s",
|
||||
"%u us",
|
||||
raw == nullptr ? "" : raw, static_cast<unsigned long long>(requested),
|
||||
static_cast<unsigned long long>(m_affinityMask), policy.spinUs, ApplyPeerName(session.Peer()),
|
||||
session.PeerSharedSegments() ? "shared segments" : "stream", policy.rule);
|
||||
static_cast<unsigned long long>(m_affinityMask), SpinUsFromConfig());
|
||||
|
||||
ServerSession& session = *m_session;
|
||||
// The decoder is built HERE, on this thread, because PipeWireDecoder is "not thread
|
||||
// safe: one decoder on the apply thread, by construction" and its constructor installs
|
||||
// the process-wide apply hook.
|
||||
@@ -461,7 +395,7 @@ namespace MobileGL::MG_Remote::Server {
|
||||
const auto signals = session.DataLink()->Signals();
|
||||
Transport::Doorbell& bell = session.DataLink()->ConsumerBell();
|
||||
Transport::RingConsumer& ring = session.CommandRing();
|
||||
const Uint32 spinUs = policy.spinUs;
|
||||
const Uint32 spinUs = SpinUsFromConfig();
|
||||
|
||||
// THE PARK CONDITION IS THREE THINGS, NOT ONE, AND THAT IS THE WHOLE REASON THIS LOOP
|
||||
// DOES NOT CALL SessionConsumer::WaitForWork.
|
||||
@@ -503,24 +437,11 @@ namespace MobileGL::MG_Remote::Server {
|
||||
return signals.CmdHead->load(std::memory_order_acquire) != ring.LocalTail();
|
||||
};
|
||||
|
||||
// P10 (CONTRACT-P10.md §1): the client answers a fence poll from what this thread reports,
|
||||
// so a fence the GPU finishes must be reported whether or not another record ever arrives.
|
||||
// After every drain batch the pending fences are asked (a status query, no submit); a
|
||||
// thread about to go idle submits first and, while any fence is still pending, parks for
|
||||
// at most kFenceIdlePollMs rather than for ever. Never on a full SEG_EVENT: posting there
|
||||
// would park this thread inside the post, and the ring test below already says "not now".
|
||||
ServerVerbSink& verbs = session.Applier().Verbs();
|
||||
constexpr Uint32 kFenceIdlePollMs = 1;
|
||||
const auto eventRingHasRoom = [signals] {
|
||||
return signals.EventRingFull->load(std::memory_order_acquire) == 0;
|
||||
};
|
||||
|
||||
for (;;) {
|
||||
PumpControlRequest();
|
||||
if (stopOrForfeit()) break;
|
||||
if (eventRingHasRoom()) DrainRing();
|
||||
if (signals.EventRingFull->load(std::memory_order_acquire) == 0) DrainRing();
|
||||
if (stopOrForfeit()) break;
|
||||
if (eventRingHasRoom() && !SessionLatched()) verbs.ReportSignaledFences(/*flush=*/false);
|
||||
// PH-1 (3): a latched session applies nothing more, so this thread leaves the loop
|
||||
// (and does not spin on a ring whose head is still ahead of a tail DrainRing will no
|
||||
// longer move). The exit path below tears the backend down as for a Stop; the
|
||||
@@ -533,12 +454,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
break;
|
||||
}
|
||||
if (ready()) continue;
|
||||
// P10: going idle with a client fence still pending - submit what the driver holds and
|
||||
// ask again, once, before the park.
|
||||
if (verbs.HasUnreportedFences() && eventRingHasRoom()) {
|
||||
verbs.ReportSignaledFences(/*flush=*/true);
|
||||
if (ready()) continue;
|
||||
}
|
||||
|
||||
const Uint64 waits = m_parks.fetch_add(1, std::memory_order_acq_rel) + 1;
|
||||
// THE WAIT LEDGER'S SERVER HALF (P5d round 3, package T item 4). The client may not
|
||||
@@ -565,21 +480,18 @@ namespace MobileGL::MG_Remote::Server {
|
||||
}
|
||||
// Flush-on-idle publishes the last reply record even below the batch threshold.
|
||||
session.FlushDataProgress();
|
||||
const Bool fencePending = verbs.HasUnreportedFences();
|
||||
const bool woke = bell.Wait(*signals.ConsumerParked, ready, spinUs,
|
||||
fencePending ? kFenceIdlePollMs : Transport::kWaitForever,
|
||||
&m_parkBlocks);
|
||||
Transport::kWaitForever, &m_parkBlocks);
|
||||
if (!woke) {
|
||||
// Wait returns false only on a dead bell or an expired deadline. A dead bell IS the
|
||||
// shutdown signal (table 3's teardown step 2); treating it as anything else would
|
||||
// spin at full clock for ever, since parking on a dead bell no longer blocks.
|
||||
// Wait returns false only on a dead bell or an expired deadline, and this park
|
||||
// has no deadline. A dead bell IS the shutdown signal (table 3's teardown step
|
||||
// 2); treating it as anything else would spin at full clock for ever, since
|
||||
// parking on a dead bell no longer blocks.
|
||||
if (bell.Dead()) {
|
||||
MGLOG_D("MG_Remote server: the consumer doorbell is dead; mgl-srv-apply is "
|
||||
"shutting down");
|
||||
break;
|
||||
}
|
||||
// P10: the deadline is the fence re-check, and the only park that has one.
|
||||
if (fencePending) continue;
|
||||
MGLOG_E("MG_Remote server: Doorbell::Wait(kWaitForever) returned false on a live "
|
||||
"bell - that is impossible by Doorbell::Wait's park loop (the only "
|
||||
"false returns are the Dead() arm and an expired deadline) and means "
|
||||
@@ -871,8 +783,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
std::chrono::steady_clock::now() - applyStarted)
|
||||
.count());
|
||||
++sFrameRecords;
|
||||
// P9 W3, F2: outside the apply timing above; 0 in every run that is not F2.
|
||||
if (m_testLogFloodLines != 0) FloodLogForTest(m_testLogFloodLines);
|
||||
if (record.kind == static_cast<std::uint16_t>(MG_Pipe::MGPWireOp::Present)) {
|
||||
const auto now = std::chrono::steady_clock::now();
|
||||
const auto wallNs = static_cast<std::uint64_t>(
|
||||
@@ -886,7 +796,7 @@ namespace MobileGL::MG_Remote::Server {
|
||||
// recv - blocking included - so a frame that is 90% read_ms is a frame the
|
||||
// reader spent WAITING for bytes, and one that is mostly recv calls with
|
||||
// little read_ms is a reader that is copying.
|
||||
const auto read = Transport::LinkMetricsTakeReadStats();
|
||||
const auto read = Transport::StreamLink::TakeReadStats();
|
||||
MGLOG_I("P65ServerFrame frame=%llu records=%llu apply_ms=%.1f wall_ms=%.1f "
|
||||
"outside_ms=%.1f | read: %llu B in %llu recv(%llu reads) "
|
||||
"recv_ms=%.1f total_ms=%.1f (%.0f%% blocked, %.1f MB/s)",
|
||||
|
||||
@@ -569,9 +569,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
std::atomic<Uint64> m_parkBlocks{0};
|
||||
std::atomic<void (*)()> m_beforeRetireHook{nullptr};
|
||||
std::atomic<void (*)()> m_betweenRecordsHook{nullptr};
|
||||
// P9 W3, fault injection F2: MOBILEGL_TEST_APPLY_LOG_FLOOD, read by Start(). Zero - the only
|
||||
// value a production run has - makes the per-record test a load of this and nothing else.
|
||||
Uint32 m_testLogFloodLines = 0;
|
||||
|
||||
// C7 / ID-54: the (dpy, draw, read, ctx) currently bound on the apply thread. Written and
|
||||
// read ONLY on the apply thread inside ApplyMakeCurrent, so it needs no lock; the two
|
||||
@@ -597,12 +594,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
EGLSurface curRead, EGLContext curCtx, EGLDisplay dpy,
|
||||
EGLSurface draw, EGLSurface read, EGLContext ctx);
|
||||
|
||||
// P11 B1 (CONTRACT-P11 B1): the cpu core this process's `auto` policy reserves for a dialled-in
|
||||
// shared-segment client's apply thread (ApplyThreadPolicy.h ReservedApplyCoreForConfig over this
|
||||
// machine's topology and MOBILEGL_IPC_SERVER_AFFINITY), 0 when none; `outRule` receives the reason.
|
||||
// The supervisor announces it at start-up; the server app's broker relays it to the helper.
|
||||
Uint64 ReservedApplyCoreForThisProcess(const char** outRule);
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
// THE EGL OWNERSHIP MOVE - the part that can sink the phase, expressed as twelve calls
|
||||
// ---------------------------------------------------------------------------------
|
||||
|
||||
@@ -2,14 +2,12 @@
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
#include "../Transport/Doorbell.h"
|
||||
#include "../Transport/FdPassing.h"
|
||||
#include "../Transport/LogForward.h"
|
||||
#include "../Transport/SocketTransport.h"
|
||||
#include "../Transport/WireLog.h"
|
||||
#include "../Protocol/SurfaceOpCodec.h"
|
||||
#include "../Handshake.h"
|
||||
#include "../FatalFunnel.h"
|
||||
#include "InProcessServer.h"
|
||||
#include "PairAcceptor.h"
|
||||
#include "PreAuthGate.h"
|
||||
#include "ServerDisplay.h"
|
||||
#include "ServerLoop.h"
|
||||
@@ -57,42 +55,13 @@ void Refuse(SocketTransport& transport, Protocol::RefuseCode code, const char* d
|
||||
WireLogError("MG_Remote server: Refuse{%s} %s", Protocol::EnumNameRefuseCode(code), detail);
|
||||
}
|
||||
|
||||
// P9 W3. The log forward's unblock hook (LogForward.h, Close): the channel's sender is still inside a
|
||||
// write to a client that has not read for the whole close budget, at the end of the session. Cutting
|
||||
// the control socket is what returns that write (EPIPE) so the thread can be joined - the session is
|
||||
// over by then (every caller is on RunSession's way out), and the socket is closed right after anyway.
|
||||
// Not through SocketTransport::Shutdown: that takes the send mutex the blocked write holds.
|
||||
void UnblockControlSend(void* user) {
|
||||
const int fd = static_cast<SocketTransport*>(user)->StreamFd();
|
||||
if (fd >= 0) (void)::shutdown(fd, SHUT_RDWR);
|
||||
}
|
||||
|
||||
// The forward's counters, once, into the server's OWN log - the forwarder is already gone by the time
|
||||
// they are final, so this line is local; what the client saw of the same story is the in-stream
|
||||
// LogForward{Dropped} / {Coalesced} lines at each gap. WARN when anything was lost, delayed past a
|
||||
// deadline or cut, so it survives a production build; otherwise a D line.
|
||||
void LogForwardSummary(const Transport::LogForwardCounters& counters) {
|
||||
const bool eventful = counters.lossyDropped != 0 || counters.errorsCoalesced != 0 || counters.abandoned != 0 ||
|
||||
counters.fatalFlushTimeouts != 0 || counters.transportFailed;
|
||||
if (eventful) {
|
||||
MGLOG_W("MG_Remote server: log forwarding ended - forwarded=%llu dropped(<=WARN)=%llu (%llu bytes) "
|
||||
"coalesced(ERROR)=%llu paced(ERROR)=%llu notices=%llu abandoned=%llu fatal-flush-timeouts=%llu "
|
||||
"transport-failed=%d max-offer-us=%llu",
|
||||
static_cast<unsigned long long>(counters.forwarded),
|
||||
static_cast<unsigned long long>(counters.lossyDropped),
|
||||
static_cast<unsigned long long>(counters.lossyDroppedBytes),
|
||||
static_cast<unsigned long long>(counters.errorsCoalesced),
|
||||
static_cast<unsigned long long>(counters.errorsPaced),
|
||||
static_cast<unsigned long long>(counters.notices),
|
||||
static_cast<unsigned long long>(counters.abandoned),
|
||||
static_cast<unsigned long long>(counters.fatalFlushTimeouts), counters.transportFailed ? 1 : 0,
|
||||
static_cast<unsigned long long>(counters.maxOfferNs / 1000));
|
||||
} else {
|
||||
MGLOG_D("MG_Remote server: log forwarding ended - forwarded=%llu paced(ERROR)=%llu max-offer-us=%llu",
|
||||
static_cast<unsigned long long>(counters.forwarded),
|
||||
static_cast<unsigned long long>(counters.errorsPaced),
|
||||
static_cast<unsigned long long>(counters.maxOfferNs / 1000));
|
||||
}
|
||||
void ForwardLog(void* user, const char* text) {
|
||||
auto& transport = *static_cast<ITransport*>(user);
|
||||
flatbuffers::FlatBufferBuilder builder(512);
|
||||
auto log = Protocol::CreateLogLine(builder, Protocol::LogLevel::Info, builder.CreateString(text));
|
||||
auto envelope = Protocol::CreateCtrlEnvelope(builder, Protocol::CtrlMsg::LogLine, log.Union());
|
||||
Protocol::FinishCtrlEnvelopeBuffer(builder, envelope);
|
||||
(void)transport.SendFrame({builder.GetBufferPointer(), builder.GetSize()});
|
||||
}
|
||||
|
||||
// p7/spawnhang. THE PROGRESS REPORT: Wire::SurfaceProgress, sent by the thread that posted the op
|
||||
@@ -122,19 +91,6 @@ void RefuseBusy(SocketTransport& transport, const char* detail) {
|
||||
Refuse(transport, Protocol::RefuseCode::Busy, detail);
|
||||
}
|
||||
|
||||
// P11 B1 (CONTRACT-P11 B1): HOW LONG A PAIRED UNIX SESSION WAITS FOR ITS HELLO - FOR EVER; ITS END
|
||||
// IS THE PEER'S EOF. The pair's identity is settled before this wait (PairAcceptor paired the two
|
||||
// connections by the nonce each presented), and a unix endpoint is reachable only by this user / this
|
||||
// app (SELinux on Android, 0600 on a path). Since B1 the server app's broker presents the PairBinds at
|
||||
// hand-off, the moment it connects, while the program it is for may still be loading - a Termux program
|
||||
// can spend many seconds on its assets before its first EGL call sends the Hello. The old 10 s (the
|
||||
// same budget as TCP's pre-auth) refused such a program by name; there is no bound here that is long
|
||||
// enough for every program, so there is none: a program that exits (or closes the descriptors) ends
|
||||
// the wait with EOF ("control peer closed before sending a first frame"), and while it lives it holds
|
||||
// the one session slot, as a rendering session would. TCP keeps its pre-auth deadline (PreAuthKnobs),
|
||||
// and the in-process display server keeps 10 s (its stop waits for the session thread).
|
||||
constexpr std::uint32_t kPairedUnixHelloWaitMs = Transport::kWaitForever;
|
||||
|
||||
// The single-session TCP shape's wait for its data connection's DataBind (ListenerSource).
|
||||
constexpr std::uint32_t kFirstFrameWaitMs = 2000;
|
||||
constexpr std::uint64_t kFirstFrameMaxBytes = Server::kPreAuthFirstFrameMaxBytes;
|
||||
@@ -236,22 +192,13 @@ Server::ServerSession::DataConnectionSource ListenerSource(int listener, int con
|
||||
};
|
||||
}
|
||||
|
||||
// `forward` is the session's log forward when there is one (P9 W3). The ack then goes out THROUGH it,
|
||||
// queued behind every line forwarded before the flush, because a forwarded line is no longer on the
|
||||
// wire when its MGLOG returns - sending the ack directly could overtake lines still queued, and
|
||||
// MGPipeSyncPeerLog's promise is that they are in the client's file when the ack arrives.
|
||||
struct FlushAck { ITransport* transport; Transport::LogForwardChannel* forward; std::uint64_t seq; };
|
||||
struct FlushAck { ITransport* transport; std::uint64_t seq; };
|
||||
void SendLogAck(void* pointer) {
|
||||
auto& ack = *static_cast<FlushAck*>(pointer);
|
||||
flatbuffers::FlatBufferBuilder builder(64);
|
||||
auto flush = Protocol::CreateLogFlush(builder, ack.seq, true);
|
||||
auto envelope = Protocol::CreateCtrlEnvelope(builder, Protocol::CtrlMsg::LogFlush, flush.Union());
|
||||
Protocol::FinishCtrlEnvelopeBuffer(builder, envelope);
|
||||
if (ack.forward != nullptr) {
|
||||
ack.forward->OfferControlFrame(
|
||||
std::vector<std::uint8_t>(builder.GetBufferPointer(), builder.GetBufferPointer() + builder.GetSize()));
|
||||
return;
|
||||
}
|
||||
(void)ack.transport->SendFrame({builder.GetBufferPointer(), builder.GetSize()});
|
||||
}
|
||||
|
||||
@@ -354,7 +301,7 @@ void DelaySessionHandshakeForTest() {
|
||||
|
||||
// Called only after fork (or, in the single-session shape, instead of it): the supervisor never
|
||||
// creates a backend or EGL context. `dataSource` is set on TCP (PH-7 (4)) and empty on a unix
|
||||
// endpoint, whose second connection is the SCM_RIGHTS socket PairAcceptor already paired.
|
||||
// endpoint, whose second connection is the SCM_RIGHTS socket AcceptPair already paired.
|
||||
// `sourceFd` is the descriptor that source reads from - the child's end of the hand-off
|
||||
// socketpair under --serve, the listener itself in the single-session shape - and -1 when there
|
||||
// is none; it is let go of the moment Accept returns, and on every exit before that
|
||||
@@ -482,25 +429,11 @@ int RunSession(std::unique_ptr<SocketTransport> control, std::vector<std::uint8_
|
||||
// code, exactly as before.
|
||||
bool backendBuilt = false;
|
||||
bool acceptTried = false;
|
||||
// P9 W3: the TCP session's log forward (LogForward.h), made where forwarding is switched on below.
|
||||
// Declared up here because every way out has to take it down the same way: the logger stops
|
||||
// calling it FIRST (so no line is offered to a channel being destroyed), then the channel drains
|
||||
// within its close budget and its sender is joined, then its counters are said locally. Every
|
||||
// shape, forked or not: a forked child's early return destroys the channel with this frame, and a
|
||||
// forwarder left pointing at it would be a dangling pointer for however many lines remain.
|
||||
std::unique_ptr<Transport::LogForwardChannel> logForward;
|
||||
const auto stopLogForwarding = [&] {
|
||||
MobileGL::MG_Util::Debug::SetLogForwarder(nullptr, nullptr);
|
||||
if (!logForward) return;
|
||||
const auto counters = logForward->Close();
|
||||
logForward.reset();
|
||||
LogForwardSummary(counters);
|
||||
};
|
||||
const auto endSession = [&](int code) -> int {
|
||||
stopLogForwarding();
|
||||
if (!inProcess) return code;
|
||||
// Points at `control`, which dies with this frame (the log forwarder did too, above).
|
||||
// Both point at `control`, which dies with this frame.
|
||||
loop.SetControlProgressSink(nullptr, nullptr);
|
||||
MobileGL::MG_Util::Debug::SetLogForwarder(nullptr, nullptr);
|
||||
if (backendBuilt) {
|
||||
// Stop() joins a running apply thread (it destroys the backend on it), or - never
|
||||
// started - drops the backend here; either way the display lease goes with it.
|
||||
@@ -642,18 +575,11 @@ int RunSession(std::unique_ptr<SocketTransport> control, std::vector<std::uint8_
|
||||
|
||||
const char* forwarding = std::getenv("MOBILEGL_IPC_LOG_FORWARD");
|
||||
if (tcp && (!forwarding || std::strcmp(forwarding, "0") != 0)) {
|
||||
// P9 W3: the forward is a queue with a sender thread of its own, graded by severity
|
||||
// (LogForward.h): a client that stops reading control no longer holds any logging thread -
|
||||
// the apply thread above all - inside a socket write.
|
||||
logForward = std::make_unique<Transport::LogForwardChannel>(*control, &UnblockControlSend, control.get());
|
||||
// P12 review fix: in-process, only THIS session's threads (this one and its apply thread)
|
||||
// forward, and outside the log mutex - the UI thread, the listener and the next session's
|
||||
// refusals share this process and must neither reach this client nor wait on it.
|
||||
if (inProcess)
|
||||
MobileGL::MG_Util::Debug::SetSessionLogForwarder(&Transport::LogForwardChannel::ForwardThunk,
|
||||
logForward.get());
|
||||
else
|
||||
MobileGL::MG_Util::Debug::SetLogForwarder(&Transport::LogForwardChannel::ForwardThunk, logForward.get());
|
||||
if (inProcess) MobileGL::MG_Util::Debug::SetSessionLogForwarder(&ForwardLog, control.get());
|
||||
else MobileGL::MG_Util::Debug::SetLogForwarder(&ForwardLog, control.get());
|
||||
}
|
||||
// p7/spawnhang: this thread posts every surface op the client sends (ServerApplyWireSurfaceOp,
|
||||
// below) and is the one that says "still running" while the apply thread runs it. Cleared
|
||||
@@ -774,7 +700,7 @@ int RunSession(std::unique_ptr<SocketTransport> control, std::vector<std::uint8_
|
||||
static_cast<unsigned long long>(verbs.ExpectedApplierResetSerial()),
|
||||
static_cast<unsigned long long>(verbs.ObjectDeaths()));
|
||||
}
|
||||
FlushAck ack{control.get(), logForward.get(), flush->seq()};
|
||||
FlushAck ack{control.get(), flush->seq()};
|
||||
MobileGL::MG_Util::Debug::WithLogBarrier(&SendLogAck, &ack);
|
||||
continue;
|
||||
}
|
||||
@@ -823,8 +749,7 @@ int RunSession(std::unique_ptr<SocketTransport> control, std::vector<std::uint8_
|
||||
static_cast<unsigned long long>(SessionLatchCount()), kSessionLatchedExitCode);
|
||||
}
|
||||
session.Close();
|
||||
// P9 W3: the forwarder is cleared, the forward drains (bounded) and its counters are logged.
|
||||
stopLogForwarding();
|
||||
MobileGL::MG_Util::Debug::SetLogForwarder(nullptr, nullptr);
|
||||
// P12 (D5): the backend loop.Stop() destroyed is not this session's to point at any more.
|
||||
if (inProcess) session.SetBackend(nullptr);
|
||||
// The caller's exit (a forked child's ExitSessionProcess) closes control after cleanup/flush -
|
||||
@@ -1321,111 +1246,6 @@ private:
|
||||
Clock::time_point m_acceptResumeAt{};
|
||||
};
|
||||
|
||||
// THE UNIX SHAPE OF THE IN-PROCESS DISPLAY SERVER (P12 D5 extended to unix endpoints). The
|
||||
// endpoint is an @abstract name or a filesystem path. A client's control AND aux connections
|
||||
// pair by the nonce each presents first (PairAcceptor, P11 PAIR - never by arrival order) and the
|
||||
// shm segments' descriptors cross by SCM_RIGHTS, so there is no DataBind to route and no pre-auth
|
||||
// gate - both are TCP exposure machinery, and a unix peer is local by construction (the forked
|
||||
// unix supervisor runs without either). Sessions take the TCP in-process shape's thread hand-off:
|
||||
// one at a time, Busy for a second client, the latch reset between sessions, stop by
|
||||
// g_inProcessStop.
|
||||
class UnixInProcessSupervisor {
|
||||
public:
|
||||
UnixInProcessSupervisor(int listener, unsigned long& sessionsFaulted)
|
||||
: m_listener(listener), m_pairs(listener), m_sessionsFaulted(sessionsFaulted) {}
|
||||
|
||||
~UnixInProcessSupervisor() {
|
||||
// Run() only returns with the session thread joined; a listener failure (73) is the
|
||||
// one way out with it live, and it is never left running behind the supervisor.
|
||||
if (m_sessionThread.joinable()) m_sessionThread.join();
|
||||
}
|
||||
|
||||
int Run() {
|
||||
for (;;) {
|
||||
if (g_inProcessStop.load(std::memory_order_acquire)) return StopServing();
|
||||
Reap();
|
||||
std::unique_ptr<SocketTransport> control;
|
||||
const auto accepted = m_pairs.Accept(250, control);
|
||||
if (accepted == MOBILEGL_ERR_TIMEOUT) continue;
|
||||
if (accepted != MOBILEGL_OK) {
|
||||
WireLogError("MG_Remote server: the in-process unix listener failed (rc=%d)",
|
||||
static_cast<int>(accepted));
|
||||
return 73;
|
||||
}
|
||||
// exit_group's close window, as the forked loop's: a client reconnecting the moment
|
||||
// its session ended must not be told Busy by a session that is exiting.
|
||||
const auto reapDeadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(50);
|
||||
while (m_active > 0 && std::chrono::steady_clock::now() < reapDeadline) {
|
||||
if (Reap()) break;
|
||||
::usleep(1000);
|
||||
}
|
||||
if (m_active > 0) {
|
||||
RefuseBusy(*control, "one session is already active");
|
||||
continue;
|
||||
}
|
||||
StartSessionThread(std::move(control));
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
// The same reap as the TCP shape's ReapSessionThread: join, count faults, reset the latch
|
||||
// for the next session in this process.
|
||||
bool Reap() {
|
||||
if (m_active <= 0 || !m_sessionDone.load(std::memory_order_acquire)) return false;
|
||||
if (m_sessionThread.joinable()) m_sessionThread.join();
|
||||
const int code = m_sessionExit.load(std::memory_order_acquire);
|
||||
m_active = -1;
|
||||
if (code != 0) ++m_sessionsFaulted;
|
||||
ResetSessionLatch();
|
||||
WireLogError("MG_Remote server: in-process unix session #%lu pid=%d reaped exit=%d%s sessionsFaulted=%lu",
|
||||
m_sessionOrdinal, static_cast<int>(::getpid()), code,
|
||||
code == kSessionLatchedExitCode ? " (latched fault)" : "", m_sessionsFaulted);
|
||||
return true;
|
||||
}
|
||||
|
||||
void StartSessionThread(std::unique_ptr<SocketTransport> connection) {
|
||||
if (m_sessionThread.joinable()) m_sessionThread.join(); // reaped already; never live here
|
||||
m_sessionDone.store(false, std::memory_order_release);
|
||||
m_sessionExit.store(0, std::memory_order_release);
|
||||
++m_sessionOrdinal;
|
||||
try {
|
||||
// No hand-off pair and no pre-read Hello: the session reads its own first frame and
|
||||
// binds its shm segments from the fds the pair's second connection carries.
|
||||
m_sessionThread = std::thread([this, conn = std::move(connection)]() mutable {
|
||||
const int code = RunSession(std::move(conn), {}, {}, -1, DataSource::None, 10000,
|
||||
/*inProcess=*/true);
|
||||
m_sessionExit.store(code, std::memory_order_release);
|
||||
m_sessionDone.store(true, std::memory_order_release);
|
||||
});
|
||||
} catch (...) {
|
||||
WireLogError("MG_Remote server: could not start the in-process unix session thread; the "
|
||||
"connection is closed (it cannot be refused: it moved into the failed thread)");
|
||||
return;
|
||||
}
|
||||
m_active = ::getpid();
|
||||
WireLogError("MG_Remote server: in-process unix session #%lu started on a thread (pid=%d)",
|
||||
m_sessionOrdinal, static_cast<int>(::getpid()));
|
||||
}
|
||||
|
||||
int StopServing() {
|
||||
while (m_active > 0) {
|
||||
if (!Reap()) ::usleep(10000);
|
||||
}
|
||||
WireLogError("MG_Remote server: pid=%d in-process display server stopped", static_cast<int>(::getpid()));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int m_listener;
|
||||
// The connections that have not been paired yet live here between Accept calls.
|
||||
Server::PairAcceptor m_pairs;
|
||||
unsigned long& m_sessionsFaulted;
|
||||
std::thread m_sessionThread;
|
||||
std::atomic<bool> m_sessionDone{false};
|
||||
std::atomic<int> m_sessionExit{0};
|
||||
unsigned long m_sessionOrdinal = 0;
|
||||
pid_t m_active = -1;
|
||||
};
|
||||
|
||||
// The server's environment preconditions, shared by the exec'd supervisor and the in-process
|
||||
// display server (P12 D5: "same env preconditions as mobilegl_server_main"). 0 when they hold.
|
||||
int CheckServerEnvironment() {
|
||||
@@ -1475,19 +1295,6 @@ extern "C" __attribute__((visibility("default"))) int mobilegl_server_main(int a
|
||||
int listener = -1;
|
||||
if (SocketTransport::Listen(endpoint, &listener) != MOBILEGL_OK) return 72;
|
||||
WireLogError("MG_Remote server: pid=%d listening on %s", static_cast<int>(::getpid()), endpoint.c_str());
|
||||
{
|
||||
// P11 B1 (CONTRACT-P11 B1): the one announcement of the core a dialled-in shared-segment client's
|
||||
// apply thread will take, on stdout, which the server app reads line by line
|
||||
// (MobileGLServerService) and its broker hands to the helper - so the helper keeps the client
|
||||
// off the core THIS server picks rather than a Java re-derivation of the rule.
|
||||
const char* rule = "";
|
||||
const auto reserved = static_cast<unsigned long long>(Server::ReservedApplyCoreForThisProcess(&rule));
|
||||
std::fprintf(stdout, "MG_Remote server: apply core reserved for dialled-in shared-segment clients: 0x%llx (%s)\n",
|
||||
reserved, rule);
|
||||
std::fflush(stdout);
|
||||
WireLogError("MG_Remote server: apply core reserved for dialled-in shared-segment clients: 0x%llx (%s)",
|
||||
reserved, rule);
|
||||
}
|
||||
unsigned long sessionsFaulted = 0;
|
||||
const bool tcpEndpoint = endpoint.compare(0, 6, "tcp://") == 0;
|
||||
const auto knobs = Server::PreAuthKnobs::FromEnvironment();
|
||||
@@ -1502,10 +1309,6 @@ extern "C" __attribute__((visibility("default"))) int mobilegl_server_main(int a
|
||||
// From here: the unix endpoint (--serve or not), and the single-session TCP shape.
|
||||
pid_t active = -1;
|
||||
const auto reap = [&]() { return ReapActiveSession(active, sessionsFaulted); };
|
||||
// P11 PAIR: a unix client's two connections, paired by the nonce each presents first. The
|
||||
// connections not yet paired stay in it between calls.
|
||||
std::unique_ptr<Server::PairAcceptor> pairs;
|
||||
if (!tcpEndpoint) pairs = std::make_unique<Server::PairAcceptor>(listener);
|
||||
for (;;) {
|
||||
reap();
|
||||
std::unique_ptr<SocketTransport> control;
|
||||
@@ -1515,14 +1318,11 @@ extern "C" __attribute__((visibility("default"))) int mobilegl_server_main(int a
|
||||
accepted = SocketTransport::AcceptOne(listener, 30000, &fd);
|
||||
if (accepted == MOBILEGL_OK) control = std::make_unique<SocketTransport>(fd, -1, TransportRole::Server);
|
||||
} else {
|
||||
accepted = pairs->Accept(serve ? 250 : 30000, control);
|
||||
accepted = SocketTransport::AcceptPair(listener, serve ? 250 : 30000, control);
|
||||
}
|
||||
if (accepted == MOBILEGL_ERR_TIMEOUT && serve) continue;
|
||||
if (accepted != MOBILEGL_OK) { pairs.reset(); LogSupervisorSummary(sessionsFaulted); ::close(listener); return 73; }
|
||||
if (accepted != MOBILEGL_OK) { LogSupervisorSummary(sessionsFaulted); ::close(listener); return 73; }
|
||||
if (!serve) {
|
||||
// The process IS this one session: whatever else is waiting to be paired is let go of by
|
||||
// name now, not held for the session's lifetime.
|
||||
pairs.reset();
|
||||
if (tcpEndpoint) {
|
||||
// The listener stays open until this session's data connection has arrived on
|
||||
// it; RunSession closes it the moment Accept returns. The process IS the session,
|
||||
@@ -1534,7 +1334,7 @@ extern "C" __attribute__((visibility("default"))) int mobilegl_server_main(int a
|
||||
}
|
||||
::close(listener);
|
||||
if (endpoint[0] != '@') ::unlink(endpoint.c_str());
|
||||
ExitSessionProcess(RunSession(std::move(control), {}, {}, -1, DataSource::None, kPairedUnixHelloWaitMs));
|
||||
ExitSessionProcess(RunSession(std::move(control), {}, {}, -1, DataSource::None, 10000));
|
||||
}
|
||||
reap();
|
||||
// exit_group closes files just before waitpid can observe the exit.
|
||||
@@ -1555,11 +1355,7 @@ extern "C" __attribute__((visibility("default"))) int mobilegl_server_main(int a
|
||||
// P12 (D8): the unix `--serve` child dies with its supervisor too.
|
||||
DieWithSupervisor(supervisor);
|
||||
::close(listener);
|
||||
// Every other waiting connection is the supervisor's: closed here without a word, or the
|
||||
// supervisor's refusal of one would not end it while this session lives (TcpSupervisor's
|
||||
// fork does the same with its pending peers).
|
||||
if (pairs) pairs->CloseInForkedChild();
|
||||
ExitSessionProcess(RunSession(std::move(control), {}, {}, -1, DataSource::None, kPairedUnixHelloWaitMs));
|
||||
ExitSessionProcess(RunSession(std::move(control), {}, {}, -1, DataSource::None, 10000));
|
||||
}
|
||||
if (child < 0) {
|
||||
RefuseBusy(*control, "could not create session child");
|
||||
@@ -1577,14 +1373,11 @@ extern "C" __attribute__((visibility("default"))) int mobilegl_server_main(int a
|
||||
// P12 (on-screen server window), D5. See InProcessServer.h for the contract.
|
||||
extern "C" __attribute__((visibility("default"))) int mobilegl_server_serve_inprocess(const char* endpoint) {
|
||||
if (const int refused = CheckServerEnvironment(); refused != 0) return refused;
|
||||
if (endpoint == nullptr || endpoint[0] == '\0') {
|
||||
WireLogError("MG_Remote server: the in-process display server needs an endpoint (tcp://, "
|
||||
"@abstract or a filesystem path)");
|
||||
if (endpoint == nullptr || std::strncmp(endpoint, "tcp://", 6) != 0) {
|
||||
WireLogError("MG_Remote server: the in-process display server serves tcp:// only; '%s' is not one",
|
||||
endpoint == nullptr ? "(null)" : endpoint);
|
||||
return 71;
|
||||
}
|
||||
// tcp:// takes the TCP supervisor's thread hand-off; anything else is a unix endpoint
|
||||
// (@abstract name or filesystem path), taken by the unix supervisor with the same threads.
|
||||
const bool tcpEndpoint = std::strncmp(endpoint, "tcp://", 6) == 0;
|
||||
bool idle = false;
|
||||
if (!g_inProcessServing.compare_exchange_strong(idle, true, std::memory_order_acq_rel)) {
|
||||
WireLogError("MG_Remote server: an in-process display server is already serving in this process; "
|
||||
@@ -1618,18 +1411,13 @@ extern "C" __attribute__((visibility("default"))) int mobilegl_server_serve_inpr
|
||||
Server::ServerDisplayInstance().HasDisplay() ? "installed" : "NOT installed - offscreen only");
|
||||
unsigned long sessionsFaulted = 0;
|
||||
int result = 0;
|
||||
if (tcpEndpoint) {
|
||||
{
|
||||
TcpSupervisor supervisor(listener, Server::PreAuthKnobs::FromEnvironment(), sessionsFaulted,
|
||||
TcpSupervisor::Handoff::Thread, &g_inProcessStop);
|
||||
result = supervisor.Run();
|
||||
} else {
|
||||
UnixInProcessSupervisor supervisor(listener, sessionsFaulted);
|
||||
result = supervisor.Run();
|
||||
}
|
||||
LogSupervisorSummary(sessionsFaulted);
|
||||
::close(listener);
|
||||
// A filesystem unix endpoint leaves a node behind; an abstract name has none.
|
||||
if (!tcpEndpoint && endpoint[0] != '@') ::unlink(endpoint);
|
||||
g_inProcessStop.store(false, std::memory_order_release);
|
||||
g_inProcessServing.store(false, std::memory_order_release);
|
||||
return result;
|
||||
|
||||
@@ -15,7 +15,6 @@
|
||||
#include "../CapsCodec.h"
|
||||
#include "../Handshake.h"
|
||||
#include "../Transport/LinkMetrics.h"
|
||||
#include "../Transport/AdoptTier.h"
|
||||
#include "../Protocol/generated/protocol_generated.h"
|
||||
#include "../Transport/InProcessTransport.h"
|
||||
|
||||
@@ -654,10 +653,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
hello->dialMode() != ::MobileGL::Wire::DialMode::Connect)
|
||||
return RefuseHandshake(transport, ::MobileGL::Wire::RefuseCode::MalformedHello,
|
||||
"unknown dial mode");
|
||||
// P11 B1: remembered for the apply thread's `auto` policy (ApplyThreadPolicy.h).
|
||||
m_peer = hello->dialMode() == ::MobileGL::Wire::DialMode::Connect ? ApplyPeer::Connected
|
||||
: hello->dialMode() == ::MobileGL::Wire::DialMode::Fork ? ApplyPeer::Forked
|
||||
: ApplyPeer::InProcess;
|
||||
const MobileGLResult compatible = ValidatePeerHandshake(transport, hello->abiMajor(),
|
||||
hello->abiMinor(), hello->wireFingerprint(), theirStamp, hello->dialMode());
|
||||
if (compatible != MOBILEGL_OK) return compatible;
|
||||
@@ -669,7 +664,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
return RefuseHandshake(transport, ::MobileGL::Wire::RefuseCode::LinkTerms,
|
||||
"unsupported or missing link terms");
|
||||
const bool stream = terms->dataPlane() == ::MobileGL::Wire::DataPlane::Stream;
|
||||
m_peerSharedSegments = !stream; // P11 B1: the apply thread's `auto` policy reads the plane too
|
||||
if (stream && transport.Role() == Transport::TransportRole::InProcess)
|
||||
return RefuseHandshake(transport, ::MobileGL::Wire::RefuseCode::LinkTerms,
|
||||
"stream requires a data connection");
|
||||
@@ -679,11 +673,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
"backend request differs from server", m_backend == nullptr ? 0 :
|
||||
static_cast<Uint32>(m_backend->GetBackendType()), hello->backendType());
|
||||
|
||||
// ---- P11 A1: this side's adopt tier, from its own knob and the plane the Hello asked
|
||||
// for, before a byte of Welcome. A stream refuses T0/T1 by name and serves T2; over
|
||||
// shared segments the client settles it (Transport/AdoptTier.h). 0/1 never die here.
|
||||
(void)Transport::SettleAdoptTierAtHandshake(stream, Transport::AdoptTierSide::Server);
|
||||
|
||||
// ---- 3. the four segments, both control pages, the rings.
|
||||
MobileGLResult created = MOBILEGL_ERR_UNSUPPORTED;
|
||||
// PH-7 (4), ID-P7-3. Minted HERE - after the token was checked, before a byte of Welcome
|
||||
@@ -1139,27 +1128,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
PublishEvents();
|
||||
}
|
||||
|
||||
void ServerSession::PostFenceSignaled(MG_Pipe::MGPipeHandle fence) {
|
||||
if (!m_accepted) {
|
||||
MGLOG_E_ONCE("MG_Remote server: PostFenceSignaled {%u, %u} before Accept - dropped, "
|
||||
"there is no SEG_EVENT to carry it on",
|
||||
fence.Slot, fence.Gen);
|
||||
return;
|
||||
}
|
||||
void* slot = ReserveEventOrBlock(*this, Transport::kEventFenceSignaled, "kEventFenceSignaled",
|
||||
sizeof(Transport::EventFenceSignaledHead));
|
||||
Transport::EventFenceSignaledHead head{};
|
||||
head.Fence.Slot = fence.Slot;
|
||||
head.Fence.Gen = fence.Gen;
|
||||
std::memcpy(slot, &head, sizeof(head));
|
||||
PublishEvents();
|
||||
}
|
||||
|
||||
Bool ServerSession::EventRingHasRoom() const {
|
||||
if (!m_accepted || m_link == nullptr) return false;
|
||||
return m_link->Signals().EventRingFull->load(std::memory_order_acquire) == 0;
|
||||
}
|
||||
|
||||
// PH-6 (ID-P7-2). THE FIRST DROP, AND THE LATCH IT RAISES.
|
||||
//
|
||||
// Logged ONCE, by name, with everything a triage needs: which event, how big, what the
|
||||
|
||||
@@ -57,7 +57,6 @@
|
||||
#include "../Transport/RoleMemory.h"
|
||||
#include "../Transport/SessionRings.h"
|
||||
#include "../Wire/PipeWireCodec.h"
|
||||
#include "ApplyThreadPolicy.h"
|
||||
#include "PipeApplier.h"
|
||||
|
||||
namespace MobileGL::MG_Remote::Server {
|
||||
@@ -182,11 +181,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
Uint64 CallMask() const;
|
||||
|
||||
Bool Accepted() const;
|
||||
// P11 B1: who the client is - its Hello's dial mode - and whether it uses shared segments
|
||||
// (false = the stream plane), both set by Accept before Welcome. ServerLoop picks the apply
|
||||
// thread's `auto` affinity and spin from them (ApplyThreadPolicy.h).
|
||||
ApplyPeer Peer() const { return m_peer; }
|
||||
Bool PeerSharedSegments() const { return m_peerSharedSegments; }
|
||||
// Teardown: after the apply thread has been joined, never before - a record still in
|
||||
// flight can still resolve a segment offset (table 3's fourth column).
|
||||
void Close();
|
||||
@@ -216,13 +210,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
// ruling (§1), not a check. A session that has not accepted drops the error with a
|
||||
// loud line, exactly as RecordError's own no-live-context arm does.
|
||||
void PostGlError(Uint32 code, const char* message);
|
||||
// P10 (CONTRACT-P10.md §1): one kEventFenceSignaled for a client fence the apply thread
|
||||
// found signaled. Posted and published at once - a client may be polling on it right now.
|
||||
// Dropped with the same loud line as PostGlError before Accept.
|
||||
void PostFenceSignaled(MG_Pipe::MGPipeHandle fence);
|
||||
// True when SEG_EVENT is not latched full: an optional post (a fence report) goes
|
||||
// there without parking the apply thread. False before Accept.
|
||||
Bool EventRingHasRoom() const;
|
||||
Transport::ITransport* Control_Plane();
|
||||
|
||||
// ---- PH-6 (ID-P7-2): THE REVERSE CHANNEL IS FORFEITED, NOT FATAL -------------------
|
||||
@@ -315,8 +302,6 @@ namespace MobileGL::MG_Remote::Server {
|
||||
Bool m_consumedSet = false;
|
||||
Bool m_sizesSet = false;
|
||||
Bool m_accepted = false;
|
||||
ApplyPeer m_peer = ApplyPeer::InProcess;
|
||||
Bool m_peerSharedSegments = true;
|
||||
// PH-6. Written by the apply thread (the only SEG_EVENT producer), reset by Accept.
|
||||
std::atomic<Bool> m_reverseChannelForfeit{false};
|
||||
std::atomic<Uint64> m_forfeitDrops{0};
|
||||
|
||||
@@ -1,70 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_Remote/Transport/AdoptTier.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
|
||||
#include "AdoptTier.h"
|
||||
|
||||
#include <Config.h>
|
||||
#include <MG_Remote/FatalFunnel.h>
|
||||
#include <MG_Util/Debug/Log.h>
|
||||
|
||||
#include <atomic>
|
||||
|
||||
namespace MobileGL::MG_Remote::Transport {
|
||||
|
||||
namespace {
|
||||
std::atomic<bool> g_settled{false};
|
||||
|
||||
const char* SideName(AdoptTierSide side) { return side == AdoptTierSide::Client ? "client" : "server"; }
|
||||
} // namespace
|
||||
|
||||
std::uint32_t SettleAdoptTierAtHandshake(bool streamDataPlane, AdoptTierSide side) {
|
||||
const std::uint32_t knob = MG_Config::Ipc.AdoptTier;
|
||||
if (knob > 2) {
|
||||
// Unreachable through ConfigLoader (it admits 0..2); a direct assignment is the only
|
||||
// way here, and "P11 implements it" of a 7 would be a lie.
|
||||
SessionFail(MGFatalFamily::UnimplementedAdoptTier,
|
||||
"MGPipe: Fatal{UnimplementedAdoptTier, \"%u\"} - MOBILEGL_IPC_ADOPT_TIER=%u is not an "
|
||||
"adoption tier; the values are 0 and 1 (not implemented) and 2 (emulate, the default)",
|
||||
static_cast<unsigned>(knob), static_cast<unsigned>(knob));
|
||||
}
|
||||
if (knob == 2) {
|
||||
g_settled.store(true, std::memory_order_release);
|
||||
return 2;
|
||||
}
|
||||
if (streamDataPlane) {
|
||||
// ONE LINE PER SESSION, on the side that holds the knob. The tcp lane's server is a
|
||||
// shared fixture that never sees the client's environment, so each side says it for
|
||||
// itself; neither side dies, because T2 is the only tier a stream can carry.
|
||||
MGLOG_W("MG_Remote %s: Refuse{AdoptTierOnStream, \"T%u\"} - MOBILEGL_IPC_ADOPT_TIER=%u names a "
|
||||
"shared-mapping adoption tier and this session's data plane is a stream (tcp): the two "
|
||||
"sides share no memory to map, so the session runs T2 (emulate: the client keeps the "
|
||||
"shadow and pushes)",
|
||||
SideName(side), static_cast<unsigned>(knob), static_cast<unsigned>(knob));
|
||||
g_settled.store(true, std::memory_order_release);
|
||||
return 2;
|
||||
}
|
||||
if (side == AdoptTierSide::Server) {
|
||||
MGLOG_W("MG_Remote server: MOBILEGL_IPC_ADOPT_TIER=%u is the client's to settle on a shared-segment "
|
||||
"link (a client naming T0/T1 dies by name at its own handshake); this server serves T2",
|
||||
static_cast<unsigned>(knob));
|
||||
g_settled.store(true, std::memory_order_release);
|
||||
return 2;
|
||||
}
|
||||
SessionFail(MGFatalFamily::UnimplementedAdoptTier,
|
||||
"MGPipe: Fatal{UnimplementedAdoptTier, \"T%u\"} - MOBILEGL_IPC_ADOPT_TIER=%u names a "
|
||||
"shared-mapping adoption tier no package implements yet (T0 is P11 package B's, T1 is "
|
||||
"closed); refused at the handshake over shared segments, before any record is emitted. "
|
||||
"Unset it or set 2 (emulate)",
|
||||
static_cast<unsigned>(knob), static_cast<unsigned>(knob));
|
||||
}
|
||||
|
||||
bool AdoptTierSettledAtHandshake() { return g_settled.load(std::memory_order_acquire); }
|
||||
|
||||
void ForgetAdoptTierSettlementForTest() { g_settled.store(false, std::memory_order_release); }
|
||||
|
||||
} // namespace MobileGL::MG_Remote::Transport
|
||||
@@ -1,53 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_Remote/Transport/AdoptTier.h
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
|
||||
// P11 A1 (MG_Remote/CONTRACT-P11.md §1): THE PERSISTENT-MAP ADOPTION TIER IS SETTLED AT THE
|
||||
// HANDSHAKE, BY THE SIDE THAT KNOWS THE DATA PLANE, BEFORE THE FIRST map_persistent.
|
||||
//
|
||||
// Tier names follow docs/Disaggregated/design/07: T0 = the client allocates an AHardwareBuffer
|
||||
// and the server imports it; T1 = the server exports an opaque fd; T2 = the resource owner
|
||||
// declines and the client keeps the shadow and pushes. Only T2 is implemented (T0 is P11
|
||||
// package B's, T1 is closed), so MOBILEGL_IPC_ADOPT_TIER=0/1 is either refused by name or
|
||||
// fatal - never a silent T2, and never discovered at the first map_persistent:
|
||||
//
|
||||
// data plane side knob 0 / 1
|
||||
// Stream (tcp) either one line `Refuse{AdoptTierOnStream, "T<n>"}`, then T2. Never Fatal:
|
||||
// a stream has no memory the two sides share, so no tier but T2
|
||||
// can exist on it.
|
||||
// SharedSegments client Fatal{UnimplementedAdoptTier, "T<n>"} at the handshake, before any
|
||||
// record is emitted.
|
||||
// SharedSegments server one warning that the client settles the tier on this plane, then
|
||||
// T2. (inproc and fork share the client's environment, so the client
|
||||
// dies by name right after; a unix-socket server launched on its own
|
||||
// serves the T2 its client settled.)
|
||||
//
|
||||
// In MG_Remote/Transport (the link-ratchet's SERVER partition) because both roles call it:
|
||||
// ServerSession::Accept and ClientSession's two Start halves. The at-use check the server's
|
||||
// applier and codec ask (Client::AdoptTierIsEmulate) reads the settlement back.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace MobileGL::MG_Remote::Transport {
|
||||
|
||||
enum class AdoptTierSide : std::uint8_t { Client, Server };
|
||||
|
||||
// Settles this session's tier from MOBILEGL_IPC_ADOPT_TIER and the negotiated data plane,
|
||||
// on `side`, and returns the tier the session runs (2 until package B). Logs at most one
|
||||
// line per call; aborts (SessionFail) only on the client over shared segments.
|
||||
std::uint32_t SettleAdoptTierAtHandshake(bool streamDataPlane, AdoptTierSide side);
|
||||
|
||||
// True once a handshake in this process has settled the tier. The at-use check trusts a
|
||||
// settled session and still refuses by name a map_persistent no handshake settled.
|
||||
bool AdoptTierSettledAtHandshake();
|
||||
|
||||
// Test seam: forget the settlement, so one process can drive both answers.
|
||||
void ForgetAdoptTierSettlementForTest();
|
||||
|
||||
} // namespace MobileGL::MG_Remote::Transport
|
||||
@@ -1,6 +1,5 @@
|
||||
#include "ControlInbox.h"
|
||||
#include "Doorbell.h"
|
||||
#include "LogForward.h"
|
||||
#include "../Protocol/SurfaceOpCodec.h"
|
||||
#include <MG_Util/Debug/Log.h>
|
||||
#include <chrono>
|
||||
@@ -19,21 +18,11 @@ namespace MobileGL::MG_Remote::Transport {
|
||||
if (m_reader.joinable()) m_reader.join();
|
||||
}
|
||||
|
||||
void ControlInbox::PauseReadingForTest(bool paused) {
|
||||
std::lock_guard<std::mutex> lock(m_mutex);
|
||||
m_pausedForTest = paused;
|
||||
m_cv.notify_all();
|
||||
}
|
||||
|
||||
void ControlInbox::Read() {
|
||||
for (;;) {
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
std::lock_guard<std::mutex> lock(m_mutex);
|
||||
if (m_stop) return;
|
||||
if (m_pausedForTest) {
|
||||
m_cv.wait(lock, [&] { return m_stop || !m_pausedForTest; });
|
||||
continue;
|
||||
}
|
||||
}
|
||||
std::uint64_t size = 0;
|
||||
auto result = m_transport.ReceiveFrame({nullptr, 0}, &size, 100);
|
||||
@@ -49,9 +38,7 @@ namespace MobileGL::MG_Remote::Transport {
|
||||
else {
|
||||
const auto* envelope = ::MobileGL::Wire::GetCtrlEnvelope(frame.data());
|
||||
if (const auto* log = envelope->msg_as_LogLine()) {
|
||||
// P9 W3: filed with the severity the server sent (LogForward.h's mapping).
|
||||
if (log->text())
|
||||
MG_Util::Debug::WritePeerLog(LogLevelFromWire(log->level()), log->text()->c_str());
|
||||
if (log->text()) MG_Util::Debug::WritePeerLog(log->text()->c_str());
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -18,11 +18,6 @@ namespace MobileGL::MG_Remote::Transport {
|
||||
MobileGLResult Receive(std::vector<std::uint8_t>& frame, std::uint32_t timeoutMs);
|
||||
std::uint64_t Peek();
|
||||
bool WaitClosed(std::uint32_t timeoutMs);
|
||||
// TEST-ONLY (P9 W3, fault injection F2). While paused the reader takes NOTHING off the
|
||||
// socket - not a LogLine, not a reply - which is exactly a client that stopped reading its
|
||||
// control connection, the peer the server's log forward (LogForward.h) must not be held by.
|
||||
// Frames already queued stay queued; resuming picks up where the socket is.
|
||||
void PauseReadingForTest(bool paused);
|
||||
private:
|
||||
void Read();
|
||||
ITransport& m_transport;
|
||||
@@ -31,7 +26,6 @@ namespace MobileGL::MG_Remote::Transport {
|
||||
std::deque<std::vector<std::uint8_t>> m_frames;
|
||||
std::uint64_t m_bytes = 0;
|
||||
bool m_stop = false;
|
||||
bool m_pausedForTest = false;
|
||||
MobileGLResult m_result = MOBILEGL_OK;
|
||||
std::thread m_reader;
|
||||
};
|
||||
|
||||
@@ -50,7 +50,6 @@ namespace MobileGL::MG_Remote::Transport {
|
||||
kEventGpuWritten = 2, // MGPipeCallbacks::OnGpuWritten
|
||||
kEventSurfaceChanged = 3, // MGPipeCallbacks::OnSurfaceChanged
|
||||
kEventGlError = 4, // PipeInputs::RecordError, posted by the server session
|
||||
kEventFenceSignaled = 5, // P10: a client fence the server saw signaled (CONTRACT-P10 §1)
|
||||
};
|
||||
|
||||
// The 8-byte {slot, gen} pair, mirrored (MGPipeHandles.h:54-65).
|
||||
@@ -111,14 +110,6 @@ namespace MobileGL::MG_Remote::Transport {
|
||||
std::uint32_t MessageBytes; // strlen + 1, the NUL included
|
||||
};
|
||||
static_assert(sizeof(EventGlErrorHead) == 8, "wire shape");
|
||||
// P10 (CONTRACT-P10.md §1): the fence the server's apply thread found signaled, once per
|
||||
// fence. The client keeps the answer and gives it to every later glClientWaitSync /
|
||||
// glGetSynciv(GL_SYNC_STATUS) on that fence without a round trip.
|
||||
struct EventFenceSignaledHead {
|
||||
EventHandle Fence;
|
||||
};
|
||||
static_assert(sizeof(EventFenceSignaledHead) == 8, "wire shape");
|
||||
|
||||
inline constexpr std::uint32_t kEventGlErrorMaxMessageBytes = 1024;
|
||||
static_assert(kEventGlErrorMaxMessageBytes == 1024,
|
||||
"CONTRACT-P5C §1 caps an inline GL-error message at 1024 bytes, NUL included");
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
// P6.5 transport measurements. The Window state is written only by the single client
|
||||
// producer; the socket-io counters drained by LinkMetricsTakeReadStats/TakeSendStats are
|
||||
// atomic and cross-thread (io thread writes, apply/client thread reads) - see below.
|
||||
// P6.5 transport measurements. Called only by the single client producer.
|
||||
#pragma once
|
||||
#include <cstdint>
|
||||
|
||||
@@ -43,28 +41,4 @@ namespace MobileGL::MG_Remote::Transport {
|
||||
std::uint64_t LinkMetricsRecordsFor(std::uint32_t op);
|
||||
void LinkMetricsPresent();
|
||||
void LinkMetricsServerPresent(std::uint64_t serial);
|
||||
|
||||
// P65READ: THE SERVER'S SOCKET-READ PATH, ACCOUNTED WHERE IT CAN BE SEEN. The counters are
|
||||
// published from the io thread's recv loop and read by the APPLY thread, because the io
|
||||
// thread's own MGLOG_ lines never reach the phone's forwarded log (only mgl-srv-apply and
|
||||
// mgl-display-ser do - measured, not assumed). Taking them RESETS them, so one call is one
|
||||
// frame's worth of the stage nothing else measures: the frame's time is not the client's GL
|
||||
// thread (13%) and not PipeApplier::ApplyOne (11%), and this is what sits between them.
|
||||
//
|
||||
// Free functions, NOT StreamLink members: the P6.5 seam gate (scripts/ci/link_seam_purity.py)
|
||||
// rejects a concrete-link include outside Transport, and the readers of these numbers live in
|
||||
// ClientSession/ServerLoop. The counters themselves stay in StreamLink.cpp beside the recv /
|
||||
// sendmsg loops that feed them.
|
||||
struct LinkIoStats {
|
||||
std::uint64_t bytes = 0; // payload bytes taken off the socket
|
||||
std::uint64_t calls = 0; // recv() calls it took
|
||||
std::uint64_t reads = 0; // Link::Read() calls (one per header, envelope or chunk)
|
||||
std::uint64_t nsInRecv = 0; // wall time inside recv - blocking included
|
||||
std::uint64_t nsTotal = 0; // wall time inside Read
|
||||
};
|
||||
LinkIoStats LinkMetricsTakeReadStats();
|
||||
// The client's half: bytes handed to the io thread's sendmsg, the calls it took, and the
|
||||
// wall time inside sendmsg (blocking included). nsInRecv carries the send time; reads is
|
||||
// unused on this side.
|
||||
LinkIoStats LinkMetricsTakeSendStats();
|
||||
}
|
||||
|
||||
@@ -1,355 +0,0 @@
|
||||
// MobileGL - MobileGL/MG_Remote/Transport/LogForward.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
|
||||
// P9 W3: the graded, non-blocking log forward. The policy and its reasons are in LogForward.h.
|
||||
|
||||
#include "LogForward.h"
|
||||
|
||||
#include "../Protocol/generated/protocol_generated.h"
|
||||
|
||||
// The umbrella, for MOBILEGL_LOG_LEVEL_* and GetCurrentTime - a .cpp may pull it (WireLog.h).
|
||||
#include <MG_Util/Debug/Log.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
|
||||
#if defined(__linux__)
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
|
||||
namespace MobileGL::MG_Remote::Transport {
|
||||
|
||||
namespace Wire = ::MobileGL::Wire;
|
||||
|
||||
// THE TWO SCALES ARE ONE SCALE, and these are what would notice if either moved: a sixth
|
||||
// MobileGL level, a reordered wire enum, or Log.h's 2026-08-13 inversion coming back.
|
||||
static_assert(MOBILEGL_LOG_LEVEL_DEBUG == 0 && MOBILEGL_LOG_LEVEL_INFO == 1 && MOBILEGL_LOG_LEVEL_WARN == 2 &&
|
||||
MOBILEGL_LOG_LEVEL_ERROR == 3 && MOBILEGL_LOG_LEVEL_FATAL == 4,
|
||||
"MobileGL's log levels moved; re-read WireLogLevelFor / LogLevelFromWire");
|
||||
static_assert(static_cast<int>(Wire::LogLevel::Debug) == 0 && static_cast<int>(Wire::LogLevel::Info) == 1 &&
|
||||
static_cast<int>(Wire::LogLevel::Warn) == 2 && static_cast<int>(Wire::LogLevel::Error) == 3 &&
|
||||
static_cast<int>(Wire::LogLevel::Fatal) == 4,
|
||||
"protocol.fbs's LogLevel moved; re-read WireLogLevelFor / LogLevelFromWire");
|
||||
|
||||
Wire::LogLevel WireLogLevelFor(int level) {
|
||||
if (level <= MOBILEGL_LOG_LEVEL_DEBUG) return Wire::LogLevel::Debug;
|
||||
switch (level) {
|
||||
case MOBILEGL_LOG_LEVEL_INFO: return Wire::LogLevel::Info;
|
||||
case MOBILEGL_LOG_LEVEL_WARN: return Wire::LogLevel::Warn;
|
||||
case MOBILEGL_LOG_LEVEL_ERROR: return Wire::LogLevel::Error;
|
||||
default: return Wire::LogLevel::Fatal;
|
||||
}
|
||||
}
|
||||
|
||||
int LogLevelFromWire(Wire::LogLevel level) {
|
||||
switch (level) {
|
||||
case Wire::LogLevel::Debug: return MOBILEGL_LOG_LEVEL_DEBUG;
|
||||
case Wire::LogLevel::Info: return MOBILEGL_LOG_LEVEL_INFO;
|
||||
case Wire::LogLevel::Warn: return MOBILEGL_LOG_LEVEL_WARN;
|
||||
case Wire::LogLevel::Error: return MOBILEGL_LOG_LEVEL_ERROR;
|
||||
case Wire::LogLevel::Fatal: return MOBILEGL_LOG_LEVEL_FATAL;
|
||||
}
|
||||
// A value this build's schema does not name: a newer peer's severity. Never demoted into
|
||||
// the lossy class - an unknown severity is filed as an error.
|
||||
return MOBILEGL_LOG_LEVEL_ERROR;
|
||||
}
|
||||
|
||||
namespace {
|
||||
// The header a notice line carries: the shape of Log()'s own ("[time] [OS thread/LEVEL]: "),
|
||||
// so it reads like any other forwarded line and starts with '[' (WritePeerLog writes it as it
|
||||
// came). The "OS" slot names the layer instead: GetOSName is not callable outside Log.cpp.
|
||||
std::string NoticeHeader(int level) {
|
||||
return "[" + MG_Util::Debug::GetCurrentTime() + "] [MG_Remote mgl-log-fwd/" +
|
||||
MG_Util::Debug::LogLevelTag(level) + "]: ";
|
||||
}
|
||||
} // namespace
|
||||
|
||||
LogForwardChannel::LogForwardChannel(ITransport& transport, Unblock unblock, void* unblockUser,
|
||||
const LogForwardLimits& limits)
|
||||
: m_transport(transport), m_unblock(unblock), m_unblockUser(unblockUser), m_limits(limits),
|
||||
m_tokens(static_cast<double>(limits.errorBurstLines)), m_tokensAt(std::chrono::steady_clock::now()) {
|
||||
m_sender = std::thread([this] { Run(); });
|
||||
}
|
||||
|
||||
LogForwardChannel::~LogForwardChannel() { (void)Close(); }
|
||||
|
||||
void LogForwardChannel::ForwardThunk(void* user, int level, const char* line) {
|
||||
static_cast<LogForwardChannel*>(user)->Offer(level, line);
|
||||
}
|
||||
|
||||
bool LogForwardChannel::IsUrgentLocked() const { return m_urgent > 0 || m_closing; }
|
||||
|
||||
void LogForwardChannel::QueueGapNoticesLocked(bool lossyGapToo) {
|
||||
// ONE NOTICE PER GAP, however many lines it swallowed, so a notice never needs room of its
|
||||
// own worth refusing and the number of notices is bounded by the number of lines that did
|
||||
// get in. WHERE each class's gap is closed differs, on purpose:
|
||||
// * an ERROR gap is marked before the very next item queued - the next ERROR line that
|
||||
// fits, a LogFlush ack, Close - because an error gap is rare and where it sits matters;
|
||||
// * a <= WARN gap is marked when the lossy class RECOVERS (the next line at or below WARN
|
||||
// that fits), or at a LogFlush ack or Close. Not before every ERROR line that squeezes
|
||||
// through in the middle of it: under a sustained stall that was one notice per ERROR
|
||||
// line (F2 measured 373 in one run), which buries the errors it sits between. The notice
|
||||
// names the time the gap began instead, so it still says where it started.
|
||||
char text[512];
|
||||
if (lossyGapToo && m_gapLossyLines != 0) {
|
||||
std::snprintf(text, sizeof(text),
|
||||
"MG_Remote server: LogForward{Dropped} - %llu line(s) at or below WARN (%llu bytes) were "
|
||||
"not forwarded, from %s until here: the control connection was not taking them and the "
|
||||
"forward queue held its %llu-byte cap. The server's own log has every one\n",
|
||||
static_cast<unsigned long long>(m_gapLossyLines),
|
||||
static_cast<unsigned long long>(m_gapLossyBytes), m_gapLossySince.c_str(),
|
||||
static_cast<unsigned long long>(m_limits.lossyQueueBytes));
|
||||
Item notice;
|
||||
notice.kind = Kind::Notice;
|
||||
notice.level = MOBILEGL_LOG_LEVEL_WARN;
|
||||
notice.seq = m_nextSeq++;
|
||||
notice.text = NoticeHeader(notice.level) + text;
|
||||
m_queue.push_back(std::move(notice));
|
||||
++m_counters.notices;
|
||||
m_gapLossyLines = 0;
|
||||
m_gapLossyBytes = 0;
|
||||
}
|
||||
if (m_gapErrorLines != 0) {
|
||||
std::snprintf(text, sizeof(text),
|
||||
"MG_Remote server: LogForward{Coalesced} - %llu ERROR line(s) were not forwarded here: the "
|
||||
"forward queue held its %llu-byte cap of error lines the control connection had not "
|
||||
"taken. The server's own log has every one\n",
|
||||
static_cast<unsigned long long>(m_gapErrorLines),
|
||||
static_cast<unsigned long long>(m_limits.errorQueueBytes));
|
||||
Item notice;
|
||||
notice.kind = Kind::Notice;
|
||||
notice.level = MOBILEGL_LOG_LEVEL_ERROR;
|
||||
notice.seq = m_nextSeq++;
|
||||
notice.text = NoticeHeader(notice.level) + text;
|
||||
m_queue.push_back(std::move(notice));
|
||||
++m_counters.notices;
|
||||
m_gapErrorLines = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void LogForwardChannel::Offer(int level, const char* line) {
|
||||
if (line == nullptr) return;
|
||||
const auto started = std::chrono::steady_clock::now();
|
||||
const std::size_t length = std::strlen(line);
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
// The bound this whole file exists for, measured where it is spent: everything below FATAL
|
||||
// returns through here with the lock still held and no wait taken.
|
||||
const auto noteOfferTime = [this, started] {
|
||||
const auto spent = static_cast<std::uint64_t>(
|
||||
std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now() - started)
|
||||
.count());
|
||||
m_counters.maxOfferNs = std::max(m_counters.maxOfferNs, spent);
|
||||
};
|
||||
if (m_closing || m_counters.transportFailed) {
|
||||
// Offered after Close() began or after the peer went: it can never be written.
|
||||
++m_counters.abandoned;
|
||||
return;
|
||||
}
|
||||
const bool lossy = level <= MOBILEGL_LOG_LEVEL_WARN;
|
||||
const bool fatal = level >= MOBILEGL_LOG_LEVEL_FATAL;
|
||||
if (lossy && m_lossyBytes + length > m_limits.lossyQueueBytes) {
|
||||
// The first drop of a gap stamps when it began; the notice that closes it names that.
|
||||
if (m_gapLossyLines == 0) m_gapLossySince = MG_Util::Debug::GetCurrentTime();
|
||||
++m_counters.lossyDropped;
|
||||
m_counters.lossyDroppedBytes += length;
|
||||
++m_gapLossyLines;
|
||||
m_gapLossyBytes += length;
|
||||
noteOfferTime();
|
||||
return;
|
||||
}
|
||||
// FATAL is never refused: the process is about to end, and its last word is the one line
|
||||
// the cap must not cost. The cap still bounds everything that can repeat.
|
||||
if (!lossy && !fatal && m_errorBytes + length > m_limits.errorQueueBytes) {
|
||||
++m_counters.errorsCoalesced;
|
||||
++m_gapErrorLines;
|
||||
noteOfferTime();
|
||||
return;
|
||||
}
|
||||
// A lossy line that fits closes a <= WARN gap; any line closes an ERROR gap.
|
||||
QueueGapNoticesLocked(/*lossyGapToo=*/lossy);
|
||||
Item item;
|
||||
item.kind = Kind::Line;
|
||||
item.level = level;
|
||||
item.seq = m_nextSeq++;
|
||||
item.text.assign(line, length);
|
||||
const std::uint64_t seq = item.seq;
|
||||
m_queue.push_back(std::move(item));
|
||||
if (lossy) m_lossyBytes += length;
|
||||
else m_errorBytes += length;
|
||||
if (fatal) ++m_urgent;
|
||||
m_cv.notify_all();
|
||||
if (!fatal) {
|
||||
noteOfferTime();
|
||||
return;
|
||||
}
|
||||
// FATAL: wait - bounded - until the sender has written this line and everything before it.
|
||||
//
|
||||
// ONCE PER STALL, NOT ONCE PER LINE. MGLOG_F is not only the last word before an abort: the
|
||||
// tree also uses it for survivable conditions (the EGL loader's "Failed to load EGL function"
|
||||
// lines, several in a row). If an earlier FATAL wait already ran out and the sender has not
|
||||
// written a single item since, the peer is still not reading and a second wait would only
|
||||
// spend another fatalFlushMs of this thread's time on the same answer - so it is counted as
|
||||
// a timeout at once. The line itself is queued either way.
|
||||
if (m_fatalGaveUpAtWritten == m_writtenSeq) {
|
||||
++m_counters.fatalFlushTimeouts;
|
||||
return;
|
||||
}
|
||||
const auto deadline = started + std::chrono::milliseconds(m_limits.fatalFlushMs);
|
||||
if (!m_cv.wait_until(lock, deadline,
|
||||
[this, seq] { return m_writtenSeq >= seq || m_counters.transportFailed; })) {
|
||||
++m_counters.fatalFlushTimeouts;
|
||||
m_fatalGaveUpAtWritten = m_writtenSeq;
|
||||
}
|
||||
}
|
||||
|
||||
void LogForwardChannel::OfferControlFrame(std::vector<std::uint8_t> frame) {
|
||||
std::lock_guard<std::mutex> lock(m_mutex);
|
||||
if (m_closing || m_counters.transportFailed) {
|
||||
++m_counters.abandoned;
|
||||
return;
|
||||
}
|
||||
// A gap before the acknowledgement is marked before it: the client reads the file after the
|
||||
// ack arrives, and a gap it cannot see there is a gap it will read as "nothing was said".
|
||||
QueueGapNoticesLocked(/*lossyGapToo=*/true);
|
||||
Item item;
|
||||
item.kind = Kind::Control;
|
||||
item.seq = m_nextSeq++;
|
||||
item.frame = std::move(frame);
|
||||
m_queue.push_back(std::move(item));
|
||||
++m_urgent;
|
||||
m_cv.notify_all();
|
||||
}
|
||||
|
||||
MobileGLResult LogForwardChannel::Send(const Item& item) {
|
||||
if (item.kind == Kind::Control) {
|
||||
return m_transport.SendFrame(MobileGLByteSpan{item.frame.data(), item.frame.size()});
|
||||
}
|
||||
flatbuffers::FlatBufferBuilder builder(item.text.size() + 64);
|
||||
const auto text = builder.CreateString(item.text);
|
||||
const auto log = Wire::CreateLogLine(builder, WireLogLevelFor(item.level), text);
|
||||
const auto envelope = Wire::CreateCtrlEnvelope(builder, Wire::CtrlMsg::LogLine, log.Union());
|
||||
Wire::FinishCtrlEnvelopeBuffer(builder, envelope);
|
||||
return m_transport.SendFrame(MobileGLByteSpan{builder.GetBufferPointer(), builder.GetSize()});
|
||||
}
|
||||
|
||||
void LogForwardChannel::Run() {
|
||||
#if defined(__linux__)
|
||||
pthread_setname_np(pthread_self(), "mgl-log-fwd");
|
||||
#endif
|
||||
// THIS THREAD NEVER LOGS. It is the logger's sink: a line it logged would come straight back
|
||||
// to its own queue (and in the non-session shape, through the log mutex a FATAL Offer can be
|
||||
// waiting behind). What it has to say is in the counters, which Close() hands to its owner.
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
for (;;) {
|
||||
m_cv.wait(lock, [this] { return m_stop || !m_queue.empty(); });
|
||||
if (m_queue.empty()) return; // stopped, and nothing left
|
||||
if (m_counters.transportFailed) {
|
||||
// The peer is gone (a write failed): nothing queued can be written any more.
|
||||
m_counters.abandoned += m_queue.size();
|
||||
m_writtenSeq = m_queue.back().seq;
|
||||
m_queue.clear();
|
||||
m_lossyBytes = 0;
|
||||
m_errorBytes = 0;
|
||||
m_urgent = 0;
|
||||
m_cv.notify_all();
|
||||
continue;
|
||||
}
|
||||
Item& front = m_queue.front();
|
||||
if (front.kind == Kind::Line && front.level == MOBILEGL_LOG_LEVEL_ERROR && !IsUrgentLocked()) {
|
||||
// THE ERROR PACE. A token bucket, refilled by the time since it was last looked at.
|
||||
// A line with no token waits - in the queue, in order - until one accrues, or until
|
||||
// something urgent (a FATAL line, a LogFlush ack, Close) makes the pace moot.
|
||||
const auto now = std::chrono::steady_clock::now();
|
||||
const double elapsed = std::chrono::duration<double>(now - m_tokensAt).count();
|
||||
m_tokens = std::min(static_cast<double>(m_limits.errorBurstLines),
|
||||
m_tokens + elapsed * static_cast<double>(m_limits.errorLinesPerSecond));
|
||||
m_tokensAt = now;
|
||||
if (m_tokens < 1.0) {
|
||||
if (!front.paced) {
|
||||
front.paced = true;
|
||||
++m_counters.errorsPaced;
|
||||
}
|
||||
const double rate = std::max(1.0, static_cast<double>(m_limits.errorLinesPerSecond));
|
||||
const auto untilToken = std::chrono::duration_cast<std::chrono::steady_clock::duration>(
|
||||
std::chrono::duration<double>((1.0 - m_tokens) / rate));
|
||||
m_cv.wait_for(lock, untilToken, [this] { return IsUrgentLocked() || m_stop; });
|
||||
continue;
|
||||
}
|
||||
m_tokens -= 1.0;
|
||||
}
|
||||
Item item = std::move(front);
|
||||
m_queue.pop_front();
|
||||
if (item.kind == Kind::Line) {
|
||||
if (item.level <= MOBILEGL_LOG_LEVEL_WARN) m_lossyBytes -= item.text.size();
|
||||
else m_errorBytes -= item.text.size();
|
||||
}
|
||||
if (item.kind == Kind::Control || (item.kind == Kind::Line && item.level >= MOBILEGL_LOG_LEVEL_FATAL)) {
|
||||
--m_urgent;
|
||||
}
|
||||
m_sending = true;
|
||||
lock.unlock();
|
||||
const MobileGLResult sent = Send(item);
|
||||
lock.lock();
|
||||
m_sending = false;
|
||||
m_writtenSeq = item.seq;
|
||||
if (sent == MOBILEGL_OK) {
|
||||
if (item.kind == Kind::Line) ++m_counters.forwarded;
|
||||
} else if (sent == MOBILEGL_ERR_INVALID_ARGUMENT) {
|
||||
// Refused on its own shape (over the frame cap), not because the peer is gone.
|
||||
++m_counters.abandoned;
|
||||
} else {
|
||||
++m_counters.abandoned;
|
||||
m_counters.transportFailed = true;
|
||||
}
|
||||
m_cv.notify_all();
|
||||
}
|
||||
}
|
||||
|
||||
LogForwardCounters LogForwardChannel::Close() {
|
||||
bool unblock = false;
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(m_mutex);
|
||||
if (m_closed) return m_counters;
|
||||
if (!m_closing) {
|
||||
m_closing = true;
|
||||
// The last gap is marked too: a client reading the file after the session sees
|
||||
// that the tail it has is not the whole tail.
|
||||
QueueGapNoticesLocked(/*lossyGapToo=*/true);
|
||||
m_cv.notify_all();
|
||||
const auto drained = [this] {
|
||||
return (m_queue.empty() && !m_sending) || m_counters.transportFailed;
|
||||
};
|
||||
if (!m_cv.wait_for(lock, std::chrono::milliseconds(m_limits.closeDrainMs), drained)) {
|
||||
// Not taken within the budget: the peer is not reading. The rest is abandoned,
|
||||
// and a sender inside a write is blocked on that peer and needs unblocking.
|
||||
m_counters.abandoned += m_queue.size();
|
||||
if (!m_queue.empty()) m_writtenSeq = m_queue.back().seq;
|
||||
m_queue.clear();
|
||||
m_lossyBytes = 0;
|
||||
m_errorBytes = 0;
|
||||
m_urgent = 0;
|
||||
unblock = m_sending;
|
||||
}
|
||||
}
|
||||
m_stop = true;
|
||||
m_cv.notify_all();
|
||||
}
|
||||
if (unblock && m_unblock != nullptr) m_unblock(m_unblockUser);
|
||||
if (m_sender.joinable()) m_sender.join();
|
||||
std::lock_guard<std::mutex> lock(m_mutex);
|
||||
m_closed = true;
|
||||
return m_counters;
|
||||
}
|
||||
|
||||
LogForwardCounters LogForwardChannel::Counters() const {
|
||||
std::lock_guard<std::mutex> lock(m_mutex);
|
||||
return m_counters;
|
||||
}
|
||||
|
||||
} // namespace MobileGL::MG_Remote::Transport
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user