Avoid repeatedly encoding method name strings in protocol (#41644)

Author: halter73

src/SignalR/server/Core/src/Internal/Utf8HashLookup.cs

@@ -12,50 +12,78 @@ namespace Microsoft.AspNetCore.SignalR.Internal;
 /// </summary>
 internal sealed class Utf8HashLookup
 {
-    private int[] buckets;
-    private Slot[] slots;
-    private int count;
+    private int[] _buckets;
+    private int[] _caseSensitiveBuckets;
+    private Slot[] _slots;
+    private int _count;
 
     private const int HashCodeMask = 0x7fffffff;
 
     internal Utf8HashLookup()
     {
-        buckets = new int[7];
-        slots = new Slot[7];
+        _buckets = new int[7];
+        _caseSensitiveBuckets = new int[7];
+        _slots = new Slot[7];
     }
 
     internal void Add(string value)
     {
-        var hashCode = GetKeyHashCode(value.AsSpan());
-
-        if (count == slots.Length)
+        if (_count == _slots.Length)
         {
             Resize();
         }
 
-        int index = count;
-        count++;
+        int slotIndex = _count;
+        _count++;
+
+        var encodedValue = Encoding.UTF8.GetBytes(value);
+        var hashCode = GetHashCode(value.AsSpan());
+        var caseSensitiveHashCode = GetCaseSensitiveHashCode(encodedValue);
+        int bucketIndex = hashCode % _buckets.Length;
+        int caseSensitiveBucketIndex = caseSensitiveHashCode % _caseSensitiveBuckets.Length;
+
+        _slots[slotIndex].hashCode = hashCode;
+        _slots[slotIndex].caseSensitiveHashCode = caseSensitiveHashCode;
+
+        _slots[slotIndex].value = value;
+        _slots[slotIndex].encodedValue = encodedValue;
+
+        _slots[slotIndex].next = _buckets[bucketIndex] - 1;
+        _slots[slotIndex].caseSensitiveNext = _caseSensitiveBuckets[caseSensitiveBucketIndex] - 1;
+
+        _buckets[bucketIndex] = slotIndex + 1;
+        _caseSensitiveBuckets[caseSensitiveBucketIndex] = slotIndex + 1;
+    }
+
+    internal bool TryGetValue(ReadOnlySpan<byte> encodedValue, [MaybeNullWhen(false), AllowNull] out string value)
+    {
+        var caseSensitiveHashCode = GetCaseSensitiveHashCode(encodedValue);
+
+        for (var i = _caseSensitiveBuckets[caseSensitiveHashCode % _caseSensitiveBuckets.Length] - 1; i >= 0; i = _slots[i].caseSensitiveNext)
+        {
+            if (_slots[i].caseSensitiveHashCode == caseSensitiveHashCode && encodedValue.SequenceEqual(_slots[i].encodedValue.AsSpan()))
+            {
+                value = _slots[i].value;
+                return true;
+            }
+        }
 
-        int bucket = hashCode % buckets.Length;
-        slots[index].hashCode = hashCode;
-        slots[index].key = value;
-        slots[index].value = value;
-        slots[index].next = buckets[bucket] - 1;
-        buckets[bucket] = index + 1;
+        // If we cannot find a case-sensitive match, we transcode the encodedValue to a stackalloced UTF16 string
+        // and do an OrdinalIgnoreCase comparison.
+        return TryGetValueSlow(encodedValue, out value);
     }
 
-    internal bool TryGetValue(ReadOnlySpan<byte> utf8, [MaybeNullWhen(false), AllowNull] out string value)
+    private bool TryGetValueSlow(ReadOnlySpan<byte> encodedValue, [MaybeNullWhen(false), AllowNull] out string value)
     {
         const int StackAllocThreshold = 128;
 
-        // Transcode to utf16 for comparison
         char[]? pooled = null;
-        var count = Encoding.UTF8.GetCharCount(utf8);
+        var count = Encoding.UTF8.GetCharCount(encodedValue);
         var chars = count <= StackAllocThreshold ?
             stackalloc char[StackAllocThreshold] :
             (pooled = ArrayPool<char>.Shared.Rent(count));
-        var encoded = Encoding.UTF8.GetChars(utf8, chars);
-        var hasValue = TryGetValue(chars[..encoded], out value);
+        var encoded = Encoding.UTF8.GetChars(encodedValue, chars);
+        var hasValue = TryGetValueFromChars(chars[..encoded], out value);
         if (pooled is not null)
         {
             ArrayPool<char>.Shared.Return(pooled);
@@ -64,15 +92,15 @@ internal bool TryGetValue(ReadOnlySpan<byte> utf8, [MaybeNullWhen(false), AllowN
         return hasValue;
     }
 
-    private bool TryGetValue(ReadOnlySpan<char> key, [MaybeNullWhen(false), AllowNull] out string value)
+    private bool TryGetValueFromChars(ReadOnlySpan<char> key, [MaybeNullWhen(false), AllowNull] out string value)
     {
-        var hashCode = GetKeyHashCode(key);
+        var hashCode = GetHashCode(key);
 
-        for (var i = buckets[hashCode % buckets.Length] - 1; i >= 0; i = slots[i].next)
+        for (var i = _buckets[hashCode % _buckets.Length] - 1; i >= 0; i = _slots[i].next)
         {
-            if (slots[i].hashCode == hashCode && key.Equals(slots[i].key, StringComparison.OrdinalIgnoreCase))
+            if (_slots[i].hashCode == hashCode && key.Equals(_slots[i].value, StringComparison.OrdinalIgnoreCase))
             {
-                value = slots[i].value;
+                value = _slots[i].value;
                 return true;
             }
         }
@@ -81,32 +109,52 @@ private bool TryGetValue(ReadOnlySpan<char> key, [MaybeNullWhen(false), AllowNul
         return false;
     }
 
-    private static int GetKeyHashCode(ReadOnlySpan<char> key)
+    private static int GetHashCode(ReadOnlySpan<char> value) =>
+        HashCodeMask & string.GetHashCode(value, StringComparison.OrdinalIgnoreCase);
+
+    private static int GetCaseSensitiveHashCode(ReadOnlySpan<byte> encodedValue)
     {
-        return HashCodeMask & string.GetHashCode(key, StringComparison.OrdinalIgnoreCase);
+        var hashCode = new HashCode();
+        hashCode.AddBytes(encodedValue);
+        return HashCodeMask & hashCode.ToHashCode();
     }
 
     private void Resize()
     {
-        var newSize = checked(count * 2 + 1);
-        var newBuckets = new int[newSize];
+        var newSize = checked(_count * 2 + 1);
         var newSlots = new Slot[newSize];
-        Array.Copy(slots, newSlots, count);
-        for (int i = 0; i < count; i++)
+
+        var newBuckets = new int[newSize];
+        var newCaseSensitiveBuckets = new int[newSize];
+
+        Array.Copy(_slots, newSlots, _count);
+
+        for (int i = 0; i < _count; i++)
         {
             int bucket = newSlots[i].hashCode % newSize;
             newSlots[i].next = newBuckets[bucket] - 1;
             newBuckets[bucket] = i + 1;
+
+            int caseSensitiveBucket = newSlots[i].caseSensitiveHashCode % newSize;
+            newSlots[i].caseSensitiveNext = newCaseSensitiveBuckets[caseSensitiveBucket] - 1;
+            newCaseSensitiveBuckets[caseSensitiveBucket] = i + 1;
         }
-        buckets = newBuckets;
-        slots = newSlots;
+
+        _slots = newSlots;
+
+        _buckets = newBuckets;
+        _caseSensitiveBuckets = newCaseSensitiveBuckets;
     }
 
-    internal struct Slot
+    private struct Slot
     {
         internal int hashCode;
-        internal int next;
-        internal string key;
+        internal int caseSensitiveHashCode;
+
         internal string value;
+        internal byte[] encodedValue;
+
+        internal int next;
+        internal int caseSensitiveNext;
     }
 }