Merge pull request #377 from FoundatioFx/perf/cache-remove-all

Tests for RemoveAllAsync + some tweaks to cache maintenance.

Author: niemyjski

src/Foundatio.TestHarness/Caching/CacheClientTestsBase.cs

@@ -357,6 +357,64 @@ public virtual async Task CanUseScopedCachesAsync()
         }
     }
 
+    public virtual async Task CanRemoveAllAsync()
+    {
+        const int COUNT = 10000;
+
+        var cache = GetCacheClient();
+        if (cache == null)
+            return;
+
+        using (cache)
+        {
+            await cache.RemoveAllAsync();
+
+            var dictionary = Enumerable.Range(0, COUNT).ToDictionary(i => $"remove-all:{i}");
+
+            var sw = Stopwatch.StartNew();
+            await cache.SetAllAsync(dictionary);
+            sw.Stop();
+            _logger.LogInformation("Set All Time: {Elapsed:g}", sw.Elapsed);
+
+            sw = Stopwatch.StartNew();
+            Assert.Equal(COUNT, await cache.RemoveAllAsync());
+            sw.Stop();
+            _logger.LogInformation("Remove All Time: {Elapsed:g}", sw.Elapsed);
+
+            Assert.False(await cache.ExistsAsync("remove-all:0"));
+            Assert.False(await cache.ExistsAsync($"remove-all:{COUNT - 1}"));
+        }
+    }
+
+    public virtual async Task CanRemoveAllKeysAsync()
+    {
+        const int COUNT = 10000;
+
+        var cache = GetCacheClient();
+        if (cache == null)
+            return;
+
+        using (cache)
+        {
+            await cache.RemoveAllAsync();
+
+            var dictionary = Enumerable.Range(0, COUNT).ToDictionary(i => $"remove-all-keys:{i}");
+
+            var sw = Stopwatch.StartNew();
+            await cache.SetAllAsync(dictionary);
+            sw.Stop();
+            _logger.LogInformation("Set All Time: {Elapsed:g}", sw.Elapsed);
+
+            sw = Stopwatch.StartNew();
+            Assert.Equal(COUNT, await cache.RemoveAllAsync(dictionary.Keys));
+            sw.Stop();
+            _logger.LogInformation("Remove All Time: {Elapsed:g}", sw.Elapsed);
+
+            Assert.False(await cache.ExistsAsync("remove-all-keys:0"));
+            Assert.False(await cache.ExistsAsync($"remove-all-keys:{COUNT - 1}"));
+        }
+    }
+
     public virtual async Task CanRemoveByPrefixAsync()
     {
         var cache = GetCacheClient();
@@ -1036,7 +1094,7 @@ public virtual async Task MeasureThroughputAsync()
                 await cache.SetAsync("test", 13422);
                 await cache.SetAsync("flag", true);
                 Assert.Equal(13422, (await cache.GetAsync<int>("test")).Value);
-                Assert.Null(await cache.GetAsync<int>("test2"));
+                Assert.False((await cache.GetAsync<int>("test2")).HasValue);
                 Assert.True((await cache.GetAsync<bool>("flag")).Value);
             }
             sw.Stop();

src/Foundatio.TestHarness/Caching/HybridCacheClientTests.cs

@@ -81,6 +81,18 @@ public override Task CanSetAndGetObjectAsync()
         return base.CanSetAndGetObjectAsync();
     }
 
+    [Fact]
+    public override Task CanRemoveAllAsync()
+    {
+        return base.CanRemoveAllAsync();
+    }
+
+    [Fact]
+    public override Task CanRemoveAllKeysAsync()
+    {
+        return base.CanRemoveAllKeysAsync();
+    }
+
     [Fact]
     public override Task CanRemoveByPrefixAsync()
     {

src/Foundatio/Caching/InMemoryCacheClient.cs

@@ -715,7 +715,7 @@ private async Task<bool> SetInternalAsync(string key, CacheEntry entry, bool add
             if (isTraceLogLevelEnabled) _logger.LogTrace("Set cache key: {Key}", key);
         }
 
-        await StartMaintenanceAsync(true).AnyContext();
+        await StartMaintenanceAsync(ShouldCompact).AnyContext();
         return wasUpdated;
     }
 
@@ -957,18 +957,22 @@ private async Task StartMaintenanceAsync(bool compactImmediately = false)
         if (compactImmediately)
             await CompactAsync().AnyContext();
 
-        if (TimeSpan.FromMilliseconds(100) < utcNow - _lastMaintenance)
+        if (TimeSpan.FromMilliseconds(250) < utcNow - _lastMaintenance)
         {
             _lastMaintenance = utcNow;
             _ = Task.Run(DoMaintenanceAsync);
         }
     }
 
