27% Faster hashing with less memory allocation.

Author: JimBobSquarePants

Directory.Build.props

@@ -13,13 +13,14 @@
   <!-- Default settings that are used by other settings -->
   <PropertyGroup>
     <BaseArtifactsPath>$(MSBuildThisFileDirectory)artifacts/</BaseArtifactsPath>
-    <BaseArtifactsPathSuffix>$(ImageSharpProjectCategory)/$(MSBuildProjectName)</BaseArtifactsPathSuffix>
+    <BaseArtifactsPathSuffix>$(SixLaborsProjectCategory)/$(MSBuildProjectName)</BaseArtifactsPathSuffix>
     <RepositoryUrl Condition="'$(RepositoryUrl)' == ''">https://github.com/SixLabors/ImageSharp.Web/</RepositoryUrl>
   </PropertyGroup>
 
   <!-- Default settings that explicitly differ from the Sdk.props defaults  -->
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <BaseIntermediateOutputPath>$(BaseArtifactsPath)obj/$(BaseArtifactsPathSuffix)/</BaseIntermediateOutputPath>
     <DebugType>portable</DebugType>
     <DebugType Condition="'$(codecov)' != ''">full</DebugType>
     <NullableContextOptions>disable</NullableContextOptions>
@@ -58,6 +59,7 @@
   <!-- Default settings that explicitly differ from the Sdk.targets defaults-->
   <PropertyGroup>
     <Authors>Six Labors and contributors</Authors>
+    <BaseOutputPath>$(BaseArtifactsPath)bin/$(BaseArtifactsPathSuffix)/</BaseOutputPath>
     <Company>Six Labors</Company>
     <PackageOutputPath>$(BaseArtifactsPath)pkg/$(BaseArtifactsPathSuffix)/$(Configuration)/</PackageOutputPath>
     <Product>SixLabors.ImageSharp.Web</Product>

src/Directory.Build.props

@@ -43,7 +43,7 @@
     <!-- DynamicProxyGenAssembly2 is needed so Moq can use our internals -->
     <InternalsVisibleTo Include="DynamicProxyGenAssembly2" PublicKey="0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7" />
     <InternalsVisibleTo Include="SixLabors.ImageSharp.Web.Tests"  PublicKey="$(SixLaborsPublicKey)" />
-    <InternalsVisibleTo Include="SixLabors.ImageSharp.Web.Benchmarks"  PublicKey="$(SixLaborsPublicKey)" />
+    <InternalsVisibleTo Include="ImageSharp.Web.Benchmarks"  PublicKey="$(SixLaborsPublicKey)" />
   </ItemGroup>
 
 </Project>

src/ImageSharp.Web/Caching/CacheHash.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
 using System.Text;
 using Microsoft.Extensions.Options;
@@ -33,17 +34,34 @@ public CacheHash(IOptions<ImageSharpMiddlewareOptions> options, MemoryAllocator
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public string Create(string value, uint length)
         {
-            int len = (int)length;
             int byteCount = Encoding.ASCII.GetByteCount(value);
-            using (var hashAlgorithm = SHA256.Create())
-            using (IManagedByteBuffer buffer = this.memoryAllocator.AllocateManagedByteBuffer(byteCount))
+
+            // Allocating a buffer from the pool is ~27% slower than stackalloc so use
+            // that for short strings
+            if (byteCount < 257)
             {
-                Encoding.ASCII.GetBytes(value, 0, byteCount, buffer.Array, 0);
-                byte[] hash = hashAlgorithm.ComputeHash(buffer.Array, 0, byteCount);
-                return $"{HexEncoder.Encode(new Span<byte>(hash).Slice(0, len / 2))}";
+                return HashValue(value, length, stackalloc byte[byteCount]);
             }
+
+            using IManagedByteBuffer buffer = this.memoryAllocator.AllocateManagedByteBuffer(byteCount);
+            return HashValue(value, length, buffer.Memory.Span);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static string HashValue(string value, uint length, Span<byte> bufferSpan)
+        {
+            using var hashAlgorithm = SHA256.Create();
+            Encoding.ASCII.GetBytes(value, bufferSpan);
+
+            // Hashed output maxes out at 32 bytes @ 256bit/8 so we're safe to use stackalloc.
+            Span<byte> hash = stackalloc byte[32];
+            hashAlgorithm.TryComputeHash(bufferSpan, hash, out int _);
+
+            // length maxes out at 64 since we throw if options is greater.
+            return HexEncoder.Encode(hash.Slice(0, (int)(length / 2)));
         }
     }
 }

src/ImageSharp.Web/Caching/HexEncoder.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -28,24 +28,28 @@ internal static class HexEncoder
         /// <param name="bytes">The bytes.</param>
         /// <returns>The <see cref="string"/>.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static string Encode(Span<byte> bytes)
