Fix chunking

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.cs

@@ -23,7 +23,11 @@ public sealed unsafe partial class WebGPUDrawingBackend : IDrawingBackend, IDisp
 
     // A single flush can rerun the staged path a small number of times while the scratch
     // buffers converge on the capacity reported by the scheduling stages.
-    private const int MaxDynamicGrowthAttempts = 3;
+    // The prepare shader cancels early when any single buffer overflows, so each
+    // retry only discovers one new overflow. 8 attempts covers all 7 bump buffers
+    // plus the final successful run. Only needed on the first flush; subsequent
+    // flushes reuse the persisted GPU-reported sizes and need zero retries.
+    private const int MaxDynamicGrowthAttempts = 8;
 
     private readonly DefaultDrawingBackend fallbackBackend;
     private static bool? isSupported;
@@ -268,24 +272,18 @@ public void FlushCompositions<TPixel>(
 
                     if (stagedScene.EncodedScene.FillCount == 0)
                     {
-                        // Empty staged scenes still establish the flush-sized scratch-capacity baseline.
-                        this.bumpSizes = stagedScene.Config.BumpSizes;
                         return;
                     }
 
                     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;
+                        this.bumpSizes = grownBumpSizes;
                         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;
                     }

src/ImageSharp.Drawing.WebGPU/WebGPUSceneConfig.cs

@@ -202,47 +202,7 @@ public static WebGPUSceneBumpSizes Initial()
             1U << 17);
 
     /// <summary>
-    /// Raises the current capacities to the scene-derived lower bounds for one encoded scene.
-    /// </summary>
-    /// <remarks>
-    /// Several staged allocators already have reliable CPU-side counts before any GPU scheduling work starts.
-    /// Using those counts as the first attempt avoids wasting retries on scenes that are obviously larger than
-    /// the previous flush. The GPU bump allocators still provide the final correction for the dynamic cases.
-    /// </remarks>
-    /// <param name="scene">The encoded scene whose aggregate scheduling counts are already known on the CPU.</param>
-    /// <returns>The current capacities raised to this scene's known lower bounds.</returns>
-    public WebGPUSceneBumpSizes WithSceneLowerBounds(WebGPUEncodedScene scene)
-        => new(
-            MaxCapacity(this.Lines, GetSceneLinesLowerBound(scene)),
-            MaxCapacity(this.Binning, GetSceneBinningLowerBound(scene)),
-            MaxCapacity(this.PathTiles, GetSceneTileLowerBound(scene)),
-            MaxCapacity(this.SegCounts, GetSceneSegmentLowerBound(scene)),
-            MaxCapacity(this.Segments, GetSceneSegmentLowerBound(scene)),
-            this.BlendSpill,
-            this.Ptcl);
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint GetSceneLinesLowerBound(WebGPUEncodedScene scene)
-        => AddSizingSlack(checked((uint)Math.Max(scene.LineCount, 1)));
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint GetSceneBinningLowerBound(WebGPUEncodedScene scene)
-        => AddSizingSlack(checked((uint)Math.Max(scene.TotalBinMembershipCount, scene.DrawTagCount)));
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint GetSceneTileLowerBound(WebGPUEncodedScene scene)
-        => AddSizingSlack(checked((uint)Math.Max(scene.TotalTileMembershipCount, scene.PathCount)));
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint GetSceneSegmentLowerBound(WebGPUEncodedScene scene)
-        => AddSizingSlack(checked((uint)scene.LineCount));
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint MaxCapacity(uint current, uint required)
-        => current >= required ? current : required;
-
-    /// <summary>
-    /// Adds a small retry margin and aligns the result so scene-derived capacities do not sit exactly on the edge.
+    /// Adds a small retry margin and aligns the result so capacities do not sit exactly on the edge.
     /// </summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static uint AddSizingSlack(uint required)

src/ImageSharp.Drawing.WebGPU/WebGPUSceneDispatch.cs

@@ -170,8 +170,7 @@ public static bool TryCreateStagedScene<TPixel>(
             }
 
             encodedScene = createdScene;
-            WebGPUSceneBumpSizes sceneBumpSizes = bumpSizes.WithSceneLowerBounds(encodedScene);
-            WebGPUSceneConfig config = WebGPUSceneConfig.Create(encodedScene, sceneBumpSizes);
+            WebGPUSceneConfig config = WebGPUSceneConfig.Create(encodedScene, bumpSizes);
             uint baseColor = 0U;
             bool segmentChunkingRequired = false;
             if (!TryValidateBindingSizes(encodedScene, config, flushContext.DeviceState.MaxStorageBufferBindingSize, out bindingLimitFailure, out error))
