implement canary

Author: LoneWandererProductions

MemoryManager.Core/BlobManager.cs

@@ -75,7 +75,8 @@ public BlobManager(nint buffer, int capacity)
         /// <inheritdoc />
         public bool CanAllocate(int size)
         {
-            return _nextFreeOffset + size <= _capacity;
+            int physicalSize = MemoryCanary.GetPhysicalSize(size);
+            return _nextFreeOffset + physicalSize <= _capacity;
         }
 
         /// <inheritdoc />
@@ -86,24 +87,32 @@ public MemoryHandle Allocate(
             string? debugName = null,
             int currentFrame = 0)
         {
-            if (!CanAllocate(size))
+            int physicalSizeNeeded = MemoryCanary.GetPhysicalSize(size);
+            if (_nextFreeOffset + physicalSizeNeeded > _capacity)
                 throw new OutOfMemoryException(
                     $"BlobManager: Out of memory. Requested {size} bytes, but only {FreeSpace()} available.");
 
             if (_nextId == int.MinValue)
                 throw new OutOfMemoryException("BlobManager: ID exhaustion. Cannot allocate more IDs.");
 
             var id = _nextId--;
-            int index = StartingId - id; // Maps sequential negative IDs cleanly to 0, 1, 2...
+            int index = StartingId - id;
 
             EnsureCapacity(index);
 
             byte version = 1;
 
+            var physicalOffset = _nextFreeOffset;
+            _nextFreeOffset += physicalSizeNeeded; // Bump advanced by complete physical footprint block size
+
+            // Map user pointer past the pre-canary guard band and stamp the signature bounds
+            var userOffset = MemoryCanary.GetUserOffset(physicalOffset);
+            MemoryCanary.WriteGuardBands(_buffer, userOffset, size);
+
             _entries[index] = new BlobEntry
             {
                 Id = id,
-                Offset = _nextFreeOffset,
+                Offset = userOffset, // Resolve() continues to target this instantly
                 Size = size,
                 AllocationFrame = currentFrame,
                 Version = version
@@ -116,10 +125,7 @@ public MemoryHandle Allocate(
             }
 #endif
 
-            // Bump the allocator forward
-            _nextFreeOffset += size;
             EntryCount++;
-
             return new MemoryHandle(id, version, this);
         }
 
@@ -131,6 +137,11 @@ public void Free(MemoryHandle handle)
             if (index < 0 || index >= _entries.Length || _entries[index].Size == 0)
                 throw new InvalidOperationException($"BlobManager: Invalid or double-freed handle {handle.Id}");
 
+            ref readonly var entry = ref _entries[index];
+
+            // Assert safety guard signatures are perfectly intact before deletion sweeps
+            MemoryCanary.Validate(_buffer, entry.Offset, entry.Size, handle.Id);
+
             _entries[index] = default;
             EntryCount--;
 
@@ -237,23 +248,29 @@ public void Compact()
                 {
                     ref readonly var entry = ref validSpan[i];
 
-                    if (entry.Offset > currentOffset)
+                    // Reconstruct exact physical positions and block dimensions
+                    int srcPhysicalOffset = MemoryCanary.GetPhysicalOffset(entry.Offset);
+                    int destPhysicalOffset = currentOffset;
+                    int physicalSize = MemoryCanary.GetPhysicalSize(entry.Size);
+
+                    if (srcPhysicalOffset > destPhysicalOffset)
                     {
                         unsafe
                         {
+                            // Copy complete physical layout block footprints concurrently
                             System.Buffer.MemoryCopy(
-                                (void*)(_buffer + entry.Offset),
-                                (void*)(_buffer + currentOffset),
-                                entry.Size,
-                                entry.Size);
+                                (void*)(_buffer + srcPhysicalOffset),
+                                (void*)(_buffer + destPhysicalOffset),
+                                physicalSize,
+                                physicalSize);
                         }
                     }
 
-                    // Update the offset inside our primary dense track tracking array slot directly
+                    // Sync user data offsets based on newly modified position tracking indices
                     int index = StartingId - entry.Id;
-                    _entries[index].Offset = currentOffset;
+                    _entries[index].Offset = MemoryCanary.GetUserOffset(destPhysicalOffset);
 
-                    currentOffset += entry.Size;
+                    currentOffset += physicalSize;
                 }
 
                 _nextFreeOffset = currentOffset;
@@ -287,7 +304,8 @@ public int EstimateFragmentation()
             {
                 if (_entries[i].Size > 0)
                 {
-                    livingBytes += _entries[i].Size;
+                    // Evaluate tracking states using total physical block footprints
+                    livingBytes += MemoryCanary.GetPhysicalSize(_entries[i].Size);
                 }
             }
 
