Port SequentialEqual() optimizations to ReadOnlySpan overloads (#28073)

Author: atsushikan

src/Common/src/CoreLib/System/MemoryExtensions.cs

@@ -635,12 +635,34 @@ public static bool SequenceEqual<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T>
             where T : IEquatable<T>
         {
             int length = first.Length;
-            if (typeof(T) == typeof(byte))
+            if (typeof(T) == typeof(byte) || typeof(T) == typeof(sbyte))
                 return length == second.Length &&
                 SpanHelpers.SequenceEqual(
                     ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(first)),
                     ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(second)),
                     length);
+
+            if (typeof(T) == typeof(char) || typeof(T) == typeof(short) || typeof(T) == typeof(ushort))
+                return length == second.Length &&
+                SpanHelpers.SequenceEqualBytes(
+                    ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(first)),
+                    ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(second)),
+                    ((nuint)length) * 2); // If this multiplication overflows, the Span we got overflows the entire address range. There's no happy outcome for this api in such a case so we choose not to take the overhead of checking. 
+
+            if (typeof(T) == typeof(int) || typeof(T) == typeof(uint))
+                return length == second.Length &&
+                SpanHelpers.SequenceEqualBytes(
+                    ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(first)),
+                    ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(second)),
+                    ((nuint)length) * 4); // If this multiplication overflows, the Span we got overflows the entire address range. There's no happy outcome for this api in such a case so we choose not to take the overhead of checking. 
+
+            if (typeof(T) == typeof(long) || typeof(T) == typeof(ulong))
+                return length == second.Length &&
+                SpanHelpers.SequenceEqualBytes(
+                    ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(first)),
+                    ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(second)),
+                    ((nuint)length) * 8); // If this multiplication overflows, the Span we got overflows the entire address range. There's no happy outcome for this api in such a case so we choose not to take the overhead of checking. 
+
             return length == second.Length && SpanHelpers.SequenceEqual(ref MemoryMarshal.GetReference(first), ref MemoryMarshal.GetReference(second), length);
         }
 

src/System.Memory/tests/ReadOnlySpan/SequenceEqual.long.cs

@@ -0,0 +1,104 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Xunit;
+
+namespace System.SpanTests
+{
+    public static partial class ReadOnlySpanTests
+    {
+        [Fact]
+        public static void ZeroLengthSequenceEqual_Long()
+        {
+            long[] a = new long[3];
+
+            ReadOnlySpan<long> first = new ReadOnlySpan<long>(a, 1, 0);
+            ReadOnlySpan<long> second = new ReadOnlySpan<long>(a, 2, 0);
+            bool b = first.SequenceEqual<long>(second);
+            Assert.True(b);
+        }
+
+        [Fact]
+        public static void SameSpanSequenceEqual_Long()
+        {
+            long[] a = { 488238291, 52498989823, 619890289890 };
+            ReadOnlySpan<long> span = new ReadOnlySpan<long>(a);
+            bool b = span.SequenceEqual<long>(span);
+            Assert.True(b);
+        }
+
+        [Fact]
+        public static void SequenceEqualArrayImplicit_Long()
+        {
+            long[] a = { 488238291, 52498989823, 619890289890 };
+            ReadOnlySpan<long> first = new ReadOnlySpan<long>(a, 0, 3);
+            bool b = first.SequenceEqual<long>(a);
+            Assert.True(b);
+        }
+
+        [Fact]
+        public static void SequenceEqualArraySegmentImplicit_Long()
+        {
+            long[] src = { 1989089123, 234523454235, 3123213231 };
+            long[] dst = { 5, 1989089123, 234523454235, 3123213231, 10 };
+            ArraySegment<long> segment = new ArraySegment<long>(dst, 1, 3);
+
+            ReadOnlySpan<long> first = new ReadOnlySpan<long>(src, 0, 3);
+            bool b = first.SequenceEqual<long>(segment);
+            Assert.True(b);
+        }
+
+        [Fact]
+        public static void LengthMismatchSequenceEqual_Long()
+        {
+            long[] a = { 488238291, 52498989823, 619890289890 };
+            ReadOnlySpan<long> first = new ReadOnlySpan<long>(a, 0, 3);
+            ReadOnlySpan<long> second = new ReadOnlySpan<long>(a, 0, 2);
+            bool b = first.SequenceEqual<long>(second);
+            Assert.False(b);
+        }
+
+        [Fact]
+        public static void SequenceEqualNoMatch_Long()
+        {
+            for (int length = 1; length < 32; length++)
+            {
+                for (int mismatchIndex = 0; mismatchIndex < length; mismatchIndex++)
+                {
+                    long[] first = new long[length];
+                    long[] second = new long[length];
+                    for (int i = 0; i < length; i++)
+                    {
+                        first[i] = second[i] = (byte)(i + 1);
+                    }
+
+                    second[mismatchIndex] = (byte)(second[mismatchIndex] + 1);
+
+                    ReadOnlySpan<long> firstSpan = new ReadOnlySpan<long>(first);
+                    ReadOnlySpan<long> secondSpan = new ReadOnlySpan<long>(second);
+                    bool b = firstSpan.SequenceEqual<long>(secondSpan);
+                    Assert.False(b);
+                }
+            }
+        }
+
+        [Fact]
+        public static void MakeSureNoSequenceEqualChecksGoOutOfRange_Long()
+        {
+            for (int length = 0; length < 100; length++)
+            {
+                long[] first = new long[length + 2];
+                first[0] = 99;
+                first[length + 1] = 99;
+                long[] second = new long[length + 2];
+                second[0] = 100;
+                second[length + 1] = 100;
+                ReadOnlySpan<long> span1 = new ReadOnlySpan<long>(first, 1, length);
+                ReadOnlySpan<long> span2 = new ReadOnlySpan<long>(second, 1, length);
+                bool b = span1.SequenceEqual<long>(span2);
+                Assert.True(b);
+            }
+        }
+    }
+}

src/System.Memory/tests/System.Memory.Tests.csproj

@@ -122,6 +122,7 @@
     <Compile Include="ReadOnlySpan\SequenceEqual.T.cs" />
     <Compile Include="ReadOnlySpan\SequenceEqual.byte.cs" />
     <Compile Include="ReadOnlySpan\SequenceEqual.char.cs" />
+    <Compile Include="ReadOnlySpan\SequenceEqual.long.cs" />
     <Compile Include="ReadOnlySpan\Slice.cs" />
     <Compile Include="ReadOnlySpan\StartsWith.byte.cs" />
     <Compile Include="ReadOnlySpan\StartsWith.char.cs" />
@@ -229,4 +230,4 @@
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-</Project>
+</Project>