perf: reuse counter snapshot buffer in CounterGroup.OnTimer

[unsafePtr]

CounterGroup.OnTimer allocates a fresh DiagnosticCounter[] snapshot every poll to copy the counter list. In practice the counter set is fixed at EventSource construction and rarely changes. Reuse a per-instance buffer instead, grow on demand, and clear trailing slots for disposed counters.

[dotnet-policy-service]

Tagging subscribers to this area: @steveisok, @dotnet/area-system-diagnostics-tracing
See info in area-owners.md if you want to be subscribed.

[tarekgh]

race condition can be raised? The _onTimerCounters is allocated/resized and then filled using _counters.CopyTo inside the s_counterGroupLock but later it is used outside the lock. This means theoretically _onTimerCounters or its contents can be changed before executing the next foreach loop.

I would suggest instead of doing that, we can use ArrayPool?

[unsafePtr]

There is only a single thread executing PollForValues

runtime/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/CounterGroup.cs

Lines 171 to 175 in 458c690

	s_pollingThread = new Thread(PollForValues)
	{
	IsBackground = true,
	Name = ".NET Counter Poller"
	};

OnTimer itself is called sequentially in a foreach within PollForValues

runtime/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/CounterGroup.cs

Lines 334 to 337 in 458c690

	foreach (CounterGroup onTimer in onTimers)
	{
	onTimer.OnTimer();
	}

There is no parrallel accessed pattern, and if _counters are modified, we are protected under s_counterGroupLock lock. _onTimerCounters is only ever read or written inside OnTimer.

In practice the counter set is fixed at first Enable and never mutated afterward. ArrayPool would pay Rent/Return overhead on every tick for a buffer that, in practice, never needs to be returned.

[unsafePtr]

When it would be possible to do stackalloc DiagnosticCounter[_counters.Count] it would be an easy change here. Actually now thinking about it again, we can do [InlineArray] for small counts (maybe below 32?). As it seems the max count of RuntimeEventSource is 27 counters. And use ValueListBuilder which switches to ArrayPool when there is no enough space.

i.e.

[InlineArray(32)]
private struct CounterScratch
{
    private DiagnosticCounter? _element0;
}

CounterScratch scratch = default; 
var builder = new ValueListBuilder<DiagnosticCounter>(scratch);

// instead of  _onTimerCounters = new DiagnosticCounter[counterCount];
counterCount = _counters.Count;
Span<DiagnosticCounter> dst = builder.AppendSpan(counterCount);
CollectionsMarshal.AsSpan(_counters).CopyTo(dst);

Seems to be an elegant solution, and this way we avoid holding an array. Will wait for your judgment before doing the change.

[unsafePtr]

Cleaning so we don't hold any references, and GC can collect them in case if _counters is updated