Collections benchmarks rewrite

src/benchmarks/Benchmarks.csproj

@@ -6,15 +6,15 @@
     <DebugType>pdbonly</DebugType>
     <DebugSymbols>true</DebugSymbols>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="img\**" />
     <EmbeddedResource Remove="img\**" />
     <None Remove="img\**" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.10.14.665" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.10.14.683" />
     <PackageReference Include="CommandLineParser" Version="2.2.1" />
     <PackageReference Include="Jil" Version="2.15.4" />
     <PackageReference Include="MessagePack" Version="1.7.3.4" />

src/benchmarks/Categories.cs

@@ -16,5 +16,8 @@ public static class Categories
         public const string LINQ = "LINQ";
         public const string SIMD = "SIMD";
         public const string Span = "Span";
+        public const string Collections = "Collections";
+        public const string GenericCollections = "GenericCollections";
+        public const string NonGenericCollections = "NonGenericCollections";
     }
 }

src/benchmarks/corefx/Common/UniqueValuesGenerator.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Helpers
+{
+    internal static class UniqueValuesGenerator
+    {
+        internal static T[] GenerateArray<T>(int count)
+        {
+            var random = new Random(12345); // we always use the same seed to have repeatable results!
+
+            var uniqueValues = new HashSet<T>();
+
+            while (uniqueValues.Count != count)
+            {
+                T value = GenerateValue<T>(random);
+
+                if (!uniqueValues.Contains(value))
+                    uniqueValues.Add(value);
+            }
+
+            return uniqueValues.ToArray();
+        }
+
+        internal static Dictionary<TKey, TValue> GenerateDictionary<TKey, TValue>(int count)
+        {
+            var random = new Random(12345); // we always use the same seed to have repeatable results!
+
+            var dictionary = new Dictionary<TKey, TValue>();
+
+            while (dictionary.Count != count)
+            {
+                TKey key = GenerateValue<TKey>(random);
+
+                if (!dictionary.ContainsKey(key))
+                    dictionary.Add(key, GenerateValue<TValue>(random));
+            }
+
+            return dictionary;
+        }
+
+        private static T GenerateValue<T>(Random random)
+        {
+            if (typeof(T) == typeof(int))
+                return (T)(object)random.Next();
+            if (typeof(T) == typeof(double))
+                return (T)(object)random.NextDouble();
+            if (typeof(T) == typeof(string))
+                return (T)(object)Guid.NewGuid().ToString(); // I am open to better ideas!
+
+            throw new NotImplementedException($"{typeof(T).Name} is not implemented");
+        }
+    }
+}

src/benchmarks/corefx/System.Collections/Add/AddDefaultSize.cs

