[Core] WIP on Freeform Allocator;

Author: LittleCodingFox

Engine/Staple.Core.Tests/FreeformAllocatorTests.cs

@@ -0,0 +1,159 @@
+using Staple.Utilities;
+using System.Numerics;
+
+namespace CoreTests;
+
+internal class FreeformAllocatorTests
+{
+    [Test]
+    public void TestAllocate()
+    {
+        var allocator = new FreeformAllocator<Vector2>();
+
+        var entry = allocator.Allocate(20);
+
+        Assert.That(entry.start, Is.EqualTo(0));
+        Assert.That(entry.length, Is.EqualTo(20));
+
+        var second = allocator.Allocate(30);
+
+        Assert.That(second.start, Is.EqualTo(20));
+        Assert.That(second.length, Is.EqualTo(30));
+
+        Assert.That(allocator.buffer.Length, Is.EqualTo(50));
+
+        var span = allocator.Get(entry);
+
+        Assert.That(span.Length, Is.EqualTo(20));
+
+        span = allocator.Get(second);
+
+        Assert.That(span.Length, Is.EqualTo(30));
+    }
+
+    [Test]
+    public void TestFree()
+    {
+        var allocator = new FreeformAllocator<Vector2>();
+
+        var entry = allocator.Allocate(20);
+
+        Assert.That(entry.start, Is.EqualTo(0));
+        Assert.That(entry.length, Is.EqualTo(20));
+
+        var second = allocator.Allocate(30);
+
+        Assert.That(second.start, Is.EqualTo(20));
+        Assert.That(second.length, Is.EqualTo(30));
+
+        allocator.Free(entry);
+
+        Assert.That(entry.freed, Is.True);
+
+        Assert.That(allocator.freeEntries, Has.Count.EqualTo(1));
+
+        var free = allocator.freeEntries.FirstOrDefault();
+
+        Assert.That(free.start, Is.EqualTo(0));
+        Assert.That(free.length, Is.EqualTo(20));
+    }
+
+    [Test]
+    public void TestCompact()
+    {
+        var allocator = new FreeformAllocator<Vector2>();
+
+        var entry = allocator.Allocate(20);
+
+        Assert.That(entry.start, Is.EqualTo(0));
+        Assert.That(entry.length, Is.EqualTo(20));
+
+        var span = allocator.Get(entry);
+
+        Assert.That(span.Length, Is.EqualTo(20));
+
+        for(var i = 0; i < span.Length; i++)
+        {
+            span[i] = Vector2.One;
+        }
+
+        var second = allocator.Allocate(30);
+
+        Assert.That(second.start, Is.EqualTo(20));
+        Assert.That(second.length, Is.EqualTo(30));
+
+        span = allocator.Get(second);
+
+        Assert.That(span.Length, Is.EqualTo(30));
+
+        for (var i = 0; i < span.Length; i++)
+        {
+            Assert.That(span[i], Is.EqualTo(Vector2.Zero));
+
+            span[i] = new(0, 1);
+        }
+
+        allocator.Free(entry);
+
+        Assert.That(allocator.freeEntries, Has.Count.EqualTo(1));
+
+        var free = allocator.freeEntries.FirstOrDefault();
+
+        Assert.That(free.start, Is.EqualTo(0));
+        Assert.That(free.length, Is.EqualTo(20));
+
+        entry = allocator.Allocate(10);
+
+        Assert.That(entry.start, Is.EqualTo(0));
+        Assert.That(entry.length, Is.EqualTo(10));
+
+        span = allocator.Get(entry);
+
+        Assert.That(span.Length, Is.EqualTo(10));
+
+        for (var i = 0; i < span.Length; i++)
+        {
+            Assert.That(span[i], Is.EqualTo(Vector2.One));
+
+            span[i] = Vector2.Zero;
+        }
+
+        var third = allocator.Allocate(20);
+
+        Assert.That(entry.start, Is.EqualTo(0));
+        Assert.That(entry.length, Is.EqualTo(10));
+
+        Assert.That(second.start, Is.EqualTo(10));
+        Assert.That(second.length, Is.EqualTo(30));
+
+        Assert.That(third.start, Is.EqualTo(40));
+        Assert.That(third.length, Is.EqualTo(20));
+
+        span = allocator.Get(entry);
+
+        for (var i = 0; i < span.Length; i++)
+        {
+            Assert.That(span[i], Is.EqualTo(Vector2.Zero));
+        }
+
+        Assert.That(span.Length, Is.EqualTo(10));
+
+        span = allocator.Get(second);
+
+        for (var i = 0; i < span.Length; i++)
+        {
+            Assert.That(span[i], Is.EqualTo(new Vector2(0, 1)));
+        }
+
+        Assert.That(span.Length, Is.EqualTo(30));
+
+        span = allocator.Get(third);
+
+        Assert.That(span.Length, Is.EqualTo(20));
+
+        for (var i = 0; i < span.Length; i++)
+        {
+            Assert.That(span[i], Is.EqualTo(Vector2.Zero));
+        }
+    }
+}

