optimize find freespot.

Author: LoneWandererProductions

MemoryManager.Core/AllocationStrategy.cs

@@ -0,0 +1,26 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     MemoryArenaPrototype.Core
+ * FILE:        AllocationStrategy.cs
+ * PURPOSE:     Defines the search algorithm used to locate available unmanaged space within the free-lists.
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+namespace MemoryManager.Core
+{
+    /// <summary>
+    /// Defines the search algorithm used to locate available unmanaged space within the free-lists.
+    /// </summary>
+    public enum AllocationStrategy : byte
+    {
+        /// <summary>
+        /// Blazing fast execution. Grabs the very first block that fits. Ideal for uniform/homogeneous lifetimes.
+        /// </summary>
+        FirstFit,
+
+        /// <summary>
+        /// Minimizes fragmentation. Scans the free-list to find the absolute smallest hole that fits the payload.
+        /// </summary>
+        BestFit
+    }
+}

MemoryManager.Core/MemoryManagerConfig.cs

@@ -6,14 +6,15 @@
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 
+using System;
+
 namespace MemoryManager.Core
 {
     /// <summary>
     ///      The config for the mm
     /// </summary>
     public sealed class MemoryManagerConfig
     {
-
         /// <summary>
         ///      Parameter-less constructor with defaults
         /// </summary>
@@ -50,8 +51,22 @@ public MemoryManagerConfig(int slowLaneSize)
             // Default hybrid tuning
             SlowLaneBlobCapacityFraction = 0.20;
             SlowLaneBlobThreshold = 256;
+
+            // Default performance-tuned layout choices
+            FastLaneFreeListStrategy = AllocationStrategy.FirstFit;
+            SlowLaneFreeListStrategy = AllocationStrategy.BestFit;
         }
 
+        /// <summary>
+        /// Gets the free-list block search strategy used by the FastLane when running the FreeList strategy wrapper.
+        /// </summary>
+        public AllocationStrategy FastLaneFreeListStrategy { get; init; } = AllocationStrategy.FirstFit;
+
+        /// <summary>
+        /// Gets the free-list block search strategy used by the SlowLane to manage gap allocations.
+        /// </summary>
+        public AllocationStrategy SlowLaneFreeListStrategy { get; init; } = AllocationStrategy.BestFit;
+
         /// <summary>
         /// Gets the fast lane strategy.
         /// Your pick old FastLane or the more speedy BumbLane.
@@ -199,12 +214,11 @@ public MemoryManagerConfig(int slowLaneSize)
         public int SlowLaneBlobThreshold { get; init; } = 256;
 
         /// <summary>
-        ///     Estimates the total reserved unmanaged memory (in bytes) this configuration will request,
-        ///     not including minor overhead for handles and management structures.
+        ///      Estimates the total reserved unmanaged memory (in bytes) this configuration will request,
+        ///      not including minor overhead for handles and management structures.
         /// </summary>
         public double GetEstimatedReservedMegabytes()
         {
-            // BufferSize is gone! Just the raw unmanaged lane allocations.
             return (FastLaneSize + SlowLaneSize) / (1024.0 * 1024.0);
         }
 
@@ -213,28 +227,35 @@ public double GetEstimatedReservedMegabytes()
          */
 
         /// <summary>
-        /// Creates a configuration tuned for real-time game loops. 
+        /// Creates a configuration tuned for real-time game loops.
         /// Employs an ultra-fast Bump/Linear allocator for short-lived transient frames.
         /// </summary>
+        /// <param name="totalBudget">The total budget.</param>
+        /// <returns>MemoryManagerConfig instance configured for real-time game loops.</returns>
         public static MemoryManagerConfig CreateForGameLoop(int totalBudget = 16 * 1024 * 1024)
         {
             return new MemoryManagerConfig
             {
                 SlowLaneSize = (int)(totalBudget * 0.75),
                 FastLaneSize = (int)(totalBudget * 0.25),
                 FastLaneStrategy = AllocatorStrategy.LinearBump, // Maximum speed
-                MaxFastLaneAgeFrames = 300,                  // Evict to SlowLane faster
+                MaxFastLaneAgeFrames = 300,                      // Evict to SlowLane faster
                 FastLaneUsageThreshold = 0.85,
                 CompactionThreshold = 0.75,
                 EnableAutoCompaction = true,
-                PolicyCheckInterval = TimeSpan.FromMilliseconds(16) // Check roughly every frame at 60fps
+                PolicyCheckInterval = TimeSpan.FromMilliseconds(16), // Check roughly every frame at 60fps
+
+                // Homogeneous loop presets: SlowLane aggregates long-lived chunks neatly via BestFit
+                SlowLaneFreeListStrategy = AllocationStrategy.BestFit
             };
         }
 
         /// <summary>
         /// Creates a configuration tuned for heavy I/O, networking, or asset streaming.
         /// Uses a FreeList allocator to handle random out-of-order allocations.
         /// </summary>
+        /// <param name="totalBudget">The total budget.</param>
+        /// <returns>MemoryManagerConfig instance configured for bulk processing.</returns>
         public static MemoryManagerConfig CreateForBulkProcessing(int totalBudget = 64 * 1024 * 1024)
         {
             return new MemoryManagerConfig
@@ -246,27 +267,36 @@ public static MemoryManagerConfig CreateForBulkProcessing(int totalBudget = 64 *
                 MaxFastLaneAgeFrames = 1200,                  // Let data sit longer before moving
                 SlowLaneUsageThreshold = 0.80,
                 SlowLaneBlobThreshold = 512,                  // Route larger fragments to blobs
-                PolicyCheckInterval = TimeSpan.FromSeconds(2)  // Low maintenance overhead
+                PolicyCheckInterval = TimeSpan.FromSeconds(2), // Low maintenance overhead
+
+                // Heterogeneous presets: prioritize high allocation velocity on FastLane, anti-fragmentation on SlowLane
+                FastLaneFreeListStrategy = AllocationStrategy.FirstFit,
+                SlowLaneFreeListStrategy = AllocationStrategy.BestFit
             };
         }
 
         /// <summary>
         /// Creates a configuration tuned for tightly constrained or embedded footprints.
         /// Minimizes unmanaged allocation limits and compacts aggressively.
         /// </summary>
+        /// <returns>MemoryManagerConfig instance configured for low memory scenarios.</returns>
         public static MemoryManagerConfig CreateForLowMemory()
         {
             return new MemoryManagerConfig
             {
-                FastLaneSize = 256 * 1024,                     // 256 KB
-                SlowLaneSize = 1024 * 1024,                    // 1 MB
+                FastLaneSize = 256 * 1024,                      // 256 KB
+                SlowLaneSize = 1024 * 1024,                     // 1 MB
                 FastLaneStrategy = AllocatorStrategy.FreeList,
                 EnableAutoCompaction = true,
                 CompactionThreshold = 0.60,                    // Compact very early
                 FastLaneUsageThreshold = 0.70,
                 SlowLaneUsageThreshold = 0.70,
                 SlowLaneBlobCapacityFraction = 0.35,           // Allocate more space for tiny fragments
-                PolicyCheckInterval = TimeSpan.FromMilliseconds(500)
+                PolicyCheckInterval = TimeSpan.FromMilliseconds(500),
+
+                // Low-Footprint presets: Use BestFit everywhere to squeeze the max data out of limited space limits
+                FastLaneFreeListStrategy = AllocationStrategy.BestFit,
+                SlowLaneFreeListStrategy = AllocationStrategy.BestFit
             };
         }
     }

