Improved SegmentedPool with the introduction of handles and alignment (#1)

UnmangedMMU/Allocators/DefaultUnmanagedAllocator.cs

@@ -3,14 +3,36 @@
 namespace UnmanagedMMU.Allocators
 {
     /// <summary>
-    /// Wrapper class around <see cref="NativeMemory.Alloc(nuint)"/> and <see cref="NativeMemory.Free(void*)"/>.
+    /// Wrapper class around <see cref="NativeMemory.AlignedAlloc(nuint, nuint)"/> and <see cref="NativeMemory.AlignedFree(void*)"/>.
     /// </summary>
     internal sealed unsafe class DefaultUnmanagedAllocator : IUnmanagedAllocator
     {
         /// <inheritdoc/>
-        public void* Alloc(nuint size) => NativeMemory.Alloc(size);
+        public void* Alloc(nuint size)
+        {
+            return NativeMemory.AlignedAlloc(size, 16);
+        }
 
         /// <inheritdoc/>
-        public void Free(void* ptr) => NativeMemory.Free(ptr);
+        public void* AllocAligned(nuint size, nuint alignment)
+        {
+            if (!((alignment & (alignment - 1)) == 0 && alignment > 0))
+            {
+                throw new ArgumentException("Alignment must be a power of 2.", nameof(alignment));
+            }
+            return NativeMemory.AlignedAlloc(size, alignment);
+        }
+
+        /// <inheritdoc/>
+        public void Free(void* ptr)
+        {
+            NativeMemory.Free(ptr);
+        }
+
+        /// <inheritdoc/>
+        public void FreeAligned(void* ptr, nuint alignment = 0)
+        {
+            NativeMemory.AlignedFree(ptr);
+        }
     }
 }

UnmangedMMU/Allocators/IUnmanagedAllocator.cs

@@ -1,9 +1,11 @@
-namespace UnmanagedMMU.Allocators
+using System.Runtime.InteropServices;
+
+namespace UnmanagedMMU.Allocators
 {
     /// <summary>
     /// Interface that defines an Unmanaged allocator
     /// </summary>
-    internal unsafe interface IUnmanagedAllocator
+    public unsafe interface IUnmanagedAllocator
     {
         /// <summary>
         /// Allocates an unmanaged memory block of the specified size.
@@ -14,10 +16,28 @@
         /// </returns>
         void* Alloc(nuint size);
 
+        /// <summary>
+        /// Allocates an unmanaged memory block of the specified size with the requested alignment
+        /// </summary>
+        /// <param name="size">The number of bytes to allocate.</param>
+        /// <param name="alignment">The alignment, in bytes, of the block to allocate. This must be a power of <c>2</c></param>
+        /// <returns></returns>
+        void* AllocAligned(nuint size, nuint alignment);
+
+
         /// <summary>
         /// Frees a previously allocated unmanaged memory block.
         /// </summary>
         /// <param name="ptr">A pointer to the beginning of the memory block to free.</param>
+        /// <remarks>This method should only be called on with pointers allocated with <see cref="Alloc"/>.</remarks>
         void Free(void* ptr);
+
+        /// <summary>
+        /// Frees a previously allocated unmanaged aligned memory block
+        /// </summary>
+        /// <param name="ptr">A pointer to the beginning of the memory block to free.</param>
+        /// <param name="alignment">The alignment that the memory refered to by <paramref name="ptr"/> was aligned at (This parameter can be ignored if the underlying allocator does not need it)</param>
+        /// <remarks>This method should only be called on with pointers allocated with <see cref="AllocAligned"/>.</remarks>
+        void FreeAligned(void* ptr, nuint alignment = 0);
     }
 }

UnmangedMMU/Allocators/IUnmanagedMemoryOwner.cs

@@ -0,0 +1,16 @@
+
+using UnmanagedMMU.Handles.Internal;
+
+namespace UnmanagedMMU.Allocators
+{
+    /// <summary>
+    /// Interface that defines a mechanisim for the owner of an unmanaged memory allocation
+    /// </summary>
+    internal interface IUnmanagedMemoryOwner
+    {
+        /// <summary>
+        /// Frees the allocated memory represented by <paramref name="handle"/> back to the owning <see cref="IUnmanagedMemoryOwner"/> instance
+        /// </summary>
+        void Free(IOwnedHandle handle);
+    }
+}