Engine/Staple.Core/Staple.Core.csproj

@@ -412,6 +412,7 @@
 		<Compile Include="Serialization\App\AppSettingsHeader.cs" />
 		<Compile Include="Utilities\DictionaryExtensions.cs" />
 		<Compile Include="Utilities\ExpandableContainer.cs" />
+		<Compile Include="Utilities\FreeformAllocator.cs" />
 		<Compile Include="Utilities\GuidGenerator.cs" />
 		<Compile Include="Utilities\IntLookupCache.cs" />
 		<Compile Include="Utilities\ObjectCreation.cs" />

Engine/Staple.Core/Utilities/FreeformAllocator.cs

@@ -0,0 +1,185 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Staple.Utilities;
+
+internal class FreeformAllocator<T> where T: unmanaged
+{
+    public class Entry
+    {
+        public int start;
+        public int length;
+        public bool freed = false;
+    }
+
+    internal readonly List<Entry> freeEntries = [];
+
+    private readonly List<Entry> entries = [];
+
+    public T[] buffer = [];
+
+    private GCHandle pinHandle;
+
+    internal nint pinAddress;
+
+    private readonly int elementSize = Marshal.SizeOf<T>();
+
+    private void Repin()
+    {
+        if (pinHandle.IsAllocated)
+        {
+            pinHandle.Free();
+        }
+
+        pinHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+
+        pinAddress = pinHandle.AddrOfPinnedObject();
+    }
+
+    public void EnsurePin()
+    {
+        if (pinHandle.IsAllocated == false)
+        {
+            pinHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+        }
+    }
+
+    public Entry Allocate(int length)
+    {
+        Entry outValue = null;
+
+        if (freeEntries.Count == 0)
+        {
+            var start = buffer.Length;
+
+            Array.Resize(ref buffer, buffer.Length + length);
+
+            outValue = new Entry()
+            {
+                start = start,
+                length = length,
+            };
+
+            entries.Add(outValue);
+
+            return outValue;
+        }
+
+        for (var i = 0; i < freeEntries.Count; i++)
+        {
+            var entry = freeEntries[i];
+
+            if (length <= entry.length)
+            {
+                freeEntries.RemoveAt(i);
+
+                var difference = entry.length - length;
+
+                if(difference > 0)
+                {
+                    freeEntries.Add(new()
+                    {
+                        start = entry.start + length,
+                        length = difference,
+                        freed = true,
+                    });
+                }
+
+                outValue = new Entry()
+                {
+                    start = entry.start,
+                    length = length,
+                };
+
+                entries.Add(outValue);
+
+                entries.Sort((a, b) => a.start.CompareTo(b.start));
+
+                return outValue;
+            }
+        }
+
+        var compactedLength = buffer.Length;
+
+        foreach(var entry in freeEntries)
+        {
+            compactedLength -= entry.length;
+        }
+
+        var newBuffer = new T[compactedLength + length];
+
+        var newPosition = 0;
+
+        foreach (var entry in entries)
+        {
+            entry.start = newPosition;
+
+            newPosition += entry.length;
+        }
+
+        newPosition = 0;
+
+        var position = 0;
+
+        foreach (var entry in freeEntries)
+        {
+            var l = entry.start - position;
+
+            Array.Copy(buffer, position, newBuffer, newPosition, l);
+
+            position = entry.start + entry.length;
+            newPosition += l;
+        }
+
+        if(newPosition < compactedLength)
+        {
+            Array.Copy(buffer, position, newBuffer, newPosition, compactedLength - newPosition);
+        }
+
+        buffer = newBuffer;
+
+        outValue = new Entry()
+        {
+            start = compactedLength,
+            length = length,
+        };
+
+        entries.Add(outValue);
+
+        Repin();
+
+        return outValue;
+    }
+
+    public void Free(Entry entry)
+    {
+        if(entry.freed)
+        {
+            return;
+        }
+
+        entry.freed = true;
+
+        entries.Remove(entry);
+
+        freeEntries.Add(entry);
+    }
+
+    public Span<T> Get(Entry entry)
+    {
+        if(entry.freed ||
+            entry.start >= buffer.Length ||
+            entry.start + entry.length > buffer.Length)
+        {
+            return default;
+        }
+
+        return buffer.AsSpan(entry.start, entry.length);
+    }
+
+    public nint GetNative(Entry entry)
+    {
+        return pinAddress + elementSize * entry.start;
+    }
+}