Switched from LRU cache algorithm to clock cache algorithm (#8253)

Author: michaelstaib

src/HotChocolate/Core/src/Authorization/AuthorizationCache.cs

@@ -3,26 +3,19 @@
 
 namespace HotChocolate.Authorization;
 
-internal sealed class AuthorizationCache
+internal sealed class AuthorizationCache(int capacity = 256)
 {
-    private readonly Cache<AuthorizeDirective[]> _cache;
-
-    public AuthorizationCache(int capacity = 100)
-    {
-        _cache = new Cache<AuthorizeDirective[]>(capacity);
-    }
+    private readonly Cache<AuthorizeDirective[]> _cache = new(capacity);
 
     public int Capacity => _cache.Capacity;
 
-    public int Count => _cache.Usage;
+    public int Count => _cache.Count;
 
-    public bool TryGetDirectives(
-        string documentId,
-        [NotNullWhen(true)] out AuthorizeDirective[]? directives)
+    public bool TryGetDirectives(string documentId, [NotNullWhen(true)] out AuthorizeDirective[]? directives)
         => _cache.TryGet(documentId, out directives);
 
     public void TryAddDirectives(string documentId, AuthorizeDirective[] directives)
-        => _cache.GetOrCreate(documentId, () => directives);
+        => _cache.GetOrCreate(documentId, static (_, d) => d, directives);
 
     public void Clear()
         => _cache.Clear();

src/HotChocolate/Core/src/Execution/Caching/DefaultDocumentCache.cs

@@ -4,19 +4,19 @@
 
 namespace HotChocolate.Execution.Caching;
 
-internal sealed class DefaultDocumentCache(int capacity = 100) : IDocumentCache
+internal sealed class DefaultDocumentCache(int capacity = 256) : IDocumentCache
 {
     private readonly Cache<CachedDocument> _cache = new(capacity);
 
     public int Capacity => _cache.Capacity;
 
-    public int Count => _cache.Usage;
+    public int Count => _cache.Count;
 
     public void TryAddDocument(string documentId, CachedDocument document)
-        => _cache.GetOrCreate(documentId, () => document);
+        => _cache.GetOrCreate(documentId, static (_, d) => d, document);
 
     public bool TryGetDocument(string documentId, [NotNullWhen(true)] out CachedDocument? document)
-        => _cache.TryGet(documentId, out document!);
+        => _cache.TryGet(documentId, out document);
 
     public void Clear() => _cache.Clear();
 }

src/HotChocolate/Core/src/Execution/Caching/DefaultPreparedOperationCache.cs

@@ -4,23 +4,19 @@
 
 namespace HotChocolate.Execution.Caching;
 
-internal sealed class DefaultPreparedOperationCache(int capacity = 100) : IPreparedOperationCache
+internal sealed class DefaultPreparedOperationCache(int capacity = 256) : IPreparedOperationCache
 {
     private readonly Cache<IOperation> _cache = new(capacity);
 
     public int Capacity => _cache.Capacity;
 
-    public int Count => _cache.Usage;
+    public int Count => _cache.Count;
 
-    public void TryAddOperation(
-        string operationId,
-        IOperation operation) =>
-        _cache.GetOrCreate(operationId, () => operation);
+    public void TryAddOperation(string operationId, IOperation operation)
+        => _cache.GetOrCreate(operationId, static (_, op) => op, operation);
 
-    public bool TryGetOperation(
-        string operationId,
-        [NotNullWhen(true)] out IOperation? operation) =>
-        _cache.TryGet(operationId, out operation!);
+    public bool TryGetOperation(string operationId, [NotNullWhen(true)] out IOperation? operation)
+        => _cache.TryGet(operationId, out operation);
 
     public void Clear() => _cache.Clear();
 }

src/HotChocolate/Core/src/Execution/Caching/IPreparedOperationCache.cs

@@ -9,18 +9,18 @@ namespace HotChocolate.Execution.Caching;
 public interface IPreparedOperationCache
 {
     /// <summary>
-    /// Gets maximum amount of compiled operations that can be cached. The default
+    /// Gets the maximum number of compiled operations that can be cached. The default
     /// value is <c>100</c>. The minimum allowed value is <c>10</c>.
     /// </summary>
     int Capacity { get; }
 
     /// <summary>
-    /// Gets the amount of compiled queries residing in the cache.
+    /// Gets the maximum number of compiled queries residing in the cache.
     /// </summary>
     int Count { get; }
 
     /// <summary>
-    /// Try get a compiled operation by it <paramref name="operationId" />.
+    /// Try to get a compiled operation by it <paramref name="operationId" />.
     /// </summary>
     /// <param name="operationId">
     /// The internal operation id.
@@ -33,9 +33,7 @@ public interface IPreparedOperationCache
     /// <c>true</c> if an operation was found that matches the specified
     /// <paramref name="operationId"/>, otherwise <c>false</c>.
     /// </returns>
-    bool TryGetOperation(
-        string operationId,
-        [NotNullWhen(true)] out IOperation? operation);
+    bool TryGetOperation(string operationId, [NotNullWhen(true)] out IOperation? operation);
 
     /// <summary>
     /// Tries to add a new compiled operation to the cache.
@@ -46,9 +44,7 @@ bool TryGetOperation(
     /// <param name="operation">
     /// The operation that shall be cached.
     /// </param>
-    void TryAddOperation(
-        string operationId,
-        IOperation operation);
+    void TryAddOperation(string operationId, IOperation operation);
 
     /// <summary>
     /// Clears all items from the cache.

src/HotChocolate/Core/src/Execution/Caching/PreparedOperationCacheOptions.cs

@@ -2,5 +2,5 @@ namespace HotChocolate.Execution.Caching;
 
 internal sealed class PreparedOperationCacheOptions
 {
-    public int Capacity { get; set; } = 100;
+    public int Capacity { get; set; } = 256;
 }

src/HotChocolate/Core/src/Execution/DependencyInjection/InternalServiceCollectionExtensions.cs

@@ -162,10 +162,11 @@ internal static IServiceCollection TryAddRequestExecutorResolver(
     internal static IServiceCollection TryAddDefaultCaches(
         this IServiceCollection services)
     {
-        services.TryAddSingleton<IDocumentCache>(
-            _ => new DefaultDocumentCache());
         services.TryAddSingleton<PreparedOperationCacheOptions>(
-            _ => new PreparedOperationCacheOptions { Capacity = 100 });
+            _ => new PreparedOperationCacheOptions { Capacity = 256 });
+        services.TryAddSingleton<IDocumentCache>(
+            sp => new DefaultDocumentCache(
+                sp.GetRequiredService<PreparedOperationCacheOptions>().Capacity));
         return services;
     }
 

src/HotChocolate/Core/src/Execution/DependencyInjection/RequestExecutorServiceCollectionExtensions.cs

@@ -172,7 +172,7 @@ private static IRequestExecutorBuilder CreateBuilder(
 
     public static IServiceCollection AddDocumentCache(
         this IServiceCollection services,
-        int capacity = 100)
+        int capacity = 256)
     {
         services.RemoveAll<IDocumentCache>();
         services.AddSingleton<IDocumentCache>(
@@ -182,7 +182,7 @@ public static IServiceCollection AddDocumentCache(
 
     public static IServiceCollection AddOperationCache(
         this IServiceCollection services,
-        int capacity = 100)
+        int capacity = 256)
     {
         services.RemoveAll<PreparedOperationCacheOptions>();
         services.AddSingleton<PreparedOperationCacheOptions>(

src/HotChocolate/CostAnalysis/src/CostAnalysis/Caching/DefaultCostMetricsCache.cs

@@ -3,23 +3,21 @@
 
 namespace HotChocolate.CostAnalysis.Caching;
 
-internal sealed class DefaultCostMetricsCache(int capacity = 100) : ICostMetricsCache
+internal sealed class DefaultCostMetricsCache(int capacity = 256) : ICostMetricsCache
 {
     private readonly Cache<CostMetrics> _cache = new(capacity);
 
     public int Capacity => _cache.Capacity;
 
-    public int Count => _cache.Usage;
+    public int Count => _cache.Count;
 
     public bool TryGetCostMetrics(
         string operationId,
         [NotNullWhen(true)] out CostMetrics? costMetrics)
         => _cache.TryGet(operationId, out costMetrics);
 
-    public void TryAddCostMetrics(
-        string operationId,
-        CostMetrics costMetrics)
-        => _cache.GetOrCreate(operationId, () => costMetrics);
+    public void TryAddCostMetrics(string operationId, CostMetrics costMetrics)
+        => _cache.GetOrCreate(operationId, static (_, m) => m, costMetrics);
 
     public void Clear() => _cache.Clear();
 }

src/HotChocolate/CostAnalysis/test/CostAnalysis.Tests/Doubles/FakeCostMetricsCache.cs

@@ -4,23 +4,21 @@
 
 namespace HotChocolate.CostAnalysis.Doubles;
 
-internal class FakeCostMetricsCache(int capacity = 100) : ICostMetricsCache
+internal class FakeCostMetricsCache(int capacity = 256) : ICostMetricsCache
 {
     private readonly Cache<CostMetrics> _cache = new(capacity);
 
     public int Capacity => _cache.Capacity;
 
-    public int Count => _cache.Usage;
+    public int Count => _cache.Count;
 
     public int Hits { get; private set; }
 
     public int Misses { get; private set; }
 
     public int Additions { get; private set; }
 
-    public bool TryGetCostMetrics(
-        string operationId,
-        [NotNullWhen(true)] out CostMetrics? costMetrics)
+    public bool TryGetCostMetrics(string operationId, [NotNullWhen(true)] out CostMetrics? costMetrics)
     {
         var result = _cache.TryGet(operationId, out costMetrics);
 
@@ -36,11 +34,9 @@ public bool TryGetCostMetrics(
         return result;
     }
 
-    public void TryAddCostMetrics(
-        string operationId,
-        CostMetrics costMetrics)
+    public void TryAddCostMetrics(string operationId, CostMetrics costMetrics)
     {
-        _cache.GetOrCreate(operationId, () => costMetrics);
+        _cache.GetOrCreate(operationId, static (_, m) => m, costMetrics);
         Additions++;
     }