Subject: [PATCH 19/24] wip: add hardware-validated tiled test-only probe

From: Justin Youens <[email-masked]>
Date: Sat, 15 Aug 2026 14:27:35 -0500

---
 src/backend/drm/DRM.cpp                   | 301 ++++++++++++++++++++++
 src/backend/drm/TiledAtomic.hpp           |   6 +
 src/backend/drm/TiledDRMIntegration.cpp   |  68 ++++-
 src/backend/drm/TiledDRMIntegration.hpp   |  11 +
 src/backend/drm/TiledRuntimeAuthority.cpp | 104 +++++++-
 src/backend/drm/TiledRuntimeAuthority.hpp |  48 +++-
 6 files changed, 517 insertions(+), 21 deletions(-)

diff --git a/src/backend/drm/DRM.cpp b/src/backend/drm/DRM.cpp
index 0617b2fd6b29b663832a53b0b45dd202cb1f50d7..e00a604d6194fbcde8ddb81f71eadfa0ac7a54a0 100644
--- a/src/backend/drm/DRM.cpp
+++ b/src/backend/drm/DRM.cpp
@@ -12,6 +12,7 @@
 #include <hyprutils/string/VarList.hpp>
 #include <chrono>
 #include <cstdio>
+#include <cstdlib>
 #include <thread>
 #include <deque>
 #include <unordered_map>
@@ -19,6 +20,7 @@
 #include <exception>
 #include <filesystem>
 #include <limits>
+#include <map>
 #include <set>
 #include <span>
 #include <system_error>
