[Fix] (ShaderTranspiler, DirectVulkan, MG_IntegrationTest): patch both of iterationRP's under-declared subgroup scratch arrays

The previous commit's fingerprint was pinned to one array's incidental
dimensions - workgroup exactly 32x16x1, element exactly vec2, length
exactly 32 - which is the auto-exposure reduction and nothing else. The
pack ships the same idiom twice:

  - auto-exposure:  32x16 (512 invocations), shared vec2 prefixSumCache[32]
  - RTW warp:       1024 invocations,        shared float prefixSumCache[64]

so the warp kept writing 128 subgroups into 64 entries on an 8-lane
device and the retrace stayed bit-identically wrong (ssim 0.027902).

Key the fingerprint on the pack's idiom instead of one array's shape: a
workgroup array of 32-bit floats indexed by gl_SubgroupID, fed by a
subgroup scan, whose declared length is below ceil(invocations / native
width). Three properties keep that a targeted repair rather than a
general array resizer:

  - the index must BE gl_SubgroupID (through OpCopyObject, a signedness
    OpBitcast, or a spill whose every store is that id), so an index
    masked or clamped into range is left alone;
  - the >= 16-lane early-out is retained, so every module on the devices
    the pack was written for passes through byte-identical;
  - growth is certified against maxComputeSharedMemorySize using a
    natural-alignment layout model, and declined outright when a
    declaration cannot be sized, so a patched module can never fail
    pipeline creation where the original would not have.

Verified against the shaders the CI trace actually contains: of the 14
compute modules in the fixture exactly these two change, the other
twelve are byte-identical, and all fourteen pass spirv-val. The
integration scenario grows a second case for the 1024-invocation shape;
both abort with heap corruption when the patch is disabled.

Claude-Session: https://claude.ai/code/session_01EXSURVxwp8VVrWrPEQeLCm

.github/workflows/apk.yml

@@ -420,9 +420,6 @@ jobs:
           MOBILEGL_USE_ANGLE: ${{ matrix.backend.name == 'DirectGLES' && '1' || '0' }}
           MOBILEGL_TRACE_ANGLE_VARIANT: ${{ matrix.case.name == 'minecraft-1.21.4-fabric-iris-bliss-in-world' && '90a62123d794' || 'ec889e6ea831' }}
           MOBILEGL_MAGMA_R11G11B10F_FALLBACK: ${{ matrix.backend.name == 'DirectVulkan' && '1' || '0' }}
