Improve GPU perf

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.cs

@@ -51,6 +51,16 @@ public WebGPUDrawingBackend()
     /// </summary>
     internal string? TestingLastGPUInitializationFailure { get; private set; }
 
+    /// <summary>
+    /// Gets a value indicating whether the last staged flush used chunked oversized-scene dispatch.
+    /// </summary>
+    internal bool TestingLastFlushUsedChunking { get; private set; }
+
+    /// <summary>
+    /// Gets the chunkable binding-limit failure that selected the chunked path for the last staged flush.
+    /// </summary>
+    internal WebGPUSceneDispatch.BindingLimitBuffer TestingLastChunkingBindingFailure { get; private set; }
+
     /// <summary>
     /// Gets a value indicating whether the last flush completed on the staged path.
     /// </summary>
@@ -61,6 +71,16 @@ public WebGPUDrawingBackend()
     /// </summary>
     public string? DiagnosticLastSceneFailure => this.TestingLastGPUInitializationFailure;
 
+    /// <summary>
+    /// Gets a value indicating whether the last staged flush used the chunked oversized-scene path.
+    /// </summary>
+    public bool DiagnosticLastFlushUsedChunking => this.TestingLastFlushUsedChunking;
+
+    /// <summary>
+    /// Gets the chunkable binding-limit failure that selected the chunked oversized-scene path for the last staged flush.
+    /// </summary>
+    public string DiagnosticLastChunkingBindingFailure => this.TestingLastChunkingBindingFailure.ToString();
+
     /// <summary>
     /// Gets a value indicating whether WebGPU is available on the current system.
     /// This probes the runtime by attempting to acquire an adapter and device.
@@ -223,59 +243,71 @@ public void FlushCompositions<TPixel>(
 
         this.TestingLastFlushUsedGPU = false;
         this.TestingLastGPUInitializationFailure = null;
+        this.TestingLastFlushUsedChunking = false;
+        this.TestingLastChunkingBindingFailure = WebGPUSceneDispatch.BindingLimitBuffer.None;
         WebGPUSceneBumpSizes currentBumpSizes = this.bumpSizes;
-        for (int attempt = 0; attempt < MaxDynamicGrowthAttempts; attempt++)
+        WebGPUSceneSchedulingArena schedulingArena = default;
+        try
         {
-            if (!WebGPUSceneDispatch.TryCreateStagedScene(configuration, target, compositionScene, currentBumpSizes, out bool exceedsBindingLimit, out WebGPUSceneDispatch.BindingLimitFailure bindingLimitFailure, out WebGPUStagedScene stagedScene, out string? error))
-            {
-                this.TestingLastGPUInitializationFailure = exceedsBindingLimit
-                    ? error ?? "The staged WebGPU scene exceeded the current binding limits."
-                    : error ?? "Failed to create the staged WebGPU scene.";
-                this.FlushCompositionsFallback(configuration, target, compositionScene, compositionBounds: null);
-                return;
-            }
-
-            try
+            for (int attempt = 0; attempt < MaxDynamicGrowthAttempts; attempt++)
             {
-                this.TestingLastFlushUsedGPU = true;
-
-                if (stagedScene.EncodedScene.FillCount == 0)
+                if (!WebGPUSceneDispatch.TryCreateStagedScene(configuration, target, compositionScene, currentBumpSizes, out bool exceedsBindingLimit, out WebGPUSceneDispatch.BindingLimitFailure bindingLimitFailure, out WebGPUStagedScene stagedScene, out string? error))
                 {
-                    // Empty staged scenes still establish the flush-sized scratch-capacity baseline.
-                    this.bumpSizes = stagedScene.Config.BumpSizes;
+                    this.TestingLastGPUInitializationFailure = exceedsBindingLimit
+                        ? error ?? "The staged WebGPU scene exceeded the current binding limits."
+                        : error ?? "Failed to create the staged WebGPU scene.";
+                    this.FlushCompositionsFallback(configuration, target, compositionScene, compositionBounds: null);
                     return;
                 }
 
-                if (WebGPUSceneDispatch.TryRenderStagedScene(ref stagedScene, out bool requiresGrowth, out WebGPUSceneBumpSizes grownBumpSizes, out error))
+                try
                 {
-                    // Persist the last successful capacities so the next flush starts from the
-                    // budget that actually worked on this device.
-                    this.bumpSizes = stagedScene.Config.BumpSizes;
-                    return;
-                }
+                    this.TestingLastFlushUsedGPU = true;
+                    this.TestingLastFlushUsedChunking = stagedScene.BindingLimitFailure.Buffer != WebGPUSceneDispatch.BindingLimitBuffer.None;
+                    this.TestingLastChunkingBindingFailure = stagedScene.BindingLimitFailure.Buffer;
+
+                    if (stagedScene.EncodedScene.FillCount == 0)
+                    {
+                        // Empty staged scenes still establish the flush-sized scratch-capacity baseline.
+                        this.bumpSizes = stagedScene.Config.BumpSizes;
+                        return;
+                    }
 
-                this.TestingLastFlushUsedGPU = false;
-                if (requiresGrowth)
+                    if (WebGPUSceneDispatch.TryRenderStagedScene(ref stagedScene, ref schedulingArena, out bool requiresGrowth, out WebGPUSceneBumpSizes grownBumpSizes, out error))
+                    {
+                        // Persist the last successful capacities so the next flush starts from the
+                        // budget that actually worked on this device.
+                        this.bumpSizes = stagedScene.Config.BumpSizes;
+                        return;
+                    }
+
+                    this.TestingLastFlushUsedGPU = false;
+                    if (requiresGrowth)
+                    {
+                        // Scheduling reported that one or more bump allocators overflowed. Retry the
+                        // same flush with the larger capacities read back from the GPU.
+                        currentBumpSizes = grownBumpSizes;
+                        continue;
+                    }
+
+                    this.TestingLastGPUInitializationFailure = error ?? "The staged WebGPU scene dispatch failed.";
+                }
+                finally
                 {
-                    // Scheduling reported that one or more bump allocators overflowed. Retry the
-                    // same flush with the larger capacities read back from the GPU.
-                    currentBumpSizes = grownBumpSizes;
-                    continue;
+                    stagedScene.Dispose();
                 }
 
-                this.TestingLastGPUInitializationFailure = error ?? "The staged WebGPU scene dispatch failed.";
-            }
-            finally
-            {
-                stagedScene.Dispose();
+                this.FlushCompositionsFallback(configuration, target, compositionScene, compositionBounds: null);
+                return;
             }
 
+            this.TestingLastGPUInitializationFailure = "The staged WebGPU scene exceeded the current dynamic growth retry budget.";
             this.FlushCompositionsFallback(configuration, target, compositionScene, compositionBounds: null);
-            return;
         }
