Use retained debug bridge per test invocation

Author: jkwak-work

tools/gfx-unit-test/scoped-core-debug-callback-test.cpp

@@ -11,18 +11,18 @@ void emitError(renderer_test::CoreToRHIDebugBridge& bridge, const char* message)
     bridge.handleMessage(rhi::DebugMessageType::Error, rhi::DebugMessageSource::Layer, message);
 }
 
-renderer_test::CoreToRHIDebugBridge& getStaticBridgeAfterStackCallbackScope()
+renderer_test::CoreToRHIDebugBridge* getRetainedBridgeAfterStackCallbackScope()
 {
-    static renderer_test::CoreToRHIDebugBridge bridge;
+    auto bridge = renderer_test::createRetainedCoreToRHIDebugBridge();
 
     renderer_test::CoreDebugCallback callback;
     {
-        renderer_test::ScopedCoreDebugCallback scopedDebugCallback(bridge, &callback);
-        emitError(bridge, "static scope");
+        renderer_test::ScopedCoreDebugCallback scopedDebugCallback(*bridge, &callback);
+        emitError(*bridge, "retained scope");
     }
-    SLANG_CHECK(callback.getString() == "static scope\n");
+    SLANG_CHECK(callback.getString() == "retained scope\n");
 
-    return bridge;
+    return bridge.Ptr();
 }
 } // namespace
 
@@ -99,61 +99,78 @@ SLANG_UNIT_TEST(scopedCoreDebugCallbackClearsBridgeOnException)
     SLANG_CHECK(secondCallback.getString() == "next iteration\n");
 }
 
-SLANG_UNIT_TEST(scopedCoreDebugCallbackClearsStaticBridgeAfterStackCallback)
+SLANG_UNIT_TEST(scopedCoreDebugCallbackSeparatesRetainedBridgeScopes)
 {
-    renderer_test::CoreToRHIDebugBridge& bridge = getStaticBridgeAfterStackCallbackScope();
-
-    emitError(bridge, "after stack callback");
+    renderer_test::CoreToRHIDebugBridge* oldBridge = getRetainedBridgeAfterStackCallbackScope();
+    auto nextBridge = renderer_test::createRetainedCoreToRHIDebugBridge();
 
     renderer_test::CoreDebugCallback nextCallback;
     {
-        renderer_test::ScopedCoreDebugCallback scopedDebugCallback(bridge, &nextCallback);
-        emitError(bridge, "next invocation");
+        renderer_test::ScopedCoreDebugCallback scopedDebugCallback(*nextBridge, &nextCallback);
+        emitError(*oldBridge, "after stack callback");
+        emitError(*nextBridge, "next invocation");
     }
     SLANG_CHECK(nextCallback.getString() == "next invocation\n");
 }
 
 SLANG_UNIT_TEST(coreDebugBridgeHandlesConcurrentMessages)
 {
     static constexpr int kThreadCount = 4;
-    static constexpr int kMessageCount = 64;
+    static constexpr int kMessageCount = 1024;
 
     renderer_test::CoreToRHIDebugBridge bridge;
     renderer_test::CoreDebugCallback callback;
-    {
-        renderer_test::ScopedCoreDebugCallback scopedDebugCallback(bridge, &callback);
+    std::atomic<bool> startWriting(false);
+    std::atomic<bool> keepReading(true);
 
-        std::atomic<bool> keepReading(true);
-        std::thread readerThread(
+    std::thread readerThread(
+        [&]()
+        {
+            while (keepReading.load(std::memory_order_acquire))
+            {
+                callback.getString();
+            }
+        });
+
+    std::thread writerThreads[kThreadCount];
+    for (int threadIndex = 0; threadIndex < kThreadCount; ++threadIndex)
+    {
+        writerThreads[threadIndex] = std::thread(
             [&]()
             {
-                while (keepReading.load(std::memory_order_acquire))
+                while (!startWriting.load(std::memory_order_acquire))
                 {
-                    callback.getString();
+                    std::this_thread::yield();
                 }
-            });
 
-        std::thread writerThreads[kThreadCount];
-        for (int threadIndex = 0; threadIndex < kThreadCount; ++threadIndex)
-        {
-            writerThreads[threadIndex] = std::thread(
-                [&]()
+                for (int messageIndex = 0; messageIndex < kMessageCount; ++messageIndex)
                 {
-                    for (int messageIndex = 0; messageIndex < kMessageCount; ++messageIndex)
-                    {
-                        emitError(bridge, "x");
-                    }
-                });
-        }
+                    emitError(bridge, "x");
+                }
+            });
+    }
 
