youmuliu/stgsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

going on reconstruct of HLSF

Browse Source
This commit is contained in:
Youmu Liu
2026-05-07 18:03:33 +08:00
parent c343e763ed
commit 8aa319a120
8 changed files with 220 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Level.cs
+79 -47
View File
@@ -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,72 +39,103 @@ namespace StgSharp.HighPerformance.Memory
public unsafe partial class HybridLayerSegregatedFitAllocator
{
private const int MaxLevel = 9;
private uint[] _levelSizeArray = [
64U,
256U,
1024U,
4096U,
16384U,
65536U,
262144U,
1048576U,
4194304U,
16777216U
];
public int AlignOfLevel(
int bucketLevel
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private nuint GetAllocSize(
nuint size
)
{
uint blockSize = _levelSizeArray[bucketLevel];
return Math.Min((int)blockSize, _align);
return (size + 63u) & (~63u);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int GetLevelFromSize(
nuint size
private int GetBucketIndexOnce(
nuint size
)
{
/*
* Level sizes: [64, 256, 1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, ......]
* Pattern: 64 * 4^level = 2^6 * 2^(2*level) = 2^(6+2*level)
*
* For size S, we need: 2^(6+2*level) >= S
* So: 6+2*level >= log2(S)
* Therefore: level >= (log2(S) - 6) / 2
*
* We use hardware LZCNT instruction via BitOperations.LeadingZeroCount
* log2(S) = 63 - LeadingZeroCount(S) for 64-bit values
*/
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
return level;
level = Math.Min(level, _maxLevel);
uint levelSize = 1u << (log2Size & (~1));
int segment = ((int)(size / levelSize)) - 1;
return (level * 3) + segment;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int GetLevelFromSize(
uint size
private (int level, int segment) GetIndexPairOnce(
nuint size
)
{
return GetLevelFromSize(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
)
{
/*
* Level sizes: [64, 256, 1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, ......]
* Pattern: 64 * 4^level = 2^6 * 2^(2*level) = 2^(6+2*level)
*
* For size S, we need: 2^(6+2*level) >= S
* So: 6+2*level >= log2(S)
* Therefore: level >= (log2(S) - 6) / 2
*
* We use hardware LZCNT instruction via BitOperations.LeadingZeroCount
* log2(S) = 63 - LeadingZeroCount(S) for 64-bit values
*/
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
return Math.Min(level, _maxLevel);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static uint GetLevelSizeFromLevel(
int level
)
{
return 1u << (6 + (2 * level));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static uint GetLevelSizeFromSize(
nuint size
)
{
int log2Size = 63 - BitOperations.LeadingZeroCount((ulong)size);
return 1u << (log2Size & (~1));
}
/// <summary>
/// Determine segment index based on size and originLevel. Input level value is regarded
/// safe.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private int GetSegmentFromLevel(
ulong size,
int level
)
{
return ((int)(size / GetLevelSizeFromLevel(level))) - 1;
}
}
public enum CommonMemoryAlign : int
{
XMMLevel = 16,
YMMLevel = 32,
ZMMLevel = 64,
ArmNEONLevel = 16,
}
}