Stage the WebGPU support probe and name each failing capability

Split the isolated availability probe into staged checks: pipeline
creation, an indexed submission with buffer readback, one production
compute dispatch, and a layered retained-scene render. Distinct exit
codes name the first failing stage, and codes reserved for completed
probes map to the unsupported result instead of a process failure.
Adapters whose driver stack wedges after real render work, such as
WARP, now classify as unsupported before any test or consumer can
reach the native fault.

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/WebGPURuntime.cs

@@ -381,7 +381,11 @@ public static WebGPUEnvironmentError ProbeComputePipelineSupport()
             computePipelineProbeResult = exitCode switch
             {
                 0 => WebGPUEnvironmentError.Success,
-                1 => WebGPUEnvironmentError.ComputePipelineCreationFailed,
+
+                // Codes one through nine are reserved for probe stages that completed and
+                // reported the adapter unsupported; everything else means the isolated
+                // process died mid-probe.
+                >= 1 and <= 9 => WebGPUEnvironmentError.ComputePipelineCreationFailed,
                 _ => WebGPUEnvironmentError.ComputePipelineProbeProcessFailed,
             };
             return computePipelineProbeResult.Value;
@@ -475,10 +479,20 @@ public static int RunComputePipelineSupportProbe()
                             api.ComputePipelineRelease(pipeline);
 
                             // Pipeline creation and even trivial submissions succeed on adapters
