ImmutableHashSet.Contains is few times slower that HashSet.Contains

@jorive @valenis this is quite serious

from performance.

Queue<T>.Enqueue and Stack<T>.Push are slower than List<T>.Add

All 3 collections are just wrappers around the Array so adding an element should be on par.

-f *AddDefaultSize<Int32>.List *AddDefaultSize<Int32>.Stack *AddDefaultSize<Int32>.Queue --join

from performance.

ImmutableList.Contains is few times slower that List.Contains or LinkedList.Contains

-f *Contains*List --join

@jorive @valenis this is quite serious

from performance.

@danmosemsft I created the issues in CoreFX:

https://github.com/dotnet/corefx/issues/36405
https://github.com/dotnet/corefx/issues/36406
https://github.com/dotnet/corefx/issues/36407
https://github.com/dotnet/corefx/issues/36412
https://github.com/dotnet/corefx/issues/36413
https://github.com/dotnet/corefx/issues/36414
https://github.com/dotnet/corefx/issues/36415
https://github.com/dotnet/corefx/issues/36416

We have officially switched to the performance repo in CoreFX so next time I find a performance issue in CoreFX using performance repo I am going to create an issue in CoreFX

from performance.

ConcurrentDictionary.Clear and ConcurrentQueue.Clear allocates memory

From the code it looks like it's by design.

where T : Int32

Note: 1ns for value types with no nested references is not a bug, the collections do simply array = null or head = null and that's it ;)

from performance.

ImmutableDictionary.ContainsKey is few times slower than Dictionary.ContainsKey or even ConcurrentDictionary.ContainsKey

-f *ContainsKey*Dictionary --join

@jorive @valenis another perf issue with immutable collections

from performance.

Creating ImmutableDictionary from an existing dictionary is very slow

-f *CtorFromCollection*Dictionary --join

@jorive @valenis another perf issue with immutable collections

from performance.

Creating ImmutableHashSet from an existing collection is very slow

-f *CtorFromCollection*HashSet --join

another perf issue with immutable collections

from performance.

Creating Stack and Queue takes slighly more time than creating List

All 3 collections are just wrappers around the Array so creating them should be on par.

from performance.

Indexer.Set of List is much slower than Array

[Benchmark]
public T[] Array()
{
    var array = _array;
    for (int i = 0; i < array.Length; i++)
        array[i] = default;
    return array;
}

[Benchmark]
public List<T> List()
{
    var list = _list;
    for (int i = 0; i < list.Count; i++)
        list[i] = default;
    return list;
}

-f *IndexerSet*.List *IndexerSet*.Array --join

from performance.

Iterating with ForEach over Immutable collections is very slow

foreach over Array is implemented in CLR to match for loop with the performance, I wonder how much effor would it cost to add similar support for ImmutableArray

from performance.

@adamsitnik nice findings! :) … I'm surprised by those huge differences in such a trivial scenarios.

from performance.

What to do here -- seems to me each of these findings could become an issue in CoreFX perhaps for community interest, then we coud close this?

from performance.