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

hlsf error is solving

Browse Source
This commit is contained in:
Youmu Liu
2025-12-01 18:01:34 +08:00
parent 0c90461d35
commit 482cddd6bf
8 changed files with 160 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Alloc.cs
+28 -58
View File
@@ -77,21 +77,14 @@ namespace StgSharp.HighPerformance.Memory
throw new OverflowException("Out of memory: insufficient block size returned from spare memory.");
}
long remainder = handle->Size - requestedOffset;
if (remainder > 0)
{
Entry* extra = (Entry*)_entries.Allocate();
extra->Position = handle->Position + (nuint)requestedOffset;
extra->Size = (uint)remainder;
extra->State = EntryState.Empty;
extra->NextNear = handle->NextNear;
extra->PreviousNear = handle;
extra->NextNear->PreviousNear = extra;
extra->PreviousNear->NextNear = extra;
SliceMemory(extra);
}
SetEntryLevel(handle, handle->Position, (uint)requestedOffset);
handle->State = EntryState.Alloc;
handle->Size = requestedOffset;
handle->Level = level;
if (remainder > 0) {
SliceMemory(handle->NextNear, remainder);
}
}
if (handle->PreviousNear == null || handle->NextNear == null) {
throw new HLSFPositionChainBreakException();
}
return new hlsfHandle(handle, size);
}
@@ -103,14 +96,15 @@ namespace StgSharp.HighPerformance.Memory
/// <param name="e">
///
/// </param>
private void SliceMemory(Entry* e)
/// <param name="sizeToSlice">
///
/// </param>
private void SliceMemory(Entry* e, long sizeToSlice)
{
Entry* cur = e->PreviousNear;
Entry* next = e->NextNear;
long remain = e->Size;
long offset = (long)e->Position - (long)m_Buffer;
long end = offset + remain;
_entries.Free((nuint)e);
Entry* next = e;
long remain = sizeToSlice; // remained size to slice
long offset = (long)e->Position - sizeToSlice - (long)m_Buffer; // offset of buffer to slice
long end = (long)e->Position - (long)m_Buffer; // end offset of buffer to slice
int i = (BitOperations.TrailingZeroCount(remain) - 6) / 2;
i = int.Min(10, i);
@@ -125,21 +119,15 @@ namespace StgSharp.HighPerformance.Memory
int newSize = count * size;
Entry* newEntry = (Entry*)_entries.Allocate();
newEntry->PreviousNear = cur;
newEntry->NextNear = next;
cur->NextNear = newEntry;
next->PreviousNear = newEntry;
newEntry->Position = (nuint)offset + (nuint)m_Buffer;
InsertEntryBefore(newEntry, next);
SetEntryLevel(newEntry, (nuint)offset + (nuint)m_Buffer, newSize);
newEntry->State = EntryState.Empty;
newEntry->Size = (uint)newSize;
newEntry->Level = i;
BucketNode* b = (BucketNode*)newEntry->Position;
b->EntryRef = newEntry;
PushLevel(i, count - 1, b);
PushBucketToLevel(i, count - 1, b);
offset += newSize;
remain -= (long)newSize;
cur = newEntry;
remain -= newSize;
}
if (remain <= 0) {
return;
@@ -157,19 +145,13 @@ namespace StgSharp.HighPerformance.Memory
int newSize = count * upper;
Entry* newEntry = (Entry*)_entries.Allocate();
newEntry->PreviousNear = cur;
newEntry->NextNear = next;
cur->NextNear = newEntry;
next->PreviousNear = newEntry;
newEntry->Position = (nuint)offset + (nuint)m_Buffer;
InsertEntryBefore(newEntry, next);
SetEntryLevel(newEntry, (nuint)offset + (nuint)m_Buffer, newSize);
newEntry->State = EntryState.Empty;
newEntry->Size = (uint)newSize;
newEntry->Level = i;
BucketNode* b = (BucketNode*)newEntry->Position;
b->EntryRef = newEntry;
PushLevel(i, count - 1, b);
cur = newEntry;
PushBucketToLevel(i, count - 1, b);
offset += newSize;
remain -= (long)newSize;
if (remain <= 0) {
@@ -188,22 +170,15 @@ namespace StgSharp.HighPerformance.Memory
int newSize = count * size;
Entry* newEntry = (Entry*)_entries.Allocate();
newEntry->PreviousNear = cur;
newEntry->NextNear = next;
cur->NextNear = newEntry;
next->PreviousNear = newEntry;
newEntry->Position = (nuint)offset + (nuint)m_Buffer;
InsertEntryBefore(newEntry, next);
SetEntryLevel(newEntry, (nuint)offset + (nuint)m_Buffer, newSize);
newEntry->State = EntryState.Empty;
newEntry->Size = (uint)newSize;
newEntry->Level = i;
BucketNode* b = (BucketNode*)newEntry->Position;
b->EntryRef = newEntry;
b->NextLevel = null;
b->PreviousLevel = null;
PushLevel(i, count - 1, b);
cur = newEntry;
PushBucketToLevel(i, count - 1, b);
offset += newSize;
remain -= (long)newSize;
}
@@ -236,20 +211,15 @@ namespace StgSharp.HighPerformance.Memory
// build new entry
Entry* e = (Entry*)_entries.Allocate();
e->Position = pos;
e->Size = size;
Entry* prev = _spareMemory->PreviousNear;
e->NextNear = _spareMemory;
e->PreviousNear = prev;
prev->NextNear = e;
_spareMemory->PreviousNear = e;
SetEntryLevel(e, pos, size);
InsertEntryBefore(e, _spareMemory);
e->State = EntryState.Empty;
e->Level = GetLevelFromSize(size);
// set fields of spare memory
_spareMemory->Size -= size;
_spareMemory->Position += (nuint)size;
handle = e;
return true;
}
StgSharp.Common/HighPerformance/Memory/HLSFAllocator.BucketNode.cs
+1 -21
View File
@@ -35,7 +35,7 @@ namespace StgSharp.HighPerformance.Memory
public unsafe partial class HybridLayerSegregatedFitAllocator
{
private void PushLevel(int levelIndex, int sizeIndex, BucketNode* node)
private void PushBucketToLevel(int levelIndex, int sizeIndex, BucketNode* node)
{
if (node == null || node->EntryRef == null) {
return;
@@ -68,25 +68,6 @@ namespace StgSharp.HighPerformance.Memory
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void RemoveFromBucket(BucketNode* node)
{
BucketNode* previous = node->PreviousLevel;
BucketNode* next = node->NextLevel;
if (previous != null) {
previous->NextLevel = next;
}
if (next != null) {
next->PreviousLevel = previous;
}
node->NextLevel = (BucketNode*)null;
node->PreviousLevel = (BucketNode*)null;
node->IsInBucket = false;
return;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void RemoveFromBucket(int levelIndex, int sizeIndex, BucketNode* node)
{
@@ -97,7 +78,6 @@ namespace StgSharp.HighPerformance.Memory
return;
}
}
BucketNode* previous = node->PreviousLevel;
BucketNode* next = node->NextLevel;
StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Debug.cs
+38 -2
View File
@@ -62,6 +62,42 @@ namespace StgSharp.HighPerformance.Memory
}
}
public void DumpPositionChain(bool singleStep = false, int maxCount = 4096)
{
lock (_lock)
{
try
{
Entry* cur = _spareMemory;
int cnt = 0;
if (cur != null) {
cur = cur->NextNear;
}
Console.WriteLine(EntryToString(_spareMemory));
while (cur != null && cur != _spareMemory && cnt < maxCount)
{
Console.WriteLine(EntryToString(cur));
cnt++;
if (singleStep) {
Console.ReadKey();
}
cur = cur->NextNear;
}
if (cur == _spareMemory)
{
Console.WriteLine("(reached sentinel)");
} else if (cnt >= maxCount) {
Console.WriteLine("(stopped at maxCount)");
}
}
catch (Exception ex)
{
Console.WriteLine($"[DumpPositionChain-forward] Exception: {ex.Message}");
}
}
}
public IEnumerable<string> ShowEntryLayout()
{
lock (_lock)
@@ -80,8 +116,8 @@ namespace StgSharp.HighPerformance.Memory
private static string EntryToString(Entry* e)
{
BucketNode* b = (BucketNode*)e->Position;
return $"{(ulong)e->PreviousNear}<-- Position{(ulong)e} Bucket:{{{(ulong)e->Position},{e->Level},{e->Size}}} -->{(ulong)e->NextNear}";
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
+13 -12
View File
@@ -49,27 +49,28 @@ namespace StgSharp.HighPerformance.Memory
public void Collect()
{
Entry* cur = _spareMemory->NextNear;
long size = 0;
while (cur != null && cur != _spareMemory)
{
// cur is not empty, skip
if (cur->State != EntryState.Empty)
{
cur = cur->NextNear;
continue;
}
RemoveFromBucket(cur->Level, DetermineSegmentIndex(cur->Size, cur->Level), (BucketNode*)cur->Position);
Entry* next = cur->NextNear;
while (next is not null &&
next->State == EntryState.Empty &&
AssertAdjacentTo(cur, next))
// remove cur from bucket
do
{
RemoveFromBucket(next->Level, DetermineSegmentIndex(next->Size, next->Level), (BucketNode*)next->Position);
cur->Size += next->Size;
RemoveFromPositionChain(next);
next = cur->NextNear;
size += cur->Size;
Entry* next = cur->NextNear;
RemoveFromBucket(cur->Level, DetermineSegmentIndex(cur->Size, cur->Level), (BucketNode*)cur->Position);
RemoveFromPositionChain(cur);
cur = next;
} while (cur != null && cur != _spareMemory && cur->State == EntryState.Empty);
if (size > 0) {
SliceMemory(cur, size);
}
SliceMemory(cur);
cur = next;
}
}
@@ -108,7 +109,7 @@ namespace StgSharp.HighPerformance.Memory
int finalSegment = DetermineSegmentIndex(finalSize, finalLevel);
// Push the merged entry back to appropriate bucket
PushLevel(finalLevel, finalSegment, (BucketNode*)e->Position);
PushBucketToLevel(finalLevel, finalSegment, (BucketNode*)e->Position);
// Console.WriteLine("one block freed");
}
StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Level.cs
+2 -2
View File
@@ -60,13 +60,13 @@ namespace StgSharp.HighPerformance.Memory
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private int GetLevelFromSize(long size)
private static int GetLevelFromSize(long size)
{
return GetLevelFromSize((uint)size);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private int GetLevelFromSize(uint size)
private static int GetLevelFromSize(uint size)
{
/*
* Level sizes: [64, 256, 1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216]
StgSharp.Common/HighPerformance/Memory/HLSFAllocator.SegmentEntry.cs
+74 -6
View File
@@ -61,12 +61,32 @@ namespace StgSharp.HighPerformance.Memory
/// Determine segment index based on size and originLevel
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private int DetermineSegmentIndex(long size, int level)
private static int DetermineSegmentIndex(long size, int level)
{
level = int.Min(level, MaxLevel);
return (int)((size - 1) / levelSizeArray[level]);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void InsertEntryAfter(Entry* entry, Entry* position)
{
Entry* next = position->NextNear;
entry->NextNear = next;
entry->PreviousNear = position;
next->PreviousNear = entry;
position->NextNear = entry;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void InsertEntryBefore(Entry* entry, Entry* position)
{
Entry* prev = position->PreviousNear;
entry->NextNear = position;
entry->PreviousNear = prev;
prev->NextNear = entry;
position->PreviousNear = entry;
}
/// <summary>
/// Used in Free operations, efficiently remove from buckets and merge adjacent blocks.
/// Current Entry will serve as the final merged block. The Merge will be in lazy
@@ -74,12 +94,52 @@ namespace StgSharp.HighPerformance.Memory
/// </summary>
private void MergeAndRemoveFromBuckets(Entry* entry)
{
// TODO 后续提供HLSF.Collect全量整理API，从头遍历邻接块进行彻底的合并
if (entry == null)
{
if (entry == null) {
return;
}
/*
Console.WriteLine("============ Merge start =======================");
try
{
Console.WriteLine("forward from entry");
Entry* __cur = entry;
int __cnt = 0;
while (__cur != null && __cur != _spareMemory && __cnt < 512)
{
Console.WriteLine(EntryToString(__cur));
__cur = __cur->NextNear;
__cnt++;
if (__cur == entry)
{
Console.WriteLine("(looped back to start)");
break;
}
}
Console.WriteLine(EntryToString(__cur));
Console.WriteLine("MergeAndRemoveFromBuckets: backward from entry");
__cur = entry;
__cnt = 0;
while (__cur != null && __cur != _spareMemory && __cnt < 512)
{
Console.WriteLine(EntryToString(__cur));
__cur = __cur->PreviousNear;
__cnt++;
if (__cur == entry)
{
Console.WriteLine("(looped back to start)");
break;
}
}
Console.WriteLine(EntryToString(__cur));
}
catch { }
finally
{
Console.WriteLine("==========================================");
}
/**/
long size = entry->Size;
int originLevel = entry->Level;
int segment = DetermineSegmentIndex(size, originLevel);
@@ -88,8 +148,8 @@ namespace StgSharp.HighPerformance.Memory
// previous direction merge
Entry* p = entry->PreviousNear;
if (p == null ||
p == _spareMemory ||
p->State != EntryState.Empty ||
!AssertAdjacentTo(entry, p) ||
p->Level != entry->Level ||
!AssertBoundary(p, entry, originLevel))
{
@@ -108,8 +168,8 @@ namespace StgSharp.HighPerformance.Memory
// next direction merge
Entry* n = entry->NextNear;
if (n == null ||
n == _spareMemory ||
n->State != EntryState.Empty ||
!AssertAdjacentTo(entry, n) ||
n->Level != entry->Level ||
!AssertBoundary(n, entry, originLevel))
{
@@ -149,6 +209,14 @@ namespace StgSharp.HighPerformance.Memory
_entries.Free((nuint)entry);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void SetEntryLevel(Entry* entry, nuint position, long size)
{
entry ->Position = position;
entry->Size = size;
entry->Level = GetLevelFromSize(size);
}
/// <summary>
/// Entry structure - streamlined version (only position and state information) Stored in
/// external SLAB
StgSharp.Common/HighPerformance/Memory/HLSFAllocator.cs
+3 -3
View File
@@ -37,7 +37,7 @@ namespace StgSharp.HighPerformance.Memory
{
// Bucket system field - directly in main allocator class
private BucketNode*[] _bucketHeads;
private readonly BucketNode*[] _bucketHeads;
// _spareMemory is also the beginning position of allocator
private Entry* _spareMemory;
@@ -64,7 +64,7 @@ namespace StgSharp.HighPerformance.Memory
_spareMemory->PreviousNear = _spareMemory;
_spareMemory->NextNear = _spareMemory;
_spareMemory->Position = (nuint)m_Buffer;
_spareMemory->Size = (uint)byteSize;
_spareMemory->Size = (long)byteSize;
}
public HybridLayerSegregatedFitAllocator(nuint byteSize, int align)
@@ -85,7 +85,7 @@ namespace StgSharp.HighPerformance.Memory
_spareMemory->PreviousNear = _spareMemory;
_spareMemory->NextNear = _spareMemory;
_spareMemory->Position = (nuint)m_Buffer;
_spareMemory->Size = (uint)byteSize;
_spareMemory->Size = (long)byteSize;
}
public void Dispose()
StgSharpDebug/HlsfStressTest.cs
+1
View File
@@ -65,6 +65,7 @@ namespace StgSharp
uint size = sz > MaxAllocSize ? MaxAllocSize : sz;
BenchAllocThroughput(allocator, size, touch:false);
allocator.Collect();
allocator.DumpPositionChain();
GC.Collect();
GC.WaitForPendingFinalizers();
}