+        public static unsafe string Encode(ReadOnlySpan<byte> bytes)
         {
-            int length = bytes.Length;
-            char[] chars = new char[length * 2];
-            ref char charRef = ref MemoryMarshal.GetReference<char>(chars);
-            ref byte bytesRef = ref MemoryMarshal.GetReference(bytes);
-            ref char hiRef = ref MemoryMarshal.GetReference<char>(HexLutHi);
-            ref char lowRef = ref MemoryMarshal.GetReference<char>(HexLutLo);
-
-            int index = 0;
-            for (int i = 0; i < length; i++)
+            fixed (byte* bytesPtr = bytes)
             {
-                byte byteIndex = Unsafe.Add(ref bytesRef, i);
-                Unsafe.Add(ref charRef, index++) = Unsafe.Add(ref hiRef, byteIndex);
-                Unsafe.Add(ref charRef, index++) = Unsafe.Add(ref lowRef, byteIndex);
-            }
+                return string.Create(bytes.Length * 2, (Ptr: (IntPtr)bytesPtr, bytes.Length), (chars, args) =>
+                {
+                    var ros = new ReadOnlySpan<byte>((byte*)args.Ptr, args.Length);
 
-            return new string(chars, 0, chars.Length);
+                    ref char charRef = ref MemoryMarshal.GetReference(chars);
+                    ref byte bytesRef = ref MemoryMarshal.GetReference(ros);
+                    ref char hiRef = ref MemoryMarshal.GetReference<char>(HexLutHi);
+                    ref char lowRef = ref MemoryMarshal.GetReference<char>(HexLutLo);
+
+                    int index = 0;
+                    for (int i = 0; i < ros.Length; i++)
+                    {
+                        byte byteIndex = Unsafe.Add(ref bytesRef, i);
+                        Unsafe.Add(ref charRef, index++) = Unsafe.Add(ref hiRef, byteIndex);
+                        Unsafe.Add(ref charRef, index++) = Unsafe.Add(ref lowRef, byteIndex);
+                    }
+                });
+            }
         }
     }
-}
+}

tests/ImageSharp.Web.Benchmarks/CacheHashBaseline.cs

@@ -16,11 +16,11 @@ public class CacheHashBaseline : ICacheHash
         /// <inheritdoc/>
         public string Create(string value, uint length)
         {
-            if (length.CompareTo(2) < 0 || length.CompareTo(64) > 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(length), $"Value must be greater than or equal to {2} and less than or equal to {64}.");
-            }
-
+            // Don't use in benchmark.
+            // if (length.CompareTo(2) < 0 || length.CompareTo(64) > 0)
+            // {
+            //    throw new ArgumentOutOfRangeException(nameof(length), $"Value must be greater than or equal to {2} and less than or equal to {64}.");
+            // }
             using (var hashAlgorithm = SHA256.Create())
             {
                 // Concatenate the hash bytes into one long string.

tests/ImageSharp.Web.Benchmarks/Caching/CacheHashBenchmarks.cs

@@ -12,8 +12,8 @@ namespace SixLabors.ImageSharp.Web.Benchmarks.Caching
     public class CacheHashBenchmarks
     {
         private const string URL = "http://testwebsite.com/image-12345.jpeg?width=400";
-        private static readonly IOptions<ImageSharpMiddlewareOptions> Options = Microsoft.Extensions.Options.Options.Create(new ImageSharpMiddlewareOptions());
-        private static readonly CacheHash Sha256Hasher = new CacheHash(Options, Options.Value.Configuration.MemoryAllocator);
+        private static readonly IOptions<ImageSharpMiddlewareOptions> MWOptions = Options.Create(new ImageSharpMiddlewareOptions());
+        private static readonly CacheHash Sha256Hasher = new CacheHash(MWOptions, MWOptions.Value.Configuration.MemoryAllocator);
         private static readonly CacheHashBaseline NaiveSha256Hasher = new CacheHashBaseline();
 
         [Benchmark(Baseline = true, Description = "Baseline Sha256Hasher")]

tests/ImageSharp.Web.Benchmarks/ImageSharp.Web.Benchmarks.csproj

@@ -1,9 +1,9 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFrameworks>netcoreapp3.1;netcoreapp2.1</TargetFrameworks>
-    <AssemblyName>SixLabors.ImageSharp.Web.Benchmarks</AssemblyName>
+    <AssemblyName>ImageSharp.Web.Benchmarks</AssemblyName>
     <RootNamespace>SixLabors.ImageSharp.Web.Benchmarks</RootNamespace>
     <GenerateProgramFile>false</GenerateProgramFile>
     <!--Used to hide test project from dotnet test-->