Codegen improvements (removed unnecessary movsxd ops)

Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.2D.cs

@@ -66,13 +66,13 @@ public static ref T DangerousGetReference<T>(this T[,] array)
         /// </remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ref T DangerousGetReferenceAt<T>(this T[,] array, int i, int j)
+        public static unsafe ref T DangerousGetReferenceAt<T>(this T[,] array, int i, int j)
         {
 #if NETCORE_RUNTIME
             var arrayData = Unsafe.As<RawArray2DData>(array);
             int offset = (i * arrayData.Width) + j;
             ref T r0 = ref Unsafe.As<byte, T>(ref arrayData.Data);
-            ref T ri = ref Unsafe.Add(ref r0, offset);
+            ref T ri = ref Unsafe.Add(ref r0, (IntPtr)(void*)(uint)offset);
 
             return ref ri;
 #else
@@ -82,10 +82,7 @@ public static ref T DangerousGetReferenceAt<T>(this T[,] array, int i, int j)
                 return ref array[i, j];
             }
 
-            unsafe
-            {
-                return ref Unsafe.AsRef<T>(null);
-            }
+            return ref Unsafe.AsRef<T>(null);
 #endif
         }
 
@@ -274,11 +271,11 @@ public static Span<T> AsSpan<T>(this T[,] array)
         /// <returns>The number of occurrences of <paramref name="value"/> in <paramref name="array"/>.</returns>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<T>(this T[,] array, T value)
+        public static unsafe int Count<T>(this T[,] array, T value)
             where T : IEquatable<T>
         {
             ref T r0 = ref array.DangerousGetReference();
-            IntPtr length = (IntPtr)array.Length;
+            IntPtr length = (IntPtr)(void*)(uint)array.Length;
 
             return SpanHelper.Count(ref r0, length, value);
         }
@@ -293,11 +290,11 @@ public static int Count<T>(this T[,] array, T value)
         /// <remarks>The Djb2 hash is fully deterministic and with no random components.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int GetDjb2HashCode<T>(this T[,] array)
+        public static unsafe int GetDjb2HashCode<T>(this T[,] array)
             where T : notnull
         {
             ref T r0 = ref array.DangerousGetReference();
-            IntPtr length = (IntPtr)array.Length;
+            IntPtr length = (IntPtr)(void*)(uint)array.Length;
 
             return SpanHelper.GetDjb2HashCode(ref r0, length);
         }

Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.cs

@@ -62,12 +62,12 @@ public static ref T DangerousGetReference<T>(this T[] array)
         /// <remarks>This method doesn't do any bounds checks, therefore it is responsibility of the caller to ensure the <paramref name="i"/> parameter is valid.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ref T DangerousGetReferenceAt<T>(this T[] array, int i)
+        public static unsafe ref T DangerousGetReferenceAt<T>(this T[] array, int i)
         {
 #if NETCORE_RUNTIME
             var arrayData = Unsafe.As<RawArrayData>(array);
             ref T r0 = ref Unsafe.As<byte, T>(ref arrayData.Data);
-            ref T ri = ref Unsafe.Add(ref r0, i);
+            ref T ri = ref Unsafe.Add(ref r0, (IntPtr)(void*)(uint)i);
 
             return ref ri;
 #else
@@ -76,10 +76,7 @@ public static ref T DangerousGetReferenceAt<T>(this T[] array, int i)
                 return ref array[i];
             }
 
-            unsafe
-            {
-                return ref Unsafe.AsRef<T>(null);
-            }
+            return ref Unsafe.AsRef<T>(null);
 #endif
         }
 
@@ -114,11 +111,11 @@ private sealed class RawArrayData
         /// <returns>The number of occurrences of <paramref name="value"/> in <paramref name="array"/>.</returns>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<T>(this T[] array, T value)
+        public static unsafe int Count<T>(this T[] array, T value)
             where T : IEquatable<T>
         {
             ref T r0 = ref array.DangerousGetReference();
-            IntPtr length = (IntPtr)array.Length;
+            IntPtr length = (IntPtr)(void*)(uint)array.Length;
 
             return SpanHelper.Count(ref r0, length, value);
         }
@@ -185,11 +182,11 @@ public static SpanTokenizer<T> Tokenize<T>(this T[] array, T separator)
         /// <remarks>The Djb2 hash is fully deterministic and with no random components.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int GetDjb2HashCode<T>(this T[] array)
+        public static unsafe int GetDjb2HashCode<T>(this T[] array)
             where T : notnull
         {
             ref T r0 = ref array.DangerousGetReference();
-            IntPtr length = (IntPtr)array.Length;
+            IntPtr length = (IntPtr)(void*)(uint)array.Length;
 
             return SpanHelper.GetDjb2HashCode(ref r0, length);
         }

Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlySpanExtensions.cs

