Abort hlsf, goes back to tlsf, may use 'Arena-ed tlsf'
This commit is contained in:
Youmu Liu
@@ -0,0 +1,239 @@
|
||||
//-----------------------------------------------------------------------
|
||||
// -----------------------------------------------------------------------
|
||||
// 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;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user