ADO.NET IHashPicker customization API + Orleans v3-compatible IHashPicker implementation

src/AdoNet/Orleans.Persistence.AdoNet/Storage/Provider/JenkinsHash.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Text;
 
 namespace Orleans.Storage
 {
@@ -22,12 +21,6 @@ private static void Mix(ref uint a, ref uint b, ref uint c)
             c -= a; c -= b; c ^= (b >> 15);
         }
 
-        // This is the reference implementation of the Jenkins hash.
-        public static uint ComputeHash(byte[] data)
-        {
-            return ComputeHash(data.AsSpan());
-        }
-
         // This is the reference implementation of the Jenkins hash.
         public static uint ComputeHash(ReadOnlySpan<byte> data)
         {
@@ -79,36 +72,5 @@ public static uint ComputeHash(ReadOnlySpan<byte> data)
             Mix(ref a, ref b, ref c);
             return c;
         }
-
-        public static uint ComputeHash(string data)
-        {
-            byte[] bytesToHash = Encoding.UTF8.GetBytes(data);
-            return ComputeHash(bytesToHash);
-        }
-
-        // This implementation calculates the exact same hash value as the above, but is
-        // optimized for the case where the input is exactly 24 bytes of data provided as
-        // three 8-byte unsigned integers.
-        public static uint ComputeHash(ulong u1, ulong u2, ulong u3)
-        {
-            uint a = 0x9e3779b9;
-            uint b = a;
-            uint c = 0;
-
-            unchecked
-            {
-                a += (uint)u1;
-                b += (uint)((u1 ^ (uint)u1) >> 32);
-                c += (uint)u2;
-                Mix(ref a, ref b, ref c);
-                a += (uint)((u2 ^ (uint)u2) >> 32);
-                b += (uint)u3;
-                c += (uint)((u3 ^ (uint)u3) >> 32);
-            }
-            Mix(ref a, ref b, ref c);
-            c += 24;
-            Mix(ref a, ref b, ref c);
-            return c;
-        }
     }
 }

src/AdoNet/Orleans.Persistence.AdoNet/Storage/Provider/Orleans3CompatibleHasher.cs

@@ -1,4 +1,4 @@
-using Orleans.Storage;
+using System;
 
 namespace Orleans.Storage
 {
@@ -15,7 +15,12 @@ internal class Orleans3CompatibleHasher : IHasher
         /// <summary>
         /// <see cref="IHasher.Hash(byte[])"/>.
         /// </summary>
-        public int Hash(byte[] data)
+        public int Hash(byte[] data) => Hash(data.AsSpan());
+
+        /// <summary>
+        /// <see cref="IHasher.Hash(byte[])"/>.
+        /// </summary>
+        public int Hash(ReadOnlySpan<byte> data)
         {
             // implementation restored from Orleans v3.7.2: https://github.com/dotnet/orleans/blob/b24e446abfd883f0e4ed614f5267eaa3331548dc/src/AdoNet/Orleans.Persistence.AdoNet/Storage/Provider/OrleansDefaultHasher.cs
             return unchecked((int)JenkinsHash.ComputeHash(data));

src/AdoNet/Orleans.Persistence.AdoNet/Storage/Provider/Orleans3CompatibleStringKeyHasher.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Buffers;
 using System.Text;
 
 namespace Orleans.Storage
@@ -37,17 +38,63 @@ public int Hash(byte[] data)
             // PickHasher parameters are the same for both calls so we need to analyze data content to distinguish these cases.
             // It doesn't word if string key is equal to grain type name, but we consider this edge case to be negligibly rare.
 
-            // reducing allocations if data is not a grain type
-            if (data.Length >= _grainType.Length && Encoding.UTF8.GetByteCount(_grainType) == data.Length)
+            if (IsGrainTypeName(data))
+                return _innerHasher.Hash(data);
+
+            var extendedLength = data.Length + 8;
+            if (extendedLength <= 256)
+            {
+                Span<byte> extended = stackalloc byte[extendedLength];
+                data.AsSpan().CopyTo(extended);
+                return _innerHasher.Hash(extended);
+            }
+
+            var buffer = ArrayPool<byte>.Shared.Rent(extendedLength);
+            try
+            {
+                data.AsSpan().CopyTo(buffer);
+                Array.Clear(buffer, data.Length, 8);
+                return _innerHasher.Hash(buffer.AsSpan(0, extendedLength));
+            }
+            finally
+            {
+                ArrayPool<byte>.Shared.Return(buffer);
+            }
+        }
+
+        private bool IsGrainTypeName(byte[] data)
+        {
+            // at least 1 byte per char
+            if (data.Length < _grainType.Length)
+                return false;
+
+            var grainTypeByteCount = Encoding.UTF8.GetByteCount(_grainType);
+            if (grainTypeByteCount != data.Length)
+                return false;
+
+            if (grainTypeByteCount <= 256)
             {
-                var grainTypeBytes = Encoding.UTF8.GetBytes(_grainType);
-                if (grainTypeBytes.AsSpan().SequenceEqual(data))
-                    return _innerHasher.Hash(data);
+                Span<byte> grainTypeBytes = stackalloc byte[grainTypeByteCount];
+                if (!Encoding.UTF8.TryGetBytes(_grainType, grainTypeBytes, out _))
+                    throw new InvalidOperationException();
+
+                return grainTypeBytes.SequenceEqual(data);
             }
 
-            var extendedData = new byte[data.Length + 8];
-            data.CopyTo(extendedData, 0);
-            return _innerHasher.Hash(extendedData);
+            var buffer = ArrayPool<byte>.Shared.Rent(grainTypeByteCount);
+            try
+            {
+                var grainTypeBytes = buffer.AsSpan(0, grainTypeByteCount);
+
+                if (!Encoding.UTF8.TryGetBytes(_grainType, grainTypeBytes, out _))
+                    throw new InvalidOperationException();
+
+                return grainTypeBytes.SequenceEqual(data);
+            }
+            finally
+            {
+                ArrayPool<byte>.Shared.Return(buffer);
+            }
         }
     }
 }