Search for optimization opportunities in the distributed broadcast logic

I've been watching slskd metrics after upgrading to .NET 7, and one thing that is really jumping out at me is the correlation between garbage collection frequency, CPU utilization, and the number of distributed children:

The broadcast logic accounts for 100% of this activity, since it is the only part of the library that scales with the number of distributed children. There isn't much to the code, either:

        /// <summary>
        ///     Asynchronously writes the specified bytes to each of the connected child connections.
        /// </summary>
        /// <param name="bytes">The bytes to write.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>The operation context.</returns>
        public async Task BroadcastMessageAsync(byte[] bytes, CancellationToken? cancellationToken = null)
        {
            cancellationToken ??= CancellationToken.None;

            async Task Write(KeyValuePair<string, Lazy<Task<IMessageConnection>>> child, byte[] bytes, CancellationToken? cancellationToken)
            {
                IMessageConnection connection = default;

                try
                {
                    connection = await child.Value.Value.ConfigureAwait(false);

                    if (connection.State == ConnectionState.Connected)
                    {
                        await connection.WriteAsync(bytes, cancellationToken).ConfigureAwait(false);
                    }
                }
                catch (Exception ex)
                {
                    connection?.Disconnect($"Broadcast failure: {ex.Message}");
                }
            }

            var sw = new Stopwatch();
            sw.Start();

            var tasks = new List<Task>();

            foreach (var child in ChildConnectionDictionary)
            {
                tasks.Add(Write(child, bytes, cancellationToken));
            }

            await Task.WhenAll(tasks).ConfigureAwait(false);

            sw.Stop();

            if (!AverageBroadcastLatency.HasValue)
            {
                AverageBroadcastLatency = sw.ElapsedMilliseconds;
            }
            else
            {
                // EMA
                AverageBroadcastLatency = ((sw.ElapsedMilliseconds - AverageBroadcastLatency) * LatencyAlpha) + AverageBroadcastLatency;
            }
        }

Take a look at this code, as well as the underlying WriteAsync method, to see if there are any opportunities to reduce CPU or memory overhead (without losing functionality)

jpdillingham / Soulseek.NET

Search for optimization opportunities in the distributed broadcast logic #773