Misaki
48f2dce778
Added a new configuration setting in `.editorconfig` to sort system directives last and increased the maximum line length to 400 characters. Added a new static class `MathUtilities` in `MathUtilities.cs` with a method `CeilPow2` for computing powers of two. Added a new benchmark class `CollectionBenchmark` in `CollectionBenchmark.cs` to measure performance of standard versus unsafe arrays. Added a new benchmark class `HashCodeBenchmark` in `HashCodeBenchmark.cs` to evaluate hash code generation performance. Added new utility methods in `UnsafeUtilities.cs` for memory allocation and deallocation, including `Malloc`, `AlignedAlloc`, `Realloc`, and `Free`. Added a new `AllocationType` enum in `AllocationType.cs` to specify memory allocation types. Changed the project file `Misaki.HighPerformance.Mathematics.csproj` to target .NET 9.0 and enable implicit usings and nullable reference types. Changed the `ParallelNoiseBenchmark` class in `ParallelNoiseBenchmark.cs` to improve memory allocation strategies and performance. Changed memory management in `Arena.cs` and `DynamicArena.cs` to use custom `Malloc` and `Free` functions. Changed the `IUnsafeCollection` interface in `IUnsafeCollection.cs` to include new methods for resizing collections and obtaining unsafe pointers. Changed the `UnsafeArray.cs` to improve management of unsafe arrays, including constructor and method updates. Changed the `UnsafeHashMap` and `UnsafeHashSet` classes to enhance performance and memory management. Changed the `UnsafeCollectionExtensions` class to provide additional methods for copying elements and converting collections. Changed the `ObjectPool` class in `ObjectPool.cs` to simplify cleanup and remove auto-cleanup functionality. Changed job scheduling and worker classes in `JobExtensions.cs` and `JobWorker.cs` to improve job scheduling in a thread pool. Removed commented-out code in `Program.cs` related to previous testing methods. Removed auto-cleanup functionality from the `ObjectPool` class.
81 lines
2.4 KiB
C#
81 lines
2.4 KiB
C#
using Misaki.HighPerformance.Unsafe.Collections;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace Misaki.HighPerformance.Unsafe.Buffer;
|
|
|
|
/// <summary>
|
|
/// A memory management structure that allocates and resets memory blocks with specified alignment.
|
|
/// </summary>
|
|
public unsafe struct Arena : IDisposable
|
|
{
|
|
private byte* _buffer;
|
|
private uint _size;
|
|
private uint _offset;
|
|
|
|
private bool _disposed;
|
|
|
|
public Arena(uint size)
|
|
{
|
|
_buffer = (byte*)Malloc(size);
|
|
_size = size;
|
|
_offset = 0;
|
|
}
|
|
|
|
/// <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.
|
|
/// Must use <see cref="NativeMemory.AlignedFree"/> to free the memory.
|
|
/// </summary>
|
|
/// <param name="size">Specifies the amount of memory to allocate in bytes.</param>
|
|
/// <param name="alignSize">Defines the alignment requirement for the allocated memory.</param>
|
|
/// <returns>A pointer to the allocated memory block or null if the allocation cannot be fulfilled.</returns>
|
|
/// <exception cref="ObjectDisposedException">Thrown if the arena has been disposed.</exception>
|
|
public void* Allocate(uint size, uint alignSize, AllocationType allocationType)
|
|
{
|
|
ObjectDisposedException.ThrowIf(_disposed, this);
|
|
|
|
var offset = (_offset + alignSize - 1) & ~(alignSize - 1);
|
|
if (offset + size > _size)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
_offset = offset + size;
|
|
var ptr = (byte*)_buffer + offset;
|
|
|
|
if (allocationType == AllocationType.Clear)
|
|
{
|
|
MemClear(ptr, size);
|
|
}
|
|
|
|
return ptr;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets the arena, optionally clearing the allocated memory.
|
|
/// </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>
|
|
public void Reset(bool clear = false)
|
|
{
|
|
ObjectDisposedException.ThrowIf(_disposed, this);
|
|
|
|
if (clear)
|
|
{
|
|
MemClear(_buffer, _size);
|
|
}
|
|
|
|
_offset = 0;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Free(_buffer);
|
|
|
|
_buffer = null;
|
|
_size = 0;
|
|
_offset = 0;
|
|
|
|
_disposed = true;
|
|
}
|
|
} |