Merge pull request #76 from wieslawsoltes/agent/skiasharp-perf-continuation

Optimize Avalonia Skia hot paths

Author: wieslawsoltes

docs/SKIASHARP_API_PARITY.md

@@ -979,6 +979,80 @@ main build and resolves the packaged RID-native WebGPU directory on Linux,
 macOS, and Windows. This fixes the prior Ubuntu `libwgpu_native` loader failure
 without skipping the GPU workload or relaxing comparison evidence.
 
+### Avalonia immutable-image upload and deferred-draw checkpoint
+
+The source-built Avalonia 12 `WriteableBitmapImpl` creates an immutable image
+with `SKImage.FromPixels(info, address, rowBytes)` whenever its writable pixel
+version changes, then reuses that image across draws. ProGPU now copies common
+RGBA, sRGBA, and BGRA rows directly into one tight immutable portable snapshot
+and uploads that same snapshot to WebGPU. The former temporary `SKBitmap`
+wrapper and its second row walk are gone; arbitrary supported formats keep the
+conservative conversion fallback. Snapshot work remains `O(P)` time and
+storage for `P` pixels because the public pointer is caller-owned and the image
+must remain immutable after the writable framebuffer changes.
+
+Whole images drawn in the same WebGPU device now cross the retained-command
+boundary through `IProGpuContextTextureLeaseSource`. The first draw records one
+bounded lifetime lease and every subsequent draw in that context reuses the
+same `GpuTexture`, texture view, and bindable identity. Disposal of the public
+`SKImage` releases its ownership but cannot destroy the texture while a
+deferred context or picture still holds a lease. Subsets, cross-device images,
+and mipmap generation retain their normalized materialization paths. This makes
+ordinary same-device recording `O(C)` command work for `C` draws with one GPU
+texture and one lease, rather than `O(C * P)` texture allocation and copy
+bandwidth.
+
+The clean-room design follows Skia's public
+[immutable image contract](https://api.skia.org/classSkImage.html), WebGPU's
+[texture ownership and copy model](https://www.w3.org/TR/webgpu/#textures),
+Direct2D's
+[device-context bitmap drawing contract](https://learn.microsoft.com/windows/win32/direct2d/id2d1devicecontext-drawbitmap-overload),
+Win2D's
+[CanvasBitmap contract](https://learn.microsoft.com/uwp/api/microsoft.graphics.canvas.canvasbitmap),
+WebRender's
+[external-image frame split](https://firefox-source-docs.mozilla.org/gfx/RenderingOverview.html),
+and Vello's
+[explicit wgpu scene-to-texture pipeline](https://github.com/linebender/vello).
+ProGPU adopts immutable CPU ownership at the public pointer boundary and typed
+same-device leases at the deferred GPU boundary; it rejects borrowed pointer
+lifetime assumptions, per-draw GPU copies, reflection, and backend-specific
+public handles. Text shaping remains unchanged at the reusable CPU-result
+boundary established by SkParagraph, DirectWrite, Parley, and HarfBuzz.
+
+On the Apple M3 Pro Release baseline, the 16-by-16 Avalonia snapshot workload
+improved from `13,356.445` to `10,934.730` ns/op and from `1,568` to `1,424`
+managed B/op with the exact native checksum. The new 1,000-draw retained-picture
+workload isolates reuse of that immutable image: replacing one GPU texture copy
+per draw with one lifetime lease reduced ProGPU from `69,164.500` to `608.354`
+ns/draw and from `2,831.500` to `2,486.000` managed B/draw. Native measured
+`48.479` ns/draw and `2` managed B/draw because its retained command storage is
+native and outside the managed counter. The remaining ProGPU command-storage
+and snapshot gaps are explicit optimization targets; these shared-machine
+figures establish the direction and do not claim final cross-platform parity.
+
+Matched final-binary macOS profiling compared exact pre-lease commit
+`1c60239b` with exact candidate `79d86548` on the same Apple M3 Pro, macOS
+26.4.1, and .NET 10.0.5 workload. Time Profiler measured `327,088.874` versus
+`816.041` median ns/draw; Allocations plus VM Tracker measured `82,988.745`
+versus `929.165`; Metal System Trace measured `49,527.290` versus `797.290`;
+and EventPipe measured `60,615.875` versus `627.041`. EventPipe retained the
+exact checksum while managed allocation fell from `2,831` to `2,486` B/draw
+(`12.2%`). Profiler overhead perturbs the absolute latency, so the ordinary
+Release process numbers above remain the throughput result and these matched
+captures provide causal evidence.
+
+The Metal capture reduced target resource-allocation rows from `188` to `53`
+and target application command-buffer submission rows from `5,627` to zero.
+The baseline target stack contains WebGPU `copy_texture_to_texture`; the
+candidate target stack does not. Both captures reported zero Metal
+command-buffer errors, compiler spills, and hang risks. Completion and
+`currentAllocatedSize` row counts include process/device sampling and are not
+interpreted as bytes or per-draw totals. The Allocations template did not
+export a native retained-byte table on this Xcode version, so no unsupported
+native-memory claim is made. Compact results are recorded here; the 221 MiB of
+raw trace and EventPipe data, temporary publishes, packages, and exact-baseline
+worktree were removed after the audit.
+
 ### Retained canvas contract and empty-clip checkpoint
 
 `SKCanvas` now closes all 45 missing entries in its official 4.151.0 owner

src/ProGPU.Tests/SkBlenderCompatibilityTests.cs

@@ -67,6 +67,42 @@ public void PaintBlendModeAndBlenderShareNativeStateSemantics()
         Assert.Equal(SKBlendMode.SrcOver, paint.BlendMode);
     }
 
+    [Fact]
+    public void ReusedPaintBlendModeStateIsAllocationFreeUntilBlenderIsObserved()
+    {
+        using var paint = new SKPaint();
+        _ = CycleBlendModeState(paint, 1);
+
+        var allocatedBefore = GC.GetAllocatedBytesForCurrentThread();
+        var checksum = CycleBlendModeState(paint, 10_000);
+        var allocated = GC.GetAllocatedBytesForCurrentThread() - allocatedBefore;
+
+        Assert.NotEqual(0u, checksum);
+        Assert.Equal(0, allocated);
+
+        paint.BlendMode = SKBlendMode.DstIn;
+        Assert.NotNull(paint.Blender);
+        Assert.Equal(SKBlendMode.DstIn, paint.BlendMode);
+        Assert.Throws<ArgumentOutOfRangeException>(
+            () => paint.BlendMode = (SKBlendMode)(-1));
+    }
+
+    private static uint CycleBlendModeState(SKPaint paint, int count)
+    {
+        var checksum = 2166136261u;
+        for (var index = 0; index < count; index++)
+        {
+            paint.BlendMode = (index & 1) == 0
+                ? SKBlendMode.DstIn
+                : SKBlendMode.Src;
+            checksum = (checksum ^ (uint)paint.BlendMode) * 16777619u;
+            paint.Reset();
+            checksum = (checksum ^ (uint)paint.BlendMode) * 16777619u;
+        }
+
+        return checksum;
+    }
+
     [Fact]
     public void BuiltInBlenderRecordsExistingGpuBlendScope()
     {

src/ProGPU.Tests/SkCanvasStateTests.cs

@@ -1670,8 +1670,11 @@ void OnTextureDisposed(ulong id)
 
             Assert.Empty(drawingContext.Commands);
             Assert.Equal(0, drawingContext.RetainedResourceCount);
-            Assert.True(retainedTextureDisposed);
+            Assert.False(retainedTextureDisposed);
             Assert.True(layerTextureDisposed);
+
+            image.Dispose();
+            Assert.True(retainedTextureDisposed);
         }
         finally
         {
@@ -1817,7 +1820,7 @@ public void CanvasDisposeKeepsSaveLayerTextureAliveForDeferredDrawingContext()
     }
 
     [Fact]
-    public void RestoreLayerReleasesRetainedImageTexturesAfterOffscreenRender()
+    public void RestoreLayerReleasesRetainedImageLeaseAfterOffscreenRender()
     {
         using var surface = SKSurface.Create(new SKImageInfo(32, 32, SKColorType.Rgba8888, SKAlphaType.Premul));
         using var layerPaint = new SKPaint();
@@ -1849,7 +1852,7 @@ void OnTextureDisposed(ulong id)
         {
             surface.Canvas.RestoreToCount(restoreCount);
 
-            Assert.True(retainedTextureDisposed);
+            Assert.False(retainedTextureDisposed);
             Assert.Empty(layerContext.Commands);
             Assert.Equal(0, layerContext.RetainedResourceCount);
             Assert.Equal(1, GetSurfaceDrawingContext(surface).RetainedResourceCount);
@@ -1862,7 +1865,7 @@ void OnTextureDisposed(ulong id)
     }
 
     [Fact]
-    public void RestoreLayerClearsRetainedImageTexturesWhenLayerBoundsAreSkipped()
+    public void RestoreLayerClearsRetainedImageLeaseWhenLayerBoundsAreSkipped()
     {
         using var surface = SKSurface.Create(new SKImageInfo(32, 32, SKColorType.Rgba8888, SKAlphaType.Premul));
         using var layerPaint = new SKPaint();
@@ -1894,7 +1897,7 @@ void OnTextureDisposed(ulong id)
         {
             surface.Canvas.RestoreToCount(restoreCount);
 
-            Assert.True(retainedTextureDisposed);
+            Assert.False(retainedTextureDisposed);
             Assert.Empty(layerContext.Commands);
             Assert.Equal(0, layerContext.RetainedResourceCount);
             Assert.Empty(GetOwnedLayerTextures(surface.Canvas));
@@ -2296,7 +2299,7 @@ public void DrawImagePushesPaintAlphaOpacity()
             draw =>
             {
                 Assert.Equal(RenderCommandType.DrawTexture, draw.Type);
-                Assert.NotSame(image.Texture, draw.Texture);
+                Assert.Same(image.Texture, draw.Texture);
                 AssertNear(10f, draw.Rect.X);
                 AssertNear(20f, draw.Rect.Y);
                 AssertNear(20.5f, draw.Rect.Width);
@@ -2349,7 +2352,7 @@ public void DrawImageRetainsSourceTextureForDeferredFlush()
 
         var command = GetDrawTextureCommand(context.Commands);
         var retainedTexture = command.Texture!;
-        Assert.NotSame(image.Texture, retainedTexture);
+        Assert.Same(image.Texture, retainedTexture);
         Assert.Equal(1, context.RetainedResourceCount);
 
         var retainedTextureDisposed = false;
@@ -2379,6 +2382,25 @@ void OnTextureDisposed(ulong id)
         }
     }
 
+    [Fact]
+    public void RepeatedWholeImageDrawsShareOneTextureLeaseWithoutGpuCopies()
+    {
+        var context = new DrawingContext();
+        using var canvas = new SKCanvas(context, 16f, 16f);
+        using var bitmap = new SKBitmap(1, 1);
+        using var image = SKImage.FromBitmap(bitmap);
+
+        canvas.DrawImage(image, 0f, 0f);
+        canvas.DrawImage(image, 1f, 1f);
+
+        var draws = context.Commands
+            .Where(command => command.Type == RenderCommandType.DrawTexture)
+            .ToArray();
+        Assert.Equal(2, draws.Length);
+        Assert.All(draws, command => Assert.Same(image.Texture, command.Texture));
+        Assert.Equal(1, context.RetainedResourceCount);
+    }
+
     [Fact]
     public void GpuPictureKeepsRetainedImageTextureAfterRecorderReuse()
     {
@@ -2417,6 +2439,8 @@ void OnTextureDisposed(ulong id)
 
             picture.Dispose();
 
+            Assert.False(retainedTextureDisposed);
+            image.Dispose();
             Assert.True(retainedTextureDisposed);
         }
         finally
@@ -2466,8 +2490,10 @@ void OnTextureDisposed(ulong id)
 
             target.Clear();
 
-            Assert.True(retainedTextureDisposed);
+            Assert.False(retainedTextureDisposed);
             Assert.Equal(0, target.RetainedResourceCount);
+            image.Dispose();
+            Assert.True(retainedTextureDisposed);
         }
         finally
         {

src/ProGPU.Tests/SkMatrixCompatibilityTests.cs

@@ -138,6 +138,21 @@ public void RectangleMappingClipsPerspectiveAtNativeNearPlane()
             SKMatrix.CreateScale(2f, 3f).MapRect(new SKRect(5f, 8f, 1f, 2f)));
     }
 
+    [Fact]
+    public void AffineRectangleMappingPreservesSkewAndNegativeScaleBounds()
+    {
+        var skewed = new SKMatrix(2f, 0.5f, 10f, -0.25f, 3f, 20f, 0f, 0f, 1f);
+        Assert.Equal(
+            new SKRect(13f, 24.5f, 26f, 43.75f),
+            skewed.MapRect(new SKRect(1f, 2f, 6f, 8f)));
+
+        var reflected = SKMatrix.CreateScale(-2f, -3f).PostConcat(
+            SKMatrix.CreateTranslation(10f, 20f));
+        Assert.Equal(
+            new SKRect(-2f, -4f, 8f, 14f),
+            reflected.MapRect(new SKRect(1f, 2f, 6f, 8f)));
+    }
+
     [Fact]
     public void RadiusEqualityHashAndInternalMatrixConversionMatchNativeValues()
     {

src/ProGPU.Tests/SkPathBuilderCompatibilityTests.cs

@@ -7,6 +7,19 @@ namespace ProGPU.Tests;
 
 public sealed class SkPathBuilderCompatibilityTests
 {
+    [Fact]
+    public void DetachedPackedBuilderComputesTightBoundsOnlyWhenRequested()
+    {
+        using var builder = new SKPathBuilder();
+        builder.MoveTo(0f, 0f);
+        builder.QuadTo(10f, 100f, 20f, 0f);
+        using var path = builder.Detach();
+
+        Assert.Equal(new SKRect(0f, 0f, 20f, 100f), path.Bounds);
+        Assert.Equal(new SKRect(0f, 0f, 20f, 50f), path.TightBounds);
+        Assert.Equal(new SKRect(0f, 0f, 20f, 50f), path.TightBounds);
+    }
+
     [Fact]
     public void PackedDetachAndBoundsStayBoundedIndependentOfSegmentCount()
     {

src/ProGPU.Tests/SkPathMutationCompatibilityTests.cs

@@ -5,6 +5,70 @@ namespace ProGPU.Tests;
 
 public sealed class SkPathMutationCompatibilityTests
 {
+    [Fact]
+    public void CommonLegacyVerbStreamKeepsTightBoundsAllocationBounded()
+    {
+        static float MeasureOnce()
+        {
+            using var path = new SKPath { FillType = SKPathFillType.EvenOdd };
+            path.MoveTo(0f, 0f);
+            for (var segment = 0; segment < 8; segment++)
+            {
+                var x = segment * 6f;
+                var y = segment * 3f;
+                path.LineTo(x + 1f, y + 2f);
+                path.QuadTo(x + 2f, y - 1f, x + 3f, y + 3f);
+                path.CubicTo(x + 3.5f, y + 4f, x + 4.5f, y - 2f, x + 5f, y + 1f);
+            }
+
+            path.Close();
+            var bounds = path.TightBounds;
+            return bounds.Left + bounds.Top + bounds.Right + bounds.Bottom;
+        }
+
+        _ = MeasureOnce();
+        const int iterations = 1_000;
+        var checksum = 0f;
+        var allocatedBefore = GC.GetAllocatedBytesForCurrentThread();
+        for (var index = 0; index < iterations; index++)
+        {
+            checksum += MeasureOnce();
+        }
+
+        var allocatedPerPath =
+            (GC.GetAllocatedBytesForCurrentThread() - allocatedBefore) / iterations;
+        Assert.True(float.IsFinite(checksum));
+        Assert.InRange(allocatedPerPath, 0, 128);
+    }
+
+    [Fact]
+    public void TightCurveBoundsPreserveFractionalTranslation()
+    {
+        static SKRect Build(float offset)
+        {
+            using var path = new SKPath();
+            path.MoveTo(offset, -offset);
+            path.QuadTo(2f + offset, -1f - offset, 3f + offset, 3f - offset);
+            path.CubicTo(
+                3.5f + offset,
+                4f - offset,
+                4.5f + offset,
+                -2f - offset,
+                5f + offset,
+                1f - offset);
+            return path.TightBounds;
+        }
+
+        const float offset = 0.125f;
+        var baseline = Build(0f);
+        var translated = Build(offset);
+
+        Assert.Equal(baseline.Left + offset, translated.Left);
+        Assert.Equal(baseline.Right + offset, translated.Right);
+        Assert.Equal(baseline.Top - offset, translated.Top);
+        Assert.Equal(baseline.Bottom - offset, translated.Bottom);
+    }
+
     [Fact]
     public void RelativeCommandsUseOneNativeCurrentPointPerVerb()
     {

src/ProGPU.Tests/SkRoundRectCompatibilityTests.cs

@@ -79,7 +79,7 @@ public void ConstructionKeepsCornerRadiiInSingleManagedAllocation()
         var allocated = GC.GetAllocatedBytesForCurrentThread() - before;
         Assert.Equal(85_000f, checksum);
         Assert.True(
-            allocated <= 96L * iterations,
+            allocated <= 72L * iterations,
             $"Expected one bounded SKRoundRect allocation per construction, but measured {allocated / (double)iterations:F3} B/op.");
     }