Optimize caching string generation

Author: JimBobSquarePants

src/ImageSharp.Web/Caching/CacheHash.cs

@@ -51,7 +51,7 @@ public string Create(string value, uint length)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static string HashValue(string value, uint length, Span<byte> bufferSpan)
+        private static string HashValue(ReadOnlySpan<char> value, uint length, Span<byte> bufferSpan)
         {
             using var hashAlgorithm = SHA256.Create();
             Encoding.ASCII.GetBytes(value, bufferSpan);

src/ImageSharp.Web/Caching/PhysicalFileSystemCache.cs

@@ -1,7 +1,10 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.FileProviders;
@@ -21,6 +24,11 @@ public class PhysicalFileSystemCache : IImageCache
         /// </summary>
         private readonly string cacheRootPath;
 
+        /// <summary>
+        /// The length of the filename to use (minus the extension) when storing images in the image cache.
+        /// </summary>
+        private readonly int cachedNameLength;
+
         /// <summary>
         /// The file provider abstraction.
         /// </summary>
@@ -69,6 +77,7 @@ public PhysicalFileSystemCache(
                 Directory.CreateDirectory(this.cacheRootPath);
             }
 
+            this.cachedNameLength = (int)this.options.CachedNameLength;
             this.fileProvider = new PhysicalFileProvider(this.cacheRootPath);
             this.options = options.Value;
             this.formatUtilies = formatUtilities;
@@ -77,7 +86,7 @@ public PhysicalFileSystemCache(
         /// <inheritdoc/>
         public async Task<IImageCacheResolver> GetAsync(string key)
         {
-            string path = this.ToFilePath(key);
+            string path = ToFilePath(key, this.cachedNameLength);
 
             IFileInfo metaFileInfo = this.fileProvider.GetFileInfo(this.ToMetaDataFilePath(path));
             if (!metaFileInfo.Exists)
@@ -105,7 +114,7 @@ public async Task<IImageCacheResolver> GetAsync(string key)
         /// <inheritdoc/>
         public async Task SetAsync(string key, Stream stream, ImageCacheMetadata metadata)
         {
-            string path = Path.Combine(this.cacheRootPath, this.ToFilePath(key));
+            string path = Path.Combine(this.cacheRootPath, ToFilePath(key, this.cachedNameLength));
             string imagePath = this.ToImageFilePath(path, metadata);
             string metaPath = this.ToMetaDataFilePath(path);
             string directory = Path.GetDirectoryName(path);
@@ -146,8 +155,36 @@ private string ToImageFilePath(string path, in ImageCacheMetadata metaData)
         /// Converts the key into a nested file path.
         /// </summary>
         /// <param name="key">The cache key.</param>
+        /// <param name="cachedNameLength">The length of the cached file name minus the extension.</param>
         /// <returns>The <see cref="string"/>.</returns>
-        private string ToFilePath(string key) // TODO: Avoid the allocation here.
-            => $"{string.Join("/", key.Substring(0, (int)this.options.CachedNameLength).ToCharArray())}/{key}";
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe string ToFilePath(string key, int cachedNameLength)
+        {
+            const char separator = '/';
+
+            // Each key substring char + separator + key
+            int length = (cachedNameLength * 2) + key.Length;
+            fixed (char* keyPtr = key)
+            {
+                return string.Create(length, (Ptr: (IntPtr)keyPtr, key.Length), (chars, args) =>
+                {
+                    var keySpan = new ReadOnlySpan<char>((char*)args.Ptr, args.Length);
+                    ref char keyRef = ref MemoryMarshal.GetReference(keySpan);
+                    ref char charRef = ref MemoryMarshal.GetReference(chars);
+
+                    int index = 0;
+                    for (int i = 0; i < cachedNameLength; i++)
+                    {
+                        Unsafe.Add(ref charRef, index++) = Unsafe.Add(ref keyRef, i);
+                        Unsafe.Add(ref charRef, index++) = separator;
+                    }
+
+                    for (int i = 0; i < keySpan.Length; i++)
+                    {
+                        Unsafe.Add(ref charRef, index++) = Unsafe.Add(ref keyRef, i);
+                    }
+                });
+            }
+        }
     }
 }

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

@@ -0,0 +1,72 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using BenchmarkDotNet.Attributes;
+
+namespace SixLabors.ImageSharp.Web.Benchmarks.Caching
+{
+    [Config(typeof(MemoryConfig))]
+    public class StringJoinBenchmarks
+    {
+        private const string Key = "abcdefghijkl";
+        private const int CachedNameLength = 12;
+
+        [Benchmark(Baseline = true, Description = "String.Join")]
+        public string JoinUsingString()
+            => $"{string.Join("/", Key.Substring(0, CachedNameLength).ToCharArray())}/{Key}";
+
+        [Benchmark(Description = "StringBuilder.Append")]
+        public string JoinUsingStringBuilder()
+        {
+            ReadOnlySpan<char> keySpan = Key;
+            const char separator = '/';
+
+            // Each key substring char + separator + key
+            var sb = new StringBuilder((CachedNameLength * 2) + Key.Length);
+            ReadOnlySpan<char> paths = keySpan.Slice(0, CachedNameLength);
+            for (int i = 0; i < paths.Length; i++)
+            {
+                sb.Append(paths[i]);
+                sb.Append(separator);
+            }
+
+            sb.Append(Key);
+            return sb.ToString();
+        }
+
+        [Benchmark(Description = "String.Create")]
+        public unsafe string JoinUsingStringCreate()
+        {
+            ReadOnlySpan<char> keySpan = Key;
+            const char separator = '/';
+
+            // Each key substring char + separator + key
+            int length = (CachedNameLength * 2) + Key.Length;
+            fixed (char* keyPtr = Key)
+            {
+                return string.Create(length, (Ptr: (IntPtr)keyPtr, Key.Length), (chars, args) =>
+                {
+                    var keySpan = new ReadOnlySpan<char>((char*)args.Ptr, args.Length);
+                    ref char keyRef = ref MemoryMarshal.GetReference(keySpan);
+                    ref char charRef = ref MemoryMarshal.GetReference(chars);
+
+                    int index = 0;
+                    for (int i = 0; i < CachedNameLength; i++)
+                    {
+                        Unsafe.Add(ref charRef, index++) = Unsafe.Add(ref keyRef, i);
+                        Unsafe.Add(ref charRef, index++) = separator;
+                    }
+
+                    for (int i = 0; i < keySpan.Length; i++)
+                    {
+                        Unsafe.Add(ref charRef, index++) = Unsafe.Add(ref keyRef, i);
+                    }
+                });
+            }
+        }
+    }
+}

tests/ImageSharp.Web.Tests/Caching/PhysicialFileSystemCacheTests.cs

@@ -0,0 +1,23 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using SixLabors.ImageSharp.Web.Caching;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Web.Tests.Caching
+{
+    public class PhysicialFileSystemCacheTests
+    {
+        [Fact]
+        public void FilePathMatchesReference()
+        {
+            const string Key = "abcdefghijkl";
+            const int CachedNameLength = 12;
+
+            string expected = $"{string.Join("/", Key.Substring(0, CachedNameLength).ToCharArray())}/{Key}";
+            string actual = PhysicalFileSystemCache.ToFilePath(Key, CachedNameLength);
+
+            Assert.Equal(expected, actual);
+        }
+    }
+}