@@ -61,6 +63,10 @@ namespace {
     using Aquamarine::NDRM::NTiledDRMIntegration::eAllocationCaptureResult;
     using Aquamarine::NDRM::NTiledDRMIntegration::eScanCommitResult;
     using Aquamarine::NDRM::NTiledDRMIntegration::eScanStageResult;
+    using Aquamarine::NDRM::NTiledRuntimeAuthority::SGroupedTestKMSCapture;
+    using Aquamarine::NDRM::NTiledRuntimeAuthority::SGroupedTestLivePlaneCapture;
+    using Aquamarine::NDRM::NTiledDRMIntegration::SGroupedTestProbeResult;
+    using Aquamarine::NDRM::NTiledAtomic::eTiledReplacementPlaneRole;
     using Aquamarine::NDRM::NTiledScan::SConnectorView;
     using Aquamarine::NDRM::NTiledScan::eScanCompleteness;
 
@@ -86,6 +92,27 @@ namespace {
         return LAST_LEGACY_SCAN_KEY == key && LAST_LEGACY_SCAN_COMPLETE;
     }
 
+    bool tiledProbeEnabled() noexcept {
+        const auto* const VALUE = std::getenv("AQ_DRM_TILED_PROBE");
+        return VALUE && std::strcmp(VALUE, "1") == 0;
+    }
+
+    void logTiledProbeResult(const CWeakPointer<CBackend>& backend, const std::string& device, const SGroupedTestProbeResult& probe) {
+        const auto LOGGER = backend.lock();
+        if (!LOGGER || !probe.attempted)
+            return;
+        if (probe.test) {
+            LOGGER->log(AQ_LOG_WARNING, std::format("drm: AQ_DRM_TILED_PROBE=1 TEST_ONLY PASS on {}", device));
+            return;
+        }
+        const auto EXECUTION = probe.test.executionStatus ? static_cast<uint32_t>(*probe.test.executionStatus) : std::numeric_limits<uint32_t>::max();
+        const auto RETURN    = probe.test.submission ? probe.test.submission->returnCode : 0;
+        const auto ERROR     = probe.test.submission ? probe.test.submission->error : 0;
+        LOGGER->log(AQ_LOG_ERROR,
+                    std::format("drm: AQ_DRM_TILED_PROBE=1 TEST_ONLY FAIL on {} status={} route={} execution={} return={} errno={}", device,
+                                static_cast<uint32_t>(probe.test.status), static_cast<uint32_t>(probe.test.routeError), EXECUTION, RETURN, ERROR));
+    }
+
     struct SDRMResourcesSnapshot {
         uint32_t              minWidth  = 0;
         uint32_t              maxWidth  = 0;
@@ -326,6 +353,264 @@ namespace {
         return capture;
     }
 
+    struct SProbePlaneFingerprint {
+        uint64_t type             = 0;
+        uint32_t possibleCRTCMask = 0;
+        uint32_t crtcId           = 0;
+        uint32_t framebufferId    = 0;
+
+        bool     operator==(const SProbePlaneFingerprint&) const = default;
+    };
+
+    std::optional<SP<CDRMFB>> cachedPlaneFramebuffer(const SP<SDRMPlane>& plane, uint32_t framebufferId) {
+        if (!plane)
+            return std::nullopt;
+        if (framebufferId == 0)
+            return SP<CDRMFB>{};
+
+        SP<CDRMFB> result;
+        for (const auto& CANDIDATE : std::array{plane->front, plane->back, plane->last}) {
+            if (!CANDIDATE || CANDIDATE->id != framebufferId)
+                continue;
+            if (result && result.impl_ != CANDIDATE.impl_)
+                return std::nullopt;
+            result = CANDIDATE;
+        }
+        if (!result || result->dead || !result->buffer || result->backend.impl_ != plane->backend.impl_)
+            return std::nullopt;
+        return result;
+    }
+
+    std::optional<SProbePlaneFingerprint> readProbePlane(int fd, const SP<SDRMPlane>& owner) {
+        if (!owner || owner->id == 0 || owner->props.values.type == 0 || owner->props.values.fb_id == 0 || owner->props.values.crtc_id == 0)
+            return std::nullopt;
+        uint64_t type = 0, framebuffer = 0, crtc = 0;
+        if (!getDRMProp(fd, owner->id, owner->props.values.type, &type) || !getDRMProp(fd, owner->id, owner->props.values.fb_id, &framebuffer) ||
+            !getDRMProp(fd, owner->id, owner->props.values.crtc_id, &crtc) || framebuffer > std::numeric_limits<uint32_t>::max() || crtc > std::numeric_limits<uint32_t>::max())
+            return std::nullopt;
+        auto* const PLANE = drmModeGetPlane(fd, owner->id);
+        if (!PLANE)
+            return std::nullopt;
+        CScopeGuard planeGuard([PLANE] { drmModeFreePlane(PLANE); });
+        if (PLANE->plane_id != owner->id || PLANE->fb_id != framebuffer || PLANE->crtc_id != crtc || owner->type != type)
+            return std::nullopt;
+        return SProbePlaneFingerprint{
+            .type             = type,
+            .possibleCRTCMask = PLANE->possible_crtcs,
+            .crtcId           = PLANE->crtc_id,
+            .framebufferId    = PLANE->fb_id,
+        };
+    }
+
+    std::optional<bool> readProbeCrtcActive(int fd, const SP<SDRMCRTC>& owner) {
+        if (!owner || owner->id == 0)
+            return std::nullopt;
+        auto* const CRTC = drmModeGetCrtc(fd, owner->id);
+        if (!CRTC)
+            return std::nullopt;
+        CScopeGuard crtcGuard([CRTC] { drmModeFreeCrtc(CRTC); });
+        if (CRTC->crtc_id != owner->id)
+            return std::nullopt;
+        bool active = CRTC->mode_valid || CRTC->buffer_id != 0;
+        if (owner->props.values.active != 0) {
+            uint64_t value = 0;
+            if (!getDRMProp(fd, owner->id, owner->props.values.active, &value))
+                return std::nullopt;
+            active = value != 0;
+        }
+        return active;
+    }
+
+    std::optional<SGroupedTestKMSCapture> captureGroupedTestKMS(int fd, const std::vector<SP<SDRMConnector>>& connectors, const std::vector<SP<SDRMCRTC>>& crtcs,
+                                                                const std::vector<SP<SDRMPlane>>& planes, uint32_t& failureStage) {
+        failureStage                = 1;
+        auto* const FIRST_RESOURCES = drmModeGetResources(fd);
+        if (!FIRST_RESOURCES)
+            return std::nullopt;
+        CScopeGuard firstResourcesGuard([FIRST_RESOURCES] { drmModeFreeResources(FIRST_RESOURCES); });
+        const auto  FIRST = copyResourcesSnapshot(FIRST_RESOURCES);
+        if (!FIRST || !exactResourceOwners(FIRST->connectors, connectors) || !exactResourceOwners(FIRST->crtcs, crtcs) || FIRST->crtcs.size() > 32)
+            return std::nullopt;
+
+        failureStage                      = 2;
+        auto* const FIRST_PLANE_RESOURCES = drmModeGetPlaneResources(fd);
+        if (!FIRST_PLANE_RESOURCES)
+            return std::nullopt;
+        CScopeGuard firstPlaneResourcesGuard([FIRST_PLANE_RESOURCES] { drmModeFreePlaneResources(FIRST_PLANE_RESOURCES); });
+        const auto  FIRST_PLANE_IDS = copyPlaneResourceIDs(FIRST_PLANE_RESOURCES);
+        if (!FIRST_PLANE_IDS || !exactResourceOwners(*FIRST_PLANE_IDS, planes))
+            return std::nullopt;
+
+        failureStage              = 3;
+        auto* const FIRST_LESSEES = drmModeListLessees(fd);
+        if (!FIRST_LESSEES)
+            return std::nullopt;
+        CScopeGuard firstLesseesGuard([FIRST_LESSEES] { drmFree(FIRST_LESSEES); });
+        if (FIRST_LESSEES->count != 0)
+            return std::nullopt;
+
+        SGroupedTestKMSCapture                     capture;
+        std::map<uint32_t, uint32_t>               connectorByCrtc;
+        std::map<uint32_t, uint32_t>               primaryPlaneByCrtc;
+        std::map<uint32_t, size_t>                 planesByCrtc;
+        std::map<uint32_t, bool>                   activeCrtcs;
+        std::map<uint32_t, SProbePlaneFingerprint> planeFingerprints;
+        capture.connectors.reserve(connectors.size());
+        capture.crtcs.reserve(crtcs.size());
+        capture.planes.reserve(planes.size());
+
+        failureStage = 4;
+        for (const auto CONNECTOR_ID : FIRST->connectors) {
+            const auto OWNER = std::ranges::find(connectors, CONNECTOR_ID, &SDRMConnector::id);
+            if (OWNER == connectors.end() || (*OWNER)->props.values.crtc_id == 0)
+                return std::nullopt;
+            auto* const CONNECTOR = drmModeGetConnector(fd, CONNECTOR_ID);
+            if (!CONNECTOR)
+                return std::nullopt;
+            CScopeGuard connectorGuard([CONNECTOR] { drmModeFreeConnector(CONNECTOR); });
+            if (CONNECTOR->connector_id != CONNECTOR_ID)
+                return std::nullopt;
+            const auto CRTC_ID = currentConnectorCRTCID(fd, **OWNER, CONNECTOR, FIRST->encoders);
+            if (!CRTC_ID || (*CRTC_ID != 0 && !std::ranges::contains(FIRST->crtcs, *CRTC_ID)))
+                return std::nullopt;
+            SP<SDRMCRTC> attached;
+            if (*CRTC_ID != 0) {
+                const auto CRTC = std::ranges::find(crtcs, *CRTC_ID, &SDRMCRTC::id);
+                if (CRTC == crtcs.end() || !connectorByCrtc.emplace(*CRTC_ID, CONNECTOR_ID).second)
+                    return std::nullopt;
+                attached = *CRTC;
+            }
+            capture.connectors.push_back({.connector = *OWNER, .attachedCrtc = std::move(attached)});
+        }
+
+        failureStage = 5;
+        for (const auto CRTC_ID : FIRST->crtcs) {
+            const auto OWNER = std::ranges::find(crtcs, CRTC_ID, &SDRMCRTC::id);
+            if (OWNER == crtcs.end() || (*OWNER)->pendingFlip.id.has_value())
+                return std::nullopt;
+            const auto ACTIVE = readProbeCrtcActive(fd, *OWNER);
+            if (!ACTIVE)
+                return std::nullopt;
+            activeCrtcs.emplace(CRTC_ID, *ACTIVE);
+            capture.crtcs.push_back({.crtc = *OWNER});
+        }
+
+        failureStage = 6;
+        for (const auto PLANE_ID : *FIRST_PLANE_IDS) {
+            const auto OWNER = std::ranges::find(planes, PLANE_ID, &SDRMPlane::id);
+            if (OWNER == planes.end()) {
+                failureStage = 600'000 + (PLANE_ID * 10) + 1;
+                return std::nullopt;
+            }
+            const auto FINGERPRINT = readProbePlane(fd, *OWNER);
+            if (!FINGERPRINT) {
+                failureStage = 600'000 + (PLANE_ID * 10) + 2;
+                return std::nullopt;
+            }
+            const auto VALID_CRTC_MASK = FIRST->crtcs.size() == 32 ? std::numeric_limits<uint32_t>::max() : (uint32_t{1} << FIRST->crtcs.size()) - 1;
+            if ((FINGERPRINT->possibleCRTCMask & VALID_CRTC_MASK) == 0) {
+                failureStage = 600'000 + (PLANE_ID * 10) + 3;
+                return std::nullopt;
+            }
+            if ((FINGERPRINT->crtcId == 0) != (FINGERPRINT->framebufferId == 0)) {
+                failureStage = 600'000 + (PLANE_ID * 10) + 4;
+                return std::nullopt;
+            }
+            if (FINGERPRINT->crtcId != 0 && !std::ranges::contains(FIRST->crtcs, FINGERPRINT->crtcId)) {
+                failureStage = 600'000 + (PLANE_ID * 10) + 5;
+                return std::nullopt;
+            }
+
+            eTiledReplacementPlaneRole role;
+            switch (FINGERPRINT->type) {
+                case DRM_PLANE_TYPE_PRIMARY: role = eTiledReplacementPlaneRole::PRIMARY; break;
+                case DRM_PLANE_TYPE_CURSOR: role = eTiledReplacementPlaneRole::CURSOR; break;
+                case DRM_PLANE_TYPE_OVERLAY: role = eTiledReplacementPlaneRole::OVERLAY; break;
+                default: failureStage = 600'000 + (PLANE_ID * 10) + 6; return std::nullopt;
+            }
+            const auto FRAMEBUFFER = cachedPlaneFramebuffer(*OWNER, FINGERPRINT->framebufferId);
+            if (!FRAMEBUFFER) {
+                failureStage = 600'000 + (PLANE_ID * 10) + 7;
+                return std::nullopt;
+            }
+            if (FINGERPRINT->crtcId != 0) {
+                ++planesByCrtc[FINGERPRINT->crtcId];
+                if (role == eTiledReplacementPlaneRole::PRIMARY && !primaryPlaneByCrtc.emplace(FINGERPRINT->crtcId, PLANE_ID).second) {
+                    failureStage = 600'000 + (PLANE_ID * 10) + 8;
+                    return std::nullopt;
+                }
+            }
+            planeFingerprints.emplace(PLANE_ID, *FINGERPRINT);
+            capture.planes.push_back({
+                .id            = PLANE_ID,
+                .owner         = *OWNER,
+                .role          = role,
+                .crtcId        = FINGERPRINT->crtcId,
+                .framebufferId = FINGERPRINT->framebufferId,
+                .framebuffer   = *FRAMEBUFFER,
+            });
+        }
+
+        failureStage = 7;
+        for (const auto& [CRTC_ID, ACTIVE] : activeCrtcs) {
+            const bool HAS_CONNECTOR = connectorByCrtc.contains(CRTC_ID);
+            const bool HAS_PRIMARY   = primaryPlaneByCrtc.contains(CRTC_ID);
+            const bool HAS_PLANE     = planesByCrtc.contains(CRTC_ID);
+            if (ACTIVE ? (!HAS_CONNECTOR || !HAS_PRIMARY) : (HAS_CONNECTOR || HAS_PLANE))
+                return std::nullopt;
+        }
+
+        failureStage                       = 8;
+        auto* const SECOND_PLANE_RESOURCES = drmModeGetPlaneResources(fd);
+        if (!SECOND_PLANE_RESOURCES)
+            return std::nullopt;
+        CScopeGuard secondPlaneResourcesGuard([SECOND_PLANE_RESOURCES] { drmModeFreePlaneResources(SECOND_PLANE_RESOURCES); });
+        const auto  SECOND_PLANE_IDS = copyPlaneResourceIDs(SECOND_PLANE_RESOURCES);
+        auto* const SECOND_RESOURCES = drmModeGetResources(fd);
+        if (!SECOND_RESOURCES)
+            return std::nullopt;
+        CScopeGuard secondResourcesGuard([SECOND_RESOURCES] { drmModeFreeResources(SECOND_RESOURCES); });
+        const auto  SECOND = copyResourcesSnapshot(SECOND_RESOURCES);
+        if (!SECOND_PLANE_IDS || *SECOND_PLANE_IDS != *FIRST_PLANE_IDS || !SECOND || *SECOND != *FIRST)
+            return std::nullopt;
+
+        failureStage = 9;
+        for (const auto& CONNECTOR_CAPTURE : capture.connectors) {
+            auto* const CONNECTOR = drmModeGetConnector(fd, CONNECTOR_CAPTURE.connector->id);
+            if (!CONNECTOR)
+                return std::nullopt;
+            CScopeGuard connectorGuard([CONNECTOR] { drmModeFreeConnector(CONNECTOR); });
+            const auto  CRTC_ID = currentConnectorCRTCID(fd, *CONNECTOR_CAPTURE.connector, CONNECTOR, SECOND->encoders);
+            if (!CRTC_ID || *CRTC_ID != (CONNECTOR_CAPTURE.attachedCrtc ? CONNECTOR_CAPTURE.attachedCrtc->id : 0))
+                return std::nullopt;
+        }
+        failureStage = 10;
+        for (const auto& CRTC_CAPTURE : capture.crtcs) {
+            const auto ACTIVE = readProbeCrtcActive(fd, CRTC_CAPTURE.crtc);
+            if (!ACTIVE || *ACTIVE != activeCrtcs.at(CRTC_CAPTURE.crtc->id) || CRTC_CAPTURE.crtc->pendingFlip.id.has_value())
+                return std::nullopt;
+        }
+        failureStage = 11;
+        for (const auto& PLANE_CAPTURE : capture.planes) {
+            const auto FINGERPRINT = readProbePlane(fd, PLANE_CAPTURE.owner);
+            if (!FINGERPRINT || *FINGERPRINT != planeFingerprints.at(PLANE_CAPTURE.id))
+                return std::nullopt;
+            const auto FRAMEBUFFER = cachedPlaneFramebuffer(PLANE_CAPTURE.owner, PLANE_CAPTURE.framebufferId);
+            if (!FRAMEBUFFER || FRAMEBUFFER->impl_ != PLANE_CAPTURE.framebuffer.impl_)
+                return std::nullopt;
+        }
+
+        failureStage               = 12;
+        auto* const SECOND_LESSEES = drmModeListLessees(fd);
+        if (!SECOND_LESSEES)
+            return std::nullopt;
+        CScopeGuard secondLesseesGuard([SECOND_LESSEES] { drmFree(SECOND_LESSEES); });
+        if (SECOND_LESSEES->count != 0)
+            return std::nullopt;
+        failureStage = 0;
+        return capture;
+    }
+
     std::optional<uint64_t> rawConnectorProperty(const drmModeConnector* connector, uint32_t propertyId) {
         if (!connector || propertyId == 0 || connector->count_props < 0 || (connector->count_props > 0 && (!connector->props || !connector->prop_values)))
             return std::nullopt;
@@ -1444,6 +1729,22 @@ void Aquamarine::CDRMBackend::recheckOutputs() {
     try {
         if (RESULT != eAllocationCaptureResult::INSTALLED && RESULT != eAllocationCaptureResult::SHADOW_DISABLED)
             backend->log(AQ_LOG_DEBUG, std::format("drm: Tiled allocation shadow unavailable for {} ({})", gpu->path, static_cast<uint32_t>(RESULT)));
+
+        // The first discovery pass runs before this DRM implementation has a
+        // usable allocator. Defer the one-shot probe until the post-renderer
+        // recheck, otherwise framebuffer acquisition would fail before a KMS
+        // TEST_ONLY request can be built.
+        const bool HAS_TEST_ALLOCATOR = (dumbAllocator && dumbAllocator->drmFD() == gpu->fd) || (backend->primaryAllocator && backend->primaryAllocator->drmFD() == gpu->fd);
+        if (!tiledProbeEnabled() || RESULT != eAllocationCaptureResult::INSTALLED || !HAS_TEST_ALLOCATOR)
+            return;
+        uint32_t   captureFailureStage = 0;
+        const auto PROBE               = NDRM::NTiledDRMIntegration::probeCurrentGroupedTestModeset(SELF, [&]() {
+            auto capture = captureGroupedTestKMS(gpu->fd, connectors, crtcs, planes, captureFailureStage);
+            if (!capture)
+                backend->log(AQ_LOG_ERROR, std::format("drm: AQ_DRM_TILED_PROBE=1 live capture failed at stage {}", captureFailureStage));
+            return capture;
+        });
+        logTiledProbeResult(backend, gpu->path, PROBE);
     } catch (...) { return; }
 }
 
diff --git a/src/backend/drm/TiledAtomic.hpp b/src/backend/drm/TiledAtomic.hpp
index e3eaf66bbd0bd33f7c528fe9f275cf8a5e2b7265..aa09a90679f290e696ec11d40f83df6c0e59ccd8 100644
--- a/src/backend/drm/TiledAtomic.hpp
+++ b/src/backend/drm/TiledAtomic.hpp
@@ -22,6 +22,10 @@ namespace Aquamarine::NDRM::NTiledRuntimeAuthorityTest {
     class CFixtureAuthority;
 }
 
+namespace Aquamarine::NDRM::NTiledRuntimeAuthority {
+    class CGroupedRuntimeAuthority;
+}
+
 namespace Aquamarine::NDRM::NTiledDRMIntegrationTest {
     class CFixtureAuthority;
 }
@@ -268,6 +272,7 @@ namespace Aquamarine::NDRM::NTiledAtomic { // NOLINT(readability-identifier-nami
         bool                                         m_dead = true;
 
         friend class ::Aquamarine::NDRM::NTiledRuntimeAuthorityTest::CFixtureAuthority;
+        friend class ::Aquamarine::NDRM::NTiledRuntimeAuthority::CGroupedRuntimeAuthority;
         friend class ::Aquamarine::NDRM::NTiledDRMIntegrationTest::CFixtureAuthority;
         friend class ::Aquamarine::NDRM::NTiledDRMIntegration::CTiledDRMIntegrationRegistry;
     };
@@ -370,6 +375,7 @@ namespace Aquamarine::NDRM::NTiledAtomic { // NOLINT(readability-identifier-nami
         std::vector<STiledReplacementPlane>        m_planes;
 
         friend class ::Aquamarine::NDRM::NTiledRuntimeAuthorityTest::CFixtureAuthority;
+        friend class ::Aquamarine::NDRM::NTiledRuntimeAuthority::CGroupedRuntimeAuthority;
         friend class ::Aquamarine::NDRM::NTiledDRMIntegrationTest::CFixtureAuthority;
         friend class ::Aquamarine::NDRM::NTiledDRMIntegration::CTiledDRMIntegrationRegistry;
     };
diff --git a/src/backend/drm/TiledDRMIntegration.cpp b/src/backend/drm/TiledDRMIntegration.cpp
index 3cf40b36589ebf53abb2aadfab3d0d82f17daf6c..0220604686f336a534c65d361efd1b0a7b7fd7b8 100644
--- a/src/backend/drm/TiledDRMIntegration.cpp
+++ b/src/backend/drm/TiledDRMIntegration.cpp
@@ -114,8 +114,9 @@ class CTiledDRMIntegrationRegistry::CImpl {
         PAllocationShadow                                           allocationShadow;
         CSharedPointer<COutputBridgeState>                          outputBridge;
         Hyprutils::Memory::CUniquePointer<CGroupedRuntimeAuthority> groupedRuntime;
-        bool                                                        allocationGateActive = false;
-        bool                                                        detachBegun          = false;
+        bool                                                        allocationGateActive      = false;
+        bool                                                        groupedTestProbeAttempted = false;
+        bool                                                        detachBegun               = false;
         std::optional<eDetachTerminalProof>                         terminalProof;
         // Diagnostic context only. terminalizeDetachedKey() never derives an
         // authorization proof from this value.
@@ -1022,6 +1023,63 @@ SGroupedTestModesetResult CTiledDRMIntegrationRegistry::executeCurrentGroupedTes
     return executeCurrentGroupedTestModesetKey(backend.impl_, expected, replacement, group, outputMode);
 }
 
+SGroupedTestProbeResult CTiledDRMIntegrationRegistry::probeCurrentGroupedTestModesetKey(const void* key, const TGroupedTestKMSCaptureProvider& captureProvider) noexcept {
+    const auto THREAD = m_impl->registeredThread(key);
+    if (!THREAD || *THREAD != std::this_thread::get_id() || !captureProvider)
+        return {};
+    const auto ENTRY = m_impl->entries.find(key);
+    if (ENTRY == m_impl->entries.end() || ENTRY->second.detachBegun || ENTRY->second.groupedTestProbeAttempted || !ENTRY->second.outputBridge || !ENTRY->second.groupedRuntime ||
+        !ENTRY->second.allocationShadow || m_impl->mutationBusy(ENTRY->second))
+        return {};
+
+    ENTRY->second.groupedTestProbeAttempted = true;
+    SGroupedTestProbeResult result{.attempted = true};
+    const auto              SHADOW        = ENTRY->second.allocationShadow;
+    bool                    bridgeCurrent = false;
+    bool                    invoked       = false;
+    try {
+        const auto ALLOCATION_CURRENT = withCurrentAllocationKey(key, SHADOW, [&](const CPlan&, const SCurrentState& current) {
+            const auto CURRENT_ENTRY = m_impl->entries.find(key);
+            if (CURRENT_ENTRY == m_impl->entries.end() || !CURRENT_ENTRY->second.outputBridge || !CURRENT_ENTRY->second.groupedRuntime)
+                return;
+            bridgeCurrent = CURRENT_ENTRY->second.outputBridge->withCurrentOwner(current, [&](const POutputBridgeObservation& observation) {
+                const CGroupProjection* selected = nullptr;
+                for (const auto& candidate : observation->groups()) {
+                    if (candidate.projection() != eGroupProjection::MULTI_STREAM_ALLOCATED || !candidate.scanDefinition() || !candidate.modeSet() ||
+                        candidate.modeSet()->modes().empty())
+                        continue;
+                    selected = &candidate;
+                    break;
+                }
+                if (!selected)
+                    return;
+
+                const auto MODES = selected->modeSet()->modes();
+                auto       mode  = std::ranges::find_if(MODES, [](const auto& binding) {
+                    return binding.outputMode && binding.outputMode->pixelSize.x == 5120.0 && binding.outputMode->pixelSize.y == 2880.0 && binding.outputMode->preferred;
+                });
+                if (mode == MODES.end()) {
+                    mode = std::ranges::find_if(
+                        MODES, [](const auto& binding) { return binding.outputMode && binding.outputMode->pixelSize.x == 5120.0 && binding.outputMode->pixelSize.y == 2880.0; });
+                }
+                if (mode == MODES.end() || !mode->outputMode)
+                    return;
+
+                invoked     = true;
+                result.test = CURRENT_ENTRY->second.groupedRuntime->executeCurrentTestProbe(observation, selected->scanDefinition(), mode->outputMode, captureProvider);
+            });
+        });
+        if (!ALLOCATION_CURRENT || !bridgeCurrent || !invoked)
+            result.test = {.status = eGroupedTestModesetStatus::INVALID_CURRENT};
+    } catch (...) { result.test = {.status = eGroupedTestModesetStatus::ALLOCATION_FAILED}; }
+    return result;
+}
+
+SGroupedTestProbeResult CTiledDRMIntegrationRegistry::probeCurrentGroupedTestModeset(const CWeakPointer<CDRMBackend>&      backend,
+                                                                                     const TGroupedTestKMSCaptureProvider& captureProvider) noexcept {
+    return probeCurrentGroupedTestModesetKey(backend.impl_, captureProvider);
+}
+
 SGroupedInitialFrameResult CTiledDRMIntegrationRegistry::submitCurrentGroupedInitialFrameKey(const void* key, const POutputBridgeObservation& expected,
                                                                                              const PResolvedTiledAtomicReplacement& replacement, const PScanGroupDefinition& group,
                                                                                              const CSharedPointer<SOutputMode>& outputMode,
@@ -1425,6 +1483,12 @@ eAllocationCaptureResult Aquamarine::NDRM::NTiledDRMIntegration::captureAllocati
     return REGISTRY ? REGISTRY->captureAllocationShadow(backend, std::move(capture)) : eAllocationCaptureResult::SHADOW_DISABLED;
 }
 
+SGroupedTestProbeResult Aquamarine::NDRM::NTiledDRMIntegration::probeCurrentGroupedTestModeset(const CWeakPointer<CDRMBackend>&      backend,
+                                                                                               const TGroupedTestKMSCaptureProvider& captureProvider) noexcept {
+    auto* const REGISTRY = productionRegistryIfCreated();
+    return REGISTRY ? REGISTRY->probeCurrentGroupedTestModeset(backend, captureProvider) : SGroupedTestProbeResult{};
+}
+
 PAllocationShadow Aquamarine::NDRM::NTiledDRMIntegration::currentAllocationShadow(const CWeakPointer<CDRMBackend>& backend) noexcept {
     auto* const REGISTRY = productionRegistryIfCreated();
     return REGISTRY ? REGISTRY->currentAllocationShadow(backend) : PAllocationShadow{};
diff --git a/src/backend/drm/TiledDRMIntegration.hpp b/src/backend/drm/TiledDRMIntegration.hpp
index d7072204e54ca5dba0578c5d4203911e40bbf259..6ab79c76786c9572afb12c9a60a6ca97b8a7537c 100644
--- a/src/backend/drm/TiledDRMIntegration.hpp
+++ b/src/backend/drm/TiledDRMIntegration.hpp
@@ -37,6 +37,7 @@ namespace Aquamarine::NDRM::NTiledDRMIntegration { // NOLINT(readability-identif
     using NTiledRuntimeAuthority::SGroupedPageFlipResult;
     using NTiledRuntimeAuthority::SGroupedInitialFrameResult;
     using NTiledRuntimeAuthority::SGroupedTestModesetResult;
+    using NTiledRuntimeAuthority::TGroupedTestKMSCaptureProvider;
     using NTiledRuntimeAuthority::PGroupedPublicationInstance;
     using NTiledScan::PCommittedScan;
     using NTiledScan::PScanGroupDefinition;
@@ -55,6 +56,11 @@ namespace Aquamarine::NDRM::NTiledDRMIntegration { // NOLINT(readability-identif
         INVALID_STATE,
     };
 
+    struct AQ_TILED_DRM_PRIVATE SGroupedTestProbeResult {
+        bool                      attempted = false;
+        SGroupedTestModesetResult test;
+    };
+
     enum class eScanStageResult : uint8_t {
         PREPARED = 0,
         INCOMPLETE,
@@ -242,6 +248,8 @@ namespace Aquamarine::NDRM::NTiledDRMIntegration { // NOLINT(readability-identif
         [[nodiscard]] SGroupedTestModesetResult  executeCurrentGroupedTestModeset(const CWeakPointer<CDRMBackend>& backend, const POutputBridgeObservation& expected,
                                                                                   const NTiledAtomic::PResolvedTiledAtomicReplacement& replacement,
                                                                                   const PScanGroupDefinition& group, const CSharedPointer<SOutputMode>& outputMode) noexcept;
+        [[nodiscard]] SGroupedTestProbeResult    probeCurrentGroupedTestModeset(const CWeakPointer<CDRMBackend>&      backend,
+                                                                                const TGroupedTestKMSCaptureProvider& captureProvider) noexcept;
         [[nodiscard]] SGroupedInitialFrameResult submitCurrentGroupedInitialFrame(const CWeakPointer<CDRMBackend>& backend, const POutputBridgeObservation& expected,
                                                                                   const NTiledAtomic::PResolvedTiledAtomicReplacement& replacement,
                                                                                   const PScanGroupDefinition& group, const CSharedPointer<SOutputMode>& outputMode,
@@ -284,6 +292,7 @@ namespace Aquamarine::NDRM::NTiledDRMIntegration { // NOLINT(readability-identif
         [[nodiscard]] SGroupedTestModesetResult  executeCurrentGroupedTestModesetKey(const void* key, const POutputBridgeObservation& expected,
                                                                                      const NTiledAtomic::PResolvedTiledAtomicReplacement& replacement,
                                                                                      const PScanGroupDefinition& group, const CSharedPointer<SOutputMode>& outputMode) noexcept;
+        [[nodiscard]] SGroupedTestProbeResult    probeCurrentGroupedTestModesetKey(const void* key, const TGroupedTestKMSCaptureProvider& captureProvider) noexcept;
         [[nodiscard]] SGroupedInitialFrameResult submitCurrentGroupedInitialFrameKey(const void* key, const POutputBridgeObservation& expected,
                                                                                      const NTiledAtomic::PResolvedTiledAtomicReplacement& replacement,
                                                                                      const PScanGroupDefinition& group, const CSharedPointer<SOutputMode>& outputMode,
@@ -340,6 +349,8 @@ namespace Aquamarine::NDRM::NTiledDRMIntegration { // NOLINT(readability-identif
                                                                                              const std::function<void(const CPlan&, const SCurrentState&)>& callback) noexcept;
     [[nodiscard]] AQ_TILED_DRM_PRIVATE bool                      withCurrentOutputBridge(const CWeakPointer<CDRMBackend>& backend, const PAllocationShadow& expected,
                                                                                          const std::function<void(const POutputBridgeObservation&)>& callback) noexcept;
+    [[nodiscard]] AQ_TILED_DRM_PRIVATE SGroupedTestProbeResult   probeCurrentGroupedTestModeset(const CWeakPointer<CDRMBackend>&      backend,
+                                                                                                const TGroupedTestKMSCaptureProvider& captureProvider) noexcept;
     [[nodiscard]] AQ_TILED_DRM_PRIVATE SOrdinaryKMSGateResult    gateOrdinaryKMS(const CWeakPointer<CDRMBackend>& backend, std::span<const SOrdinaryKMSCRTC> crtcs,
                                                                                  const std::function<bool()>& callback) noexcept;
     [[nodiscard]] AQ_TILED_DRM_PRIVATE SGroupedPageFlipResult    routeGroupedPageFlip(const CWeakPointer<CDRMBackend>& backend, uintptr_t transactionId, uint32_t crtcId,
diff --git a/src/backend/drm/TiledRuntimeAuthority.cpp b/src/backend/drm/TiledRuntimeAuthority.cpp
index 7b5b8972c43a255c676c2f0dd1e9da328aa336e1..bb1582066b20af22cf6a4fe2060947214aa7b80a 100644
--- a/src/backend/drm/TiledRuntimeAuthority.cpp
+++ b/src/backend/drm/TiledRuntimeAuthority.cpp
@@ -354,14 +354,43 @@ SGroupedTestModesetResult CGroupedRuntimeAuthority::executeCurrentTestModeset(co
 
     m_mutationActive = true;
     Hyprutils::Utils::CScopeGuard mutationGuard([&] { m_mutationActive = false; });
+    return executeCurrentTestModesetUnguarded(current, replacement, group, outputMode, nullptr);
+}
+
+SGroupedTestModesetResult CGroupedRuntimeAuthority::executeCurrentTestProbe(const POutputBridgeObservation& current, const PScanGroupDefinition& group,
+                                                                            const CSharedPointer<SOutputMode>&    outputMode,
+                                                                            const TGroupedTestKMSCaptureProvider& captureProvider) noexcept {
+    if (!onEventThread())
+        return {.status = eGroupedTestModesetStatus::WRONG_THREAD};
+    if (m_mutationActive)
+        return {.status = eGroupedTestModesetStatus::BUSY};
+    if (m_terminal)
+        return {.status = eGroupedTestModesetStatus::TERMINAL};
+    if (!captureProvider || !m_testDevice || m_testDrmFD < 0 || !m_testOperations || !m_testFramebufferSource || !m_testCleanupRegistry ||
+        m_testCleanupRegistry->drmFD() != m_testDrmFD)
+        return {.status = eGroupedTestModesetStatus::NOT_CONFIGURED};
+
+    m_mutationActive = true;
+    Hyprutils::Utils::CScopeGuard mutationGuard([&] { m_mutationActive = false; });
+    return executeCurrentTestModesetUnguarded(current, {}, group, outputMode, &captureProvider);
+}
+
+SGroupedTestModesetResult CGroupedRuntimeAuthority::executeCurrentTestModesetUnguarded(const POutputBridgeObservation& current, const PResolvedTiledAtomicReplacement& replacement,
+                                                                                       const PScanGroupDefinition& group, const CSharedPointer<SOutputMode>& outputMode,
+                                                                                       const TGroupedTestKMSCaptureProvider* captureProvider) noexcept {
     try {
-        const auto& ROUTE    = replacement ? replacement->targetRoute() : PResolvedTiledAtomicRoute{};
-        const auto& SNAPSHOT = current ? current->capturedSnapshot() : CSharedPointer<const CSnapshot>{};
-        const auto* GROUP    = current ? current->findGroup(group) : nullptr;
-        if (!SNAPSHOT || !sameOwner(SNAPSHOT->device(), m_testDevice) || !GROUP || !sameOwner(GROUP->scanDefinition(), group) || !GROUP->definitionIdentity() || !replacement ||
-            !exactCurrentRoute(current, ROUTE) || !sameOwner(ROUTE->groupDefinition(), group) || !sameOwner(ROUTE->definitionIdentity(), GROUP->definitionIdentity()) ||
-            !sameOwner(ROUTE->outputMode(), outputMode))
+        auto        effectiveReplacement = replacement;
+        const auto& SNAPSHOT             = current ? current->capturedSnapshot() : CSharedPointer<const CSnapshot>{};
+        const auto* GROUP                = current ? current->findGroup(group) : nullptr;
+        if (!SNAPSHOT || !sameOwner(SNAPSHOT->device(), m_testDevice) || !GROUP || !sameOwner(GROUP->scanDefinition(), group) || !GROUP->definitionIdentity() ||
+            (!effectiveReplacement && (!captureProvider || !*captureProvider)))
             return {.status = eGroupedTestModesetStatus::INVALID_CURRENT};
+        if (effectiveReplacement) {
+            const auto& ROUTE = effectiveReplacement->targetRoute();
+            if (!exactCurrentRoute(current, ROUTE) || !sameOwner(ROUTE->groupDefinition(), group) || !sameOwner(ROUTE->definitionIdentity(), GROUP->definitionIdentity()) ||
+                !sameOwner(ROUTE->outputMode(), outputMode))
+                return {.status = eGroupedTestModesetStatus::INVALID_CURRENT};
+        }
         if (GROUP->projection() != eGroupProjection::MULTI_STREAM_ALLOCATED)
             return {.status = eGroupedTestModesetStatus::NOT_ALLOCATED};
 
@@ -412,7 +441,66 @@ SGroupedTestModesetResult CGroupedRuntimeAuthority::executeCurrentTestModeset(co
             return {.status = eGroupedTestModesetStatus::FRAMEBUFFER_UNAVAILABLE};
         }
 
-        const auto& FRAMEBUFFER_OWNER = replacement->targetFramebufferOwner();
+        if (!effectiveReplacement) {
+            auto capture = (*captureProvider)();
+            if (!capture)
+                return {.status = eGroupedTestModesetStatus::ROUTE_INVALID, .routeError = eTiledAtomicError::INCOMPLETE_REPLACEMENT};
+
+            const auto RESOLVED_ROUTE = resolveCapturedTiledAtomic({
+                .generationOwner    = current,
+                .groupDefinition    = group,
+                .definitionIdentity = GROUP->definitionIdentity(),
+                .outputMode         = outputMode,
+                .framebuffer        = m_testFramebuffer->atomic,
+            });
+            if (!RESOLVED_ROUTE)
+                return {.status = eGroupedTestModesetStatus::ROUTE_INVALID, .routeError = RESOLVED_ROUTE.error};
+
+            const auto TARGET_FRAMEBUFFER = CTiledAtomicFramebufferOwner::createCurrent(current, m_testFramebuffer->framebuffer);
+            if (!TARGET_FRAMEBUFFER)
+                return {.status = eGroupedTestModesetStatus::ROUTE_INVALID, .routeError = eTiledAtomicError::FRAMEBUFFER_MISMATCH};
+
+            std::vector<STiledPlaneInventoryResource> planeResources;
+            std::vector<STiledPlaneInventoryState>    planeStates;
+            planeResources.reserve(capture->planes.size());
+            planeStates.reserve(capture->planes.size());
+            for (auto& plane : capture->planes) {
+                PAtomicFramebufferOwner liveFramebuffer;
+                if (plane.framebuffer)
+                    liveFramebuffer = CTiledAtomicFramebufferOwner::createCurrent(current, plane.framebuffer);
+                if ((plane.framebufferId != 0 || plane.crtcId != 0) && !liveFramebuffer)
+                    return {.status = eGroupedTestModesetStatus::ROUTE_INVALID, .routeError = eTiledAtomicError::FRAMEBUFFER_MISMATCH};
+                planeResources.push_back({.id = plane.id, .owner = plane.owner, .role = plane.role});
+                planeStates.push_back({
+                    .id               = plane.id,
+                    .owner            = plane.owner,
+                    .crtcId           = plane.crtcId,
+                    .framebufferId    = plane.framebufferId,
+                    .framebufferOwner = std::move(liveFramebuffer),
+                });
+            }
+            const auto INVENTORY = CTiledAtomicPlaneInventory::create(current, std::move(planeResources), std::move(planeStates));
+            if (!INVENTORY)
+                return {.status = eGroupedTestModesetStatus::ROUTE_INVALID, .routeError = eTiledAtomicError::INCOMPLETE_REPLACEMENT};
+
+            const auto RESOLVED_REPLACEMENT = resolveTiledAtomicReplacement({
+                .targetRoute            = RESOLVED_ROUTE.route,
+                .targetFramebufferOwner = TARGET_FRAMEBUFFER,
+                .planeInventory         = INVENTORY,
+                .connectors             = std::move(capture->connectors),
+                .crtcs                  = std::move(capture->crtcs),
+            });
+            if (!RESOLVED_REPLACEMENT)
+                return {.status = eGroupedTestModesetStatus::ROUTE_INVALID, .routeError = RESOLVED_REPLACEMENT.error};
+            effectiveReplacement = RESOLVED_REPLACEMENT.replacement;
+        }
+
+        const auto& ROUTE = effectiveReplacement->targetRoute();
+        if (!exactCurrentRoute(current, ROUTE) || !sameOwner(ROUTE->groupDefinition(), group) || !sameOwner(ROUTE->definitionIdentity(), GROUP->definitionIdentity()) ||
+            !sameOwner(ROUTE->outputMode(), outputMode))
+            return {.status = eGroupedTestModesetStatus::INVALID_CURRENT};
+
+        const auto& FRAMEBUFFER_OWNER = effectiveReplacement->targetFramebufferOwner();
         const auto  LIFETIME          = SNAPSHOT->device()->backend().lock();
         if (!FRAMEBUFFER_OWNER || !LIFETIME || FRAMEBUFFER_OWNER->dead() || !sameOwner(FRAMEBUFFER_OWNER->generationOwner(), current) ||
             !sameOwner(FRAMEBUFFER_OWNER->backend(), LIFETIME) || FRAMEBUFFER_OWNER->framebuffer() != ROUTE->framebuffer() || ROUTE->framebuffer() != m_testFramebuffer->atomic)
@@ -429,7 +517,7 @@ SGroupedTestModesetResult CGroupedRuntimeAuthority::executeCurrentTestModeset(co
         }
 
         result.routeError      = eTiledAtomicError::NONE;
-        const auto EXECUTION   = executeTiledTestModeset(replacement, m_testDrmFD, m_testOperations, m_testCleanupRegistry);
+        const auto EXECUTION   = executeTiledTestModeset(effectiveReplacement, m_testDrmFD, m_testOperations, m_testCleanupRegistry);
         result.executionStatus = EXECUTION.status;
         result.submission      = EXECUTION.submission;
         result.cleanup         = EXECUTION.cleanup;
diff --git a/src/backend/drm/TiledRuntimeAuthority.hpp b/src/backend/drm/TiledRuntimeAuthority.hpp
index b0144763e77ec2952d98598aea5668e69d70a916..2b7a3d3134c0b87d755f1eec65c9cecb7ecdf61d 100644
--- a/src/backend/drm/TiledRuntimeAuthority.hpp
+++ b/src/backend/drm/TiledRuntimeAuthority.hpp
@@ -327,6 +327,26 @@ namespace Aquamarine::NDRM::NTiledRuntimeAuthority { // NOLINT(readability-ident
         explicit                                             operator bool() const noexcept;
     };
 
+    // One complete, coherent read of the backend's live KMS attachment graph.
+    // The production registry supplies it synchronously while its exact
+    // allocation/bridge current-owner gate is held.
+    struct AQ_TILED_RUNTIME_AUTHORITY_PRIVATE SGroupedTestLivePlaneCapture {
+        uint32_t                                 id = 0;
+        CSharedPointer<SDRMPlane>                owner;
+        NTiledAtomic::eTiledReplacementPlaneRole role          = NTiledAtomic::eTiledReplacementPlaneRole::PRIMARY;
+        uint32_t                                 crtcId        = 0;
+        uint32_t                                 framebufferId = 0;
+        CSharedPointer<CDRMFB>                   framebuffer;
+    };
+
+    struct AQ_TILED_RUNTIME_AUTHORITY_PRIVATE SGroupedTestKMSCapture {
+        std::vector<NTiledAtomic::STiledReplacementConnectorCapture> connectors;
+        std::vector<NTiledAtomic::STiledReplacementCrtcCapture>      crtcs;
+        std::vector<SGroupedTestLivePlaneCapture>                    planes;
+    };
+
+    using TGroupedTestKMSCaptureProvider = std::function<std::optional<SGroupedTestKMSCapture>()>;
+
     struct AQ_TILED_RUNTIME_AUTHORITY_PRIVATE SGroupedTestFramebuffer {
         PDeviceIncarnation         device;
         CWeakPointer<CDRMBackend>  backend;
@@ -424,18 +444,24 @@ namespace Aquamarine::NDRM::NTiledRuntimeAuthority { // NOLINT(readability-ident
         [[nodiscard]] bool configureProductionTestModeset(const PDeviceIncarnation& device, const CWeakPointer<CDRMBackend>& backend, int drmFD) noexcept;
         [[nodiscard]] bool configureInjectedTestModeset(const PDeviceIncarnation& device, int drmFD, const CSharedPointer<ITiledAtomicRequestOperations>& operations,
                                                         const CSharedPointer<IGroupedTestFramebufferSource>& framebufferSource) noexcept;
-        [[nodiscard]] SGroupedTestModesetResult       executeCurrentTestModeset(const POutputBridgeObservation& current, const PResolvedTiledAtomicReplacement& replacement,
-                                                                                const PScanGroupDefinition& group, const CSharedPointer<SOutputMode>& outputMode) noexcept;
-        [[nodiscard]] bool                            prepareTestModesetDetach() noexcept;
-        [[nodiscard]] bool                            validTestFramebuffer(const PGroupedTestFramebuffer& framebuffer, const SPlaneFramebufferSize& size,
-                                                                           std::span<const SDRMFormat> commonFormats) const noexcept;
+        [[nodiscard]] SGroupedTestModesetResult executeCurrentTestModeset(const POutputBridgeObservation& current, const PResolvedTiledAtomicReplacement& replacement,
+                                                                          const PScanGroupDefinition& group, const CSharedPointer<SOutputMode>& outputMode) noexcept;
+        [[nodiscard]] SGroupedTestModesetResult executeCurrentTestProbe(const POutputBridgeObservation& current, const PScanGroupDefinition& group,
+                                                                        const CSharedPointer<SOutputMode>&    outputMode,
+                                                                        const TGroupedTestKMSCaptureProvider& captureProvider) noexcept;
+        [[nodiscard]] SGroupedTestModesetResult executeCurrentTestModesetUnguarded(const POutputBridgeObservation& current, const PResolvedTiledAtomicReplacement& replacement,
+                                                                                   const PScanGroupDefinition& group, const CSharedPointer<SOutputMode>& outputMode,
+                                                                                   const TGroupedTestKMSCaptureProvider* captureProvider) noexcept;
+        [[nodiscard]] bool                      prepareTestModesetDetach() noexcept;
+        [[nodiscard]] bool                      validTestFramebuffer(const PGroupedTestFramebuffer& framebuffer, const SPlaneFramebufferSize& size,
+                                                                     std::span<const SDRMFormat> commonFormats) const noexcept;
 
-        std::thread::id                               m_eventThread;
-        CTiledFlipReservationRegistry                 m_reservations;
-        TRuntimeMap                                   m_runtimes;
-        PDeviceIncarnation                            m_testDevice;
-        CWeakPointer<CDRMBackend>                     m_testBackend;
-        int                                           m_testDrmFD = -1;
+        std::thread::id                         m_eventThread;
+        CTiledFlipReservationRegistry           m_reservations;
+        TRuntimeMap                             m_runtimes;
+        PDeviceIncarnation                      m_testDevice;
+        CWeakPointer<CDRMBackend>               m_testBackend;
+        int                                     m_testDrmFD = -1;
         CSharedPointer<ITiledAtomicRequestOperations> m_testOperations;
         CSharedPointer<IGroupedTestFramebufferSource> m_testFramebufferSource;
         NTiledAtomic::PModeBlobCleanupRegistry        m_testCleanupRegistry;