Implement clear (#75)

* basic impl
* fix
* rem cmt

Author: bitfaster

BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs

@@ -327,5 +327,38 @@ public void WhenAddOrUpdateExpiresItemsTheyAreDisposed()
             // all other items are not disposed
             items.Skip(1).All(i => i.IsDisposed == false).Should().BeTrue();
         }
+
+        [Fact]
+        public void WhenCacheIsEmptyClearIsNoOp()
+        {
+            lru.Clear();
+            lru.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenItemsExistClearRemovesAllItems()
+        {
+            lru.AddOrUpdate(1, "1");
+            lru.AddOrUpdate(2, "2");
+            lru.Clear();
+            lru.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenItemsAreDisposableClearDisposesItemsOnRemove()
+        {
+            var lruOfDisposable = new ClassicLru<int, DisposableItem>(1, 3, EqualityComparer<int>.Default);
+
+            var items = Enumerable.Range(1, 4).Select(i => new DisposableItem()).ToList();
+
+            for (int i = 0; i < 4; i++)
+            {
+                lruOfDisposable.AddOrUpdate(i, items[i]);
+            }
+
+            lruOfDisposable.Clear();
+
+            items.All(i => i.IsDisposed == true).Should().BeTrue();
+        }
     }
 }

BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs

@@ -477,5 +477,45 @@ public void WhenKeyDoesNotExistAddOrUpdateMaintainsLruOrder()
             lru.HotCount.Should().Be(3);
             lru.ColdCount.Should().Be(1); // items must have been enqueued and cycled for one of them to reach the cold queue
         }
+
+        [Fact]
+        public void WhenCacheIsEmptyClearIsNoOp()
+        {
+            lru.Clear();
+            lru.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenItemsExistClearRemovesAllItems()
+        {
+            lru.AddOrUpdate(1, "1");
+            lru.AddOrUpdate(2, "2");
+            
+            lru.Clear();
+
+            lru.Count.Should().Be(0);
+
+            // verify queues are purged
+            lru.HotCount.Should().Be(0);
+            lru.WarmCount.Should().Be(0);
+            lru.ColdCount.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenItemsAreDisposableClearDisposesItemsOnRemove()
+        {
+            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, 6, EqualityComparer<int>.Default);
+
+            var items = Enumerable.Range(1, 4).Select(i => new DisposableItem()).ToList();
+
+            for (int i = 0; i < 4; i++)
+            {
+                lruOfDisposable.AddOrUpdate(i, items[i]);
+            }
+
+            lruOfDisposable.Clear();
+
+            items.All(i => i.IsDisposed == true).Should().BeTrue();
+        }
     }
 }

BitFaster.Caching/ICache.cs

@@ -62,5 +62,10 @@ public interface ICache<K, V>
         /// <param name="key">The key of the element to update.</param>
         /// <param name="value">The new value.</param>
         void AddOrUpdate(K key, V value);
+
+        /// <summary>
+        /// Removes all keys and values from the cache.
+        /// </summary>
+        void Clear();
     }
 }

BitFaster.Caching/Lru/ClassicLru.cs

@@ -258,6 +258,19 @@ public void AddOrUpdate(K key, V value)
             AddOrUpdate(key, value);
         }
 
+        ///<inheritdoc/>
+        public void Clear()
+        { 
+            // take a key snapshot
+            var keys = this.dictionary.Keys.ToList();
+
+            // remove all keys in the snapshot - this correctly handles disposable values
+            foreach (var key in keys)
+            { 
+                TryRemove(key);    
+            }
+        }
+
         // Thead A reads x from the dictionary. Thread B adds a new item. Thread A moves x to the end. Thread B now removes the new first Node (removal is atomic on both data structures).
         private void LockAndMoveToEnd(LinkedListNode<LruItem> node)
         {

BitFaster.Caching/Lru/TemplateConcurrentLru.cs

@@ -259,6 +259,30 @@ public void AddOrUpdate(K key, V value)
 
             // if both update and add failed there was a race, try again
             AddOrUpdate(key, value);
+        }
+
+        ///<inheritdoc/>
+        public void Clear()
+        {
+            // take a key snapshot
+            var keys = this.dictionary.Keys.ToList();
+
+            // remove all keys in the snapshot - this correctly handles disposable values
+            foreach (var key in keys)
+            {
+                TryRemove(key);
+            }
+
+            // At this point, dictionary is empty but queues still hold references to all values.
+            // Cycle the queues to purge all refs. If any items were added during this process, 
+            // it is possible they might be removed as part of CycleCold. However, the dictionary
+            // and queues will remain in a consistent state.
+            for (int i = 0; i < keys.Count; i++)
+            {
+                CycleHotUnchecked();
+                CycleWarmUnchecked();
+                CycleColdUnchecked();
+            }
         }
 
         private void Cycle()
