Simplify tests and update docs

Author: JimBobSquarePants

samples/DrawingBackendBenchmark/BenchmarkForm.cs

@@ -249,14 +249,14 @@ private void UpdatePreview(BenchmarkRenderResult result, bool capturePreview)
     /// Formats one status line describing the current sample, running statistics, and backend outcome.
     /// </summary>
     private static string FormatStatusText(
-        string backendName,
+        string? backendName,
         BenchmarkRenderResult result,
         int lineCount,
         int iteration,
         int totalIterations,
         BenchmarkStatistics statistics)
     {
-        string backendStatus = GetBackendStatusText(backendName, result);
+        string backendStatus = GetBackendStatusText(backendName ?? string.Empty, result);
         string backendFailure = result.BackendFailure is not null ? $" | {result.BackendFailure}" : string.Empty;
 
         return

samples/DrawingBackendBenchmark/CpuBenchmarkBackend.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using System.Diagnostics;
@@ -15,6 +15,7 @@ namespace DrawingBackendBenchmark;
 internal sealed class CpuBenchmarkBackend : IBenchmarkBackend
 {
     private readonly Configuration configuration;
+    private Image<Bgra32>? image;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="CpuBenchmarkBackend"/> class.
@@ -26,7 +27,7 @@ internal sealed class CpuBenchmarkBackend : IBenchmarkBackend
     /// </summary>
     public BenchmarkRenderResult Render(ReadOnlySpan<VisualLine> lines, int width, int height, bool capturePreview)
     {
-        using Image<Bgra32> image = new(width, height);
+        Image<Bgra32> image = this.EnsureImage(width, height);
         Buffer2DRegion<Bgra32> region = new(image.Frames.RootFrame.PixelBuffer, image.Bounds);
 
         Stopwatch stopwatch = Stopwatch.StartNew();
@@ -46,4 +47,28 @@ public BenchmarkRenderResult Render(ReadOnlySpan<VisualLine> lines, int width, i
     /// Gets the name of this backend.
     /// </summary>
     public override string ToString() => "CPU";
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        this.image?.Dispose();
+        this.image = null;
+    }
+
+    /// <summary>
+    /// Gets the cached CPU render target image for the benchmark backend.
+    /// </summary>
+    /// <param name="width">The image width.</param>
+    /// <param name="height">The image height.</param>
+    /// <returns>The cached image.</returns>
+    private Image<Bgra32> EnsureImage(int width, int height)
+    {
+        if (this.image is not null)
+        {
+            return this.image;
+        }
+
+        this.image = new Image<Bgra32>(width, height);
+        return this.image;
+    }
 }

samples/DrawingBackendBenchmark/IBenchmarkBackend.cs

@@ -6,7 +6,7 @@ namespace DrawingBackendBenchmark;
 /// <summary>
 /// Base interface for benchmark backends exposing their shared render method.
 /// </summary>
-internal interface IBenchmarkBackend
+internal interface IBenchmarkBackend : IDisposable
 {
     /// <summary>
     /// Renders the benchmark scene and returns timing and optional preview data.
@@ -16,5 +16,5 @@ internal interface IBenchmarkBackend
     /// <param name="height">The height of the render target.</param>
     /// <param name="capturePreview">Whether to capture a preview image of the final frame.</param>
     /// <returns>The benchmark render result including timing and diagnostics.</returns>
-    BenchmarkRenderResult Render(ReadOnlySpan<VisualLine> lines, int width, int height, bool capturePreview);
+    public BenchmarkRenderResult Render(ReadOnlySpan<VisualLine> lines, int width, int height, bool capturePreview);
 }

samples/DrawingBackendBenchmark/Program.cs

@@ -1,9 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using Color = SixLabors.ImageSharp.Color;
-using PointF = SixLabors.ImageSharp.PointF;
-
 namespace DrawingBackendBenchmark;
 
 /// <summary>

samples/DrawingBackendBenchmark/README.md

@@ -1,27 +1,93 @@
 # Drawing Backend Benchmark
 
-A Windows sample based on the original `ImageSharpBenchmark` workload from the `Csharp-Data-Visualization` repo.
+`DrawingBackendBenchmark` is a small Windows sample that renders the same randomized line scene through several drawing backends and shows the last rendered frame alongside timing statistics.
+
+It is based on the original ImageSharp benchmark workload from the `Csharp-Data-Visualization` repo:
 
 https://swharden.com/csdv/platforms/compare/
 
-It renders a randomized line scene repeatedly and lets you compare:
+## What it compares
+
+Depending on what the machine can initialize, the sample can show:
+
+- `CPU`: the default `ImageSharp.Drawing` CPU backend
+- `SkiaSharp (CPU)`: Skia rasterized in CPU mode
+- `SkiaSharp (GPU)`: Skia using a GPU-backed `GRContext` when the hidden GL host is available
+- `WebGPU`: the offscreen `ImageSharp.Drawing.WebGPU` backend
 
-- `CPU` via the default `ImageSharp.Drawing` backend
-- `WebGPU` via the offscreen `ImageSharp.Drawing.WebGPU` backend
+The sample always starts with the CPU and Skia CPU paths. The WebGPU backend is added only when `WebGPUEnvironment.TryProbeComputePipelineSupport(...)` succeeds. The Skia GPU backend is added once the hidden `SKGLControl` has produced a usable `GRContext`.
 
-The sample shows:
+## What the UI shows
 
-- a preview of the last rendered frame
-- the most recent render time
-- running mean
-- standard deviation
+The benchmark window contains:
+
+- a backend selector
+- an iteration count selector
+- preset buttons for `10`, `1k`, `10k`, and `100k` lines
+- a preview of the final rendered frame
+- current render time, running mean, and standard deviation
+
+The fixed benchmark surface is `600x400` pixels.
 
 ## Running
 
 ```powershell
 dotnet run --project samples/DrawingBackendBenchmark -c Release
 ```
 
-The WebGPU path renders to an offscreen native texture and reads the final frame back for preview. The reported benchmark time measures scene rendering and flush time only, not the preview readback.
+## How one benchmark run works
+
+For each iteration the form:
+
+1. generates a deterministic random line set for the requested line count
+2. renders that scene through the selected backend
+3. records the elapsed render time
+4. updates the running mean and standard deviation
+5. captures a preview image only on the last iteration
+
+That last point matters: preview capture is intentionally outside the measured timing path. The reported time measures scene submission and backend flush work only. Any readback, clone, or bitmap conversion needed for the UI happens afterward.
+
+## Timing model
+
+All backends follow the same basic timing rule:
+
+- start the stopwatch immediately before drawing the scene
+- stop it immediately after the backend flush or submission boundary
+- capture preview pixels only after the stopwatch stops
+
+In practice that means:
+
+- `CPU` measures drawing into the cached `Image<Bgra32>` through `DrawingCanvas.Flush()`
+- `SkiaSharp` measures drawing through `SKCanvas.Flush()` and optional GPU context flush
+- `WebGPU` measures drawing through `DrawingCanvas.Flush()` into the offscreen `WebGPURenderTarget<Bgra32>`
+
+So the numbers are comparable as "render and submit" timings, not "render plus preview extraction" timings.
+
+## Backend resource reuse
+
+The sample uses a fixed benchmark size, so the backends keep their render targets alive across iterations instead of reallocating them every run:
+
+- `CpuBenchmarkBackend` caches one `Image<Bgra32>`
+- `SkiaSharpBenchmarkBackend` caches one `SKSurface`
+- `WebGpuBenchmarkBackend` caches one `WebGPURenderTarget<Bgra32>`
+
+This keeps the benchmark focused on scene rendering rather than repeated target allocation noise.
+
+## WebGPU path
+
+The WebGPU backend is intentionally small:
+
+- it probes support up front with `WebGPUEnvironment.TryProbeComputePipelineSupport(...)`
+- it renders into an owned offscreen `WebGPURenderTarget<Bgra32>`
+- it draws through `CreateCanvas(...)`, not a hybrid CPU plus GPU canvas
+- it reads back the final frame only when the UI requests the last-iteration preview
+
+The status line also reports whether the last WebGPU flush completed on the staged GPU path or had to fall back to CPU execution.
+
+## File guide
 
-Internally the sample now uses an owned `WebGPURenderTarget<TPixel>` so the offscreen WebGPU setup stays small while still supporting the benchmark's hybrid CPU+GPU frame flow.
+- [BenchmarkForm.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/DrawingBackendBenchmark/BenchmarkForm.cs): WinForms UI, backend selection, iteration loop, and preview display
+- [CpuBenchmarkBackend.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/DrawingBackendBenchmark/CpuBenchmarkBackend.cs): ImageSharp CPU baseline backend
+- [SkiaSharpBenchmarkBackend.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/DrawingBackendBenchmark/SkiaSharpBenchmarkBackend.cs): Skia CPU and GPU benchmark backend
+- [WebGpuBenchmarkBackend.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/DrawingBackendBenchmark/WebGpuBenchmarkBackend.cs): offscreen WebGPU benchmark backend
+- [VisualLine.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/DrawingBackendBenchmark/VisualLine.cs): shared randomized line scene description and canvas render helper

samples/DrawingBackendBenchmark/SkiaSharpBenchmarkBackend.cs

@@ -8,7 +8,7 @@
 
 namespace DrawingBackendBenchmark;
 
-internal sealed class SkiaSharpBenchmarkBackend : IBenchmarkBackend, IDisposable
+internal sealed class SkiaSharpBenchmarkBackend : IBenchmarkBackend
 {
     private static readonly SKColor BackgroundColor = SKColor.Parse("#003366");
 

samples/DrawingBackendBenchmark/WebGpuBenchmarkBackend.cs

@@ -13,9 +13,9 @@ namespace DrawingBackendBenchmark;
 /// <summary>
 /// Small offscreen WebGPU host used by the sample so the benchmark can drive the real backend without manual WebGPU bootstrap code.
 /// </summary>
-internal sealed class WebGpuBenchmarkBackend : IBenchmarkBackend, IDisposable
+internal sealed class WebGpuBenchmarkBackend : IBenchmarkBackend
 {
-    private RenderResources? resources;
+    private WebGPURenderTarget<Bgra32>? renderTarget;
 
     private WebGpuBenchmarkBackend()
     {
@@ -29,43 +29,33 @@ public static bool TryCreate([NotNullWhen(true)] out WebGpuBenchmarkBackend? res
             return false;
         }
 
-        try
-        {
-            using WebGPURenderTarget<Bgra32> probe = new(1, 1);
-            result = new WebGpuBenchmarkBackend();
-            error = null;
-            return true;
-        }
-        catch (Exception ex)
-        {
-            result = null;
-            error = ex.Message;
-            return false;
-        }
+        result = new WebGpuBenchmarkBackend();
+        error = null;
+        return true;
     }
 
     /// <summary>
     /// Renders the benchmark scene through the WebGPU backend and optionally captures a readback preview.
     /// </summary>
     public BenchmarkRenderResult Render(ReadOnlySpan<VisualLine> lines, int width, int height, bool capturePreview)
     {
-        RenderResources resources = this.EnsureResources(width, height);
+        WebGPURenderTarget<Bgra32> renderTarget = this.EnsureRenderTarget(width, height);
 
         Stopwatch stopwatch = Stopwatch.StartNew();
-        using (DrawingCanvas<Bgra32> canvas = resources.RenderTarget.CreateHybridCanvas(resources.CpuImage, new DrawingOptions()))
+        using (DrawingCanvas<Bgra32> canvas = renderTarget.CreateCanvas(new DrawingOptions()))
         {
             VisualLine.RenderLinesToCanvas(canvas, lines);
             canvas.Flush();
         }
 
         stopwatch.Stop();
 
-        Image<Bgra32>? preview = capturePreview ? resources.RenderTarget.Readback() : null;
+        Image<Bgra32>? preview = capturePreview ? renderTarget.Readback() : null;
         return new BenchmarkRenderResult(
             stopwatch.Elapsed.TotalMilliseconds,
             preview,
-            resources.RenderTarget.Graphics.Backend.DiagnosticLastFlushUsedGPU,
-            resources.RenderTarget.Graphics.Backend.DiagnosticLastSceneFailure);
+            renderTarget.Graphics.Backend.DiagnosticLastFlushUsedGPU,
+            renderTarget.Graphics.Backend.DiagnosticLastSceneFailure);
     }
 
     /// <summary>
@@ -76,42 +66,18 @@ public BenchmarkRenderResult Render(ReadOnlySpan<VisualLine> lines, int width, i
     /// <inheritdoc />
     public void Dispose()
     {
-        this.resources?.Dispose();
-        this.resources = null;
-    }
-
-    private RenderResources EnsureResources(int width, int height)
-    {
-        if (this.resources is RenderResources resources && resources.Width == width && resources.Height == height)
-        {
-            return resources;
-        }
-
-        this.resources?.Dispose();
-        this.resources = new RenderResources(new WebGPURenderTarget<Bgra32>(width, height), new Image<Bgra32>(width, height));
-        return this.resources;
+        this.renderTarget?.Dispose();
+        this.renderTarget = null;
     }
 
-    private sealed class RenderResources : IDisposable
+    private WebGPURenderTarget<Bgra32> EnsureRenderTarget(int width, int height)
     {
-        public RenderResources(WebGPURenderTarget<Bgra32> renderTarget, Image<Bgra32> cpuImage)
+        if (this.renderTarget is not null)
         {
-            this.RenderTarget = renderTarget;
-            this.CpuImage = cpuImage;
+            return this.renderTarget;
         }
 
-        public WebGPURenderTarget<Bgra32> RenderTarget { get; }
-
-        public Image<Bgra32> CpuImage { get; }
-
-        public int Width => this.CpuImage.Width;
-
-        public int Height => this.CpuImage.Height;
-
-        public void Dispose()
-        {
-            this.RenderTarget.Dispose();
-            this.CpuImage.Dispose();
-        }
+        this.renderTarget = new WebGPURenderTarget<Bgra32>(width, height);
+        return this.renderTarget;
     }
 }