Misaki
3c555a9489
Changed the `ParallelNoiseBenchmark` class to use `AllocationOption.None` for `UnsafeArray<float>` instances. Changed the `AllocationOption` enum to replace `UnInitialized` with `None` and clarified the `UnTracked` option. Changed constructors for `UnsafeArray<T>`, `UnsafeList<T>`, `UnsafeQueue<T>`, and `UnsafeStack<T>` to use `AllocationOption.None`. Changed the `HashMapHelper<TKey>` constructor to accept an `AllocationOption` parameter for improved flexibility. Changed the `Allocate` method documentation in `Arena.cs` to clarify memory management. Improved the `AllocationManager` class with a default arena size and updated allocation logic to handle new `AllocationOption` flags. Removed the import statement for `BenchmarkDotNet.Running` in `Program.cs` and added new imports for `Misaki.HighPerformance.Unsafe.Collections` and `Misaki.HighPerformance.Unsafe.Services`. Added a new `UnsafeArray<int>` in `Program.cs` and called `AllocationManager.Dispose()` to clean up resources.
103 lines
2.2 KiB
C#
103 lines
2.2 KiB
C#
using Misaki.HighPerformance.Unsafe.Collections.Contracts;
|
|
using Misaki.HighPerformance.Unsafe.Helpers;
|
|
using System.Collections;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
namespace Misaki.HighPerformance.Unsafe.Collections;
|
|
|
|
public unsafe struct UnsafeStack<T> : IUnsafeCollection<T>
|
|
where T : unmanaged
|
|
{
|
|
private UnsafeArray<T> _array;
|
|
private int _count;
|
|
|
|
public readonly int Count => _count;
|
|
public readonly bool IsCreated => _array.IsCreated;
|
|
|
|
public IEnumerator<T> GetEnumerator()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return GetEnumerator();
|
|
}
|
|
|
|
public UnsafeStack(int initialSize, Allocator allocator, AllocationOption allocationOption = AllocationOption.None)
|
|
{
|
|
_array = new UnsafeArray<T>(initialSize, allocator, allocationOption);
|
|
}
|
|
|
|
public void Push(T value)
|
|
{
|
|
if (_count >= _array.Count)
|
|
{
|
|
Resize(_array.Count + (int)(_array.Count * 0.5f));
|
|
}
|
|
|
|
UnsafeUtilities.WriteArrayElement(_array.GetUnsafePtr(), _count, value);
|
|
_count++;
|
|
}
|
|
|
|
public T Pop()
|
|
{
|
|
if (_count == 0)
|
|
{
|
|
throw new InvalidOperationException("Stack is empty.");
|
|
}
|
|
|
|
_count--;
|
|
return _array[_count];
|
|
}
|
|
|
|
public bool TryPop(out T value)
|
|
{
|
|
if (_count == 0)
|
|
{
|
|
value = default;
|
|
return false;
|
|
}
|
|
|
|
_count--;
|
|
value = _array[_count];
|
|
return true;
|
|
}
|
|
|
|
public readonly T Peek()
|
|
{
|
|
if (_count == 0)
|
|
{
|
|
throw new InvalidOperationException("Stack is empty.");
|
|
}
|
|
|
|
return _array[_count - 1];
|
|
}
|
|
|
|
public void Resize(int newSize)
|
|
{
|
|
_array.Resize(newSize);
|
|
|
|
if (_count > newSize)
|
|
{
|
|
_count = newSize;
|
|
}
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
_array.Clear();
|
|
_count = 0;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public readonly void* GetUnsafePtr()
|
|
{
|
|
return _array.GetUnsafePtr();
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_array.Dispose();
|
|
_count = 0;
|
|
}
|
|
} |