graphics: per-message GBV detection, suppress tree dump for GBV-only frames

Author: xen2

sources/engine/Stride.Graphics/Direct3D11/GraphicsDevice.Direct3D11.cs

@@ -40,6 +40,23 @@ public unsafe partial class GraphicsDevice
 
         private ID3D11InfoQueue* nativeInfoQueue;
 
+        // GBV message IDs from D3D11_MESSAGE_ID, populated lazily via reflection so the scan
+        // only runs in debug mode (InfoQueue draining never happens in release → Value is
+        // never queried). Robust against SDK additions to the GBV enum range.
+        private static readonly Lazy<System.Collections.Generic.HashSet<MessageID>> gbvMessageIds = new(BuildGbvMessageIdSet);
+
+        private static System.Collections.Generic.HashSet<MessageID> BuildGbvMessageIdSet()
+        {
+            var set = new System.Collections.Generic.HashSet<MessageID>();
+            foreach (var name in Enum.GetNames<MessageID>())
+            {
+                if (name.Contains("Gpubased", StringComparison.OrdinalIgnoreCase)
+                    && Enum.TryParse<MessageID>(name, out var id))
+                    set.Add(id);
+            }
+            return set;
+        }
+
         /// <summary>
         ///   Gets the internal Direct3D 11 Device.
         /// </summary>
@@ -481,14 +498,14 @@ private void OnDeviceInfoQueueMessage(ref readonly Message message)
             var description = descriptionSpan.GetString();
 
             // D3D11 has no synchronous-callback API. CPU-side validation is synchronous with the
-            // API call, so as long as we drain at every scope transition (BeginProfile/EndProfile)
-            // the leaf at drain time matches the leaf at message time. If GPU-based validation is
-            // turned on (DebugGpuValidationEnabled = true), GBV messages arrive asynchronously
-            // via the InfoQueue at fence completion — skip leaf attribution in that mode.
+            // API call, so draining at every BeginProfile/EndProfile gives accurate leaf
+            // attribution. GBV messages arrive asynchronously and we detect them by ID via the
+            // reflection-built set. DebugGpuValidationEnabled is the kill-switch override.
             bool isDrawCategory = message.Category is MessageCategory.StateSetting
                                                    or MessageCategory.Execution
                                                    or MessageCategory.ResourceManipulation;
-            bool attributable = isDrawCategory && !DebugGpuValidationEnabled;
+            bool isGbv = DebugGpuValidationEnabled || gbvMessageIds.Value.Contains(message.ID);
+            bool attributable = isDrawCategory && !isGbv;
             string scopePrefix = "";
             DebugScopeFrame leaf = null;
             if (attributable)
@@ -504,12 +521,12 @@ or MessageCategory.Execution
                 case MessageSeverity.Error:
                     DebugLog.Error($"[D3D11] {scopePrefix}{description}");
                     if (leaf is not null) leaf.Errors++;
-                    if (isDrawCategory) debugSawDrawIssue = true;
+                    if (attributable) debugSawDrawIssue = true;
                     break;
                 case MessageSeverity.Warning:
                     DebugLog.Warning($"[D3D11] {scopePrefix}{description}");
                     if (leaf is not null) leaf.Warnings++;
-                    if (isDrawCategory) debugSawDrawIssue = true;
+                    if (attributable) debugSawDrawIssue = true;
                     break;
             }
 

sources/engine/Stride.Graphics/Direct3D12/GraphicsDevice.Direct3D12.cs

@@ -40,6 +40,23 @@ public unsafe partial class GraphicsDevice
         // Set by the callback when a draw-relevant validation message arrives within a scope.
         // Consumed by DrainDebugMessages at the next scope-empty transition.
 
