improve logging

Author: LoneWandererProductions

MemoryManager.Core/IMemoryAllocator.cs

@@ -7,6 +7,8 @@
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 
+using System.Diagnostics;
+
 namespace MemoryManager.Core
 {
     /// <summary>
@@ -52,5 +54,16 @@ public interface IMemoryAllocator
         /// <param name="handle">The handle.</param>
         /// <returns>An <see cref="AllocationEntry"/> representing the allocation entry.</returns>
         AllocationEntry GetEntry(MemoryHandle handle);
+
+        /// <summary>
+        /// Generates a highly detailed string snapshot of the internal clockwork and moving parts.
+        /// </summary>
+        /// <returns>A string representing the internal state of the allocator.</returns>
+        string DebugDump();
+
+        /// <summary>
+        /// Default Interface Method: Automatically pushes the DebugDump straight to the system Trace.
+        /// </summary>
+        public void LogDump();
     }
 }

MemoryManager.Lanes/SlabLane.cs

@@ -360,13 +360,21 @@ public IEnumerable<MemoryHandle> GetHandles()
             }
         }
 
+        /// <summary>
+        /// Ensures the entry capacity.
+        /// </summary>
+        /// <param name="requiredSlotIndex">Index of the required slot.</param>
         private void EnsureEntryCapacity(int requiredSlotIndex)
         {
             var oldSize = _entries!.Length;
             var newSize = MemoryLaneUtils.EnsureEntryCapacity(ref _entries, requiredSlotIndex);
             if (newSize > oldSize) OnAllocationExtension?.Invoke(nameof(SlabLane), oldSize, newSize);
         }
 
+        /// <summary>
+        /// Grows the versions.
+        /// </summary>
+        /// <param name="minCapacity">The minimum capacity.</param>
         [MethodImpl(MethodImplOptions.NoInlining)]
         private unsafe void GrowVersions(int minCapacity)
         {

MemoryManager.Tests/ConcurrentMemoryArenaTests.cs

@@ -78,6 +78,7 @@ public void Arena_ParallelAllocation_MaintainsThreadIsolation()
                 arena.Free(handle);
             }
 
+            arena.DebugDump(); // Optional: Visualize the arena state after the test
             arena.Dispose();
         }
 
@@ -147,6 +148,7 @@ public unsafe void Arena_CrossThreadFree_RecyclesViaRemoteQueue()
             threadA.Join();
             threadB.Join();
 
+            arena.DebugDump(); // Optional: Visualize the arena state after the test
             // Cleanup
             arena.Dispose();
         }
@@ -183,6 +185,8 @@ public void Arena_LargeAllocations_FallbackToGlobalSlowLane()
 
             // Clean verification pass
             arena.Free(largeHandle);
+
+            arena.LogDump(); // Optional: Visualize the arena state after the test
             arena.Dispose();
         }
     }

MemoryManager.Tests/FastLaneTests.cs

@@ -73,7 +73,7 @@ public void MoveFastToSlowMovesEntryAndReplacesStub()
             // 2. Move to SlowLane
             arena.MoveFastToSlow(fastHandle);
 
-            arena.DebugDump();
+            arena.LogDump();
 
             // 3. Assertions
             // The FastLane MUST still have the handle (it's a stub now!)

MemoryManager.Tests/MemoryArenaInlineTests.cs

@@ -198,7 +198,7 @@ public void MemoryArenaJanitorAndCompactionStressTest()
             }
 
             // 5. Check final health
-            arena.DebugDump();
+            arena.LogDump();
             Assert.AreEqual(0, arena.FastLane.EstimateFragmentation());
         }
 

MemoryManager.Tests/MemoryArenaTests.cs

@@ -49,7 +49,7 @@ public void AllocateWithinFastLaneThresholdAllocatesInFastLane()
 
             var handle = arena.Allocate(size);
 
-            arena.DebugDump();
+            arena.LogDump();
 
             Assert.IsTrue(arena.Resolve(handle) != nint.Zero);
             //Assert.IsTrue(arena.FastLane.GetAllocationSize() < _config.FastLaneSize);

MemoryManager.Tests/SlowLaneTests.cs

@@ -73,7 +73,7 @@ public void Setup()
             // 2. Move to FastLane (The method returns the NEW handle!)
             var fastHandle = arena.MoveSlowToFast(slowHandle);
 
-            arena.DebugDump();
+            arena.LogDump();
 
             // 3. Verify the old handle is dead
             Assert.IsFalse(arena.SlowLane.HasHandle(slowHandle), "SlowLane should no longer have the old handle.");

