Use a TLRU implementation to reduce cache lookup cost.

Author: JimBobSquarePants

src/ImageSharp.Web/Caching/PhysicalFileSystemCache.cs

@@ -85,31 +85,17 @@ public PhysicalFileSystemCache(
         }
 
         /// <inheritdoc/>
-        public async Task<IImageCacheResolver> GetAsync(string key)
+        public Task<IImageCacheResolver> GetAsync(string key)
         {
             string path = ToFilePath(key, this.cachedNameLength);
 
             IFileInfo metaFileInfo = this.fileProvider.GetFileInfo(this.ToMetaDataFilePath(path));
             if (!metaFileInfo.Exists)
             {
-                return null;
+                return Task.FromResult<IImageCacheResolver>(null);
             }
 
-            ImageCacheMetadata metadata = default;
-            using (Stream stream = metaFileInfo.CreateReadStream())
-            {
-                metadata = await ImageCacheMetadata.ReadAsync(stream);
-            }
-
-            IFileInfo fileInfo = this.fileProvider.GetFileInfo(this.ToImageFilePath(path, metadata));
-
-            // Check to see if the file exists.
-            if (!fileInfo.Exists)
-            {
-                return null;
-            }
-
-            return new PhysicalFileSystemCacheResolver(fileInfo, metadata);
+            return Task.FromResult<IImageCacheResolver>(new PhysicalFileSystemCacheResolver(metaFileInfo, this.formatUtilities));
         }
 
         /// <inheritdoc/>
@@ -142,6 +128,7 @@ public async Task SetAsync(string key, Stream stream, ImageCacheMetadata metadat
         /// <param name="path">The root path.</param>
         /// <param name="metaData">The image metadata.</param>
         /// <returns>The <see cref="string"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private string ToImageFilePath(string path, in ImageCacheMetadata metaData)
             => $"{path}.{this.formatUtilities.GetExtensionFromContentType(metaData.ContentType)}";
 
@@ -150,6 +137,7 @@ private string ToImageFilePath(string path, in ImageCacheMetadata metaData)
         /// </summary>
         /// <param name="path">The root path.</param>
         /// <returns>The <see cref="string"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private string ToMetaDataFilePath(string path) => $"{path}.meta";
 
         /// <summary>

src/ImageSharp.Web/Caching/PhysicalFileSystemCacheResolver.cs

@@ -14,23 +14,38 @@ namespace SixLabors.ImageSharp.Web.Resolvers
     public class PhysicalFileSystemCacheResolver : IImageCacheResolver
     {
         private readonly IFileInfo fileInfo;
-        private readonly ImageCacheMetadata metadata;
+        private readonly FormatUtilities formatUtilities;
+        private ImageCacheMetadata metadata;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="PhysicalFileSystemCacheResolver"/> class.
         /// </summary>
-        /// <param name="fileInfo">The input file info.</param>
-        /// <param name="metadata">The image metadata associated with this file.</param>
-        public PhysicalFileSystemCacheResolver(IFileInfo fileInfo, in ImageCacheMetadata metadata)
+        /// <param name="metaFileInfo">The cached metadata file info.</param>
+        /// <param name="formatUtilities">
+        /// Contains various format helper methods based on the current configuration.
+        /// </param>
+        public PhysicalFileSystemCacheResolver(IFileInfo metaFileInfo, FormatUtilities formatUtilities)
         {
-            this.fileInfo = fileInfo;
-            this.metadata = metadata;
+            this.fileInfo = metaFileInfo;
+            this.formatUtilities = formatUtilities;
         }
 
         /// <inheritdoc/>
-        public Task<ImageCacheMetadata> GetMetaDataAsync() => Task.FromResult(this.metadata);
+        public async Task<ImageCacheMetadata> GetMetaDataAsync()
+        {
+            using Stream stream = this.fileInfo.CreateReadStream();
+            this.metadata = await ImageCacheMetadata.ReadAsync(stream);
+            return this.metadata;
+        }
 
         /// <inheritdoc/>
-        public Task<Stream> OpenReadAsync() => Task.FromResult(this.fileInfo.CreateReadStream());
+        public Task<Stream> OpenReadAsync()
+        {
+            string path = Path.ChangeExtension(
+                this.fileInfo.PhysicalPath,
+                this.formatUtilities.GetExtensionFromContentType(this.metadata.ContentType));
+
+            return Task.FromResult<Stream>(File.OpenRead(path));
+        }
     }
 }

src/ImageSharp.Web/ImageSharp.Web.csproj

@@ -16,18 +16,19 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp2.1'">
-    <PackageReference Include="Microsoft.AspNetCore.Hosting.Abstractions"  />
+    <PackageReference Include="Microsoft.AspNetCore.Hosting.Abstractions" />
     <PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" />