+        // GBV message IDs from D3D12_MESSAGE_ID, populated lazily via reflection so the scan
+        // only runs in debug mode (callback never fires in release → Value is never queried).
+        // Robust against SDK additions to the GBV enum range.
+        private static readonly Lazy<System.Collections.Generic.HashSet<MessageID>> gbvMessageIds = new(BuildGbvMessageIdSet);
+
+        private static System.Collections.Generic.HashSet<MessageID> BuildGbvMessageIdSet()
+        {
+            var set = new System.Collections.Generic.HashSet<MessageID>();
+            foreach (var name in Enum.GetNames<MessageID>())
+            {
+                if (name.Contains("Gpubased", StringComparison.OrdinalIgnoreCase)
+                    && Enum.TryParse<MessageID>(name, out var id))
+                    set.Add(id);
+            }
+            return set;
+        }
+
         /// <summary>
         ///   Concurrent pool for lists of Graphics Resources that are used for staging operations.
         /// </summary>
@@ -910,10 +927,11 @@ private static void OnDebugMessageCallback(MessageCategory category, MessageSeve
                                             or MessageCategory.Execution
                                             or MessageCategory.ResourceManipulation;
 
-            // GPU-based validation messages arrive asynchronously — the active scope at callback
-            // time isn't the one that issued the offending command. Skip leaf attribution and
-            // scope prefix in that mode to avoid misleading the user.
-            bool attributable = !device.DebugGpuValidationEnabled;
+            // GBV messages arrive asynchronously, so leaf attribution would be wrong. We detect
+            // them by ID via the reflection-built set. The DebugGpuValidationEnabled override
+            // is a kill switch for cases the heuristic misses.
+            bool isGbv = device.DebugGpuValidationEnabled || gbvMessageIds.Value.Contains(id);
+            bool attributable = !isGbv;
             var leafName = attributable ? device.GetDebugLeafScopeName() : null;
             var scope = leafName is not null ? $"[{leafName}]: " : "";
 
@@ -922,18 +940,20 @@ or MessageCategory.Execution
             // chain of "Down2" passes).
             var leaf = attributable ? device.debugCurrentFrame : null;
 
+            // Tree dump only fires for attributable messages — a tree without [!] markers is
+            // noise, so GBV-only frames stay quiet (just the log lines).
             switch (severity)
             {
                 case MessageSeverity.Corruption:
                 case MessageSeverity.Error:
                     DebugLog.Error($"{scope}{desc}");
                     if (leaf is not null) leaf.Errors++;
-                    if (isDrawCategory) device.debugSawDrawIssue = true;
+                    if (isDrawCategory && attributable) device.debugSawDrawIssue = true;
                     break;
                 case MessageSeverity.Warning:
                     DebugLog.Warning($"{scope}{desc}");
                     if (leaf is not null) leaf.Warnings++;
-                    if (isDrawCategory) device.debugSawDrawIssue = true;
+                    if (isDrawCategory && attributable) device.debugSawDrawIssue = true;
                     break;
             }
         }
@@ -982,9 +1002,11 @@ internal void FlushDebugMessages()
                     bool isDrawCategory = message->Category is MessageCategory.StateSetting
                                                             or MessageCategory.Execution
                                                             or MessageCategory.ResourceManipulation;
+                    bool isGbv = DebugGpuValidationEnabled || gbvMessageIds.Value.Contains(message->ID);
+                    bool attributable = !isGbv;
 
                     string prefix = null;
-                    if (isDrawCategory)
+                    if (isDrawCategory && attributable)
                     {
                         var leafName = GetDebugLeafScopeName();
                         prefix = leafName is not null ? $"[{leafName}]: " : null;
@@ -995,11 +1017,11 @@ or MessageCategory.Execution
                         case MessageSeverity.Corruption:
                         case MessageSeverity.Error:
                             DebugLog.Error($"{prefix}{description}");
-                            if (isDrawCategory) sawDrawIssue = true;
+                            if (isDrawCategory && attributable) sawDrawIssue = true;
                             break;
                         case MessageSeverity.Warning:
                             DebugLog.Warning($"{prefix}{description}");
-                            if (isDrawCategory) sawDrawIssue = true;
+                            if (isDrawCategory && attributable) sawDrawIssue = true;
                             break;
                     }
                 }

sources/engine/Stride.Graphics/GraphicsDevice.DebugScope.cs

@@ -37,13 +37,12 @@ public partial class GraphicsDevice
     internal bool debugSawDrawIssue;
 
     /// <summary>
