Improving the benchmark, so we can see all the implementations.

Author: Daniel Lemire

README.md

@@ -47,6 +47,13 @@ cd benchmark
 dotnet run -c Release
 ```
 
+To run just one benchmark, use a filter:
+
+```
+cd benchmark
+dotnet run --configuration Release --filter "*Arabic-Lipsum*"
+```
+
 If you are under macOS or Linux, you may want to run the benchmarks in privileged mode:
 
 ```

benchmark/Benchmark.cs

@@ -4,6 +4,7 @@
 using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Reports;
+using BenchmarkDotNet.Filters;
 using System.Text;
 using System.Runtime;
 using System.Runtime.InteropServices;
@@ -12,7 +13,10 @@
 using System.Collections.Generic;
 using System.Linq;
 using BenchmarkDotNet.Columns;
-
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+using System.Runtime.Intrinsics.Arm;
+using System.Runtime.CompilerServices;
 
 
 namespace SimdUnicodeBenchmarks
@@ -47,6 +51,8 @@ public string GetValue(Summary summary, BenchmarkCase benchmarkCase)
         public UnitType UnitType { get; } = UnitType.Dimensionless;
         public string Legend { get; } = "The speed in gigabytes per second";
     }
+
+
     [SimpleJob(launchCount: 1, warmupCount: 3, iterationCount: 3)]
     [Config(typeof(Config))]
     public class RealDataBenchmark
@@ -56,7 +62,44 @@ private class Config : ManualConfig
         {
             public Config()
             {
-                AddColumn(new Speed());
+                AddColumn(new Speed());
+
+
+                if (RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
+                {
+                    Console.WriteLine("ARM64 system detected.");
+                    AddFilter(new AnyCategoriesFilter(["arm64", "scalar", "runtime"]));
+
+                }
+                else if (RuntimeInformation.ProcessArchitecture == Architecture.X64)
+                {
+                    if (Vector512.IsHardwareAccelerated && System.Runtime.Intrinsics.X86.Avx512Vbmi.IsSupported)
+                    {
+                        Console.WriteLine("X64 system detected (Intel, AMD,...) with AVX-512 support.");
+                        AddFilter(new AnyCategoriesFilter(["avx512", "avx", "sse", "scalar", "runtime"]));
+                    }
+                    else if (Avx2.IsSupported)
+                    {
+                        Console.WriteLine("X64 system detected (Intel, AMD,...) with AVX2 support.");
+                        AddFilter(new AnyCategoriesFilter(["avx", "sse", "scalar", "runtime"]));
+                    }
+                    else if (Sse42.IsSupported)
+                    {
+                        Console.WriteLine("X64 system detected (Intel, AMD,...) with Sse4.2 support.");
+                        AddFilter(new AnyCategoriesFilter(["sse", "scalar", "runtime"]));
+                    }
+                    else
+                    {
+                        Console.WriteLine("X64 system detected (Intel, AMD,...) without relevant SIMD support.");
+                        AddFilter(new AnyCategoriesFilter(["scalar", "runtime"]));
+                    }
+                }
+                else
+                {
+                    AddFilter(new AnyCategoriesFilter(["scalar", "runtime"]));
+
+                }
+
             }
         }
         // Parameters and variables for real data
@@ -128,42 +171,83 @@ public void Setup()
         }
 
         [Benchmark]
+        [BenchmarkCategory("default", "runtime")]
         public unsafe void DotnetRuntimeUtf8ValidationRealData()
         {
             RunDotnetRuntimeUtf8ValidationBenchmark(allLinesUtf8, DotnetRuntime.Utf8Utility.GetPointerToFirstInvalidByte);
         }
 
         [Benchmark]
+        [BenchmarkCategory("default")]
         public unsafe void SIMDUtf8ValidationRealData()
         {
             if (allLinesUtf8 != null)
             {
                 RunUtf8ValidationBenchmark(allLinesUtf8, SimdUnicode.UTF8.GetPointerToFirstInvalidByte);
             }
         }