@@ -967,6 +966,8 @@ public static unsafe bool TryRenderStagedScene(
         {
             requiresGrowth = true;
             grownBumpSizes = GrowBumpSizes(stagedScene.Config.BumpSizes, in bumpAllocators);
+            WebGPUSceneBumpSizes cfg = stagedScene.Config.BumpSizes;
+            System.IO.File.AppendAllText("bump_debug.log", $"[BUMP OVERFLOW] failed={bumpAllocators.Failed:X} | had: lines={cfg.Lines} bin={cfg.Binning} tiles={cfg.PathTiles} segc={cfg.SegCounts} segs={cfg.Segments} blend={cfg.BlendSpill} ptcl={cfg.Ptcl} | gpu: lines={bumpAllocators.Lines} bin={bumpAllocators.Binning} tiles={bumpAllocators.Tile} segc={bumpAllocators.SegCounts} segs={bumpAllocators.Segments} blend={bumpAllocators.BlendSpill} ptcl={bumpAllocators.Ptcl} | grown: lines={grownBumpSizes.Lines} bin={grownBumpSizes.Binning} tiles={grownBumpSizes.PathTiles} segc={grownBumpSizes.SegCounts} segs={grownBumpSizes.Segments} blend={grownBumpSizes.BlendSpill} ptcl={grownBumpSizes.Ptcl}\n");
             error = "The staged WebGPU scene needs larger scratch buffers and will be retried.";
             return false;
         }
@@ -978,7 +979,18 @@ public static unsafe bool TryRenderStagedScene(
             return false;
         }
 
-        // Scheduling passed. Submit the pre-recorded fine + copy. Fire-and-forget.
+        // Scheduling passed. Persist the actual GPU usage so the next flush starts
+        // from sizes that are known to work, eliminating retries for similar scenes.
+        grownBumpSizes = new WebGPUSceneBumpSizes(
+            Math.Max(bumpAllocators.Lines, stagedScene.Config.BumpSizes.Lines),
+            Math.Max(bumpAllocators.Binning, stagedScene.Config.BumpSizes.Binning),
+            Math.Max(bumpAllocators.Tile, stagedScene.Config.BumpSizes.PathTiles),
+            Math.Max(bumpAllocators.SegCounts, stagedScene.Config.BumpSizes.SegCounts),
+            Math.Max(bumpAllocators.Segments, stagedScene.Config.BumpSizes.Segments),
+            Math.Max(bumpAllocators.BlendSpill, stagedScene.Config.BumpSizes.BlendSpill),
+            Math.Max(bumpAllocators.Ptcl, stagedScene.Config.BumpSizes.Ptcl));
+
+        // Submit the pre-recorded fine + copy. Fire-and-forget.
         return WebGPUDrawingBackend.TrySubmit(flushContext);
     }
 