@@ -0,0 +1,142 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using BenchmarkDotNet.Attributes;
+using Benchmarks;
+using Helpers;
+
+namespace System.Collections
+{
+    [BenchmarkCategory(Categories.CoreFX, Categories.Collections, Categories.GenericCollections)]
+    [GenericTypeArguments(typeof(int))] // value type
+    [GenericTypeArguments(typeof(string))] // reference type
+    public class AddDefaultSize<T>
+    {
+        private T[] _uniqueValues;
+
+        [Params(Utils.DefaultCollectionSize)]
+        public int Count;
+
+        [GlobalSetup]
+        public void Setup() => _uniqueValues = UniqueValuesGenerator.GenerateArray<T>(Count);
+
+        [Benchmark]
+        public List<T> List()
+        {
+            var collection = new List<T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public HashSet<T> HashSet()
+        {
+            var collection = new HashSet<T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public Dictionary<T, T> Dictionary()
+        {
+            var collection = new Dictionary<T, T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i], uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public SortedList<T, T> SortedList()
+        {
+            var collection = new SortedList<T, T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i], uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public SortedSet<T> SortedSet()
+        {
+            var collection = new SortedSet<T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public SortedDictionary<T, T> SortedDictionary()
+        {
+            var collection = new SortedDictionary<T, T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i], uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public ConcurrentBag<T> ConcurrentBag()
+        {
+            var collection = new ConcurrentBag<T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public Queue<T> Queue()
+        {
+            var collection = new Queue<T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Enqueue(uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public Stack<T> Stack()
+        {
+            var collection = new Stack<T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Push(uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public ConcurrentQueue<T> ConcurrentQueue()
+        {
+            var collection = new ConcurrentQueue<T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Enqueue(uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public ConcurrentStack<T> ConcurrentStack()
+        {
+            var collection = new ConcurrentStack<T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Push(uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public ConcurrentDictionary<T, T> ConcurrentDictionary()
+        {
+            var collection = new ConcurrentDictionary<T, T>();
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.TryAdd(uniqueValues[i], uniqueValues[i]);
+            return collection;
+        }
+    }
+}

src/benchmarks/corefx/System.Collections/Add/AddGivenSize.cs

@@ -0,0 +1,94 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using BenchmarkDotNet.Attributes;
+using Benchmarks;
+using Helpers;
+
+namespace System.Collections
+{
+    [BenchmarkCategory(Categories.CoreFX, Categories.Collections, Categories.GenericCollections)]
+    [GenericTypeArguments(typeof(int))] // value type
+    [GenericTypeArguments(typeof(string))] // reference type
+    public class AddGivenSize<T>
+    {
+        private T[] _uniqueValues;
+
+        [Params(Utils.DefaultCollectionSize)]
+        public int Count;
+
+        [GlobalSetup]
+        public void Setup() => _uniqueValues = UniqueValuesGenerator.GenerateArray<T>(Count);
+
+        [Benchmark]
+        public List<T> List()
+        {
+            var collection = new List<T>(Count);
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i]);
+            return collection;
+        }
+
+#if !NET461 // API added in .NET Core 2.0
+        [Benchmark]
+        public HashSet<T> HashSet()
+        {
+            var collection = new HashSet<T>(Count);
+            var uniqueValues = _uniqueValues;
+            for(int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i]);
+            return collection;
+        }
+#endif
+
+        [Benchmark]
+        public Dictionary<T, T> Dictionary()
+        {
+            var collection = new Dictionary<T, T>(Count);
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i], uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public SortedList<T, T> SortedList()
+        {
+            var collection = new SortedList<T, T>(Count);
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Add(uniqueValues[i], uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public Queue<T> Queue()
+        {
+            var collection = new Queue<T>(Count);
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Enqueue(uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public Stack<T> Stack()
+        {
+            var collection = new Stack<T>(Count);
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.Push(uniqueValues[i]);
+            return collection;
+        }
+
+        [Benchmark]
+        public ConcurrentDictionary<T, T> ConcurrentDictionary()
+        {
+            var collection = new ConcurrentDictionary<T, T>(Utils.ConcurrencyLevel, Count);
+            var uniqueValues = _uniqueValues;
+            for (int i = 0; i < uniqueValues.Length; i++)
+                collection.TryAdd(uniqueValues[i], uniqueValues[i]);
+            return collection;
+        }
+    }
+}

src/benchmarks/corefx/System.Collections/Add/TryAddDefaultSize.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using BenchmarkDotNet.Attributes;
+using Benchmarks;
+using Helpers;
+
+namespace System.Collections
+{
+    [BenchmarkCategory(Categories.CoreFX, Categories.Collections, Categories.GenericCollections)]
+    [GenericTypeArguments(typeof(int))] // value type
+    [GenericTypeArguments(typeof(string))] // reference type
+    public class TryAddDefaultSize<T>
+    {
+        private T[] _uniqueValues;
+
+        [Params(Utils.DefaultCollectionSize)]
+        public int Count;
+
+        [GlobalSetup]
+        public void Setup() => _uniqueValues = UniqueValuesGenerator.GenerateArray<T>(Count);
+
+#if !NET461 // API added in .NET Core 2.0
+        [Benchmark]
+        public Dictionary<T, T> Dictionary()
+        {
+            var collection = new Dictionary<T, T>();
+            var uniqueValues = _uniqueValues;
+            for(int i = 0; i < uniqueValues.Length; i++)
+                collection.TryAdd(uniqueValues[i], uniqueValues[i]);
+            return collection;
+        }
+#endif
+
+        [Benchmark]
+        public ConcurrentDictionary<T, T> ConcurrentDictionary()
+        {
+            var collection = new ConcurrentDictionary<T, T>();
+            var uniqueValues = _uniqueValues;
+            for(int i = 0; i < uniqueValues.Length; i++)
+                collection.TryAdd(uniqueValues[i], uniqueValues[i]);
+            return collection;
+        }
+    }
+}