-    }
 
-    public class Program
-    {
-        // TODO: adopt BenchmarkSwitcher https://benchmarkdotnet.org/articles/guides/how-to-run.html 
-        public static void Main(string[] args)
+        [Benchmark]
+        [BenchmarkCategory("scalar")]
+        public unsafe void Utf8ValidationRealDataScalar()
+        {
+            if (allLinesUtf8 != null)
+            {
+                RunUtf8ValidationBenchmark(allLinesUtf8, SimdUnicode.UTF8.GetPointerToFirstInvalidByteScalar);
+            }
+        }
+        [Benchmark]
+        [BenchmarkCategory("arm64")]
+        public unsafe void SIMDUtf8ValidationRealDataArm64()
+        {
+            if (allLinesUtf8 != null)
+            {
+                RunUtf8ValidationBenchmark(allLinesUtf8, SimdUnicode.UTF8.GetPointerToFirstInvalidByteArm64);
+            }
+        }
+        [Benchmark]
+        [BenchmarkCategory("avx")]
+        public unsafe void SIMDUtf8ValidationRealDataAvx2()
         {
-            if (RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
+            if (allLinesUtf8 != null)
             {
-                Console.WriteLine("ARM64 system detected.");
+                RunUtf8ValidationBenchmark(allLinesUtf8, SimdUnicode.UTF8.GetPointerToFirstInvalidByteAvx2);
             }
-            else if (RuntimeInformation.ProcessArchitecture == Architecture.X64)
+        }
+        /*
+        // TODO: enable this benchmark when the SSE implementation is ready
+        [Benchmark]
+        [BenchmarkCategory("sse")]
+        public unsafe void SIMDUtf8ValidationRealDataSse()
+        {
+            if (allLinesUtf8 != null)
             {
-                Console.WriteLine("X64 system detected (Intel, AMD,...).");
+                RunUtf8ValidationBenchmark(allLinesUtf8, SimdUnicode.UTF8.GetPointerToFirstInvalidByteSse);
             }
-            else
+        }*/
+        /*
+        // TODO: enable this benchmark when the AVX-512 implementation is ready
+        [Benchmark]
+        [BenchmarkCategory("avx512")]
+        public unsafe void SIMDUtf8ValidationRealDataAvx512()
+        {
+            if (allLinesUtf8 != null)
             {
-                Console.WriteLine("Unrecognized system.");
+                RunUtf8ValidationBenchmark(allLinesUtf8, SimdUnicode.UTF8.GetPointerToFirstInvalidByteAvx512);
             }
+        }*/
 
+    }
+    public class Program
+    {
+        // TODO: adopt BenchmarkSwitcher https://benchmarkdotnet.org/articles/guides/how-to-run.html 
+        /*public static void Main(string[] args)
+        {
             var config = DefaultConfig.Instance.WithSummaryStyle(SummaryStyle.Default.WithMaxParameterColumnWidth(100));
             BenchmarkRunner.Run<RealDataBenchmark>(config);
-        }
+        }*/
+        static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+
 
     }
 

src/UTF8.cs

@@ -465,11 +465,11 @@ public static class UTF8
             //if (Vector512.IsHardwareAccelerated && Avx512Vbmi2.IsSupported)
             //{
             //    return GetPointerToFirstInvalidByteAvx512(pInputBuffer, inputLength);
-            //
+            //GetPointerToFirstInvalidByteAvx2
             //}
-            //if (Sse2.IsSupported)
+            //if (Sse42.IsSupported)
             //{
-            //    return GetPointerToFirstInvalidByteSse2(pInputBuffer, inputLength);
+            //    return GetPointerToFirstInvalidByteSse(pInputBuffer, inputLength);
             //}
             return GetPointerToFirstInvalidByteScalar(pInputBuffer, inputLength);
         }