Gen-0 collections happens more frequently on macOS

[smoogipoo]

We've observed the GC running much more frequently on .NET Core 3.0 preview 5 than .NET Core 2.2.5 on macOS.

The data I provide may be replicated via the following benchmark:

[MemoryDiagnoser]
public class ConcurrentQueueBenchmarks
{
    [Benchmark]
    public ConcurrentQueue<int> Queue()
    {
        return new ConcurrentQueue<int>();
    }
}

Method	Mean	Error	StdDev	Gen 0	Gen 1	Gen 2	Allocated
macOS (.NET Core 2.2.5)	96.63 ns	0.8469 ns	0.7922 ns	0.2441	-	-	768 B
macOS (.NET Core 3.0-preview5)	278.4 ns	1.203 ns	1.066 ns	3.5210	-	-	576 B
Windows (.NET Core 2.2.5)	104.2 ns	2.094 ns	1.958 ns	0.2440	-	-	768 B
Windows (.NET Core 3.0-preview5)	97.15 ns	0.5990 ns	0.5002 ns	0.1836	-	-	576 B
Ubuntu 18.04 (.NET Core 2.2.5)	113.8 ns	7.344 ns	21.42 ns	0.2440	-	-	768 B
Ubuntu 18.04 (.NET Core 3.0-preview5)	93.64 ns	5.161 ns	15.22 ns	0.1836	-	-	576 B

This is not only exhibited by ConcurrentQueue; for example, Lazy experiences a similar ~10x increase in Gen 0 collections per 1000 instances.

I'm unsure of how to debug this further (please let me know how to, if required) - going this deep into the CLR without memory profiling tools on macOS is outside of my area of expertise at the moment.

[stephentoub]

cc: @Maoni0

[Maoni0]

cc @sergiy-k, @Andy-MS
do we see the same thing on Windows and Linux? it would be a lot easier to debug there (especially if we can repro this on windows).

[smoogipoo]

This does not happen on Ubuntu 18.04 (added results to the OP) nor Windows.

Can confirm that on windows and linux, there is a decrease in gen0 collections with ConcurrentQueue<int>, and a very small increase for object or Lazy<int>. Testing with:

using System;
using System.Collections.Concurrent;

class Program
{
    static void Main(string[] args)
    {
        object o;
        for (int i = 0; i < 100_000_000; i++)
        {
            o = new Lazy<int>(); // fill in your type here
        }

        for (int gen = 0; gen <= 2; gen++)
        {
            Console.WriteLine($"Gen {gen}: {GC.CollectionCount(gen)}");
        }
    }
}

(Building in debug mode, otherwise the code is optimized away for object; though ConcurrentQueue and Lazy<int> seem the same either way.)
Do we have any macs to test on?

[smoogipoo]

@Andy-MS on mac I get:

With Lazy:

.NET Core 2.2.5:
Gen 0: 2288
Gen 1: 0
Gen 2: 0

.NET Core 3.0:
Gen 0: 44067
Gen 1: 0
Gen 2: 0

With ConcurrentQueue:

.NET Core 2.2.5:
Gen 0: 24414
Gen 1: 0
Gen 2: 0

.NET Core 3.0:
Gen 0: 352107
Gen 1: 1
Gen 2: 0

@smoogipoo Thanks, I got access to a mac and can easily reproduce this with just object.

[smoogipoo]

Is the fix for this supposed to be in preview 6? These are the current stats for construction of object:

Runtime	Mean	Error	StdDev	Gen 0/1k Op	Gen 1/1k Op	Gen 2/1k Op	Allocated Memory/Op
2.2.5	4.580 ns	0.0334 ns	0.0279 ns	0.0076	-	-	24 B
3.0.0-preview5-27626-15	9.348 ns	0.1417 ns	0.1326 ns	0.1469	-	-	24 B
3.0.0-preview6-27804-01	8.938 ns	0.1034 ns	0.0916 ns	0.1469	-	-	24 B

[Maoni0]

@Andy-MS

[sergiy-k]

This is not in Preview 6. It was merged too late. It is included into Preview 7.