Refactor scheduling & resource arena helpers

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.cs

@@ -323,7 +323,7 @@ public void FlushCompositions<TPixel>(
         {
             // Return arenas for the next flush. If another thread already returned one,
             // dispose the displaced arena (at most one survives in the cache).
-            WebGPUSceneDispatch.DisposeSchedulingArena(Interlocked.Exchange(ref this.cachedSchedulingArena, schedulingArena));
+            WebGPUSceneSchedulingArena.Dispose(Interlocked.Exchange(ref this.cachedSchedulingArena, schedulingArena));
             WebGPUSceneResourceArena.Dispose(Interlocked.Exchange(ref this.cachedResourceArena, resourceArena));
         }
     }
@@ -583,7 +583,7 @@ public void Dispose()
 
         this.TestingLastFlushUsedGPU = false;
         this.TestingLastGPUInitializationFailure = null;
-        WebGPUSceneDispatch.DisposeSchedulingArena(this.cachedSchedulingArena);
+        WebGPUSceneSchedulingArena.Dispose(this.cachedSchedulingArena);
         WebGPUSceneResourceArena.Dispose(this.cachedResourceArena);
         this.isDisposed = true;
     }

src/ImageSharp.Drawing.WebGPU/WebGPUSceneDispatch.cs

@@ -728,43 +728,16 @@ private static bool TryEnsureSchedulingArena(
         [NotNullWhen(true)] ref WebGPUSceneSchedulingArena? arena,
         out string? error)
     {
-        if (arena is not null && CanReuseSchedulingArena(flushContext, arena, bufferSizes, readbackByteLength))
+        if (arena is not null && arena.CanReuse(flushContext, bufferSizes, readbackByteLength))
         {
             error = null;
             return true;
         }
 
-        DisposeSchedulingArena(arena);
+        WebGPUSceneSchedulingArena.Dispose(arena);
         return TryCreateSchedulingArena(flushContext, bufferSizes, readbackByteLength, ref arena, out error);
     }
 
-    /// <summary>
-    /// Returns true if every buffer in the arena fits the required sizes for this scene.
-    /// </summary>
-    private static unsafe bool CanReuseSchedulingArena(
-        WebGPUFlushContext flushContext,
-        WebGPUSceneSchedulingArena arena,
-        WebGPUSceneBufferSizes bufferSizes,
-        nuint readbackByteLength)
-        => arena.Device == flushContext.Device &&
-           arena.BinHeaderBuffer is not null &&
-           arena.IndirectCountBuffer is not null &&
-           arena.PathTileBuffer is not null &&
-           arena.SegCountBuffer is not null &&
-           arena.SegmentBuffer is not null &&
-           arena.BlendBuffer is not null &&
-           arena.PtclBuffer is not null &&
-           arena.BumpBuffer is not null &&
-           arena.ReadbackBuffer is not null &&
-           bufferSizes.BinHeaders.ByteLength <= arena.CapacitySizes.BinHeaders.ByteLength &&
-           bufferSizes.IndirectCount.ByteLength <= arena.CapacitySizes.IndirectCount.ByteLength &&
-           bufferSizes.PathTiles.ByteLength <= arena.CapacitySizes.PathTiles.ByteLength &&
-           bufferSizes.SegCounts.ByteLength <= arena.CapacitySizes.SegCounts.ByteLength &&
-           bufferSizes.Segments.ByteLength <= arena.CapacitySizes.Segments.ByteLength &&
-           bufferSizes.BlendSpill.ByteLength <= arena.CapacitySizes.BlendSpill.ByteLength &&
-           bufferSizes.Ptcl.ByteLength <= arena.CapacitySizes.Ptcl.ByteLength &&
-           readbackByteLength <= arena.ReadbackByteLength;
-
     private static unsafe bool TryCreateSchedulingArena(
         WebGPUFlushContext flushContext,
         WebGPUSceneBufferSizes bufferSizes,
@@ -851,27 +824,6 @@ private static unsafe bool TryCreateSchedulingArena(
         }
     }
 
-    /// <summary>
-    /// Releases one reusable scheduling arena created outside the flush-context tracking lists.
-    /// </summary>
-    public static unsafe void DisposeSchedulingArena(WebGPUSceneSchedulingArena? arena)
-    {
-        if (arena is null || arena.BinHeaderBuffer is null)
-        {
-            return;
-        }
-
-        ReleaseArenaBuffer(arena.Api, arena.ReadbackBuffer);
-        ReleaseArenaBuffer(arena.Api, arena.BumpBuffer);
-        ReleaseArenaBuffer(arena.Api, arena.PtclBuffer);
-        ReleaseArenaBuffer(arena.Api, arena.BlendBuffer);
-        ReleaseArenaBuffer(arena.Api, arena.SegmentBuffer);
-        ReleaseArenaBuffer(arena.Api, arena.SegCountBuffer);
-        ReleaseArenaBuffer(arena.Api, arena.PathTileBuffer);
-        ReleaseArenaBuffer(arena.Api, arena.IndirectCountBuffer);
-        ReleaseArenaBuffer(arena.Api, arena.BinHeaderBuffer);
-    }
-
     /// <summary>
     /// Executes the staged scene pipeline against the current flush target.
     /// </summary>
