_zero_ cost resize of ArenaList in some cases

Author: FlurinBruehwiler

Flamui/Arena.cs

@@ -7,6 +7,12 @@ public class Arena : IDisposable
 {
     public VirtualBuffer VirtualBuffer;
 
+    /// <summary>
+    /// Counts how many allocations happened (calls to <see cref="Allocate{T}"/> or <see cref="AllocateSlice{T}"/>)
+    /// This is useful for dynamic arrays that can make growing more efficient when no other allocation happened in between resizes
+    /// </summary>
+    public int AllocNum { get; private set; }
+
     private readonly Dictionary<object, GCHandle> objectToHandle = [];
 
     public Arena(VirtualBuffer virtualBuffer)
@@ -33,6 +39,7 @@ public ManagedRef<T> AddReference<T>(T obj) where T : class
 
     public void Reset()
     {
+        AllocNum = 0;
         VirtualBuffer.Reset();
         foreach (var (_, value) in objectToHandle)
         {
@@ -43,6 +50,8 @@ public void Reset()
 
     public unsafe T* Allocate<T>(T value) where T : unmanaged
     {
+        AllocNum++;
+
         var span = VirtualBuffer.AllocateRange(sizeof(T));
         fixed (byte* ptr = span)
         {
@@ -54,6 +63,8 @@ public void Reset()
 
     public unsafe Slice<T> AllocateSlice<T>(int count) where T : unmanaged
     {
+        AllocNum++;
+
         if (count == 0)
             return new Slice<T>(null, 0);
 

Flamui/ArenaList.cs

@@ -2,35 +2,59 @@
 
 namespace Flamui;
 
+//todo, implement IEnumerable
+
+/// <summary>
+/// Basic dynamic array on the arena
+/// </summary>
+/// <typeparam name="T"></typeparam>
 public struct ArenaList<T> where T : unmanaged
 {
     private Arena? _arena;
     private Slice<T> _backingSlice;
+    private int _backingSliceAllocateNum;
 
     public int Count;
     public int Capacity => _backingSlice.Count;
 
     public ArenaList(Arena arena, int initialCapacity)
     {
+        ArgumentNullException.ThrowIfNull(arena);
+        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(initialCapacity);
+
         _arena = arena;
         _backingSlice = _arena.AllocateSlice<T>(initialCapacity);
+        _backingSliceAllocateNum = _arena.AllocNum;
     }
 
-    public void Add(T value)
+    public unsafe void Add(T value)
     {
         _arena ??= Ui.Arena;
         if (Capacity == 0) //in case the ArenaList isn't initialized via the constructor
         {
             _backingSlice = _arena.AllocateSlice<T>(1);
+            _backingSliceAllocateNum = _arena.AllocNum;
         }
 
         Debug.Assert(Count <= Capacity);
 
         if (Count == Capacity)
         {
-            var newSlice = _arena.AllocateSlice<T>(Capacity * 2);
-            _backingSlice.Span.CopyTo(newSlice.Span);
-            _backingSlice = newSlice;
+            //if there hasn't been another allocation on the arena, we don't need to allocate a new slice, we can just "extend" the current one
+
+            //todo, this isn't really elegant or easy to understand, would be better to have a method directly on the
+            //arena, that can tell you if a slice is at the end of the arena, and therefore allows *zero* cost resize
+            if (_backingSliceAllocateNum == _arena.AllocNum)
+            {
+                _arena.AllocateSlice<T>(_backingSlice.Count);
+                _backingSlice = new Slice<T>(_backingSlice.Items, _backingSlice.Count * 2);
+            }
+            else
+            {
+                var newSlice = _arena.AllocateSlice<T>(Capacity * 2);
+                _backingSlice.Span.CopyTo(newSlice.Span);
+                _backingSlice = newSlice;
+            }
         }
 
         _backingSlice[Count] = value;