297 lines
9.9 KiB
C#
297 lines
9.9 KiB
C#
//-----------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------
|
|
// file="ConcurrentBufferStack.cs"
|
|
// Project: StgSharp
|
|
// AuthorGroup: Nitload Space
|
|
// Copyright (c) Nitload Space. 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.Threading;
|
|
|
|
using System;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
|
|
namespace StgSharp.HighPerformance.Memory
|
|
{
|
|
public static class BufferStackBuilder
|
|
{
|
|
|
|
// For BufferStack collection builder
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static BufferStack<T> Create<T>(ReadOnlySpan<T> span) where T: unmanaged
|
|
{
|
|
if (span.IsEmpty)
|
|
{
|
|
return new BufferStack<T>(4); // Default small capacity
|
|
}
|
|
|
|
BufferStack<T> stack = new BufferStack<T>(span.Length);
|
|
|
|
|
|
// Use internal method for efficient bulk initialization
|
|
stack.InitializeFromSpan(span);
|
|
|
|
return stack;
|
|
}
|
|
|
|
// For ConcurrentBufferStack collection builder
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static ConcurrentBufferStack<T> CreateConcurrent<T>(ReadOnlySpan<T> span) where T: unmanaged
|
|
{
|
|
if (span.IsEmpty)
|
|
{
|
|
return new ConcurrentBufferStack<T>(4); // Default small capacity
|
|
}
|
|
|
|
ConcurrentBufferStack<T> stack = new ConcurrentBufferStack<T>(span.Length);
|
|
|
|
|
|
// Use internal method for efficient bulk initialization
|
|
stack.InitializeFromSpan(span);
|
|
|
|
return stack;
|
|
}
|
|
|
|
}
|
|
|
|
[CollectionBuilder(builderType: typeof(BufferStackBuilder), methodName: nameof(BufferStackBuilder.CreateConcurrent))]
|
|
public unsafe class ConcurrentBufferStack<T> : IDisposable where T: unmanaged
|
|
{
|
|
|
|
private byte* _buffer;
|
|
private readonly BufferExpansionLock _lock = new();
|
|
private ulong _count;
|
|
|
|
public ConcurrentBufferStack()
|
|
{
|
|
AllocateBuffer(4);
|
|
}
|
|
|
|
public ConcurrentBufferStack(int capacity)
|
|
{
|
|
if (capacity <= 0) {
|
|
throw new ArgumentOutOfRangeException(nameof(capacity));
|
|
}
|
|
|
|
AllocateBuffer(capacity);
|
|
}
|
|
|
|
public ulong Count
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get => Volatile.Read(ref _count);
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
Header* header = (Header*)_buffer;
|
|
_lock.EnterExpansionProcess();
|
|
try
|
|
{
|
|
header->Top = 0;
|
|
Volatile.Write(ref _count, 0);
|
|
}
|
|
finally
|
|
{
|
|
_lock.ExitExpansionProcess();
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_lock.Dispose();
|
|
Marshal.FreeHGlobal((nint)_buffer);
|
|
}
|
|
|
|
public T Pop()
|
|
{
|
|
Header* header = (Header*)_buffer;
|
|
while (true)
|
|
{
|
|
nuint oldTop = Volatile.Read(ref header->Top);
|
|
if (oldTop <= 0) {
|
|
throw new InvalidOperationException("Stack underflow");
|
|
}
|
|
|
|
if (Interlocked.CompareExchange(ref header->Top, oldTop - 1, oldTop) == oldTop)
|
|
{
|
|
_lock.EnterBufferRead();
|
|
try
|
|
{
|
|
T* dataStart = (T*)(_buffer + sizeof(Header));
|
|
_ = Interlocked.Decrement(ref _count);
|
|
return dataStart[oldTop - 1];
|
|
}
|
|
finally
|
|
{
|
|
_lock.ExitBufferRead();
|
|
}
|
|
}
|
|
Thread.Sleep(0); // Yield to avoid busy waiting
|
|
}
|
|
}
|
|
|
|
public void Push(T item)
|
|
{
|
|
while (true)
|
|
{
|
|
_lock.EnterMetaDataRead();
|
|
try
|
|
{
|
|
Header* header = (Header*)_buffer;
|
|
nuint oldTop = Volatile.Read(ref header->Top);
|
|
nuint cap = Volatile.Read(ref header->Capacity);
|
|
if (oldTop >= cap)
|
|
{
|
|
_lock.ExitMetaDataRead();
|
|
_lock.EnterExpansionProcess();
|
|
try
|
|
{
|
|
header = (Header*)_buffer;
|
|
if (header->Top >= header->Capacity)
|
|
{
|
|
nuint newCap = header->Capacity * 2;
|
|
nuint newSize = (nuint)sizeof(Header) + (newCap * (nuint)sizeof(T));
|
|
|
|
_lock.EnterBufferCopy();
|
|
try
|
|
{
|
|
_buffer = (byte*)NativeMemory.Realloc(_buffer, newSize);
|
|
((Header*)_buffer)->Capacity = newCap;
|
|
}
|
|
finally
|
|
{
|
|
_lock.ExitBufferCopy();
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_lock.ExitExpansionProcess();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (Interlocked.CompareExchange(ref header->Top, oldTop + 1, oldTop) == oldTop)
|
|
{
|
|
_lock.EnterBufferRead();
|
|
try
|
|
{
|
|
T* dataStart = (T*)(_buffer + sizeof(Header));
|
|
dataStart[oldTop] = item;
|
|
_ = Interlocked.Increment(ref _count);
|
|
return;
|
|
}
|
|
finally
|
|
{
|
|
_lock.ExitBufferRead();
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (_lock.IsThreadReadingMetaData) {
|
|
_lock.ExitMetaDataRead();
|
|
}
|
|
}
|
|
Thread.Sleep(0); // Yield to avoid busy waiting
|
|
}
|
|
}
|
|
|
|
public bool TryPop(out T value)
|
|
{
|
|
Header* header = (Header*)_buffer;
|
|
while (true)
|
|
{
|
|
nuint oldTop = Volatile.Read(ref header->Top);
|
|
if (oldTop <= 0)
|
|
{
|
|
value = default;
|
|
return false;
|
|
}
|
|
|
|
if (Interlocked.CompareExchange(ref header->Top, oldTop - 1, oldTop) == oldTop)
|
|
{
|
|
_lock.EnterBufferRead();
|
|
try
|
|
{
|
|
T* dataStart = (T*)(_buffer + sizeof(Header));
|
|
value = dataStart[oldTop - 1];
|
|
_ = Interlocked.Decrement(ref _count);
|
|
}
|
|
finally
|
|
{
|
|
_lock.ExitBufferRead();
|
|
}
|
|
return true;
|
|
}
|
|
Thread.Sleep(0); // Yield to avoid busy waiting
|
|
}
|
|
}
|
|
|
|
// Internal method for efficient bulk initialization
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal unsafe void InitializeFromSpan(ReadOnlySpan<T> span)
|
|
{
|
|
if (span.IsEmpty) {
|
|
return;
|
|
}
|
|
|
|
Header* header = (Header*)_buffer;
|
|
T* dataStart = (T*)(_buffer + sizeof(Header));
|
|
|
|
fixed (T* sourcePtr = span) {
|
|
Buffer.MemoryCopy(sourcePtr, dataStart,
|
|
header->Capacity * (nuint)sizeof(T),
|
|
(nuint)span.Length * (nuint)sizeof(T));
|
|
}
|
|
|
|
header->Top = (nuint)span.Length;
|
|
Volatile.Write(ref _count, (ulong)span.Length);
|
|
}
|
|
|
|
private void AllocateBuffer(int capacity)
|
|
{
|
|
nuint size = (nuint)sizeof(Header) + ((nuint)capacity * (nuint)sizeof(T));
|
|
_buffer = (byte*)NativeMemory.Alloc(size);
|
|
Header* header = (Header*)_buffer;
|
|
header->Top = 0;
|
|
header->Capacity = (nuint)capacity;
|
|
}
|
|
|
|
private struct Header
|
|
{
|
|
|
|
public nuint Capacity; // max capacity of the stack (number of elements)
|
|
public nuint Top; // next available index in the stack
|
|
|
|
}
|
|
|
|
}
|
|
}
|