From d922602a26fa139b97dee86681b7dfcec188df68 Mon Sep 17 00:00:00 2001
From: Sergio Pedri <sergio0694@live.com>
Date: Thu, 27 Feb 2020 12:54:51 +0100
Subject: [PATCH] Introduced single row parallel helpers

---
 .../Advanced/ParallelRowIterator.cs           | 138 +++++++++++++++++-
 1 file changed, 134 insertions(+), 4 deletions(-)

diff --git a/src/ImageSharp/Advanced/ParallelRowIterator.cs b/src/ImageSharp/Advanced/ParallelRowIterator.cs
index 70b48aee9..86442ede7 100644
--- a/src/ImageSharp/Advanced/ParallelRowIterator.cs
+++ b/src/ImageSharp/Advanced/ParallelRowIterator.cs
@@ -17,6 +17,137 @@ namespace SixLabors.ImageSharp.Advanced
     /// </summary>
     public static partial class ParallelRowIterator
     {
+        /// <summary>
+        /// Iterate through the rows of a rectangle in optimized batches.
+        /// </summary>
+        /// <typeparam name="T">The type of row operation to perform.</typeparam>
+        /// <param name="configuration">The <see cref="Configuration"/> to get the parallel settings from.</param>
+        /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
+        /// <param name="operation">The operation defining the iteration logic on a single row.</param>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static void IterateRows<T>(Configuration configuration, Rectangle rectangle, in T operation)
+            where T : struct, IRowOperation
+        {
+            var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
+            IterateRows(rectangle, in parallelSettings, in operation);
+        }
+
+        /// <summary>
+        /// Iterate through the rows of a rectangle in optimized batches.
+        /// </summary>
+        /// <typeparam name="T">The type of row operation to perform.</typeparam>
+        /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
+        /// <param name="parallelSettings">The <see cref="ParallelExecutionSettings"/>.</param>
+        /// <param name="operation">The operation defining the iteration logic on a single row.</param>
+        public static void IterateRows<T>(
+            Rectangle rectangle,
+            in ParallelExecutionSettings parallelSettings,
+            in T operation)
+            where T : struct, IRowOperation
+        {
+            ValidateRectangle(rectangle);
+
+            int top = rectangle.Top;
+            int bottom = rectangle.Bottom;
+            int width = rectangle.Width;
+            int height = rectangle.Height;
+
+            int maxSteps = DivideCeil(width * height, parallelSettings.MinimumPixelsProcessedPerTask);
+            int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps);
+
+            // Avoid TPL overhead in this trivial case:
+            if (numOfSteps == 1)
+            {
+                for (int y = top; y < bottom; y++)
+                {
+                    Unsafe.AsRef(operation).Invoke(y);
+                }
+
+                return;
+            }
+
+            int verticalStep = DivideCeil(rectangle.Height, numOfSteps);
+            var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps };
+            var info = new IterationParameters(top, bottom, verticalStep);
+            var wrappingOperation = new RowOperationWrapper<T>(in info, in operation);
+
+            Parallel.For(
+                0,
+                numOfSteps,
+                parallelOptions,
+                wrappingOperation.Invoke);
+        }
+
+        /// <summary>
+        /// Iterate through the rows of a rectangle in optimized batches.
+        /// instantiating a temporary buffer for each <paramref name="operation"/> invocation.
+        /// </summary>
+        /// <typeparam name="T">The type of row operation to perform.</typeparam>
+        /// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
+        /// <param name="configuration">The <see cref="Configuration"/> to get the parallel settings from.</param>
+        /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
+        /// <param name="operation">The operation defining the iteration logic on a single row.</param>
+        public static void IterateRows<T, TBuffer>(Configuration configuration, Rectangle rectangle, in T operation)
+            where T : struct, IRowOperation<TBuffer>
+            where TBuffer : unmanaged
+        {
+            var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
+            IterateRows<T, TBuffer>(rectangle, in parallelSettings, in operation);
+        }
+
+        /// <summary>
+        /// Iterate through the rows of a rectangle in optimized batches.
+        /// instantiating a temporary buffer for each <paramref name="operation"/> invocation.
+        /// </summary>
+        /// <typeparam name="T">The type of row operation to perform.</typeparam>
+        /// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
+        /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
+        /// <param name="parallelSettings">The <see cref="ParallelExecutionSettings"/>.</param>
+        /// <param name="operation">The operation defining the iteration logic on a single row.</param>
+        public static void IterateRows<T, TBuffer>(
+            Rectangle rectangle,
+            in ParallelExecutionSettings parallelSettings,
+            in T operation)
+            where T : struct, IRowOperation<TBuffer>
+            where TBuffer : unmanaged
+        {
+            ValidateRectangle(rectangle);
+
+            int top = rectangle.Top;
+            int bottom = rectangle.Bottom;
+            int width = rectangle.Width;
+            int height = rectangle.Height;
+
+            int maxSteps = DivideCeil(width * height, parallelSettings.MinimumPixelsProcessedPerTask);
+            int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps);
+            MemoryAllocator allocator = parallelSettings.MemoryAllocator;
+
+            // Avoid TPL overhead in this trivial case:
+            if (numOfSteps == 1)
+            {
+                using IMemoryOwner<TBuffer> buffer = allocator.Allocate<TBuffer>(width);
+                Span<TBuffer> span = buffer.Memory.Span;
+
+                for (int y = top; y < bottom; y++)
+                {
+                    Unsafe.AsRef(operation).Invoke(y, span);
+                }
+
+                return;
+            }
+
+            int verticalStep = DivideCeil(height, numOfSteps);
+            var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps };
+            var info = new IterationParameters(top, bottom, verticalStep, width);
+            var wrappingOperation = new RowOperationWrapper<T, TBuffer>(in info, allocator, in operation);
+
+            Parallel.For(
+                0,
+                numOfSteps,
+                parallelOptions,
+                wrappingOperation.Invoke);
+        }
+
         /// <summary>
         /// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s.
         /// </summary>
@@ -123,10 +254,9 @@ namespace SixLabors.ImageSharp.Advanced
             if (numOfSteps == 1)
             {
                 var rows = new RowInterval(top, bottom);
-                using (IMemoryOwner<TBuffer> buffer = allocator.Allocate<TBuffer>(width))
-                {
-                    Unsafe.AsRef(operation).Invoke(in rows, buffer.Memory.Span);
-                }
+                using IMemoryOwner<TBuffer> buffer = allocator.Allocate<TBuffer>(width);
+
+                Unsafe.AsRef(operation).Invoke(in rows, buffer.Memory.Span);
 
                 return;
             }