Misaki/Misaki.HighPerformance
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(allocator): add VirtualArena and FreeList allocators

Browse Source 
Introduce VirtualArena for large, thread-safe virtual memory allocation and FreeList allocator for efficient persistent allocations. Update AllocationManager to support new allocators, add cross-platform virtual memory utilities, and improve thread-safety and performance in existing allocators. Bump version to 1.5.0 and update project configuration.

BREAKING CHANGE: AllocationManager initialization now requires explicit parameters for arena and FreeList capacities. Existing allocator usage may require code changes.
This commit is contained in:
Misaki
2026-03-18 19:26:16 +09:00
parent 9cee32aa83
commit 7326c83948
12 changed files with 425 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
Misaki.HighPerformance.LowLevel/Buffer/AllocationManager.cs
View File

@@ -1,7 +1,6 @@
using Misaki.HighPerformance.Collections;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace Misaki.HighPerformance.LowLevel.Buffer;
@@ -49,16 +48,16 @@ public static unsafe class AllocationManager
{
private const int _ARENA_MAGIC_ID = -3941029;
private DynamicArena _arena;
private AllocationHandle _handle;
private VirtualArena _arena;
private int _currentTick;
private AllocationHandle _handle;
public readonly AllocationHandle Handle => _handle;
public readonly int CurrentTick => _currentTick;
public void Init(uint initialSize)
public void Init(nuint capacity)
{
_arena = new DynamicArena(initialSize);
_arena = new VirtualArena(capacity);
_handle = new AllocationHandle
{
State = Unsafe.AsPointer(ref this),
@@ -67,6 +66,7 @@ public static unsafe class AllocationManager
Free = null,
IsValid = &IsValid
};
_currentTick = 0;
}
@@ -265,20 +265,94 @@ public static unsafe class AllocationManager
}
}
private const uint _DEFAULT_MEMORY_POOL_SIZE = 1024 * 1024; // 1 MB
private struct FreeListAllocator : IAllocator, IDisposable
{
private FreeList _freeList;
private AllocationHandle _handle;
private static readonly ArenaAllocator* s_pArenaAllocator;
private static readonly HeapAllocator* s_pHeapAllocator;
private static readonly StackAllocator* s_pStackAllocator;
public readonly AllocationHandle Handle => _handle;
private static bool s_disposed;
public void Init(int concurrencyLevel)
{
_freeList = new FreeList(8, 64 * 1024, concurrencyLevel);
_handle = new AllocationHandle
{
State = Unsafe.AsPointer(ref this),
Alloc = &Allocate,
Realloc = &Reallocate,
Free = &Free,
IsValid = &IsValid
};
}
private static void* Allocate(void* instance, nuint size, nuint alignment, AllocationOption allocationOption, MemoryHandle* pHandle)
{
var selfPtr = (FreeListAllocator*)instance;
var ptr = selfPtr->_freeList.Allocate(size, alignment, allocationOption);
if (ptr == null)
{
*pHandle = MemoryHandle.Invalid;
return null;
}
*pHandle = AddAllocation(ptr);
return ptr;
}
private static void* Reallocate(void* instance, void* ptr, nuint oldSize, nuint newSize, nuint alignment, AllocationOption allocationOption, MemoryHandle* pHandle)
{
if (ptr == null)
{
return Allocate(instance, newSize, alignment, allocationOption, pHandle);
}
var selfPtr = (FreeListAllocator*)instance;
var newPtr = selfPtr->_freeList.Allocate(newSize, alignment, allocationOption);
if (newPtr == null)
{
return null;
}
MemCpy(newPtr, ptr, Math.Min(oldSize, newSize));
selfPtr->_freeList.Free(ptr);
RemoveAllocation(*pHandle);
*pHandle = AddAllocation(newPtr);
return newPtr;
}
private static bool IsValid(void* instance, MemoryHandle handle)
{
return ContainsAllocation(handle);
}
private static void Free(void* instance, void* ptr, MemoryHandle handle)
{
var selfPtr = (FreeListAllocator*)instance;
selfPtr->_freeList.Free(ptr);
RemoveAllocation(handle);
}
public void Dispose()
{
_freeList.Dispose();
}
}
private static ArenaAllocator* s_pArenaAllocator;
private static HeapAllocator* s_pHeapAllocator;
private static StackAllocator* s_pStackAllocator;
private static FreeListAllocator* s_pFreeListAllocator;
private static bool s_initialized;
#if ENABLE_DEBUG_LAYER
private static SpinLock s_liveLock;
private static AllocationHeader* s_pLiveHead;
#endif
private static readonly ConcurrentSlotMap<IntPtr> s_allocations;
private static ConcurrentSlotMap<IntPtr> s_allocations = null!;
public static readonly MemoryHandle MagicHandle = new MemoryHandle(int.MinValue, int.MinValue);
@@ -287,14 +361,12 @@ public static unsafe class AllocationManager
/// </summary>
public static int LiveAllocationCount => s_allocations.Count;
static AllocationManager()
public static void Initialize(nuint arenaCapacity, int freeListConcurrencyLevel)
{
var allocatorTotalSize = (nuint)(sizeof(ArenaAllocator) + sizeof(HeapAllocator) + sizeof(StackAllocator));
var basePtr = Malloc(allocatorTotalSize);
s_pArenaAllocator = (ArenaAllocator*)basePtr;
s_pHeapAllocator = (HeapAllocator*)((byte*)basePtr + (nuint)sizeof(ArenaAllocator));
s_pStackAllocator = (StackAllocator*)((byte*)basePtr + (nuint)(sizeof(ArenaAllocator) + sizeof(HeapAllocator)));
if (s_initialized)
{
return;
}
#if ENABLE_DEBUG_LAYER
s_liveLock = new SpinLock(false);
@@ -303,9 +375,19 @@ public static unsafe class AllocationManager
s_allocations = new ConcurrentSlotMap<IntPtr>(256);
s_pArenaAllocator->Init(_DEFAULT_MEMORY_POOL_SIZE);
var ptr = (byte*)Malloc((nuint)(sizeof(ArenaAllocator) + sizeof(HeapAllocator) + sizeof(StackAllocator) + sizeof(FreeListAllocator)));
s_pArenaAllocator = (ArenaAllocator*)ptr;
s_pHeapAllocator = (HeapAllocator*)(ptr + sizeof(ArenaAllocator));
s_pStackAllocator = (StackAllocator*)(ptr + sizeof(ArenaAllocator) + sizeof(HeapAllocator));
s_pFreeListAllocator = (FreeListAllocator*)(ptr + sizeof(ArenaAllocator) + sizeof(HeapAllocator) + sizeof(StackAllocator));
s_pArenaAllocator->Init(arenaCapacity);
s_pHeapAllocator->Init();
s_pStackAllocator->Init();
s_pFreeListAllocator->Init(freeListConcurrencyLevel);
s_initialized = true;
}
#if ENABLE_DEBUG_LAYER
@@ -472,10 +554,13 @@ public static unsafe class AllocationManager
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static AllocationHandle GetAllocationHandle(Allocator allocator)
{
Debug.Assert(s_initialized, "AllocationManager is not initialized.");
return allocator switch
{
Allocator.Temp => s_pArenaAllocator->Handle,
Allocator.Persistent => s_pHeapAllocator->Handle,
Allocator.FreeList => s_pFreeListAllocator->Handle,
_ => throw new ArgumentException("Target allocator type does not support custom allocation.", nameof(allocator)),
};
}
@@ -491,6 +576,8 @@ public static unsafe class AllocationManager
/// <exception cref="OutOfMemoryException">Thrown if the allocation fails.</exception>
public static void* HeapAlloc(nuint size, nuint alignment, AllocationOption allocationOption, MemoryHandle* pHandle)
{
Debug.Assert(s_initialized, "AllocationManager is not initialized.");
#if ENABLE_DEBUG_LAYER
var ptr = DebugAllocate(size, alignment);
#else
@@ -508,7 +595,7 @@ public static unsafe class AllocationManager
MemClear(ptr, size);
}
*pHandle = AddAllocation((IntPtr)ptr);
*pHandle = AddAllocation(ptr);
return ptr;
}
@@ -520,6 +607,8 @@ public static unsafe class AllocationManager
/// <param name="handle">The handle representing the memory allocation to free. The handle must be valid and previously allocated.</param>
public static void HeapFree(void* ptr, MemoryHandle handle)
{
Debug.Assert(s_initialized, "AllocationManager is not initialized.");
#if ENABLE_DEBUG_LAYER
if (handle != MagicHandle)
{
@@ -540,6 +629,8 @@ public static unsafe class AllocationManager
/// <param name="handle">The handle representing the memory allocation to free. The handle must be valid and previously allocated.</param>
public static void HeapFree(MemoryHandle handle)
{
Debug.Assert(s_initialized, "AllocationManager is not initialized.");
if (TryGetAllocation(handle, out var ptr))
{
HeapFree((void*)ptr, handle);
@@ -552,6 +643,7 @@ public static unsafe class AllocationManager
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void ResetTempAllocator()
{
Debug.Assert(s_initialized, "AllocationManager is not initialized.");
s_pArenaAllocator->Reset();
}
@@ -562,6 +654,7 @@ public static unsafe class AllocationManager
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Stack.Scope CreateStackScope()
{
Debug.Assert(s_initialized, "AllocationManager is not initialized.");
return StackAllocator.CreateScope(s_pStackAllocator);
}
@@ -571,9 +664,11 @@ public static unsafe class AllocationManager
/// <param name="ptr">A pointer to the memory block to be registered. The pointer must reference a valid, allocated memory region.</param>
/// <returns>A MemoryHandle representing the registered allocation.</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MemoryHandle AddAllocation(IntPtr ptr)
public static MemoryHandle AddAllocation(void* ptr)
{
var id = s_allocations.Add(ptr, out var generation);
Debug.Assert(s_initialized, "AllocationManager is not initialized.");
var id = s_allocations.Add((nint)ptr, out var generation);
return new MemoryHandle(id, generation);
}
@@ -585,6 +680,7 @@ public static unsafe class AllocationManager
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool RemoveAllocation(MemoryHandle handle)
{
Debug.Assert(s_initialized, "AllocationManager is not initialized.");
return s_allocations.Remove(handle.id, handle.generation);
}
@@ -597,6 +693,7 @@ public static unsafe class AllocationManager
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool TryGetAllocation(MemoryHandle handle, out IntPtr ptr)
{
Debug.Assert(s_initialized, "AllocationManager is not initialized.");
return s_allocations.TryGetElement(handle.id, handle.generation, out ptr);
}
@@ -612,6 +709,8 @@ public static unsafe class AllocationManager
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool ContainsAllocation(MemoryHandle handle)
{
Debug.Assert(s_initialized, "AllocationManager is not initialized.");
if (handle == MagicHandle)
{
return true;
@@ -625,7 +724,7 @@ public static unsafe class AllocationManager
/// </summary>
public static void Dispose()
{
if (s_disposed)
if (!s_initialized)
{
return;
}
@@ -678,15 +777,12 @@ public static unsafe class AllocationManager
}
#endif
// NOTE: Arena allocator holds the base ptr for all allocators, heap and stack allocators do not own any memory themselves.
if (s_pArenaAllocator != null)
{
s_pArenaAllocator->Dispose();
s_pStackAllocator->Dispose();
s_pArenaAllocator->Dispose();
s_pStackAllocator->Dispose();
s_pFreeListAllocator->Dispose();
NativeMemory.Free(s_pArenaAllocator);
}
Free(s_pArenaAllocator);
s_disposed = true;
s_initialized = false;
}
}

4
Misaki.HighPerformance.LowLevel/Buffer/AllocationOption.cs
View File

@@ -25,4 +25,8 @@ public enum Allocator : byte
/// Allocator for persistent allocations. Allocations are not automatically released after use.
/// </summary>
Persistent,
/// <summary>
/// Allocator for persistent allocations using a free list. Allocations are not automatically released after use, but can be reused to reduce fragmentation and improve performance.
/// </summary>
FreeList
}

18
Misaki.HighPerformance.LowLevel/Buffer/Arena.cs
View File

@@ -1,3 +1,4 @@
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace Misaki.HighPerformance.LowLevel.Buffer;
@@ -30,10 +31,11 @@ public unsafe struct Arena : IDisposable
}
/// <summary>
/// Allocates a block of memory of a specified size with a given alignment. Returns a pointer to the allocated
/// memory or null if allocation fails.
/// You don't need to free the memory manually, it will be freed when the arena is disposed.
/// Allocates a block of memory of a specified size with a given alignment.
/// </summary>
/// <remarks>
/// This is thread safe.
/// </remarks>
/// <param name="size">Specifies the amount of memory to allocate in bytes.</param>
/// <param name="alignment">Defines the alignment requirement for the allocated memory.</param>
/// <param name="allocationOption">The option when allocating memory.</param>
@@ -81,17 +83,11 @@ public unsafe struct Arena : IDisposable
}
/// <summary>
/// Resets the arena, optionally clearing the allocated memory.
/// Resets the arena.
/// </summary>
/// <param name="clear">If true, the allocated memory will be cleared; otherwise, it will not be cleared.</param>
/// <exception cref="ObjectDisposedException">Thrown if the arena has been disposed.</exception>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Reset()
{
if (_buffer == null)
{
throw new ObjectDisposedException(nameof(DynamicArena));
}
_offset = 0;
}

10
Misaki.HighPerformance.LowLevel/Buffer/DynamicArena.cs
View File

@@ -3,8 +3,7 @@ using System.Runtime.InteropServices;
namespace Misaki.HighPerformance.LowLevel.Buffer;
/// <summary>
/// A dynamic memory management structure that automatically grows by creating linked arenas
/// when more space is needed.
/// A dynamic memory management structure that automatically grows by creating linked arenas when more space is needed.
/// </summary>
[StructLayout(LayoutKind.Explicit, Size = 128)]
public unsafe struct DynamicArena : IDisposable
@@ -97,6 +96,9 @@ public unsafe struct DynamicArena : IDisposable
/// <summary>
/// Allocates a block of memory with specified size and alignment. Creates a new arena if current one is full.
/// </summary>
/// <remarks>
/// This is thread safe.
/// </remarks>
/// <param name="size">Size of the memory block to allocate in bytes.</param>
/// <param name="alignment">Alignment requirement for the memory block.</param>
/// <returns>Pointer to the allocated memory block.</returns>
@@ -132,10 +134,8 @@ public unsafe struct DynamicArena : IDisposable
}
/// <summary>
/// Resets all arenas in the chain, optionally clearing their memory.
/// Resets all arenas in the chain.
/// </summary>
/// <param name="clear">If true, memory will be cleared during reset.</param>
/// <exception cref="ObjectDisposedException">Thrown if the arena has been disposed.</exception>
public void Reset()
{
var current = _root;

23
Misaki.HighPerformance.LowLevel/Buffer/FreeList.cs
View File

@@ -4,8 +4,7 @@ using System.Runtime.InteropServices;
namespace Misaki.HighPerformance.LowLevel.Buffer;
/// <summary>
/// A thread-safe variable-size allocator that uses per-thread caches for the hot path and
/// a remote-free queue for cross-thread deallocation.
/// A variable-size allocator that uses per-thread caches for the hot path and a remote-free queue for cross-thread deallocation.
/// </summary>
[StructLayout(LayoutKind.Sequential)]
public unsafe struct FreeList : IDisposable
@@ -94,11 +93,6 @@ public unsafe struct FreeList : IDisposable
/// </summary>
public readonly nuint Alignment => _alignment;
/// <summary>
/// Gets whether the allocator has been disposed.
/// </summary>
public readonly bool IsDisposed => _disposed != 0;
/// <summary>
/// Gets the chunk size used by this allocator.
/// </summary>
@@ -208,7 +202,7 @@ public unsafe struct FreeList : IDisposable
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private readonly int FindBucket(nuint size)
private static int FindBucket(nuint size)
{
var blockSize = _MIN_BLOCK_SIZE;
for (var i = 0; i < _MAX_BUCKETS; i++)
@@ -240,7 +234,7 @@ public unsafe struct FreeList : IDisposable
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void DrainRemoteFrees(ThreadCache* cache)
private readonly void DrainRemoteFrees(ThreadCache* cache)
{
var head = (FreeNode*)Interlocked.Exchange(ref cache->remoteFreeHead, 0);
while (head != null)
@@ -320,7 +314,7 @@ public unsafe struct FreeList : IDisposable
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void* TryPopFromBucket(ThreadCache* cache, int cacheIndex, int bucketIndex)
private readonly void* TryPopFromBucket(ThreadCache* cache, int cacheIndex, int bucketIndex)
{
var buckets = GetBuckets(cache);
var bucket = &buckets[bucketIndex];
@@ -338,7 +332,7 @@ public unsafe struct FreeList : IDisposable
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void PushToBucket(ThreadCache* cache, int bucketIndex, void* ptr, MemoryChunk* ownerChunk, nuint blockSize)
private readonly void PushToBucket(ThreadCache* cache, int bucketIndex, void* ptr, MemoryChunk* ownerChunk, nuint blockSize)
{
var buckets = GetBuckets(cache);
var bucket = &buckets[bucketIndex];
@@ -490,6 +484,9 @@ public unsafe struct FreeList : IDisposable
/// <summary>
/// Allocates a memory block of the specified size.
/// </summary>
/// <remarks>
/// This is thread safe.
/// </remarks>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void* Allocate(nuint size, nuint alignment, AllocationOption allocationOption = AllocationOption.None)
{
@@ -548,6 +545,7 @@ public unsafe struct FreeList : IDisposable
{
ptr = AllocateFromChunk(cacheIndex, totalSize, alignment);
}
if (ptr == null)
{
return null;
@@ -576,6 +574,9 @@ public unsafe struct FreeList : IDisposable
/// <summary>
/// Frees a previously allocated memory block.
/// </summary>
/// <remarks>
/// This is thread safe.
/// </remarks>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Free(void* ptr)
{

5
Misaki.HighPerformance.LowLevel/Buffer/Stack.cs
View File

@@ -221,6 +221,11 @@ public unsafe partial struct Stack : IDisposable
public void Dispose()
{
if (_buffer == null)
{
return;
}
Free(_buffer);
_buffer = null;

119
Misaki.HighPerformance.LowLevel/Buffer/VirtualArena.cs Normal file
View File

@@ -0,0 +1,119 @@
using Misaki.HighPerformance.LowLevel.Utilities;
using System.Runtime.CompilerServices;
namespace Misaki.HighPerformance.LowLevel.Buffer;
/// <summary>
/// A thread-safe memory management structure that reserves a large virtual address space and commits physical memory on demand as allocations are made.
/// </summary>
public unsafe struct VirtualArena
{
private const nuint _PAGE_SIZE = 64 * 1024;
private byte* _baseAddress;
private nuint _reserveCapacity;
private nuint _committedSize;
private nuint _allocatedOffset;
private volatile int _allocationLock;
public VirtualArena(nuint reserveCapacity)
{
_reserveCapacity = (reserveCapacity + _PAGE_SIZE - 1) & ~(_PAGE_SIZE - 1);
_committedSize = 0;
_allocatedOffset = 0;
_baseAddress = (byte*)Mmap(null, _reserveCapacity, VirtualAllocationFlags.Reserve);
if (_baseAddress == null)
{
throw new OutOfMemoryException("Failed to reserve virtual address space.");
}
}
/// <summary>
/// Allocates a block of memory of the specified size and alignment, using the given allocation options.
/// </summary>
/// <remarks>
/// This is thread safe.
/// </remarks>
/// <param name="size">The number of bytes to allocate. Must be greater than zero and less than or equal to the reserved capacity.</param>
/// <param name="alignment">The alignment, in bytes, for the allocated memory block. Must be a power of two.</param>
/// <param name="allocationOption">The allocation options that control allocation behavior.</param>
/// <returns>A pointer to the allocated memory block if the allocation succeeds, otherwise null.</returns>
public void* Allocate(nuint size, nuint alignment, AllocationOption allocationOption)
{
while (Interlocked.CompareExchange(ref _allocationLock, 1, 0) != 0)
{
Thread.SpinWait(1);
}
void* ptr;
try
{
// Align the requested offset
var alignedOffset = (_allocatedOffset + alignment - 1) & ~(alignment - 1);
var newAllocatedOffset = alignedOffset + size;
if (newAllocatedOffset > _reserveCapacity)
{
return null; // Out of reserved space
}
if (newAllocatedOffset > _committedSize)
{
var sizeToCommit = newAllocatedOffset - _committedSize;
// Align the commit size to the 64KB OS Page Size
sizeToCommit = (sizeToCommit + _PAGE_SIZE - 1) & ~(_PAGE_SIZE - 1);
var commitAddress = _baseAddress + _committedSize;
var result = Mmap(commitAddress, sizeToCommit, VirtualAllocationFlags.Commit);
if (result == null)
{
return null; // Out of physical RAM
}
_committedSize += sizeToCommit;
}
ptr = _baseAddress + alignedOffset;
_allocatedOffset = newAllocatedOffset;
}
finally
{
Interlocked.Exchange(ref _allocationLock, 0);
}
if (allocationOption.HasFlag(AllocationOption.Clear))
{
MemClear(ptr, size);
}
return ptr;
}
/// <summary>
/// Resets the arena.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Reset()
{
_allocatedOffset = 0;
}
public void Dispose()
{
if (_baseAddress != null)
{
Munmap(_baseAddress, _reserveCapacity);
_baseAddress = null;
_reserveCapacity = 0;
_committedSize = 0;
_allocatedOffset = 0;
}
}
}

9
Misaki.HighPerformance.LowLevel/Collections/UnsafeList.cs
View File

@@ -206,11 +206,15 @@ public unsafe struct UnsafeList<T> : IUnsafeCollection<T>
{
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[Conditional("ENABLE_COLLECTION_CHECKS")]
private readonly void CheckNoResizeCapacity(int count)
{
CheckNoResizeCapacity(count, Count);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[Conditional("ENABLE_COLLECTION_CHECKS")]
private readonly void CheckNoResizeCapacity(int index, int count)
{
if (index + count > Capacity)
@@ -242,16 +246,19 @@ public unsafe struct UnsafeList<T> : IUnsafeCollection<T>
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Enumerator GetEnumerator()
{
return new((UnsafeList<T>*)UnsafeUtility.AddressOf(ref this));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return GetEnumerator();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
@@ -266,6 +273,7 @@ public unsafe struct UnsafeList<T> : IUnsafeCollection<T>
/// Otherwise the parallel reader will be invalid after the stack frame that creates the list is popped, even if the list's internal array is still valid.
/// </remarks>
/// <returns>A <see cref="ParallelReader"/> instance that can be used to read items from the list in a thread-safe manner.</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ParallelReader AsParallelReader()
{
return new((UnsafeList<T>*)UnsafeUtility.AddressOf(ref this));
@@ -280,6 +288,7 @@ public unsafe struct UnsafeList<T> : IUnsafeCollection<T>
/// Otherwise the parallel writer will be invalid after the stack frame that creates the list is popped, even if the list's internal array is still valid.
/// </remarks>
/// <returns>A <see cref="ParallelWriter"/> instance that can be used to add items to the list in a thread-safe manner.</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ParallelWriter AsParallelWriter()
{
return new((UnsafeList<T>*)UnsafeUtility.AddressOf(ref this));

3
Misaki.HighPerformance.LowLevel/Misaki.HighPerformance.LowLevel.csproj
View File

@@ -7,7 +7,7 @@
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
<Authors>Misaki</Authors>
<AssemblyVersion>1.4.5</AssemblyVersion>
<AssemblyVersion>1.5.0</AssemblyVersion>
<Version>$(AssemblyVersion)</Version>
<PackageProjectUrl>https://git.personalnas.com/Misaki/Misaki.HighPerformance.git</PackageProjectUrl>
<RepositoryUrl>https://git.personalnas.com/Misaki/Misaki.HighPerformance.git</RepositoryUrl>
@@ -17,7 +17,6 @@
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<IsAotCompatible>True</IsAotCompatible>
<DefineConstants>$(DefineConstants);ENABLE_COLLECTION_CHECKS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">

118
Misaki.HighPerformance.LowLevel/Utilities/MemoryUtility.cs
View File

@@ -1,10 +1,55 @@
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
namespace Misaki.HighPerformance.LowLevel.Utilities;
[Flags]
public enum VirtualAllocationFlags
{
Reserve = 1 << 0,
Commit = 1 << 1,
}
public static unsafe partial class MemoryUtility
{
private const uint _MEM_COMMIT = 0x00001000;
private const uint _MEM_RESERVE = 0x00002000;
private const uint _MEM_RELEASE = 0x00008000;
private const uint _PAGE_READWRITE = 0x04;
[SupportedOSPlatform("windows")]
[DllImport("kernel32.dll")]
private static extern void* VirtualAlloc(void* lpAddress, nuint dwSize, uint flAllocationType, uint flProtect);
[SupportedOSPlatform("windows")]
[DllImport("kernel32.dll")]
private static extern int VirtualFree(void* lpAddress, nuint dwSize, uint dwFreeType);
private const int _PROT_NONE = 0x0;
private const int _PROT_READ = 0x1;
private const int _PROT_WRITE = 0x2;
private const int _MAP_PRIVATE = 0x02;
// Note: MAP_ANONYMOUS varies by OS. Linux is 0x20, macOS is 0x1000.
private static int GetMapAnonymousFlag() => RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? 0x1000 : 0x20;
[SupportedOSPlatform("linux")]
[SupportedOSPlatform("macos")]
[DllImport("libc")]
private static extern void* mmap(void* addr, nuint length, int prot, int flags, int fd, nint offset);
[SupportedOSPlatform("linux")]
[SupportedOSPlatform("macos")]
[DllImport("libc")]
private static extern int munmap(void* addr, nuint length);
[SupportedOSPlatform("linux")]
[SupportedOSPlatform("macos")]
[DllImport("libc")]
private static extern int mprotect(void* addr, nuint len, int prot);
[StructLayout(LayoutKind.Sequential)]
private struct AlignOfHelper<T>
where T : struct
@@ -224,6 +269,79 @@ public static unsafe partial class MemoryUtility
return span1.SequenceCompareTo(span2);
}
public static void* Mmap(void* addr, nuint size, VirtualAllocationFlags flags)
{
if (OperatingSystem.IsWindows())
{
var allocFlags = 0u;
var protect = _PAGE_READWRITE;
if (flags.HasFlag(VirtualAllocationFlags.Reserve))
{
allocFlags |= _MEM_RESERVE;
}
if (flags.HasFlag(VirtualAllocationFlags.Commit))
{
allocFlags |= _MEM_COMMIT;
}
var ptr = VirtualAlloc(addr, size, allocFlags, protect);
if (ptr == null)
{
throw new OutOfMemoryException("Failed to allocate memory using MMap.");
}
return ptr;
}
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
{
if (flags == VirtualAllocationFlags.Commit)
{
// POSIX commit changes protection of already-reserved memory
if (mprotect(addr, size, _PROT_READ | _PROT_WRITE) == -1)
{
throw new OutOfMemoryException("Failed to commit physical RAM via mprotect.");
}
return addr;
}
// Reserve or Reserve|Commit creates a new mapping
var prot = flags.HasFlag(VirtualAllocationFlags.Commit) ? _PROT_READ | _PROT_WRITE : _PROT_NONE;
var ptr = mmap(addr, size, prot, _MAP_PRIVATE | GetMapAnonymousFlag(), -1, 0);
if (ptr == (void*)-1)
{
throw new OutOfMemoryException("Failed to allocate memory using MMap.");
}
return ptr;
}
throw new PlatformNotSupportedException("Mmap is not supported on this platform.");
}
public static bool Munmap(void* ptr, nuint size)
{
if (ptr == null)
{
return false;
}
if (OperatingSystem.IsWindows())
{
return VirtualFree(ptr, 0, _MEM_RELEASE) != 0;
}
else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
{
return munmap(ptr, size) == 0;
}
throw new PlatformNotSupportedException("Munmap is not supported on this platform.");
}
/// <summary>
/// Calculates the size in bytes of a specified unmanaged type.
/// </summary>

6
Misaki.HighPerformance.Test/Misaki.HighPerformance.Test.csproj
View File

@@ -9,10 +9,12 @@
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DefineConstants>$(DefineConstants);ENABLE_COLLECTION_CHECKS</DefineConstants>
<DefineConstants>$(DefineConstants);ENABLE_COLLECTION_CHECKS;PLATFORM_WINDOWS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DefineConstants>$(DefineConstants);PLATFORM_WINDOWS</DefineConstants>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="BenchmarkDotNet" Version="0.15.8" />

16
Misaki.HighPerformance.Test/Program.cs
View File

@@ -1,4 +1,5 @@
using BenchmarkDotNet.Running;
using Misaki.HighPerformance.LowLevel.Buffer;
using Misaki.HighPerformance.LowLevel.Collections;
using Misaki.HighPerformance.LowLevel.Utilities;
using Misaki.HighPerformance.Mathematics.SPMD;
@@ -10,7 +11,7 @@ using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;
BenchmarkRunner.Run<SPMDBenchmark>();
//BenchmarkRunner.Run<SPMDBenchmark>();
//var hashMap = new UnsafeHashMap<int, int>(10, Misaki.HighPerformance.LowLevel.Buffer.Allocator.Persistent);
//hashMap[0] = 5;
//hashMap[1] = 6;
@@ -39,4 +40,15 @@ BenchmarkRunner.Run<SPMDBenchmark>();
// return ref Unsafe.NullRef<int>();
// }
//}
//}
AllocationManager.Initialize(1024 * 1024 * 1024, 1);
// Should be undefined or throw exception because AllocationManager does not initialized.
var arr = new UnsafeArray<int>(1000, Allocator.FreeList);
for (int i = 0; i < arr.Length; i++)
{
Console.WriteLine(arr[i]);
}
arr.Dispose();
AllocationManager.Dispose();