-    <PackageReference Include="Microsoft.AspNetCore.Http.Extensions"  />
-    <PackageReference Include="Microsoft.AspNetCore.WebUtilities"  />
-    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions"  />
-    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions"  />
+    <PackageReference Include="Microsoft.AspNetCore.Http.Extensions" />
+    <PackageReference Include="Microsoft.AspNetCore.WebUtilities" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" />
     <PackageReference Include="Microsoft.Extensions.FileProviders.Physical" />
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="BitFaster.Caching" Version="1.0.1" />
     <PackageReference Include="Microsoft.IO.RecyclableMemoryStream" />
-    <PackageReference Include="Microsoft.SourceLink.GitHub"/>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" />
     <PackageReference Include="MinVer" PrivateAssets="All" />
     <PackageReference Include="SixLabors.ImageSharp" />
   </ItemGroup>

src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

@@ -8,8 +8,8 @@
 using System.IO;
 using System.Linq;
 using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
+using BitFaster.Caching.Lru;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -33,6 +33,24 @@ public class ImageSharpMiddleware
         /// </summary>
         private static readonly AsyncKeyLock AsyncLock = new AsyncKeyLock();
 
+        /// <summary>
+        /// Used to temporarily store source metadata reads to reduce the overhead of cache lookups.
+        /// </summary>
+        private static readonly ConcurrentTLru<string, ImageMetadata> SourceMetadataLru
+            = new ConcurrentTLru<string, ImageMetadata>(1024, TimeSpan.FromMinutes(5));
+
+        /// <summary>
+        /// Used to temporarily store cache resolver reads to reduce the overhead of cache lookups.
+        /// </summary>
+        private static readonly ConcurrentTLru<string, IImageCacheResolver> CacheResolverLru
+            = new ConcurrentTLru<string, IImageCacheResolver>(1024, TimeSpan.FromMinutes(5));
+
+        /// <summary>
+        /// Used to temporarily store cache metadata reads to reduce the overhead of cache lookups.
+        /// </summary>
+        private static readonly ConcurrentTLru<string, ImageCacheMetadata> CacheMetadataLru
+            = new ConcurrentTLru<string, ImageCacheMetadata>(1024, TimeSpan.FromMinutes(5));
+
         /// <summary>
         /// The function processing the Http request.
         /// </summary>
@@ -304,6 +322,14 @@ private async Task ProcessRequestAsync(
 
                     // Save the image to the cache and send the response to the caller.
                     await this.cache.SetAsync(key, outStream, cachedImageMetadata);
+
+                    // Remove the resolver from the cache so we always resolve next request.
+                    CacheResolverLru.TryRemove(key);
+
+                    // Replace cache metadata item value.
+                    CacheMetadataLru.TryRemove(key);
+                    CacheMetadataLru.GetOrAdd(key, _ => cachedImageMetadata);
+
                     await this.SendResponseAsync(imageContext, key, cachedImageMetadata, outStream, null);
                 }
                 catch (Exception ex)
@@ -351,14 +377,20 @@ private async Task<ValueTuple<bool, ImageMetadata>> IsNewOrUpdatedAsync(
             using (await AsyncLock.ReaderLockAsync(key))
             {
                 // Check to see if the cache contains this image.
-                sourceImageMetadata = await sourceImageResolver.GetMetaDataAsync();
-                IImageCacheResolver cachedImageResolver = await this.cache.GetAsync(key);
+                IImageCacheResolver cachedImageResolver
+                    = await CacheResolverLru.GetOrAddAsync(key, async k => await this.cache.GetAsync(k));
+
                 if (cachedImageResolver != null)
                 {
-                    ImageCacheMetadata cachedImageMetadata = await cachedImageResolver.GetMetaDataAsync();
+                    ImageCacheMetadata cachedImageMetadata =
+                        await CacheMetadataLru.GetOrAddAsync(key, async _ => await cachedImageResolver.GetMetaDataAsync());
+
                     if (cachedImageMetadata != default)
                     {
                         // Has the cached image expired or has the source image been updated?
+                        sourceImageMetadata =
+                            await SourceMetadataLru.GetOrAddAsync(key, async _ => await sourceImageResolver.GetMetaDataAsync());
+
                         if (cachedImageMetadata.SourceLastWriteTimeUtc == sourceImageMetadata.LastWriteTimeUtc
                             && cachedImageMetadata.ContentLength > 0 // Fix for old cache without length property
                             && cachedImageMetadata.CacheLastWriteTimeUtc > (DateTimeOffset.UtcNow - this.options.CacheMaxAge))