@@ -1061,11 +1073,13 @@ private static unsafe bool TryRenderSegmentChunkedStagedScene(
                 WebGPUSceneConfig chunkConfig = WebGPUSceneConfig.Create(encodedScene, chunkBumpSize, chunkWindow);
                 if (!TryValidateBindingSizes(encodedScene, chunkConfig, maxStorageBufferBindingSize, out BindingLimitFailure bindingLimitFailure, out error))
                 {
+                    System.IO.File.AppendAllText("bump_debug.log", $"[CHUNK VALIDATION FAIL] buffer={bindingLimitFailure.Buffer} required={bindingLimitFailure.RequiredBytes} limit={bindingLimitFailure.LimitBytes} chunkTileH={requestedTileHeight} totalTileH={totalTileHeight} tiles={chunkBumpSize.PathTiles} segc={chunkBumpSize.SegCounts} segs={chunkBumpSize.Segments} srcTiles={stagedScene.Config.BumpSizes.PathTiles} srcSegc={stagedScene.Config.BumpSizes.SegCounts}\n");
                     if (IsChunkableBindingFailure(bindingLimitFailure.Buffer))
                     {
                         uint smallerTileHeight = ShrinkChunkTileHeight(requestedTileHeight, remainingTileHeight, bindingLimitFailure);
                         if (smallerTileHeight >= requestedTileHeight)
                         {
+                            System.IO.File.AppendAllText("bump_debug.log", $"[CHUNK SHRINK STUCK] smallerH={smallerTileHeight} requestedH={requestedTileHeight}\n");
                             return false;
                         }
 
@@ -1293,18 +1307,17 @@ private static WebGPUSceneChunkWindow CreateChunkWindow(uint tileYStart, uint re
     private static WebGPUSceneBumpSizes ScaleChunkBumpSizes(WebGPUSceneBumpSizes sourceBumpSizes, WebGPUEncodedScene scene, uint chunkTileHeight)
     {
         uint fullTileHeight = checked((uint)scene.TileCountY);
-        uint chunkTileBufferHeight = AlignUp(chunkTileHeight, 16U);
-        uint pathTileFloor = AddSizingSlack(ScaleCount((uint)Math.Max(scene.TotalTileMembershipCount, scene.PathCount), chunkTileBufferHeight, fullTileHeight));
-        uint segmentFloor = AddSizingSlack(ScaleCount((uint)scene.LineCount, chunkTileBufferHeight, fullTileHeight));
+        uint pathTileFloor = AddSizingSlack(ScaleCount((uint)Math.Max(scene.TotalTileMembershipCount, scene.PathCount), chunkTileHeight, fullTileHeight));
+        uint segmentFloor = AddSizingSlack(ScaleCount((uint)scene.LineCount, chunkTileHeight, fullTileHeight));
 
         return new WebGPUSceneBumpSizes(
             sourceBumpSizes.Lines,
             sourceBumpSizes.Binning,
-            Math.Max(ScaleCount(sourceBumpSizes.PathTiles, chunkTileBufferHeight, fullTileHeight), pathTileFloor),
-            Math.Max(ScaleCount(sourceBumpSizes.SegCounts, chunkTileBufferHeight, fullTileHeight), segmentFloor),
-            Math.Max(ScaleCount(sourceBumpSizes.Segments, chunkTileBufferHeight, fullTileHeight), segmentFloor),
-            ScaleCount(sourceBumpSizes.BlendSpill, chunkTileBufferHeight, fullTileHeight),
-            ScaleCount(sourceBumpSizes.Ptcl, chunkTileBufferHeight, fullTileHeight));
+            Math.Max(ScaleCount(sourceBumpSizes.PathTiles, chunkTileHeight, fullTileHeight), pathTileFloor),
+            Math.Max(ScaleCount(sourceBumpSizes.SegCounts, chunkTileHeight, fullTileHeight), segmentFloor),
+            Math.Max(ScaleCount(sourceBumpSizes.Segments, chunkTileHeight, fullTileHeight), segmentFloor),
+            ScaleCount(sourceBumpSizes.BlendSpill, chunkTileHeight, fullTileHeight),
+            ScaleCount(sourceBumpSizes.Ptcl, chunkTileHeight, fullTileHeight));
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1448,8 +1461,8 @@ private static uint GrowBumpSize(uint currentSize, uint requiredSize)
             return currentSize;
         }
 
-        uint nextSize = checked(requiredSize + Math.Max(requiredSize / 2U, 4096U));
-        return nextSize > currentSize ? nextSize : checked(currentSize + 1U);
+        // Use the GPU-reported size doubled so one retry is always enough.
+        return checked(requiredSize * 2U);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1839,14 +1852,25 @@ void Callback(BufferMapAsyncStatus status, void* userData)
             {
                 GpuSceneBumpAllocators bumpAllocators = statuses[i];
                 WebGPUSceneBumpSizes currentSizes = chunkBumpSizes[i];
+                WebGPUSceneBumpSizes chunkActuals = new(
+                    Math.Max(bumpAllocators.Lines, currentSizes.Lines),
+                    Math.Max(bumpAllocators.Binning, currentSizes.Binning),
+                    Math.Max(bumpAllocators.Tile, currentSizes.PathTiles),
+                    Math.Max(bumpAllocators.SegCounts, currentSizes.SegCounts),
+                    Math.Max(bumpAllocators.Segments, currentSizes.Segments),
+                    Math.Max(bumpAllocators.BlendSpill, currentSizes.BlendSpill),
+                    Math.Max(bumpAllocators.Ptcl, currentSizes.Ptcl));
+                WebGPUSceneBumpSizes expandedActuals = ExpandChunkBumpSizesToSceneBudget(chunkActuals, fullTileHeight, chunkTileHeights[i]);
+                grownBumpSizes = MaxBumpSizes(grownBumpSizes, expandedActuals);
+
                 if (!RequiresScratchReallocation(in bumpAllocators, currentSizes))
                 {
                     continue;
                 }
 
                 WebGPUSceneBumpSizes grownChunkBumpSizes = GrowBumpSizes(currentSizes, in bumpAllocators);
                 WebGPUSceneBumpSizes grownSourceBumpSizes = ExpandChunkBumpSizesToSceneBudget(grownChunkBumpSizes, fullTileHeight, chunkTileHeights[i]);
-                grownBumpSizes = requiresGrowth ? MaxBumpSizes(grownBumpSizes, grownSourceBumpSizes) : grownSourceBumpSizes;
+                grownBumpSizes = MaxBumpSizes(grownBumpSizes, grownSourceBumpSizes);
                 requiresGrowth = true;
             }