@@ -40,10 +40,40 @@ public static ref T DangerousGetReference<T>(this ReadOnlySpan<T> span)
         /// <remarks>This method doesn't do any bounds checks, therefore it is responsibility of the caller to ensure the <paramref name="i"/> parameter is valid.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ref T DangerousGetReferenceAt<T>(this ReadOnlySpan<T> span, int i)
+        public static unsafe ref T DangerousGetReferenceAt<T>(this ReadOnlySpan<T> span, int i)
         {
+            // Here we assume the input index will never be negative, so we do an unsafe cast to
+            // force the JIT to skip the sign extension when going from int to native int.
+            // On .NET Core 3.1, if we only use Unsafe.Add(ref r0, i), we get the following:
+            // =============================
+            // L0000: mov rax, [rcx]
+            // L0003: movsxd rdx, edx
+            // L0006: lea rax, [rax+rdx*4]
+            // L000a: ret
+            // =============================
+            // Note the movsxd (move with sign extension) to expand the index passed in edx to
+            // the whole rdx register. This is unnecessary and more expensive than just a mov,
+            // which when done to a large register size automatically zeroes the upper bits.
+            // With the (IntPtr)(void*)(uint) cast, we get the following codegen instead:
+            // =============================
+            // L0000: mov rax, [rcx]
+            // L0003: mov edx, edx
+            // L0005: lea rax, [rax+rdx*4]
+            // L0009: ret
+            // =============================
+            // Here we can see how the index is extended to a native integer with just a mov,
+            // which effectively only zeroes the upper bits of the same register used as source.
+            // These three casts are a bit verbose, but they do the trick on both 32 bit and 64
+            // bit architectures, producing optimal code in both cases (they are either completely
+            // elided on 32 bit systems, or result in the correct register expansion when on 64 bit).
+            // We first do an unchecked conversion to uint (which is just a reinterpret-cast). We
+            // then cast to void*, which lets the following IntPtr cast avoid the range check on 32 bit
+            // (since uint could be out of range there if the original index was negative). The final
+            // result is a clean mov as shown above. This will eventually be natively supported by the
+            // JIT compiler (see https://github.com/dotnet/runtime/issues/38794), but doing this here
+            // still ensures the optimal codegen even on existing runtimes (eg. .NET Core 2.1 and 3.1).
             ref T r0 = ref MemoryMarshal.GetReference(span);
-            ref T ri = ref Unsafe.Add(ref r0, i);
+            ref T ri = ref Unsafe.Add(ref r0, (IntPtr)(void*)(uint)i);
 
             return ref ri;
         }
@@ -87,7 +117,7 @@ public static ref T DangerousGetReferenceAt<T>(this ReadOnlySpan<T> span, int i)
         /// </returns>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ref readonly T DangerousGetLookupReferenceAt<T>(this ReadOnlySpan<T> span, int i)
