Drawing performance tweaks

src/ImageSharp.Drawing/Shapes/PolygonClipper/ClipperOffset.cs

@@ -1,17 +1,13 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
-
 namespace SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper;
 
 /// <summary>
 /// Wrapper for clipper offset
 /// </summary>
 internal class ClipperOffset
 {
-    // To make the floating point polygons compatible with clipper we have to scale them.
-    private const float ScalingFactor = 1000F;
     private readonly PolygonOffsetter polygonClipperOffset;
 
     /// <summary>
@@ -30,16 +26,16 @@ public ClipperOffset(float meterLimit = 2F, float arcTolerance = .25F)
     public ComplexPolygon Execute(float width)
     {
         PathsF solution = new();
-        this.polygonClipperOffset.Execute(width * ScalingFactor, solution);
+        this.polygonClipperOffset.Execute(width, solution);
 
-        var polygons = new Polygon[solution.Count];
+        Polygon[] polygons = new Polygon[solution.Count];
         for (int i = 0; i < solution.Count; i++)
         {
             PathF pt = solution[i];
-            var points = new PointF[pt.Count];
+            PointF[] points = new PointF[pt.Count];
             for (int j = 0; j < pt.Count; j++)
             {
-                points[j] = pt[j] / ScalingFactor;
+                points[j] = pt[j];
             }
 
             polygons[i] = new Polygon(points);
@@ -59,7 +55,7 @@ public void AddPath(ReadOnlySpan<PointF> pathPoints, JointStyle jointStyle, EndC
         PathF points = new(pathPoints.Length);
         for (int i = 0; i < pathPoints.Length; i++)
         {
-            points.Add((Vector2)pathPoints[i] * ScalingFactor);
+            points.Add(pathPoints[i]);
         }
 
         this.polygonClipperOffset.AddPath(points, jointStyle, endCapStyle);

src/ImageSharp.Drawing/Shapes/Rasterization/ScanEdgeCollection.Build.cs

@@ -4,6 +4,10 @@
 using System.Buffers;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
+using System.Runtime.Intrinsics.X86;
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.Drawing.Shapes.Rasterization;
@@ -42,17 +46,17 @@ private enum VertexCategory
         RightRight,
     }
 
-    internal static ScanEdgeCollection Create(TessellatedMultipolygon multipolygon, MemoryAllocator allocator, int subsampling)
+    internal static ScanEdgeCollection Create(TessellatedMultipolygon multiPolygon, MemoryAllocator allocator, int subsampling)
     {
         // We allocate more than we need, since we don't know how many horizontal edges do we have:
-        IMemoryOwner<ScanEdge> buffer = allocator.Allocate<ScanEdge>(multipolygon.TotalVertexCount);
+        IMemoryOwner<ScanEdge> buffer = allocator.Allocate<ScanEdge>(multiPolygon.TotalVertexCount);
 
-        RingWalker walker = new RingWalker(buffer.Memory.Span);
+        RingWalker walker = new(buffer.Memory.Span);
 
-        using IMemoryOwner<float> roundedYBuffer = allocator.Allocate<float>(multipolygon.Max(r => r.Vertices.Length));
+        using IMemoryOwner<float> roundedYBuffer = allocator.Allocate<float>(multiPolygon.Max(r => r.Vertices.Length));
         Span<float> roundedY = roundedYBuffer.Memory.Span;
 
-        foreach (TessellatedMultipolygon.Ring ring in multipolygon)
+        foreach (TessellatedMultipolygon.Ring ring in multiPolygon)
         {
             if (ring.VertexCount < 3)
             {
@@ -82,22 +86,140 @@ internal static ScanEdgeCollection Create(TessellatedMultipolygon multipolygon,
 
         static void RoundY(ReadOnlySpan<PointF> vertices, Span<float> destination, float subsamplingRatio)
         {
-            for (int i = 0; i < vertices.Length; i++)
+            int ri = 0;
+            if (Avx.IsSupported)
             {
-                // for future SIMD impl:
-                // https://www.ocf.berkeley.edu/~horie/rounding.html
-                // Avx.RoundToPositiveInfinity()
-                destination[i] = MathF.Round(vertices[i].Y * subsamplingRatio, MidpointRounding.AwayFromZero) / subsamplingRatio;
+                // If the length of the input buffer as a float array is a multiple of 16, we can use AVX instructions:
+                int verticesLengthInFloats = vertices.Length * 2;
+                int vector256FloatCount_x2 = Vector256<float>.Count * 2;
+                int remainder = verticesLengthInFloats % vector256FloatCount_x2;
+                int verticesLength = verticesLengthInFloats - remainder;
+
+                if (verticesLength > 0)
+                {
+                    ri = vertices.Length - (remainder / 2);
+                    float maxIterations = verticesLength / (Vector256<float>.Count * 2);
+                    ref Vector256<float> sourceBase = ref Unsafe.As<PointF, Vector256<float>>(ref MemoryMarshal.GetReference(vertices));
+                    ref Vector256<float> destinationBase = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
+
+                    Vector256<float> ssRatio = Vector256.Create(subsamplingRatio);
+                    Vector256<float> inverseSsRatio = Vector256.Create(1F / subsamplingRatio);
+                    Vector256<float> half = Vector256.Create(.5F);
+
+                    // For every 1 vector we add to the destination we read 2 from the vertices.
+                    for (nint i = 0, j = 0; i < maxIterations; i++, j += 2)
+                    {
+                        // Load 8 PointF
+                        Vector256<float> points1 = Unsafe.Add(ref sourceBase, j);
+                        Vector256<float> points2 = Unsafe.Add(ref sourceBase, j + 1);
+
+                        // Shuffle the points to group the Y properties
+                        Vector128<float> points1Y = Sse.Shuffle(points1.GetLower(), points1.GetUpper(), 0b11_01_11_01);
+                        Vector128<float> points2Y = Sse.Shuffle(points2.GetLower(), points2.GetUpper(), 0b11_01_11_01);
+                        Vector256<float> pointsY = Vector256.Create(points1Y, points2Y);
+
+                        // Multiply by the subsampling ratio, round, then multiply by the inverted subsampling ratio and assign.
+                        // https://www.ocf.berkeley.edu/~horie/rounding.html
+                        Vector256<float> rounded = Avx.RoundToPositiveInfinity(Avx.Subtract(Avx.Multiply(pointsY, ssRatio), half));
+                        Unsafe.Add(ref destinationBase, i) = Avx.Multiply(rounded, inverseSsRatio);
+                    }
+                }
+            }
+            else if (Sse41.IsSupported)
+            {
+                // If the length of the input buffer as a float array is a multiple of 8, we can use Sse instructions:
+                int verticesLengthInFloats = vertices.Length * 2;
+                int vector128FloatCount_x2 = Vector128<float>.Count * 2;
+                int remainder = verticesLengthInFloats % vector128FloatCount_x2;
+                int verticesLength = verticesLengthInFloats - remainder;
+
+                if (verticesLength > 0)
+                {
+                    ri = vertices.Length - (remainder / 2);
+                    float maxIterations = verticesLength / (Vector128<float>.Count * 2);
+                    ref Vector128<float> sourceBase = ref Unsafe.As<PointF, Vector128<float>>(ref MemoryMarshal.GetReference(vertices));
+                    ref Vector128<float> destinationBase = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(destination));
+
+                    Vector128<float> ssRatio = Vector128.Create(subsamplingRatio);
+                    Vector128<float> inverseSsRatio = Vector128.Create(1F / subsamplingRatio);
+                    Vector128<float> half = Vector128.Create(.5F);
+
+                    // For every 1 vector we add to the destination we read 2 from the vertices.
+                    for (nint i = 0, j = 0; i < maxIterations; i++, j += 2)
+                    {
+                        // Load 4 PointF
+                        Vector128<float> points1 = Unsafe.Add(ref sourceBase, j);
+                        Vector128<float> points2 = Unsafe.Add(ref sourceBase, j + 1);
+
+                        // Shuffle the points to group the Y properties
+                        Vector128<float> pointsY = Sse.Shuffle(points1, points2, 0b11_01_11_01);
+
+                        // Multiply by the subsampling ratio, round, then multiply by the inverted subsampling ratio and assign.
+                        // https://www.ocf.berkeley.edu/~horie/rounding.html
+                        Vector128<float> rounded = Sse41.RoundToPositiveInfinity(Sse.Subtract(Sse.Multiply(pointsY, ssRatio), half));
+                        Unsafe.Add(ref destinationBase, i) = Sse.Multiply(rounded, inverseSsRatio);
+                    }
+                }
+            }
+            else if (AdvSimd.IsSupported)
+            {
+                // If the length of the input buffer as a float array is a multiple of 8, we can use AdvSimd instructions:
+                int verticesLengthInFloats = vertices.Length * 2;
+                int vector128FloatCount_x2 = Vector128<float>.Count * 2;
+                int remainder = verticesLengthInFloats % vector128FloatCount_x2;
+                int verticesLength = verticesLengthInFloats - remainder;
+
+                if (verticesLength > 0)
+                {
+                    ri = vertices.Length - (remainder / 2);
+                    float maxIterations = verticesLength / (Vector128<float>.Count * 2);
+                    ref Vector128<float> sourceBase = ref Unsafe.As<PointF, Vector128<float>>(ref MemoryMarshal.GetReference(vertices));
+                    ref Vector128<float> destinationBase = ref Unsafe.As<float, Vector128<float>>(ref MemoryMarshal.GetReference(destination));
+
+                    Vector128<float> ssRatio = Vector128.Create(subsamplingRatio);
+                    Vector128<float> inverseSsRatio = Vector128.Create(1F / subsamplingRatio);
+
+                    // For every 1 vector we add to the destination we read 2 from the vertices.
+                    for (nint i = 0, j = 0; i < maxIterations; i++, j += 2)
+                    {
+                        // Load 4 PointF
+                        Vector128<float> points1 = Unsafe.Add(ref sourceBase, j);
+                        Vector128<float> points2 = Unsafe.Add(ref sourceBase, j + 1);
+
+                        // Shuffle the points to group the Y properties
+                        Vector128<float> pointsY = AdvSimdShuffle(points1, points2, 0b11_01_11_01);
+
+                        // Multiply by the subsampling ratio, round, then multiply by the inverted subsampling ratio and assign.
+                        Vector128<float> rounded = AdvSimd.RoundAwayFromZero(AdvSimd.Multiply(pointsY, ssRatio));
+                        Unsafe.Add(ref destinationBase, i) = AdvSimd.Multiply(rounded, inverseSsRatio);
+                    }
+                }
+            }
+
+            for (; ri < vertices.Length; ri++)
+            {
+                destination[ri] = MathF.Round(vertices[ri].Y * subsamplingRatio, MidpointRounding.AwayFromZero) / subsamplingRatio;
             }
         }
 
         return new ScanEdgeCollection(buffer, walker.EdgeCounter);
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector128<float> AdvSimdShuffle(Vector128<float> a, Vector128<float> b, byte control)
+    {
+        Vector128<float> result = Vector128.Create(AdvSimd.Extract(a, (byte)(control & 0x3)));
+        result = AdvSimd.Insert(result, 1, AdvSimd.Extract(a, (byte)((control >> 2) & 0x3)));
+        result = AdvSimd.Insert(result, 2, AdvSimd.Extract(b, (byte)((control >> 4) & 0x3)));
+        result = AdvSimd.Insert(result, 3, AdvSimd.Extract(b, (byte)((control >> 6) & 0x3)));
+
+        return result;
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static VertexCategory CreateVertexCategory(EdgeCategory previousCategory, EdgeCategory currentCategory)
     {
-        var value = (VertexCategory)(((int)previousCategory << 2) | (int)currentCategory);
+        VertexCategory value = (VertexCategory)(((int)previousCategory << 2) | (int)currentCategory);
         VerifyVertexCategory(value);
         return value;
     }
@@ -106,7 +228,7 @@ private static VertexCategory CreateVertexCategory(EdgeCategory previousCategory
     private static void VerifyVertexCategory(VertexCategory vertexCategory)
     {
         int value = (int)vertexCategory;
-        if (value < 0 || value >= 16)
+        if (value is < 0 or >= 16)
         {
             throw new ArgumentOutOfRangeException(nameof(vertexCategory), "EdgeCategoryPair value shall be: 0 <= value < 16");
         }
@@ -151,7 +273,7 @@ public EdgeData(float startX, float endX, float startYRounded, float endYRounded
 
         public void EmitScanEdge(Span<ScanEdge> edges, ref int edgeCounter)
         {
-            if (this.EdgeCategory == EdgeCategory.Left || this.EdgeCategory == EdgeCategory.Right)
+            if (this.EdgeCategory is EdgeCategory.Left or EdgeCategory.Right)
             {
                 return;
             }

tests/Directory.Build.targets

@@ -19,7 +19,9 @@
   <ItemGroup>
     <!-- Test Dependencies -->
     <PackageReference Update="BenchmarkDotNet" Version="0.13.1" />
-    <PackageReference Update="Magick.NET-Q16-AnyCPU" Version="8.3.3" />
+    <PackageReference Update="Magick.NET-Q16-AnyCPU" Version="12.2.2" />
+    <PackageReference Update="Microsoft.DotNet.RemoteExecutor" Version="6.0.0-beta.21311.3" />
+    <PackageReference Update="Microsoft.DotNet.XUnitExtensions" Version="6.0.0-beta.21311.3" />
     <PackageReference Update="Moq" Version="4.16.1" />
     <PackageReference Include="runtime.osx.10.10-x64.CoreCompat.System.Drawing" Version="5.8.64" Condition="'$(IsOSX)'=='true'" />
     <PackageReference Update="System.Drawing.Common" Version="5.0.2" />