Add more benchmarks. (#12)

Author: jlao

Benchmark/Benchmark.csproj

@@ -7,6 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.11.4" />
+    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.11.4" />
   </ItemGroup>
 
   <ItemGroup>

Benchmark/HashCollisions.cs

@@ -0,0 +1,55 @@
+using CacheTable;
+using System;
+using BenchmarkDotNet.Attributes;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+
+namespace Benchmark
+{
+    [CoreJob]
+    [RPlotExporter, RankColumn]
+    public class HashCollisions
+    {
+        private readonly CacheTable<WrappedInt, int> cacheTable = new CacheTable<WrappedInt, int>(10, 4);
+        private readonly ConcurrentCacheTable<WrappedInt, int> concurrentCacheTable = new ConcurrentCacheTable<WrappedInt, int>(10, 4, Environment.ProcessorCount);
+        private readonly Dictionary<WrappedInt, int> dictionary = new Dictionary<WrappedInt, int>();
+        private readonly ConcurrentDictionary<WrappedInt, int> concurrentDictionary = new ConcurrentDictionary<WrappedInt, int>();
+
+        struct WrappedInt : IEquatable<WrappedInt>
+        {
+            public int Value;
+
+            public bool Equals(WrappedInt other) => this.Value == other.Value;
+
+            public override int GetHashCode() => 42;
+
+            public override bool Equals(object obj) => this.Equals((WrappedInt)obj);
+
+            public static implicit operator WrappedInt(int i) => new WrappedInt { Value = i };
+        }
+
+        [Benchmark]
+        public void CacheTable()
+        {
+            for (int i = 0; i < 4; i++) this.cacheTable[i] = i;
+        }
+
+        [Benchmark]
+        public void ConcurrentCacheTable()
+        {
+            for (int i = 0; i < 4; i++) this.concurrentCacheTable[i] = i;
+        }
+
+        [Benchmark(Baseline = true)]
+        public void Dictionary()
+        {
+            for (int i = 0; i < 4; i++) this.dictionary[i] = i;
+        }
+
+        [Benchmark]
+        public void ConcurrentDictionary()
+        {
+            for (int i = 0; i < 4; i++) this.concurrentDictionary[i] = i;
+        }
+    }
+}

Benchmark/SetSingleItem.cs Benchmark/SetSingleInt.csBenchmark/SetSingleItem.cs renamed to Benchmark/SetSingleInt.cs

@@ -8,7 +8,7 @@ namespace Benchmark
 {
     [CoreJob]
     [RPlotExporter, RankColumn]
-    public class SetSingleItem
+    public class SetSingleInt
     {
         private readonly CacheTable<int, int> cacheTable = new CacheTable<int, int>(10, 4);
         private readonly ConcurrentCacheTable<int, int> concurrentCacheTable = new ConcurrentCacheTable<int, int>(10, 4, Environment.ProcessorCount);

Benchmark/SetSingleString.cs

@@ -0,0 +1,65 @@
+using CacheTable;
+using System;
+using BenchmarkDotNet.Attributes;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+
+namespace Benchmark
+{
+    [CoreJob]
+    [RPlotExporter, RankColumn]
+    public class SetSingleString
+    {
+        private static readonly WrappedString Zero = "0";
+
+        private readonly CacheTable<WrappedString, int> cacheTable = new CacheTable<WrappedString, int>(10, 4);
+        private readonly ConcurrentCacheTable<WrappedString, int> concurrentCacheTable = new ConcurrentCacheTable<WrappedString, int>(10, 4, Environment.ProcessorCount);
+        private readonly Dictionary<WrappedString, int> dictionary = new Dictionary<WrappedString, int>();
+        private readonly ConcurrentDictionary<WrappedString, int> concurrentDictionary = new ConcurrentDictionary<WrappedString, int>();
+
+        // Wrap the string because Dictionary has special code to optimize
+        // string hashing. This levels the playing field.
+        struct WrappedString : IEquatable<WrappedString>
+        {
+            public string Value;
+
+            public bool Equals(WrappedString other) => this.Value.Equals(other.Value);
+
+            public override int GetHashCode() => this.Value.GetHashCode();
+
+            public override bool Equals(object obj) => this.Equals((WrappedString)obj);
+
+            public static implicit operator WrappedString(string str) => new WrappedString { Value = str };
+        }
+
+        [Benchmark]
+        public void CacheTable()
+        {
+            this.cacheTable[Zero] = 0;
+        }
+
+        [Benchmark]
+        public void ConcurrentCacheTable()
+        {
+            this.concurrentCacheTable[Zero] = 0;
+        }
+
+        [Benchmark]
+        public void Dictionary()
+        {
+            this.dictionary[Zero] = 0;
+        }
+
+        [Benchmark]
+        public void ConcurrentDictionary()
+        {
+            this.concurrentDictionary[Zero] = 0;
+        }
+
+        [Benchmark(Baseline = true)]
+        public int Hash()
+        {
+            return Zero.GetHashCode();
+        }
+    }
+}