-    ///   When <see langword="true"/>, the backend has GPU-side validation enabled
-    ///   (D3D11/D3D12 GPU-based validation, Vulkan GPU-Assisted Validation). Messages from
-    ///   those modes arrive asynchronously to recording, so per-leaf scope attribution is
-    ///   unreliable. Backends should skip leaf <c>Errors</c>/<c>Warnings</c> increments and the
-    ///   <c>[scope]:</c> log prefix when this is set, but still log the message and dump the
-    ///   tree. Defaults to <see langword="false"/> — Stride doesn't enable any of those modes
-    ///   today.
+    ///   Kill switch that forces every validation message to be treated as GPU-side and skip
+    ///   leaf attribution / tree-dump triggering. Backends already detect GPU-side messages
+    ///   per-message (D3D11/D3D12 via the <c>D3D*_MESSAGE_ID_GPU_BASED_VALIDATION_*</c>
+    ///   enum entries; Vulkan via <c>pMessageIdName</c>), so this is only needed if those
+    ///   heuristics ever miss a backend's GBV namespace and produce noisy misattributed
+    ///   dumps. Defaults to <see langword="false"/>; Stride doesn't enable any GBV mode today.
     /// </summary>
     public bool DebugGpuValidationEnabled { get; set; }
 

sources/engine/Stride.Graphics/Vulkan/GraphicsAdapterFactory.Vulkan.cs

@@ -287,10 +287,20 @@ private unsafe static uint DebugReport(VkDebugUtilsMessageSeverityFlagsEXT sever
             // Performance categories are draw-relevant; General is mostly init/shutdown noise.
             var device = GraphicsDevice.DebugMessengerDevice;
             bool isDrawCategory = (types & (VkDebugUtilsMessageTypeFlagsEXT.Validation | VkDebugUtilsMessageTypeFlagsEXT.Performance)) != 0;
-            // GPU-Assisted Validation messages arrive on a worker thread after the GPU completes
-            // the offending draw — scope attribution is meaningless. Skip prefix/leaf bumps when
-            // that mode is on; the tree dump still fires from the draw-issue flag below.
-            bool attributable = device is not null && !device.DebugGpuValidationEnabled;
+
+            // GPU-Assisted Validation (instrumented shaders, results read back on a worker)
+            // arrives asynchronously to recording. The Khronos validation layer tags those with
+            // ID names containing "GPU-AV"/"GPUAV"/"GPU-Assisted". Skip attribution and the
+            // tree-dump trigger so GBV-only frames stay quiet.
+            bool isGbv = device is not null && device.DebugGpuValidationEnabled;
+            if (!isGbv && pCallbackData->pMessageIdName != null)
+            {
+                var idName = new VkUtf8String(pCallbackData->pMessageIdName).ToString();
+                isGbv = idName.Contains("GPU-AV", StringComparison.Ordinal)
+                     || idName.Contains("GPUAV", StringComparison.Ordinal)
+                     || idName.Contains("GPU-Assisted", StringComparison.Ordinal);
+            }
+            bool attributable = device is not null && !isGbv;
             string scopePrefix = "";
             DebugScopeFrame leaf = null;
             if (attributable)
@@ -305,13 +315,13 @@ private unsafe static uint DebugReport(VkDebugUtilsMessageSeverityFlagsEXT sever
             {
                 GraphicsDevice.DebugLog.Error($"[Vulkan] {scopePrefix}{message}");
                 if (leaf is not null) leaf.Errors++;
-                if (device is not null && isDrawCategory) device.debugSawDrawIssue = true;
+                if (device is not null && isDrawCategory && attributable) device.debugSawDrawIssue = true;
             }
             else if (severity >= VkDebugUtilsMessageSeverityFlagsEXT.Warning)
             {
                 GraphicsDevice.DebugLog.Warning($"[Vulkan] {scopePrefix}{message}");
                 if (leaf is not null) leaf.Warnings++;
-                if (device is not null && isDrawCategory) device.debugSawDrawIssue = true;
+                if (device is not null && isDrawCategory && attributable) device.debugSawDrawIssue = true;
             }
             else if (severity >= VkDebugUtilsMessageSeverityFlagsEXT.Info)
             {