Add RemoteExecutor and WebGPU probe

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/ImageSharp.Drawing.WebGPU.csproj

@@ -12,6 +12,13 @@
     <PackageTags>Image Draw Shape Path Font</PackageTags>
     <Description>An extension to ImageSharp that allows the drawing of images, paths, and text.</Description>
     <Configurations>Debug;Release</Configurations>
+    <!--
+      OutputType=Exe is required so that runtimeconfig.json and deps.json are generated.
+      The internal RemoteExecutor uses 'dotnet exec' to spawn a child process that probes
+      compute pipeline support. This avoids unrecoverable AccessViolationException crashes
+      in the parent process. The assembly is still usable as a library via ProjectReference.
+    -->
+    <OutputType>Exe</OutputType>
     <IsTrimmable>true</IsTrimmable>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
 

src/ImageSharp.Drawing.WebGPU/RemoteExecutor/Program.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
+
+/// <summary>
+/// Entry point for child processes spawned by <see cref="RemoteExecutor"/>.
+/// Dispatches to the requested probe method by name.
+/// Adapted from Microsoft.DotNet.RemoteExecutor (MIT license).
+/// </summary>
+internal static class Program
+{
+    private static int Main(string[] args)
+    {
+        if (args.Length < 1)
+        {
+            Console.Error.WriteLine("Usage: {0} methodName", typeof(Program).Assembly.GetName().Name);
+            return -1;
+        }
+
+        string methodName = args[0];
+
+        return methodName switch
+        {
+            nameof(WebGPUDrawingBackend.ProbeComputePipelineSupport) => WebGPUDrawingBackend.ProbeComputePipelineSupport(),
+            _ => -1
+        };
+    }
+}

src/ImageSharp.Drawing.WebGPU/RemoteExecutor/RemoteExecutor.cs

