Benchmarks, tests, and cleanup.

Author: JimBobSquarePants

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

@@ -13,15 +13,13 @@
 #endif
 
 using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Environments;
-using BenchmarkDotNet.Jobs;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
 namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
 {
-    [Config(typeof(Config.ShortClr))]
+    [Config(typeof(Config.ShortCore31))]
     public abstract class FromVector4<TPixel>
         where TPixel : unmanaged, IPixel<TPixel>
     {

tests/ImageSharp.Benchmarks/Color/Bulk/FromVector4.cs

@@ -13,7 +13,7 @@
 
 namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
 {
-    [Config(typeof(Config.ShortClr))]
+    [Config(typeof(Config.ShortCore31))]
     public class ToVector4_Rgba32 : ToVector4<Rgba32>
     {
         [Benchmark]
@@ -52,6 +52,17 @@ public void ExtendedIntrinsics()
             SimdUtils.ExtendedIntrinsics.ByteToNormalizedFloat(sBytes, dFloats);
         }
 
+#if SUPPORTS_RUNTIME_INTRINSICS
+        [Benchmark]
+        public void HwIntrinsics()
+        {
+            Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
+            Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
+
+            SimdUtils.HwIntrinsics.ByteToNormalizedFloat(sBytes, dFloats);
+        }
+#endif
+
         // [Benchmark]
         public void ExtendedIntrinsics_BulkConvertByteToNormalizedFloat_2Loops()
         {

tests/ImageSharp.Benchmarks/Color/Bulk/ToVector4_Rgba32.cs

@@ -7,7 +7,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Common.Tuples;
-
+using SixLabors.ImageSharp.Tests.TestUtilities;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -209,9 +209,17 @@ public void ExtendedIntrinsics_BulkConvertByteToNormalizedFloat(int count)
         [MemberData(nameof(ArraySizesDivisibleBy32))]
         public void HwIntrinsics_BulkConvertByteToNormalizedFloat(int count)
         {
-            TestImpl_BulkConvertByteToNormalizedFloat(
-                count,
-                (s, d) => SimdUtils.HwIntrinsics.ByteToNormalizedFloat(s.Span, d.Span));
+            static void RunTest(string serialized)
+            {
+                TestImpl_BulkConvertByteToNormalizedFloat(
+                    FeatureTestRunner.Deserialize(serialized),
+                    (s, d) => SimdUtils.HwIntrinsics.ByteToNormalizedFloat(s.Span, d.Span));
+            }
+
+            FeatureTestRunner.RunWithHwIntrinsicsFeature(
+                RunTest,
+                HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2 | HwIntrinsics.DisableSSE41,
+                count);
         }
 #endif
 
@@ -294,9 +302,17 @@ public void ExtendedIntrinsics_ConvertToSingle(short scale)
         [MemberData(nameof(ArraySizesDivisibleBy32))]
         public void HwIntrinsics_BulkConvertNormalizedFloatToByteClampOverflows(int count)
         {
-            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(
-                count,
-                (s, d) => SimdUtils.HwIntrinsics.NormalizedFloatToByteSaturate(s.Span, d.Span));
+            static void RunTest(string serialized)
+            {
+                TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(
+                    FeatureTestRunner.Deserialize(serialized),
+                    (s, d) => SimdUtils.HwIntrinsics.NormalizedFloatToByteSaturate(s.Span, d.Span));
+            }
+
+            FeatureTestRunner.RunWithHwIntrinsicsFeature(
+                RunTest,
+                HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX2,
+                count);
         }
 
 #endif

tests/ImageSharp.Tests/Common/SimdUtilsTests.cs

@@ -33,6 +33,14 @@ public static T Deserialize<T>(string value)
             where T : IXunitSerializable
             => BasicSerializer.Deserialize<T>(value);
 
+        /// <summary>
+        /// Allows the deserialization of integers passed to the feature test.
+        /// </summary>
+        /// <param name="value">The string value to deserialize.</param>
+        /// <returns>The <see cref="int"/> value.</returns>
+        public static int Deserialize(string value)
+            => Convert.ToInt32(value);
+
         /// <summary>
         /// Runs the given test <paramref name="action"/> within an environment
         /// where the given <paramref name="intrinsics"/> features.
@@ -201,6 +209,48 @@ public static void RunWithHwIntrinsicsFeature<T>(
             }
         }
 
+        /// <summary>
+        /// Runs the given test <paramref name="action"/> within an environment
+        /// where the given <paramref name="intrinsics"/> features.
+        /// </summary>
+        /// <param name="action">The test action to run.</param>
+        /// <param name="intrinsics">The intrinsics features.</param>
+        /// <param name="serializable">The value to pass as a parameter to the test action.</param>
+        public static void RunWithHwIntrinsicsFeature(
+            Action<string> action,
+            HwIntrinsics intrinsics,
+            int serializable)
+        {
+            if (!RemoteExecutor.IsSupported)
+            {
+                return;
+            }
+
+            foreach (KeyValuePair<HwIntrinsics, string> intrinsic in intrinsics.ToFeatureKeyValueCollection())
+            {
+                var processStartInfo = new ProcessStartInfo();
+                if (intrinsic.Key != HwIntrinsics.AllowAll)
+                {
+                    processStartInfo.Environment[$"COMPlus_{intrinsic.Value}"] = "0";
+
+                    RemoteExecutor.Invoke(
+                        action,
+                        serializable.ToString(),
+                        new RemoteInvokeOptions
+                        {
+                            StartInfo = processStartInfo
+                        })
+                        .Dispose();
+                }
+                else
+                {
+                    // Since we are running using the default architecture there is no
+                    // point creating the overhead of running the action in a separate process.
+                    action(serializable.ToString());
+                }
+            }
+        }
+
         internal static Dictionary<HwIntrinsics, string> ToFeatureKeyValueCollection(this HwIntrinsics intrinsics)
         {
             // Loop through and translate the given values into COMPlus equivaluents