-        for (auto& writerThread : writerThreads)
+    {
+        renderer_test::ScopedCoreDebugCallback scopedDebugCallback(bridge, &callback);
+        startWriting.store(true, std::memory_order_release);
+        for (int spinCount = 0; spinCount < 100000 && callback.getString().getLength() == 0;
+             ++spinCount)
         {
-            writerThread.join();
+            std::this_thread::yield();
         }
+        SLANG_CHECK(callback.getString().getLength() > 0);
+    }
 
-        keepReading.store(false, std::memory_order_release);
-        readerThread.join();
+    for (auto& writerThread : writerThreads)
+    {
+        writerThread.join();
     }
 
-    SLANG_CHECK(callback.getString().getLength() == kThreadCount * kMessageCount * 2);
+    keepReading.store(false, std::memory_order_release);
+    readerThread.join();
+
+    auto capturedLength = callback.getString().getLength();
+    SLANG_CHECK(capturedLength > 0);
+    SLANG_CHECK(capturedLength <= kThreadCount * kMessageCount * 2);
+    SLANG_CHECK((capturedLength % 2) == 0);
 }

tools/render-test/render-test-main.cpp

@@ -1769,9 +1769,9 @@ static SlangResult _innerMain(
         }
     }
 
-    static renderer_test::CoreToRHIDebugBridge debugCallback;
+    auto debugCallback = renderer_test::createRetainedCoreToRHIDebugBridge();
     renderer_test::ScopedCoreDebugCallback scopedDebugCallback(
-        debugCallback,
+        *debugCallback,
         stdWriters->getDebugCallback());
 
     // Use the profile name set on options if set