MemoryManager.Lanes/FastLane.cs

@@ -78,18 +78,27 @@ public sealed class FastLane : IFastLane, IDisposable
         /// </summary>
         private int _freeBlockCount;
 
+        /// <summary>
+        /// The configured search strategy used to scan the free-list for gaps.
+        /// </summary>
+        private readonly AllocationStrategy _searchStrategy;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="FastLane" /> class.
         /// </summary>
         /// <param name="size">The size.</param>
         /// <param name="slowLane">The slow lane.</param>
         /// <param name="maxEntries">The maximum entries.</param>
-        public unsafe FastLane(int size, SlowLane slowLane, int maxEntries = 1024)
+        /// <param name="fastLaneFreeListStrategy">The fast lane free list strategy.</param>
+        public unsafe FastLane(int size, SlowLane slowLane, int maxEntries = 1024, AllocationStrategy fastLaneFreeListStrategy = default)
         {
             _slowLane = slowLane;
             Capacity = size;
             Buffer = Marshal.AllocHGlobal(size);
 
+            // CAPTURE STRATEGY: Persist the configuration choice for all future allocation passes
+            _searchStrategy = fastLaneFreeListStrategy;
+
             // PRE-ALLOCATE everything based on maxEntries
             _entries = new AllocationEntry[maxEntries];
             _freeBlocks = new FreeBlock[maxEntries]; // Free blocks can theoretically equal maxEntries
@@ -179,7 +188,7 @@ public unsafe MemoryHandle Allocate(
 
             // Calculate total layout footprint including canary guards
             int physicalSizeNeeded = MemoryCanary.GetPhysicalSize(size);
-            var physicalOffset = MemoryLaneUtils.FindFreeSpot(physicalSizeNeeded, ref _freeBlocks, ref _freeBlockCount);
+            var physicalOffset = MemoryLaneUtils.FindFreeSpot(physicalSizeNeeded, ref _freeBlocks, ref _freeBlockCount, _searchStrategy);
 
             if (physicalOffset == -1)
                 throw new OutOfMemoryException("FastLane: Cannot allocate - No contiguous block large enough.");

MemoryManager.Lanes/MemoryLaneUtils.cs

@@ -89,37 +89,74 @@ internal static int StubCount(ReadOnlySpan<AllocationEntry> entries)
         }
 
         /// <summary>
-        /// Finds a free spot using a Free-List approach (Zero Allocation, O(N) over holes, not allocations)
+        /// Finds a free spot using a configurable Free-List search approach (Zero Allocation).
         /// </summary>
-        /// <param name="size">The size.</param>
-        /// <param name="freeBlocks">The free blocks.</param>
-        /// <param name="freeBlockCount">The free block count.</param>
-        /// <returns>The offset of the allocated spot, or -1 if out of memory.</returns>
+        /// <param name="size">The physical size needed (including canaries/alignment padding).</param>
+        /// <param name="freeBlocks">The free blocks tracker array.</param>
+        /// <param name="freeBlockCount">The active free block count.</param>
+        /// <param name="strategy">The allocation strategy layout constraint to use.</param>
+        /// <returns>First free next offset for the allocator, or -1 if Out of Memory.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static int FindFreeSpot(int size, ref FreeBlock[] freeBlocks, ref int freeBlockCount)
+        internal static int FindFreeSpot(int size, ref FreeBlock[] freeBlocks, ref int freeBlockCount, AllocationStrategy strategy)
         {
-            for (var i = 0; i < freeBlockCount; i++)
+            var targetIndex = -1;
+
+            switch (strategy)
             {
-                if (freeBlocks[i].Size >= size)
-                {
-                    var assignedOffset = freeBlocks[i].Offset;
+                case AllocationStrategy.FirstFit:
+                    // --- FIRST FIT STRATEGY (High-Velocity Homogeneous Path) ---
+                    for (var i = 0; i < freeBlockCount; i++)
+                    {
+                        if (freeBlocks[i].Size >= size)
+                        {
+                            targetIndex = i;
+                            break; // Exit instantly on the first validation match
+                        }
+                    }
+                    break;
 
-                    // Shrink the hole
-                    freeBlocks[i].Offset += size;
-                    freeBlocks[i].Size -= size;
+                case AllocationStrategy.BestFit:
+                    // --- BEST FIT STRATEGY (Anti-Fragmentation Heterogeneous Path) ---
+                    var minRemainder = int.MaxValue;
 
-                    // If hole is fully consumed, remove it by swapping with the last item
-                    if (freeBlocks[i].Size == 0)
+                    for (var i = 0; i < freeBlockCount; i++)
                     {
-                        freeBlockCount--;
-                        freeBlocks[i] = freeBlocks[freeBlockCount];
+                        if (freeBlocks[i].Size >= size)
+                        {
+                            int remainder = freeBlocks[i].Size - size;
+
+                            // Track the hole that leaves behind the smallest possible wasted remnant
+                            if (remainder < minRemainder)
+                            {
+                                minRemainder = remainder;
+                                targetIndex = i;
+
+                                // OPTIMIZATION: If we hit a perfect structural match, stop scanning immediately
+                                if (remainder == 0) break;
+                            }
+                        }
                     }
+                    break;
+            }
 
-                    return assignedOffset;
-                }
+            // If no suitable memory block hole was found across the free-list table
+            if (targetIndex == -1) return -1;
+
+            // --- CONSUME AND UPDATE THE TRACKED HOLE ---
+            var assignedOffset = freeBlocks[targetIndex].Offset;
+
+            // Shrink the hole footprint boundaries
+            freeBlocks[targetIndex].Offset += size;
+            freeBlocks[targetIndex].Size -= size;
+
+            // If the hole is fully consumed down to 0 bytes, remove it by swapping with the last item
+            if (freeBlocks[targetIndex].Size == 0)
+            {
+                freeBlockCount--;
+                freeBlocks[targetIndex] = freeBlocks[freeBlockCount];
             }
 
-            return -1; // -1 indicates Out of Memory
+            return assignedOffset;
         }
 
         /// <summary>

MemoryManager.Lanes/SlowLane.cs

@@ -93,6 +93,11 @@ public sealed class SlowLane : IMemoryLane, IDisposable
         /// </summary>
         private int _versionsCapacity;
 
+        /// <summary>
+        /// The configured search strategy used to scan the free-list for gaps.
+        /// </summary>
+        private readonly AllocationStrategy _searchStrategy;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="SlowLane" /> class.
         /// </summary>
@@ -101,11 +106,14 @@ public sealed class SlowLane : IMemoryLane, IDisposable
         /// <param name="blobThreshold">The BLOB threshold.</param>
         /// <param name="maxEntries">The maximum entries.</param>
         public unsafe SlowLane(int capacity, double blobCapacityFraction = 0.20, int blobThreshold = 256,
-            int maxEntries = 1024)
+            int maxEntries = 1024, AllocationStrategy slowLaneFreeListStrategy = default)
         {
             Capacity = capacity;
             _blobThreshold = blobThreshold;
 
+            // CAPTURE STRATEGY: Persist the configuration choice for all future allocation passes
+            _searchStrategy = slowLaneFreeListStrategy;
+
             Buffer = Marshal.AllocHGlobal(capacity);
             _entries = new AllocationEntry[maxEntries];
 
@@ -192,7 +200,7 @@ public unsafe MemoryHandle Allocate(
 
             // Calculate tracking footprint dimension rules including canary bytes
             int physicalSizeNeeded = MemoryCanary.GetPhysicalSize(size);
-            var offset = MemoryLaneUtils.FindFreeSpot(physicalSizeNeeded, ref _freeBlocks, ref _freeBlockCount);
+            var offset = MemoryLaneUtils.FindFreeSpot(physicalSizeNeeded, ref _freeBlocks, ref _freeBlockCount, _searchStrategy);
 
             if (offset == -1)
                 throw new OutOfMemoryException("SlowLane: Cannot allocate - No contiguous block large enough.");

MemoryManager/MemoryArena.cs

@@ -67,19 +67,27 @@ public MemoryArena(MemoryManagerConfig config)
             _config = config;
             Threshold = config.Threshold;
 
-            // FIX: Pass configuration parameters to the SlowLane constructor
+            // PASS 1: Pass the anti-fragmentation strategy flag straight into the SlowLane
             SlowLane = new SlowLane(
                 config.SlowLaneSize,
                 config.SlowLaneBlobCapacityFraction,
                 config.SlowLaneBlobThreshold,
-                config.MaxEntries);
+                config.MaxEntries,
+                config.SlowLaneFreeListStrategy); // Added strategy selection
 
             if (config.FastLaneStrategy == AllocatorStrategy.FreeList)
             {
-                FastLane = new FastLane(config.FastLaneSize, SlowLane, config.MaxEntries);
+                // PASS 2: Pass the high-velocity strategy flag into the Free-List FastLane
+                FastLane = new FastLane(
+                    config.FastLaneSize,
+                    SlowLane,
+                    config.MaxEntries,
+                    config.FastLaneFreeListStrategy); // Added strategy selection
             }
             else
             {
+                // NOTE: LinearLane is a pure O(1) bump allocator. It does not scan holes, 
+                // so it does not take an AllocationStrategy configuration parameter.
                 FastLane = new LinearLane(config.FastLaneSize, SlowLane, config.MaxEntries);
             }