ProfilerLogger.cs

using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;
using Cysharp.Text;
using Cysharp.Threading.Tasks;
using UnityEngine;
using Unity.Jobs.LowLevel.Unsafe;
using Unity.Profiling;

namespace Tests
{
    public class ProfilerLogger : MonoBehaviour
    {
        private ProfilerRecorder _frameTimeRecorder;
        private ProfilerRecorder _idleTimeRecorder;
        private ProfilerRecorder _systemMemoryRecorder;
        private ProfilerRecorder _gcAllocRecorder;

        private StreamWriter _writer;
        private float _startWriteTime;

        // Accumulators
        private double _frameTimeSum;
        private double _idleTimeSum;
        private long _gcAllocSum;
        private double _systemMemorySum;
        private int _frameCount;

        public void Init(List<string> selectedScenes, int numberOfBoids, string logFileArg)
        {
            _frameTimeRecorder = ProfilerRecorder.StartNew(
                ProfilerCategory.Render,
                "CPU Total Frame Time"
            );

            _idleTimeRecorder = ProfilerRecorder.StartNew(
                ProfilerCategory.Internal,
                "Idle"
            );
            
            _systemMemoryRecorder = ProfilerRecorder.StartNew(
                ProfilerCategory.Memory,
                "System Used Memory"
            );
            
            _gcAllocRecorder = ProfilerRecorder.StartNew(
                ProfilerCategory.Memory,
                "GC Allocated In Frame"
            );
            
            string filePath;
            using (var sb = ZString.CreateStringBuilder())
            {
                sb.Append("EEProfilerLog_");

                selectedScenes.Sort();
                for (var i = 0; i < selectedScenes.Count; i++)
                {
                    sb.Append(selectedScenes[i]);
                    if (i != selectedScenes.Count - 1)
                    {
                        sb.Append('+');
                    }
                }

                sb.Append('_');
                sb.Append(numberOfBoids);
                sb.Append("boids_");
                sb.Append(logFileArg);
                sb.Append(".csv");
                filePath = Path.Combine(Application.persistentDataPath, sb.ToString());
            }
            
            _writer = new StreamWriter(filePath, false, Encoding.UTF8, 4096);

            // Header
            _writer.WriteLine(
                "Time(s),FrameTimeAvg(ns),IdleTimeAvg(ns),SystemMemoryAvg(bytes),GCAllocTotal(bytes),JobWorkerCount"
            );
        }

        private async UniTaskVoid Accumulator(CancellationTokenSource cts)
        {
            while (!cts.Token.IsCancellationRequested)
            {
                // Clamping idle time is required as during lag frames it may go into negatives or exceed max value
                var idleTimeClamped = Mathf.Clamp(_idleTimeRecorder.LastValue, 0f,
                    _frameTimeRecorder.LastValue * JobsUtility.JobWorkerCount);
                
                // Accumulate per frame
                _frameTimeSum += _frameTimeRecorder.LastValue;
                _idleTimeSum += idleTimeClamped;
                _systemMemorySum += _systemMemoryRecorder.LastValue;
                _gcAllocSum += _gcAllocRecorder.LastValue;
                _frameCount++;
                
                await UniTask.Yield(PlayerLoopTiming.Update);
            }
        }

        public async UniTaskVoid RunLogger(CancellationTokenSource cts, float logInterval)
        {
            _startWriteTime = Time.unscaledTime;
            Accumulator(cts).Forget();
            
            while (!cts.Token.IsCancellationRequested)
            {
                await UniTask.WaitForSeconds(logInterval, true, PlayerLoopTiming.LastUpdate, cancellationToken: cts.Token);
                
                WriteLogEntry();
            }
        }

        private void WriteLogEntry()
        {
            var writeTime = Time.unscaledTime - _startWriteTime;
            var mainThreadTimeAvg = _frameTimeSum / _frameCount;
            var idleTimeAvg = _idleTimeSum / _frameCount;
            var systemMemoryAvg = _systemMemorySum / _frameCount;
            var gcAllocTotal = _gcAllocSum; // Total over an interval
            
            using(var sb = ZString.CreateStringBuilder())
            {
                sb.Append(writeTime); sb.Append(',');
                sb.Append(mainThreadTimeAvg); sb.Append(',');
                sb.Append(idleTimeAvg); sb.Append(',');
                sb.Append(systemMemoryAvg); sb.Append(',');
                sb.Append(gcAllocTotal); sb.Append(',');
                sb.Append(JobsUtility.JobWorkerCount);
                
                _writer.WriteLine(sb.AsSpan());
            }
            
            // Reset accumulators
            _frameTimeSum = 0;
            _idleTimeSum = 0;
            _systemMemorySum = 0;
            _gcAllocSum = 0;
            _frameCount = 0;
        }

        public void Shutdown()
        {
            WriteLogEntry(); // final entry
            
            _frameTimeRecorder.Dispose();
            _idleTimeRecorder.Dispose();
            _gcAllocRecorder.Dispose();
            _systemMemoryRecorder.Dispose();

            if (_writer != null)
            {
                _writer.Flush();
                _writer.Close();
            }
        }
    }
}