@@ -316,6 +334,7 @@ public string DebugDump()
             return $"BlobManager Dump\nAllocations: {EntryCount}\nUsed: {_nextFreeOffset}/{_capacity} bytes";
         }
 
+        /// <inheritdoc />
         /// <inheritdoc />
         public string DebugVisualMap()
         {
@@ -332,21 +351,28 @@ public string DebugVisualMap()
 
                 if (startByte >= _nextFreeOffset)
                 {
-                    map[i] = '░';
+                    map[i] = '░'; // Totally unallocated space past the bump pointer
                     continue;
                 }
 
                 var isLiving = false;
                 for (var j = 0; j < _entries.Length; j++)
                 {
-                    if (_entries[j].Size > 0 && _entries[j].Offset < endByte && _entries[j].Offset + _entries[j].Size > startByte)
+                    if (_entries[j].Size > 0)
                     {
-                        isLiving = true;
-                        break;
+                        // Extract absolute physical footprints so boundaries match raw heap tracking properties
+                        int physicalStart = MemoryCanary.GetPhysicalOffset(_entries[j].Offset);
+                        int physicalEnd = physicalStart + MemoryCanary.GetPhysicalSize(_entries[j].Size);
+
+                        if (physicalStart < endByte && physicalEnd > startByte)
+                        {
+                            isLiving = true;
+                            break;
+                        }
                     }
                 }
 
-                map[i] = isLiving ? '█' : '-';
+                map[i] = isLiving ? '█' : '-'; // Render '█' for allocated memory blocks and '-' for active gaps
             }
 
             return $"Blob Map: [{new string(map)}]\nLegend: █=Used, -=Gap, ░=Free";

MemoryManager.Lanes/MemoryCanary.cs MemoryManager.Core/MemoryCanary.csMemoryManager.Lanes/MemoryCanary.cs renamed to MemoryManager.Core/MemoryCanary.cs

