370 lines
12 KiB
C#
370 lines
12 KiB
C#
//-----------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------
|
|
// file="TwoLayerSegregatedFitAllocator"
|
|
// 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 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;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using static StgSharp.HighPerformance.Memory.TwoLayerSegregatedFitAllocator;
|
|
|
|
namespace StgSharp.HighPerformance.Memory
|
|
{
|
|
public unsafe class TwoLayerSegregatedFitAllocator : IDisposable
|
|
{
|
|
|
|
private const ulong Mask48Bits = 0x0000FFFFFFFFFFFF;
|
|
|
|
private readonly int[] _bucket;
|
|
private readonly Metadata* _spareMemory;
|
|
private readonly Action<nuint> _freeHandle;
|
|
private bool disposedValue;
|
|
private readonly int _align;
|
|
|
|
private int _metadataEnd;
|
|
private readonly Ptr64 _basePtr;
|
|
private readonly ulong _maxAllocSize;
|
|
private readonly ulong _totalSize;
|
|
|
|
internal TwoLayerSegregatedFitAllocator(
|
|
nuint byteSize,
|
|
int align,
|
|
ulong maxBlockSize,
|
|
Func<nuint, int, nuint> allocator,
|
|
Action<nuint> freeHandle
|
|
)
|
|
: this(byteSize, align, maxBlockSize, (void*)allocator(byteSize, align), freeHandle) { }
|
|
|
|
internal TwoLayerSegregatedFitAllocator(
|
|
nuint byteSize,
|
|
int align,
|
|
ulong maxBlockSize,
|
|
void* externalPointer,
|
|
Action<nuint> freeHandle
|
|
)
|
|
{
|
|
_totalSize = byteSize;
|
|
_basePtr = (Ptr64)(ulong)externalPointer;
|
|
_align = align;
|
|
_maxAllocSize = ulong.Max(64, (~64UL) & (ulong.Min(maxBlockSize + 63, Mask48Bits)));
|
|
_bucket = new int[GetLevel(_maxAllocSize) + 1];
|
|
_spareMemory = &((Metadata*)(ulong)(_basePtr + _totalSize))[-1];
|
|
_freeHandle = freeHandle ?? (static_ => { });
|
|
_metadataEnd = 0;
|
|
|
|
// init spare memory node
|
|
|
|
_spareMemory->Position = 0UL;
|
|
_spareMemory->Size = _totalSize - Metadata.SizeOf;
|
|
_spareMemory->NextLevel = 0;
|
|
_spareMemory->NextNear = 0;
|
|
_spareMemory->PreviousLevel = 0;
|
|
_spareMemory->PreviousNear = 0;
|
|
}
|
|
|
|
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
|
|
)
|
|
: this(byteSize, 16, maxBlockSize, NativeMemory.AlignedAlloc(byteSize, 16),
|
|
ptr => NativeMemory.AlignedFree((void*)ptr)) { }
|
|
|
|
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
|
|
)
|
|
: this(byteSize, align, maxBlockSize, NativeMemory.AlignedAlloc(byteSize, 16),
|
|
ptr => NativeMemory.AlignedFree((void*)ptr)) { }
|
|
|
|
public Handle Alloc(
|
|
nuint size
|
|
)
|
|
{
|
|
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 = GetLevel(allocSize);
|
|
Metadata* entry = null;
|
|
for (int i = level; i < _bucket.Length; i++)
|
|
{
|
|
int idx = _bucket[i];
|
|
if (idx != 0)
|
|
{
|
|
entry = &_spareMemory[-idx];
|
|
_bucket[i] = entry->NextLevel;
|
|
break;
|
|
}
|
|
}
|
|
if (entry is null && !TryAllocNewChunk(allocSize, out entry)) {
|
|
throw new OverflowException("No available ");
|
|
}
|
|
int entryIdx = (int)(_spareMemory - entry);
|
|
ulong entrySize = entry->Size;
|
|
ulong remain = entrySize - allocSize;
|
|
|
|
// 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,
|
|
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
|
|
)
|
|
{
|
|
if (!disposedValue)
|
|
{
|
|
if (disposing) {
|
|
_freeHandle((nuint)_basePtr);
|
|
}
|
|
|
|
disposedValue = true;
|
|
}
|
|
}
|
|
|
|
[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)
|
|
{
|
|
meta = &_spareMemory[-idx];
|
|
_spareMemory->NextLevel = meta->NextLevel;
|
|
return true;
|
|
}
|
|
ulong spareSize = _spareMemory->Size;
|
|
if (spareSize < Metadata.SizeOf + size)
|
|
{
|
|
meta = null;
|
|
return false;
|
|
}
|
|
_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;
|
|
}
|
|
|
|
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
|
|
{
|
|
|
|
[FieldOffset(0)]internal readonly Metadata* _meta;
|
|
[FieldOffset(8)]public readonly void* Pointer;
|
|
[FieldOffset(16)]public readonly Ptr64 Size;
|
|
|
|
internal Handle(
|
|
Metadata* meta,
|
|
Ptr64 baseAddress
|
|
)
|
|
{
|
|
_meta = meta;
|
|
Pointer = (void*)(ulong)(meta->Position + baseAddress);
|
|
Size = meta->Size;
|
|
}
|
|
|
|
[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 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
|
|
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Explicit, Size = 32)]
|
|
internal struct Metadata
|
|
{
|
|
|
|
[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;
|
|
|
|
public Ptr64 Position
|
|
{
|
|
readonly get => PositionMask;
|
|
set => PositionMask = value;
|
|
}
|
|
|
|
public Ptr64 Size
|
|
{
|
|
readonly get => (Ptr64)(SizeMask & Mask48Bits);
|
|
set => SizeMask = (SizeMask & ~Mask48Bits) | ((ulong)value & Mask48Bits);
|
|
}
|
|
|
|
public Ptr64 SizeForSpare
|
|
{
|
|
readonly get => SizeMask;
|
|
set => SizeMask = value;
|
|
}
|
|
|
|
public static uint SizeOf { get; } = (uint)Unsafe.SizeOf<Metadata>();
|
|
|
|
}
|
|
|
|
}
|
|
}
|