-                            // whose render path later fails natively, so the probe must also prove
-                            // an indexed submission with buffer map and one layered scene render
-                            // with readback before reporting support.
-                            return ProbeSubmissionReadback(api, device, queue) && ProbeSceneRenderReadback() ? 0 : 1;
+                            // whose execution or render path later fails natively, so the probe
+                            // proves each deeper capability in turn. The distinct exit codes name
+                            // the first stage that failed.
+                            if (!ProbeSubmissionReadback(api, device, queue))
+                            {
+                                return 2;
+                            }
+
+                            if (!ProbeComputeDispatch(api, device, queue))
+                            {
+                                return 3;
+                            }
+
+                            return ProbeSceneRenderReadback() ? 0 : 4;
                         }
                         finally
                         {
@@ -557,47 +571,244 @@ private static bool ProbeSubmissionReadback(WebGPU api, WGPUDeviceImpl* device,
             }
 
             ulong submissionIndex = api.QueueSubmitForIndex(queue, 1, ref commandBuffer);
+            return TryMapProbeBuffer(api, device, readbackBuffer, (nuint)probeByteCount, submissionIndex);
+        }
+        finally
+        {
+            if (commandBuffer is not null)
+            {
+                api.CommandBufferRelease(commandBuffer);
+            }
+
+            if (commandEncoder is not null)
+            {
+                api.CommandEncoderRelease(commandEncoder);
+            }
+
+            if (readbackBuffer is not null)
+            {
+                api.BufferRelease(readbackBuffer);
+            }
+
+            if (sourceBuffer is not null)
+            {
+                api.BufferRelease(sourceBuffer);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Maps a probe readback buffer after its submission and verifies readable bytes.
+    /// </summary>
+    /// <param name="api">The WebGPU API loader.</param>
+    /// <param name="device">The probe device.</param>
+    /// <param name="readbackBuffer">The mappable buffer written by the probe submission.</param>
+    /// <param name="byteCount">The buffer length in bytes.</param>
+    /// <param name="submissionIndex">The submission the map depends on.</param>
+    /// <returns><see langword="true"/> when the buffer mapped with readable data.</returns>
+    private static bool TryMapProbeBuffer(
+        WebGPU api,
+        WGPUDeviceImpl* device,
+        WGPUBufferImpl* readbackBuffer,
+        nuint byteCount,
+        ulong submissionIndex)
+    {
+        WGPUMapAsyncStatus mapStatus = default;
+        using ManualResetEventSlim mapReady = new(false);
+        void Callback(WGPUMapAsyncStatus status, void* userData)
+        {
+            _ = userData;
+            mapStatus = status;
+            mapReady.Set();
+        }
 
-            WGPUMapAsyncStatus mapStatus = default;
-            using ManualResetEventSlim mapReady = new(false);
-            void Callback(WGPUMapAsyncStatus status, void* userData)
+        using WebGPUBufferMapCallback callback = WebGPUBufferMapCallback.From(Callback);
+        api.BufferMapAsync(readbackBuffer, MapMode.Read, 0, byteCount, callback, null);
+
+        // Non-blocking polls scoped to the submission index mirror the renderer's readback
+        // wait, and the managed timeout turns an adapter that never completes the submission
+        // into a probe failure instead of a hang.
+        Stopwatch stopwatch = Stopwatch.StartNew();
+        while (!mapReady.IsSet && stopwatch.ElapsedMilliseconds < CallbackTimeoutMilliseconds)
+        {
+            _ = api.DevicePoll(device, false, &submissionIndex);
+            if (!mapReady.IsSet)
             {
-                _ = userData;
-                mapStatus = status;
-                mapReady.Set();
+                Thread.Yield();
             }
+        }
+
+        // The status keeps its default value when the callback never fired, so timeouts and
+        // explicit non-success map results fail through the same check.
+        if (!mapReady.IsSet || mapStatus != WGPUMapAsyncStatus.Success)
+        {
+            return false;
+        }
+
+        void* mapped = api.BufferGetConstMappedRange(readbackBuffer, 0, byteCount);
+        if (mapped is null)
+        {
+            return false;
+        }
+
+        api.BufferUnmap(readbackBuffer);
+        return true;
+    }
+
+    /// <summary>
+    /// Executes the chunk-reset production shader once and proves its submission completes.
+    /// </summary>
+    /// <param name="api">The WebGPU API loader.</param>
+    /// <param name="device">The probe device.</param>
+    /// <param name="queue">The probe device's queue.</param>
+    /// <returns><see langword="true"/> when the dispatch completed and the readback mapped.</returns>
+    /// <remarks>
+    /// The chunk-reset stage is the smallest production shader: one workgroup, one thread, one
+    /// storage binding. Executing it proves the adapter can run the full shader compilation
+    /// chain, which pipeline creation alone does not.
+    /// </remarks>
+    private static bool ProbeComputeDispatch(WebGPU api, WGPUDeviceImpl* device, WGPUQueueImpl* queue)
+    {
+        nuint statusByteCount = (nuint)sizeof(GpuSceneBumpAllocators);
+
+        WGPUBufferImpl* storageBuffer = null;
+        WGPUBufferImpl* readbackBuffer = null;
+        WGPUShaderModuleImpl* shaderModule = null;
+        WGPUBindGroupLayoutImpl* bindGroupLayout = null;
+        WGPUPipelineLayoutImpl* pipelineLayout = null;
+        WGPUComputePipelineImpl* pipeline = null;
+        WGPUBindGroupImpl* bindGroup = null;
+        WGPUCommandEncoderImpl* commandEncoder = null;
+        WGPUCommandBufferImpl* commandBuffer = null;
+        try
+        {
+            WGPUBufferDescriptor storageDescriptor = new()
+            {
+                usage = (ulong)(BufferUsage.Storage | BufferUsage.CopySrc),
+                size = statusByteCount,
+                mappedAtCreation = 0U,
+            };
 
-            using WebGPUBufferMapCallback callback = WebGPUBufferMapCallback.From(Callback);
-            api.BufferMapAsync(readbackBuffer, MapMode.Read, 0, (nuint)probeByteCount, callback, null);
+            WGPUBufferDescriptor readbackDescriptor = new()
+            {
+                usage = (ulong)(BufferUsage.CopyDst | BufferUsage.MapRead),
+                size = statusByteCount,
+                mappedAtCreation = 0U,
+            };
+
+            storageBuffer = api.DeviceCreateBuffer(device, in storageDescriptor);
+            readbackBuffer = api.DeviceCreateBuffer(device, in readbackDescriptor);
+            if (storageBuffer is null || readbackBuffer is null)
+            {
+                return false;
+            }
 
-            // Non-blocking polls scoped to the submission index mirror the renderer's readback
-            // wait, and the managed timeout turns an adapter that never completes the submission
-            // into a probe failure instead of a hang.
-            Stopwatch stopwatch = Stopwatch.StartNew();
-            while (!mapReady.IsSet && stopwatch.ElapsedMilliseconds < CallbackTimeoutMilliseconds)
+            fixed (byte* shaderCodePtr = ChunkResetComputeShader.ShaderCode)
             {
-                _ = api.DevicePoll(device, false, &submissionIndex);
-                if (!mapReady.IsSet)
+                fixed (byte* entryPointPtr = ChunkResetComputeShader.EntryPoint)
                 {
-                    Thread.Yield();
+                    WGPUShaderSourceWGSL wgslDescriptor = new()
+                    {
+                        chain = new WGPUChainedStruct { sType = WGPUSType.ShaderSourceWGSL },
+                        code = shaderCodePtr
+                    };
+
+                    WGPUShaderModuleDescriptor shaderDescriptor = new()
+                    {
+                        nextInChain = (WGPUChainedStruct*)&wgslDescriptor
+                    };
+
+                    shaderModule = api.DeviceCreateShaderModule(device, in shaderDescriptor);
+                    if (shaderModule is null
+                        || !ChunkResetComputeShader.TryCreateBindGroupLayout(api, device, out bindGroupLayout, out _))
+                    {
+                        return false;
+                    }
+
+                    WGPUBindGroupLayoutImpl** layouts = stackalloc WGPUBindGroupLayoutImpl*[1] { bindGroupLayout };
+                    WGPUPipelineLayoutDescriptor layoutDescriptor = new()
+                    {
+                        bindGroupLayoutCount = 1,
+                        bindGroupLayouts = layouts
+                    };
+
+                    pipelineLayout = api.DeviceCreatePipelineLayout(device, in layoutDescriptor);
+                    if (pipelineLayout is null)
+                    {
+                        return false;
+                    }
+
+                    WGPUComputePipelineDescriptor pipelineDescriptor = new()
+                    {
+                        layout = pipelineLayout,
+                        compute = new WGPUComputeState
+                        {
+                            module = shaderModule,
+                            entryPoint = entryPointPtr
+                        }
+                    };
+
+                    pipeline = api.DeviceCreateComputePipeline(device, in pipelineDescriptor);
+                    if (pipeline is null)
+                    {
+                        return false;
+                    }
                 }
             }
 
-            // The status keeps its default value when the callback never fired, so timeouts and
-            // explicit non-success map results fail through the same check.
-            if (!mapReady.IsSet || mapStatus != WGPUMapAsyncStatus.Success)
+            WGPUBindGroupEntry* bindEntries = stackalloc WGPUBindGroupEntry[1];
+            bindEntries[0] = new WGPUBindGroupEntry
+            {
+                binding = 0,
+                buffer = storageBuffer,
+                offset = 0,
+                size = statusByteCount
+            };
+
+            WGPUBindGroupDescriptor bindGroupDescriptor = new()
+            {
+                layout = bindGroupLayout,
+                entryCount = 1,
+                entries = bindEntries
+            };
+
+            bindGroup = api.DeviceCreateBindGroup(device, in bindGroupDescriptor);
+            if (bindGroup is null)
+            {
+                return false;
+            }
+
+            WGPUCommandEncoderDescriptor encoderDescriptor = default;
+            commandEncoder = api.DeviceCreateCommandEncoder(device, in encoderDescriptor);
+            if (commandEncoder is null)
             {
                 return false;
             }
 
-            void* mapped = api.BufferGetConstMappedRange(readbackBuffer, 0, (nuint)probeByteCount);
-            if (mapped is null)
+            WGPUComputePassDescriptor passDescriptor = default;
+            WGPUComputePassEncoderImpl* pass = api.CommandEncoderBeginComputePass(commandEncoder, in passDescriptor);
+            if (pass is null)
             {
                 return false;
             }
 
-            api.BufferUnmap(readbackBuffer);
-            return true;
+            api.ComputePassEncoderSetPipeline(pass, pipeline);
+            api.ComputePassEncoderSetBindGroup(pass, 0, bindGroup, 0, null);
+            api.ComputePassEncoderDispatchWorkgroups(pass, ChunkResetComputeShader.GetDispatchX(), 1, 1);
+            api.ComputePassEncoderEnd(pass);
+            api.ComputePassEncoderRelease(pass);
+
+            api.CommandEncoderCopyBufferToBuffer(commandEncoder, storageBuffer, 0, readbackBuffer, 0, statusByteCount);
+
+            WGPUCommandBufferDescriptor commandBufferDescriptor = default;
+            commandBuffer = api.CommandEncoderFinish(commandEncoder, in commandBufferDescriptor);
+            if (commandBuffer is null)
+            {
+                return false;
+            }
+
+            ulong submissionIndex = api.QueueSubmitForIndex(queue, 1, ref commandBuffer);
+            return TryMapProbeBuffer(api, device, readbackBuffer, statusByteCount, submissionIndex);
         }
         finally
         {
@@ -611,14 +822,39 @@ void Callback(WGPUMapAsyncStatus status, void* userData)
                 api.CommandEncoderRelease(commandEncoder);
             }
 
+            if (bindGroup is not null)
+            {
+                api.BindGroupRelease(bindGroup);
+            }
+
+            if (pipeline is not null)
+            {
+                api.ComputePipelineRelease(pipeline);
+            }
+
+            if (pipelineLayout is not null)
+            {
+                api.PipelineLayoutRelease(pipelineLayout);
+            }
+
+            if (bindGroupLayout is not null)
+            {
+                api.BindGroupLayoutRelease(bindGroupLayout);
+            }
+
+            if (shaderModule is not null)
+            {
+                api.ShaderModuleRelease(shaderModule);
+            }
+
             if (readbackBuffer is not null)
             {
                 api.BufferRelease(readbackBuffer);
             }
 
-            if (sourceBuffer is not null)
+            if (storageBuffer is not null)
             {
-                api.BufferRelease(sourceBuffer);
+                api.BufferRelease(storageBuffer);
             }
         }
     }