+    private bool ShouldCompact => _maxItems.HasValue && _memory.Count > _maxItems;
+
     private async Task CompactAsync()
     {
-        if (!_maxItems.HasValue || _memory.Count <= _maxItems)
+        if (!ShouldCompact)
             return;
 
+        _logger.LogTrace("CompactAsync: Compacting cache");
+
         string expiredKey = null;
         using (await _lock.LockAsync().AnyContext())
         {
@@ -1014,7 +1018,11 @@ private async Task DoMaintenanceAsync()
             foreach (var kvp in _memory.ToArray())
             {
                 bool lastAccessTimeIsInfrequent = kvp.Value.LastAccessTicks < lastAccessMaximumTicks;
-                if (lastAccessTimeIsInfrequent && kvp.Value.ExpiresAt < DateTime.MaxValue && kvp.Value.ExpiresAt <= utcNow)
+                if (!lastAccessTimeIsInfrequent)
+                    continue;
+
+                var expiresAt = kvp.Value.ExpiresAt;
+                if (expiresAt < DateTime.MaxValue && expiresAt <= utcNow)
                 {
                     _logger.LogDebug("DoMaintenance: Removing expired key {Key}", kvp.Key);
                     RemoveKeyIfExpired(kvp.Key);
@@ -1023,10 +1031,11 @@ private async Task DoMaintenanceAsync()
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error trying to find expired cache items");
+            _logger.LogError(ex, "Error trying to find expired cache items: {Message}", ex.Message);
         }
 
-        await CompactAsync().AnyContext();
+        if (ShouldCompact)
+            await CompactAsync().AnyContext();
     }
 
     public void Dispose()

tests/Foundatio.Tests/Caching/InMemoryCacheClientTests.cs

@@ -77,6 +77,18 @@ public override Task CanSetAndGetObjectAsync()
         return base.CanSetAndGetObjectAsync();
     }
 
+    [Fact]
+    public override Task CanRemoveAllAsync()
+    {
+        return base.CanRemoveAllAsync();
+    }
+
+    [Fact]
+    public override Task CanRemoveAllKeysAsync()
+    {
+        return base.CanRemoveAllKeysAsync();
+    }
+
     [Fact]
     public override Task CanRemoveByPrefixAsync()
     {
@@ -187,10 +199,28 @@ public override Task CanManageListRemoveExpirationAsync()
         return base.CanManageListRemoveExpirationAsync();
     }
 
+    [Fact]
+    public override Task MeasureThroughputAsync()
+    {
+        return base.MeasureThroughputAsync();
+    }
+
+    [Fact]
+    public override Task MeasureSerializerSimpleThroughputAsync()
+    {
+        return base.MeasureSerializerSimpleThroughputAsync();
+    }
+
+    [Fact]
+    public override Task MeasureSerializerComplexThroughputAsync()
+    {
+        return base.MeasureSerializerComplexThroughputAsync();
+    }
+
     [Fact]
     public async Task CanSetMaxItems()
     {
-        // run in tight loop so that the code is warmed up and we can catch timing issues
+        // run in a tight loop so that the code is warmed up and we can catch timing issues
         for (int x = 0; x < 5; x++)
         {
             var cache = new InMemoryCacheClient(o => o.MaxItems(10).CloneValues(true));

tests/Foundatio.Tests/Caching/InMemoryHybridCacheClientTests.cs

@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Foundatio.Caching;
 using Foundatio.Messaging;
 using Microsoft.Extensions.Logging;
@@ -34,6 +34,18 @@ public override Task CanTryGetAsync()
         return base.CanTryGetAsync();
     }
 
+    [Fact]
+    public override Task CanRemoveAllAsync()
+    {
+        return base.CanRemoveAllAsync();
+    }
+
+    [Fact]
+    public override Task CanRemoveAllKeysAsync()
+    {
+        return base.CanRemoveAllKeysAsync();
+    }
+
     [Fact]
     public override Task CanRemoveByPrefixAsync()
     {
@@ -90,19 +102,19 @@ public override Task WillWorkWithSets()
         return base.WillWorkWithSets();
     }
 
-    [Fact(Skip = "Performance Test")]
+    [Fact]
     public override Task MeasureThroughputAsync()
     {
         return base.MeasureThroughputAsync();
     }
 
-    [Fact(Skip = "Performance Test")]
+    [Fact]
     public override Task MeasureSerializerSimpleThroughputAsync()
     {
         return base.MeasureSerializerSimpleThroughputAsync();
     }
 
-    [Fact(Skip = "Performance Test")]
+    [Fact]
     public override Task MeasureSerializerComplexThroughputAsync()
     {
         return base.MeasureSerializerComplexThroughputAsync();