mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-09-11 10:18:52 +02:00
90 lines
3.3 KiB
C#
90 lines
3.3 KiB
C#
|
using System;
|
|||
|
using System.Runtime.CompilerServices;
|
|||
|
using System.Runtime.InteropServices;
|
|||
|
using System.Threading;
|
|||
|
|
|||
|
namespace Ryujinx.Graphics.GAL.Multithreading.Model
|
|||
|
{
|
|||
|
/// <summary>
|
|||
|
/// A memory pool for passing through Span<T> resources with one producer and consumer.
|
|||
|
/// Data is copied on creation to part of the pool, then that region is reserved until it is disposed by the consumer.
|
|||
|
/// Similar to the command queue, this pool assumes that data is created and disposed in the same order.
|
|||
|
/// </summary>
|
|||
|
class CircularSpanPool
|
|||
|
{
|
|||
|
private ThreadedRenderer _renderer;
|
|||
|
private byte[] _pool;
|
|||
|
private int _size;
|
|||
|
|
|||
|
private int _producerPtr;
|
|||
|
private int _producerSkipPosition = -1;
|
|||
|
private int _consumerPtr;
|
|||
|
|
|||
|
public CircularSpanPool(ThreadedRenderer renderer, int size)
|
|||
|
{
|
|||
|
_renderer = renderer;
|
|||
|
_size = size;
|
|||
|
_pool = new byte[size];
|
|||
|
}
|
|||
|
|
|||
|
public SpanRef<T> Insert<T>(ReadOnlySpan<T> data) where T : unmanaged
|
|||
|
{
|
|||
|
int size = data.Length * Unsafe.SizeOf<T>();
|
|||
|
|
|||
|
// Wrapping aware circular queue.
|
|||
|
// If there's no space at the end of the pool for this span, we can't fragment it.
|
|||
|
// So just loop back around to the start. Remember the last skipped position.
|
|||
|
|
|||
|
bool wraparound = _producerPtr + size >= _size;
|
|||
|
int index = wraparound ? 0 : _producerPtr;
|
|||
|
|
|||
|
// _consumerPtr is from another thread, and we're taking it without a lock, so treat this as a snapshot in the past.
|
|||
|
// We know that it will always be before or equal to the producer pointer, and it cannot pass it.
|
|||
|
// This is enough to reason about if there is space in the queue for the data, even if we're checking against an outdated value.
|
|||
|
|
|||
|
int consumer = _consumerPtr;
|
|||
|
bool beforeConsumer = _producerPtr < consumer;
|
|||
|
|
|||
|
if (size > _size - 1 || (wraparound && beforeConsumer) || ((index < consumer || wraparound) && index + size >= consumer))
|
|||
|
{
|
|||
|
// Just get an array in the following situations:
|
|||
|
// - The data is too large to fit in the pool.
|
|||
|
// - A wraparound would happen but the consumer would be covered by it.
|
|||
|
// - The producer would catch up to the consumer as a result.
|
|||
|
|
|||
|
return new SpanRef<T>(_renderer, data.ToArray());
|
|||
|
}
|
|||
|
|
|||
|
data.CopyTo(MemoryMarshal.Cast<byte, T>(new Span<byte>(_pool).Slice(index, size)));
|
|||
|
|
|||
|
if (wraparound)
|
|||
|
{
|
|||
|
_producerSkipPosition = _producerPtr;
|
|||
|
}
|
|||
|
|
|||
|
_producerPtr = index + size;
|
|||
|
|
|||
|
return new SpanRef<T>(data.Length);
|
|||
|
}
|
|||
|
|
|||
|
public Span<T> Get<T>(int length) where T : unmanaged
|
|||
|
{
|
|||
|
int size = length * Unsafe.SizeOf<T>();
|
|||
|
|
|||
|
if (_consumerPtr == Interlocked.CompareExchange(ref _producerSkipPosition, -1, _consumerPtr))
|
|||
|
{
|
|||
|
_consumerPtr = 0;
|
|||
|
}
|
|||
|
|
|||
|
return MemoryMarshal.Cast<byte, T>(new Span<byte>(_pool).Slice(_consumerPtr, size));
|
|||
|
}
|
|||
|
|
|||
|
public void Dispose<T>(int length) where T : unmanaged
|
|||
|
{
|
|||
|
int size = length * Unsafe.SizeOf<T>();
|
|||
|
|
|||
|
_consumerPtr = _consumerPtr + size;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|