Use ThreadLocal<T> for allocations

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/GradientBrush.cs

@@ -44,6 +44,7 @@ public abstract BrushApplicator<TPixel> CreateApplicator<TPixel>(
         /// <summary>
         /// Base class for gradient brush applicators
         /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
         internal abstract class GradientBrushApplicator<TPixel> : BrushApplicator<TPixel>
             where TPixel : unmanaged, IPixel<TPixel>
         {
@@ -115,11 +116,10 @@ protected GradientBrushApplicator(
                     {
                         return from.Color.ToPixel<TPixel>();
                     }
-                    else
-                    {
-                        float onLocalGradient = (positionOnCompleteGradient - from.Ratio) / (to.Ratio - from.Ratio);
-                        return new Color(Vector4.Lerp((Vector4)from.Color, (Vector4)to.Color, onLocalGradient)).ToPixel<TPixel>();
-                    }
+
+                    float onLocalGradient = (positionOnCompleteGradient - from.Ratio) / (to.Ratio - from.Ratio);
+
+                    return new Color(Vector4.Lerp((Vector4)from.Color, (Vector4)to.Color, onLocalGradient)).ToPixel<TPixel>();
                 }
             }
 

src/ImageSharp.Drawing/Processing/LinearGradientBrush.cs

@@ -54,6 +54,7 @@ public override BrushApplicator<TPixel> CreateApplicator<TPixel>(
         /// <summary>
         /// The linear gradient brush applicator.
         /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
         private sealed class LinearGradientBrushApplicator<TPixel> : GradientBrushApplicator<TPixel>
             where TPixel : unmanaged, IPixel<TPixel>
         {

src/ImageSharp.Drawing/Processing/PathGradientBrush.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
+using System.Threading;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -208,6 +209,7 @@ public Vector4 ColorAt(float distance)
         /// <summary>
         /// The path gradient brush applicator.
         /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
         private class PathGradientBrushApplicator<TPixel> : BrushApplicator<TPixel>
             where TPixel : unmanaged, IPixel<TPixel>
         {
@@ -219,14 +221,22 @@ private class PathGradientBrushApplicator<TPixel> : BrushApplicator<TPixel>
 
             private readonly float maxDistance;
 
-            private readonly int maxIntersections;
-
             private readonly IList<Edge> edges;
 
             private readonly TPixel centerPixel;
 
             private readonly TPixel transparentPixel;
 
+            private readonly MemoryAllocator allocator;
+
+            private readonly int maxIntersections;
+
+            private readonly int scalineWidth;
+
+            private readonly ThreadLocal<ThreadContextData> threadContextData;
+
+            private bool isDisposed;
+
             /// <summary>
             /// Initializes a new instance of the <see cref="PathGradientBrushApplicator{TPixel}"/> class.
             /// </summary>
@@ -253,8 +263,14 @@ public PathGradientBrushApplicator(
                 this.hasSpecialCenterColor = hasSpecialCenterColor;
                 this.centerPixel = centerColor.ToPixel<TPixel>();
                 this.maxDistance = points.Select(p => (Vector2)(p - this.center)).Max(d => d.Length());
-                this.maxIntersections = this.edges.Max(e => e.Path.MaxIntersections);
                 this.transparentPixel = Color.Transparent.ToPixel<TPixel>();
+
+                this.scalineWidth = source.Width;
+                this.maxIntersections = this.edges.Max(e => e.Path.MaxIntersections);
+                this.allocator = configuration.MemoryAllocator;
+                this.threadContextData = new ThreadLocal<ThreadContextData>(
+                    () => new ThreadContextData(this.allocator, this.scalineWidth, this.maxIntersections),
+                    true);
             }
 
             internal TPixel this[int x, int y, Span<PointF> intersections, Span<PointOrientation> orientations]
@@ -317,38 +333,55 @@ public PathGradientBrushApplicator(
             /// <inheritdoc />
             public override void Apply(Span<float> scanline, int x, int y)
             {
-                MemoryAllocator memoryAllocator = this.Configuration.MemoryAllocator;
-                using IMemoryOwner<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length);
-                using IMemoryOwner<TPixel> overlayBuffer = memoryAllocator.Allocate<TPixel>(scanline.Length);
-                using IMemoryOwner<PointF> intersectionsBuffer = memoryAllocator.Allocate<PointF>(this.maxIntersections);
-                using IMemoryOwner<PointOrientation> orientationsBuffer = memoryAllocator.Allocate<PointOrientation>(this.maxIntersections);
-
-                Span<float> amountSpan = amountBuffer.Memory.Span;
-                Span<TPixel> overlaySpan = overlayBuffer.Memory.Span;
-                Span<PointF> intersectionsSpan = intersectionsBuffer.Memory.Span;
-                Span<PointOrientation> orientationsSpan = orientationsBuffer.Memory.Span;
+                ThreadContextData values = this.threadContextData.Value;
+                Span<float> amounts = values.AmountSpan.Slice(0, scanline.Length);
+                Span<TPixel> overlays = values.OverlaySpan.Slice(0, scanline.Length);
+                Span<PointF> intersections = values.IntersectionsSpan;
+                Span<PointOrientation> orientations = values.OrientationsSpan;
                 float blendPercentage = this.Options.BlendPercentage;
 
                 // TODO: Remove bounds checks.
                 if (blendPercentage < 1)
                 {
                     for (int i = 0; i < scanline.Length; i++)
                     {
-                        amountSpan[i] = scanline[i] * blendPercentage;
-                        overlaySpan[i] = this[x + i, y, intersectionsSpan, orientationsSpan];
+                        amounts[i] = scanline[i] * blendPercentage;
+                        overlays[i] = this[x + i, y, intersections, orientations];
                     }
                 }
                 else
                 {
                     for (int i = 0; i < scanline.Length; i++)
                     {
-                        amountSpan[i] = scanline[i];
-                        overlaySpan[i] = this[x + i, y, intersectionsSpan, orientationsSpan];
+                        amounts[i] = scanline[i];
+                        overlays[i] = this[x + i, y, intersections, orientations];
                     }
                 }
 
                 Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                this.Blender.Blend(this.Configuration, destinationRow, destinationRow, overlaySpan, amountSpan);
+                this.Blender.Blend(this.Configuration, destinationRow, destinationRow, overlays, amounts);
+            }
+
+            protected override void Dispose(bool disposing)
+            {
+                if (this.isDisposed)
+                {
+                    return;
+                }
+
+                base.Dispose(disposing);
+
+                if (disposing)
+                {
+                    foreach (ThreadContextData data in this.threadContextData.Values)
+                    {
+                        data.Dispose();
+                    }
+
+                    this.threadContextData.Dispose();
+                }
+
+                this.isDisposed = true;
             }
 
             private (Edge edge, Intersection? info) FindIntersection(
@@ -410,6 +443,43 @@ private static bool FindPointOnTriangle(PointF v1, PointF v2, PointF v3, PointF
                 v = ((d00 * d21) - (d01 * d20)) / denominator;
                 return true;
             }
+
+            private sealed class ThreadContextData : IDisposable
+            {
+                private bool isDisposed;
+                private readonly IMemoryOwner<float> amountBuffer;
+                private readonly IMemoryOwner<TPixel> overlayBuffer;
+                private readonly IMemoryOwner<PointF> intersectionsBuffer;
+                private readonly IMemoryOwner<PointOrientation> orientationsBuffer;
+
+                public ThreadContextData(MemoryAllocator memoryAllocator, int scanlineLength, int maxIntersections)
+                {
+                    this.amountBuffer = memoryAllocator.Allocate<float>(scanlineLength);
+                    this.overlayBuffer = memoryAllocator.Allocate<TPixel>(scanlineLength);
+                    this.intersectionsBuffer = memoryAllocator.Allocate<PointF>(maxIntersections);
+                    this.orientationsBuffer = memoryAllocator.Allocate<PointOrientation>(maxIntersections);
+                }
+
+                public Span<float> AmountSpan => this.amountBuffer.Memory.Span;
+
+                public Span<TPixel> OverlaySpan => this.overlayBuffer.Memory.Span;
+
+                public Span<PointF> IntersectionsSpan => this.intersectionsBuffer.Memory.Span;
+
+                public Span<PointOrientation> OrientationsSpan => this.orientationsBuffer.Memory.Span;
+
+                public void Dispose()
+                {
+                    if (!this.isDisposed)
+                    {
+                        this.isDisposed = true;
+                        this.amountBuffer.Dispose();
+                        this.overlayBuffer.Dispose();
+                        this.intersectionsBuffer.Dispose();
+                        this.orientationsBuffer.Dispose();
+                    }
+                }
+            }
         }
     }
 }

src/ImageSharp.Drawing/Processing/SolidBrush.cs

@@ -36,6 +36,7 @@ public BrushApplicator<TPixel> CreateApplicator<TPixel>(
         /// <summary>
         /// The solid brush applicator.
         /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
         private class SolidBrushApplicator<TPixel> : BrushApplicator<TPixel>
             where TPixel : unmanaged, IPixel<TPixel>
         {
@@ -97,14 +98,13 @@ public override void Apply(Span<float> scanline, int x, int y)
                 }
 
                 Configuration configuration = this.Configuration;
-                MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
-
                 if (this.Options.BlendPercentage == 1f)
                 {
                     this.Blender.Blend(configuration, destinationRow, destinationRow, this.Colors.Memory.Span, scanline);
                 }
                 else
                 {
+                    MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
                     using IMemoryOwner<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length);
                     Span<float> amountSpan = amountBuffer.Memory.Span;