Add allocators, string utilities, and hashing support

Implemented `BumpAllocator` and `ConcurrentBumpAllocator` for efficient memory management in single-threaded and multi-threaded environments. Added `StringPool` for string deduplication and `StringSpan` for span-based string manipulation. Introduced `MurmurHash3` for robust hashing.

Enhanced `AlignmentHelper` with `AlignUp` and `AlignDown` methods for `nuint` and `nint` types. Corrected operator precedence in existing alignment methods.

Updated `UnsafeHashSet` with public `EntryFlags` and `Entry`, added `ResultPair` struct, and introduced `AddIt` and `At` methods.

Added extensive unit tests for allocators, string utilities, and hash functions. Updated `Hexa.NET.Utilities` package version to 2.2.5.

Author: JunaMeinhold

Hexa.NET.Utilities.Tests/BumpAllocatorSingleThreadedTests.cs

@@ -2,24 +2,44 @@
 {
     public static class AlignmentHelper
     {
+        public static nuint AlignUp(nuint size, nuint alignment)
+        {
+            return (size + alignment - 1) & ~(alignment - 1);
+        }
+
+        public static nint AlignUp(nint size, nint alignment)
+        {
+            return (size + alignment - 1) & ~(alignment - 1);
+        }
+
         public static ulong AlignUp(ulong size, ulong alignment)
         {
-            return size + alignment - 1 & ~(alignment - 1);
+            return (size + alignment - 1) & ~(alignment - 1);
         }
 
         public static uint AlignUp(uint size, uint alignment)
         {
-            return size + alignment - 1 & ~(alignment - 1);
+            return (size + alignment - 1) & ~(alignment - 1);
         }
 
         public static long AlignUp(long size, long alignment)
         {
-            return size + alignment - 1 & ~(alignment - 1);
+            return (size + alignment - 1) & ~(alignment - 1);
         }
 
         public static int AlignUp(int size, int alignment)
         {
-            return size + alignment - 1 & ~(alignment - 1);
+            return (size + alignment - 1) & ~(alignment - 1);
+        }
+
+        public static nuint AlignDown(nuint size, nuint alignment)
+        {
+            return size & ~(alignment - 1);
+        }
+
+        public static nint AlignDown(nint size, nint alignment)
+        {
+            return size & ~(alignment - 1);
         }
 
         public static ulong AlignDown(ulong size, ulong alignment)

Hexa.NET.Utilities.Tests/ConcurrentBumpAllocatorTests.cs

@@ -0,0 +1,165 @@
+#if NET5_0_OR_GREATER
+namespace Hexa.NET.Utilities
+{
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    public unsafe struct BumpAllocator : IDisposable, IFreeable
+    {
+        public const uint PageSize = 4096;
+
+        private struct MemoryBlock
+        {
+            public MemoryBlock* Next;
+            public uint Used;
+            public uint Size;
+
+            public MemoryBlock(MemoryBlock* next, uint size)
+            {
+                Next = next;
+                Size = size;
+            }
+
+            public static MemoryBlock* Create(uint size, MemoryBlock* next)
+            {
+                size = AlignmentHelper.AlignUp(size + (uint)sizeof(MemoryBlock), PageSize);
+                var mem = (byte*)NativeMemory.AlignedAlloc(size, PageSize) + size;
+                MemoryBlock* block = ((MemoryBlock*)mem) - 1;
+                *block = new(next, size - (uint)sizeof(MemoryBlock));
+                return block;
+            }
+
+            public uint Alloc(uint size, uint alignment)
+            {
+                var offset = Used;
+                var alignedOffset = AlignmentHelper.AlignUp(offset, alignment);
+                var newUsed = alignedOffset + size;
+                if (newUsed > Size)
+                {
+                    return uint.MaxValue;
+                }
+                Used = newUsed;
+                return alignedOffset;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static byte* GetBasePointer(MemoryBlock* block)
+            {
+                return (byte*)block - block->Size;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static void* GetPointer(MemoryBlock* block, uint offset)
+            {
+                return GetBasePointer(block) + offset;
+            }
+
+
+            public static void Destroy(MemoryBlock* block)
+            {
+                NativeMemory.AlignedFree(GetBasePointer(block));
+            }
+        }
+
+        private MemoryBlock* head;
+        private MemoryBlock* tail;
+        private MemoryBlock* freeList;
+
+
+        private MemoryBlock* CreateBlock(uint sizeMin)
+        {
+            MemoryBlock* block;
+
+            if (freeList != null)
+            {
+                block = freeList;
+                freeList = freeList->Next;
+                block->Next = tail;
+                tail = block;
+                return block;
+            }
+
+            block = MemoryBlock.Create(Math.Max(sizeMin, PageSize), tail);
+            tail = block;
+            if (head == null)
+            {
+                head = block;
+            }
+
+            return block;
+
+        }
+
+        public void* Alloc(uint size, uint alignment = 8)
+        {
+            while (true)
+            {
+                var currentTail = tail;
+                if (currentTail != null)
+                {
+                    var offs = currentTail->Alloc(size, alignment);
+                    if (offs != uint.MaxValue)
+                    {
+                        return MemoryBlock.GetPointer(currentTail, offs);
+                    }
+                }
+
+                CreateBlock(size);
+            }
+        }
+
+        public void Free(void* ptr, uint size)
+        {
+            var basePtr = MemoryBlock.GetBasePointer(tail);
+            var endPtr = basePtr + tail->Used;
+            if ((byte*)ptr + size == endPtr)
+            {
+                tail->Used -= size;
+            }
+        }
+
+        public void Reset()
+        {
+            var curr = tail;
+            while (curr != null)
+            {
+                curr->Used = 0;
+                curr = curr->Next;
+            }
+            freeList = tail;
+            tail = null;
+            head = null;
+        }
+
+        public void ReleaseAll()
+        {
+            DestroyList(tail);
+            DestroyList(freeList);
+            tail = null;
+            head = null;
+            freeList = null;
+        }
+
+        private static void DestroyList(MemoryBlock* curr)
+        {
+            while (curr != null)
+            {
+                var next = curr->Next;
+                MemoryBlock.Destroy(curr);
+                curr = next;
+            }
+        }
+
+        public void Dispose()
+        {
+            ReleaseAll();
+        }
+
+        public void Release()
+        {
+            ReleaseAll();
+        }
+    }
+}
+
+#endif