SVE microbenchmarks with string operations

src/benchmarks/micro/MicroBenchmarks.csproj

@@ -237,6 +237,11 @@
     <Compile Remove="libraries\System.Reflection.Metadata\*.cs" />
   </ItemGroup>
 
+  <!-- Remove Sve microbenchmarks when running on net versions < 9.0 -->
+  <ItemGroup Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' Or ('$(TargetFrameworkIdentifier)' == '.NETCoreApp' And '$(_TargetFrameworkVersionWithoutV)' &lt; '9.0')">
+    <Compile Remove="sve\*.cs" />
+  </ItemGroup>
+
   <!-- This is not removing things from older Net versions, it is removing from newer Net versions -->
   <ItemGroup Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' Or ('$(TargetFrameworkIdentifier)' == '.NETCoreApp' And '$(_TargetFrameworkVersionWithoutV)' &gt;= '8.0')">
     <Compile Remove="libraries\System.Drawing\*.cs" />

src/benchmarks/micro/sve/StrCmp.cs

@@ -0,0 +1,222 @@
+#pragma warning disable SYSLIB5003
+
+using System;
+using System.Numerics;
+using System.Linq;
+using System.Diagnostics;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Extensions;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Filters;
+using MicroBenchmarks;
+
+namespace SveBenchmarks
+{
+    [BenchmarkCategory(Categories.Runtime)]
+    [OperatingSystemsArchitectureFilter(allowed: true, System.Runtime.InteropServices.Architecture.Arm64)]
+    [Config(typeof(Config))]
+    public class StrCmp
+    {
+        private class Config : ManualConfig
+        {
+            public Config()
+            {
+                AddFilter(new SimpleFilter(_ => Sve.IsSupported));
+            }
+        }
+
+        [Params(15, 127, 527, 10015)]
+        public int Size;
+
+        [Params("Middle", "End", "None")]
+        public string Modify;
+
+        private byte[] _arr1, _arr2;
+
+        [GlobalSetup]
+        public virtual void Setup()
+        {
+            _arr1 = ValuesGenerator.Array<byte>(Size);
+            _arr2 = ValuesGenerator.Array<byte>(Size);
+
+            switch (Modify)
+            {
+                case "Middle":
+                    // modify arr1 value in the middle of the array
+                    _arr1[Size / 2] += 1;
+                    break;
+
+                case "End":
+                    // modify arr2 value near the end of the array
+                    _arr2[Size - 1] += 1;
+                    break;
+
+                case "None":
+                    // keep both arrays equal
+                    break;
+            }
+        }
+
+        [Benchmark]
+        public int Scalar()
+        {
+            if (_arr1.Length == _arr2.Length)
+            {
+                for (int i = 0; i < Size; i++)
+                {
+                    if (_arr1[i] != _arr2[i])
+                        return _arr1[i] - _arr2[i];
+                }
+
+                return 0;
+            }
+
+            Debug.Assert(false, "Different array lengths are not expected");
+            return 0;
+        }
+
+        [Benchmark]
+        public int Vector128StrCmp()
+        {
+            int incr = Vector128<byte>.Count;
+            int i = 0;
+
+            if (_arr1.Length == _arr2.Length)
+            {
+                for (; i <= Size - incr; i += incr)
+                {
+                    Vector128<byte> arr1_vals = Vector128.LoadUnsafe(ref _arr1[i]);
+                    Vector128<byte> arr2_vals = Vector128.LoadUnsafe(ref _arr2[i]);
+
+                    bool allEqual = Vector128.EqualsAll(arr1_vals, arr2_vals);
+
+                    if (!allEqual)
+                    {
+                        break;
+                    }
+                }
+
+                // fall back to scalar for remaining values
+                for (; i < Size; i++)
+                {
+                    if (_arr1[i] != _arr2[i])
+                        return _arr1[i] - _arr2[i];
+                }
+                return 0;
+            }
+
+            Debug.Assert(false, "Different array lengths are not expected");
+            return 0;
+        }
+
+
+        [Benchmark]
+        public unsafe long SveStrCmp()
+        {
+            if (Sve.IsSupported)
+            {
+                int i = 0;
+                int elemsInVector = (int)Sve.Count8BitElements();
+
+                Vector<byte> ptrue = Sve.CreateTrueMaskByte();
+                Vector<byte> pLoop = (Vector<byte>)Sve.CreateWhileLessThanMask8Bit(i, Size);
+                Vector<byte> cmp = Vector<byte>.Zero;
+                Vector<byte> arr1_data, arr2_data;
+
+                if (_arr1.Length == _arr2.Length)
+                {
+                    fixed (byte* arr1_ptr = _arr1, arr2_ptr = _arr2)
+                    {
+                        while (Sve.TestFirstTrue(ptrue, pLoop))
+                        {
+                            arr1_data = Sve.LoadVector(pLoop, arr1_ptr + i);
+                            arr2_data = Sve.LoadVector(pLoop, arr2_ptr + i);
+
+                            // stop if any values arent equal
+                            cmp = Sve.CompareNotEqualTo(arr1_data, arr2_data);
+
+                            if (Sve.TestAnyTrue(ptrue, cmp))
+                                break;
+
+                            i += elemsInVector;
+
+                            pLoop = (Vector<byte>)Sve.CreateWhileLessThanMask8Bit(i, Size);
+                        }
+
+                        // create a bitmask to find position of changed value
+                        int mask = 0;
+                        for (int j = 0; j < elemsInVector; j++)
+                        {
+                            // set bits in lanes with non zero elements
+                            if (cmp.GetElement(j) != 0)
+                                mask |= (1 << j);
+                        }
+
+                        int zeroCount = BitOperations.TrailingZeroCount(mask);
+
+                        if (zeroCount < elemsInVector)
+                            return _arr1[i + zeroCount] - _arr2[i + zeroCount];
+
+                        return 0;
+                    }
+                }
+
+                Debug.Assert(false, "Different array lengths are not expected");
+                return 0;
+            }
+            return 0;
+        }
+
+        [Benchmark]
+        public unsafe long SveTail()
+        {
+            if (Sve.IsSupported)
+            {
+                Vector<byte> ptrue = Sve.CreateTrueMaskByte();
+                Vector<byte> cmp;
+                Vector<byte> arr1_data, arr2_data;
+
+                int i = 0;
+                int elemsInVector = (int)Sve.Count8BitElements();
+
+                if (_arr1.Length == _arr2.Length)
+                {
+                    fixed (byte* arr1_ptr = _arr1, arr2_ptr = _arr2)
+                    {
+                        for (; i <= Size - elemsInVector; i += elemsInVector)
+                        {
+                            arr1_data = Sve.LoadVector(ptrue, arr1_ptr + i);
+                            arr2_data = Sve.LoadVector(ptrue, arr2_ptr + i);
+
+                            cmp = Sve.CompareNotEqualTo(arr1_data, arr2_data);
+
+                            byte allEqual = (byte)Sve.AddAcross(cmp).ToScalar();
+
+                            if (allEqual > 0)
+                            {
+                                break;
+                            }
+                        }
+
+                        for (; i < Size; i++)
+                        {
+                            if (_arr1[i] != _arr2[i])
+                                return _arr1[i] - _arr2[i];
+                        }
+
+                        return 0;
+                    }
+                }
+
+                Debug.Assert(false, "Different array lengths are not expected");
+                return 0;
+            }
+
+            return 0;
+        }
+    }
+}
+
+#pragma warning restore SYSLIB5003