just some renaming

Author: GuilhermeStrice

Infinity.Core/Memory/Chunk.cs

@@ -2,64 +2,67 @@
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 
-public unsafe class ChunkedByteAllocator : IDisposable
+namespace Infinity.Core
 {
-    private readonly int _slabSize;
-    private readonly Stack<IntPtr> _freeSlabs = new Stack<IntPtr>();
-
-    public ChunkedByteAllocator(int slabSize)
+    public unsafe class ChunkAllocator : IDisposable
     {
-        if (slabSize <= 0) throw new ArgumentOutOfRangeException(nameof(slabSize));
-        _slabSize = slabSize;
-    }
+        private readonly int _slabSize;
+        private readonly Stack<IntPtr> _freeSlabs = new Stack<IntPtr>();
 
-    /// <summary>
-    /// Allocates a block of memory. If size <= slabSize, reuses slab; otherwise allocates exact size.
-    /// </summary>
-    public byte* Allocate(int size)
-    {
-        if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size));
+        public ChunkAllocator(int slabSize)
+        {
+            if (slabSize <= 0) throw new ArgumentOutOfRangeException(nameof(slabSize));
+            _slabSize = slabSize;
+        }
 
-        if (size <= _slabSize)
+        /// <summary>
+        /// Allocates a block of memory. If size <= slabSize, reuses slab; otherwise allocates exact size.
+        /// </summary>
+        public byte* Allocate(int size)
         {
-            if (_freeSlabs.Count > 0)
+            if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size));
+
+            if (size <= _slabSize)
             {
-                return (byte*)_freeSlabs.Pop();
+                if (_freeSlabs.Count > 0)
+                {
+                    return (byte*)_freeSlabs.Pop();
+                }
+                return (byte*)Marshal.AllocHGlobal(_slabSize);
+            }
+            else
+            {
+                return (byte*)Marshal.AllocHGlobal(size);
             }
-            return (byte*)Marshal.AllocHGlobal(_slabSize);
-        }
-        else
-        {
-            return (byte*)Marshal.AllocHGlobal(size);
         }
-    }
-
-    /// <summary>
-    /// Frees a previously allocated block.
-    /// </summary>
-    /// <param name="ptr">Pointer to free.</param>
-    /// <param name="size">Original allocation size. Determines if slab or large allocation.</param>
-    public void Free(byte* ptr, int size = -1)
-    {
-        if (ptr == null) return;
 
-        if (size <= _slabSize || size < 0)
-        {
-            // Return to slab pool
-            _freeSlabs.Push((IntPtr)ptr);
-        }
-        else
+        /// <summary>
+        /// Frees a previously allocated block.
+        /// </summary>
+        /// <param name="ptr">Pointer to free.</param>
+        /// <param name="size">Original allocation size. Determines if slab or large allocation.</param>
+        public void Free(byte* ptr, int size = -1)
         {
-            // Free large allocation
-            Marshal.FreeHGlobal((IntPtr)ptr);
+            if (ptr == null) return;
+
+            if (size <= _slabSize || size < 0)
+            {
+                // Return to slab pool
+                _freeSlabs.Push((IntPtr)ptr);
+            }
+            else
+            {
+                // Free large allocation
+                Marshal.FreeHGlobal((IntPtr)ptr);
+            }
         }
-    }
 
-    public void Dispose()
-    {
-        while (_freeSlabs.Count > 0)
+        public void Dispose()
         {
-            Marshal.FreeHGlobal(_freeSlabs.Pop());
+            while (_freeSlabs.Count > 0)
+            {
+                Marshal.FreeHGlobal(_freeSlabs.Pop());
+            }
         }
     }
 }

Infinity.Core/Memory/ChunkAllocator.cs

@@ -0,0 +1,84 @@
+namespace Infinity.Core
+{
+    public unsafe class MemoryChunk : IDisposable
+    {
+        private byte* _ptr;
+        private int _capacity;
+        private int _length;
+        private readonly ChunkAllocator _allocator;
+
+        public byte* Ptr => _ptr;
+        public int Length => _length;
+        public int Capacity => _capacity;
+
+        public MemoryChunk(ChunkAllocator allocator, int initialCapacity = 1024)
+        {
+            _allocator = allocator;
+            _capacity = initialCapacity;
+            _ptr = _allocator.Allocate(_capacity);
+            _length = 0;
+        }
+
+        /// <summary>
+        /// Ensures buffer has space for additional bytes. Grows automatically if needed.
+        /// </summary>
+        public void EnsureCapacity(int additional)
+        {
+            int required = _length + additional;
+            if (required <= _capacity) return;
+
+            int newCapacity = _capacity;
+            while (newCapacity < required) newCapacity *= 2;
+
+            byte* newPtr = _allocator.Allocate(newCapacity);
+            Buffer.MemoryCopy(_ptr, newPtr, newCapacity, _length);
+            _allocator.Free(_ptr, _capacity);
+
+            _ptr = newPtr;
+            _capacity = newCapacity;
+        }
+
+        /// <summary>
+        /// Increases the length after writing bytes.
+        /// </summary>
+        public void Advance(int count)
+        {
+            _length += count;
+        }
+
+        public void SetLength(int length)
+        {
+            if (length < 0 || length > _capacity)
+                throw new ArgumentOutOfRangeException(nameof(length), "Length must be between 0 and Capacity.");
+            _length = length;
+        }
+
+        public void Dispose()
+        {
+            Free();
+            GC.SuppressFinalize(this); // prevent finalizer from running twice
+        }
+
+        private void Free()
+        {
+            if (_ptr != null)
+            {
+                _allocator.Free(_ptr);
+                _ptr = null;
+                _capacity = 0;
+                _length = 0;
+            }
+        }
+
+        ~MemoryChunk()
+        {
+            // This will run if Dispose was not called
+            Free();
+        }
+
+        /// <summary>
+        /// Returns a read-only span of written bytes.
+        /// </summary>
+        public ReadOnlySpan<byte> AsSpan => new ReadOnlySpan<byte>(_ptr, _length);
+    }
+}

Infinity.Core/Memory/Manager.cs

@@ -0,0 +1,48 @@
+using System.Buffers;
+using System.Runtime.InteropServices;
+
+namespace Infinity.Core
+{
+    public unsafe class UnmanagedMemoryManager : MemoryManager<byte>
+    {
+        private readonly byte* _ptr;
+        private readonly int _length;
+
+        public UnmanagedMemoryManager(byte* ptr, int length)
+        {
+            if (ptr == null)
+                throw new ArgumentNullException(nameof(ptr));
+            if (length < 0)
+                throw new ArgumentOutOfRangeException(nameof(length));
+
+            _ptr = ptr;
+            _length = length;
+        }
+
+        public override Span<byte> GetSpan() => new Span<byte>(_ptr, _length);
+
+        public override MemoryHandle Pin(int elementIndex = 0)
+        {
+            if (elementIndex < 0 || elementIndex > _length)
+                throw new ArgumentOutOfRangeException(nameof(elementIndex));
+
+            // No GCHandle needed because memory is unmanaged
+            return new MemoryHandle(_ptr + elementIndex);
+        }
+
+        public override void Unpin()
+        {
+            // Nothing to do for unmanaged memory
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            // Nothing to free: memory is externally owned
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+    }
+}