feat: implement profiling utilities

Author: mnicolas94

Runtime/Collections.meta

@@ -0,0 +1,48 @@
+using System;
+
+namespace Utils.Collections
+{
+    // source: https://gist.github.com/adammyhre/51aed0c1168ed7fcedf3d6ca6f5c036b (git-amend)
+    // A fixed-size ring buffer that overwrites the oldest entries when full.
+    public class CircularBuffer<T>
+    {
+        readonly T[] buffer;
+        int head, tail;
+        public int Count { get; private set; }
+        public int Capacity => buffer.Length;
+
+        public CircularBuffer(int size)
+        {
+            if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size));
+            buffer = new T[size];
+        }
+
+        public void Enqueue(T item)
+        {
+            buffer[head] = item;
+            head = (head + 1) % Capacity;
+            if (Count == Capacity) tail = (tail + 1) % Capacity;
+            else Count++;
+        }
+
+        public T Dequeue()
+        {
+            if (Count == 0) throw new InvalidOperationException("Buffer is empty");
+            var item = buffer[tail];
+            tail = (tail + 1) % Capacity;
+            Count--;
+            return item;
+        }
+    
+        // Access elements by logical index (0 = oldest, Count-1 = newest)
+        public T this[int index]
+        {
+            get
+            {
+                if ((uint)index >= (uint)Count) throw new ArgumentOutOfRangeException(nameof(index));
+                if (Capacity == 0 || buffer == null) throw new InvalidOperationException();
+                return buffer[(tail + index) % Capacity];
+            }
+        }
+    }
+}

Runtime/Collections/CircularBuffer.cs

@@ -0,0 +1,41 @@
+using System;
+using UnityEngine.Profiling;
+
+namespace Utils.Profiling
+{
+    // I took it from git-amend's YouTube channel: https://www.youtube.com/watch?v=ham_w48aRJ4
+    // See UnityEngine.TestTools.Constraints.AllocatingGCMemoryConstraint
+    // and https://maingauche.games/devlog/20230504-counting-allocations-in-unity/
+    public class AllocCounter
+    {
+        private Recorder _rec;
+
+        public AllocCounter()
+        {
+            _rec = Recorder.Get("GC.Alloc");
+            _rec.enabled = false;
+
+#if !UNITY_WEBGL
+            _rec.FilterToCurrentThread();
+#endif
+            
+            _rec.enabled = true;
+            
+        }
+
+        public int Stop()
+        {
+            if (_rec == null) throw new InvalidOperationException("AllocCounter was not started.");
+            
+            _rec.enabled = false;
+            
+#if !UNITY_WEBGL
+            _rec.CollectFromAllThreads();
+#endif
+
+            var result = _rec.sampleBlockCount;
+            _rec = null;
+            return result;
+        }
+    }
+}