[wasm] Add few Span and String measurements (#79566)

Measure Span<T> SequenceEqual for bytes and chars
Measure string.Normalize for ASCII and non-ASCII

Author: radekdoulik

src/mono/sample/wasm/browser-bench/Span.cs

@@ -19,6 +19,8 @@ public SpanTask()
                 new ReverseChar(),
                 new IndexOfByte(),
                 new IndexOfChar(),
+                new SequenceEqualByte(),
+                new SequenceEqualChar(),
             };
         }
 
@@ -39,7 +41,7 @@ public abstract class SpanMeasurement : BenchTask.Measurement
         abstract class SpanByteMeasurement : SpanMeasurement
         {
             protected byte[] data;
-            int len = 64 * 1024;
+            protected int len = 64 * 1024;
 
             public override Task BeforeBatch()
             {
@@ -77,14 +79,14 @@ class IndexOfByte : SpanByteMeasurement
             public override void RunStep()
             {
                 var span = new Span<byte>(data);
-                span.IndexOf<byte> ((byte)random.Next(256));
+                span.IndexOf<byte>((byte)random.Next(256));
             }
         }
 
         abstract class SpanCharMeasurement : SpanMeasurement
         {
             protected char[] data;
-            int len = 64 * 1024;
+            protected int len = 64 * 1024;
 
             public override Task BeforeBatch()
             {
@@ -123,5 +125,75 @@ public override void RunStep()
                 span.IndexOf<char>((char)random.Next(0x10000));
             }
         }
+
+        class SequenceEqualByte : SpanByteMeasurement
+        {
+            public override string Name => "SequenceEqual bytes";
+
+            protected byte[] data2;
+
+            public override Task BeforeBatch()
+            {
+                base.BeforeBatch();
+
+                data2 = new byte[len];
+                random = new(234567);
+                for (int i = 0; i < len; i++)
+                    data2[i] = (i < 3 * len / 4) ? data[i] : (byte)random.Next(0x100);
+
+                return Task.CompletedTask;
+            }
+
+            public override Task AfterBatch()
+            {
+                base.AfterBatch();
+
+                data2 = null;
+
+                return Task.CompletedTask;
+            }
+
+            public override void RunStep()
+            {
+                var span = new Span<byte>(data);
+                var span2 = new ReadOnlySpan<byte>(data2);
+                span.SequenceEqual(span2);
+            }
+        }
+
+        class SequenceEqualChar : SpanCharMeasurement
+        {
+            public override string Name => "SequenceEqual chars";
+
+            protected char[] data2;
+
+            public override Task BeforeBatch()
+            {
+                base.BeforeBatch();
+
+                data2 = new char[len];
+                random = new(234567);
+                for (int i = 0; i < len; i++)
+                    data2[i] = (i < 3 * len / 4) ? data[i] : (char)random.Next(0x10000);
+
+                return Task.CompletedTask;
+            }
+
+            public override Task AfterBatch()
+            {
+                base.AfterBatch();
+
+                data2 = null;
+
+                return Task.CompletedTask;
+            }
+
+            public override void RunStep()
+            {
+                var span = new Span<char>(data);
+                var span2 = new ReadOnlySpan<char>(data2);
+                span.SequenceEqual(span2);
+            }
+        }
     }
 }

src/mono/sample/wasm/browser-bench/String.cs

@@ -0,0 +1,89 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+
+namespace Sample
+{
+    class StringTask : BenchTask
+    {
+        public override string Name => "String";
+        Measurement[] measurements;
+
+        public StringTask()
+        {
+            measurements = new Measurement[] {
+                new NormalizeMeasurement(),
+                new NormalizeMeasurementASCII(),
+            };
+        }
+
+        public override Measurement[] Measurements
+        {
+            get
+            {
+                return measurements;
+            }
+        }
+
+        public abstract class StringMeasurement : BenchTask.Measurement
+        {
+            public override int InitialSamples => 30;
+            protected Random random;
+        }
+
+        public class NormalizeMeasurement : StringMeasurement
+        {
+            protected char[] data;
+            protected int len = 64 * 1024;
+            protected string str;
+
+            public override Task BeforeBatch()
+            {
+                data = new char[len];
+                random = new(123456);
+                for (int i = 0; i < len; i++)
+                {
+                    data[i] = (char)random.Next(0xd800);
+                }
+
+                str = new string(data);
+
+                return Task.CompletedTask;
+            }
+
+            public override Task AfterBatch()
+            {
+                data = null;
+
+                return Task.CompletedTask;
+            }
+
+            public override string Name => "Normalize";
+
+            public override void RunStep()
+            {
+                str.Normalize();
+            }
+        }
+
+        public class NormalizeMeasurementASCII : NormalizeMeasurement
+        {
+            public override Task BeforeBatch()
+            {
+                data = new char[len];
+                random = new(123456);
+                for (int i = 0; i < len; i++)
+                    data[i] = (char)random.Next(0x80);
+
+                str = new string(data);
+
+                return Task.CompletedTask;
+            }
+
+            public override string Name => "Normalize ASCII";
+        }
+    }
+}