-
-        this.TestingLastGPUInitializationFailure = "The staged WebGPU scene exceeded the current dynamic growth retry budget.";
-        this.FlushCompositionsFallback(configuration, target, compositionScene, compositionBounds: null);
+        finally
+        {
+            WebGPUSceneDispatch.DisposeSchedulingArena(ref schedulingArena);
+        }
     }
 
     /// <summary>

src/ImageSharp.Drawing.WebGPU/WebGPUSceneConfig.cs

@@ -193,13 +193,13 @@ public WebGPUSceneBumpSizes(
     /// </remarks>
     public static WebGPUSceneBumpSizes Initial()
         => new(
-            1U << 21,
-            1U << 18,
-            1U << 21,
-            1U << 21,
-            1U << 21,
+            1U << 15,
+            1U << 12,
+            1U << 15,
+            1U << 15,
+            1U << 15,
             1U << 20,
-            1U << 23);
+            1U << 17);
 
     /// <summary>
     /// Raises the current capacities to the scene-derived lower bounds for one encoded scene.
@@ -235,11 +235,7 @@ private static uint GetSceneTileLowerBound(WebGPUEncodedScene scene)
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static uint GetSceneSegmentLowerBound(WebGPUEncodedScene scene)
-
-        // The final segment buffers are driven by the path-count/path-tiling stages, not by the
-        // coarser path-tile membership count. Until the encoder carries a CPU-side line-slice total,
-        // the only safe lower bound we know here is the emitted line count.
-        => AddSizingSlack(checked((uint)Math.Max(scene.TotalLineSliceCount, scene.LineCount)));
+        => AddSizingSlack(checked((uint)scene.LineCount));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static uint MaxCapacity(uint current, uint required)