@@ -1,21 +1,21 @@
 /*
  * COPYRIGHT:   See COPYING in the top level directory
- * PROJECT:     MemoryManager.Lanes
+ * PROJECT:     MemoryManager.Core
  * FILE:        MemoryCanary.cs
  * PURPOSE:     Centralized unmanaged guard band validation with zero RELEASE overhead.
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 
 using System.Runtime.CompilerServices;
 
-namespace MemoryManager.Lanes
+namespace MemoryManager.Core
 {
     /// <summary>
     /// Canary class provides a simple mechanism for detecting buffer overruns and underruns in debug builds by placing known "canary" values before and after user allocations. 
     /// In release builds, the canary logic is completely stripped out to ensure zero overhead, 
     /// making it an effective tool for catching memory corruption issues during development without impacting performance in production.
     /// </summary>
-    internal static class MemoryCanary
+    public static class MemoryCanary
     {
         /// <summary>
         /// The size

MemoryManager.Lanes/FastLane.cs

@@ -177,24 +177,26 @@ public unsafe MemoryHandle Allocate(
         {
             if (_entries == null) throw new InvalidOperationException("FastLane: Memory not reserved");
 
-            var offset = MemoryLaneUtils.FindFreeSpot(size, ref _freeBlocks, ref _freeBlockCount);
+            // Calculate total layout footprint including canary guards
+            int physicalSizeNeeded = MemoryCanary.GetPhysicalSize(size);
+            var physicalOffset = MemoryLaneUtils.FindFreeSpot(physicalSizeNeeded, ref _freeBlocks, ref _freeBlockCount);
 
-            if (offset == -1)
+            if (physicalOffset == -1)
                 throw new OutOfMemoryException("FastLane: Cannot allocate - No contiguous block large enough.");
 
+            // Position the tracked user data offset cleanly past the pre-canary boundary
+            var userOffset = MemoryCanary.GetUserOffset(physicalOffset);
+            MemoryCanary.WriteGuardBands(Buffer, userOffset, size);
+
             EnsureEntryCapacity(EntryCount);
 
-            //So we reuse freed handles here
-            // So we reuse freed handles here
             var id = MemoryLaneUtils.GetNextId(_freeIds, ref _nextHandleId);
 
-            // Ensure our flat array is large enough for this ID
             if (id >= _versionsCapacity)
             {
                 GrowVersions(id + 1);
             }
 
-            // True O(1) Version Bump
             uint version = ++_versions[id];
 
 #if DEBUG
@@ -206,7 +208,7 @@ public unsafe MemoryHandle Allocate(
 
             _entries[EntryCount] = new AllocationEntry
             {
-                Offset = offset,
+                Offset = userOffset, // Target user data directly for O(1) pointer resolution
                 Size = size,
                 HandleId = id,
                 Priority = priority,
@@ -275,39 +277,37 @@ public nint Resolve(MemoryHandle handle)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Free(MemoryHandle handle)
         {
-            // 1. Remove from index first
             if (!_handleIndex.TryRemove(handle.Id, out var index))
                 throw new InvalidOperationException($"FastLane: Invalid handle {handle.Id}");
 
 #if DEBUG
             _debugNames.Remove(handle.Id);
 #endif
 
-            // 2. Handle SlowLane/Redirects (This is your cold path)
             var entry = _entries[index];
-            MemoryLaneUtils.ReturnFreeSpace(entry.Offset, entry.Size, ref _freeBlocks, ref _freeBlockCount);
+
+            // Assert safety markers are intact before deallocation operations
+            MemoryCanary.Validate(Buffer, entry.Offset, entry.Size, handle.Id);
+
+            // Map user boundaries back to complete layout blocks for the free-list
+            int physicalOffset = MemoryCanary.GetPhysicalOffset(entry.Offset);
+            int physicalSize = MemoryCanary.GetPhysicalSize(entry.Size);
+            MemoryLaneUtils.ReturnFreeSpace(physicalOffset, physicalSize, ref _freeBlocks, ref _freeBlockCount);
 
             if (entry.IsStub && entry.RedirectToId != 0)
             {
                 var slowHandle = new MemoryHandle(entry.RedirectToId, entry.RedirectVersion, _slowLane);
                 _slowLane.Free(slowHandle);
             }
 
-            // 3. Swap-with-tail removal
-            var lastIdx = --EntryCount; // Decrement first to get the last valid index
+            var lastIdx = --EntryCount;
             if (index != lastIdx)
             {
-                // Move the last entry into the hole
                 var movedEntry = _entries[lastIdx];
                 _entries[index] = movedEntry;
-
-                // Update the map to point to the new location
-                // OPTIMIZATION: Use a direct 'Set' or 'Update' if your map allows
-                // to avoid tombstone buildup during updates.
                 _handleIndex[movedEntry.HandleId] = index;
             }
 
-            // 4. Return ID to pool
             _freeIds.Push(handle.Id);
         }
 
@@ -346,24 +346,27 @@ public unsafe void Compact(int currentFrame, MemoryManagerConfig config)
             var newBuffer = Marshal.AllocHGlobal(Capacity);
             var currentOffset = 0;
 
-            // Now take your snapshot for sorting, but ONLY for survivors (non-stubs)
             var survivors = _entries.Take(EntryCount)
                 .Where(e => !e.IsStub)
                 .OrderBy(e => e.Offset)
                 .ToList();
 
             foreach (var survivor in survivors)
             {
-                // 1. Move the bytes
-                void* source = (byte*)Buffer + survivor.Offset;
+                // Extract base tracking coordinates for the entire block footprint
+                int srcPhysicalOffset = MemoryCanary.GetPhysicalOffset(survivor.Offset);
+                int physicalSize = MemoryCanary.GetPhysicalSize(survivor.Size);
+
+                // 1. Move the complete physical block (Canary + User Data + Canary)
+                void* source = (byte*)Buffer + srcPhysicalOffset;
                 void* target = (byte*)newBuffer + currentOffset;
-                System.Buffer.MemoryCopy(source, target, Capacity - currentOffset, survivor.Size);
+                System.Buffer.MemoryCopy(source, target, Capacity - currentOffset, physicalSize);
 
-                // 2. Update the OFFSET ONLY in the real metadata
+                // 2. Map user offset coordinates relative to the new layout alignment
                 var index = _handleIndex[survivor.HandleId];
-                _entries[index].Offset = currentOffset;
+                _entries[index].Offset = MemoryCanary.GetUserOffset(currentOffset);
 
-                currentOffset += survivor.Size;
+                currentOffset += physicalSize;
             }
 
             // --- PASS 3: CLEANUP ---
@@ -463,15 +466,17 @@ public void ReplaceWithStub(MemoryHandle fastHandle, MemoryHandle slowHandle)
             if (!_handleIndex.TryGetValue(fastHandle.Id, out var index))
                 throw new InvalidOperationException("FastLane: Invalid handle");
 
-            // Grab the existing entry
             var entry = _entries[index];
 
             entry.IsStub = true;
             entry.RedirectToId = slowHandle.Id;
             entry.RedirectVersion = slowHandle.Version;
 
-            // Cleanup FastLane stats
-            MemoryLaneUtils.ReturnFreeSpace(entry.Offset, entry.Size, ref _freeBlocks, ref _freeBlockCount);
+            // Map boundaries to clean up the underlying block pool space cleanly
+            int physicalOffset = MemoryCanary.GetPhysicalOffset(entry.Offset);
+            int physicalSize = MemoryCanary.GetPhysicalSize(entry.Size);
+            MemoryLaneUtils.ReturnFreeSpace(physicalOffset, physicalSize, ref _freeBlocks, ref _freeBlockCount);
+
             entry.Offset = 0;
             entry.Size = 0;