+        public static unsafe ref readonly T DangerousGetLookupReferenceAt<T>(this ReadOnlySpan<T> span, int i)
         {
             // Check whether the input is in range by first casting both
             // operands to uint and then comparing them, as this allows
@@ -106,12 +136,12 @@ public static ref readonly T DangerousGetLookupReferenceAt<T>(this ReadOnlySpan<
             // lookup table can just be assumed to always be false.
             bool isInRange = (uint)i < (uint)span.Length;
             byte rangeFlag = Unsafe.As<bool, byte>(ref isInRange);
-            int
-                negativeFlag = rangeFlag - 1,
+            uint
+                negativeFlag = unchecked(rangeFlag - 1u),
                 mask = ~negativeFlag,
-                offset = i & mask;
+                offset = (uint)i & mask;
             ref T r0 = ref MemoryMarshal.GetReference(span);
-            ref T r1 = ref Unsafe.Add(ref r0, offset);
+            ref T r1 = ref Unsafe.Add(ref r0, (IntPtr)(void*)offset);
 
             return ref r1;
         }
@@ -165,11 +195,11 @@ public static unsafe int IndexOf<T>(this ReadOnlySpan<T> span, in T value)
         /// <returns>The number of occurrences of <paramref name="value"/> in <paramref name="span"/>.</returns>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<T>(this ReadOnlySpan<T> span, T value)
+        public static unsafe int Count<T>(this ReadOnlySpan<T> span, T value)
             where T : IEquatable<T>
         {
             ref T r0 = ref MemoryMarshal.GetReference(span);
-            IntPtr length = (IntPtr)span.Length;
+            IntPtr length = (IntPtr)(void*)(uint)span.Length;
 
             return SpanHelper.Count(ref r0, length, value);
         }
@@ -291,11 +321,11 @@ public static ReadOnlySpanTokenizer<T> Tokenize<T>(this ReadOnlySpan<T> span, T
         /// <remarks>The Djb2 hash is fully deterministic and with no random components.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int GetDjb2HashCode<T>(this ReadOnlySpan<T> span)
+        public static unsafe int GetDjb2HashCode<T>(this ReadOnlySpan<T> span)
             where T : notnull
         {
             ref T r0 = ref MemoryMarshal.GetReference(span);
-            IntPtr length = (IntPtr)span.Length;
+            IntPtr length = (IntPtr)(void*)(uint)span.Length;
 
             return SpanHelper.GetDjb2HashCode(ref r0, length);
         }

Microsoft.Toolkit.HighPerformance/Extensions/SpanExtensions.cs

@@ -40,10 +40,10 @@ public static ref T DangerousGetReference<T>(this Span<T> span)
         /// <remarks>This method doesn't do any bounds checks, therefore it is responsibility of the caller to ensure the <paramref name="i"/> parameter is valid.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ref T DangerousGetReferenceAt<T>(this Span<T> span, int i)
+        public static unsafe ref T DangerousGetReferenceAt<T>(this Span<T> span, int i)
         {
             ref T r0 = ref MemoryMarshal.GetReference(span);
-            ref T ri = ref Unsafe.Add(ref r0, i);
+            ref T ri = ref Unsafe.Add(ref r0, (IntPtr)(void*)(uint)i);
 
             return ref ri;
         }
@@ -140,11 +140,11 @@ public static unsafe int IndexOf<T>(this Span<T> span, ref T value)
         /// <returns>The number of occurrences of <paramref name="value"/> in <paramref name="span"/>.</returns>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<T>(this Span<T> span, T value)
+        public static unsafe int Count<T>(this Span<T> span, T value)
             where T : IEquatable<T>
         {
             ref T r0 = ref MemoryMarshal.GetReference(span);
-            IntPtr length = (IntPtr)span.Length;
+            IntPtr length = (IntPtr)(void*)(uint)span.Length;
 
             return SpanHelper.Count(ref r0, length, value);
         }
@@ -211,11 +211,11 @@ public static SpanTokenizer<T> Tokenize<T>(this Span<T> span, T separator)
         /// <remarks>The Djb2 hash is fully deterministic and with no random components.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int GetDjb2HashCode<T>(this Span<T> span)
+        public static unsafe int GetDjb2HashCode<T>(this Span<T> span)
             where T : notnull
         {
             ref T r0 = ref MemoryMarshal.GetReference(span);
-            IntPtr length = (IntPtr)span.Length;
+            IntPtr length = (IntPtr)(void*)(uint)span.Length;
 
             return SpanHelper.GetDjb2HashCode(ref r0, length);
         }

Microsoft.Toolkit.HighPerformance/Extensions/StringExtensions.cs

@@ -48,7 +48,7 @@ public static ref char DangerousGetReference(this string text)
         /// <remarks>This method doesn't do any bounds checks, therefore it is responsibility of the caller to ensure the <paramref name="i"/> parameter is valid.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ref char DangerousGetReferenceAt(this string text, int i)
+        public static unsafe ref char DangerousGetReferenceAt(this string text, int i)
         {
 #if NETCOREAPP3_1
             ref char r0 = ref Unsafe.AsRef(text.GetPinnableReference());
@@ -57,7 +57,7 @@ public static ref char DangerousGetReferenceAt(this string text, int i)
 #else
             ref char r0 = ref MemoryMarshal.GetReference(text.AsSpan());
 #endif
-            ref char ri = ref Unsafe.Add(ref r0, i);
+            ref char ri = ref Unsafe.Add(ref r0, (IntPtr)(void*)(uint)i);
 
             return ref ri;
         }
@@ -91,10 +91,10 @@ private sealed class RawStringData
         /// <returns>The number of occurrences of <paramref name="c"/> in <paramref name="text"/>.</returns>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count(this string text, char c)
+        public static unsafe int Count(this string text, char c)
         {
             ref char r0 = ref text.DangerousGetReference();
-            IntPtr length = (IntPtr)text.Length;
+            IntPtr length = (IntPtr)(void*)(uint)text.Length;
 
             return SpanHelper.Count(ref r0, length, c);
         }
@@ -157,10 +157,10 @@ public static ReadOnlySpanTokenizer<char> Tokenize(this string text, char separa
         /// <remarks>The Djb2 hash is fully deterministic and with no random components.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int GetDjb2HashCode(this string text)
+        public static unsafe int GetDjb2HashCode(this string text)
         {
             ref char r0 = ref text.DangerousGetReference();
-            IntPtr length = (IntPtr)text.Length;
+            IntPtr length = (IntPtr)(void*)(uint)text.Length;
 
             return SpanHelper.GetDjb2HashCode(ref r0, length);
         }

Microsoft.Toolkit.HighPerformance/Helpers/HashCode{T}.cs

@@ -57,7 +57,7 @@ public static int Combine(ReadOnlySpan<T> span)
         /// <remarks>The returned hash code is not processed through <see cref="HashCode"/> APIs.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static int CombineValues(ReadOnlySpan<T> span)
+        internal static unsafe int CombineValues(ReadOnlySpan<T> span)
         {
             ref T r0 = ref MemoryMarshal.GetReference(span);
 
@@ -67,13 +67,19 @@ internal static int CombineValues(ReadOnlySpan<T> span)
             // compiler, so this branch will never actually be executed by the code.
             if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
             {
-                return SpanHelper.GetDjb2HashCode(ref r0, (IntPtr)span.Length);
+                return SpanHelper.GetDjb2HashCode(ref r0, (IntPtr)(void*)(uint)span.Length);
             }
 #endif
 
-            // Get the info for the target memory area to process
+            // Get the info for the target memory area to process.
+            // The line below is computing the total byte size for the span,
+            // and we cast both input factors to uint first to avoid sign extensions
+            // (they're both guaranteed to always be positive values), and to let the
+            // JIT avoid the 64 bit computation entirely when running in a 32 bit
+            // process. In that case it will just compute the byte size as a 32 bit
+            // multiplication with overflow, which is guaranteed never to happen anyway.
             ref byte rb = ref Unsafe.As<T, byte>(ref r0);
-            IntPtr length = (IntPtr)((long)span.Length * Unsafe.SizeOf<T>());
+            IntPtr length = (IntPtr)(void*)((uint)span.Length * (uint)Unsafe.SizeOf<T>());
 
             return SpanHelper.GetDjb2LikeByteHash(ref rb, length);
         }

Microsoft.Toolkit.HighPerformance/Helpers/ParallelHelper.ForEach.IInAction.cs

@@ -136,7 +136,7 @@ public InActionInvoker(
             /// </summary>
             /// <param name="i">The index of the batch to process</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void Invoke(int i)
+            public unsafe void Invoke(int i)
             {
                 int
                     low = i * this.batchSize,
@@ -147,7 +147,7 @@ public void Invoke(int i)
 
                 for (int j = low; j < end; j++)
                 {
-                    ref TItem rj = ref Unsafe.Add(ref r0, j);
+                    ref TItem rj = ref Unsafe.Add(ref r0, (IntPtr)(void*)(uint)j);
 
                     Unsafe.AsRef(this.action).Invoke(rj);
                 }

Microsoft.Toolkit.HighPerformance/Helpers/ParallelHelper.ForEach.IRefAction.cs

@@ -136,7 +136,7 @@ public RefActionInvoker(
             /// </summary>
             /// <param name="i">The index of the batch to process</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void Invoke(int i)
+            public unsafe void Invoke(int i)
             {
                 int
                     low = i * this.batchSize,
@@ -147,7 +147,7 @@ public void Invoke(int i)
 
                 for (int j = low; j < end; j++)
                 {
-                    ref TItem rj = ref Unsafe.Add(ref r0, j);
+                    ref TItem rj = ref Unsafe.Add(ref r0, (IntPtr)(void*)(uint)j);
 
                     Unsafe.AsRef(this.action).Invoke(ref rj);
                 }

Microsoft.Toolkit.HighPerformance/Microsoft.Toolkit.HighPerformance.csproj

@@ -12,6 +12,7 @@
       - MemoryBufferWriter<T>: an IBufferWriter<T>: implementation that can wrap external Memory<T>: instances.
       - MemoryOwner<T>: an IMemoryOwner<T> implementation with an embedded length and a fast Span<T> accessor.
       - SpanOwner<T>: a stack-only type with the ability to rent a buffer of a specified length and getting a Span<T> from it.
+      - StringPool: a configurable pool for string instances that be used to minimize allocations when creating multiple strings from char buffers.
       - String, array, Span<T>, Memory<T> extensions and more, all focused on high performance.
       - HashCode<T>: a SIMD-enabled extension of HashCode to quickly process sequences of values.
       - BitHelper: a class with helper methods to perform bit operations on numeric types.