@@ -1909,7 +1909,7 @@ static SlangResult _innerMain(
         desc.deviceType = options.deviceType;
 
         desc.enableValidation = options.enableDebugLayers;
-        desc.debugCallback = &debugCallback;
+        desc.debugCallback = debugCallback.Ptr();
 
         desc.slang.lineDirectiveMode = SLANG_LINE_DIRECTIVE_MODE_NONE;
         if (options.generateSPIRVDirectly)

tools/render-test/slang-support.h

@@ -1,6 +1,7 @@
 // slang-support.h
 #pragma once
 
+#include "core/slang-basic.h"
 #include "core/slang-std-writers.h"
 #include "options.h"
 #include "shader-input-layout.h"
@@ -17,7 +18,7 @@ namespace renderer_test
 /// RHI backends may invoke debug callbacks from backend or driver threads, so
 /// binding changes and forwarded messages are serialized.
 /// TODO: We should replace rhi::IDebugCallback with Slang::IDebugCallback.
-class CoreToRHIDebugBridge : public rhi::IDebugCallback
+class CoreToRHIDebugBridge : public Slang::RefObject, public rhi::IDebugCallback
 {
 public:
     void setCoreCallback(Slang::IDebugCallback* coreCallback)
@@ -48,6 +49,24 @@ class CoreToRHIDebugBridge : public rhi::IDebugCallback
     Slang::IDebugCallback* m_coreCallback = nullptr;
 };
 
+/// Creates an RHI debug bridge that remains alive for process teardown.
+///
+/// Device descriptors store debug callbacks as raw pointers, and retained RHI
+/// state may emit messages after the harness invocation that created a device.
+/// Each invocation gets a distinct bridge so old emitters can only reach their
+/// own cleared bridge, not the next invocation's callback.
+inline Slang::RefPtr<CoreToRHIDebugBridge> createRetainedCoreToRHIDebugBridge()
+{
+    static std::mutex* mutex = new std::mutex;
+    static Slang::List<Slang::RefPtr<CoreToRHIDebugBridge>>* bridges =
+        new Slang::List<Slang::RefPtr<CoreToRHIDebugBridge>>();
+
+    Slang::RefPtr<CoreToRHIDebugBridge> bridge = new CoreToRHIDebugBridge();
+    std::lock_guard<std::mutex> lock(*mutex);
+    bridges->add(bridge);
+    return bridge;
+}
+
 /// Binds an RHI debug bridge to a core callback for one active test invocation.
 ///
 /// The bridge may be retained by RHI device state after this scope exits, but the

tools/slang-test/slang-test-main.cpp

@@ -5556,9 +5556,6 @@ static SlangResult runUnitTestModule(
         return SLANG_FAIL;
 
     renderer_test::CoreDebugCallback coreDebugCallback;
-    // RHI state can outlive a unit-test invocation, so the bridge must outlive
-    // the stack callback whose binding is controlled below.
-    static renderer_test::CoreToRHIDebugBridge rhiDebugBridge;
 
     UnitTestContext unitTestContext;
     unitTestContext.slangGlobalSession = context->getSession();
@@ -5569,7 +5566,7 @@ static SlangResult runUnitTestModule(
         context->options.enabledApis & _getAvailableRenderApiFlags(context);
     unitTestContext.enableDebugLayers = context->options.enableDebugLayers;
     unitTestContext.executableDirectory = context->exeDirectoryPath.getBuffer();
-    unitTestContext.debugCallback = &rhiDebugBridge;
+    unitTestContext.debugCallback = nullptr;
 
     auto testCount = testModule->getTestCount();
 
@@ -5688,8 +5685,10 @@ static SlangResult runUnitTestModule(
 
             // Clear any previous debug messages
             coreDebugCallback.clear();
+            auto rhiDebugBridge = renderer_test::createRetainedCoreToRHIDebugBridge();
+            unitTestContext.debugCallback = rhiDebugBridge.Ptr();
             renderer_test::ScopedCoreDebugCallback scopedDebugCallback(
-                rhiDebugBridge,
+                *rhiDebugBridge,
                 &coreDebugCallback);
 
             try

tools/test-server/test-server-main.cpp

@@ -543,11 +543,9 @@ SlangResult TestServer::_executeUnitTest(const JSONRPCCall& call)
 
     TestReporter testReporter;
     renderer_test::CoreDebugCallback coreDebugCallback;
-    // RHI state can outlive an RPC invocation, so the bridge must outlive the
-    // stack callback whose binding is controlled by the scoped helper.
-    static renderer_test::CoreToRHIDebugBridge rhiDebugCallback;
+    auto rhiDebugCallback = renderer_test::createRetainedCoreToRHIDebugBridge();
     renderer_test::ScopedCoreDebugCallback scopedDebugCallback(
-        rhiDebugCallback,
+        *rhiDebugCallback,
         &coreDebugCallback);
 
     testModule->setTestReporter(&testReporter);
@@ -565,7 +563,7 @@ SlangResult TestServer::_executeUnitTest(const JSONRPCCall& call)
     unitTestContext.enabledApis = RenderApiFlags(args.enabledApis);
     unitTestContext.executableDirectory = m_exeDirectory.getBuffer();
     unitTestContext.enableDebugLayers = args.enableDebugLayers;
-    unitTestContext.debugCallback = &rhiDebugCallback;
+    unitTestContext.debugCallback = rhiDebugCallback.Ptr();
 
     auto testCount = testModule->getTestCount();
     SLANG_ASSERT(testIndex >= 0 && testIndex < testCount);