feat: performance comparison

Author: NetDefender

.editorconfig

@@ -1,7 +1,10 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+#if !NET48
 using System.Runtime.Intrinsics;
+#endif
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace SimdIteration;
 
@@ -10,8 +13,22 @@ public static class LinqExtensions
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IEnumerable<TSource[]> OptimizedChunk<TSource>(this IEnumerable<TSource> source, int size)
     {
+#if NET48
+    if (source == null)
+    {
+        throw new ArgumentNullException(nameof(source));
+    }
+#else
         ArgumentNullException.ThrowIfNull(source);
+#endif
+#if NET8_0
         ArgumentOutOfRangeException.ThrowIfLessThan(size, 1);
+#else
+        if(size < 1)
+        {
+            throw new ArgumentOutOfRangeException(nameof(source));
+        }
+#endif
         return SafeOptimizedChunker(source, size);
     }
 
@@ -71,35 +88,65 @@ private static IEnumerable<TSource[]> SafeOptimizedChunker<TSource>(IEnumerable<
             }
         }
     }
+#if !NET48
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int SumSimd(this int[] source) => SimdCore<int>.Sum(new ReadOnlySpan<int>(source));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static int Sum(this int[] source) => SimdCore<int>.Sum(new ReadOnlySpan<int>(source));
+    public static (int Min, int Max) MinMaxSimd(this int[] source) => SimdCore<int>.MinMax(new ReadOnlySpan<int>(source));
+#endif
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static (int Min, int Max) MinMax(this int[] source) => SimdCore<int>.MinMax(new ReadOnlySpan<int>(source));
+    public static (int Min, int Max) MinMaxLinq(this int[] source)
+    {
+        return (source.Min(), source.Max());
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static decimal Average(this int[] source) => SimdCore<int>.Sum(new ReadOnlySpan<int>(source)) / (source.Length * 1M);
+    public static (int Min, int Max) MinMaxForEach(this int[] source)
+    {
+        int min = source[0];
+        int max = min;
+
+        foreach(int value in source)
+        {
+            if(value < min)
+            {
+                min = value;
+            }
+            if(value > max)
+            {
+                max = value;
+            }
+        }
+
+        return (min, max);
+    }
 }
 
+#if !NET48
 file static class SimdCore<T> where T : struct, INumber<T>
 {
     #region fields
     private static readonly int _vectorLength;
+#if NET8_0
     private static readonly bool _is512;
+#endif
     private static readonly bool _is256;
     private static readonly bool _is128;
     #endregion
 
     #region ctor
     static SimdCore()
     {
-        if (Vector256.IsHardwareAccelerated)
+#if NET8_0
+        if (Vector512.IsHardwareAccelerated)
         {
             _is512 = true;
             _vectorLength = Vector512<T>.Count;
             return;
         }
+#endif
         if (Vector256.IsHardwareAccelerated)
         {
             _is256 = true;
@@ -121,10 +168,12 @@ internal static T Sum(ReadOnlySpan<T> source)
     {
         if (source.Length > _vectorLength)
         {
+#if NET8_0
             if (_is512)
             {
                 return Sum512(source);
             }
+#endif
             if (_is256)
             {
                 return Sum256(source);
@@ -136,7 +185,7 @@ internal static T Sum(ReadOnlySpan<T> source)
         }
         return SumFallback(source);
     }
-
+#if NET8_0
     private static T Sum512(ReadOnlySpan<T> source)
     {
         T sum = T.Zero;
@@ -163,7 +212,7 @@ private static T Sum512(ReadOnlySpan<T> source)
 
         return sum + Vector512.Sum(vectorSum512);
     }
-
+#endif
     private static T Sum256(ReadOnlySpan<T> source)
     {
         T sum = T.Zero;
@@ -236,10 +285,12 @@ internal static (T Min, T Max) MinMax(ReadOnlySpan<T> source)
     {
         if (source.Length > _vectorLength)
         {
+#if NET8_0
             if (_is512)
             {
                 return MinMax512(source);
             }
+#endif
             if (_is256)
             {
                 return MinMax256(source);
@@ -252,6 +303,7 @@ internal static (T Min, T Max) MinMax(ReadOnlySpan<T> source)
         return MinMaxFallback(source);
     }
 
+#if NET8_0
     private static (T Min, T Max) MinMax512(ReadOnlySpan<T> source)
     {
         ref T current = ref MemoryMarshal.GetReference(source);
@@ -302,7 +354,7 @@ private static (T Min, T Max) MinMax512(ReadOnlySpan<T> source)
 
         return (min, max);
     }
-
+#endif
     private static (T Min, T Max) MinMax256(ReadOnlySpan<T> source)
     {
         ref T current = ref MemoryMarshal.GetReference(source);
@@ -426,4 +478,5 @@ private static (T Min, T Max) MinMaxFallback(ReadOnlySpan<T> source)
         return (min, max);
     }
     #endregion
-}
+}
+#endif

LinqExtensions.cs

@@ -1,3 +1,13 @@
-using static System.Console;
+using BenchmarkDotNet.Running;
+using SimdIteration;
+using static System.Console;
 
-WriteLine("Hello SIMD");
+#if DEBUG
+SimdBenchmark benchmark = new ();
+benchmark.Setup();
+WriteLine(benchmark.MinMaxLinq());
+WriteLine(benchmark.MinMaxForEach());
+WriteLine(benchmark.MinMaxSimd());
+#else
+BenchmarkRunner.Run<SimdBenchmark>();
+#endif

Program.cs

@@ -1,3 +1,29 @@
 # Simd Iteration
 
-Test SIMD 512, 256, 128 registers for fast aggregate calculations
+Test SIMD 512, 256, 128 registers for fast aggregate calculations.
+
+Unfortunately my hardware doesn't support Vector512.
+
+Anyway, the performance improvement is mindblowing.
+
+> [!IMPORTANT]
+> net8 is x100 times faster than net48 for calculate the Min and Max at the same time !!
+
+## Results
+
+BenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19044.3086/21H2/November2021Update)
+AMD Ryzen 7 1700, 1 CPU, 16 logical and 8 physical cores
+.NET SDK=8.0.100-rc.1.23455.8
+  [Host]             : .NET 8.0.0 (8.0.23.41904), X64 RyuJIT AVX2
+  .NET 7.0           : .NET 7.0.11 (7.0.1123.42427), X64 RyuJIT AVX2
+  .NET 8.0           : .NET 8.0.0 (8.0.23.41904), X64 RyuJIT AVX2
+  .NET Framework 4.8 : .NET Framework 4.8 (4.8.4644.0), X64 RyuJIT VectorSize=256
+
+
+|        Method |                Job |            Runtime |  Size |           Mean | Allocated |
+|-------------- |------------------- |------------------- |------ |---------------:|----------:|
+|    MinMaxLinq | .NET Framework 4.8 | .NET Framework 4.8 | 10000 | 118,675.226 ns |      65 B |
+|    MinMaxLinq |           .NET 7.0 |           .NET 7.0 | 10000 |   2,350.046 ns |         - |
+|    MinMaxLinq |           .NET 8.0 |           .NET 8.0 | 10000 |   1,228.518 ns |         - |
+|    MinMaxSimd |           .NET 7.0 |           .NET 7.0 | 10000 |     834.291 ns |         - |
+|    **MinMaxSimd** |          **.NET 8.0** |           **.NET 8.0** | 10000 |     **808.150 ns** |         - |