going on reconstruct of HLSF

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Alloc.cs

@@ -26,6 +26,7 @@
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 using System;
+using System.IO;
 using System.Numerics;
 using System.Reflection.Metadata;
 using hlsfHandle = StgSharp.HighPerformance.Memory.HlsfHandle;
@@ -42,46 +43,37 @@ namespace StgSharp.HighPerformance.Memory
             if (size > _maxAllocSize) {
                 throw new InvalidOperationException("Requested size exceeds maximum allocatable size.");
             }
-
+            /*
             int level = GetLevelFromSize(size);
-            int segmentIndex = DetermineSegmentIndex(_levelSizeArray, size, level);
+            int segmentIndex = GetSegmentFromLevel(size, level);
 
             int i = level, s = segmentIndex;
-            Entry* handle;
+            /**/
-            while (!TryPopLevelForAllocation(i, s, out handle))
+
-            {
+            Entry* entry = null;
-                if (++s >= 3)
+            nuint requestedOffset = GetAllocSize(size);
-                {
+            (int level, int segment) = GetIndexPairOnce(size);
-                    s = 0;
+            int index = (3 * level) + segment;
+            int i = index;
+            while ((i < _bucketHeads.Length) && !TryPopLevelForAllocation(index, out entry)) {
                 i++;
             }
-                if (i > MaxLevel)
+            if ((i > _maxLevel) && !TryAllocateNewBlock(requestedOffset, out entry)) {
-                {
-                    if (TryPopLevelForAllocation(10, 1, out handle))
-                    {
-                        break;
-                    } else if (TryAllocateNew32MBBlock(out handle))
-                    {
-                        break;
-                    }
                 throw new OverflowException("Out of memory: Unable to allocate new 16MB block or find suitable bucket for allocation.");
             }
-            }
+            if (entry != null)
-
-            if (handle != null)
             {
-                int requestedOffset = (segmentIndex + 1) * ((int)_levelSizeArray[level]);
+                if (requestedOffset > entry->Size) {
-                if (requestedOffset > (int)handle->Size) {
                     throw new OverflowException("Out of memory: insufficient block size returned from spare memory.");
                 }
-                nuint remainder = handle->Size - ((nuint)requestedOffset);
+                nuint remainder = entry->Size - requestedOffset;
-                SetEntryLevel(handle, handle->Position, (uint)requestedOffset);
+                SetEntryLevel(entry, entry->Position, (uint)requestedOffset);
-                handle->State = EntryState.Alloc;
+                entry->State = EntryState.Alloc;
                 if (remainder > 0) {
-                    SliceMemory(handle->NextNear, remainder);
+                    OrganizeMemory(entry->NextNear, remainder);
                 }
             }
-            return new(handle, size);
+            return new(entry, size);
         }
 
         public bool TryAlloc(
@@ -94,44 +86,35 @@ namespace StgSharp.HighPerformance.Memory
                 handle = default;
                 return false;
             }
-
+            /*
             int level = GetLevelFromSize(size);
-            int segmentIndex = DetermineSegmentIndex(_levelSizeArray, size, level);
+            int segmentIndex = GetSegmentFromLevel(size, level);
 
             int i = level, s = segmentIndex;
-            Entry* entry;
+            /**/
-            while (!TryPopLevelForAllocation(i, s, out entry))
+
-            {
+            Entry* entry = null;
-                if (++s >= 3)
+            nuint requestedOffset = GetAllocSize(size);
-                {
+            (int level, int segment) = GetIndexPairOnce(size);
-                    s = 0;
+            int index = (3 * level) + segment;
+            int i = index;
+            while ((i < _bucketHeads.Length) && !TryPopLevelForAllocation(index, out entry)) {
                 i++;
             }
-                if (i > MaxLevel)
+            if ((i > _maxLevel) && !TryAllocateNewBlock(requestedOffset, out entry)) {
-                {
+                throw new OverflowException("Out of memory: Unable to allocate new 16MB block or find suitable bucket for allocation.");
-                    if (TryPopLevelForAllocation(10, 1, out entry))
-                    {
-                        break;
-                    } else if (TryAllocateNew32MBBlock(out entry))
-                    {
-                        break;
-                    }
-                    handle = default;
-                    return false;
-                }
             }
 
             if (entry != null)
             {
-                int requestedOffset = (segmentIndex + 1) * ((int)_levelSizeArray[level]);
+                if (requestedOffset > entry->Size) {
-                if (requestedOffset > (int)entry->Size) {
                     throw new OverflowException("Out of memory: insufficient block size returned from spare memory.");
                 }
-                nuint remainder = entry->Size - ((nuint)requestedOffset);
+                nuint remainder = entry->Size - requestedOffset;
                 SetEntryLevel(entry, entry->Position, (uint)requestedOffset);
                 entry->State = EntryState.Alloc;
                 if (remainder > 0) {
-                    SliceMemory(entry->NextNear, remainder);
+                    OrganizeMemory(entry->NextNear, remainder);
                 }
             }
             handle = new(entry, size);
@@ -139,16 +122,16 @@ namespace StgSharp.HighPerformance.Memory
         }
 
         /// <summary>
-        ///   Slice the memory block into smaller blocks and add them to the appropriate buckets
+        ///   Slice the memory block into smaller blocks and add them to the appropriate buckets.
         ///   Notice: this method is not responsible for freeing the original BucketNode
         /// </summary>
         /// <param name="e">
-        ///
+        ///   The next entry nearby the part to slice
         /// </param>
         /// <param name="sizeToSlice">
         ///
         /// </param>
-        private void SliceMemory(
+        private void OrganizeMemory(
                      Entry* e,
                      nuint sizeToSlice
         )
@@ -159,97 +142,22 @@ namespace StgSharp.HighPerformance.Memory
             nuint end = e->Position - ((nuint)m_Buffer);                      // end offset of buffer to slice
 
             int i = (BitOperations.TrailingZeroCount(offset) - 6) / 2;
-            i = int.Min(10, i);
-            for (; i < _levelSizeArray.Length; i++)
-            {
-                uint size = _levelSizeArray[i];
-                nuint upper = size * 4;
-                nuint edge = (((offset + upper) - 1U) / upper) * upper;
-                int count = (int)((nuint.Min(edge, end) - offset) / size);
-                if (count > 0)
-                {
-                    nuint newSize = ((nuint)count) * size;
-
-                    Entry* newEntry = (Entry*)_entries.Allocate();
-                    InsertEntryBefore(newEntry, next);
-                    SetEntryLevel(newEntry, offset + ((nuint)m_Buffer), newSize);
-                    newEntry->State = EntryState.Empty;
-
-                    BucketNode* b = (BucketNode*)newEntry->Position;
-                    b->EntryRef = newEntry;
-                    PushBucketToLevel(i, count - 1, b);
-                    offset += newSize;
-                    remain -= newSize;
-                }
-                if (remain <= 0) {
-                    return;
-                }
-            }
-
-            if (i > MaxLevel)
-            {
-                uint size = _levelSizeArray[^1];
-                nuint upper = size * 4;
-                nuint edge = (end / upper) * upper;
-                int count = (int)((nuint.Min(edge, end) - offset) / upper);
-                if (count > 0)
-                {
-                    nuint newSize = ((nuint)count) * upper;
-
-                    Entry* newEntry = (Entry*)_entries.Allocate();
-                    InsertEntryBefore(newEntry, next);
-                    SetEntryLevel(newEntry, offset + ((nuint)m_Buffer), newSize);
-                    newEntry->State = EntryState.Empty;
-
-                    BucketNode* b = (BucketNode*)newEntry->Position;
-                    b->EntryRef = newEntry;
-                    PushBucketToLevel(i, count - 1, b);
-                    offset += newSize;
-                    remain -= newSize;
-                    if (remain <= 0) {
-                        return;
-                    }
-                }
-            }
-
-            for (i--; i >= 0; i--)
-            {
-                uint size = _levelSizeArray[i];
-                nuint edge = (end / size) * size;
-                int count = (int)((nuint.Min(edge, end) - offset) / size);
-                if (count > 0)
-                {
-                    nuint newSize = ((nuint)count) * size;
-
-                    Entry* newEntry = (Entry*)_entries.Allocate();
-                    InsertEntryBefore(newEntry, next);
-                    SetEntryLevel(newEntry, offset + ((nuint)m_Buffer), newSize);
-                    newEntry->State = EntryState.Empty;
-
-                    BucketNode* b = (BucketNode*)newEntry->Position;
-                    b->EntryRef = newEntry;
-                    b->NextLevel = null;
-                    b->PreviousLevel = null;
-                    PushBucketToLevel(i, count - 1, b);
-                    offset += newSize;
-                    remain -= newSize;
-                }
-                if (remain <= 0) {
-                    return;
-                }
-            }
         }
 
         /// <summary>
         ///   Try to allocate a new 16MB block when all buckets are empty
         /// </summary>
+        /// <param name="size">
+        ///   Size of memory block to be allocated. Notice: Size is assumed as times of 64.
+        /// </param>
         /// <param name="handle">
         ///   Output handle to the allocated Entry
         /// </param>
         /// <returns>
         ///   True if allocation succeeded
         /// </returns>
-        private bool TryAllocateNew32MBBlock(
+        private bool TryAllocateNewBlock(
+                     nuint size,
                      out Entry* handle
         )
         {
@@ -260,7 +168,7 @@ namespace StgSharp.HighPerformance.Memory
                 handle = null;
                 return false;
             }
-            nuint size = (remain > 32 * 1024 * 1024L) ? (32 * 1024 * 1024U) : remain;
+            size = nuint.Min(size, remain);
 
 
             // build new entry
@@ -278,6 +186,23 @@ namespace StgSharp.HighPerformance.Memory
             return true;
         }
 
+        /// <summary>
+        ///   Helper method for allocation - converts BucketNode to Entry
+        /// </summary>
+        private bool TryPopLevelForAllocation(
+                     int bucketIndex,
+                     out Entry* entry
+        )
+        {
+            if (TryPopBucket(bucketIndex, out BucketNode* bucketNode))
+            {
+                entry = bucketNode->EntryRef;
+                return entry != null;
+            }
+            entry = null;
+            return false;
+        }
+
         /// <summary>
         ///   Helper method for allocation - converts BucketNode to Entry
         /// </summary>

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.BucketNode.cs

@@ -35,6 +35,7 @@ namespace StgSharp.HighPerformance.Memory
     public unsafe partial class HybridLayerSegregatedFitAllocator
     {
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void PushBucketToLevel(
                      int levelIndex,
                      int sizeIndex,
@@ -45,7 +46,16 @@ namespace StgSharp.HighPerformance.Memory
                 return;
             }
 
-            Index index = (levelIndex > MaxLevel) ? (^1) : ((3 * levelIndex) + sizeIndex);
+            int index = (3 * levelIndex) + sizeIndex;
+            PushNodeToBucket(index, node);
+        }
+
+        private void PushNodeToBucket(
+                     int index,
+                     BucketNode* node
+        )
+        {
+            index = (index >= _bucketHeads.Length) ? _bucketHeads.Length : index;
             if (_bucketHeads[index] is null)
             {
                 _bucketHeads[index] = node;
@@ -79,10 +89,11 @@ namespace StgSharp.HighPerformance.Memory
                      BucketNode* node
         )
         {
-            Index index = (levelIndex > MaxLevel) ? (^1) : ((3 * levelIndex) + sizeIndex);
+            int index = (3 * levelIndex) + sizeIndex;
+            index = (index >= _bucketHeads.Length) ? _bucketHeads.Length : index;
             if (_bucketHeads[index] == node)
             {
-                if (TryPopLevel(levelIndex, sizeIndex, out _)) {
+                if (TryPopBucket(index, out _)) {
                     return;
                 }
             }
@@ -102,14 +113,16 @@ namespace StgSharp.HighPerformance.Memory
             return;
         }
 
-        private bool TryPopLevel(
+        private bool TryPopBucket(
-                     int levelIndex,
+                     int index,
-                     int sizeIndex,
                      out BucketNode* node
         )
         {
-            Index index = (levelIndex > MaxLevel) ? (^1) : ((3 * levelIndex) + sizeIndex);
+            /*
-
+             * Attention:
+             * This method is UNSAFE. Index may exceed range of _bucketHeads.
+             * Be careful when calling this method.
+             */
             BucketNode* head = _bucketHeads[index];
 
             if (head == null)
@@ -126,24 +139,37 @@ namespace StgSharp.HighPerformance.Memory
                 _bucketHeads[index] = null;
                 node = head;
                 return true;
+            } else
+            {
+                next->PreviousLevel = null;
             }
             _bucketHeads[index] = head->NextLevel;
             node = head;
             node->IsInBucket = false;
             node->NextLevel = null;
-            if (next != null) {
-                next->PreviousLevel = null;
-            }
             return true;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private bool TryPopLevel(
+                     int levelIndex,
+                     int sizeIndex,
+                     out BucketNode* node
+        )
+        {
+            int index = (3 * levelIndex) + sizeIndex;
+            index = (index >= _bucketHeads.Length) ? (_bucketHeads.Length - 1) : index;
+            return TryPopBucket(index, out node);
+        }
+
         private bool TryRemoveFromBucket(
                      int levelIndex,
                      int sizeIndex,
                      BucketNode* node
         )
         {
-            Index index = (levelIndex > 9) ? (^1) : ((3 * levelIndex) + sizeIndex);
+            int index = (3 * levelIndex) + sizeIndex;
+            index = (index >= _bucketHeads.Length) ? _bucketHeads.Length : index;
             if (_bucketHeads[index] == node)
             {
                 bool ok = TryPopLevel(levelIndex, sizeIndex, out _);
@@ -169,7 +195,7 @@ namespace StgSharp.HighPerformance.Memory
 
         /// <summary>
         ///   BucketNode structure - specialized node for bucket linked lists Stored in main
-        ///   allocation area (user-overwritable region)
+        ///   allocation area (user-writable region)
         /// </summary>
         [StructLayout(LayoutKind.Explicit)]
         internal struct BucketNode

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Debug.cs

@@ -2,8 +2,8 @@
 // -----------------------------------------------------------------------
 // file="HLSFAllocator.Debug"
 // Project: StgSharp
-// AuthorGroup: Nitload Space
+// AuthorGroup: Nitload
-// Copyright (c) Nitload Space. All rights reserved.
+// Copyright (c) Nitload. All rights reserved.
 //     
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -36,7 +36,8 @@ namespace StgSharp.HighPerformance.Memory
     public sealed class HLSFPositionChainBreakException : Exception
     {
 
-        public HLSFPositionChainBreakException() : base("Position chain of an HLSF allocator is broken") { }
+        public HLSFPositionChainBreakException()
+            : base("Position chain of an HLSF allocator is broken") { }
 
     }
 
@@ -45,7 +46,9 @@ namespace StgSharp.HighPerformance.Memory
 
         private object _lock = new object();
 
-        public void DisplayEntryLayout(bool singleStep)
+        public void DisplayEntryLayout(
+                    bool singleStep
+        )
         {
             lock (_lock)
             {
@@ -61,7 +64,10 @@ namespace StgSharp.HighPerformance.Memory
             }
         }
 
-        public void DumpPositionChain(bool singleStep = false, int maxCount = 4096)
+        public void DumpPositionChain(
+                    bool singleStep = false,
+                    int maxCount = 4096
+        )
         {
             lock (_lock)
             {
@@ -73,7 +79,7 @@ namespace StgSharp.HighPerformance.Memory
                         cur = cur->NextNear;
                     }
                     Console.WriteLine(EntryToString(_spareMemory));
-                    while (cur != null && cur != _spareMemory && cnt < maxCount)
+                    while ((cur != null) && (cur != _spareMemory) && (cnt < maxCount))
                     {
                         Console.WriteLine(EntryToString(cur));
                         cnt++;
@@ -112,7 +118,9 @@ namespace StgSharp.HighPerformance.Memory
             }
         }
 
-        private static string EntryToString(Entry* e)
+        private static string EntryToString(
+                              Entry* e
+        )
         {
             BucketNode* b = (BucketNode*)e->Position;
             return $"{(ulong)e->PreviousNear}<-prev- Position:{(ulong)e} Bucket:{{{(ulong)e->Position},{e->Level},{e->Size}}} -next->{(ulong)e->NextNear}";

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Free.cs

@@ -79,7 +79,7 @@ namespace StgSharp.HighPerformance.Memory
                     cur = next;
                 } while ((cur != null) && (cur != _spareMemory) && (cur->State == EntryState.Empty));
                 if (size > 0) {
-                    SliceMemory(cur, size);
+                    OrganizeMemory(cur, size);
                 }
             }
         }

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Level.cs

@@ -28,6 +28,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.Security;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -38,31 +39,51 @@ namespace StgSharp.HighPerformance.Memory
     public unsafe partial class HybridLayerSegregatedFitAllocator
     {
 
-        private const int MaxLevel = 9;
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-
+        private nuint GetAllocSize(
-        private uint[] _levelSizeArray = [
+                      nuint size
-            64U,
-            256U,
-            1024U,
-            4096U,
-            16384U,
-            65536U,
-            262144U,
-            1048576U,
-            4194304U,
-            16777216U
-        ];
-
-        public int AlignOfLevel(
-                   int bucketLevel
         )
+
         {
-            uint blockSize = _levelSizeArray[bucketLevel];
+            return (size + 63u) & (~63u);
-            return Math.Min((int)blockSize, _align);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int GetLevelFromSize(
+        private int GetBucketIndexOnce(
+                    nuint size
+        )
+        {
+            int log2Size = 63 - BitOperations.LeadingZeroCount((ulong)size);
+
+            // Calculate level: level = max(0, (log2Size - 6) / 2)
+            int level = Math.Max(0, (log2Size - 6) / 2);
+
+            // caller is responsible for ensuring level is within bounds
+            level = Math.Min(level, _maxLevel);
+            uint levelSize = 1u << (log2Size & (~1));
+            int segment = ((int)(size / levelSize)) - 1;
+            return (level * 3) + segment;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private (int level, int segment) GetIndexPairOnce(
+                                         nuint size
+        )
+        {
+            int log2Size = 63 - BitOperations.LeadingZeroCount((ulong)size);
+
+            // Calculate level: level = max(0, (log2Size - 6) / 2)
+            int level = Math.Max(0, (log2Size - 6) / 2);
+
+            // caller is responsible for ensuring level is within bounds
+            level = Math.Min(level, _maxLevel);
+            uint levelSize = 1u << (log2Size & (~1));
+            int segment = ((int)(size / levelSize)) - 1;
+            return (level, segment);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private int GetLevelFromSize(
                     nuint size
         )
         {
@@ -83,27 +104,38 @@ namespace StgSharp.HighPerformance.Memory
             int level = Math.Max(0, (log2Size - 6) / 2);
 
             // caller is responsible for ensuring level is within bounds
-            return level;
+            return Math.Min(level, _maxLevel);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int GetLevelFromSize(
+        private static uint GetLevelSizeFromLevel(
-                           uint size
+                            int level
         )
         {
-            return GetLevelFromSize(size);
+            return 1u << (6 + (2 * level));
         }
 
-    }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-
+        private static uint GetLevelSizeFromSize(
-    public enum CommonMemoryAlign : int
+                            nuint size
+        )
         {
+            int log2Size = 63 - BitOperations.LeadingZeroCount((ulong)size);
+            return 1u << (log2Size & (~1));
+        }
 
-        XMMLevel = 16,
+        /// <summary>
-        YMMLevel = 32,
+        ///   Determine segment index based on size and originLevel. Input level value is regarded
-        ZMMLevel = 64,
+        ///   safe.
-
+        /// </summary>
-        ArmNEONLevel = 16,
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private int GetSegmentFromLevel(
+                    ulong size,
+                    int level
+        )
+        {
+            return ((int)(size / GetLevelSizeFromLevel(level))) - 1;
+        }
 
     }
 }

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.SegmentEntry.cs

@@ -37,6 +37,9 @@ namespace StgSharp.HighPerformance.Memory
         /// <summary>
         ///   Check if two Entries are adjacent in memory
         /// </summary>
+        /// <returns>
+        ///   True if two mem blocks are adjacent.
+        /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static bool AssertAdjacentTo(
                             Entry* current,
@@ -48,36 +51,6 @@ namespace StgSharp.HighPerformance.Memory
                    (current->Position + current->Size == other->Position);
         }
 
-        /// <summary>
-        ///   check out if a bucket is within the same higher-level boundary as currentOffset
-        /// </summary>
-        private bool AssertBoundary(
-                     Entry* previous,
-                     Entry* current,
-                     int level
-        )
-        {
-            level = int.Min(level, MaxLevel);
-            uint nextLevelSize = _levelSizeArray[level] * 4;
-            ulong prevHead = previous->Position - ((ulong)m_Buffer),
-                currHead = current->Position - ((ulong)m_Buffer);
-            return currHead / nextLevelSize == prevHead / nextLevelSize;
-        }
-
-        /// <summary>
-        ///   Determine segment index based on size and originLevel
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int DetermineSegmentIndex(
-                           uint[] levelSizeArray,
-                           ulong size,
-                           int level
-        )
-        {
-            level = int.Min(level, MaxLevel);
-            return (int)((size - 1) / levelSizeArray[level]);
-        }
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static void InsertEntryAfter(
                             Entry* entry,
@@ -120,7 +93,7 @@ namespace StgSharp.HighPerformance.Memory
 
             nuint size = entry->Size;
             int originLevel = entry->Level;
-            int segment = DetermineSegmentIndex(_levelSizeArray, size, originLevel);
+            int segment = GetSegmentFromLevel(size, originLevel);
             do
             {
                 // previous direction merge
@@ -129,7 +102,7 @@ namespace StgSharp.HighPerformance.Memory
                     (p == _spareMemory) ||
                     (p->State != EntryState.Empty) ||
                     (p->Level != entry->Level) ||
-                    !AssertBoundary(p, entry, originLevel))
+                    !AssertAdjacentTo(p, entry))
                 {
                     break;
                 }
@@ -137,7 +110,7 @@ namespace StgSharp.HighPerformance.Memory
                 // Console.WriteLine($"{(ulong)p->Size} merged to {(ulong)entry->Size} previous");
                 entry->Size += p->Size;
                 entry->Position = p->Position;
-                RemoveFromBucket(originLevel, DetermineSegmentIndex(_levelSizeArray, p->Size, originLevel), (BucketNode*)p->Position);
+                RemoveFromBucket(originLevel, GetSegmentFromLevel(p->Size, originLevel), (BucketNode*)p->Position);
                 RemoveFromPositionChain(p);
             } while (true);
 
@@ -149,19 +122,18 @@ namespace StgSharp.HighPerformance.Memory
                     (n == _spareMemory) ||
                     (n->State != EntryState.Empty) ||
                     (n->Level != entry->Level) ||
-                    !AssertBoundary(n, entry, originLevel))
+                    !AssertAdjacentTo(n, entry))
                 {
                     break;
                 }
 
                 // Console.WriteLine($"{(ulong)n->Size} merged to {(ulong)entry->Size} next");
                 entry->Size += n->Size;
-                RemoveFromBucket(originLevel, DetermineSegmentIndex(_levelSizeArray, n->Size, originLevel), (BucketNode*)n->Position);
+                RemoveFromBucket(originLevel, GetSegmentFromLevel(n->Size, originLevel), (BucketNode*)n->Position);
                 RemoveFromPositionChain(n);
             } while (true);
             originLevel = int.Min(9, originLevel);
-            entry->Level += (entry->Size >= _levelSizeArray[originLevel] * 4) ? 1 : 0;
+            entry->Level = GetLevelFromSize(entry->Size);
-            entry->Level &= 15;
 
             BucketNode* bucket = (BucketNode*)entry->Position;
             bucket->EntryRef = entry;
@@ -190,7 +162,7 @@ namespace StgSharp.HighPerformance.Memory
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void SetEntryLevel(
+        private void SetEntryLevel(
                      Entry* entry,
                      nuint position,
                      nuint size

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.cs

@@ -30,7 +30,6 @@ using System.Buffers;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
-using hlsfHandle = StgSharp.HighPerformance.Memory.HlsfHandle;
 
 namespace StgSharp.HighPerformance.Memory
 {
@@ -47,6 +46,7 @@ namespace StgSharp.HighPerformance.Memory
         private readonly Action<nuint> _freeHandle;
         private bool disposedValue;
         private readonly int _align;
+        private readonly int _maxLevel;
         private readonly nuint _maxAllocSize;
         private readonly nuint _size;
         private readonly SlabAllocator<Entry> _entries;
@@ -88,16 +88,8 @@ namespace StgSharp.HighPerformance.Memory
             _spareMemory->Position = (nuint)m_Buffer;
             _spareMemory->Size = byteSize;
 
-            int levelCountOrigin = _levelSizeArray.Length;
+            _maxLevel = GetLevelFromSize(maxBlockSize) + 1;
-            int levelCount = GetLevelFromSize(maxBlockSize) + 1;
+            _bucketHeads = new BucketNode*[(_maxLevel * 3) + 1];
-            Array.Resize(ref _levelSizeArray, levelCount);
-            _bucketHeads = new BucketNode*[(levelCount * 3) + 1];
-            uint size = _levelSizeArray[^1];
-            for (int i = levelCountOrigin; i < levelCount; i++)
-            {
-                size *= 4;
-                _levelSizeArray[i] = size;
-            }
             _maxAllocSize = maxBlockSize;
             _freeHandle = freeHandle ?? (static _ => { });
         }

StgSharp.Common/HighPerformance/Memory/L4.cs

@@ -43,7 +43,7 @@ namespace StgSharp.HighPerformance.Memory
         private const int PredictionCount = 2048;
         private const int PredictionLeastAhead = 1024;
 
-        private static readonly IIntrinsicKernel _intrinsic = IIntrinsicKernel.Instance;
+        // private static readonly IIntrinsicKernel _intrinsic = IIntrinsicKernel.Instance;
         private readonly CacheLineHead* _head;
         private readonly MapArray* _mapCount;
         private readonly PredictionArray* _predictCount;