@@ -282,72 +306,90 @@ private void CycleHot()
         {
             if (this.hotCount > this.hotCapacity)
             {
-                Interlocked.Decrement(ref this.hotCount);
+                CycleHotUnchecked();
+            }
+        }
 
-                if (this.hotQueue.TryDequeue(out var item))
-                {
-                    var where = this.policy.RouteHot(item);
-                    this.Move(item, where);
-                }
-                else
-                {
-                    Interlocked.Increment(ref this.hotCount);
-                }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void CycleHotUnchecked()
+        {
+            Interlocked.Decrement(ref this.hotCount);
+
+            if (this.hotQueue.TryDequeue(out var item))
+            {
+                var where = this.policy.RouteHot(item);
+                this.Move(item, where);
+            }
+            else
+            {
+                Interlocked.Increment(ref this.hotCount);
             }
         }
 
         private void CycleWarm()
         {
             if (this.warmCount > this.warmCapacity)
             {
-                Interlocked.Decrement(ref this.warmCount);
-
-                if (this.warmQueue.TryDequeue(out var item))
-                {
-                    var where = this.policy.RouteWarm(item);
+                CycleWarmUnchecked();
+            }
+        }
 
-                    // When the warm queue is full, we allow an overflow of 1 item before redirecting warm items to cold.
-                    // This only happens when hit rate is high, in which case we can consider all items relatively equal in
-                    // terms of which was least recently used.
-                    if (where == ItemDestination.Warm && this.warmCount <= this.warmCapacity)
-                    {
-                        this.Move(item, where);
-                    }
-                    else
-                    {
-                        this.Move(item, ItemDestination.Cold);
-                    }
-                }
-                else
-                {
-                    Interlocked.Increment(ref this.warmCount);
-                }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void CycleWarmUnchecked()
+        {
+            Interlocked.Decrement(ref this.warmCount);
+
+            if (this.warmQueue.TryDequeue(out var item))
+            {
+                var where = this.policy.RouteWarm(item);
+
+                // When the warm queue is full, we allow an overflow of 1 item before redirecting warm items to cold.
+                // This only happens when hit rate is high, in which case we can consider all items relatively equal in
+                // terms of which was least recently used.
+                if (where == ItemDestination.Warm && this.warmCount <= this.warmCapacity)
+                {
+                    this.Move(item, where);
+                }
+                else
+                {
+                    this.Move(item, ItemDestination.Cold);
+                }
+            }
+            else
+            {
+                Interlocked.Increment(ref this.warmCount);
             }
         }
 
         private void CycleCold()
         {
             if (this.coldCount > this.coldCapacity)
             {
-                Interlocked.Decrement(ref this.coldCount);
-
-                if (this.coldQueue.TryDequeue(out var item))
-                {
-                    var where = this.policy.RouteCold(item);
+                CycleColdUnchecked();
+            }
+        }
 
-                    if (where == ItemDestination.Warm && this.warmCount <= this.warmCapacity)
-                    {
-                        this.Move(item, where);
-                    }
-                    else
-                    {
-                        this.Move(item, ItemDestination.Remove);
-                    }
-                }
-                else
-                {
-                    Interlocked.Increment(ref this.coldCount);
-                }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void CycleColdUnchecked()
+        {
+            Interlocked.Decrement(ref this.coldCount);
+
+            if (this.coldQueue.TryDequeue(out var item))
+            {
+                var where = this.policy.RouteCold(item);
+
+                if (where == ItemDestination.Warm && this.warmCount <= this.warmCapacity)
+                {
+                    this.Move(item, where);
+                }
+                else
+                {
+                    this.Move(item, ItemDestination.Remove);
+                }
+            }
+            else
+            {
+                Interlocked.Increment(ref this.coldCount);
             }
         }