debug (#224)

* debug

* test count

* lru metrics

* scoped

Author: bitfaster

BitFaster.Caching.UnitTests/Buffers/StripedMpscBufferTests.cs

@@ -21,6 +21,22 @@ public void CapacityReturnsCapacity()
             buffer.Capacity.Should().Be(32);
         }
 
+        [Fact]
+        public void CountReturnsCount()
+        {
+            buffer.Count.Should().Be(0);
+
+            for (var i = 0; i < stripeCount; i++)
+            {
+                for (var j = 0; j < bufferSize; j++)
+                {
+                    buffer.TryAdd(1.ToString()).Should().Be(BufferStatus.Success);
+                }
+            }
+
+            buffer.Count.Should().Be(buffer.Capacity);
+        }
+
         [Fact]
         public void WhenBufferIsFullTryAddReturnsFull()
         {

BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs

@@ -1,12 +1,12 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Diagnostics;
 using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Atomic
 {
+    [DebuggerDisplay("Count = {Count}")]
     public sealed class AtomicFactoryAsyncCache<K, V> : IAsyncCache<K, V>
     {
         private readonly ICache<K, AsyncAtomicFactory<K, V>> cache;

BitFaster.Caching/Atomic/AtomicFactoryCache.cs

@@ -1,12 +1,11 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Diagnostics;
 
 namespace BitFaster.Caching.Atomic
 {
+    [DebuggerDisplay("Count = {Count}")]
     public sealed class AtomicFactoryCache<K, V> : ICache<K, V>
     {
         private readonly ICache<K, AtomicFactory<K, V>> cache;

BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs

@@ -1,13 +1,13 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Atomic
 {
+    [DebuggerDisplay("Count = {Count}")]
     public sealed class AtomicFactoryScopedAsyncCache<K, V> : IScopedAsyncCache<K, V> where V : IDisposable
     {
         private readonly ICache<K, ScopedAsyncAtomicFactory<K, V>> cache;

BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs

@@ -1,13 +1,12 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Diagnostics;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Atomic
 {
+    [DebuggerDisplay("Count = {Count}")]
     public sealed class AtomicFactoryScopedCache<K, V> : IScopedCache<K, V> where V : IDisposable
     {
         private readonly ICache<K, ScopedAtomicFactory<K, V>> cache;

BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs

@@ -1,12 +1,11 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Atomic
 {
+    [DebuggerDisplay("IsValueCreated={initializer == null}, Value={ScopeIfCreated}")]
     public sealed class ScopedAsyncAtomicFactory<K, V> : IScoped<V>, IDisposable where V : IDisposable
     {
         private Scoped<V> scope;

BitFaster.Caching/Atomic/ScopedAtomicFactory.cs

@@ -1,17 +1,14 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
-using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Atomic
 {
     // Requirements:
     // 1. Exactly once disposal.
     // 2. Exactly once invocation of value factory (synchronized create).
     // 3. Resolve race between create dispose init, if disposed is called before value is created, scoped value is disposed for life.
+    [DebuggerDisplay("IsValueCreated={initializer == null}, Value={ScopeIfCreated}")]
     public sealed class ScopedAtomicFactory<K, V> : IScoped<V>, IDisposable where V : IDisposable
     {
         private Scoped<V> scope;

BitFaster.Caching/Buffers/MpscBoundedBuffer.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -14,6 +15,7 @@ namespace BitFaster.Caching.Buffers
     /// Based on BoundedBuffer by Ben Manes.
     /// https://github.com/ben-manes/caffeine/blob/master/caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedBuffer.java
     /// </remarks>
+    [DebuggerDisplay("Count = {Count}/{Capacity}")]
     public class MpscBoundedBuffer<T> where T : class
     {
         private T[] buffer;

BitFaster.Caching/Buffers/StripedMpscBuffer.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
 using System.Text;
 using System.Threading;
 
@@ -15,6 +17,7 @@ namespace BitFaster.Caching.Buffers
     /// rehashed to select a different buffer to retry up to 3 times. Using this approach
     /// writes scale linearly with number of concurrent threads.
     /// </summary>
+    [DebuggerDisplay("Count = {Count}/{Capacity}")]
     public class StripedMpscBuffer<T> where T : class
     {
         const int MaxAttempts = 3;
@@ -32,6 +35,8 @@ public StripedMpscBuffer(int stripeCount, int bufferSize)
             }
         }
 
+        public int Count => buffers.Sum(b => b.Count);
+
         public int Capacity => buffers.Length * buffers[0].Capacity;
 
         public int DrainTo(T[] outputBuffer)

BitFaster.Caching/Lfu/ConcurrentLfu.cs

@@ -31,6 +31,8 @@ namespace BitFaster.Caching.Lfu
     /// Based on Caffeine written by Ben Manes.
     /// https://www.apache.org/licenses/LICENSE-2.0
     /// </remarks>
+    [DebuggerTypeProxy(typeof(ConcurrentLfu<,>.LfuDebugView))]
+    [DebuggerDisplay("Count = {Count}/{Capacity}")]
     public sealed class ConcurrentLfu<K, V> : ICache<K, V>, IAsyncCache<K, V>, IBoundedPolicy
     {
         private const int MaxWriteBufferRetries = 100;
@@ -644,7 +646,7 @@ private void ReFitProtected()
             }
         }
 
-        [DebuggerDisplay("{Format()}")]
+        [DebuggerDisplay("{Format(),nq}")]
         private class DrainStatus
         {
             public const int Idle = 0;
@@ -687,7 +689,7 @@ public int Status()
             }
 
             [ExcludeFromCodeCoverage]
-            private string Format()
+            internal string Format()
             {
                 switch (this.drainStatus.Value)
                 {
@@ -705,7 +707,8 @@ private string Format()
             }
         }
 
-        private class CacheMetrics : ICacheMetrics
+        [DebuggerDisplay("Hit = {Hits}, Miss = {Misses}, Upd = {Updated}, Evict = {Evicted}")]
+        internal class CacheMetrics : ICacheMetrics
         {
             public long requestHitCount;
             public long requestMissCount;
@@ -741,6 +744,40 @@ public string FormatLruString()
             return sb.ToString();
         }
 #endif
+
+        [ExcludeFromCodeCoverage]
+        internal class LfuDebugView
+        {
+            private ConcurrentLfu<K, V> lfu;
+
+            public LfuDebugView(ConcurrentLfu<K, V> lfu)
+            {
+                this.lfu = lfu;
+            }
+
+            public string Maintenance => lfu.drainStatus.Format();
+
+            public ICacheMetrics Metrics => lfu.metrics;
+
+            public StripedMpscBuffer<LfuNode<K, V>> ReadBuffer => this.lfu.readBuffer;
+
+            public StripedMpscBuffer<LfuNode<K, V>> WriteBuffer => this.lfu.writeBuffer;
+
+            public KeyValuePair<K, V>[] Items
+            {
+                get
+                {
+                    var items = new KeyValuePair<K, V>[lfu.Count];
+
+                    int index = 0;
+                    foreach (var kvp in lfu)
+                    {
+                        items[index++] = kvp;
+                    }
+                    return items;
+                }
+            }
+        }
     }
 
     // Explicit layout cannot be a generic class member