Performance improvement in Count<T> extension (#3548)

## PR Type
What kind of change does this PR introduce?
<!-- Please uncomment one or more that apply to this PR. -->

- Performance improvement
<!-- - Bugfix -->
<!-- - Feature -->
<!-- - Code style update (formatting) -->
<!-- - Refactoring (no functional changes, no api changes) -->
<!-- - Build or CI related changes -->
<!-- - Documentation content changes -->
<!-- - Sample app changes -->
<!-- - Other... Please describe: -->

## What is the new behavior?
<!-- Describe how was this issue resolved or changed? -->
About 20% improvement on .NET 5 when working on `char` types (or larger):

![image](https://user-images.githubusercontent.com/10199417/97509236-ff526e80-1981-11eb-8a90-f8aa72f1551e.png)

This was done by adding an unrolled loop for the vectorized path of the SIMD accelerated version of `Count<T>`.

## PR Checklist

Please check if your PR fulfills the following requirements:

- [X] Tested code with current [supported SDKs](../readme.md#supported)
- [ ] ~~Pull Request has been submitted to the documentation repository [instructions](..\contributing.md#docs). Link: <!-- docs PR link -->~~
- [ ] ~~Sample in sample app has been added / updated (for bug fixes / features)~~
    - [ ] ~~Icon has been created (if new sample) following the [Thumbnail Style Guide and templates](https://github.com/windows-toolkit/WindowsCommunityToolkit-design-assets)~~
- [X] Tests for the changes have been added (for bug fixes / features) (if applicable)
- [X] Header has been added to all new source files (run *build/UpdateHeaders.bat*)
- [X] Contains **NO** breaking changes

Author: msftbot[bot]

Microsoft.Toolkit.HighPerformance/Helpers/Internals/SpanHelper.Count.cs

@@ -79,9 +79,6 @@ public static nint Count<T>(ref T r0, nint length, T value)
         /// Implements <see cref="Count{T}"/> with a sequential search.
         /// </summary>
         [Pure]
-#if NETCOREAPP3_1
-        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
-#endif
         private static nint CountSequential<T>(ref T r0, nint length, T value)
             where T : IEquatable<T>
         {
@@ -132,9 +129,6 @@ private static nint CountSequential<T>(ref T r0, nint length, T value)
         /// Implements <see cref="Count{T}"/> with a vectorized search.
         /// </summary>
         [Pure]
-#if NETCOREAPP3_1
-        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
-#endif
         private static nint CountSimd<T>(ref T r0, nint length, T value)
             where T : unmanaged, IEquatable<T>
         {
@@ -161,6 +155,67 @@ private static nint CountSimd<T>(ref T r0, nint length, T value)
 
                     var partials = Vector<T>.Zero;
 
+                    // Unrolled vectorized loop, with 8 unrolled iterations. We only run this when the
+                    // current type T is at least 2 bytes in size, otherwise the average chunk length
+                    // would always be too small to be able to trigger the unrolled loop, and the overall
+                    // performance would just be slightly worse due to the additional conditional branches.
+                    if (typeof(T) != typeof(sbyte))
+                    {
+                        while (chunkLength >= Vector<T>.Count * 8)
+                        {
+                            ref T ri0 = ref Unsafe.Add(ref r0, offset + (Vector<T>.Count * 0));
+                            var vi0 = Unsafe.As<T, Vector<T>>(ref ri0);
+                            var ve0 = Vector.Equals(vi0, vc);
+
+                            partials -= ve0;
+
+                            ref T ri1 = ref Unsafe.Add(ref r0, offset + (Vector<T>.Count * 1));
+                            var vi1 = Unsafe.As<T, Vector<T>>(ref ri1);
+                            var ve1 = Vector.Equals(vi1, vc);
+
+                            partials -= ve1;
+
+                            ref T ri2 = ref Unsafe.Add(ref r0, offset + (Vector<T>.Count * 2));
+                            var vi2 = Unsafe.As<T, Vector<T>>(ref ri2);
+                            var ve2 = Vector.Equals(vi2, vc);
+
+                            partials -= ve2;
+
+                            ref T ri3 = ref Unsafe.Add(ref r0, offset + (Vector<T>.Count * 3));
+                            var vi3 = Unsafe.As<T, Vector<T>>(ref ri3);
+                            var ve3 = Vector.Equals(vi3, vc);
+
+                            partials -= ve3;
+
+                            ref T ri4 = ref Unsafe.Add(ref r0, offset + (Vector<T>.Count * 4));
+                            var vi4 = Unsafe.As<T, Vector<T>>(ref ri4);
+                            var ve4 = Vector.Equals(vi4, vc);
+
+                            partials -= ve4;
+
+                            ref T ri5 = ref Unsafe.Add(ref r0, offset + (Vector<T>.Count * 5));
+                            var vi5 = Unsafe.As<T, Vector<T>>(ref ri5);
+                            var ve5 = Vector.Equals(vi5, vc);
+
+                            partials -= ve5;
+
+                            ref T ri6 = ref Unsafe.Add(ref r0, offset + (Vector<T>.Count * 6));
+                            var vi6 = Unsafe.As<T, Vector<T>>(ref ri6);
+                            var ve6 = Vector.Equals(vi6, vc);
+
+                            partials -= ve6;
+
+                            ref T ri7 = ref Unsafe.Add(ref r0, offset + (Vector<T>.Count * 7));
+                            var vi7 = Unsafe.As<T, Vector<T>>(ref ri7);
+                            var ve7 = Vector.Equals(vi7, vc);
+
+                            partials -= ve7;
+
+                            chunkLength -= Vector<T>.Count * 8;
+                            offset += Vector<T>.Count * 8;
+                        }
+                    }
+
                     while (chunkLength >= Vector<T>.Count)
                     {
                         ref T ri = ref Unsafe.Add(ref r0, offset);
@@ -242,28 +297,22 @@ private static nint CountSimd<T>(ref T r0, nint length, T value)
         private static unsafe nint GetUpperBound<T>()
             where T : unmanaged
         {
-            if (typeof(T) == typeof(byte) ||
-                typeof(T) == typeof(sbyte) ||
-                typeof(T) == typeof(bool))
+            if (typeof(T) == typeof(sbyte))
             {
                 return sbyte.MaxValue;
             }
 
-            if (typeof(T) == typeof(char) ||
-                typeof(T) == typeof(ushort) ||
-                typeof(T) == typeof(short))
+            if (typeof(T) == typeof(short))
             {
                 return short.MaxValue;
             }
 
-            if (typeof(T) == typeof(int) ||
-                typeof(T) == typeof(uint))
+            if (typeof(T) == typeof(int))
             {
                 return int.MaxValue;
             }
 
-            if (typeof(T) == typeof(long) ||
-                typeof(T) == typeof(ulong))
+            if (typeof(T) == typeof(long))
             {
                 if (sizeof(nint) == sizeof(int))
                 {

Microsoft.Toolkit.HighPerformance/Helpers/Internals/SpanHelper.Hash.cs

@@ -21,9 +21,6 @@ internal static partial class SpanHelper
         /// <param name="length">The number of items to hash.</param>
         /// <returns>The Djb2 value for the input sequence of items.</returns>
         [Pure]
-#if NETCOREAPP3_1
-        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
-#endif
         public static int GetDjb2HashCode<T>(ref T r0, nint length)
             where T : notnull
         {
@@ -87,9 +84,6 @@ public static int GetDjb2HashCode<T>(ref T r0, nint length)
         /// faster than <see cref="GetDjb2HashCode{T}"/>, as it can parallelize much of the workload.
         /// </remarks>
         [Pure]
-#if NETCOREAPP3_1
-        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
-#endif
         public static unsafe int GetDjb2LikeByteHash(ref byte r0, nint length)
         {
             int hash = 5381;