Use inline array, fix GPU retry counter logic

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.cs

@@ -20,13 +20,20 @@ namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 /// </remarks>
 public sealed unsafe partial class WebGPUDrawingBackend : IDrawingBackend, IDisposable
 {
-    // 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.
-    // 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;
+    // Number of independently sized scratch buffers tracked by WebGPUSceneBumpSizes.
+    // A first-use flush can expose at most one newly visible allocator overflow per
+    // failed pass, so the retry budget is expressed in terms of this count. The
+    // tracked allocators are Lines, Binning, PathTiles, SegCounts, Segments,
+    // BlendSpill, and Ptcl.
+    private const int ScratchAllocatorCount = 7;
+
+    // A first flush can rerun the staged path while the GPU-reported scratch capacities
+    // converge. Earlier scheduling overflows can prevent later stages from reporting
+    // their own demand, so one failed pass can be needed per tracked allocator. A
+    // Failed-only report can also require one conservative force-growth pass when no
+    // individual counter exceeded its current capacity. Add one final pass for the
+    // successful render after the last growth.
+    private const int MaxDynamicGrowthAttempts = ScratchAllocatorCount + 2;
 
     private readonly DefaultDrawingBackend fallbackBackend;
 
@@ -155,12 +162,10 @@ public void FlushCompositions<TPixel>(
         WebGPUSceneResourceArena? resourceArena = Interlocked.Exchange(ref this.cachedResourceArena, null);
         try
         {
-            // Retry loop: bump allocators start small (Vello defaults) and the GPU discovers
-            // the actual sizes needed. Each overflow grows the failing buffers. The prepare
-            // shader does not cancel on overflow so all stages report true demand per pass,
-            // but data dependencies mean later stages report zero when earlier ones overflow.
-            // Typically converges in 3-5 attempts on first use, then zero retries thereafter
-            // because successful sizes are persisted in this.bumpSizes.
+            // Retry loop: scratch allocators start small and the GPU reports actual demand.
+            // Earlier scheduling overflows can hide later-stage demand, so a first-use flush
+            // can require several passes before the capacities converge. Successful sizes are
+            // persisted in this.bumpSizes, so later flushes usually run without retries.
             for (int attempt = 0; attempt < MaxDynamicGrowthAttempts; attempt++)
             {
                 if (!WebGPUSceneDispatch.TryCreateStagedScene(configuration, target, compositionScene, currentBumpSizes, ref resourceArena, out bool exceedsBindingLimit, out WebGPUSceneDispatch.BindingLimitFailure bindingLimitFailure, out WebGPUStagedScene stagedScene, out string? error))

src/ImageSharp.Drawing.WebGPU/WebGPUSceneDispatch.cs

@@ -894,8 +894,10 @@ public static unsafe bool TryRenderStagedScene(
             return false;
         }
 
-        // Overflow: fine output is garbage but bump counters report true demand for all
-        // buffers. Prepare shader never cancels, so one retry with doubled sizes suffices.
+        // Overflow: the fine output is discarded, but the scheduling readback still reports
+        // the scratch usage visible to this pass. Later-stage demand can stay hidden until
+        // earlier overflows are resolved, so the backend retries with larger buffers until
+        // the capacities converge or the bounded attempt budget is exhausted.
         if (RequiresScratchReallocation(in bumpAllocators, stagedScene.Config.BumpSizes))
         {
             requiresGrowth = true;

src/ImageSharp.Drawing/Processing/Backends/DefaultRasterizer.RasterizableGeometry.cs

@@ -154,31 +154,14 @@ public ReadOnlySpan<int> GetCoversForRow(int localRowIndex)
         /// </summary>
         public void Dispose()
         {
-            if (this.IsX16)
+            if (this.linesX16 is not null)
             {
-                for (int i = 0; i < this.linesX16!.Length; i++)
-                {
-                    LineArrayX16Y16Block? block = this.linesX16[i];
-                    while (block is not null)
-                    {
-                        LineArrayX16Y16Block? next = block.Next;
-                        block.Dispose();
-                        block = next;
-                    }
-                }
+                Array.Clear(this.linesX16);
             }
-            else
+
+            if (this.linesX32 is not null)
             {
-                for (int i = 0; i < this.linesX32!.Length; i++)
-                {
-                    LineArrayX32Y16Block? block = this.linesX32[i];
-                    while (block is not null)
-                    {
-                        LineArrayX32Y16Block? next = block.Next;
-                        block.Dispose();
-                        block = next;
-                    }
-                }
+                Array.Clear(this.linesX32);
             }
 
             for (int i = 0; i < this.startCoverTable.Length; i++)

src/ImageSharp.Drawing/Processing/Backends/DefaultRasterizer.RetainedTypes.cs

@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 
 namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 
@@ -256,25 +255,19 @@ public void AppendLine(int x0, int y0, int x1, int y1)
     /// <summary>
     /// Represents one retained 32-bit-X line block.
     /// </summary>
-    internal sealed class LineArrayX32Y16Block : ILineBlock<LineArrayX32Y16Block>, IDisposable
+    internal sealed class LineArrayX32Y16Block : ILineBlock<LineArrayX32Y16Block>
     {
-        // These retained line blocks are one of the few places where direct native allocation
-        // consistently outperforms the upstream allocator on larger retained-fill workloads.
-        // Keep this isolated to the retained block storage rather than broadening native allocation usage.
-        private readonly unsafe PackedLineX32Y16* lines;
+        private const int BlockLineCount = 32;
+        private PackedLineX32Y16Buffer lines;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="LineArrayX32Y16Block"/> class.
         /// </summary>
         /// <param name="next">The next block in the retained chain.</param>
-        public unsafe LineArrayX32Y16Block(LineArrayX32Y16Block? next)
-        {
-            this.lines = (PackedLineX32Y16*)NativeMemory.Alloc((nuint)LineCount, (nuint)sizeof(PackedLineX32Y16));
-            this.Next = next;
-        }
+        public LineArrayX32Y16Block(LineArrayX32Y16Block? next) => this.Next = next;
 
         /// <inheritdoc />
-        public static int LineCount => 32;
+        public static int LineCount => BlockLineCount;
 
         /// <inheritdoc />
         public LineArrayX32Y16Block? Next { get; }
@@ -287,7 +280,7 @@ public unsafe LineArrayX32Y16Block(LineArrayX32Y16Block? next)
         /// <param name="x0">The starting X coordinate in 24.8 fixed-point.</param>
         /// <param name="x1">The ending X coordinate in 24.8 fixed-point.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Set(int index, int packedY0Y1, int x0, int x1)
+        public void Set(int index, int packedY0Y1, int x0, int x1)
         {
             ref PackedLineX32Y16 line = ref this.lines[index];
             line.PackedY0Y1 = packedY0Y1;
@@ -297,12 +290,11 @@ public unsafe void Set(int index, int packedY0Y1, int x0, int x1)
 
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Rasterize(int count, ref Context context)
+        public void Rasterize(int count, ref Context context)
         {
-            ReadOnlySpan<PackedLineX32Y16> lines = new(this.lines, LineCount);
             for (int i = 0; i < count; i++)
             {
-                PackedLineX32Y16 line = lines[i];
+                PackedLineX32Y16 line = this.lines[i];
                 context.RasterizeLineSegment(line.X0, UnpackLo(line.PackedY0Y1), line.X1, UnpackHi(line.PackedY0Y1));
             }
         }
@@ -324,11 +316,6 @@ public void Iterate(int firstBlockLineCount, ref Context context)
             }
         }
 
-        /// <summary>
-        /// Releases the native block storage.
-        /// </summary>
-        public unsafe void Dispose() => NativeMemory.Free(this.lines);
-
         /// <summary>
         /// Unpacks the low signed 16-bit value from a packed endpoint pair.
         /// </summary>
@@ -346,7 +333,7 @@ public void Iterate(int firstBlockLineCount, ref Context context)
         private static int UnpackHi(int packed) => packed >> 16;
 
         /// <summary>
-        /// Holds one retained 32-bit-X line record in native block storage.
+        /// Holds one retained 32-bit-X line record in block-local storage.
         /// </summary>
         private struct PackedLineX32Y16
         {
@@ -365,6 +352,15 @@ private struct PackedLineX32Y16
             /// </summary>
             public int X1;
         }
+
+        /// <summary>
+        /// Holds the fixed-capacity retained line payload inline with the block object.
+        /// </summary>
+        [InlineArray(BlockLineCount)]
+        private struct PackedLineX32Y16Buffer
+        {
+            private PackedLineX32Y16 element0;
+        }
     }
 
     /// <summary>
@@ -432,24 +428,19 @@ public void AppendLine(int x0, int y0, int x1, int y1)
     /// <summary>
     /// Represents one retained 16-bit-X line block.
     /// </summary>
-    internal sealed class LineArrayX16Y16Block : ILineBlock<LineArrayX16Y16Block>, IDisposable
+    internal sealed class LineArrayX16Y16Block : ILineBlock<LineArrayX16Y16Block>
     {
-        // Match the X32 block rationale above: this tiny retained block is hot enough that
-        // direct native backing beats allocator-owned storage on larger retained-fill workloads.
-        private readonly unsafe PackedLineX16Y16* lines;
+        private const int BlockLineCount = 32;
+        private PackedLineX16Y16Buffer lines;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="LineArrayX16Y16Block"/> class.
         /// </summary>
         /// <param name="next">The next block in the retained chain.</param>
-        public unsafe LineArrayX16Y16Block(LineArrayX16Y16Block? next)
-        {
-            this.lines = (PackedLineX16Y16*)NativeMemory.Alloc((nuint)LineCount, (nuint)sizeof(PackedLineX16Y16));
-            this.Next = next;
-        }
+        public LineArrayX16Y16Block(LineArrayX16Y16Block? next) => this.Next = next;
 
         /// <inheritdoc />
-        public static int LineCount => 32;
+        public static int LineCount => BlockLineCount;
 
         /// <inheritdoc />
         public LineArrayX16Y16Block? Next { get; }
@@ -461,7 +452,7 @@ public unsafe LineArrayX16Y16Block(LineArrayX16Y16Block? next)
         /// <param name="packedY0Y1">The packed 16-bit Y endpoints.</param>
         /// <param name="packedX0X1">The packed 16-bit X endpoints.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Set(int index, int packedY0Y1, int packedX0X1)
+        public void Set(int index, int packedY0Y1, int packedX0X1)
         {
             ref PackedLineX16Y16 line = ref this.lines[index];
             line.PackedY0Y1 = packedY0Y1;
@@ -470,12 +461,11 @@ public unsafe void Set(int index, int packedY0Y1, int packedX0X1)
 
         /// <inheritdoc />
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Rasterize(int count, ref Context context)
+        public void Rasterize(int count, ref Context context)
         {
-            ReadOnlySpan<PackedLineX16Y16> lines = new(this.lines, LineCount);
             for (int i = 0; i < count; i++)
             {
-                PackedLineX16Y16 line = lines[i];
+                PackedLineX16Y16 line = this.lines[i];
                 context.RasterizeLineSegment(
                     UnpackLo(line.PackedX0X1),
                     UnpackLo(line.PackedY0Y1),
@@ -501,11 +491,6 @@ public void Iterate(int firstBlockLineCount, ref Context context)
             }
         }
 
-        /// <summary>
-        /// Releases the native block storage.
-        /// </summary>
-        public unsafe void Dispose() => NativeMemory.Free(this.lines);
-
         /// <summary>
         /// Unpacks the low signed 16-bit value from a packed endpoint pair.
         /// </summary>
@@ -523,7 +508,7 @@ public void Iterate(int firstBlockLineCount, ref Context context)
         private static int UnpackHi(int packed) => packed >> 16;
 
         /// <summary>
-        /// Holds one retained 16-bit-X line record in native block storage.
+        /// Holds one retained 16-bit-X line record in block-local storage.
         /// </summary>
         private struct PackedLineX16Y16
         {
@@ -537,5 +522,14 @@ private struct PackedLineX16Y16
             /// </summary>
             public int PackedX0X1;
         }
+
+        /// <summary>
+        /// Holds the fixed-capacity retained line payload inline with the block object.
+        /// </summary>
+        [InlineArray(BlockLineCount)]
+        private struct PackedLineX16Y16Buffer
+        {
+            private PackedLineX16Y16 element0;
+        }
     }
 }