-          MOBILEGL_FIX_ITERATIONRP_SUBGROUP_SCRATCH: ${{ matrix.backend.name == 'DirectVulkan' && matrix.case.name == 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' && '1' || '0' }}
-          MOBILEGL_DERIVE_NUM_SUBGROUPS: ${{ matrix.backend.name == 'DirectVulkan' && matrix.case.name == 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' && '1' || '0' }}
-          MOBILEGL_ITERATIONRP_FIX_BARRIER: ${{ matrix.backend.name == 'DirectVulkan' && matrix.case.name == 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' && '1' || '0' }}
         run: |
           apk_file="android-retrace-apks/MobileGL-plugin-trace-release-${GITHUB_SHA}.apk"
           test -f "${apk_file}"

.github/workflows/test.yml

@@ -265,9 +265,6 @@ jobs:
         # crash stack without burning a CI round on an in-workflow debugger.
         env:
           MOBILEGL_ITEST_REQUIRE_GPU: "1"
-          MOBILEGL_FIX_ITERATIONRP_SUBGROUP_SCRATCH: "1"
-          MOBILEGL_DERIVE_NUM_SUBGROUPS: "1"
-          MOBILEGL_ITERATIONRP_FIX_BARRIER: "1"
         run: |
           ulimit -c unlimited
           sudo sysctl -w kernel.core_pattern='/tmp/core.%e.%p'
@@ -642,12 +639,6 @@ jobs:
           if [ '${{ matrix.backend }}' = 'DirectVulkan' ]; then
             export MOBILEGL_MAGMA_R11G11B10F_FALLBACK=1
           fi
-          if [ '${{ matrix.backend }}' = 'DirectVulkan' ] \
-             && [ '${{ matrix.case }}' = 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' ]; then
-            export MOBILEGL_FIX_ITERATIONRP_SUBGROUP_SCRATCH=1
-            export MOBILEGL_DERIVE_NUM_SUBGROUPS=1
-            export MOBILEGL_ITERATIONRP_FIX_BARRIER=1
-          fi
           # The blended depth-write quirk auto-enables only on Qualcomm, which no CI
           # runner has, so force it on for the OIT case it exists to fix. ForceOn
           # bypasses only the vendor gate, so this exercises the real strip on

.gitignore

@@ -27,4 +27,3 @@ MobileGL/MG*/cmake-build*
 tools/trace_replay/work/
 __pycache__/
 *.py[cod]
-/.gradle

CMakeLists.txt

@@ -285,7 +285,6 @@ set(SOURCE_FILES
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RebaseInstanceIndexPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/ZeroBaseVertexPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DeriveNumSubgroupsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FixIterationRPBarrierPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FixIterationRPSubgroupScratchPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EmulateSubgroupsPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/NormalizeRectCoordinatesPass.cpp
@@ -463,7 +462,7 @@ set(MOBILEGL_INCLUDE_DIR
         # Header-only submodule: no add_subdirectory, no link target. Only
         # MG_Util/Async/ShaderCompilePool.cpp includes it, and it stays behind that file's
         # pimpl so no consumer target needs this path.
-        ${CMAKE_SOURCE_DIR}/3rdparty/asio/include
+        ${CMAKE_SOURCE_DIR}/3rdparty/asio/asio/include
 )
 
 add_library(${CMAKE_PROJECT_NAME} SHARED
@@ -675,10 +674,3 @@ if (NOT ANDROID)
         add_subdirectory(tools/trace_replay)
     endif()
 endif()
-
-# The integration binary is also useful as a standalone adb-shell executable.
-# Android cannot use the desktop-only MobileGL_s target, so its CMake module
-# links libMobileGL.so and creates an AImageReader-backed window instead.
-if (ANDROID AND MOBILEGL_BUILD_INTEGRATION_TEST)
-    add_subdirectory(MobileGL/MG_IntegrationTest)
-endif()

MobileGL/Config.h

@@ -100,10 +100,6 @@ namespace MobileGL::MG_Config {
         // itself on >= 16-lane devices. Auto is ON; ForceOff replays the pack's bug
         // verbatim.
         QuirkOverride FixIterationRPSubgroupScratch = QuirkOverride::Auto;
-        // MOBILEGL_ITERATIONRP_FIX_BARRIER: repair Program 203's missing workgroup
-        // rendezvous between its two reductions over prefixSumCache. Off by default and
-        // fingerprint-gated by FixIterationRPBarrierPass when enabled.
-        Bool IterationRPFixBarrier = false;
         // MOBILEGL_DERIVE_NUM_SUBGROUPS: replace compute gl_NumSubgroups loads with
         // ceil(workgroup invocations / gl_SubgroupSize) on the NATIVE subgroup path
         // (ShaderTranspiler::DeriveNumSubgroupsPass). Auto is ON: GL requires

MobileGL/ConfigLoader.cpp

@@ -171,7 +171,6 @@ namespace MobileGL::MG_ConfigLoader {
         features.MagmaEmulateSubgroup = QueryEnvFlag("MOBILEGL_MAGMA_EMULATE_SUBGROUP");
         features.FixIterationRPSubgroupScratch =
             QueryEnvQuirkOverride("MOBILEGL_FIX_ITERATIONRP_SUBGROUP_SCRATCH");
-        features.IterationRPFixBarrier = QueryEnvFlag("MOBILEGL_ITERATIONRP_FIX_BARRIER");
         features.DeriveNumSubgroups = QueryEnvQuirkOverride("MOBILEGL_DERIVE_NUM_SUBGROUPS");
         features.AdvertiseFp64 = QueryEnvFlag("MOBILEGL_ADVERTISE_FP64");
         features.MagmaR11G11B10FFallback = QueryEnvFlag("MOBILEGL_MAGMA_R11G11B10F_FALLBACK");

MobileGL/Init.cpp

@@ -15,7 +15,6 @@
 #include <MG_Impl/GLImpl/Texture/ProxyTexture.h>
 #include <MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h>
 #include <MG_Impl/GLImpl/Sync/GL_Sync.h>
-#include <MG_Impl/GLImpl/Query/GL_Query.h>
 #include <MG_Util/Async/ShaderCompilePool.h>
 #include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
 
@@ -52,11 +51,6 @@ namespace MobileGL {
             // before a re-initialized library could pair them with the wrong
             // backend's DeleteSync).
             MG_Impl::GLImpl::DestroyAllSyncObjects();
-            // Queries die with their contexts for the same reason, and their registry
-            // is the same shape of process-global map: drain it here too, while the
-            // function table can still pair each backend handle with the backend that
-            // minted it.
-            MG_Impl::GLImpl::DestroyAllQueryObjects();
             MG_Backend::pActiveBackendObject.reset();
             MG_State::pGLContext.reset();
             MG_State::pEGLContext.reset();

MobileGL/MG_Backend/DirectGLES/DirectGLES.cpp

@@ -1431,7 +1431,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             g_fboSyncedSlotVersions[SizeT(target)] = slotVersion;
             g_fboSyncedObjectVersions[SizeT(target)] = objectVersion;
             g_fboSyncedObjects[SizeT(target)] = fbo;
-            g_fboSyncedBackendIdGenerations[SizeT(target)] = g_attachmentBackendIdGeneration;
         }
 
         void SyncCurrentFBO() {
@@ -1462,13 +1461,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 const Uint16 slotVersion = slot.GetVersion();
                 const Uint16 objectVersion = currentFBO ? currentFBO->GetObjectVersion() : 0;
                 auto* currentPtr = currentFBO.get();
-                // The backend-id generation joins the triple: a backend texture re-mint
-                // (RecreateBackendTexture) moves no frontend version, so without it the
-                // early-out would keep the driver FBO on the deleted texture name.
                 if (slotVersion == g_fboSyncedSlotVersions[SizeT(target)] &&
                     objectVersion == g_fboSyncedObjectVersions[SizeT(target)] &&
-                    currentPtr == g_fboSyncedObjects[SizeT(target)] &&
-                    g_fboSyncedBackendIdGenerations[SizeT(target)] == g_attachmentBackendIdGeneration) {
+                    currentPtr == g_fboSyncedObjects[SizeT(target)]) {
                     lastUpdatedFBO = currentPtr;
                     continue;
                 }
@@ -2134,15 +2129,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         static Bool g_broadcastMemoValid = false;
         static Uint g_broadcastMemoCount = 1;
 
-        // The identity+version key above is only monotonic WITHIN one GLContext: a
-        // library teardown + re-init frees every FramebufferObject and restarts the
-        // draw slot's counter at zero, so a recycled FBO address with coinciding
-        // fresh versions would false-hit. Cleared at the same boundaries as the
-        // structurally identical SyncCurrentFBO trio (InvalidateFramebufferBindingCache).
-        void InvalidateBroadcastMemo() {
-            g_broadcastMemoValid = false;
-        }
-
         void SyncCurrentProgram(const SharedPtr<MG_State::GLState::ProgramObject>& currentProgram) {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
@@ -2326,8 +2312,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         FramebufferImpl::g_fboSyncedSlotVersions[(SizeT)target] = slot.GetVersion();
         FramebufferImpl::g_fboSyncedObjectVersions[(SizeT)target] = fbo ? fbo->GetObjectVersion() : 0;
         FramebufferImpl::g_fboSyncedObjects[(SizeT)target] = fbo.get();
-        FramebufferImpl::g_fboSyncedBackendIdGenerations[(SizeT)target] =
-            FramebufferImpl::g_attachmentBackendIdGeneration;
     }
 
     static void BindCurrentProgramWithResources(
@@ -3966,19 +3950,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
         Bool resolved = g_GLESFuncs.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
         if (resolved) {
             DrainBlitErrors();
-            // A blit is scissored like a draw (the replicate path's guard documents the
-            // same rule): the application's box would clip this resolve into the
-            // scratch, and the second blit would then copy never-written scratch texels
-            // into the destination - silently, since scissor clipping raises no GL
-            // error. Disable for the staging blit only; the caller-visible blit below
-            // keeps the blit's native scissor semantics. Tracked via the render-state
-            // shadow, exactly like ScopedScissorDisable.
-            const Bool scissorWasEnabled =
-                (RenderStateImpl::g_syncedRenderStateParameters.ScissorTestEnabledMask & 1u) != 0;
-            if (scissorWasEnabled) g_GLESFuncs.glDisable(GL_SCISSOR_TEST);
             g_GLESFuncs.glBlitFramebuffer(left, bottom, right, top, 0, 0, width, height, GL_COLOR_BUFFER_BIT,
                                           GL_NEAREST);
-            if (scissorWasEnabled) g_GLESFuncs.glEnable(GL_SCISSOR_TEST);
             resolved = g_GLESFuncs.glGetError() == GL_NO_ERROR;
         }
         if (resolved) {
@@ -4124,25 +4097,13 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
             }
             // The per-draw-buffer colour masks are not covered by the non-indexed
-            // glColorMask above. Restore what the SYNC actually pushed, not the raw
-            // application masks: a widened attachment's alpha write is forced off by
-            // SyncRenderState and memoized in g_syncedColorMaskAlphaWidenMask, and the
-            // next sync early-outs on an unchanged version - restoring the undoctored
-            // mask here would leave alpha writes enabled on the widened buffer with
-            // nothing left to repair it. Same three-way pointer fallback as
-            // SyncRenderState's push: gating on the core name alone left EXT/OES-only
-            // devices holding buffer 0's mask broadcast across every buffer.
-            const auto colorMaskiFn = g_GLESFuncs.glColorMaski      ? g_GLESFuncs.glColorMaski
-                                      : g_GLESFuncs.glColorMaskiEXT ? g_GLESFuncs.glColorMaskiEXT
-                                                                    : g_GLESFuncs.glColorMaskiOES;
-            if (colorMaskiFn) {
+            // glColorMask above.
             for (Uint index = 0; index < MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS; ++index) {
-                    BoolVec4 colorMask = RenderStateImpl::g_syncedRenderStateParameters.ColorMasks[index];
-                    if (index < 32 && (RenderStateImpl::g_syncedColorMaskAlphaWidenMask & (1u << index)) != 0) {
-                        colorMask.w() = false;
-                    }
-                    colorMaskiFn(index, colorMask.x() ? GL_TRUE : GL_FALSE, colorMask.y() ? GL_TRUE : GL_FALSE,
-                                 colorMask.z() ? GL_TRUE : GL_FALSE, colorMask.w() ? GL_TRUE : GL_FALSE);
+                const BoolVec4& colorMask = RenderStateImpl::g_syncedRenderStateParameters.ColorMasks[index];
+                if (g_GLESFuncs.glColorMaski) {
+                    g_GLESFuncs.glColorMaski(index, colorMask.x() ? GL_TRUE : GL_FALSE,
+                                             colorMask.y() ? GL_TRUE : GL_FALSE, colorMask.z() ? GL_TRUE : GL_FALSE,
+                                             colorMask.w() ? GL_TRUE : GL_FALSE);
                 }
             }
             if (m_pausedTransformFeedback && g_GLESFuncs.glResumeTransformFeedback) {
@@ -8343,9 +8304,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // Conservatively drop the redundant-glUseProgram guard: re-issuing one bind
         // after a MakeCurrent is cheaper than trusting a possibly-reset context.
         PrgramImpl::g_lastUsedBackendProgramId = 0;
-        // The GLContext becoming current may be a fresh one whose slot versions
-        // restarted at zero; the broadcast memo's key is only monotonic within one.
-        PrgramImpl::InvalidateBroadcastMemo();
         BufferImpl::InvalidateIndexedBufferBindingCache();
         BufferImpl::InvalidatePixelBufferBindingCaches();
         FramebufferImpl::InvalidateFramebufferBindingCache();
@@ -8874,7 +8832,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         FramebufferImpl::InvalidateFramebufferBindingCache();
         VertexArrayImpl::InvalidateVAOBindingCache();
         PixelStoreImpl::InvalidatePackStateCache();
-        PrgramImpl::InvalidateBroadcastMemo();
         // Texture ids belong to the dying context; wrappers destroyed later must
         // not glDeleteTextures a recycled name in a successor context.
         ++g_backendContextGeneration;

MobileGL/MG_Backend/DirectGLES/Managers.cpp

@@ -577,9 +577,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 // immutable storage, and any prior mutable store is replaced anyway.
                 if (resource->id != 0) {
                     NoteBufferIdDeleted(resource->id);
-                    // Driver VAOs may have this id baked into attribute/element bindings
-                    // keyed on frontend versions this re-mint does not move.
-                    ++g_bufferBackendIdGeneration;
                     g_GLESFuncs.glDeleteBuffers(1, &resource->id);
                     resource->id = 0;
                     resource->immutableStorage = false;
@@ -836,10 +833,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             g_bufferMutationEpoch.fetch_add(1, std::memory_order_release);
         }
 
-        // See the declaration: re-mints of a live resource's driver id. Written only on
-        // the context thread (both re-mint sites run there), read only by the VAO sync.
-        Uint64 g_bufferBackendIdGeneration = 0;
-
         void RegisterBufferBackendOps() {
             MG_State::GLState::SetBufferBackendOps(&g_glesBufferBackendOps);
             // Frontend writes issued while ops were unregistered advanced change
@@ -967,9 +960,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             // here, on the thread that can, and the id is re-minted below.
             if (resource->immutableStorage && !resource->persistentMapped && resource->id != 0) {
                 NoteBufferIdDeleted(resource->id);
-                // Same as the persistent-map re-mint: the dying id may be baked into
-                // driver VAO bindings whose frontend versions do not move for this.
-                ++g_bufferBackendIdGeneration;
                 g_GLESFuncs.glDeleteBuffers(1, &resource->id);
                 resource->id = 0;
                 resource->immutableStorage = false;
@@ -1650,24 +1640,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             // PrepareForDraw's BindCurrentVAO establishes the draw binding regardless.
             const Uint32 currentConfigVersion = stateVAOObject->GetConfigVersion();
             const Uint16 currentIndexBufferVersion = stateVAOObject->GetIndexBufferBindingSlot().GetVersion();
-            // A live buffer's driver id was re-minted since this twin's last emit
-            // (persistent-map adoption / immutable-store retire): every baked binding may
-            // hold the dead id while every frontend version still matches, so force a
-            // full re-emit. Read once; each buffer re-mints at most once per walk (its
-            // first EnsureBufferResource this draw), before its id is baked, so stamping
-            // the entry value at the end is exact - and a stale stamp only costs one
-            // extra full emit.
-            const Uint64 currentBufferIdGeneration = BufferImpl::g_bufferBackendIdGeneration;
-            const Bool bufferIdsRemitted = m_syncedBufferIdGeneration != currentBufferIdGeneration;
-            const Bool attributesDirty =
-                bufferIdsRemitted || !m_hasSyncedConfigVersion || m_syncedConfigVersion != currentConfigVersion;
-            // Identity joins the version compare: the slot version is a wrapping Uint16,
-            // so a wrapped-back count with a different buffer bound must still read dirty.
-            const MG_State::GLState::BufferObject* currentIndexBufferObject =
-                stateVAOObject->GetIndexBufferBindingSlot().GetBoundObject().get();
-            const Bool indexBufferDirty = bufferIdsRemitted ||
-                                          currentIndexBufferVersion != m_syncedIndexBufferVersion ||
-                                          currentIndexBufferObject != m_syncedIndexBufferObject;
+            const Bool attributesDirty = !m_hasSyncedConfigVersion || m_syncedConfigVersion != currentConfigVersion;
+            const Bool indexBufferDirty = currentIndexBufferVersion != m_syncedIndexBufferVersion;
 
             // The baseInstance shift lives in the attribute offsets the driver already holds, so
             // a change of baseInstance has to re-emit the divisor'd arrays even when the frontend
@@ -1701,9 +1675,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     }
                 }
 
-                Bool needsSyncFormat = bufferIdsRemitted || allAttributeVersions[attribIndex].FormatVersion !=
+                Bool needsSyncFormat = allAttributeVersions[attribIndex].FormatVersion !=
                                        m_syncedAttributeVersions[attribIndex].FormatVersion;
-                Bool needsSyncBuffer = bufferIdsRemitted || allAttributeVersions[attribIndex].BufferVersion !=
+                Bool needsSyncBuffer = allAttributeVersions[attribIndex].BufferVersion !=
                                        m_syncedAttributeVersions[attribIndex].BufferVersion;
                 if (!needsSyncFormat && !needsSyncBuffer && !needsSyncBaseInstance) continue;
 
@@ -1824,7 +1798,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
                 if (indexBufferSynced) {
                     m_syncedIndexBufferVersion = currentIndexBufferVersion;
-                    m_syncedIndexBufferObject = currentIndexBufferObject;
                 }
             }
 
@@ -1836,7 +1809,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             if (emitAttributes) {
                 m_syncedFetchBaseInstance = fetchBaseInstance;
             }
-            m_syncedBufferIdGeneration = currentBufferIdGeneration;
         }
 
         void BackendVertexArrayObject::SyncClientSideAttributesForDrawArrays(
@@ -1974,11 +1946,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         void BackendTextureObject::RecreateBackendTexture() {
             if (m_backendTextureId != 0) {
                 ScratchFBOImpl::NoteTextureIdDeleted(m_backendTextureId);
-                // Application FBO twins that attached the dying id memoize on FRONTEND
-                // attachment versions, which this backend-side re-mint does not move;
-                // without this bump their driver FBOs would keep the deleted name
-                // attached forever (see g_attachmentBackendIdGeneration).
-                ++FramebufferImpl::g_attachmentBackendIdGeneration;
                 if (m_contextGeneration == g_backendContextGeneration) {
                     g_GLESFuncs.glDeleteTextures(1, &m_backendTextureId);
                 }
@@ -3550,9 +3517,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             m_backendReadBuffer = GL_NONE;
             std::fill(m_syncedFrontendAttachmentVersions.begin(), m_syncedFrontendAttachmentVersions.end(),
                       static_cast<Uint16>(~0u));
-            // Every attachment version is invalidated above, so the next walk re-attaches
-            // everything regardless; stamp the generation so it does not re-arm twice.
-            m_syncedBackendIdGeneration = g_attachmentBackendIdGeneration;
         }
 
         static Bool SyncAttachmentObject(GLenum glFBOTarget,
@@ -4041,15 +4005,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             }
 
             // -------------------- Attach texture to backend FBO -----------------------
-            // A backend texture id was re-minted since this twin's last walk
-            // (RecreateBackendTexture): any point here may still hold the dead id while
-            // its frontend attachment version is unchanged, so the memo below would skip
-            // exactly the attachment that needs repair. Re-arm every point first.
-            if (m_syncedBackendIdGeneration != g_attachmentBackendIdGeneration) {
-                std::fill(m_syncedFrontendAttachmentVersions.begin(), m_syncedFrontendAttachmentVersions.end(),
-                          static_cast<Uint16>(~0u));
-                m_syncedBackendIdGeneration = g_attachmentBackendIdGeneration;
-            }
             const auto& attachments = stateFBOObject->GetAllAttachmentObjects();
             const auto& attachmentVersions = stateFBOObject->GetAllFramebufferAttachmentVersions();
             for (SizeT i = 0; i < attachments.size(); ++i) {
@@ -4138,18 +4093,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
 #endif
             }
-
-            // The walk itself can re-mint an id (SyncAttachmentObject ->
-            // SyncMipmapsToBackend -> RecreateBackendTexture), invalidating points this
-            // walk already attached or version-skipped - e.g. one texture attached at two
-            // points. Re-enter until the generation is quiescent: every pass syncs each
-            // dirty texture clean, so each repeat finds strictly fewer re-mints and the
-            // common case (no re-mint) never takes a second pass. The head's draw/read-
-            // buffer syncs are memoized against their own shadows, so a repeat re-walks
-            // only the attachments.
-            if (m_syncedBackendIdGeneration != g_attachmentBackendIdGeneration) {
-                SyncToBackend(stateFBOObject, asTarget);
-            }
         }
 
         GLenum BackendFramebufferObject::GetBackendAttachmentType(FramebufferAttachmentType frontendAtt) const {
@@ -4176,8 +4119,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         Array<Uint16, SizeT(FramebufferTarget::FramebufferTargetCount)> g_fboSyncedObjectVersions = {0};
         Array<MG_State::GLState::FramebufferObject*, SizeT(FramebufferTarget::FramebufferTargetCount)>
             g_fboSyncedObjects = {};
-        Uint64 g_attachmentBackendIdGeneration = 0;
-        Array<Uint64, SizeT(FramebufferTarget::FramebufferTargetCount)> g_fboSyncedBackendIdGenerations = {0};
     } // namespace FramebufferImpl
 
     namespace ScratchFBOImpl {

MobileGL/MG_Backend/DirectGLES/Managers.h

@@ -346,14 +346,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // client-attribute staging buffers): scrub every buffer-binding shadow that
         // could false-skip when the name is recycled.
         void NoteBufferIdDeleted(Uint id);
-        // Bumped whenever a live GLESBufferResource's driver id is retired and re-minted
-        // while its frontend buffer stays alive (persistent-map adoption, immutable-store
-        // retire). The VAO twins' baked glVertexAttribPointer / element-array bindings
-        // key on FRONTEND versions, which a backend-side re-mint does not move - without
-        // this generation the driver VAO would keep fetching through the deleted id (or
-        // its retained store) forever. Compared and stamped by
-        // BackendVertexArrayObject::SyncToBackend.
-        extern Uint64 g_bufferBackendIdGeneration;
         // Redundant-bind cache for INDEXED buffer bindings (glBindBufferBase/Range on
         // GL_UNIFORM_BUFFER / GL_SHADER_STORAGE_BUFFER): skips the GL call when the
         // (id, range) already at that index matches, like the array-buffer/texture/
@@ -473,11 +465,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             Array<Uint, MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS> m_clientAttributeBufferIds;
             Bool m_isInitialized = false;
             Uint16 m_syncedIndexBufferVersion = 0;
-            // Identity of the buffer the version above was stamped against. Raw and never
-            // dereferenced: the slot version is a wrapping Uint16 (see the ResolvedDrawBuffers
-            // IBO memo and the packed_pixels postmortem at BindCurrentFBO), so the version
-            // alone would read a wrapped-back count with a different buffer bound as clean.
-            const MG_State::GLState::BufferObject* m_syncedIndexBufferObject = nullptr;
             // Aggregate gate over the per-attribute walk below: the frontend bumps its config
             // version on every per-attribute version bump (the three Bump*Version functions are
             // its only writers), so an unchanged config version proves every per-attribute
@@ -493,11 +480,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             // Kept here because it describes what was last EMITTED, which is what the next sync
             // has to correct.
             Uint32 m_syncedFetchBaseInstance = 0;
-            // BufferImpl::g_bufferBackendIdGeneration as of this twin's last emit. A
-            // mismatch means some live buffer's driver id was re-minted since; the ids
-            // baked into the driver VAO's attribute/element bindings may be dead even
-            // though every frontend version matches, so the next sync re-emits them all.
-            Uint64 m_syncedBufferIdGeneration = 0;
         };
 
         extern StateBackendObjectRegistry<MG_State::GLState::VertexArrayObject, BackendVertexArrayObject>
@@ -817,11 +799,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
             using FramebufferObject = MG_State::GLState::FramebufferObject;
             FramebufferObject::FramebufferAttachmentVersionArray m_syncedFrontendAttachmentVersions = {0};
-            // g_attachmentBackendIdGeneration as of this twin's last attachment walk. A
-            // mismatch means some backend texture id was re-minted since, and any of this
-            // twin's attachment points may still hold the dead id even though the frontend
-            // attachment versions match - so the walk re-attaches everything first.
-            Uint64 m_syncedBackendIdGeneration = 0;
         };
 
         extern StateBackendObjectRegistry<MG_State::GLState::FramebufferObject, BackendFramebufferObject>
@@ -911,19 +888,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         extern Array<MG_State::GLState::FramebufferObject*, SizeT(FramebufferTarget::FramebufferTargetCount)>
             g_fboSyncedObjects;
 
-        // Bumped whenever a live backend texture's driver id is re-minted while its
-        // frontend texture may still be attached to application FBOs
-        // (BackendTextureObject::RecreateBackendTexture - e.g. a respecify of a texture
-        // whose backend storage went immutable). The FBO twins' attachment memos key on
-        // FRONTEND attachment versions, which a backend-side re-mint does not move, so
-        // the driver FBO would keep the deleted texture name attached forever. The
-        // SyncCurrentFBO gate compares this generation (below) to re-enter the sync,
-        // and each twin re-arms its per-attachment memo on a mismatch (SyncToBackend).
-        extern Uint64 g_attachmentBackendIdGeneration;
-        // What g_attachmentBackendIdGeneration was when SyncCurrentFBO last stamped each
-        // target; part of the synced tuple above.
-        extern Array<Uint64, SizeT(FramebufferTarget::FramebufferTargetCount)> g_fboSyncedBackendIdGenerations;
-
         // Driver-level READ/DRAW framebuffer-binding shadow. Every backend
         // glBindFramebuffer routes through BindFramebufferId so scoped helpers can
         // save/restore the current binding without a glGetIntegerv round-trip (that

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.cpp

@@ -69,12 +69,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // slot's ownership unambiguous.
             Uint64 programLifetimeId = 0;
             Uint32 backendStateVersion = 0;
-            // glShaderStorageBlockBinding deliberately does NOT bump the backend state
-            // version, and the pipeline composite is unnamed so the in-place patch in
-            // DirectVulkan::ShaderStorageBlockBinding can never reach its slot - the
-            // mirror replay bumps only the program's block-binding version. Without this
-            // key the composite's slot kept serving the pre-rebind block.binding.
-            Uint32 blockBindingVersion = 0;
             Vector<StorageBlockResource> storageBlocks;
             Vector<BufferVariableResource> bufferVariables;
             GLint computeWorkGroupSize[3] = {1, 1, 1};
@@ -162,33 +156,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             auto& cache = g_programResourceCaches[program.GetExternalIndex()];
             const Uint64 programLifetimeId = program.GetLifetimeId();
             const Uint32 backendStateVersion = program.GetBackendStateVersion();
-            const Uint32 blockBindingVersion = program.GetBlockBindingVersion();
             // The lifetime id must match too: a new program that reuses a deleted
             // program's name and happens to land on the same backendStateVersion (both
             // count from zero) would otherwise be served the dead program's reflection.
             if (cache.programLifetimeId == programLifetimeId &&
                 cache.backendStateVersion == backendStateVersion &&
                 (!cache.storageBlocks.empty() || !cache.bufferVariables.empty())) {
-                if (cache.blockBindingVersion != blockBindingVersion) {
-                    // Only the block bindings moved (glShaderStorageBlockBinding, or the
-                    // pipeline composite's mirror replay - neither touches the backend
-                    // state version): the reflection itself is unchanged, so re-apply the
-                    // overrides by name instead of re-running spirv-reflect. Overrides
-                    // only ever accumulate, so a block without one still holds its
-                    // declared binding.
-                    for (auto& block : cache.storageBlocks) {
-                        const Int rebound = program.GetShaderStorageBlockBindingOverride(block.name);
-                        if (rebound >= 0) block.binding = static_cast<Uint32>(rebound);
-                    }
-                    cache.blockBindingVersion = blockBindingVersion;
-                }
                 return cache;
             }
 
             cache = {};
             cache.programLifetimeId = programLifetimeId;
             cache.backendStateVersion = backendStateVersion;
-            cache.blockBindingVersion = blockBindingVersion;
 
             Vector<SpvReflectShaderModule> modules;
             Vector<Bool> validModules;

MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.cpp

@@ -3190,25 +3190,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
 
             // GL_KHR_shader_subgroup handling (SubgroupSupportPolicy.h). Native subgroup
-            // operations execute natively; module repairs keep the GL contract intact
+            // operations execute natively; two module repairs keep the GL contract intact
             // around them. The opt-in emulation path replaces them only on devices with no
             // subgroup support at all (MOBILEGL_MAGMA_EMULATE_SUBGROUP).
             if (shaders[i] && shaders[i]->GetShaderStage() == ShaderStage::Compute) {
-                // Program 203 broadcasts the first reduction through
-                // prefixSumCache[0], then lets the second reduction overwrite that
-                // scratch without first rendezvousing all readers. Patch that exact
-                // fingerprint before either native or emulated subgroup lowering.
-                if (m_subgroupPolicy.fixIterationRPBarrier) {
-                    Vector<Uint> patchedSpirv;
-                    if (MG_Util::ShaderTranspiler::ShaderCompiler::FixIterationRPBarrierForVulkan(
-                            moduleSpirvs[i], patchedSpirv, enableSpirvValidation)) {
-                        moduleSpirvs[i] = std::move(patchedSpirv);
-                    } else {
-                        MGLOG_E("ProgramFactory: iterationRP barrier patch failed for program %u; "
-                                "Program 203 keeps its shared-scratch race",
-                                program.GetExternalIndex());
-                    }
-                }
                 if (m_subgroupPolicy.emulateSubgroups) {
                     Vector<Uint> emulatedSpirv;
                     if (MG_Util::ShaderTranspiler::ShaderCompiler::EmulateSubgroupsForVulkan(

MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.h

@@ -381,7 +381,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         struct SubgroupLoweringPolicy {
             Bool emulateSubgroups = false;      // MOBILEGL_MAGMA_EMULATE_SUBGROUP, no-native-support devices
             Bool fixIterationRPSubgroupScratch = false; // patch iterationRP's under-declared scratch
-            Bool fixIterationRPBarrier = false; // repair Program 203's shared-scratch race
             Bool deriveNumSubgroups = false;    // repair the NumSubgroups builtin
             Bool requireFullSubgroups = false;  // computeFullSubgroups enabled on the device
             Uint32 nativeSubgroupSize = 0;

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.cpp

@@ -287,10 +287,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             if (m_frameBoundaryCounter - it->second->lastUsedFrameBoundary > kRetireAgeBoundaries) {
                 it = m_cache.erase(it);
                 // Invalidate every VAO's state-pointer memo: the erased node's
-                // address may be reused by a future insert. Advance through the
-                // process-wide source so the value stays unique across factory
-                // instances (see the member comment).
-                m_evictionEpoch = ++s_evictionEpochSource;
+                // address may be reused by a future insert.
+                ++m_evictionEpoch;
             } else {
                 ++it;
             }

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.h

@@ -125,17 +125,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // construction); a memo is honored only while its recorded epoch
         // matches, so an evicted entry can never be dereferenced through a
         // stale memo.
-        //
-        // Drawn from a process-wide source, never a per-instance counter: the VAO
-        // memos outlive this factory (they live on pGLContext's VAOs, the renderer
-        // is destroyed and recreated on EGL surface release/re-create), so a fresh
-        // factory restarting at a dead factory's epoch value would honor its
-        // dangling entry pointers. The constructor takes a value strictly greater
-        // than anything a predecessor ever stamped, so a dead factory's memo can
-        // never compare equal here - the same never-reused idiom as the lifetime ids.
-        // Single-threaded like the rest of the factory (renderer-thread only).
-        static inline Uint64 s_evictionEpochSource = 0;
-        Uint64 m_evictionEpoch = ++s_evictionEpochSource;
+        Uint64 m_evictionEpoch = 1;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.cpp

@@ -166,15 +166,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void VkClearManager::MergeClearPayload(ClearAttachmentPayload& dst, const ClearAttachmentPayload& src) {
         dst.mask |= src.mask;
         if ((src.mask & GL_COLOR_BUFFER_BIT) != 0) {
-            // The whole colour story travels together (same rule as
-            // VkRenderPassManager::QueueRenderbufferClear): a glClearBufferiv/uiv
-            // payload carries its value in colorInt/colorUint and its branch selector
-            // in colorEncoding - dropping them here would leave the pending clear
-            // reading as an all-zero float one.
             dst.color = src.color;
-            dst.colorEncoding = src.colorEncoding;
-            dst.colorInt = src.colorInt;
-            dst.colorUint = src.colorUint;
         }
         if ((src.mask & GL_DEPTH_BUFFER_BIT) != 0) {
             dst.depth = src.depth;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.cpp

@@ -831,7 +831,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // recreated since (texture + renderbuffer image epochs), and no pending clear (which alters
         // load ops). Any of these differing forces the full recompute below. Portable to VK 1.1.
         if (activeRenderPass != nullptr && m_rpFastValid && m_rpFastFbo == &fbo &&
-            m_rpFastFboLifetimeId == fbo.GetLifetimeId() &&
             m_rpFastFboVersion == fbo.GetObjectVersion() && m_rpFastSwapchainIndex == swapchainImageIndex &&
             m_rpFastTexEpoch == m_textureManager.GetTextureImageEpoch() &&
             m_rpFastRbEpoch == m_renderbufferImageEpoch &&
@@ -856,7 +855,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // epochs AFTER ComputeHash: its attachment SyncTexture can create an image (bump the epoch).
             m_rpFastValid = true;
             m_rpFastFbo = &fbo;
-            m_rpFastFboLifetimeId = fbo.GetLifetimeId();
             m_rpFastFboVersion = fbo.GetObjectVersion();
             m_rpFastSwapchainIndex = swapchainImageIndex;
             m_rpFastTexEpoch = m_textureManager.GetTextureImageEpoch();
@@ -1509,23 +1507,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             ClearAttachmentPayload clearPayload{};
             SharedPtr<MG_State::GLState::ITextureObject> liveTexture;
             if (pending.hasInlinePayload) {
-                // The inline payload was snapshotted when the entry was CREATED, but the
-                // clear VALUE is not part of the entry's hash - a cache hit with a newer
-                // glClear would replay the creation-time value and drop the new one (the
-                // texture path below is immune because it re-reads the live payload).
-                // Same defense as ClearAttachmentsOnActiveRenderPass: prefer the live
-                // pending clear, fall back to the snapshot only when none is queued.
-                if (s_renderPassManager != nullptr &&
-                    s_renderPassManager->GetPendingRenderbufferClear(pending.renderbuffer, clearPayload)) {
-                    if ((clearPayload.mask & GL_COLOR_BUFFER_BIT) != 0 && pending.renderbuffer != nullptr &&
-                        MG_Util::GetBaseInternalFormatComponentCount(pending.renderbuffer->GetInternalFormat()) ==
-                            3) {
-                        // RGB renderbuffers are backed by an RGBA image; the missing alpha reads as 1.
-                        ForceOpaqueClearAlpha(clearPayload);
-                    }
-                } else {
                 clearPayload = pending.inlinePayload;
-                }
             } else {
                 if (pending.key.texture == nullptr ||
                     !s_clearManager->GetPendingClear(pending.key, clearPayload, liveTexture)) {

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.h

@@ -289,11 +289,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // or a pending clear. Portable to Vulkan 1.1 (no dynamic_rendering / imageless FB needed).
         Bool m_rpFastValid = false;
         const MG_State::GLState::FramebufferObject* m_rpFastFbo = nullptr;
-        // The FBO's never-reused lifetime id joins the raw pointer + Uint16 version:
-        // a deleted FBO reallocated at the same address whose fresh setup performed
-        // the same number of version bumps would otherwise compare equal (both count
-        // from 0), serving the dead framebuffer's pass to the new object.
-        Uint64 m_rpFastFboLifetimeId = 0;
         Uint16 m_rpFastFboVersion = 0;
         Uint32 m_rpFastSwapchainIndex = 0;
         Uint64 m_rpFastTexEpoch = 0;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.cpp

@@ -1993,13 +1993,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         texture.GetExternalIndex(),
                         MG_Util::ConvertTextureUploadTargetToString(uploadTarget).c_str(),
                         static_cast<Int>(format), static_cast<Uint32>(imageInfo.usage));
-                // The preserved image was written by GPU work that may still be in flight
-                // (preserve requires layout != UNDEFINED); park it on the deferred ring
-                // like every other destruction path instead of letting the unique_ptr
-                // destroy it synchronously under the GPU.
-                if (preservedResource) {
-                    DeferResourceRelease(Move(*preservedResource));
-                }
                 return false;
             }
         }
@@ -2022,12 +2015,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     static_cast<Int>(imageInfo.samples), static_cast<Int>(imageInfo.format));
             resource.image = VK_NULL_HANDLE;
             resource.allocation = nullptr;
-            // Same as the probe failure above: the preserved live image must go through
-            // the deferred ring, never a synchronous destructor while frames that
-            // reference it are still in flight.
-            if (preservedResource) {
-                DeferResourceRelease(Move(*preservedResource));
-            }
             return false;
         }
         ++m_textureImageEpoch; // a new attachment image invalidates cached render passes

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.cpp

@@ -3063,7 +3063,6 @@ void main() {
         subgroupPolicy.emulateSubgroups = ShouldEmulateSubgroups(m_nativeSubgroupSupported);
         subgroupPolicy.fixIterationRPSubgroupScratch =
             m_nativeSubgroupSupported && ShouldFixIterationRPSubgroupScratch();
-        subgroupPolicy.fixIterationRPBarrier = ShouldFixIterationRPBarrier();
         subgroupPolicy.deriveNumSubgroups =
             m_nativeSubgroupSupported && ShouldDeriveNumSubgroups();
         subgroupPolicy.requireFullSubgroups = m_computeFullSubgroupsFeatureEnabled;
@@ -3324,11 +3323,6 @@ void main() {
                 indexView.indexByteSize > bufferSize - indexView.indexByteOffset) {
                 return false;
             }
-            // Recorded-but-unexecuted GPU writes (XFB capture, SSBO, storage texel
-            // buffer) land in the coherent mapping this scan is about to read;
-            // submit-and-wait first, exactly like the restart-index rewrite does.
-            // A no-op unless the gpu-write flag is set.
-            indexBufferShared->SyncGpuWrites();
             indexBufferShared->SyncPersistentMappedRange();
             indexBytes = indexBufferShared->MappedData() + indexView.indexByteOffset;
         } else {
@@ -3566,16 +3560,6 @@ void main() {
                                          const Uint8* sourceData, SizeT sourceStride,
                                          SizeT elementSize, SizeT elementCount,
                                          BufferSlice& outSlice) -> Bool {
-            // A resolved stride of 0 is the binding model's "never advance" (see the
-            // factory's layout notes): exactly one element is converted and every vertex
-            // reads it. That single element is read at offset 0, so the stride is never
-            // actually used - but both converters reject 0 as a degenerate input, which
-            // made the documented single-element conversion unreachable and silently
-            // dropped every draw using such a binding. Substitute the element's own
-            // size; the caller's cache key still carries the distinct stride 0.
-            if (sourceStride == 0 && elementCount == 1) {
-                sourceStride = elementSize;
-            }
             const void* uploadData = nullptr;
             VkDeviceSize uploadSize = 0;
             switch (conversion) {
@@ -3709,12 +3693,6 @@ void main() {
                     return false;
                 }
 
-                // A GPU-written source (XFB capture, SSBO, storage texel buffer) has its
-                // bytes produced by commands that are merely RECORDED at this point, and
-                // MappedData() aliases the coherent GPU memory they will write into -
-                // converting now would read pre-write garbage. Submit-and-wait first,
-                // mirroring the restart-index rewrite; a flag-test no-op otherwise.
-                sourceBufferShared->SyncGpuWrites();
                 sourceBufferShared->SyncPersistentMappedRange();
                 const SizeT availableElementCount =
                     sourceStride == 0 ? 1 : 1 + (sourceSize - baseOffset - elementSize) / sourceStride;
@@ -4008,7 +3986,7 @@ void main() {
             // Skips the per-draw GetBackendResource chase into a cold resource object.
             Bool sliceStillValid = false;
             const Uint64 frameSerial = m_bufferManager.GetFrameSerial();
-            if (indexMemo->indexFrameSerial == frameSerial && !indexMemo->indexBufferMapped &&
+            if (indexMemo->indexFrameSerial == frameSerial &&
                 indexMemo->indexSliceEpochCounter == m_bufferManager.GetSliceEpochCounter()) {
                 sliceStillValid = true;
             }
@@ -4071,9 +4049,6 @@ void main() {
                 indexMemo->indexVkBuffer = slice.buffer;
                 indexMemo->indexSliceOffset = slice.offset;
                 indexMemo->indexFrameSerial = m_bufferManager.GetFrameSerial();
-                // A host-mapped EBO can mutate its shadow with no epoch bump; the hit
-                // path declines on this flag (mirror of anyBufferMapped).
-                indexMemo->indexBufferMapped = indexBufferShared->IsMapped();
             }
         }
         const VkDeviceSize indexBindOffset =
@@ -5743,22 +5718,6 @@ void main() {
         if (program.GetBackendStateVersion() != snap.programVersion) {
             return false;
         }
-        // glBegin/EndTransformFeedback moves no key this fast path otherwise observes
-        // (the design makes capture a compile-option FLAG precisely because no version
-        // bumps, VulkanRenderer.h's pipeline-memo note) - but the snapshot bakes that
-        // flag into resolvedTransformFlags and the pipeline. Recompute the one dynamic
-        // bit (the full path's exact predicate) and decline on a mismatch, or the first
-        // captured draw after glBeginTransformFeedback would bind the undecorated
-        // variant and silently capture nothing while the CPU bookkeeping advances.
-        const Bool wantsXfbCapture = m_transformFeedbackFeatureEnabled &&
-                                     MG_State::pGLContext->IsTransformFeedbackActive() &&
-                                     program.GetTransformFeedbackVaryingCount() > 0;
-        const Bool snapHasXfbCapture =
-            static_cast<Bool>(ProgramFactory::CompileOptionFlags(snap.resolvedTransformFlags) &
-                              ProgramFactory::CompileOptionBit::XfbCapture);
-        if (wantsXfbCapture != snapHasXfbCapture) {
-            return false;
-        }
         // A changed VAO does NOT decline: the VAO only feeds the pipeline's vertex
         // input state (re-resolved below through the layout-keyed memo, so N VAOs
         // sharing one attribute layout share one pipeline) and the vertex/index
@@ -5772,7 +5731,6 @@ void main() {
         const auto& drawFbo =
             MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Draw).GetBoundObject();
         if (static_cast<const void*>(drawFbo.get()) != snap.drawFbo ||
-            drawFbo->GetLifetimeId() != snap.drawFboLifetimeId ||
             drawFbo->GetObjectVersion() != snap.fboVersion) {
             return false;
         }
@@ -5956,14 +5914,8 @@ void main() {
         }
         const Uint64 samplingResolutionGeneration = MG_State::pGLContext->GetSamplingResolutionGeneration();
         if (samplingResolutionGeneration != snap.samplingResolutionGeneration) {
-            // Decline, not re-arm: snap.resolvedTransformFlags bakes the
-            // ExplicitLod0Sampling verdict, which reads the effective sampler's
-            // filters/aniso/LOD range - exactly the state this counter tracks.
-            // Re-arming the stamp here would rebuild the descriptors but keep the
-            // stale SPIR-V variant forever (every later draw compares equal again).
-            // Same shape as the erase-epoch declines above; costs one full-path draw
-            // per sampler/shape change, and the full path's LOD memo re-probes.
-            return false;
+            snap.samplingResolutionGeneration = samplingResolutionGeneration;
+            samplerDescriptorsUnchanged = false;
         }
 
         // Everything the full path would re-resolve is provably unchanged - or, for
@@ -6143,18 +6095,11 @@ void main() {
             const Uint64 lodProgramLifetimeId = program.GetLifetimeId();
             const Uint32 lodProgramVersion = program.GetBackendStateVersion();
             const Uint64 lodBindGeneration = MG_State::pGLContext->GetTextureBindGeneration();
-            // The probe also reads the EFFECTIVE sampler's filters/aniso/LOD range
-            // (ProgramSamplesOnlySingleLevelTextures), and those setters bump ONLY the
-            // sampling-resolution generation - not the texture params version the sum
-            // below covers. Without this key a filter/aniso change would keep serving
-            // the stale verdict.
-            const Uint64 lodSamplingGeneration = MG_State::pGLContext->GetSamplingResolutionGeneration();
             Bool lodMemoHit = false;
             if (m_lastLodDecisionValid && m_lastSampledSetValid &&
                 m_lastLodProgramLifetimeId == lodProgramLifetimeId &&
                 m_lastLodProgramVersion == lodProgramVersion &&
-                m_lastLodBindGeneration == lodBindGeneration &&
-                m_lastLodSamplingGeneration == lodSamplingGeneration && m_lastLodBaseFlags == transformFlags &&
+                m_lastLodBindGeneration == lodBindGeneration && m_lastLodBaseFlags == transformFlags &&
                 m_lastSampledSetProgramLifetimeId == lodProgramLifetimeId &&
                 m_lastSampledSetProgramVersion == lodProgramVersion &&
                 m_lastSampledSetBindGeneration == lodBindGeneration) {
@@ -6179,7 +6124,6 @@ void main() {
                 m_lastLodProgramLifetimeId = lodProgramLifetimeId;
                 m_lastLodProgramVersion = lodProgramVersion;
                 m_lastLodBindGeneration = lodBindGeneration;
-                m_lastLodSamplingGeneration = lodSamplingGeneration;
                 m_lastLodBaseFlags = baseFlags;
                 m_lastLodResultFlags = transformFlags;
                 m_lastLodParamsSum = 0;  // filled below once the sampled set is known
@@ -6523,7 +6467,6 @@ void main() {
                 snap.vaoLifetimeId = vao.GetLifetimeId();
                 snap.vaoConfigVersion = vao.GetConfigVersion();
                 snap.drawFbo = drawFbo.get();
-                snap.drawFboLifetimeId = drawFbo->GetLifetimeId();
                 snap.fboVersion = drawFbo->GetObjectVersion();
                 snap.drawFboIsDefault = drawFboIsDefault;
                 snap.viewportCount = ResolveDrawViewportCount(programObj.writesViewportIndexBuiltin);
@@ -13882,15 +13825,6 @@ void main() {
         VkPipeline pipeline = VK_NULL_HANDLE;
         VK_VERIFY(vkCreateComputePipelines(m_device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &pipeline),
                   "GetOrCreateComputePipeline, vkCreateComputePipelines");
-        // A failed creation must never be memoized - same contract as
-        // PipelineFactory::GetOrCreatePipeline: caching the null would serve it back
-        // for the rest of the process and every dispatch of this program would be
-        // silently skipped. Retrying costs one failed vkCreateComputePipelines per
-        // dispatch, which is the correct price.
-        if (pipeline == VK_NULL_HANDLE) {
-            MGLOG_E("GetOrCreateComputePipeline: vkCreateComputePipelines failed; not caching the failure");
-            return VK_NULL_HANDLE;
-        }
         m_computePipelines.emplace(programObj.hash, pipeline);
         return pipeline;
     }

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.h

@@ -807,10 +807,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint32 m_lastLodProgramVersion = 0;
         Uint64 m_lastLodBindGeneration = 0;
         Uint64 m_lastLodParamsSum = 0;
-        // Sampling-resolution generation at probe time. The probe reads the effective
-        // sampler's filters/aniso/LOD range, whose setters bump only this counter -
-        // the params-version sum above never moves for them.
-        Uint64 m_lastLodSamplingGeneration = 0;
         ProgramFactory::CompileOptionFlags m_lastLodBaseFlags = {};
         ProgramFactory::CompileOptionFlags m_lastLodResultFlags = {};
 
@@ -848,11 +844,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint64 vaoLifetimeId = 0;
             Uint32 vaoConfigVersion = 0;
             const void* drawFbo = nullptr;
-            // Never-reused lifetime id beside the raw pointer + Uint16 version: a
-            // deleted FBO recycled at the same address with the same fresh version
-            // count would otherwise compare equal (same ABA as the render-pass
-            // manager's fast-path memo).
-            Uint64 drawFboLifetimeId = 0;
             Uint16 fboVersion = 0;
             Bool drawFboIsDefault = false;
             Uint renderStateVersion = 0;
@@ -1076,14 +1067,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkBuffer indexVkBuffer = VK_NULL_HANDLE;
             VkDeviceSize indexSliceOffset = 0;
             Uint64 indexFrameSerial = 0;
-            // The EBO carried a host map when the slice was recorded - the mirror of
-            // anyBufferMapped on the vertex half. A shadow-backed (non-adopted)
-            // persistent map mutates its shadow with no API call and no epoch bump, so
-            // the one-compare rescue must decline and re-run the acquire, whose
-            // SyncPersistentMappedRange is the push-down. A map taken AFTER the record
-            // is already covered: AcquirePersistentMap bumps the slice epoch for the
-            // request itself, adopted or declined.
-            Bool indexBufferMapped = false;
 
             // Bound per draw (first bindingCount elements).
             VkBuffer vkBuffers[kMaxBindings] = {};

MobileGL/MG_Backend/DirectVulkan/SubgroupSupportPolicy.h

@@ -18,11 +18,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     //
     // Native subgroups are the implementation whenever the device has them, whatever
     // their width - subgroup operations execute on the hardware paths they were made
-    // for. Module-level repairs keep the GL contract intact around them:
+    // for. Two module-level repairs keep the GL contract intact around them:
     //   - FixIterationRPSubgroupScratchPass patches the one known pack bug: iterationRP's
     //     prefixSumCache[32], under-declared for sub-16-lane devices (8-lane lavapipe);
-    //   - FixIterationRPBarrierPass repairs Program 203's race between two reductions
-    //     reusing that scratch, when explicitly enabled;
     //   - DeriveNumSubgroupsPass replaces the one builtin drivers get wrong
     //     (gl_NumSubgroups) with the value the rest of the topology implies.
     // The 32-lane shared-memory emulation (EmulateSubgroupsPass) is a LAST RESORT for
@@ -49,10 +47,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                MG_Config::QuirkOverride::ForceOff;
     }
 
-    inline Bool ShouldFixIterationRPBarrier() {
-        return MG_Config::Features.IterationRPFixBarrier;
-    }
-
     inline Bool ShouldDeriveNumSubgroups() {
         // Auto is ON: gl_NumSubgroups must agree with the gl_SubgroupID range for the GL
         // contract to hold, and the derived ceil() value is the one the renderer can pin

MobileGL/MG_Impl/GLImpl/Program/GL_Program.cpp

@@ -1057,20 +1057,21 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
-        // Read fresh every link, never latched in a static: the capability is
-        // per-backend, and a latch would freeze it across a backend teardown +
-        // re-initialization (the previous function-static memo here never even set
-        // its own initialized flag, so it re-read every call anyway - this makes
-        // the always-fresh behavior the stated one). A struct-field read per
-        // glLinkProgram costs nothing.
+        static Bool allowVSOnlyPrograms;
+        static Bool initialized = false;
+        if (!initialized) {
             const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
             if (!activeBackendObject) {
                 MGLOG_E_ONCE("activeBackendObject is not initialized!");
                 return;
             }
-        const Bool allowVSOnlyPrograms =
-            activeBackendObject->GetRendererInfo().StaticBackendCapability.AllowVSOnlyPrograms;
+            const auto& rendererInfo = activeBackendObject->GetRendererInfo();
+            allowVSOnlyPrograms = (Int)rendererInfo.StaticBackendCapability.AllowVSOnlyPrograms;
+        }
+        const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
+        if (activeBackendObject) {
             programObject->SetMaxFragmentOutputColorNumber(activeBackendObject->GetDynamicParameters().MaxDrawBuffers);
+        }
         programObject->Link(!allowVSOnlyPrograms);
     }
 

MobileGL/MG_Impl/GLImpl/Query/GL_Query.cpp

@@ -648,39 +648,4 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!ValidateQueryStreamIndex(__FUNCTION__, target, index)) return;
         GetQueryiv(target, pname, params);
     }
-
-    void DestroyAllQueryObjects() {
-        // Detach the registry under the lock, release outside it - same discipline
-        // (and the same accepted teardown race) as DestroyAllSyncObjects. Without
-        // this drain, every query the app left undeleted survived full library
-        // teardown in the process-global registry: the objects and their backend
-        // wrappers leaked across Destroy/Initialize cycles, stale ids kept
-        // answering IsQuery == GL_TRUE in the re-initialized library, and a later
-        // glDeleteQueries could hand the OLD backend's handle to a DIFFERENT
-        // backend's DeleteBackendQuery, which casts it to the wrong wrapper type.
-        UnorderedMap<GLuint, QueryObject*> orphans;
-        {
-            const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
-            orphans.swap(g_liveQueryObjects);
-            g_activeTimeElapsedQueryId = 0;
-            g_activePrimitivesWrittenQueryId = 0;
-            g_activePrimitivesGeneratedQueryId = 0;
-            g_activeSamplesPassedQueryId = 0;
-        }
-        if (orphans.empty()) {
-            return;
-        }
-        // Backend handles must be released by the backend that created them, so
-        // this runs while the function table is still populated. Both backends'
-        // DeleteBackendQuery are generation-guarded, so a handle whose renderer
-        // or ES context is already gone frees only the wrapper.
-        const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery;
-        for (const auto& [_, queryObject] : orphans) {
-            if (deleteBackendQuery && queryObject->backendHandle) {
-                deleteBackendQuery(queryObject->backendHandle);
-            }
-            delete queryObject;
-        }
-        MGLOG_D("DestroyAllQueryObjects: reclaimed %zu query object(s) the app left undeleted", orphans.size());
-    }
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Query/GL_Query.h

@@ -29,13 +29,4 @@ namespace MobileGL::MG_Impl::GLImpl {
     void GetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
     void GetQueryBufferObjectui64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
     void QueryCounter(GLuint id, GLenum target);
-    // Destroys every still-registered query object exactly as DeleteQueries would.
-    // GL requires queries to die with their context; called only from full library
-    // teardown (DestroyImpl), where no context survives on any thread, so the
-    // process-global registry can be drained wholesale. Must run while the backend
-    // function table is still populated: each backend handle has to be released by
-    // the backend that created it, never by a later re-initialized one (whose
-    // DeleteBackendQuery would cast the wrapper to the wrong backend's type).
-    // Same contract as DestroyAllSyncObjects.
-    void DestroyAllQueryObjects();
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_IntegrationTest/CMakeLists.txt

@@ -24,14 +24,9 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(MGL_ITEST_ROOT ${CMAKE_CURRENT_LIST_DIR}/../..)
 
-# Desktop links the static implementation directly. Android runs the same
-# executable from adb shell and links the shipping shared library instead.
-if (ANDROID)
-    set(MGL_ITEST_MOBILEGL_TARGET MobileGL)
-elseif (TARGET MobileGL_s)
-    set(MGL_ITEST_MOBILEGL_TARGET MobileGL_s)
-else()
-    message(STATUS "No MobileGL library target is available; skipping the integration test module")
+# Only meaningful where MobileGL_s exists (i.e. not Android).
+if (NOT TARGET MobileGL_s)
+    message(STATUS "MobileGL_s is not available; skipping the integration test module")
     return()
 endif()
 
@@ -74,7 +69,6 @@ add_executable(MobileGLIntegrationTest
     Scenarios/UniformInitializerScenario.cpp
     Scenarios/SwizzleAccessRoutineScenario.cpp
     Scenarios/IterationRPFirstReductionScenario.cpp
-    Scenarios/IterationRPProgram203Scenario.cpp
     Scenarios/IterationRPScratchFixScenario.cpp
     Scenarios/ProgramPipelineScenario.cpp
     Scenarios/ImageLoadStoreSsoScenario.cpp
@@ -100,20 +94,9 @@ target_include_directories(MobileGLIntegrationTest PRIVATE
 # gtest, not gtest_main: Main.cpp installs the harness banner itself.
 target_link_libraries(MobileGLIntegrationTest PRIVATE
     GTest::gtest
-    ${MGL_ITEST_MOBILEGL_TARGET}
+    MobileGL_s
 )
 
-if (ANDROID)
-    find_library(MGL_ITEST_ANDROID_LIBRARY android REQUIRED)
-    find_library(MGL_ITEST_LOG_LIBRARY log REQUIRED)
-    find_library(MGL_ITEST_MEDIANDK_LIBRARY mediandk REQUIRED)
-    target_link_libraries(MobileGLIntegrationTest PRIVATE
-        ${MGL_ITEST_ANDROID_LIBRARY}
-        ${MGL_ITEST_LOG_LIBRARY}
-        ${MGL_ITEST_MEDIANDK_LIBRARY}
-    )
-endif()
-
 if (MSVC)
     # Same reason as MG_Test/Backend/DirectVulkan: the GLES headers declare gl*
     # as dllimport on Windows, so the in-library GL entry-point definitions only
@@ -122,10 +105,6 @@ if (MSVC)
 endif()
 target_compile_definitions(MobileGLIntegrationTest PRIVATE -DNOMINMAX)
 
-if (ANDROID)
-    return()
-endif()
-
 # --- ctest wiring --------------------------------------------------------
 # A bare libEGL on a glvnd box resolves to whatever vendor comes first, which is
 # usually Mesa/llvmpipe - a software rasteriser silently replacing the GPU under

MobileGL/MG_IntegrationTest/Harness/HeadlessGL.cpp

@@ -18,11 +18,6 @@
 #if defined(_WIN32)
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
-#elif defined(__ANDROID__)
-#include <android/hardware_buffer.h>
-#include <android/native_window.h>
-#include <media/NdkImage.h>
-#include <media/NdkImageReader.h>
 #endif
 
 // MobileGL's own headers, in the order MobileGL/Includes.h uses them: GL/gl.h
@@ -42,7 +37,7 @@
 // the only construction that is actually predictive here: MobileGL ABORTS
 // (MOBILEGL_ASSERT -> SIGTRAP) rather than returning an error on an unusable
 // platform, so nothing the parent can call in-process is allowed to be wrong.
-#if !defined(_WIN32) && !defined(__APPLE__) && !defined(__ANDROID__) && __has_include(<sys/wait.h>)
+#if !defined(_WIN32) && !defined(__APPLE__) && __has_include(<sys/wait.h>)
 #define MGITEST_HAVE_FORK_PREFLIGHT 1
 #include <csignal>
 #include <ctime>
@@ -83,58 +78,12 @@ namespace MGITest {
                                    CW_USEDEFAULT, CW_USEDEFAULT, kSurfaceWidth, kSurfaceHeight, nullptr, nullptr,
                                    GetModuleHandleW(nullptr), nullptr);
         }
-#elif defined(__ANDROID__)
-        AImageReader* g_imageReader = nullptr;
-        ANativeWindow* g_imageReaderWindow = nullptr;
-
-        void DrainImageReader(void*, AImageReader* reader) {
-            AImage* image = nullptr;
-            if (AImageReader_acquireNextImage(reader, &image) == AMEDIA_OK && image != nullptr) {
-                AImage_delete(image);
-            }
-        }
-
-        bool CreateImageReaderWindow() {
-            if (g_imageReaderWindow != nullptr) return true;
-            constexpr int kMaxImages = 4;
-            const media_status_t status = AImageReader_newWithUsage(
-                kSurfaceWidth, kSurfaceHeight, AIMAGE_FORMAT_RGBA_8888,
-                AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT,
-                kMaxImages, &g_imageReader);
-            if (status != AMEDIA_OK || g_imageReader == nullptr) return false;
-
-            AImageReader_ImageListener listener = {nullptr, DrainImageReader};
-            AImageReader_setImageListener(g_imageReader, &listener);
-            if (AImageReader_getWindow(g_imageReader, &g_imageReaderWindow) != AMEDIA_OK ||
-                g_imageReaderWindow == nullptr) {
-                AImageReader_setImageListener(g_imageReader, nullptr);
-                AImageReader_delete(g_imageReader);
-                g_imageReader = nullptr;
-                return false;
-            }
-            ANativeWindow_acquire(g_imageReaderWindow);
-            return true;
-        }
-
-        void DestroyImageReaderWindow() {
-            if (g_imageReaderWindow != nullptr) {
-                ANativeWindow_release(g_imageReaderWindow);
-                g_imageReaderWindow = nullptr;
-            }
-            if (g_imageReader != nullptr) {
-                AImageReader_setImageListener(g_imageReader, nullptr);
-                AImageReader_delete(g_imageReader);
-                g_imageReader = nullptr;
-            }
-        }
 #endif
 
         bool UseWindowSurface() {
 #if defined(_WIN32)
             const char* value = std::getenv("MOBILEGL_ITEST_WINDOW_SURFACE");
             return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
-#elif defined(__ANDROID__)
-            return true;
 #else
             return false;
 #endif
@@ -174,10 +123,10 @@ namespace MGITest {
         // callers). surfaceless is the platform with no window-system dependency at
         // all; the surface this file then creates is still a pbuffer, which every
         // platform supports and which the amendment to this rule requires as the
-        // fallback shape on desktop. Android instead supplies an AImageReader
-        // ANativeWindow. DISPLAY/WAYLAND_DISPLAY are cleared as well so that a
+        // fallback shape. DISPLAY/WAYLAND_DISPLAY are cleared as well so that a
         // driver that consults them directly cannot reintroduce the dependency
-        // behind EGL's back.
+        // behind EGL's back. Desktop-only file: MG_IntegrationTest never builds
+        // for Android, so no device path is affected.
         void EnsureHeadlessPlatform() {
 #if defined(__linux__) && !defined(__ANDROID__)
             static bool done = false;
@@ -265,21 +214,12 @@ namespace MGITest {
                     return 6;
                 }
                 surface = eglCreateWindowSurface(display, config, g_testWindow, nullptr);
-#elif defined(__ANDROID__)
-                if (!CreateImageReaderWindow()) {
-                    outReason = "failed to create the Android AImageReader integration-test window";
-                    return 6;
-                }
-                surface = eglCreateWindowSurface(display, config, g_imageReaderWindow, nullptr);
 #endif
             } else {
                 const EGLint pbufferAttribs[] = {EGL_WIDTH, kSurfaceWidth, EGL_HEIGHT, kSurfaceHeight, EGL_NONE};
                 surface = eglCreatePbufferSurface(display, config, pbufferAttribs);
             }
             if (surface == EGL_NO_SURFACE) {
-#if defined(__ANDROID__)
-                DestroyImageReaderWindow();
-#endif
                 outReason = WithEglError(useWindowSurface ? "eglCreateWindowSurface failed"
                                                          : "eglCreatePbufferSurface failed");
                 return 6;
@@ -608,8 +548,6 @@ namespace MGITest {
             DestroyWindow(g_testWindow);
             g_testWindow = nullptr;
         }
-#elif defined(__ANDROID__)
-        DestroyImageReaderWindow();
 #endif
         m_context = nullptr;
         m_surface = nullptr;

MobileGL/MG_IntegrationTest/Harness/HeadlessGL.h

@@ -14,11 +14,11 @@
 // inspects backend state - both bugs this module pins were invisible to
 // state-level assertions and visible only in pixels.
 //
-// Headless by construction: desktop uses an EGL pbuffer and Android uses an
-// AImageReader-backed ANativeWindow that needs no Activity. No window manager,
-// no human. Unlike DriverBench the scenarios do draw to the DEFAULT framebuffer
-// (that is where the Y-flip lives) and do call eglSwapBuffers (that is the frame
-// boundary the cross-frame scenarios need to be real).
+// Headless by construction, following MG_Benchmark/Driver/DriverBench.c: an EGL
+// context on a PBUFFER surface. No window, no window manager, no human. Unlike
+// DriverBench the scenarios do draw to the DEFAULT framebuffer (that is where
+// the Y-flip lives) and do call eglSwapBuffers (that is the frame boundary the
+// cross-frame scenarios need to be real).
 //
 // One process is one backend: MOBILEGL_BACKEND_TYPE is latched at
 // initialization, so the CMake wiring runs this binary once per backend rather

MobileGL/MG_IntegrationTest/Main.cpp

@@ -31,14 +31,8 @@ namespace {
                 // silently bound to a workstation's window system is a different
                 // run from CI's and must be visible as one in the log.
                 const char* eglPlatform = std::getenv("EGL_PLATFORM");
-#if defined(__ANDROID__)
-                constexpr const char* surfaceKind = "AImageReader window";
-#else
-                constexpr const char* surfaceKind = "pbuffer";
-#endif
-                std::fprintf(stderr, "  renderer: %s\n  surface:  %dx%d %s (headless, EGL_PLATFORM=%s)\n",
+                std::fprintf(stderr, "  renderer: %s\n  surface:  %dx%d pbuffer (headless, EGL_PLATFORM=%s)\n",
                              gl.RendererString().c_str(), gl.Width(), gl.Height(),
-                             surfaceKind,
                              eglPlatform != nullptr ? eglPlatform : "<unset>");
             } else if (MGITest::RequireGpu()) {
                 std::fprintf(stderr,

MobileGL/MG_IntegrationTest/Scenarios/IterationRPProgram203Scenario.cpp

@@ -1,379 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/IterationRPProgram203Scenario.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
-// SPDX-License-Identifier: LGPL-3.0-only
-// End of Source File Header
-//
-// Full iterationRP Program 203 golden input/output fixture. The original shader
-// consumes deterministic complete textures and uniforms, then its complete
-// 512x513 RG16F output image is compared against fixed half-float golden bits.
-// This catches both a wrong exposure slot and collateral scratch corruption.
-
-#include <array>
-#include <bit>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <iostream>
-#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 kSceneWidth = 854;
-        constexpr int kSceneHeight = 480;
-        constexpr int kPixelDataWidth = 512;
-        constexpr int kPixelDataHeight = 513;
-        constexpr std::size_t kSceneTexelCount =
-            static_cast<std::size_t>(kSceneWidth) * kSceneHeight;
-        constexpr std::size_t kPixelDataTexelCount =
-            static_cast<std::size_t>(kPixelDataWidth) * kPixelDataHeight;
-
-        struct Rgba32f {
-            float r, g, b, a;
-        };
-
-        struct Rg16 {
-            std::uint16_t r, g;
-        };
-
-        static_assert(sizeof(Rgba32f) == 16);
-        static_assert(sizeof(Rg16) == 4);
-
-        // Captured from the fixed fixture on Adreno 830. These are the exact
-        // RG16F storage bits for (0.806640625, 8.2578125), not rounded decimal
-        // comparisons performed by the test.
-        constexpr Rg16 kGoldenExposure = {0x3a74u, 0x4821u};
-
-        constexpr const char* kCommonSource = R"glsl(
-#version 430 core
-#extension GL_KHR_shader_subgroup_arithmetic : require
-
-uniform int frameCounter;
-uniform float frameTime;
-uniform float aspectRatio;
-uniform vec2 pixelSize;
-uniform float nightVision;
-uniform float darknessLightFactor;
-uniform sampler2D colortex2;
-uniform sampler2D pixelData2D;
-layout(rg16f) uniform image2D img_pixelData2D;
-
-float remapSaturate(float x, float e0, float e1) {
-    return clamp((x - e0) / (e1 - e0), 0.0f, 1.0f);
-}
-
-float GetExposureValue(float luminance) {
-    float aeCurve = 0.65f;
-    aeCurve = mix(aeCurve, clamp(aeCurve * 1.2f, 0.0f, 1.0f), nightVision);
-    aeCurve *= remapSaturate(luminance, 2.0f, 1.0f) * 0.6f + 0.4f;
-    float ae = pow(luminance, -aeCurve);
-    ae *= 1.0f - min(darknessLightFactor * 2.0f, 0.9f);
-    ae *= 8.5f;
-    return ae;
-}
-)glsl";
-
-        constexpr const char* kOriginalMain = R"glsl(
-layout(local_size_x = 32, local_size_y = 16) in;
-shared vec2 prefixSumCache[32];
-
-void main() {
-    vec2 texCoord = (vec2(gl_GlobalInvocationID.xy) + 0.5f) * vec2(1.0f / 32.0f, 1.0f / 16.0f);
-    vec2 sampleCoord = texCoord * (1.0f / 64.0f);
-    sampleCoord.x += (15.0f / 32.0f) + pixelSize.x * 12.0f;
-    float tileExposure = dot(textureLod(colortex2, sampleCoord, 0.0f).rgb,
-                             vec3(0.2125f, 0.7154f, 0.0721f));
-    vec2 sampleLuminance = vec2(tileExposure, 0.0f);
-    sampleLuminance = subgroupInclusiveAdd(sampleLuminance);
-    if (gl_SubgroupInvocationID == gl_SubgroupSize - 1u)
-        prefixSumCache[gl_SubgroupID] = sampleLuminance;
-    barrier();
-
-    uint loopLength = uint(findMSB(gl_NumSubgroups));
-    loopLength += uint(gl_NumSubgroups - (1u << (loopLength - 1u)) > 0u);
-    for (uint i = 0u; i < loopLength; ++i) {
-        if ((gl_SubgroupID & (1u << i)) > 0u) {
-            sampleLuminance += prefixSumCache[(gl_SubgroupID >> i << i) - 1u];
-            if (gl_SubgroupInvocationID == gl_SubgroupSize - 1u)
-                prefixSumCache[gl_SubgroupID] = sampleLuminance;
-        }
-        barrier();
-    }
-    if (gl_LocalInvocationIndex == 511u)
-        prefixSumCache[0] = sampleLuminance / 512.0f;
-    barrier();
-
-    float avg = prefixSumCache[0].x;
-    vec2 tileDistance = texCoord * 2.0f - 1.0f;
-    tileDistance.y /= aspectRatio;
-    float centerDistance = length(tileDistance);
-    float tileWeight = remapSaturate(centerDistance, 0.6f, 0.4f);
-    tileExposure = max(7.0E-7f, tileExposure);
-    float lumaWeight = avg / tileExposure;
-    lumaWeight = pow(lumaWeight, remapSaturate(avg, 0.02f, 0.001f) * 0.4f + 0.2f);
-    tileWeight *= lumaWeight;
-
-    vec2 sampleExposure = vec2(tileExposure * tileWeight, tileWeight);
-    sampleExposure = subgroupInclusiveAdd(sampleExposure);
-    if (gl_SubgroupInvocationID == gl_SubgroupSize - 1u)
-        prefixSumCache[gl_SubgroupID] = sampleExposure;
-    barrier();
-    for (uint i = 0u; i < loopLength; ++i) {
-        if ((gl_SubgroupID & (1u << i)) > 0u) {
-            sampleExposure += prefixSumCache[(gl_SubgroupID >> i << i) - 1u];
-            if (gl_SubgroupInvocationID == gl_SubgroupSize - 1u)
-                prefixSumCache[gl_SubgroupID] = sampleExposure;
-        }
-        barrier();
-    }
-
-    if (gl_LocalInvocationIndex == 511u) {
-        float avgExposure = max(sampleExposure.x / sampleExposure.y * 29.3f, 1.0E-10f);
-        avgExposure = log2(avgExposure);
-        float prevAvgExposure = log2(texelFetch(pixelData2D, ivec2(0, 0), 0).x);
-        float frameTimeFixed = frameTime + step(frameCounter, 20) * 100.0f;
-        float exposureTime = clamp(frameTimeFixed * 2.0f, 0.0f, 1.0f);
-        avgExposure = mix(prevAvgExposure, avgExposure, exposureTime);
-        avgExposure = max(exp2(avgExposure), 1.0E-5f);
-        float exposure = GetExposureValue(avgExposure);
-        imageStore(img_pixelData2D, ivec2(0, 0), vec4(avgExposure, exposure, 0.0f, 0.0f));
-    }
-}
-)glsl";
-
-        GLuint CompileCompute(const char* mainSource, std::string* error) {
-            const std::array<const GLchar*, 2> sources = {kCommonSource, mainSource};
-            const GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
-            glShaderSource(shader, static_cast<GLsizei>(sources.size()), sources.data(), nullptr);
-            glCompileShader(shader);
-            GLint compiled = GL_FALSE;
-            glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
-            if (compiled != GL_TRUE) {
-                std::array<char, 8192> log{};
-                glGetShaderInfoLog(shader, static_cast<GLsizei>(log.size() - 1), nullptr, log.data());
-                *error = log.data();
-                glDeleteShader(shader);
-                return 0;
-            }
-            const GLuint program = glCreateProgram();
-            glAttachShader(program, shader);
-            glLinkProgram(program);
-            glDeleteShader(shader);
-            GLint linked = GL_FALSE;
-            glGetProgramiv(program, GL_LINK_STATUS, &linked);
-            if (linked != GL_TRUE) {
-                std::array<char, 8192> log{};
-                glGetProgramInfoLog(program, static_cast<GLsizei>(log.size() - 1), nullptr, log.data());
-                *error = log.data();
-                glDeleteProgram(program);
-                return 0;
-            }
-            return program;
-        }
-
-        std::vector<Rgba32f> MakeSceneInput() {
-            std::vector<Rgba32f> texels(kSceneTexelCount);
-            for (int y = 0; y < kSceneHeight; ++y) {
-                for (int x = 0; x < kSceneWidth; ++x) {
-                    std::uint32_t h = static_cast<std::uint32_t>(x) * 0x9e3779b9u;
-                    h ^= static_cast<std::uint32_t>(y) * 0x85ebca6bu;
-                    h ^= h >> 16u;
-                    h *= 0x7feb352du;
-                    h ^= h >> 15u;
-                    const float noise = static_cast<float>(h & 0xffffu) / 65535.0f;
-                    float base = 0.0002f + noise * 0.075f;
-                    const float dx = static_cast<float>(x - 420);
-                    const float dy = static_cast<float>(y - 4);
-                    base += 0.65f * std::exp(-(dx * dx + dy * dy) / 18.0f);
-                    if (((x + y * 17) % 113) == 0) base += 1.75f;
-                    texels[static_cast<std::size_t>(y) * kSceneWidth + x] =
-                        {base * 0.83f, base * 1.07f, base * 1.31f, 1.0f};
-                }
-            }
-            return texels;
-        }
-
-        std::uint16_t FloatToHalf(float value) {
-            const std::uint32_t bits = std::bit_cast<std::uint32_t>(value);
-            const std::uint32_t sign = (bits >> 16u) & 0x8000u;
-            const std::uint32_t exponent = (bits >> 23u) & 0xffu;
-            std::uint32_t mantissa = bits & 0x7fffffu;
-
-            if (exponent == 0xffu) {
-                return static_cast<std::uint16_t>(sign | (mantissa == 0 ? 0x7c00u : 0x7e00u));
-            }
-            int halfExponent = static_cast<int>(exponent) - 127 + 15;
-            if (halfExponent >= 31) return static_cast<std::uint16_t>(sign | 0x7c00u);
-            if (halfExponent <= 0) {
-                if (halfExponent < -10) return static_cast<std::uint16_t>(sign);
-                mantissa |= 0x800000u;
-                const unsigned shift = static_cast<unsigned>(14 - halfExponent);
-                const std::uint32_t rounded = mantissa + ((1u << (shift - 1u)) - 1u) +
-                                              ((mantissa >> shift) & 1u);
-                return static_cast<std::uint16_t>(sign | (rounded >> shift));
-            }
-            mantissa += 0xfffu + ((mantissa >> 13u) & 1u);
-            if ((mantissa & 0x800000u) != 0) {
-                mantissa = 0;
-                if (++halfExponent >= 31) return static_cast<std::uint16_t>(sign | 0x7c00u);
-            }
-            return static_cast<std::uint16_t>(sign | (static_cast<std::uint32_t>(halfExponent) << 10u) |
-                                              (mantissa >> 13u));
-        }
-
-        std::vector<Rg16> MakePixelDataInput() {
-            std::vector<Rg16> texels(kPixelDataTexelCount);
-            for (std::size_t i = 0; i < texels.size(); ++i) {
-                texels[i] = {FloatToHalf(0.35f + static_cast<float>(i % 97u) * 0.0025f),
-                             FloatToHalf(-0.45f + static_cast<float>(i % 89u) * 0.01f)};
-            }
-            texels[0] = {FloatToHalf(0.73f), FloatToHalf(1.25f)};
-            return texels;
-        }
-
-        std::vector<Rg16> MakeGoldenOutput() {
-            std::vector<Rg16> golden = MakePixelDataInput();
-            golden[0] = kGoldenExposure;
-            return golden;
-        }
-
-        GLuint MakeTexture(GLenum internalFormat, GLenum format, GLenum type, int width, int height,
-                           const void* data) {
-            GLuint texture = 0;
-            glGenTextures(1, &texture);
-            glBindTexture(GL_TEXTURE_2D, texture);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-            glTexImage2D(GL_TEXTURE_2D, 0, static_cast<GLint>(internalFormat), width, height, 0, format,
-                         type, data);
-            return texture;
-        }
-
-        void BindAndDispatch(GLuint program, GLuint scene, GLuint pixelData) {
-            glUseProgram(program);
-            glActiveTexture(GL_TEXTURE3);
-            glBindTexture(GL_TEXTURE_2D, scene);
-            glUniform1i(glGetUniformLocation(program, "colortex2"), 3);
-            glActiveTexture(GL_TEXTURE4);
-            glBindTexture(GL_TEXTURE_2D, pixelData);
-            glUniform1i(glGetUniformLocation(program, "pixelData2D"), 4);
-            glBindImageTexture(0, pixelData, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RG16F);
-            glUniform1i(glGetUniformLocation(program, "img_pixelData2D"), 0);
-            glUniform1i(glGetUniformLocation(program, "frameCounter"), 100);
-            glUniform1f(glGetUniformLocation(program, "frameTime"), 1.0f / 60.0f);
-            glUniform1f(glGetUniformLocation(program, "aspectRatio"),
-                        static_cast<float>(kSceneWidth) / kSceneHeight);
-            glUniform2f(glGetUniformLocation(program, "pixelSize"), 1.0f / kSceneWidth, 1.0f / kSceneHeight);
-            glUniform1f(glGetUniformLocation(program, "nightVision"), 0.23f);
-            glUniform1f(glGetUniformLocation(program, "darknessLightFactor"), 0.08f);
-            glDispatchCompute(1, 1, 1);
-            glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT | GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
-        }
-
-        std::vector<Rg16> ReadWholeRgTexture(GLuint texture) {
-            std::vector<Rg16> texels(kPixelDataTexelCount);
-            glBindTexture(GL_TEXTURE_2D, texture);
-            glGetTexImage(GL_TEXTURE_2D, 0, GL_RG, GL_HALF_FLOAT, texels.data());
-            return texels;
-        }
-
-        class IterationRPProgram203Scenario : public ScenarioTest {
-        protected:
-            void SetUp() override {
-                ScenarioTest::SetUp();
-                if (!Ready()) return;
-
-                GLint stages = 0;
-                GLint features = 0;
-                GLint invocations = 0;
-                glGetIntegerv(GL_SUBGROUP_SUPPORTED_STAGES_KHR, &stages);
-                glGetIntegerv(GL_SUBGROUP_SUPPORTED_FEATURES_KHR, &features);
-                glGetIntegerv(GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS, &invocations);
-                const GLbitfield required =
-                    GL_SUBGROUP_FEATURE_BASIC_BIT_KHR | GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR;
-                if ((static_cast<GLbitfield>(stages) & GL_COMPUTE_SHADER_BIT) == 0 ||
-                    (static_cast<GLbitfield>(features) & required) != required || invocations < 512) {
-                    GTEST_SKIP() << "requires 512-invocation basic+arithmetic compute subgroups";
-                }
-
-                std::string error;
-                m_original = CompileCompute(kOriginalMain, &error);
-                ASSERT_NE(m_original, 0u) << "original Program 203: " << error;
-
-                const std::vector<Rgba32f> scene = MakeSceneInput();
-                const std::vector<Rg16> pixelData = MakePixelDataInput();
-                m_scene = MakeTexture(GL_RGBA16F, GL_RGBA, GL_FLOAT, kSceneWidth, kSceneHeight, scene.data());
-                m_originalOutput =
-                    MakeTexture(GL_RG16F, GL_RG, GL_HALF_FLOAT, kPixelDataWidth, kPixelDataHeight,
-                                pixelData.data());
-                ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR));
-            }
-
-            void TearDown() override {
-                if (!Ready()) return;
-                const std::array<GLuint, 2> textures = {m_scene, m_originalOutput};
-                glDeleteTextures(static_cast<GLsizei>(textures.size()), textures.data());
-                if (m_original != 0) glDeleteProgram(m_original);
-            }
-
-            GLuint m_original = 0;
-            GLuint m_scene = 0;
-            GLuint m_originalOutput = 0;
-        };
-    } // namespace
-
-    TEST_F(IterationRPProgram203Scenario, FixedCompleteInputProducesFixedCompleteGoldenOutput) {
-        if (!Ready()) return;
-
-        BindAndDispatch(m_original, m_scene, m_originalOutput);
-        glFinish();
-        const std::vector<Rg16> actual = ReadWholeRgTexture(m_originalOutput);
-        const std::vector<Rg16> expected = MakeGoldenOutput();
-        ASSERT_EQ(FirstGLError(), static_cast<GLenum>(GL_NO_ERROR));
-
-        std::size_t mismatchTexels = 0;
-        std::size_t firstMismatch = actual.size();
-        for (std::size_t i = 0; i < actual.size(); ++i) {
-            if (actual[i].r != expected[i].r || actual[i].g != expected[i].g) {
-                if (firstMismatch == actual.size()) firstMismatch = i;
-                ++mismatchTexels;
-            }
-        }
-
-        RecordProperty("program203_output_width", kPixelDataWidth);
-        RecordProperty("program203_output_height", kPixelDataHeight);
-        RecordProperty("program203_compared_texels", static_cast<long long>(actual.size()));
-        RecordProperty("program203_mismatch_texels", static_cast<long long>(mismatchTexels));
-        std::cout << "IterationRPProgram203Scenario complete-output actualExposureBits=(0x" << std::hex
-                  << actual[0].r << ", 0x" << actual[0].g << ") goldenExposureBits=(0x" << expected[0].r
-                  << ", 0x" << expected[0].g << std::dec << ") mismatches=" << mismatchTexels << '/'
-                  << actual.size() << '\n';
-
-        if (firstMismatch != actual.size()) {
-            const std::size_t x = firstMismatch % kPixelDataWidth;
-            const std::size_t y = firstMismatch / kPixelDataWidth;
-            ADD_FAILURE() << "complete Program 203 output differs at " << x << ',' << y
-                          << ": actual half bits=(0x" << std::hex << actual[firstMismatch].r << ", 0x"
-                          << actual[firstMismatch].g << ") golden half bits=(0x" << expected[firstMismatch].r
-                          << ", 0x" << expected[firstMismatch].g << std::dec << "); mismatched "
-                          << mismatchTexels << " of " << actual.size() << " texels";
-        }
-        EXPECT_EQ(mismatchTexels, 0u);
-    }
-} // namespace MGITest

MobileGL/MG_State/GLState/Core.cpp

@@ -646,17 +646,9 @@ namespace MobileGL::MG_State {
             for (SizeT stage = 0; stage < ProgramPipelineObject::kGraphicsStageCount; ++stage) {
                 const auto& stageProgram = pipeline->GetStageProgram(static_cast<ShaderStage>(stage));
                 if (!stageProgram) continue;
-                // The stage program contributes the shaders its LAST LINK consumed, never
-                // its live attach list: per GL 4.6 7.3/7.4 a pipeline stage executes the
-                // stage program as last linked - glAttachShader and glCompileShader take
-                // effect only at the program's next link - and neither of those moves the
-                // link version this cache keys on, so reading live state here would let a
-                // post-link attach or recompile leak into the composite while the signature
-                // still hits. The pinned (source, node) makes the composite's Link()
-                // consume the very inputs that link consumed.
-                for (const auto& ref : stageProgram->GetLinkedShaderSnapshot()) {
-                    if (!ref.shader || static_cast<SizeT>(ref.shader->GetShaderStage()) != stage) continue;
-                    composite->AttachShaderWithPinnedLinkInput(ref);
+                for (const auto& shader : stageProgram->GetAttachedShaders()) {
+                    if (!shader || static_cast<SizeT>(shader->GetShaderStage()) != stage) continue;
+                    composite->AttachShader(shader);
                     anyStage = true;
                 }
             }

MobileGL/MG_State/GLState/FramebufferState/FramebufferObject.cpp

@@ -9,18 +9,7 @@
 #include "FramebufferObject.h"
 #include "MG_Util/Types.h"
 
-#include <atomic>
-
 namespace MobileGL::MG_State::GLState {
-    // Starts at 1 so a zero-initialized memo slot can never carry a live object's id.
-    // Atomic for the same reason as the VAO counter: it costs nothing, and a duplicate
-    // id would resurrect exactly the ABA this id exists to kill.
-    static std::atomic<Uint64> s_nextFramebufferLifetimeId{1};
-
-    Uint64 FramebufferObject::AllocateLifetimeId() {
-        return s_nextFramebufferLifetimeId.fetch_add(1, std::memory_order_relaxed);
-    }
-
     // FramebufferAttachmentObject
     FramebufferAttachmentObject::FramebufferAttachmentObject(
         const SharedPtr<MG_State::GLState::ITextureObject>& texture, TextureUploadTarget textureUploadTarget, Int level,

MobileGL/MG_State/GLState/FramebufferState/FramebufferObject.h

@@ -148,25 +148,13 @@ namespace MobileGL {
 
             Uint16 GetObjectVersion() const { return m_objectVersion; }
 
-            // Globally-unique, never-reused id for THIS object's lifetime - the same
-            // contract as VertexArrayObject::GetLifetimeId(), and needed for the same
-            // reason: neither the GL name nor the heap address can tell a
-            // deleted-and-recreated framebuffer from the original, and m_objectVersion
-            // starts at 0 for every new object, so a backend memo keyed on
-            // (pointer, version) alone would silently inherit the dead object's entry
-            // (see VkRenderPassManager's per-draw fast-path memo).
-            Uint64 GetLifetimeId() const { return m_lifetimeId; }
-
             Uint GetExternalIndex() const;
             Bool IsDefaultFramebuffer() const { return m_externalIndex == 0; }
 
         private:
-            static Uint64 AllocateLifetimeId();
-
             void BumpAttachmentVersion(FramebufferAttachmentType type);
 
             const Uint m_externalIndex = 0;
-            const Uint64 m_lifetimeId = AllocateLifetimeId();
             FramebufferAttachmentObjectArray m_attachmentObjects;
             FramebufferAttachmentVersionArray m_attachmentVersions;
 

MobileGL/MG_State/GLState/ProgramState/ProgramObject.cpp

@@ -393,14 +393,6 @@ namespace MobileGL::MG_State::GLState {
         return true;
     }
 
-    bool ProgramObject::AttachShaderWithPinnedLinkInput(const LinkedShaderRef& ref) {
-        if (!AttachShader(ref.shader)) {
-            return false;
-        }
-        m_pinnedLinkInputs[ref.shader.get()] = ref;
-        return true;
-    }
-
     SizeT ProgramObject::DetachShader(const SharedPtr<ShaderObject>& shader) {
         MGLOG_D("DetachShader called for shader %p from ProgramObject %u", shader.get(), m_externalIndex);
         if (!ShaderIsAttached(shader)) {
@@ -483,8 +475,6 @@ namespace MobileGL::MG_State::GLState {
             AddDefaultFragmentShaderIfMissing();
         }
         if (m_shaders.empty()) {
-            // This IS the last link now, and it consumed nothing.
-            m_linkedShaderSnapshot.clear();
             m_artifacts.infoLog = "No shader objects are attached to program.";
             MGLOG_E("ProgramObject %u: Link failed - no shader objects attached.", m_externalIndex);
             return;
@@ -515,19 +505,8 @@ namespace MobileGL::MG_State::GLState {
         Vector<SharedPtr<ShaderCompileTask>> deps;
         deps.reserve(m_shaders.size());
         task->in.shaders.reserve(m_shaders.size());
-        m_linkedShaderSnapshot.clear();
-        m_linkedShaderSnapshot.reserve(m_shaders.size());
         for (const auto& shader : m_shaders) {
-            // A pipeline composite pins the (source, node) each stage program's LAST link
-            // consumed (AttachShaderWithPinnedLinkInput); an ordinary program takes the
-            // shader's current ones. Without the pin a post-link recompile would leak a
-            // shader the stage program never linked into the composite.
-            SharedPtr<const String> sourcePtr = shader->GetShaderSourcePtr();
-            SharedPtr<ShaderCompileTask> node = shader->CompiledNodeForLink();
-            if (const auto pinned = m_pinnedLinkInputs.find(shader.get()); pinned != m_pinnedLinkInputs.end()) {
-                sourcePtr = pinned->second.source;
-                node = pinned->second.node;
-            }
+            const SharedPtr<ShaderCompileTask>& node = shader->CompiledNodeForLink();
             if (node) {
                 // This link is now an observer of that node's result, and the ShaderObject is
                 // no longer the only route to it: without the marker, the ordinary
@@ -536,10 +515,7 @@ namespace MobileGL::MG_State::GLState {
                 node->MarkLinkReferenced();
                 if (!node->IsTerminal()) deps.push_back(node);
             }
-            task->in.shaders.push_back({shader->GetShaderStage(), sourcePtr, node});
-            // What "as last linked" will mean for this program from now on - the pipeline
-            // composite cache rebuilds from exactly this set (GetProgramForDraw).
-            m_linkedShaderSnapshot.push_back({shader, sourcePtr, node});
+            task->in.shaders.push_back({shader->GetShaderStage(), shader->GetShaderSourcePtr(), node});
         }
 
         // Phase B of the same link: SPIR-V generation, spirv-opt and the global-UBO routing

MobileGL/MG_State/GLState/ProgramState/ProgramObject.h

@@ -60,26 +60,6 @@ namespace MobileGL::MG_State::GLState {
 
         Vector<SharedPtr<ShaderObject>>& GetAttachedShaders();
         const Vector<SharedPtr<ShaderObject>>& GetAttachedShaders() const;
-
-        // One shader exactly as this program's last Link() consumed it: the object, the
-        // source snapshot, and the compile node taken at that link's enqueue. GL 4.6 7.3/7.4
-        // makes this triple - not the live attach list, not the shader's current compile -
-        // what a program pipeline stage executes ("as last linked"): glAttachShader and
-        // glCompileShader take effect only at the program's next link, yet neither moves
-        // m_linkVersion, so anything keyed on the link generation must consume this
-        // snapshot rather than re-read the live state.
-        struct LinkedShaderRef {
-            SharedPtr<ShaderObject> shader;
-            SharedPtr<const String> source;
-            SharedPtr<ShaderCompileTask> node;
-        };
-        // The last link's full input set; empty when this program has never linked (or its
-        // last link had no shaders attached). GL-thread-owned, rebuilt in Link()'s prologue.
-        const Vector<LinkedShaderRef>& GetLinkedShaderSnapshot() const { return m_linkedShaderSnapshot; }
-        // Pipeline-composite attach: AttachShader plus a pin that makes THIS program's
-        // Link() consume ref's (source, node) instead of the shader's current ones, so a
-        // post-link recompile of the stage program's shader cannot leak into the composite.
-        bool AttachShaderWithPinnedLinkInput(const LinkedShaderRef& ref);
         const String& GetInfoLog() const { return Artifacts().infoLog; }
         // glCreateShaderProgramv folds the shader's compile log into the program's log, which
         // is the only place a caller can read it from once the shader name is gone.
@@ -806,13 +786,6 @@ namespace MobileGL::MG_State::GLState {
         // order - and the name is the only coordinate all three agree on. Absent from the map
         // means "never rebound", and the shader's declared binding still stands.
         void SetShaderStorageBlockBinding(const String& blockName, Uint binding) {
-            // Equality bail-out like SetUniformBlockBinding's: the pipeline composite
-            // mirror replays every override each draw, and without this every replay
-            // would churn m_blockBindingVersion and rebuild whatever keys on it.
-            const auto it = Artifacts().shaderStorageBlockBinding.find(blockName);
-            if (it != Artifacts().shaderStorageBlockBinding.end() && it->second == static_cast<Int>(binding)) {
-                return;
-            }
             Artifacts().shaderStorageBlockBinding[blockName] = static_cast<Int>(binding);
             // Deliberately NOT m_backendStateVersion: Espryt's entry point never forces a
             // program build off this, and bumping that version would start doing so. The
@@ -1250,13 +1223,6 @@ namespace MobileGL::MG_State::GLState {
         // glGetAttachedShaders / GL_ATTACHED_SHADERS / the orphan-shader sweep need no join.
         Vector<SharedPtr<ShaderObject>> m_shaders;
         Vector<SharedPtr<ShaderObject>> m_detachedShaders; // Store detached shaders and remove on next link
-        // See GetLinkedShaderSnapshot. Holding the SharedPtrs here is deliberate: the
-        // "as last linked" set must survive detach-and-delete of its shaders (the
-        // glCreateShaderProgramv shape) until the next link replaces it.
-        Vector<LinkedShaderRef> m_linkedShaderSnapshot;
-        // See AttachShaderWithPinnedLinkInput. Populated only on pipeline composites,
-        // which never detach, so entries need no removal path. GL-thread-owned.
-        UnorderedMap<const ShaderObject*, LinkedShaderRef> m_pinnedLinkInputs;
 
         // Link INPUTS (all "take effect at the next link" per GL): glBindAttribLocation,
         // glBindFragDataLocation(Indexed), glTransformFeedbackVaryings, and the draw-buffer

MobileGL/MG_State/GLState/ProgramState/ShaderObject.cpp

@@ -140,13 +140,6 @@ namespace MobileGL::MG_State::GLState {
     }
 
     void ShaderObject::Compile() {
-        // The compile-environment snapshot is taken HERE, on the GL thread, and handed to
-        // the job. Everything the pipeline needs to know about the device comes through it,
-        // never through pActiveBackendObject - that is what makes the body movable.
-        // Hoisted above the memo check because the memo must be env-disciplined too (below).
-        const SharedPtr<const MG_Util::ShaderTranspiler::CompileEnv> env =
-            MG_Util::ShaderTranspiler::GetCurrentCompileEnv();
-
         // P0b layer 1, as a tri-state: the memo is "the node in m_compiled was built from
         // the string m_source still points at". SetShaderSource only swaps that pointer when
         // the text actually differs, so this is a pointer compare, and it covers Pending as
@@ -159,18 +152,7 @@ namespace MobileGL::MG_State::GLState {
         // ClaimParsedShader's on-demand re-parse needs - a real recompile would have handed
         // the next link a fresh parse, the no-op hands it a fresh re-parse of the identical
         // source instead. Same result, one parse either way.
-        //
-        // The environment joins the check (ShaderSourceKey.h's memo-hazard rule: a memo
-        // must never be handed back under an environment other than the one it was
-        // computed against). Layers 2 and 3 key on the fingerprint, but this memo sits
-        // ABOVE both, so without this compare a node computed against a dead environment
-        // - e.g. a compute shader rejected against the pre-capability fallback limits -
-        // would keep answering forever while a fresh object with byte-identical source
-        // compiles fine. The fingerprint is a content hash, so a republish of identical
-        // capabilities still hits.
-        if (HasMemoizedCompile() && m_compiled->env != nullptr && m_compiled->env->fingerprint == env->fingerprint) {
-            return;
-        }
+        if (HasMemoizedCompile()) return;
 
         // Two reasons to stay on this thread, one rule. Without the async flag the whole
         // path must be byte-identical to the synchronous implementation, and a cache-less
@@ -186,6 +168,12 @@ namespace MobileGL::MG_State::GLState {
         // glMaxShaderCompilerThreadsKHR(0) and a flag-off build both bypass sharing exactly
         // as they bypass the pool, and their behaviour stays byte-identical to pre-stage-6.
         const Bool runOnPool = m_preprocessCache && MG_Util::Async::AsyncShaderCompileActive();
+
+        // The compile-environment snapshot is taken HERE, on the GL thread, and handed to
+        // the job. Everything the pipeline needs to know about the device comes through it,
+        // never through pActiveBackendObject - that is what makes the body movable.
+        const SharedPtr<const MG_Util::ShaderTranspiler::CompileEnv> env =
+            MG_Util::ShaderTranspiler::GetCurrentCompileEnv();
         const Uint64 sourceHash = ShaderPreprocessCache::HashSource(*m_source);
 
         // ---- P1 stage 6: adopt an equivalent compile instead of enqueueing a duplicate ----

MobileGL/MG_Test/ShaderTranspiler/CMakeLists.txt

@@ -4,7 +4,6 @@ add_executable(
         SpirvPassTest
         SpirvPassTest.cpp
         DeriveNumSubgroupsTest.cpp
-        FixIterationRPBarrierTest.cpp
         FixIterationRPSubgroupScratchTest.cpp
         EmulateSubgroupsTest.cpp
         DemoteFloat64Test.cpp

MobileGL/MG_Test/ShaderTranspiler/FixIterationRPBarrierTest.cpp

@@ -1,206 +0,0 @@
-// MobileGL - MobileGL/MG_Test/ShaderTranspiler/FixIterationRPBarrierTest.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
-
-#include <gtest/gtest.h>
-
-#define SPV_ENABLE_UTILITY_CODE
-#include "glslang/SPIRV/spirv.hpp11"
-#undef SPV_ENABLE_UTILITY_CODE
-
-#include "Includes.h"
-#include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
-#include <MG_Util/ShaderTranspiler/Types.h>
-
-#include <spirv-tools/libspirv.hpp>
-
-#include <map>
-#include <vector>
-
-using namespace MobileGL;
-using MobileGL::MG_Util::ShaderTranspiler::ShaderCompiler;
-
-namespace {
-    constexpr SizeT kSpirvHeaderWordCount = 5u;
-
-    template <typename Visitor>
-    void ForEachInstruction(const Vector<Uint32>& spirv, Visitor&& visit) {
-        for (SizeT offset = kSpirvHeaderWordCount; offset < spirv.size();) {
-            const Uint32 wordCount = spirv[offset] >> 16u;
-            if (wordCount == 0u || offset + wordCount > spirv.size()) break;
-            visit(static_cast<spv::Op>(spirv[offset] & 0xffffu), &spirv[offset], wordCount);
-            offset += wordCount;
-        }
-    }
-
-    Vector<Uint32> CompileCompute(const String& source) {
-        using namespace MobileGL::MG_Util::ShaderTranspiler;
-        ShaderAttrib shaderAttrib{.shaderType = GL_COMPUTE_SHADER, .sourceStr = source};
-        auto shaderResult = ShaderCompiler::CompileShader(shaderAttrib);
-        EXPECT_TRUE(shaderResult) << (shaderResult ? String{} : shaderResult.error().log);
-        if (!shaderResult) return {};
-
-        ProgramAttrib programAttrib{.shaders = {shaderResult.value()}};
-        auto programResult = ShaderCompiler::LinkProgram(programAttrib);
-        EXPECT_TRUE(programResult) << (programResult ? String{} : programResult.error().log);
-        if (!programResult) return {};
-
-        ProgramBinaryAttrib binaryAttrib{.shaderTypes = {GL_COMPUTE_SHADER}, .program = *programResult.value()};
-        auto binaryResult = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib);
-        EXPECT_TRUE(binaryResult) << (binaryResult ? String{} : binaryResult.error().log);
-        if (!binaryResult || binaryResult->empty()) return {};
-        return binaryResult->front();
-    }
-
-    bool Validates(const Vector<Uint32>& spirv) {
-        spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1);
-        tools.SetMessageConsumer(
-            [](spv_message_level_t, const char*, const spv_position_t& position, const char* message) {
-                ADD_FAILURE() << "spirv-val at word " << position.index << ": " << message;
-            });
-        return tools.Validate(spirv);
-    }
-
-    Uint32 CountOpcode(const Vector<Uint32>& spirv, spv::Op wanted) {
-        Uint32 count = 0u;
-        ForEachInstruction(spirv, [&](spv::Op opcode, const Uint32*, Uint32) {
-            if (opcode == wanted) ++count;
-        });
-        return count;
-    }
-
-    bool HasWorkgroupBarrierImmediatelyBeforeSecondScan(const Vector<Uint32>& spirv) {
-        std::map<Uint32, Uint32> uintConstants;
-        spv::Op previous = spv::Op::OpNop;
-        Uint32 scanCount = 0u;
-        bool found = false;
-        const Uint32* previousWords = nullptr;
-        Uint32 previousWordCount = 0u;
-        ForEachInstruction(spirv, [&](spv::Op opcode, const Uint32* words, Uint32 wordCount) {
-            if (opcode == spv::Op::OpConstant && wordCount >= 4u) {
-                uintConstants[words[2]] = words[3];
-            }
-            if (opcode == spv::Op::OpGroupNonUniformFAdd && wordCount >= 6u &&
-                static_cast<spv::GroupOperation>(words[4]) == spv::GroupOperation::InclusiveScan && ++scanCount == 2u &&
-                previous == spv::Op::OpControlBarrier && previousWordCount == 4u) {
-                found =
-                    uintConstants[previousWords[1]] == static_cast<Uint32>(spv::Scope::Workgroup) &&
-                    uintConstants[previousWords[2]] == static_cast<Uint32>(spv::Scope::Workgroup) &&
-                    uintConstants[previousWords[3]] == (static_cast<Uint32>(spv::MemorySemanticsMask::AcquireRelease) |
-                                                        static_cast<Uint32>(spv::MemorySemanticsMask::WorkgroupMemory));
-            }
-            previous = opcode;
-            previousWords = words;
-            previousWordCount = wordCount;
-        });
-        return found;
-    }
-
-    constexpr const char* kProgram203RaceShape = R"(#version 450 core
-#extension GL_KHR_shader_subgroup_basic : require
-#extension GL_KHR_shader_subgroup_arithmetic : require
-layout(local_size_x = 32, local_size_y = 16, local_size_z = 1) in;
-layout(std430, binding = 0) buffer Output { vec2 value; } outputData;
-shared vec2 prefixSumCache[32];
-void main() {
-    vec2 sampleLuminance = subgroupInclusiveAdd(
-        vec2(float(gl_LocalInvocationIndex), 1.0));
-    if (gl_SubgroupInvocationID == gl_SubgroupSize - 1u)
-        prefixSumCache[gl_SubgroupID] = sampleLuminance;
-    barrier();
-    if (gl_LocalInvocationIndex == 511u)
-        prefixSumCache[0] = sampleLuminance / 512.0;
-    barrier();
-
-    float avg = prefixSumCache[0].x;
-    float weight = avg > 0.0 ? float(gl_LocalInvocationIndex + 1u) / avg : 0.0;
-    vec2 sampleExposure = subgroupInclusiveAdd(vec2(weight, 1.0));
-    if (gl_SubgroupInvocationID == gl_SubgroupSize - 1u)
-        prefixSumCache[gl_SubgroupID] = sampleExposure;
-    barrier();
-    if (gl_LocalInvocationIndex == 511u)
-        outputData.value = sampleExposure;
-}
-)";
-
-    constexpr const char* kAlreadySynchronizedShape = R"(#version 450 core
-#extension GL_KHR_shader_subgroup_basic : require
-#extension GL_KHR_shader_subgroup_arithmetic : require
-layout(local_size_x = 32, local_size_y = 16, local_size_z = 1) in;
-layout(std430, binding = 0) buffer Output { vec2 value; } outputData;
-shared vec2 prefixSumCache[32];
-void main() {
-    vec2 first = subgroupInclusiveAdd(vec2(float(gl_LocalInvocationIndex), 1.0));
-    if (gl_SubgroupInvocationID == gl_SubgroupSize - 1u)
-        prefixSumCache[gl_SubgroupID] = first;
-    barrier();
-    if (gl_LocalInvocationIndex == 511u) prefixSumCache[0] = first / 512.0;
-    barrier();
-    float avg = prefixSumCache[0].x;
-    barrier();
-    vec2 second = subgroupInclusiveAdd(vec2(avg, 1.0));
-    if (gl_SubgroupInvocationID == gl_SubgroupSize - 1u)
-        prefixSumCache[gl_SubgroupID] = second;
-    barrier();
-    if (gl_LocalInvocationIndex == 511u) outputData.value = second;
-}
-)";
-
-    constexpr const char* kForeignSingleScanShape = R"(#version 450 core
-#extension GL_KHR_shader_subgroup_basic : require
-#extension GL_KHR_shader_subgroup_arithmetic : require
-layout(local_size_x = 32, local_size_y = 16, local_size_z = 1) in;
-layout(std430, binding = 0) buffer Output { vec2 value; } outputData;
-shared vec2 prefixSumCache[32];
-void main() {
-    vec2 value = subgroupInclusiveAdd(vec2(float(gl_LocalInvocationIndex), 1.0));
-    if (gl_SubgroupInvocationID == gl_SubgroupSize - 1u)
-        prefixSumCache[gl_SubgroupID] = value;
-    barrier();
-    if (gl_LocalInvocationIndex == 0u) outputData.value = prefixSumCache[0];
-}
-)";
-} // namespace
-
-TEST(FixIterationRPBarrierPass, InsertsWorkgroupBarrierBeforeSecondReduction) {
-    const Vector<Uint32> input = CompileCompute(kProgram203RaceShape);
-    ASSERT_FALSE(input.empty());
-    const Uint32 inputBarrierCount = CountOpcode(input, spv::Op::OpControlBarrier);
-    EXPECT_FALSE(HasWorkgroupBarrierImmediatelyBeforeSecondScan(input));
-
-    Vector<Uint32> output;
-    ASSERT_TRUE(ShaderCompiler::FixIterationRPBarrierForVulkan(input, output, true));
-    EXPECT_EQ(CountOpcode(output, spv::Op::OpControlBarrier), inputBarrierCount + 1u);
-    EXPECT_TRUE(HasWorkgroupBarrierImmediatelyBeforeSecondScan(output));
-    EXPECT_TRUE(Validates(output));
-}
-
-TEST(FixIterationRPBarrierPass, LeavesOtherShapesByteIdentical) {
-    const Vector<Uint32> input = CompileCompute(kForeignSingleScanShape);
-    ASSERT_FALSE(input.empty());
-    Vector<Uint32> output;
-    ASSERT_TRUE(ShaderCompiler::FixIterationRPBarrierForVulkan(input, output, true));
-    EXPECT_EQ(output, input);
-}
-
-TEST(FixIterationRPBarrierPass, LeavesAnAlreadySynchronizedShaderByteIdentical) {
-    const Vector<Uint32> input = CompileCompute(kAlreadySynchronizedShape);
-    ASSERT_FALSE(input.empty());
-    Vector<Uint32> output;
-    ASSERT_TRUE(ShaderCompiler::FixIterationRPBarrierForVulkan(input, output, true));
-    EXPECT_EQ(output, input);
-}
-
-TEST(FixIterationRPBarrierPass, IsIdempotent) {
-    const Vector<Uint32> input = CompileCompute(kProgram203RaceShape);
-    ASSERT_FALSE(input.empty());
-    Vector<Uint32> once;
-    ASSERT_TRUE(ShaderCompiler::FixIterationRPBarrierForVulkan(input, once, true));
-    Vector<Uint32> twice;
-    ASSERT_TRUE(ShaderCompiler::FixIterationRPBarrierForVulkan(once, twice, true));
-    EXPECT_EQ(twice, once);
-}

MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp

@@ -27,7 +27,6 @@
 #include "SpirvPasses/ZeroBaseVertexPass.h"
 #include "SpirvPasses/DeriveNumSubgroupsPass.h"
 #include "SpirvPasses/EmulateSubgroupsPass.h"
-#include "SpirvPasses/FixIterationRPBarrierPass.h"
 #include "SpirvPasses/FixIterationRPSubgroupScratchPass.h"
 #include "SpirvPasses/NormalizeRectCoordinatesPass.h"
 #include "SpirvPasses/Lower1DArrayImagesPass.h"
@@ -925,17 +924,6 @@ namespace MobileGL {
                                            inputBinary, outputBinary, true, enableSpirvValidation);
             }
 
-            bool ShaderCompiler::FixIterationRPBarrierForVulkan(
-                const Vector<Uint32>& inputBinary, Vector<uint32_t>& outputBinary,
-                const bool enableSpirvValidation) {
-                using namespace spvtools;
-                Optimizer optimizer(SPV_ENV_VULKAN_1_1);
-                optimizer.RegisterPass(FixIterationRPBarrierPass::CreateFixIterationRPBarrierPass());
-
-                return RunOptimizerChecked("FixIterationRPBarrierForVulkan", optimizer,
-                                           inputBinary, outputBinary, true, enableSpirvValidation);
-            }
-
             bool ShaderCompiler::DecoratePositionInvariantForVulkan(const Vector<Uint32>& inputBinary,
                                                                     Vector<uint32_t>& outputBinary, const bool enableSpirvValidation) {
                 using namespace spvtools;

MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.h

@@ -179,12 +179,6 @@ namespace MobileGL {
                                                                    Uint32 nativeSubgroupSize,
                                                                    Uint32 maxWorkgroupScratchBytes,
                                                                    bool enableSpirvValidation = false);
-                // Inserts the missing workgroup rendezvous between Program 203's two
-                // prefixSumCache reductions. Fingerprint-gated to the iterationRP shape;
-                // unrelated and already-repaired modules pass through byte-identical.
-                static bool FixIterationRPBarrierForVulkan(const Vector<Uint32>& inputBinary,
-                                                           Vector<uint32_t>& outputBinary,
-                                                           bool enableSpirvValidation = false);
                 // Re-declares 64-bit float vertex inputs as their 32-bit unsigned word pair
                 // (double -> uvec2, dvec2 -> uvec4) and bitcasts them back to double at entry, so no
                 // VK_FORMAT_R64*_SFLOAT is needed - lavapipe advertises none of them for vertex

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.cpp

@@ -91,15 +91,9 @@ namespace MobileGL {
                     BlockRelayout(IRContext* irContext, Bool std140)
                         : m_irContext(irContext), m_std140(std140) {}
 
-                    // Size and alignment of `typeId`, QUEUING every offset/stride decoration it
-                    // implies on the way down. Zero size means "not a type this layout knows how
-                    // to describe"; the caller then leaves the block alone rather than guessing.
-                    // The queue is what makes that fallback honest: measurement must be
-                    // side-effect-free until it is known to succeed, or a mid-struct failure
-                    // would leave the block half-relaid-out - members before the failing one at
-                    // compacted 32-bit offsets, members after it at the original 64-bit ones, a
-                    // layout matching neither convention. Commit() flushes the queue and is
-                    // called only on a successful Measure of the whole block.
+                    // Size and alignment of `typeId`, applying every stride decoration it implies
+                    // on the way down. Zero size means "not a type this layout knows how to
+                    // describe"; the caller then leaves the block alone rather than guessing.
                     struct Extent {
                         Uint32 size = 0;
                         Uint32 alignment = 0;
@@ -114,29 +108,7 @@ namespace MobileGL {
                         return extent;
                     }
 
-                    // Flushes the decoration writes a successful Measure queued. Call exactly
-                    // once, only when Measure returned a non-zero size; a failed measurement's
-                    // queue dies with this per-block instance, leaving the module untouched.
-                    void Commit() {
-                        for (const PendingDecoration& pending : m_pendingWrites) {
-                            if (pending.member) {
-                                ApplyMemberDecoration(pending.targetId, pending.memberIndex, pending.decoration,
-                                                      pending.value);
-                            } else {
-                                ApplyTypeDecoration(pending.targetId, pending.decoration, pending.value);
-                            }
-                        }
-                        m_pendingWrites.clear();
-                    }
-
                 private:
-                    struct PendingDecoration {
-                        Bool member = false;
-                        Uint32 targetId = 0;
-                        Uint32 memberIndex = 0;
-                        spv::Decoration decoration = spv::Decoration::Offset;
-                        Uint32 value = 0;
-                    };
                     Extent MeasureUncached(Uint32 typeId) {
                         const Instruction* type = m_irContext->get_def_use_mgr()->GetDef(typeId);
                         if (type == nullptr) return {};
@@ -232,17 +204,7 @@ namespace MobileGL {
                         return length->GetSingleWordInOperand(0);
                     }
 
-                    // Queue-only during measurement; the module is mutated in Commit().
                     void SetTypeDecoration(Uint32 targetId, spv::Decoration decoration, Uint32 value) {
-                        m_pendingWrites.push_back({false, targetId, 0, decoration, value});
-                    }
-
-                    void SetMemberDecoration(Uint32 structId, Uint32 member, spv::Decoration decoration,
-                                             Uint32 value) {
-                        m_pendingWrites.push_back({true, structId, member, decoration, value});
-                    }
-
-                    void ApplyTypeDecoration(Uint32 targetId, spv::Decoration decoration, Uint32 value) {
                         for (Instruction& annotation : m_irContext->annotations()) {
                             if (annotation.opcode() != spv::Op::OpDecorate) continue;
                             if (annotation.GetSingleWordInOperand(0) != targetId) continue;
@@ -254,7 +216,7 @@ namespace MobileGL {
                         }
                     }
 
-                    void ApplyMemberDecoration(Uint32 structId, Uint32 member, spv::Decoration decoration,
+                    void SetMemberDecoration(Uint32 structId, Uint32 member, spv::Decoration decoration,
                                              Uint32 value) {
                         for (Instruction& annotation : m_irContext->annotations()) {
                             if (annotation.opcode() != spv::Op::OpMemberDecorate) continue;
@@ -271,7 +233,6 @@ namespace MobileGL {
                     IRContext* m_irContext = nullptr;
                     Bool m_std140 = true;
                     std::unordered_map<Uint32, Extent> m_extents;
-                    std::vector<PendingDecoration> m_pendingWrites;
                 };
             } // namespace
 
@@ -568,12 +529,9 @@ namespace MobileGL {
                         // A member shape the layout rules here do not describe. Leaving the block
                         // at its 64-bit offsets keeps the module valid for Vulkan; SPIRV-Cross will
                         // decline it for ESSL, which is the same outcome as before the demotion.
-                        // Nothing was written: Measure only queues, and the queue dies here.
                         MGLOG_D("DemoteFloat64Pass: block %%%u contains a member this pass cannot lay "
                                 "out; its 64-bit offsets are left in place",
                                 blockType->result_id());
-                    } else {
-                        relayout.Commit();
                     }
                 }
 

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FixIterationRPBarrierPass.cpp

@@ -1,232 +0,0 @@
-// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FixIterationRPBarrierPass.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
-
-#include "FixIterationRPBarrierPass.h"
-
-#include "spirv.hpp"
-#include "source/opt/constants.h"
-#include "source/opt/def_use_manager.h"
-#include "source/opt/instruction.h"
-#include "source/opt/ir_context.h"
-#include "source/opt/module.h"
-#include "source/util/make_unique.h"
-
-#include <vector>
-
-namespace MobileGL::MG_Util::ShaderTranspiler {
-    namespace {
-        using spvtools::opt::Instruction;
-        using spvtools::opt::IRContext;
-        using spvtools::opt::Operand;
-
-        const Instruction* RootVariable(IRContext* context, uint32_t pointerId) {
-            const Instruction* def = context->get_def_use_mgr()->GetDef(pointerId);
-            while (def != nullptr) {
-                switch (def->opcode()) {
-                case spv::Op::OpVariable:
-                    return def;
-                case spv::Op::OpAccessChain:
-                case spv::Op::OpInBoundsAccessChain:
-                case spv::Op::OpCopyObject:
-                    def = context->get_def_use_mgr()->GetDef(def->GetSingleWordInOperand(0));
-                    break;
-                default:
-                    return nullptr;
-                }
-            }
-            return nullptr;
-        }
-
-        bool IsUintConstant(IRContext* context, uint32_t id, uint32_t wanted) {
-            const Instruction* def = context->get_def_use_mgr()->GetDef(id);
-            return def != nullptr && def->opcode() == spv::Op::OpConstant && def->NumInOperands() == 1u &&
-                   def->GetSingleWordInOperand(0) == wanted;
-        }
-
-        bool IsZeroElementPointer(IRContext* context, uint32_t pointerId, const Instruction** root) {
-            const Instruction* pointer = context->get_def_use_mgr()->GetDef(pointerId);
-            if (pointer == nullptr ||
-                (pointer->opcode() != spv::Op::OpAccessChain && pointer->opcode() != spv::Op::OpInBoundsAccessChain) ||
-                pointer->NumInOperands() < 2u) {
-                return false;
-            }
-            for (uint32_t i = 1u; i < pointer->NumInOperands(); ++i) {
-                if (!IsUintConstant(context, pointer->GetSingleWordInOperand(i), 0u)) return false;
-            }
-            *root = RootVariable(context, pointerId);
-            return *root != nullptr;
-        }
-
-        bool IsWorkgroupVec2Array(IRContext* context, const Instruction* variable) {
-            if (variable == nullptr || variable->opcode() != spv::Op::OpVariable || variable->NumInOperands() < 1u ||
-                static_cast<spv::StorageClass>(variable->GetSingleWordInOperand(0)) != spv::StorageClass::Workgroup) {
-                return false;
-            }
-            auto* defUseMgr = context->get_def_use_mgr();
-            const Instruction* pointerType = defUseMgr->GetDef(variable->type_id());
-            if (pointerType == nullptr || pointerType->opcode() != spv::Op::OpTypePointer ||
-                pointerType->NumInOperands() < 2u) {
-                return false;
-            }
-            const Instruction* arrayType = defUseMgr->GetDef(pointerType->GetSingleWordInOperand(1));
-            if (arrayType == nullptr || arrayType->opcode() != spv::Op::OpTypeArray ||
-                arrayType->NumInOperands() < 2u) {
-                return false;
-            }
-            const Instruction* length = defUseMgr->GetDef(arrayType->GetSingleWordInOperand(1));
-            if (length == nullptr || length->opcode() != spv::Op::OpConstant || length->NumInOperands() != 1u) {
-                return false;
-            }
-            const uint32_t arrayLength = length->GetSingleWordInOperand(0);
-            if (arrayLength < 32u || arrayLength > 512u) return false;
-
-            const Instruction* vectorType = defUseMgr->GetDef(arrayType->GetSingleWordInOperand(0));
-            if (vectorType == nullptr || vectorType->opcode() != spv::Op::OpTypeVector ||
-                vectorType->NumInOperands() < 2u || vectorType->GetSingleWordInOperand(1) != 2u) {
-                return false;
-            }
-            const Instruction* scalarType = defUseMgr->GetDef(vectorType->GetSingleWordInOperand(0));
-            return scalarType != nullptr && scalarType->opcode() == spv::Op::OpTypeFloat &&
-                   scalarType->NumInOperands() == 1u && scalarType->GetSingleWordInOperand(0) == 32u;
-        }
-
-        bool IsVec2FloatInclusiveAdd(IRContext* context, const Instruction* inst) {
-            if (inst->opcode() != spv::Op::OpGroupNonUniformFAdd || inst->NumInOperands() < 3u ||
-                static_cast<spv::GroupOperation>(inst->GetSingleWordInOperand(1)) !=
-                    spv::GroupOperation::InclusiveScan) {
-                return false;
-            }
-            const Instruction* vectorType = context->get_def_use_mgr()->GetDef(inst->type_id());
-            if (vectorType == nullptr || vectorType->opcode() != spv::Op::OpTypeVector ||
-                vectorType->NumInOperands() < 2u || vectorType->GetSingleWordInOperand(1) != 2u) {
-                return false;
-            }
-            const Instruction* scalarType = context->get_def_use_mgr()->GetDef(vectorType->GetSingleWordInOperand(0));
-            return scalarType != nullptr && scalarType->opcode() == spv::Op::OpTypeFloat &&
-                   scalarType->NumInOperands() == 1u && scalarType->GetSingleWordInOperand(0) == 32u;
-        }
-
-        bool HasProgram203LocalSize(IRContext* context) {
-            for (const Instruction& entryPoint : context->module()->entry_points()) {
-                if (static_cast<spv::ExecutionModel>(entryPoint.GetSingleWordInOperand(0)) !=
-                    spv::ExecutionModel::GLCompute) {
-                    return false;
-                }
-            }
-            for (const Instruction& mode : context->module()->execution_modes()) {
-                if (mode.opcode() == spv::Op::OpExecutionMode && mode.NumInOperands() >= 5u &&
-                    static_cast<spv::ExecutionMode>(mode.GetSingleWordInOperand(1)) == spv::ExecutionMode::LocalSize) {
-                    return mode.GetSingleWordInOperand(2) == 32u && mode.GetSingleWordInOperand(3) == 16u &&
-                           mode.GetSingleWordInOperand(4) == 1u;
-                }
-            }
-            return false;
-        }
-
-        bool IsStoreToRoot(IRContext* context, const Instruction* inst, const Instruction* root) {
-            return inst->opcode() == spv::Op::OpStore && inst->NumInOperands() >= 2u &&
-                   RootVariable(context, inst->GetSingleWordInOperand(0)) == root;
-        }
-    } // namespace
-
-    spvtools::opt::Pass::Status FixIterationRPBarrierPass::Process() {
-        auto* irContext = context();
-        if (!HasProgram203LocalSize(irContext)) return Status::SuccessWithoutChange;
-
-        for (auto& function : *irContext->module()) {
-            std::vector<Instruction*> instructions;
-            std::vector<size_t> scans;
-            for (auto& block : function) {
-                for (auto& inst : block) {
-                    if (IsVec2FloatInclusiveAdd(irContext, &inst)) scans.push_back(instructions.size());
-                    instructions.push_back(&inst);
-                }
-            }
-            // Program 203 has exactly two vec2 inclusive adds: the luminance reduction
-            // and the weighted-exposure reduction. More or fewer is not our fingerprint.
-            if (scans.size() != 2u) continue;
-
-            const size_t firstScan = scans[0];
-            const size_t secondScan = scans[1];
-            const Instruction* scratch = nullptr;
-            size_t averageLoad = instructions.size();
-
-            for (size_t i = firstScan + 1u; i < secondScan; ++i) {
-                Instruction* inst = instructions[i];
-                if (inst->opcode() != spv::Op::OpLoad || inst->NumInOperands() < 1u) continue;
-                const Instruction* root = nullptr;
-                if (!IsZeroElementPointer(irContext, inst->GetSingleWordInOperand(0), &root) ||
-                    !IsWorkgroupVec2Array(irContext, root)) {
-                    continue;
-                }
-                // The broadcast is read as prefixSumCache[0].x, hence a scalar load.
-                const Instruction* type = irContext->get_def_use_mgr()->GetDef(inst->type_id());
-                if (type == nullptr || type->opcode() != spv::Op::OpTypeFloat || type->NumInOperands() != 1u ||
-                    type->GetSingleWordInOperand(0) != 32u) {
-                    continue;
-                }
-                scratch = root;
-                averageLoad = i;
-                break;
-            }
-            if (scratch == nullptr) continue;
-
-            bool sawZeroBroadcastStore = false;
-            bool sawPublishBarrier = false;
-            for (size_t i = firstScan + 1u; i < averageLoad; ++i) {
-                const Instruction* root = nullptr;
-                if (instructions[i]->opcode() == spv::Op::OpStore &&
-                    IsZeroElementPointer(irContext, instructions[i]->GetSingleWordInOperand(0), &root) &&
-                    root == scratch) {
-                    sawZeroBroadcastStore = true;
-                } else if (sawZeroBroadcastStore && instructions[i]->opcode() == spv::Op::OpControlBarrier) {
-                    sawPublishBarrier = true;
-                }
-            }
-            if (!sawZeroBroadcastStore || !sawPublishBarrier) continue;
-
-            bool alreadySynchronized = false;
-            for (size_t i = averageLoad + 1u; i < secondScan; ++i) {
-                if (instructions[i]->opcode() == spv::Op::OpControlBarrier) {
-                    alreadySynchronized = true;
-                    break;
-                }
-            }
-            if (alreadySynchronized) return Status::SuccessWithoutChange;
-
-            bool secondPhaseReusesScratch = false;
-            for (size_t i = secondScan + 1u; i < instructions.size(); ++i) {
-                if (IsStoreToRoot(irContext, instructions[i], scratch)) {
-                    secondPhaseReusesScratch = true;
-                    break;
-                }
-            }
-            if (!secondPhaseReusesScratch) continue;
-
-            auto* constantMgr = irContext->get_constant_mgr();
-            const uint32_t scopeId = constantMgr->GetUIntConstId(static_cast<uint32_t>(spv::Scope::Workgroup));
-            const uint32_t semanticsId =
-                constantMgr->GetUIntConstId(static_cast<uint32_t>(spv::MemorySemanticsMask::AcquireRelease) |
-                                            static_cast<uint32_t>(spv::MemorySemanticsMask::WorkgroupMemory));
-            if (scopeId == 0u || semanticsId == 0u) return Status::Failure;
-
-            instructions[secondScan]->InsertBefore(spvtools::MakeUnique<Instruction>(
-                irContext, spv::Op::OpControlBarrier, 0u, 0u,
-                Instruction::OperandList{Operand{SPV_OPERAND_TYPE_ID, {scopeId}},
-                                         Operand{SPV_OPERAND_TYPE_ID, {scopeId}},
-                                         Operand{SPV_OPERAND_TYPE_ID, {semanticsId}}}));
-            irContext->InvalidateAnalysesExceptFor(IRContext::kAnalysisNone);
-            return Status::SuccessWithChange;
-        }
-        return Status::SuccessWithoutChange;
-    }
-
-    spvtools::Optimizer::PassToken FixIterationRPBarrierPass::CreateFixIterationRPBarrierPass() {
-        return spvtools::Optimizer::PassToken(spvtools::MakeUnique<FixIterationRPBarrierPass>());
-    }
-} // namespace MobileGL::MG_Util::ShaderTranspiler

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FixIterationRPBarrierPass.h

@@ -1,28 +0,0 @@
-// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FixIterationRPBarrierPass.h
-// 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
-
-#pragma once
-
-#include "source/opt/pass.h"
-#include "spirv-tools/optimizer.hpp"
-
-namespace MobileGL::MG_Util::ShaderTranspiler {
-    // Repairs iterationRP Program 203's missing workgroup rendezvous between two
-    // reductions that reuse prefixSumCache. The first phase broadcasts its result
-    // through prefixSumCache[0], but the second phase may overwrite that element before
-    // every invocation has read it. The pass fingerprints that exact two-scan,
-    // 512-invocation shape and inserts one Workgroup control barrier immediately before
-    // the second scan. Unrelated modules and already-repaired modules are byte-identical.
-    class FixIterationRPBarrierPass : public spvtools::opt::Pass {
-    public:
-        const char* name() const override { return "fix-iterationrp-barrier"; }
-        Status Process() override;
-
-        static spvtools::Optimizer::PassToken CreateFixIterationRPBarrierPass();
-    };
-} // namespace MobileGL::MG_Util::ShaderTranspiler

android-plugin/app/src/trace/cpp/trace_replay_core.cpp

@@ -164,21 +164,6 @@ bool LoadMobileGL(const Request& request, std::string& error) {
     } else {
         unsetenv("MOBILEGL_COHERENT_AS_FLUSH");
     }
-    if (request.fixIterationRPSubgroupScratch) {
-        setenv("MOBILEGL_FIX_ITERATIONRP_SUBGROUP_SCRATCH", "1", 1);
-    } else {
-        unsetenv("MOBILEGL_FIX_ITERATIONRP_SUBGROUP_SCRATCH");
-    }
-    if (request.deriveNumSubgroups) {
-        setenv("MOBILEGL_DERIVE_NUM_SUBGROUPS", "1", 1);
-    } else {
-        unsetenv("MOBILEGL_DERIVE_NUM_SUBGROUPS");
-    }
-    if (request.iterationRPFixBarrier) {
-        setenv("MOBILEGL_ITERATIONRP_FIX_BARRIER", "1", 1);
-    } else {
-        unsetenv("MOBILEGL_ITERATIONRP_FIX_BARRIER");
-    }
     if (request.fboAttachmentDumps.empty()) {
         unsetenv("MOBILEGL_TRACE_DUMP_FBO_ATTACHMENTS");
     } else {
@@ -833,10 +818,6 @@ bool WriteResultJson(const Request& request, const Result& result) {
          << (request.avoidAngleLlvmpipeSamplerMipmapMinFilter ? "true" : "false") << ",\n";
     file << "  \"avoidAngleLlvmpipeExplicitLodBias\": "
          << (request.avoidAngleLlvmpipeExplicitLodBias ? "true" : "false") << ",\n";
-    file << "  \"fixIterationRPSubgroupScratch\": " << (request.fixIterationRPSubgroupScratch ? "true" : "false")
-         << ",\n";
-    file << "  \"deriveNumSubgroups\": " << (request.deriveNumSubgroups ? "true" : "false") << ",\n";
-    file << "  \"iterationRPFixBarrier\": " << (request.iterationRPFixBarrier ? "true" : "false") << ",\n";
     file << "  \"holdMs\": " << request.holdMs << ",\n";
     file << "  \"mismatchPixels\": " << result.mismatchPixels << "\n";
     file << "}\n";

android-plugin/app/src/trace/cpp/trace_replay_core.hpp

@@ -44,9 +44,6 @@ struct Request {
     bool avoidAngleLlvmpipeSamplerMipmapMinFilter = false;
     bool avoidAngleLlvmpipeExplicitLodBias = false;
     bool coherentAsFlush = false;
-    bool fixIterationRPSubgroupScratch = false;
-    bool deriveNumSubgroups = false;
-    bool iterationRPFixBarrier = false;
     int holdMs = 0;
 };
 

android-plugin/app/src/trace/cpp/trace_replay_jni.cpp

@@ -122,9 +122,6 @@ Java_top_mobilegl_plugin_trace_TraceReplayActivity_nativeRunTraceReplay(JNIEnv*
                                                                         jboolean avoidAngleLlvmpipeSamplerMipmapMinFilter,
                                                                         jboolean avoidAngleLlvmpipeExplicitLodBias,
                                                                         jboolean coherentAsFlush,
-                                                                        jboolean fixIterationRPSubgroupScratch,
-                                                                        jboolean deriveNumSubgroups,
-                                                                        jboolean iterationRPFixBarrier,
                                                                         jstring texture2dDumps) {
     mobilegl_trace::Request request;
     request.tracePath = ToString(env, tracePath);
@@ -153,9 +150,6 @@ Java_top_mobilegl_plugin_trace_TraceReplayActivity_nativeRunTraceReplay(JNIEnv*
         avoidAngleLlvmpipeSamplerMipmapMinFilter == JNI_TRUE;
     request.avoidAngleLlvmpipeExplicitLodBias = avoidAngleLlvmpipeExplicitLodBias == JNI_TRUE;
     request.coherentAsFlush = coherentAsFlush == JNI_TRUE;
-    request.fixIterationRPSubgroupScratch = fixIterationRPSubgroupScratch == JNI_TRUE;
-    request.deriveNumSubgroups = deriveNumSubgroups == JNI_TRUE;
-    request.iterationRPFixBarrier = iterationRPFixBarrier == JNI_TRUE;
 
     ScopedTraceReplayState replayState;
     mobilegl_trace_set_requested_size(request.width, request.height);

android-plugin/app/src/trace/java/top/mobilegl/plugin/trace/TraceReplayActivity.java

@@ -116,9 +116,6 @@ public final class TraceReplayActivity extends Activity {
                 request.avoidAngleLlvmpipeSamplerMipmapMinFilter,
                 request.avoidAngleLlvmpipeExplicitLodBias,
                 request.coherentAsFlush,
-                request.fixIterationRPSubgroupScratch,
-                request.deriveNumSubgroups,
-                request.iterationRPFixBarrier,
                 request.texture2dDumps
         );
         Log.i(TAG, result.toString());
@@ -152,9 +149,6 @@ public final class TraceReplayActivity extends Activity {
             boolean avoidAngleLlvmpipeSamplerMipmapMinFilter,
             boolean avoidAngleLlvmpipeExplicitLodBias,
             boolean coherentAsFlush,
-            boolean fixIterationRPSubgroupScratch,
-            boolean deriveNumSubgroups,
-            boolean iterationRPFixBarrier,
             String texture2dDumps
     );
 
@@ -180,9 +174,6 @@ public final class TraceReplayActivity extends Activity {
         final boolean avoidAngleLlvmpipeSamplerMipmapMinFilter;
         final boolean avoidAngleLlvmpipeExplicitLodBias;
         final boolean coherentAsFlush;
-        final boolean fixIterationRPSubgroupScratch;
-        final boolean deriveNumSubgroups;
-        final boolean iterationRPFixBarrier;
         final String texture2dDumps;
 
         private TraceReplayRequest(
@@ -207,9 +198,6 @@ public final class TraceReplayActivity extends Activity {
                 boolean avoidAngleLlvmpipeSamplerMipmapMinFilter,
                 boolean avoidAngleLlvmpipeExplicitLodBias,
                 boolean coherentAsFlush,
-                boolean fixIterationRPSubgroupScratch,
-                boolean deriveNumSubgroups,
-                boolean iterationRPFixBarrier,
                     String texture2dDumps
         ) {
             this.tracePath = tracePath;
@@ -233,9 +221,6 @@ public final class TraceReplayActivity extends Activity {
             this.avoidAngleLlvmpipeSamplerMipmapMinFilter = avoidAngleLlvmpipeSamplerMipmapMinFilter;
             this.avoidAngleLlvmpipeExplicitLodBias = avoidAngleLlvmpipeExplicitLodBias;
             this.coherentAsFlush = coherentAsFlush;
-            this.fixIterationRPSubgroupScratch = fixIterationRPSubgroupScratch;
-            this.deriveNumSubgroups = deriveNumSubgroups;
-            this.iterationRPFixBarrier = iterationRPFixBarrier;
             this.texture2dDumps = texture2dDumps;
         }
 
@@ -264,9 +249,6 @@ public final class TraceReplayActivity extends Activity {
                     intent.getBooleanExtra("avoid_angle_llvmpipe_sampler_mipmap_min_filter", false),
                     intent.getBooleanExtra("avoid_angle_llvmpipe_explicit_lod_bias", false),
                     intent.getBooleanExtra("coherent_as_flush", false),
-                    intent.getBooleanExtra("fix_iterationrp_subgroup_scratch", false),
-                    intent.getBooleanExtra("derive_num_subgroups", false),
-                    intent.getBooleanExtra("iterationrp_fix_barrier", false),
                     readString(intent, "texture_2d_dumps", "")
             );
         }

android-plugin/trace-replay-ci.sh

@@ -40,9 +40,6 @@ Set MOBILEGL_TRACE_ANGLE_VARIANT to the packaged ANGLE short hash used by
 DirectGLES replay.
 Set MOBILEGL_RETRACE_USE_PBUFFER=1 or pass --use-pbuffer to run DirectGLES
 against an offscreen EGL pbuffer instead of the Activity surface.
-Set MOBILEGL_FIX_ITERATIONRP_SUBGROUP_SCRATCH=1,
-MOBILEGL_DERIVE_NUM_SUBGROUPS=1, and MOBILEGL_ITERATIONRP_FIX_BARRIER=1 to
-forward the corresponding iterationRP SPIR-V repairs into the APK process.
 Pass --avoid-angle-llvmpipe-sampler-mipmap-min-filter for DirectGLES traces that
 need ANGLE llvmpipe sampler mipmap filters downgraded to avoid driver stalls.
 Pass --avoid-angle-llvmpipe-explicit-lod-bias for DirectGLES traces whose shaders
@@ -366,15 +363,6 @@ run_retrace() {
   if [ "${coherent_as_flush}" -eq 1 ]; then
     set -- "$@" --ez coherent_as_flush true
   fi
-  if [ "${MOBILEGL_FIX_ITERATIONRP_SUBGROUP_SCRATCH:-}" = "1" ]; then
-    set -- "$@" --ez fix_iterationrp_subgroup_scratch true
-  fi
-  if [ "${MOBILEGL_DERIVE_NUM_SUBGROUPS:-}" = "1" ]; then
-    set -- "$@" --ez derive_num_subgroups true
-  fi
-  if [ "${MOBILEGL_ITERATIONRP_FIX_BARRIER:-}" = "1" ]; then
-    set -- "$@" --ez iterationrp_fix_barrier true
-  fi
   if [ -n "${texture_2d_dumps}" ]; then
     set -- "$@" --es texture_2d_dumps "${texture_2d_dumps}"
   fi

tools/trace_replay/trace_replay_cli.cpp

@@ -72,16 +72,8 @@ bool ReadDouble(int argc, char **argv, int &index, double &out) {
     return true;
 }
 
-bool ReadEnvFlag(const char *name) {
-    const char *value = std::getenv(name);
-    return value != nullptr && std::string(value) == "1";
-}
-
 bool ParseArgs(int argc, char **argv, mobilegl_trace::Request &request) {
     request.backend = "DirectGLES";
-    request.fixIterationRPSubgroupScratch = ReadEnvFlag("MOBILEGL_FIX_ITERATIONRP_SUBGROUP_SCRATCH");
-    request.deriveNumSubgroups = ReadEnvFlag("MOBILEGL_DERIVE_NUM_SUBGROUPS");
-    request.iterationRPFixBarrier = ReadEnvFlag("MOBILEGL_ITERATIONRP_FIX_BARRIER");
 
     for (int i = 1; i < argc; ++i) {
         const std::string arg = argv[i];