MemoryManager/ConcurrentMemoryArena.cs

@@ -11,6 +11,7 @@
 using MemoryManager.Lanes;
 using System;
 using System.Collections.Concurrent;
+using System.Diagnostics;
 using System.Threading;
 
 namespace MemoryManager
@@ -260,6 +261,23 @@ private void DrainRemoteFreesForCurrentThread()
             }
         }
 
+        /// <inheritdoc />
+        public string DebugDump()
+        {
+            var localLane = _threadLocalFastLane.Value;
+            string laneStatus = localLane != null ? localLane.DebugDump() : "Uninitialized Local Track";
+
+            return $"=== CONCURRENT ARENA DIAGNOSTICS ===\n" +
+                   $"Calling Thread ID: {System.Threading.Thread.CurrentThread.ManagedThreadId}\n" +
+                   $"Remote Free Backlog: {_remoteFreeQueue.Count} Handles Pending\n" +
+                   $"[HOT TIER]  {localLane?.GetType().Name ?? "None"} -> {laneStatus}\n" +
+                   $"[COLD TIER] Global SlowLane -> {_globalSlowLane.DebugDump()}\n" +
+                   $"====================================";
+        }
+
+        /// <inheritdoc />
+        public void LogDump() => Trace.WriteLine(DebugDump());
+
         /// <summary>
         /// Flushes memory structures cleanly across all thread execution tracks.
         /// </summary>

MemoryManager/MemoryArena.cs

@@ -358,29 +358,43 @@ public void CompactAll()
             }
         }
 
+        /// <inheritdoc />
         /// <summary>
         /// Debugdump.
         /// </summary>
-        public void DebugDump()
+        public string DebugDump()
         {
             lock (_lock)
             {
-                Trace.WriteLine("===== MemoryArena Dump =====");
-                Trace.WriteLine($"Fast Lane Usage: {FastLane.UsagePercentage():P2}, Free: {FastLane.FreeSpace()} bytes, Entries: {FastLane.EntryCount}, Stubs: {FastLane.StubCount()}");
-                Trace.WriteLine($"Estimated Fragmentation: {FastLane.EstimateFragmentation()}%");
-                Trace.WriteLine(FastLane.DebugDump());
-                Trace.WriteLine(FastLane.DebugVisualMap());
-                Trace.WriteLine(FastLane.DebugRedirections());
-
-                Trace.WriteLine($"Slow Lane Usage: {SlowLane.UsagePercentage():P2}, Free: {SlowLane.FreeSpace()} bytes, Entries: {SlowLane.EntryCount}, Stubs: {SlowLane.StubCount()}");
-                Trace.WriteLine($"Estimated Fragmentation: {SlowLane.EstimateFragmentation()}%");
-                Trace.WriteLine(SlowLane.DebugDump());
-                Trace.WriteLine(SlowLane.DebugVisualMap());
-                Trace.WriteLine(SlowLane.DebugRedirections());
-                Trace.WriteLine("============================");
+                var sb = new System.Text.StringBuilder();
+
+                sb.AppendLine("===== MemoryArena Dump =====");
+
+                // Hot Path Telemetry
+                sb.AppendLine($"Fast Lane Usage: {FastLane.UsagePercentage():P2}, Free: {FastLane.FreeSpace()} bytes, Entries: {FastLane.EntryCount}, Stubs: {FastLane.StubCount()}");
+                sb.AppendLine($"Estimated Fragmentation: {FastLane.EstimateFragmentation()}%");
+                sb.AppendLine(FastLane.DebugDump());
+                sb.AppendLine(FastLane.DebugVisualMap());
+                sb.AppendLine(FastLane.DebugRedirections());
+
+                sb.AppendLine(); // Clean spacing break
+
+                // Cold Path Telemetry
+                sb.AppendLine($"Slow Lane Usage: {SlowLane.UsagePercentage():P2}, Free: {SlowLane.FreeSpace()} bytes, Entries: {SlowLane.EntryCount}, Stubs: {SlowLane.StubCount()}");
+                sb.AppendLine($"Estimated Fragmentation: {SlowLane.EstimateFragmentation()}%");
+                sb.AppendLine(SlowLane.DebugDump());
+                sb.AppendLine(SlowLane.DebugVisualMap());
+                sb.AppendLine(SlowLane.DebugRedirections());
+
+                sb.AppendLine("============================");
+
+                return sb.ToString();
             }
         }
 
+        /// <inheritdoc />
+        public void LogDump() => Trace.WriteLine(DebugDump());
+
         // --- UNLOCKED INTERNAL PATHS ---
 
         /// <summary>