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

Remove hlsf, TLSF.alloc is ok

Browse Source
This commit is contained in:
Youmu Liu
2026-05-11 18:08:35 +08:00
parent 5706c89563
commit b59d414e20
21 changed files with 267 additions and 1514 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Common/HighPerformance/Memory/HLSFAllocationHandle.cs
-117
View File
@@ -1,117 +0,0 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="HLSFAllocationHandle"
// Project: StgSharp
// AuthorGroup: Nitload
// 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
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Allocator = StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator;
namespace StgSharp.HighPerformance.Memory
{
public readonly unsafe struct HlsfHandle
{
internal readonly Allocator.Entry* EntryHandle;
public readonly nuint AllocSize;
internal HlsfHandle(
Allocator.Entry* handle,
nuint s
)
{
EntryHandle = handle;
Pointer = (byte*)handle->Position;
AllocSize = s;
// Console.WriteLine($"{(ulong)handle->PreviousNear}<->{(ulong)handle->NextNear},\t{handle->Size}");
}
public readonly ref byte this[
uint index
]
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, AllocSize);
return ref Pointer[index];
}
}
public readonly byte* Pointer { get; init; }
public readonly Span<byte> BufferHandle => new(Pointer, (int)AllocSize);
public readonly Enumerator GetEnumerator()
{
return new Enumerator(this);
}
public ref struct Enumerator : IEnumerator<byte>
{
private HlsfHandle _handle;
private uint _index = ~0u;
internal Enumerator(
HlsfHandle span
)
{
_handle = span;
Span = span.BufferHandle;
}
public ref byte RefCurrent => ref _handle[_index];
public Span<byte> Span { get; init; }
public readonly void Dispose() { }
public bool MoveNext()
{
_index++;
return _index < _handle.AllocSize;
}
public void Reset()
{
_index = 0;
}
object IEnumerator.Current => RefCurrent;
byte IEnumerator<byte>.Current => RefCurrent;
}
}
}
StgSharp.Common/HighPerformance/Memory/L4.CacheLine.cs
+10 -11
View File
@@ -28,7 +28,7 @@
using StgSharp.HighPerformance.ProcessorAbstraction;
using System.Runtime.InteropServices;
using Hlsf = StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator;
using Tlsf = StgSharp.HighPerformance.Memory.TwoLayerSegregatedFitAllocator;
namespace StgSharp.HighPerformance.Memory
{
@@ -51,34 +51,33 @@ namespace StgSharp.HighPerformance.Memory
}
[StructLayout(LayoutKind.Explicit, Size = 64, Pack = 16)]
[StructLayout(LayoutKind.Explicit, Size = 64, Pack = 64)]
private unsafe struct CacheLineHead
{
[FieldOffset(0)] internal Hlsf.Entry AllocatorEntry;
[FieldOffset(0)] internal Tlsf.Handle AllocatorEntry;
[FieldOffset(0)] internal readonly M512 Buffer;
#region reference counting and state information
[FieldOffset(52)] internal int RefCount;
[FieldOffset(60)] private readonly int Reverse;
[FieldOffset(56)] internal readonly int Id;
[FieldOffset(24)] internal int RefCount;
[FieldOffset(28)] internal readonly int Id;
#endregion
#region hlsf entry alias
[FieldOffset(24)] public readonly nuint Address;
[FieldOffset(16)] public readonly uint Size;
[FieldOffset(8)] public readonly Ptr64 Address;
[FieldOffset(16)] public readonly Ptr64 Size;
#endregion
#region cache line information
[FieldOffset(50)] internal short Predictor;
[FieldOffset(48)] internal ushort Profile;
[FieldOffset(40)] internal nuint Origin;
[FieldOffset(32)] internal short Predictor;
[FieldOffset(34)] internal ushort Profile;
[FieldOffset(36)] internal nuint Origin;
#endregion
}
StgSharp.Common/HighPerformance/Memory/L4.Evict.cs
+10 -5
View File
@@ -35,7 +35,7 @@ using System.Runtime.Intrinsics.X86;
using System.Text;
using System.Threading.Tasks;
using HlsfEntry = StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator.Entry;
using Tlsf = StgSharp.HighPerformance.Memory.TwoLayerSegregatedFitAllocator;
namespace StgSharp.HighPerformance.Memory
{
@@ -87,8 +87,11 @@ namespace StgSharp.HighPerformance.Memory
int id
)
{
HlsfEntry* entry = (HlsfEntry*)(_entryManager._basePtr + id);
throw new NotImplementedException();
/*
Tlsf* entry = (Tlsf*)(_entryManager._basePtr + id);
_bufferAllocator.Free(entry);
/**/
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -105,7 +108,7 @@ namespace StgSharp.HighPerformance.Memory
int id = head->Predictor;
IL4Predict predict = predictorSpan[id] ??
throw new L4PredictUnregisteredException(id);
predict.WriteBack(head->Origin, head->Profile, new ReadOnlySpan<byte>((byte*)head->Address, (int)head->Size));
predict.WriteBack(head->Origin, head->Profile, new ReadOnlySpan<byte>((byte*)(ulong)head->Address, (int)(ulong)head->Size));
RecycleLine(index);
(*_mapCount)[index] = 0;
(*_predictCount)[index] = int.MaxValue;
@@ -121,12 +124,14 @@ namespace StgSharp.HighPerformance.Memory
)
{
if (!_bufferAllocator.TryAlloc(size, out HlsfHandle handle))
if (!_bufferAllocator.TryAlloc(size, out Tlsf.Handle handle))
{
index = 0;
return false;
}
CacheLineHead* entry = (CacheLineHead*)handle.EntryHandle;
// origin :CacheLineHead* entry = (CacheLineHead*)handle.EntryHandle;
CacheLineHead* entry = (CacheLineHead*)handle.Pointer;
index = entry->Id;
return true;
}
StgSharp.Common/HighPerformance/Memory/L4.Prefetch.cs
+1 -1
View File
@@ -146,7 +146,7 @@ namespace StgSharp.HighPerformance.Memory
(*_mapCount)[index] = 1;
// pre fetch them here
predict.Prefetch(head->Origin, head->Profile, new Span<byte>((byte*)head->Address, (int)head->Size));
predict.Prefetch(head->Origin, head->Profile, new Span<byte>((byte*)(ulong)head->Address, (int)(ulong)head->Size));
_ = _map.TryAddOrSet(address, (nuint)head, out _);
}
_ = Interlocked.Add(ref _aheadCount, actualCount);
StgSharp.Common/HighPerformance/Memory/L4.Slab.cs
+3 -3
View File
@@ -31,14 +31,14 @@ using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Hlsf = StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator;
using Tlsf = StgSharp.HighPerformance.Memory.TwoLayerSegregatedFitAllocator;
namespace StgSharp.HighPerformance.Memory
{
public partial class L4
{
private sealed unsafe class Slab : SlabAllocator<Hlsf.Entry>
private sealed unsafe class Slab : SlabAllocator<Tlsf.Metadata>
{
private const int Capacity = L4.CacheLineCount;
@@ -91,7 +91,7 @@ namespace StgSharp.HighPerformance.Memory
_recycleCount++;
}
public override SlabAllocationHandle<Hlsf.Entry> ReadAllocation()
public override SlabAllocationHandle<Tlsf.Metadata> ReadAllocation()
{
return new(this, false);
}
StgSharp.Common/HighPerformance/Memory/L4.cs
+23 -10
View File
@@ -2,8 +2,8 @@
// -----------------------------------------------------------------------
// file="L4"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
// AuthorGroup: Nitload
// 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
@@ -31,7 +31,7 @@ using StgSharp.HighPerformance.ProcessorAbstraction;
using System.Data;
using System.Runtime.InteropServices;
using HLSF = StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator;
using HLSF = StgSharp.HighPerformance.Memory.TwoLayerSegregatedFitAllocator;
namespace StgSharp.HighPerformance.Memory
{
@@ -62,7 +62,12 @@ namespace StgSharp.HighPerformance.Memory
private readonly Slab _entryManager;
private readonly SwissTable _map;
public L4(int bindedNuma, nuint bufferSize = 8192 * 8192, int align = 16, nuint maxCacheLineSize = 8192)
public L4(
int bindedNuma,
nuint bufferSize = 8192 * 8192,
int align = 16,
nuint maxCacheLineSize = 8192
)
{
_bindedNuma = bindedNuma;
@@ -85,8 +90,8 @@ namespace StgSharp.HighPerformance.Memory
// init all components with the buffer, and move the buffer pointer forward.
nuint _buffer = _baseAddress + normalizedBufferSize;
_entryManager = new Slab(_buffer);
_bufferAllocator = new HLSF(entrySize, align, maxCacheLineSize, (void*)_baseAddress, static _ => { },
_entryManager);
_bufferAllocator = new HLSF(entrySize, align, maxCacheLineSize, (void*)_baseAddress,
static _ => { }/*, _entryManager/**/);
ptr += entrySize;
_head = (CacheLineHead*)ptr;
ptr += headSize;
@@ -112,7 +117,9 @@ namespace StgSharp.HighPerformance.Memory
// public IL4Predict PrefetchPredict { get; set; }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void ContinueOnce(L4CacheLine line)
public void ContinueOnce(
L4CacheLine line
)
{
if (line.Address > 0) {
_ = Interlocked.Decrement(ref _aheadCount);
@@ -150,7 +157,9 @@ namespace StgSharp.HighPerformance.Memory
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public L4CacheLine Map(ref CacheLineDescription prediction)
public L4CacheLine Map(
ref CacheLineDescription prediction
)
{
if ((_aheadCount < PredictionLeastAhead) && !_exhausted)
{
@@ -182,7 +191,7 @@ namespace StgSharp.HighPerformance.Memory
_ = Interlocked.Increment(ref _activeCount);
_ = Interlocked.Decrement(ref _aheadCount);
_ = Interlocked.Decrement(ref (*_mapCount)[entry->Id]);
return new L4CacheLine(entry->Address, ref _activeCount, ref entry->RefCount);
return new L4CacheLine((nuint)entry->Address, ref _activeCount, ref entry->RefCount);
} else
{
_ = Interlocked.Decrement(ref entry->RefCount);
@@ -203,7 +212,11 @@ namespace StgSharp.HighPerformance.Memory
private ref int _refCount;
private nuint _handle;
internal L4CacheLine(nuint handle, ref int activeCount, ref int cacheRefCount)
internal L4CacheLine(
nuint handle,
ref int activeCount,
ref int cacheRefCount
)
{
_handle = handle;
_refCount = ref cacheRefCount;
StgSharp.Common/HighPerformance/Memory/TwoLayerSegregatedFitAllocator.cs
+169 -40
View File
@@ -2,8 +2,8 @@
// -----------------------------------------------------------------------
// file="TwoLayerSegregatedFitAllocator"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
// AuthorGroup: Nitload
// 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
@@ -29,6 +29,7 @@ using StgSharp.HighPerformance.Memory;
using StgSharp.HighPerformance.ProcessorAbstraction;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Numerics;
using System.Reflection.Metadata;
@@ -44,13 +45,13 @@ namespace StgSharp.HighPerformance.Memory
private const ulong Mask48Bits = 0x0000FFFFFFFFFFFF;
private readonly Metadata*[] _bucket;
private readonly int[] _bucket;
private readonly Metadata* _spareMemory;
private readonly Action<nuint> _freeHandle;
private bool disposedValue;
private readonly int _align;
private int _allocEnd;
private int _metadataEnd;
private readonly Ptr64 _basePtr;
private readonly ulong _maxAllocSize;
private readonly ulong _totalSize;
@@ -60,7 +61,8 @@ namespace StgSharp.HighPerformance.Memory
int align,
ulong maxBlockSize,
Func<nuint, int, nuint> allocator,
Action<nuint> freeHandle)
Action<nuint> freeHandle
)
: this(byteSize, align, maxBlockSize, (void*)allocator(byteSize, align), freeHandle) { }
internal TwoLayerSegregatedFitAllocator(
@@ -68,16 +70,17 @@ namespace StgSharp.HighPerformance.Memory
int align,
ulong maxBlockSize,
void* externalPointer,
Action<nuint> freeHandle)
Action<nuint> freeHandle
)
{
_totalSize = byteSize;
_basePtr = (Ptr64)(ulong)externalPointer;
_align = align;
_maxAllocSize = ulong.Max(64, (~64UL) & (ulong.Min(maxBlockSize + 63, Mask48Bits)));
_bucket = new Metadata*[58 - BitOperations.LeadingZeroCount(_maxAllocSize)];
_bucket = new int[GetLevel(_maxAllocSize) + 1];
_spareMemory = &((Metadata*)(ulong)(_basePtr + _totalSize))[-1];
_freeHandle = freeHandle ?? (static_ => { });
_allocEnd = 0;
_metadataEnd = 0;
// init spare memory node
@@ -89,59 +92,128 @@ namespace StgSharp.HighPerformance.Memory
_spareMemory->PreviousNear = 0;
}
public TwoLayerSegregatedFitAllocator(nuint byteSize)
public TwoLayerSegregatedFitAllocator(
nuint byteSize
)
: this(byteSize, 16, 32U * 1024U * 1024U, NativeMemory.AlignedAlloc(byteSize, 16),
ptr => NativeMemory.AlignedFree((void*)ptr)) { }
public TwoLayerSegregatedFitAllocator(nuint byteSize, uint maxBlockSize)
public TwoLayerSegregatedFitAllocator(
nuint byteSize,
uint maxBlockSize
)
: this(byteSize, 16, maxBlockSize, NativeMemory.AlignedAlloc(byteSize, 16),
ptr => NativeMemory.AlignedFree((void*)ptr)) { }
public TwoLayerSegregatedFitAllocator(nuint byteSize, int align)
public TwoLayerSegregatedFitAllocator(
nuint byteSize,
int align
)
: this(byteSize, align, 32U * 1024U * 1024U, NativeMemory.AlignedAlloc(byteSize, 16),
ptr => NativeMemory.AlignedFree((void*)ptr)) { }
public TwoLayerSegregatedFitAllocator(nuint byteSize, int align, nuint maxBlockSize)
public TwoLayerSegregatedFitAllocator(
nuint byteSize,
int align,
nuint maxBlockSize
)
: this(byteSize, align, maxBlockSize, NativeMemory.AlignedAlloc(byteSize, 16),
ptr => NativeMemory.AlignedFree((void*)ptr)) { }
public Handle Alloc(nuint size)
public Handle Alloc(
nuint size
)
{
ulong allocSize = nuint.Max(64, (~64U) & (size + 63));
ulong allocSize = ulong.Max(64, (~63UL) & ((ulong)size + 63));
if (allocSize > _maxAllocSize) {
throw new OverflowException("Requested allocation size exceeds the maximum block size.");
}
int level = 57 - BitOperations.LeadingZeroCount(allocSize);
int level = GetLevel(allocSize);
Metadata* entry = null;
for (int i = level; i < _bucket.Length; i++)
{
entry = _bucket[i];
if (entry is not null)
int idx = _bucket[i];
if (idx != 0)
{
_bucket[i] = entry->NextLevel != 0 ? &_spareMemory[-entry->NextLevel] : null;
entry = &_spareMemory[-idx];
_bucket[i] = entry->NextLevel;
break;
}
}
if (entry is null && !TryGetNewMetadata(allocSize, out entry)) {
if (entry is null && !TryAllocNewChunk(allocSize, out entry)) {
throw new OverflowException("No available ");
}
ulong remain = entry->Size - allocSize;
int entryIdx = (int)(_spareMemory - entry);
ulong entrySize = entry->Size;
ulong remain = entrySize - allocSize;
throw new NotImplementedException();
// slice tail
if (remain > (entrySize >> 7) && TryGetNewMetadata(out Metadata* newEntry))
{
int newEntryIdx = (int)(_spareMemory - newEntry);
newEntry->Position = entry->Position + allocSize;
newEntry->Size = remain;
int newLevel = GetLevel(remain);
int bucketHeadIdx = _bucket[newLevel];
if (bucketHeadIdx != 0)
{
// if there is already an entry in the bucket, link it to the new entry
Metadata* bucketHead = &_spareMemory[-bucketHeadIdx];
newEntry->NextLevel = bucketHeadIdx;
bucketHead->PreviousLevel = newEntryIdx;
} else
{
newEntry->NextLevel = 0;
}
newEntry->PreviousLevel = 0;
_bucket[newLevel] = newEntryIdx;
// push to position chain
int afterIdx = entry->NextNear;
Metadata* after = &_spareMemory[-afterIdx];
newEntry->NextNear = afterIdx;
after->PreviousNear = newEntryIdx;
entry->NextNear = newEntryIdx;
newEntry->PreviousNear = entryIdx;
}
return new Handle(entry, _basePtr);
}
public void Collect() { }
public void Dispose()
{
Dispose(disposing:true);
GC.SuppressFinalize(this);
}
public void Free(Handle handle)
public void Free(
Handle handle,
int collectScanWindow = 4
)
{
Metadata* head = handle._meta;
for (int i = 0; i < collectScanWindow; i++)
{
// forward scan
}
for (int i = 0; i < collectScanWindow; i++)
{
// backward scan
}
}
public bool TryAlloc(
nuint size,
out Handle h
)
{
throw new NotImplementedException();
}
protected virtual void Dispose(bool disposing)
protected virtual void Dispose(
bool disposing
)
{
if (!disposedValue)
{
@@ -153,7 +225,18 @@ namespace StgSharp.HighPerformance.Memory
}
}
private bool TryGetNewMetadata(ulong size, out Metadata* meta)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int GetLevel(
ulong size
)
{
return 57 - BitOperations.LeadingZeroCount(size);
}
private bool TryAllocNewChunk(
ulong size,
out Metadata* meta
)
{
int idx = _spareMemory->NextLevel;
if (idx != 0)
@@ -163,29 +246,57 @@ namespace StgSharp.HighPerformance.Memory
return true;
}
ulong spareSize = _spareMemory->Size;
if (spareSize < 32UL + size)
if (spareSize < Metadata.SizeOf + size)
{
meta = null;
return false;
}
_allocEnd++;
meta = &_spareMemory[-_allocEnd];
spareSize -= 32UL - size;
_metadataEnd++;
meta = &_spareMemory[-_metadataEnd];
spareSize -= Metadata.SizeOf + size;
_spareMemory->Size = spareSize;
_spareMemory->Position += size;
meta->Size = size;
// insert the new chunk to position chain
int nearIdx = _spareMemory->PreviousNear;
Metadata* near = &_spareMemory[-nearIdx];
near->NextNear = _metadataEnd;
meta->PreviousNear = nearIdx;
_spareMemory->PreviousNear = _metadataEnd;
meta->NextNear = 0;
return true;
}
[StructLayout(LayoutKind.Sequential)]
private bool TryGetNewMetadata(
out Metadata* meta
)
{
ulong spareSize = _spareMemory->Size;
if (spareSize < Metadata.SizeOf)
{
meta = null;
return false;
}
_metadataEnd++;
meta = &_spareMemory[-_metadataEnd];
spareSize -= Metadata.SizeOf;
_spareMemory->Size = spareSize;
return true;
}
[StructLayout(LayoutKind.Explicit)]
public readonly struct Handle
{
internal readonly Metadata* _meta;
public readonly void* Pointer;
public readonly Ptr64 Size;
[FieldOffset(0)]internal readonly Metadata* _meta;
[FieldOffset(8)]public readonly void* Pointer;
[FieldOffset(16)]public readonly Ptr64 Size;
internal Handle(Metadata* meta, Ptr64 baseAddress)
internal Handle(
Metadata* meta,
Ptr64 baseAddress
)
{
_meta = meta;
Pointer = (void*)(ulong)(meta->Position + baseAddress);
@@ -195,7 +306,26 @@ namespace StgSharp.HighPerformance.Memory
[Obsolete("You should not create instance from default. Alloc from allocator please")]
public Handle() { }
public ref byte this[int offset] => ref ((byte*)Pointer)[offset];
public ref byte this[
int offset
] => ref ((byte*)Pointer)[offset];
public Span<byte> AsSpan(
int range = -1
)
{
return new Span<byte>(Pointer, range < 0 ? (int)(ulong)Size : range);
}
}
internal enum AllocationState : short
{
Free = 0,
Used = 1,
Split = 2,
Merged = 3
}
@@ -206,18 +336,17 @@ namespace StgSharp.HighPerformance.Memory
[FieldOffset(24)] private ulong PositionMask;
[FieldOffset(16)] private ulong SizeMask;
[FieldOffset(30)] internal AllocationState State;
[FieldOffset(0)] public int NextLevel;
[FieldOffset(4)] public int NextNear;
[FieldOffset(8)] public int PreviousLevel;
[FieldOffset(12)] public int PreviousNear;
[FieldOffset(22)] public ushort Mask1;
[FieldOffset(30)] public ushort Mask2;
public Ptr64 Position
{
readonly get => (Ptr64)(PositionMask & Mask48Bits);
set => PositionMask = (PositionMask & ~Mask48Bits) | ((ulong)value & Mask48Bits);
readonly get => PositionMask;
set => PositionMask = value;
}
public Ptr64 Size
@@ -228,7 +357,7 @@ namespace StgSharp.HighPerformance.Memory
public Ptr64 SizeForSpare
{
get => SizeMask;
readonly get => SizeMask;
set => SizeMask = value;
}
StgSharp.Common/HighPerformance/Memory/old/HLSFAllocator.Alloc.cs
-239
View File
@@ -1,239 +0,0 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="HLSFAllocator.Alloc"
// Project: StgSharp
// AuthorGroup: Nitload
// 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
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using System;
using System.IO;
using System.Numerics;
using System.Reflection.Metadata;
using hlsfHandle = StgSharp.HighPerformance.Memory.HlsfHandle;
namespace StgSharp.HighPerformance.Memory
{
public unsafe partial class HybridLayerSegregatedFitAllocator
{
public partial HlsfHandle Alloc(
nuint size
)
{
if (size > _maxAllocSize) {
throw new InvalidOperationException("Requested size exceeds maximum allocatable size.");
}
/*
int level = GetLevelFromSize(size);
int segmentIndex = GetSegmentFromLevel(size, level);
int i = level, s = segmentIndex;
/**/
Entry* entry = null;
nuint requestedOffset = GetAllocSize(size);
(int level, int segment) = GetIndexPairOnce(size);
int index = int.Min((3 * level) + segment, _bucketHeads.Length);
int i = index;
while ((i < _bucketHeads.Length) && !TryPopLevelForAllocation(i, out entry)) {
i++;
}
if ((i >= _bucketHeads.Length) && !TryAllocateNewBlock(requestedOffset, out entry)) {
throw new OverflowException($"Out of memory: unable to satisfy request of {size} B (aligned {requestedOffset} B) from existing buckets or spare memory.");
}
if (entry != null)
{
if (requestedOffset > entry->Size) {
throw new OverflowException("Out of memory: insufficient block size returned from spare memory.");
}
nuint remainder = entry->Size - requestedOffset;
SetEntryLevel(entry, entry->Position, (uint)requestedOffset);
entry->State = EntryState.Alloc;
if (remainder > 0) {
OrganizeMemory(entry->NextNear, remainder);
}
}
return new(entry, size);
}
public bool TryAlloc(
nuint size,
out HlsfHandle handle
)
{
if (size > _maxAllocSize)
{
handle = default;
return false;
}
/*
int level = GetLevelFromSize(size);
int segmentIndex = GetSegmentFromLevel(size, level);
int i = level, s = segmentIndex;
/**/
Entry* entry = null;
nuint requestedOffset = GetAllocSize(size);
(int level, int segment) = GetIndexPairOnce(size);
int index = int.Min((3 * level) + segment, _bucketHeads.Length);
int i = index;
while ((i < _bucketHeads.Length) && !TryPopLevelForAllocation(i, out entry)) {
i++;
}
if ((i >= _bucketHeads.Length) && !TryAllocateNewBlock(requestedOffset, out entry)) {
throw new OverflowException($"Out of memory: unable to satisfy request of {size} B (aligned {requestedOffset} B) from existing buckets or spare memory.");
}
if (entry != null)
{
if (requestedOffset > entry->Size) {
throw new OverflowException("Out of memory: insufficient block size returned from spare memory.");
}
nuint remainder = entry->Size - requestedOffset;
SetEntryLevel(entry, entry->Position, (uint)requestedOffset);
entry->State = EntryState.Alloc;
if (remainder > 0) {
OrganizeMemory(entry->NextNear, remainder);
}
}
handle = new(entry, size);
return true;
}
/// <summary>
/// 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 OrganizeMemory(
Entry* e,
nuint sizeToSlice
)
{
Entry* next = e;
nuint remain = sizeToSlice; // remained size to slice
nuint offset = e->Position - sizeToSlice - ((nuint)m_Buffer); // offset of buffer to slice
nuint position = e->Position - sizeToSlice; // position of buffer to slice
nuint end = e->Position - ((nuint)m_Buffer); // end offset of buffer to slice
int i = GetBucketIndexOnce(sizeToSlice);
Entry* entry = (Entry*)_entries.Allocate();
SetEntryLevel(entry, position, remain);
entry->State = EntryState.Empty;
BucketNode* bucketNode = (BucketNode*)entry->Position;
bucketNode->EntryRef = entry;
PushNodeToBucket(i, bucketNode);
Entry* prev = next->PreviousNear;
prev->NextNear = entry;
entry->PreviousNear = prev;
entry->NextNear = next;
next->PreviousNear = entry;
}
/// <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 TryAllocateNewBlock(
nuint size,
out Entry* handle
)
{
nuint pos = _spareMemory->Position;
nuint remain = _spareMemory->Size;
if (remain <= 0)
{
handle = null;
return false;
}
size = nuint.Min(size, remain);
// build new entry
Entry* e = (Entry*)_entries.Allocate();
SetEntryLevel(e, pos, size);
InsertEntryBefore(e, _spareMemory);
e->State = EntryState.Empty;
// set fields of spare memory
_spareMemory->Size -= size;
_spareMemory->Position += size;
handle = e;
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>
private bool TryPopLevelForAllocation(
int levelIndex,
int sizeIndex,
out Entry* entry
)
{
if (TryPopLevel(levelIndex, sizeIndex, out BucketNode* bucketNode))
{
entry = bucketNode->EntryRef;
return entry != null;
}
entry = null;
return false;
}
}
}
StgSharp.Common/HighPerformance/Memory/old/HLSFAllocator.BucketNode.cs
-214
View File
@@ -1,214 +0,0 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="HLSFAllocator.BucketNode"
// Project: StgSharp
// AuthorGroup: Nitload
// 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
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using System;
using System.Reflection.Metadata;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace StgSharp.HighPerformance.Memory
{
public unsafe partial class HybridLayerSegregatedFitAllocator
{
/*
* All operations with style of (level, segment)
* DO NOT assume that the level are valid.
* They are just used to calculate the bucket index,
* which may exceed the range of _bucketHeads.
*/
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void PushBucketToLevel(
int levelIndex,
int sizeIndex,
BucketNode* node
)
{
if ((node == null) || (node->EntryRef == null)) {
return;
}
int index = Math.Min((3 * levelIndex) + sizeIndex, _bucketHeads.Length - 1);
PushNodeToBucket(index, node);
}
private void PushNodeToBucket(
int index,
BucketNode* node
)
{
index = Math.Min(index, _bucketHeads.Length - 1);
if (_bucketHeads[index] is null)
{
_bucketHeads[index] = node;
node->IsInBucket = true;
node->NextLevel = null;
node->PreviousLevel = null;
// Console.WriteLine($"Push to empty level of {levelIndex} {sizeIndex}, bucket pos {(ulong)node}");
return;
} else
{
BucketNode* head = _bucketHeads[index];
node->NextLevel = head;
node->IsInBucket = true;
_bucketHeads[index] = node;
// Console.WriteLine($"Push to head of level of {levelIndex} {sizeIndex}, bucket pos {(ulong)node}, previous head is at {head}");
head->PreviousLevel = node;
return;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void RemoveFromBucket(
int levelIndex,
int sizeIndex,
BucketNode* node
)
{
int index = Math.Min((3 * levelIndex) + sizeIndex, _bucketHeads.Length - 1);
if (_bucketHeads[index] == node)
{
if (TryPopBucket(index, out _)) {
return;
}
}
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;
}
private bool TryPopBucket(
int index,
out BucketNode* node
)
{
/*
* Attention:
* This method is UNSAFE. Index may exceed range of _bucketHeads.
* Be careful when calling this method.
*/
BucketNode* head = _bucketHeads[index];
if (head == null)
{
node = null;
return false;
}
// Console.WriteLine($"level popped from level {levelIndex} {sizeIndex}, node is at {(ulong)head}");
BucketNode* next = head->NextLevel;
if (next == null)
{
_bucketHeads[index] = null;
node = head;
return true;
} else
{
next->PreviousLevel = null;
}
_bucketHeads[index] = head->NextLevel;
node = head;
node->IsInBucket = false;
node->NextLevel = null;
return true;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private bool TryPopLevel(
int levelIndex,
int sizeIndex,
out BucketNode* node
)
{
int index = int.Min((3 * levelIndex) + sizeIndex, _bucketHeads.Length - 1);
return TryPopBucket(index, out node);
}
private bool TryRemoveFromBucket(
int levelIndex,
int sizeIndex,
BucketNode* node
)
{
int index = (3 * levelIndex) + sizeIndex;
index = (index >= _bucketHeads.Length) ? _bucketHeads.Length : index;
if (_bucketHeads[index] == node)
{
bool ok = TryPopLevel(levelIndex, sizeIndex, out _);
return ok;
}
BucketNode* previous = node->PreviousLevel;
BucketNode* next = node->NextLevel;
if (previous != null) {
previous->NextLevel = next;
}
if (next != null) {
next->PreviousLevel = previous;
}
node->NextLevel = null;
node->PreviousLevel = null;
node->IsInBucket = false;
node->EntryRef = null;
return true;
}
/// <summary>
/// BucketNode structure - specialized node for bucket linked lists Stored in main
/// allocation area (user-writable region)
/// </summary>
[StructLayout(LayoutKind.Explicit)]
internal struct BucketNode
{
[FieldOffset(0)] internal Entry* EntryRef; // Pointer to corresponding Entry
// [FieldOffset(16)] internal ulong LockBuffer;
[FieldOffset(8)] internal BucketNode* NextLevel; // Bucket stack linked list: next pointer
[FieldOffset(24)] internal BucketNode* PreviousLevel; // Bucket stack linked list: previous pointer
[FieldOffset(32)] internal bool IsInBucket; // Whether in bucket
}
}
}
StgSharp.Common/HighPerformance/Memory/old/HLSFAllocator.Debug.cs
-130
View File
@@ -1,130 +0,0 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="HLSFAllocator.Debug"
// Project: StgSharp
// AuthorGroup: Nitload
// 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
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.HighPerformance.Memory
{
public sealed class HLSFPositionChainBreakException : Exception
{
public HLSFPositionChainBreakException()
: base("Position chain of an HLSF allocator is broken") { }
}
public unsafe partial class HybridLayerSegregatedFitAllocator
{
private object _lock = new object();
public void DisplayEntryLayout(
bool singleStep
)
{
lock (_lock)
{
Entry* cur = _spareMemory;
while (cur != null)
{
Console.WriteLine(EntryToString(cur));
cur = cur->PreviousNear;
if (singleStep) {
Console.ReadKey();
}
}
}
}
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)
{
Stack<string> layout = [];
Entry* cur = _spareMemory;
while (cur != null)
{
layout.Push(EntryToString(cur));
cur = cur->PreviousNear;
}
return layout;
}
}
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/old/HLSFAllocator.Free.cs
-166
View File
@@ -1,166 +0,0 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="HLSFAllocator.Free"
// Project: StgSharp
// AuthorGroup: Nitload
// 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
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using System;
using System.Buffers;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Reflection.Emit;
using System.Reflection.Metadata;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using hlsfHandle = StgSharp.HighPerformance.Memory.HlsfHandle;
namespace StgSharp.HighPerformance.Memory
{
public enum FreePolicy
{
FullCollect,
LazyCollect,
NoCollect
}
public unsafe partial class HybridLayerSegregatedFitAllocator
{
/// <summary>
/// Minimal collect: linear scan, merge contiguous empty Blocks into one, push merged head
/// back to bucket. Caller-responsible design: no slicing or redistribution.
/// </summary>
public partial void Collect()
{
Entry* cur = _spareMemory->NextNear;
nuint size = 0;
while ((cur != null) && (cur != _spareMemory))
{
// cur is not empty, skip
if (cur->State != EntryState.Empty)
{
cur = cur->NextNear;
continue;
}
// remove cur from bucket
do
{
size += cur->Size;
Entry* next = cur->NextNear;
RemoveFromBucket(cur->Level, GetSegmentFromLevel(cur->Size, cur->Level), (BucketNode*)cur->Position);
RemoveFromPositionChain(cur);
cur = next;
} while ((cur != null) && (cur != _spareMemory) && (cur->State == EntryState.Empty));
if (size > 0)
{
OrganizeMemory(cur, size);
size = 0;
}
}
}
/// <summary>
/// Free allocated memory block and perform adjacent block merging
/// </summary>
/// <param name="handle">
/// Handle to the allocated memory block
/// <param name="collectPolicy">
/// </param>
public void Free(
HlsfHandle handle,
FreePolicy collectPolicy = FreePolicy.NoCollect
)
{
Entry* e = handle.EntryHandle;
if (e == null) {
return;
}
if (e->State != EntryState.Alloc) {
return;
}
// Mark as empty so it can be merged
e->State = EntryState.Empty;
// Try merge with adjacent free blocks and remove them from buckets
MergeAndRemoveFromBuckets(e);
// Calculate final level and segment for the merged block
nuint finalSize = e->Size;
(int finalLevel, int finalSegment) = GetIndexPairOnce(finalSize);
e->Level = finalLevel;
// Push the merged entry back to appropriate bucket
PushBucketToLevel(finalLevel, finalSegment, (BucketNode*)e->Position);
// Console.WriteLine("one block freed");
if (collectPolicy == FreePolicy.FullCollect)
{
Collect();
}
}
internal void Free(
Entry* e,
FreePolicy collectPolicy = FreePolicy.NoCollect
)
{
if (e == null) {
return;
}
if (e->State != EntryState.Alloc) {
return;
}
// Mark as empty so it can be merged
e->State = EntryState.Empty;
// Try merge with adjacent free blocks and remove them from buckets
/**/
MergeAndRemoveFromBuckets(e);
// Calculate final level and segment for the merged block
nuint finalSize = e->Size;
int finalLevel = GetLevelFromSize(finalSize);
e->Level = finalLevel;
int finalSegment = GetSegmentFromLevel(finalSize, finalLevel);
// Push the merged entry back to appropriate bucket
PushBucketToLevel(finalLevel, finalSegment, (BucketNode*)e->Position);
// Console.WriteLine("one block freed");
if (collectPolicy == FreePolicy.FullCollect)
{
Collect();
}
}
}
}
StgSharp.Common/HighPerformance/Memory/old/HLSFAllocator.Level.cs
-154
View File
@@ -1,154 +0,0 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="HLSFAllocator.Level"
// Project: StgSharp
// AuthorGroup: Nitload
// 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
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Security;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.HighPerformance.Memory
{
public unsafe partial class HybridLayerSegregatedFitAllocator
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private nuint GetAllocSize(
nuint size
)
{
return (size + 63u) & (~63u);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
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 Math.Min((level * 3) + segment, _bucketHeads.Length - 1);
}
[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);
}
/// <summary>
/// NOTICE: returned level may exceed maxLevel, caller is responsible for ensuring the
/// returned level is within bounds. This method is designed for performance and does not
/// perform bounds checking.
/// </summary>
/// <param name="size">
/// Size of the memory block to determine level for. This method does not assume size is
/// already aligned
/// </param>
/// <returns>
/// Level corresponding to the given size. Level is determined based on the formula: level
/// >= (log2(S) - 6) / 2
/// </returns>
[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 level;
}
[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;
}
}
}
StgSharp.Common/HighPerformance/Memory/old/HLSFAllocator.SegmentEntry.cs
-219
View File
@@ -1,219 +0,0 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="HLSFAllocator.SegmentEntry"
// Project: StgSharp
// AuthorGroup: Nitload
// 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
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace StgSharp.HighPerformance.Memory
{
public unsafe partial class HybridLayerSegregatedFitAllocator
{
/// <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* front,
Entry* back
)
{
// Only a predicate; never throw here. Callers rely on false to skip merging.
return front->Position + front->Size == back->Position;
}
[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
/// strategy.
/// </summary>
private void MergeAndRemoveFromBuckets(
Entry* entry,
int maxScanRange = 4
)
{
if (entry == null) {
return;
}
nuint size = entry->Size;
int originLevel = entry->Level;
int segment = GetSegmentFromLevel(size, originLevel);
for (int i = 0; i < maxScanRange; i++)
{
// previous direction merge
Entry* p = entry->PreviousNear;
if ((p == null) ||
(p == _spareMemory) ||
(p->State != EntryState.Empty) ||
(p->Level != entry->Level) ||
!AssertAdjacentTo(p, entry))
{
break;
}
// Console.WriteLine($"{(ulong)p->Size} merged to {(ulong)entry->Size} previous");
entry->Size += p->Size;
entry->Position = p->Position;
RemoveFromBucket(originLevel, GetSegmentFromLevel(p->Size, originLevel), (BucketNode*)p->Position);
RemoveFromPositionChain(p);
}
for (int i = 0; i < maxScanRange; i++)
{
// next direction merge
Entry* n = entry->NextNear;
if ((n == null) ||
(n == _spareMemory) ||
(n->State != EntryState.Empty) ||
(n->Level != entry->Level) ||
!AssertAdjacentTo(entry, n))
{
break;
}
// Console.WriteLine($"{(ulong)n->Size} merged to {(ulong)entry->Size} next");
entry->Size += n->Size;
RemoveFromBucket(originLevel, GetSegmentFromLevel(n->Size, originLevel), (BucketNode*)n->Position);
RemoveFromPositionChain(n);
}
// originLevel = int.Min(9, originLevel);
entry->Level = GetLevelFromSize(entry->Size);
BucketNode* bucket = (BucketNode*)entry->Position;
bucket->EntryRef = entry;
}
/// <summary>
/// Remove node from position linked list, this method does not recycle a BucketNode from
/// size bucket
/// </summary>
private void RemoveFromPositionChain(
Entry* entry
)
{
Entry* prev = entry->PreviousNear;
Entry* next = entry->NextNear;
prev->NextNear = next;
next->PreviousNear = prev;
// Clear node pointers
entry->NextNear = null;
entry->PreviousNear = null;
// Console.WriteLine("entry recycled.");
_entries.Free((nuint)entry);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void SetEntryLevel(
Entry* entry,
nuint position,
nuint 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
/// </summary>
[StructLayout(LayoutKind.Explicit, Size = 40)]
internal struct Entry
{
[FieldOffset(0)] internal Entry* NextNear; // Position linked list: next pointer
[FieldOffset(8)] internal Entry* PreviousNear; // Position linked list: previous pointer
[FieldOffset(32)] internal int Level; // Level of the block in the allocator
[FieldOffset(16)] internal nuint Size; // Block size information
[FieldOffset(36)] public EntryState State;
[FieldOffset(24)] public nuint Position; // Memory block position
}
[StructLayout(LayoutKind.Explicit, Size = 32)]
internal struct Metadata
{
[FieldOffset(0)] internal int NextLevel;
[FieldOffset(4)] internal int NextNear;
[FieldOffset(8)] internal int PreviousLevel;
[FieldOffset(12)] internal int PreviousNear;
[FieldOffset(16)] internal nuint Size;
}
internal enum EntryState : uint
{
Spare,
Empty,
Alloc,
Large
}
}
}
StgSharp.Common/HighPerformance/Memory/old/HLSFAllocator.cs
-163
View File
@@ -1,163 +0,0 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="HLSFAllocator"
// Project: StgSharp
// AuthorGroup: Nitload
// 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
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using System;
using System.Buffers;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
namespace StgSharp.HighPerformance.Memory
{
public unsafe partial class HybridLayerSegregatedFitAllocator : IDisposable
{
// Bucket system field - directly in main allocator class
private readonly BucketNode*[] _bucketHeads;
private Metadata* _metadata;
// _spareMemory is also the beginning position of allocator
private Entry* _spareMemory;
private readonly byte* m_Buffer;
private readonly Action<nuint> _freeHandle;
private bool disposedValue;
private readonly int _align;
private readonly int _maxAllocCount;
private readonly int _maxLevel;
private int unusedMetaData;
private readonly nuint _maxAllocSize;
private readonly nuint _size;
private Ptr64 _basePtr;
private readonly SlabAllocator<Entry> _entries;
internal HybridLayerSegregatedFitAllocator(
nuint byteSize,
int align,
nuint maxBlockSize,
Func<nuint, int, nuint> allocator,
Action<nuint> freeHandle,
SlabAllocator<Entry>? entryManager
)
: this(byteSize, align, maxBlockSize, (void*)allocator(byteSize, align), freeHandle,
entryManager) { }
internal HybridLayerSegregatedFitAllocator(
nuint byteSize,
int align,
nuint maxBlockSize,
void* externalPointer,
Action<nuint> freeHandle,
SlabAllocator<Entry>? entryManager = null
)
{
if ((align < 16) || ((align & (align - 1)) != 0)) {
throw new ArgumentException(
"Alignment must be a power of two and at least 16 bytes.");
}
_entries = entryManager ??
SlabAllocator.Create<Entry>(64, SlabBufferLayout.Chunked, false);
m_Buffer = (byte*)externalPointer;
_basePtr = (Ptr64)(nuint)externalPointer;
_metadata = (Metadata*)((nuint)externalPointer + byteSize);
_align = align;
_size = byteSize;
_spareMemory = (Entry*)_entries.Allocate();
_spareMemory->State = EntryState.Empty;
_spareMemory->PreviousNear = _spareMemory;
_spareMemory->NextNear = _spareMemory;
_spareMemory->Position = (nuint)m_Buffer;
_spareMemory->Size = byteSize;
_maxLevel = GetLevelFromSize(maxBlockSize) + 1;
_bucketHeads = new BucketNode*[(_maxLevel * 3) + 1];
_maxAllocSize = maxBlockSize;
_freeHandle = freeHandle ?? (static _ => { });
}
public HybridLayerSegregatedFitAllocator(
nuint byteSize
)
: this(byteSize, 16, 32U * 1024U * 1024U, NativeMemory.AlignedAlloc(byteSize, 16),
ptr => NativeMemory.AlignedFree((void*)ptr)) { }
public HybridLayerSegregatedFitAllocator(
nuint byteSize,
uint maxBlockSize
)
: this(byteSize, 16, maxBlockSize, NativeMemory.AlignedAlloc(byteSize, 16),
ptr => NativeMemory.AlignedFree((void*)ptr)) { }
public HybridLayerSegregatedFitAllocator(
nuint byteSize,
int align
)
: this(byteSize, align, 32U * 1024U * 1024U, NativeMemory.AlignedAlloc(byteSize, 16),
ptr => NativeMemory.AlignedFree((void*)ptr)) { }
public HybridLayerSegregatedFitAllocator(
nuint byteSize,
int align,
nuint maxBlockSize
)
: this(byteSize, align, maxBlockSize, NativeMemory.AlignedAlloc(byteSize, 16),
ptr => NativeMemory.AlignedFree((void*)ptr)) { }
public partial HlsfHandle Alloc(
nuint size
);
public partial void Collect();
public void Dispose()
{
Dispose(disposing:true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(
bool disposing
)
{
if (!disposedValue)
{
if (disposing) {
_entries.Dispose();
}
_freeHandle((nuint)m_Buffer);
disposedValue = true;
}
}
~HybridLayerSegregatedFitAllocator()
{
Dispose(disposing:false);
}
}
}