@@ -3351,6 +3303,60 @@ public WebGPUSceneSchedulingArena(
     public WgpuBuffer* BumpBuffer { get; }
 
     public WgpuBuffer* ReadbackBuffer { get; }
+
+    /// <summary>
+    /// Returns true if every buffer fits the required sizes for this scene.
+    /// </summary>
+    public bool CanReuse(WebGPUFlushContext flushContext, WebGPUSceneBufferSizes bufferSizes, nuint readbackByteLength)
+        => this.Device == flushContext.Device &&
+           this.BinHeaderBuffer is not null &&
+           this.IndirectCountBuffer is not null &&
+           this.PathTileBuffer is not null &&
+           this.SegCountBuffer is not null &&
+           this.SegmentBuffer is not null &&
+           this.BlendBuffer is not null &&
+           this.PtclBuffer is not null &&
+           this.BumpBuffer is not null &&
+           this.ReadbackBuffer is not null &&
+           bufferSizes.BinHeaders.ByteLength <= this.CapacitySizes.BinHeaders.ByteLength &&
+           bufferSizes.IndirectCount.ByteLength <= this.CapacitySizes.IndirectCount.ByteLength &&
+           bufferSizes.PathTiles.ByteLength <= this.CapacitySizes.PathTiles.ByteLength &&
+           bufferSizes.SegCounts.ByteLength <= this.CapacitySizes.SegCounts.ByteLength &&
+           bufferSizes.Segments.ByteLength <= this.CapacitySizes.Segments.ByteLength &&
+           bufferSizes.BlendSpill.ByteLength <= this.CapacitySizes.BlendSpill.ByteLength &&
+           bufferSizes.Ptcl.ByteLength <= this.CapacitySizes.Ptcl.ByteLength &&
+           readbackByteLength <= this.ReadbackByteLength;
+
+    /// <summary>
+    /// Releases all GPU buffers owned by this arena.
+    /// </summary>
+    public static void Dispose(WebGPUSceneSchedulingArena? arena)
+    {
+        if (arena is null || arena.BinHeaderBuffer is null)
+        {
+            return;
+        }
+
+        WebGPU api = arena.Api;
+        ReleaseArenaBuffer(api, arena.ReadbackBuffer);
+        ReleaseArenaBuffer(api, arena.BumpBuffer);
+        ReleaseArenaBuffer(api, arena.PtclBuffer);
+        ReleaseArenaBuffer(api, arena.BlendBuffer);
+        ReleaseArenaBuffer(api, arena.SegmentBuffer);
+        ReleaseArenaBuffer(api, arena.SegCountBuffer);
+        ReleaseArenaBuffer(api, arena.PathTileBuffer);
+        ReleaseArenaBuffer(api, arena.IndirectCountBuffer);
+        ReleaseArenaBuffer(api, arena.BinHeaderBuffer);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void ReleaseArenaBuffer(WebGPU api, WgpuBuffer* buffer)
+    {
+        if (buffer is not null)
+        {
+            api.BufferRelease(buffer);
+        }
+    }
 }
 
 #pragma warning restore SA1201

src/ImageSharp.Drawing.WebGPU/WebGPUSceneResources.cs

@@ -58,8 +58,8 @@ public static bool TryCreate<TPixel>(
         }
 
         // Compute byte lengths for the two variable-size data buffers.
-        nuint infoBinDataByteLength = checked(WebGPUSceneResourceArena.GetBindingByteLength<uint>(scene.InfoWordCount) + config.BufferSizes.BinData.ByteLength);
-        nuint sceneByteLength = WebGPUSceneResourceArena.GetBindingByteLength<uint>(scene.SceneWordCount);
+        nuint infoBinDataByteLength = checked(GetBindingByteLength<uint>(scene.InfoWordCount) + config.BufferSizes.BinData.ByteLength);
+        nuint sceneByteLength = GetBindingByteLength<uint>(scene.SceneWordCount);
 
         // Reuse arena buffers if all capacities fit this scene.
         if (arena is not null && arena.CanReuse(flushContext, config.BufferSizes, infoBinDataByteLength, sceneByteLength))
@@ -96,6 +96,7 @@ public static bool TryCreate<TPixel>(
                 arena.LineBuffer,
                 gradientTextureView,
                 imageAtlasTextureView);
+
             error = null;
             return true;
         }
@@ -235,6 +236,7 @@ public static bool TryCreate<TPixel>(
             lineBuffer,
             gradientTextureView,
             imageAtlasTextureView);
+
         error = null;
         return true;
     }
@@ -834,6 +836,15 @@ private static bool TryCreateAndUploadBuffer<T>(
         error = null;
         return true;
     }
+
+    /// <summary>
+    /// Gets the byte length required to bind <paramref name="count"/> unmanaged elements,
+    /// preserving WebGPU's non-zero binding rule.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal static nuint GetBindingByteLength<T>(int count)
+        where T : unmanaged
+        => checked((nuint)Math.Max(count, 1) * (nuint)Unsafe.SizeOf<T>());
 }
 
 /// <summary>
@@ -1084,15 +1095,6 @@ public WebGPUSceneResourceArena(
 
     public WgpuBuffer* LineBuffer { get; }
 
-    /// <summary>
-    /// Gets the byte length required to bind <paramref name="count"/> unmanaged elements,
-    /// preserving WebGPU's non-zero binding rule.
-    /// </summary>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static nuint GetBindingByteLength<T>(int count)
-        where T : unmanaged
-        => checked((nuint)Math.Max(count, 1) * (nuint)Unsafe.SizeOf<T>());
-
     /// <summary>
     /// Returns true if every buffer fits the required sizes for this scene.
     /// </summary>