Merge branch 'main' into js/accumulative-memory-limit

Author: JimBobSquarePants

src/ImageSharp/Advanced/ParallelExecutionSettings.cs

@@ -18,7 +18,10 @@ public readonly struct ParallelExecutionSettings
     /// <summary>
     /// Initializes a new instance of the <see cref="ParallelExecutionSettings"/> struct.
     /// </summary>
-    /// <param name="maxDegreeOfParallelism">The value used for initializing <see cref="ParallelOptions.MaxDegreeOfParallelism"/> when using TPL.</param>
+    /// <param name="maxDegreeOfParallelism">
+    /// The value used for initializing <see cref="ParallelOptions.MaxDegreeOfParallelism"/> when using TPL.
+    /// Set to <c>-1</c> to leave the degree of parallelism unbounded.
+    /// </param>
     /// <param name="minimumPixelsProcessedPerTask">The value for <see cref="MinimumPixelsProcessedPerTask"/>.</param>
     /// <param name="memoryAllocator">The <see cref="MemoryAllocator"/>.</param>
     public ParallelExecutionSettings(
@@ -44,7 +47,10 @@ public ParallelExecutionSettings(
     /// <summary>
     /// Initializes a new instance of the <see cref="ParallelExecutionSettings"/> struct.
     /// </summary>
-    /// <param name="maxDegreeOfParallelism">The value used for initializing <see cref="ParallelOptions.MaxDegreeOfParallelism"/> when using TPL.</param>
+    /// <param name="maxDegreeOfParallelism">
+    /// The value used for initializing <see cref="ParallelOptions.MaxDegreeOfParallelism"/> when using TPL.
+    /// Set to <c>-1</c> to leave the degree of parallelism unbounded.
+    /// </param>
     /// <param name="memoryAllocator">The <see cref="MemoryAllocator"/>.</param>
     public ParallelExecutionSettings(int maxDegreeOfParallelism, MemoryAllocator memoryAllocator)
         : this(maxDegreeOfParallelism, DefaultMinimumPixelsProcessedPerTask, memoryAllocator)
@@ -58,6 +64,7 @@ public ParallelExecutionSettings(int maxDegreeOfParallelism, MemoryAllocator mem
 
     /// <summary>
     /// Gets the value used for initializing <see cref="ParallelOptions.MaxDegreeOfParallelism"/> when using TPL.
+    /// A value of <c>-1</c> leaves the degree of parallelism unbounded.
     /// </summary>
     public int MaxDegreeOfParallelism { get; }
 

src/ImageSharp/Advanced/ParallelRowIterator.cs

@@ -44,14 +44,14 @@ public static void IterateRows<T>(
         where T : struct, IRowOperation
     {
         ValidateRectangle(rectangle);
+        ValidateSettings(parallelSettings);
 
         int top = rectangle.Top;
         int bottom = rectangle.Bottom;
         int width = rectangle.Width;
         int height = rectangle.Height;
 
-        int maxSteps = DivideCeil(width * (long)height, parallelSettings.MinimumPixelsProcessedPerTask);
-        int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps);
+        int numOfSteps = GetNumberOfSteps(width, height, parallelSettings);
 
         // Avoid TPL overhead in this trivial case:
         if (numOfSteps == 1)
@@ -65,7 +65,7 @@ public static void IterateRows<T>(
         }
 
         int verticalStep = DivideCeil(rectangle.Height, numOfSteps);
-        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
+        ParallelOptions parallelOptions = CreateParallelOptions(parallelSettings, numOfSteps);
         RowOperationWrapper<T> wrappingOperation = new(top, bottom, verticalStep, in operation);
 
         _ = Parallel.For(
@@ -109,14 +109,14 @@ public static void IterateRows<T, TBuffer>(
         where TBuffer : unmanaged
     {
         ValidateRectangle(rectangle);
+        ValidateSettings(parallelSettings);
 
         int top = rectangle.Top;
         int bottom = rectangle.Bottom;
         int width = rectangle.Width;
         int height = rectangle.Height;
 
-        int maxSteps = DivideCeil(width * (long)height, parallelSettings.MinimumPixelsProcessedPerTask);
-        int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps);
+        int numOfSteps = GetNumberOfSteps(width, height, parallelSettings);
         MemoryAllocator allocator = parallelSettings.MemoryAllocator;
         int bufferLength = Unsafe.AsRef(in operation).GetRequiredBufferLength(rectangle);
 
@@ -135,7 +135,7 @@ public static void IterateRows<T, TBuffer>(
         }
 
         int verticalStep = DivideCeil(height, numOfSteps);
-        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
+        ParallelOptions parallelOptions = CreateParallelOptions(parallelSettings, numOfSteps);
         RowOperationWrapper<T, TBuffer> wrappingOperation = new(top, bottom, verticalStep, bufferLength, allocator, in operation);
 
         _ = Parallel.For(
@@ -174,14 +174,14 @@ public static void IterateRowIntervals<T>(
         where T : struct, IRowIntervalOperation
     {
         ValidateRectangle(rectangle);
+        ValidateSettings(parallelSettings);
 
         int top = rectangle.Top;
         int bottom = rectangle.Bottom;
         int width = rectangle.Width;
         int height = rectangle.Height;
 
-        int maxSteps = DivideCeil(width * (long)height, parallelSettings.MinimumPixelsProcessedPerTask);
-        int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps);
+        int numOfSteps = GetNumberOfSteps(width, height, parallelSettings);
 
         // Avoid TPL overhead in this trivial case:
         if (numOfSteps == 1)
@@ -192,7 +192,7 @@ public static void IterateRowIntervals<T>(
         }
 
         int verticalStep = DivideCeil(rectangle.Height, numOfSteps);
-        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
+        ParallelOptions parallelOptions = CreateParallelOptions(parallelSettings, numOfSteps);
         RowIntervalOperationWrapper<T> wrappingOperation = new(top, bottom, verticalStep, in operation);
 
         _ = Parallel.For(
@@ -236,14 +236,14 @@ public static void IterateRowIntervals<T, TBuffer>(
         where TBuffer : unmanaged
     {
         ValidateRectangle(rectangle);
+        ValidateSettings(parallelSettings);
 
         int top = rectangle.Top;
         int bottom = rectangle.Bottom;
         int width = rectangle.Width;
         int height = rectangle.Height;
 
-        int maxSteps = DivideCeil(width * (long)height, parallelSettings.MinimumPixelsProcessedPerTask);
-        int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps);
+        int numOfSteps = GetNumberOfSteps(width, height, parallelSettings);
         MemoryAllocator allocator = parallelSettings.MemoryAllocator;
         int bufferLength = Unsafe.AsRef(in operation).GetRequiredBufferLength(rectangle);
 
@@ -259,7 +259,7 @@ public static void IterateRowIntervals<T, TBuffer>(
         }
 
         int verticalStep = DivideCeil(height, numOfSteps);
-        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
+        ParallelOptions parallelOptions = CreateParallelOptions(parallelSettings, numOfSteps);
         RowIntervalOperationWrapper<T, TBuffer> wrappingOperation = new(top, bottom, verticalStep, bufferLength, allocator, in operation);
 
         _ = Parallel.For(
@@ -272,6 +272,37 @@ public static void IterateRowIntervals<T, TBuffer>(
     [MethodImpl(InliningOptions.ShortMethod)]
     private static int DivideCeil(long dividend, int divisor) => (int)Math.Min(1 + ((dividend - 1) / divisor), int.MaxValue);
 
+    /// <summary>
+    /// Creates the <see cref="ParallelOptions"/> for the current iteration.
+    /// </summary>
+    /// <param name="parallelSettings">The execution settings.</param>
+    /// <param name="numOfSteps">The number of row partitions to execute.</param>
+    /// <returns>The <see cref="ParallelOptions"/> instance.</returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static ParallelOptions CreateParallelOptions(in ParallelExecutionSettings parallelSettings, int numOfSteps)
+        => new() { MaxDegreeOfParallelism = parallelSettings.MaxDegreeOfParallelism == -1 ? -1 : numOfSteps };
+
+    /// <summary>
+    /// Calculates the number of row partitions to execute for the given region.
+    /// </summary>
+    /// <param name="width">The width of the region.</param>
+    /// <param name="height">The height of the region.</param>
+    /// <param name="parallelSettings">The execution settings.</param>
+    /// <returns>The number of row partitions to execute.</returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static int GetNumberOfSteps(int width, int height, in ParallelExecutionSettings parallelSettings)
+    {
+        int maxSteps = DivideCeil(width * (long)height, parallelSettings.MinimumPixelsProcessedPerTask);
+
+        if (parallelSettings.MaxDegreeOfParallelism == -1)
+        {
+            // Row batching cannot produce more useful partitions than the number of rows available.
+            return Math.Min(height, maxSteps);
+        }
+
+        return Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps);
+    }
+
     private static void ValidateRectangle(Rectangle rectangle)
     {
         Guard.MustBeGreaterThan(
@@ -284,4 +315,35 @@ private static void ValidateRectangle(Rectangle rectangle)
             0,
             $"{nameof(rectangle)}.{nameof(rectangle.Height)}");
     }
+
+    /// <summary>
+    /// Validates the supplied <see cref="ParallelExecutionSettings"/>.
+    /// </summary>
+    /// <param name="parallelSettings">The execution settings.</param>
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// Thrown when <see cref="ParallelExecutionSettings.MaxDegreeOfParallelism"/> or
+    /// <see cref="ParallelExecutionSettings.MinimumPixelsProcessedPerTask"/> is invalid.
+    /// </exception>
+    /// <exception cref="ArgumentNullException">
+    /// Thrown when <see cref="ParallelExecutionSettings.MemoryAllocator"/> is null.
+    /// This also guards the public <see cref="ParallelExecutionSettings"/> default value, which bypasses constructor validation.
+    /// </exception>
+    private static void ValidateSettings(in ParallelExecutionSettings parallelSettings)
+    {
+        // ParallelExecutionSettings is a public struct, so callers can pass default and bypass constructor validation.
+        if (parallelSettings.MaxDegreeOfParallelism is 0 or < -1)
+        {
+            throw new ArgumentOutOfRangeException(
+                $"{nameof(parallelSettings)}.{nameof(ParallelExecutionSettings.MaxDegreeOfParallelism)}");
+        }
+
+        Guard.MustBeGreaterThan(
+            parallelSettings.MinimumPixelsProcessedPerTask,
+            0,
+            $"{nameof(parallelSettings)}.{nameof(ParallelExecutionSettings.MinimumPixelsProcessedPerTask)}");
+
+        Guard.NotNull(
+            parallelSettings.MemoryAllocator,
+            $"{nameof(parallelSettings)}.{nameof(ParallelExecutionSettings.MemoryAllocator)}");
+    }
 }

src/ImageSharp/Common/Helpers/Numerics.cs

@@ -643,6 +643,20 @@ public static Vector256<float> UnPremultiply(Vector256<float> source, Vector256<
         return Avx.Blend(result, alpha, BlendAlphaControl);
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> UnPremultiply(Vector512<float> source, Vector512<float> alpha)
+    {
+        // Check if alpha is zero to avoid division by zero
+        Vector512<float> zeroMask = Vector512.Equals(alpha, Vector512<float>.Zero);
+
+        // Divide source by alpha if alpha is nonzero, otherwise set all components to match the source value
+        Vector512<float> result = Vector512.ConditionalSelect(zeroMask, source, source / alpha);
+
+        // Blend the result with the alpha vector to ensure that the alpha component is unchanged
+        Vector512<float> alphaMask = Vector512.Create(0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1).AsSingle();
+        return Vector512.ConditionalSelect(alphaMask, alpha, result);
+    }
+
     /// <summary>
     /// Permutes the given vector return a new instance with all the values set to <see cref="Vector4.W"/>.
     /// </summary>
@@ -690,7 +704,7 @@ public static Vector4 WithW(Vector4 value, Vector4 w)
     /// </summary>
     /// <param name="vectors">The span of vectors</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static unsafe void CubePowOnXYZ(Span<Vector4> vectors)
+    public static void CubePowOnXYZ(Span<Vector4> vectors)
     {
         ref Vector4 baseRef = ref MemoryMarshal.GetReference(vectors);
         ref Vector4 endRef = ref Unsafe.Add(ref baseRef, (uint)vectors.Length);

src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs

@@ -601,51 +601,6 @@ private static void Shuffle4Slice3(
             }
         }
 
-        /// <summary>
-        /// Performs a multiplication and an addition of the <see cref="Vector256{Single}"/>.
-        /// TODO: Fix. The arguments are in a different order to the FMA intrinsic.
-        /// </summary>
-        /// <remarks>ret = (vm0 * vm1) + va</remarks>
-        /// <param name="va">The vector to add to the intermediate result.</param>
-        /// <param name="vm0">The first vector to multiply.</param>
-        /// <param name="vm1">The second vector to multiply.</param>
-        /// <returns>The <see cref="Vector256{T}"/>.</returns>
-        [MethodImpl(InliningOptions.AlwaysInline)]
-        public static Vector256<float> MultiplyAdd(
-            Vector256<float> va,
-            Vector256<float> vm0,
-            Vector256<float> vm1)
-        {
-            if (Fma.IsSupported)
-            {
-                return Fma.MultiplyAdd(vm1, vm0, va);
-            }
-
-            return va + (vm0 * vm1);
-        }
-
-        /// <summary>
-        /// Performs a multiplication and a negated addition of the <see cref="Vector256{Single}"/>.
-        /// </summary>
-        /// <remarks>ret = c - (a * b)</remarks>
-        /// <param name="a">The first vector to multiply.</param>
-        /// <param name="b">The second vector to multiply.</param>
-        /// <param name="c">The vector to add negated to the intermediate result.</param>
-        /// <returns>The <see cref="Vector256{T}"/>.</returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static Vector256<float> MultiplyAddNegated(
-            Vector256<float> a,
-            Vector256<float> b,
-            Vector256<float> c)
-        {
-            if (Fma.IsSupported)
-            {
-                return Fma.MultiplyAddNegated(a, b, c);
-            }
-
-            return Avx.Subtract(c, Avx.Multiply(a, b));
-        }
-
         /// <summary>
         /// Blend packed 8-bit integers from <paramref name="left"/> and <paramref name="right"/> using <paramref name="mask"/>.
         /// The high bit of each corresponding <paramref name="mask"/> byte determines the selection.

src/ImageSharp/Common/Helpers/Vector256Utilities.cs

@@ -115,6 +115,28 @@ public static Vector256<float> MultiplyAdd(
         return va + (vm0 * vm1);
     }
 
+    /// <summary>
+    /// Performs a multiplication and a negated addition of the <see cref="Vector256{Single}"/>.
+    /// </summary>
+    /// <remarks>ret = va - (vm0 * vm1)</remarks>
+    /// <param name="va">The vector to add to the negated intermediate result.</param>
+    /// <param name="vm0">The first vector to multiply.</param>
+    /// <param name="vm1">The second vector to multiply.</param>
+    /// <returns>The <see cref="Vector256{T}"/>.</returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static Vector256<float> MultiplyAddNegated(
+        Vector256<float> va,
+        Vector256<float> vm0,
+        Vector256<float> vm1)
+    {
+        if (Fma.IsSupported)
+        {
+            return Fma.MultiplyAddNegated(vm0, vm1, va);
+        }
+
+        return va - (vm0 * vm1);
+    }
+
     /// <summary>
     /// Performs a multiplication and a subtraction of the <see cref="Vector256{Single}"/>.
     /// </summary>

src/ImageSharp/Common/Helpers/Vector512Utilities.cs

@@ -87,6 +87,21 @@ public static Vector512<float> MultiplyAdd(
         Vector512<float> vm1)
         => Avx512F.FusedMultiplyAdd(vm0, vm1, va);
 
+    /// <summary>
+    /// Performs a multiplication and a negated addition of the <see cref="Vector512{Single}"/>.
+    /// </summary>
+    /// <remarks>ret = va - (vm0 * vm1)</remarks>
+    /// <param name="va">The vector to add to the negated intermediate result.</param>
+    /// <param name="vm0">The first vector to multiply.</param>
+    /// <param name="vm1">The second vector to multiply.</param>
+    /// <returns>The <see cref="Vector512{T}"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector512<float> MultiplyAddNegated(
+        Vector512<float> va,
+        Vector512<float> vm0,
+        Vector512<float> vm1)
+        => Avx512F.FusedMultiplyAddNegated(vm0, vm1, va);
+
     /// <summary>
     /// Restricts a vector between a minimum and a maximum value.
     /// </summary>

src/ImageSharp/Configuration.cs

@@ -64,6 +64,7 @@ public Configuration(params IImageFormatConfigurationModule[] configurationModul
     /// <summary>
     /// Gets or sets the maximum number of concurrent tasks enabled in ImageSharp algorithms
     /// configured with this <see cref="Configuration"/> instance.
+    /// Set to <c>-1</c> to leave the degree of parallelism unbounded.
     /// Initialized with <see cref="Environment.ProcessorCount"/> by default.
     /// </summary>
     public int MaxDegreeOfParallelism

src/ImageSharp/Formats/Gif/GifDecoderCore.cs

@@ -468,7 +468,7 @@ private bool ReadFrame<TPixel>(
             int length = this.currentLocalColorTableSize = this.imageDescriptor.LocalColorTableSize * 3;
             this.currentLocalColorTable ??= this.configuration.MemoryAllocator.Allocate<byte>(768, AllocationOptions.Clean);
             stream.Read(this.currentLocalColorTable.GetSpan()[..length]);
-            rawColorTable = this.currentLocalColorTable!.GetSpan()[..length];
+            rawColorTable = this.currentLocalColorTable.GetSpan()[..length];
         }
         else if (this.globalColorTable != null)
         {