@@ -0,0 +1,151 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using IOPath = System.IO.Path;
+
+namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
+
+/// <summary>
+/// Minimal remote executor that invokes a named method in a child process.
+/// The child process entry point (<see cref="Program.Main"/>) dispatches to
+/// the requested method by name — no reflection is used.
+/// Adapted from Microsoft.DotNet.RemoteExecutor (MIT license).
+/// </summary>
+internal static class RemoteExecutor
+{
+    private static readonly string? AssemblyPath;
+    private static readonly string? HostRunner;
+    private static readonly string? RuntimeConfigPath;
+    private static readonly string? DepsJsonPath;
+
+    static RemoteExecutor()
+    {
+        if (!IsSupported)
+        {
+            return;
+        }
+
+        string? processFileName = Process.GetCurrentProcess().MainModule?.FileName;
+        if (processFileName is null)
+        {
+            return;
+        }
+
+        string baseDir = AppContext.BaseDirectory;
+        string assemblyName = typeof(RemoteExecutor).Assembly.GetName().Name!;
+        AssemblyPath = IOPath.Combine(baseDir, assemblyName + ".dll");
+        if (!File.Exists(AssemblyPath))
+        {
+            return;
+        }
+
+        HostRunner = processFileName;
+        string hostName = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "dotnet.exe" : "dotnet";
+
+        if (!IOPath.GetFileName(HostRunner).Equals(hostName, StringComparison.OrdinalIgnoreCase))
+        {
+            string runtimeDir = RuntimeEnvironment.GetRuntimeDirectory();
+            string? directory = IOPath.GetDirectoryName(IOPath.GetDirectoryName(IOPath.GetDirectoryName(runtimeDir)));
+            if (directory is not null)
+            {
+                string dotnetExe = IOPath.Combine(directory, hostName);
+                if (File.Exists(dotnetExe))
+                {
+                    HostRunner = dotnetExe;
+                }
+            }
+        }
+
+        string runtimeConfigCandidate = IOPath.Combine(baseDir, assemblyName + ".runtimeconfig.json");
+        string depsJsonCandidate = IOPath.Combine(baseDir, assemblyName + ".deps.json");
+
+        RuntimeConfigPath = File.Exists(runtimeConfigCandidate) ? runtimeConfigCandidate : null;
+        DepsJsonPath = File.Exists(depsJsonCandidate) ? depsJsonCandidate : null;
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether this remote executor is supported on the current platform.
+    /// </summary>
+    internal static bool IsSupported { get; } =
+        !RuntimeInformation.IsOSPlatform(OSPlatform.Create("IOS")) &&
+        !RuntimeInformation.IsOSPlatform(OSPlatform.Create("ANDROID")) &&
+        !RuntimeInformation.IsOSPlatform(OSPlatform.Create("BROWSER")) &&
+        !RuntimeInformation.IsOSPlatform(OSPlatform.Create("WASI")) &&
+        Environment.GetEnvironmentVariable("DOTNET_REMOTEEXECUTOR_SUPPORTED") != "0";
+
+    /// <summary>
+    /// Invokes the specified static method in a child process and returns its exit code.
+    /// The method name is dispatched by <see cref="Program.Main"/> via a switch statement,
+    /// so no reflection is needed in the child process.
+    /// </summary>
+    /// <param name="method">A static method returning <see cref="int"/> (the exit code).</param>
+    /// <param name="timeoutMilliseconds">Maximum time to wait for the child process.</param>
+    /// <returns>The exit code from the child process, or -1 on failure.</returns>
+    internal static int Invoke(Func<int> method, int timeoutMilliseconds = 30_000)
+    {
+        if (!IsSupported || AssemblyPath is null || HostRunner is null)
+        {
+            return -1;
+        }
+
+        string methodName = method.Method.Name;
+
+        string args = "exec";
+        if (RuntimeConfigPath is not null)
+        {
+            args += $" --runtimeconfig \"{RuntimeConfigPath}\"";
+        }
+
+        if (DepsJsonPath is not null)
+        {
+            args += $" --depsfile \"{DepsJsonPath}\"";
+        }
+
+        args += $" \"{AssemblyPath}\" \"{methodName}\"";
+
+        ProcessStartInfo psi = new()
+        {
+            FileName = HostRunner,
+            Arguments = args,
+            UseShellExecute = false,
+            CreateNoWindow = true
+        };
+
+        // Remove profiler environment variables from child process.
+        psi.Environment.Remove("Cor_Profiler");
+        psi.Environment.Remove("Cor_Enable_Profiling");
+        psi.Environment.Remove("CoreClr_Profiler");
+        psi.Environment.Remove("CoreClr_Enable_Profiling");
+
+        try
+        {
+            using Process? process = Process.Start(psi);
+            if (process is null)
+            {
+                return -1;
+            }
+
+            if (!process.WaitForExit(timeoutMilliseconds))
+            {
+                try
+                {
+                    process.Kill();
+                }
+                catch
+                {
+                    // Ignore cleanup errors.
+                }
+
+                return -1;
+            }
+
+            return process.ExitCode;
+        }
+        catch
+        {
+            return -1;
+        }
+    }
+}

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.cs

@@ -142,33 +142,76 @@ private enum PreparedBrushType : uint
     /// This probes the runtime by attempting to acquire an adapter and device.
     /// The result is cached after the first probe.
     /// </summary>
-    public bool IsSupported => isSupported ??= ProbeSupport();
+    public bool IsSupported => isSupported ??= ProbeFullSupport();
 
     /// <summary>
-    /// Determines whether WebGPU compute support is available on the current system.
+    /// Probes whether WebGPU compute is fully supported on the current system.
+    /// First checks adapter/device availability in-process. If that succeeds,
+    /// spawns a child process via <see cref="RemoteExecutor"/> to test compute
+    /// pipeline creation, which can crash with an unrecoverable access violation
+    /// on some systems. If the remote executor is not available, falls back to
+    /// the device-only check.
     /// </summary>
-    /// <remarks>
-    /// This method goes beyond checking adapter and device availability — it also compiles
-    /// a trivial compute shader and creates a compute pipeline to verify the full compute
-    /// path works. Some systems report a valid device but crash on pipeline creation due to
-    /// driver or runtime issues.
-    /// </remarks>
     /// <returns>Returns <see langword="true"/> if WebGPU compute support is available; otherwise, <see langword="false"/>.</returns>
+    private static bool ProbeFullSupport()
+    {
+        // Step 1: Quick in-process check for adapter/device availability.
+        if (!ProbeSupport())
+        {
+            return false;
+        }
+
+        // Step 2: Out-of-process probe for compute pipeline support.
+        // DeviceCreateComputePipeline can crash with an AccessViolationException
+        // on some systems (e.g. Windows CI with software renderers). This native
+        // crash cannot be caught in managed code, so we run it in a child process.
+        if (!RemoteExecutor.IsSupported)
+        {
+            // If we can't spawn a child process, assume device availability is sufficient.
+            return true;
+        }
+
+        return RemoteExecutor.Invoke(ProbeComputePipelineSupport) == 0;
+    }
+
+    /// <summary>
+    /// Determines whether WebGPU adapter and device are available on the current system.
+    /// </summary>
+    /// <remarks>This method only checks adapter and device availability. It does not attempt
+    /// compute pipeline creation. Use <see cref="ProbeFullSupport"/> for a complete check.</remarks>
+    /// <returns>Returns <see langword="true"/> if a WebGPU device is available; otherwise, <see langword="false"/>.</returns>
     public static bool ProbeSupport()
+    {
+        try
+        {
+            using WebGPURuntime.Lease lease = WebGPURuntime.Acquire();
+            return WebGPURuntime.TryGetOrCreateDevice(out _, out _, out _);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Probes full WebGPU compute pipeline support by compiling a trivial shader and
+    /// creating a compute pipeline. This method may crash with an access violation on
+    /// systems with broken WebGPU compute support — callers should run it in a child
+    /// process (e.g. via <c>RemoteExecutor</c>) to isolate the crash.
+    /// </summary>
+    /// <returns>Exit code: 0 on success, 1 on failure.</returns>
+    public static int ProbeComputePipelineSupport()
     {
         try
         {
             using WebGPURuntime.Lease lease = WebGPURuntime.Acquire();
             if (!WebGPURuntime.TryGetOrCreateDevice(out Device* device, out _, out _))
             {
-                return false;
+                return 1;
             }
 
             WebGPU api = lease.Api;
 
-            // Compile a trivial compute shader and create a pipeline to verify the
-            // full compute path works end-to-end. Some drivers/runtimes crash at
-            // DeviceCreateComputePipeline despite successful device creation.
             ReadOnlySpan<byte> probeShader = "@compute @workgroup_size(1) fn cs_main() {}\0"u8;
             fixed (byte* shaderCodePtr = probeShader)
             {
@@ -186,7 +229,7 @@ public static bool ProbeSupport()
                 ShaderModule* shaderModule = api.DeviceCreateShaderModule(device, in shaderDescriptor);
                 if (shaderModule is null)
                 {
-                    return false;
+                    return 1;
                 }
 
                 try
@@ -209,7 +252,7 @@ public static bool ProbeSupport()
                         PipelineLayout* pipelineLayout = api.DeviceCreatePipelineLayout(device, in layoutDescriptor);
                         if (pipelineLayout is null)
                         {
-                            return false;
+                            return 1;
                         }
 
                         try
@@ -223,11 +266,11 @@ public static bool ProbeSupport()
                             ComputePipeline* pipeline = api.DeviceCreateComputePipeline(device, in pipelineDescriptor);
                             if (pipeline is null)
                             {
-                                return false;
+                                return 1;
                             }
 
                             api.ComputePipelineRelease(pipeline);
-                            return true;
+                            return 0;
                         }
                         finally
                         {
@@ -243,7 +286,7 @@ public static bool ProbeSupport()
         }
         catch
         {
-            return false;
+            return 1;
         }
     }
 

tests/ImageSharp.Drawing.Tests/TestUtilities/Attributes/WebGPUFactAttribute.cs

@@ -6,31 +6,55 @@
 namespace SixLabors.ImageSharp.Drawing.Tests.TestUtilities.Attributes;
 
 /// <summary>
-/// A <see cref="FactAttribute"/> that skips when WebGPU is not available on the current system.
+/// A <see cref="FactAttribute"/> that skips when WebGPU compute is not available on the current system.
 /// </summary>
 public class WebGPUFactAttribute : FactAttribute
 {
     public WebGPUFactAttribute()
     {
-        using WebGPUDrawingBackend backend = new();
-        if (!backend.IsSupported)
+        if (!WebGPUProbe.IsComputeSupported)
         {
-            this.Skip = "WebGPU is not available on this system.";
+            this.Skip = "WebGPU compute is not available on this system.";
         }
     }
 }
 
 /// <summary>
-/// A <see cref="TheoryAttribute"/> that skips when WebGPU is not available on the current system.
+/// A <see cref="TheoryAttribute"/> that skips when WebGPU compute is not available on the current system.
 /// </summary>
 public class WebGPUTheoryAttribute : TheoryAttribute
 {
     public WebGPUTheoryAttribute()
     {
-        using WebGPUDrawingBackend backend = new();
-        if (!backend.IsSupported)
+        if (!WebGPUProbe.IsComputeSupported)
         {
-            this.Skip = "WebGPU is not available on this system.";
+            this.Skip = "WebGPU compute is not available on this system.";
+        }
+    }
+}
+
+/// <summary>
+/// Caches the result of the WebGPU compute pipeline probe.
+/// The backend's <see cref="WebGPUDrawingBackend.IsSupported"/> already performs
+/// a full out-of-process probe via the internal RemoteExecutor, so we simply
+/// instantiate the backend and check its result.
+/// </summary>
+internal static class WebGPUProbe
+{
+    private static bool? computeSupported;
+
+    internal static bool IsComputeSupported => computeSupported ??= Probe();
+
+    private static bool Probe()
+    {
+        try
+        {
+            using WebGPUDrawingBackend backend = new();
+            return backend.IsSupported;
+        }
+        catch
+        {
+            return false;
         }
     }
 }