mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-06-02 13:18:46 +02:00
ead9a25141
* - WritableRegion: enable wrapping IMemoryOwner<byte> - IVirtualMemoryManager impls of GetWritableRegion() use pooled memory when region is non-contiguous. - IVirtualMemoryManager: add GetReadOnlySequence() and impls - ByteMemoryPool: add new method RentCopy() - ByteMemoryPool: make class static, remove ctor and singleton field from earlier impl * - BytesReadOnlySequenceSegment: move from Ryujinx.Common.Memory to Ryujinx.Memory - BytesReadOnlySequenceSegment: add IsContiguousWith() and Replace() methods - VirtualMemoryManagerBase: - remove generic type parameters, instead use ulong for virtual addresses and nuint for host/physical addresses - implement IWritableBlock - add virtual GetReadOnlySequence() with coalescing of contiguous segments - add virtual GetSpan() - add virtual GetWritableRegion() - add abstract IsMapped() - add virtual MapForeign(ulong, nuint, ulong) - add virtual Read<T>() - add virtual Read(ulong, Span<byte>) - add virtual ReadTracked<T>() - add virtual SignalMemoryTracking() - add virtual Write() - add virtual Write<T>() - add virtual WriteUntracked() - add virtual WriteWithRedundancyCheck() - VirtualMemoryManagerRefCountedBase: remove generic type parameters - AddressSpaceManager: remove redundant methods, add required overrides - HvMemoryManager: remove redundant methods, add required overrides, add overrides for _invalidAccessHandler handling - MemoryManager: remove redundant methods, add required overrides, add overrides for _invalidAccessHandler handling - MemoryManagerHostMapped: remove redundant methods, add required overrides, add overrides for _invalidAccessHandler handling - NativeMemoryManager: add get properties for Pointer and Length - throughout: removed invalid <inheritdoc/> comments * - WritableRegion: enable wrapping IMemoryOwner<byte> - IVirtualMemoryManager impls of GetWritableRegion() use pooled memory when region is non-contiguous. - IVirtualMemoryManager: add GetReadOnlySequence() and impls - ByteMemoryPool: add new method RentCopy() - ByteMemoryPool: make class static, remove ctor and singleton field from earlier impl * add PagedMemoryRange enumerator types, use them in IVirtualMemoryManager implementations to consolidate page-handling logic and add a new capability - the coalescing of pages for consolidating memory copies and segmentation. * new: more tests for PagedMemoryRangeCoalescingEnumerator showing coalescing of contiguous segments * make some struct properties readonly * put braces around `foreach` bodies * encourage inlining of some PagedMemoryRange*Enumerator members * DynamicRingBuffer: - use ByteMemoryPool - make some methods return without locking when size/count argument = 0 - make generic Read<T>()/Write<T>() non-generic because its only usage is as T = byte - change Read(byte[]...) to Read(Span<byte>...) - change Write(byte[]...) to Write(Span<byte>...) * change IAudioRenderer.RequestUpdate() to take a ReadOnlySequence<byte>, enabling zero-copy audio rendering * HipcGenerator: support ReadOnlySequence<byte> as IPC method parameter * change IAudioRenderer/AudioRenderer RequestUpdate* methods to take input as ReadOnlySequence<byte> * MemoryManagerHostTracked: use rented memory when contiguous in `GetWritableRegion()` * rebase cleanup * dotnet format fixes * format and comment fixes * format long parameter list - take 2 * - add support to HipcGenerator for buffers of type `Memory<byte>` - change `AudioRenderer` `RequestUpdate()` and `RequestUpdateAuto()` to use Memory<byte> for output buffers, removing another memory block allocation/copy * SplitterContext `UpdateState()` and `UpdateData()` smooth out advance/rewind logic, only rewind if magic is invalid * DynamicRingBuffer.Write(): change Span<byte> to ReadOnlySpan<byte>
174 lines
4.8 KiB
C#
174 lines
4.8 KiB
C#
using Ryujinx.Common;
|
|
using Ryujinx.Common.Memory;
|
|
using System;
|
|
using System.Buffers;
|
|
|
|
namespace Ryujinx.Audio.Backends.Common
|
|
{
|
|
/// <summary>
|
|
/// A ring buffer that grow if data written to it is too big to fit.
|
|
/// </summary>
|
|
public class DynamicRingBuffer
|
|
{
|
|
private const int RingBufferAlignment = 2048;
|
|
|
|
private readonly object _lock = new();
|
|
|
|
private IMemoryOwner<byte> _bufferOwner;
|
|
private Memory<byte> _buffer;
|
|
private int _size;
|
|
private int _headOffset;
|
|
private int _tailOffset;
|
|
|
|
public int Length => _size;
|
|
|
|
public DynamicRingBuffer(int initialCapacity = RingBufferAlignment)
|
|
{
|
|
_bufferOwner = ByteMemoryPool.RentCleared(initialCapacity);
|
|
_buffer = _bufferOwner.Memory;
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
_size = 0;
|
|
_headOffset = 0;
|
|
_tailOffset = 0;
|
|
}
|
|
|
|
public void Clear(int size)
|
|
{
|
|
if (size == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
lock (_lock)
|
|
{
|
|
if (size > _size)
|
|
{
|
|
size = _size;
|
|
}
|
|
|
|
_headOffset = (_headOffset + size) % _buffer.Length;
|
|
_size -= size;
|
|
|
|
if (_size == 0)
|
|
{
|
|
_headOffset = 0;
|
|
_tailOffset = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SetCapacityLocked(int capacity)
|
|
{
|
|
IMemoryOwner<byte> newBufferOwner = ByteMemoryPool.RentCleared(capacity);
|
|
Memory<byte> newBuffer = newBufferOwner.Memory;
|
|
|
|
if (_size > 0)
|
|
{
|
|
if (_headOffset < _tailOffset)
|
|
{
|
|
_buffer.Slice(_headOffset, _size).CopyTo(newBuffer);
|
|
}
|
|
else
|
|
{
|
|
_buffer[_headOffset..].CopyTo(newBuffer);
|
|
_buffer[.._tailOffset].CopyTo(newBuffer[(_buffer.Length - _headOffset)..]);
|
|
}
|
|
}
|
|
|
|
_bufferOwner.Dispose();
|
|
|
|
_bufferOwner = newBufferOwner;
|
|
_buffer = newBuffer;
|
|
_headOffset = 0;
|
|
_tailOffset = _size;
|
|
}
|
|
|
|
public void Write(ReadOnlySpan<byte> buffer, int index, int count)
|
|
{
|
|
if (count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
lock (_lock)
|
|
{
|
|
if ((_size + count) > _buffer.Length)
|
|
{
|
|
SetCapacityLocked(BitUtils.AlignUp(_size + count, RingBufferAlignment));
|
|
}
|
|
|
|
if (_headOffset < _tailOffset)
|
|
{
|
|
int tailLength = _buffer.Length - _tailOffset;
|
|
|
|
if (tailLength >= count)
|
|
{
|
|
buffer.Slice(index, count).CopyTo(_buffer.Span[_tailOffset..]);
|
|
}
|
|
else
|
|
{
|
|
buffer.Slice(index, tailLength).CopyTo(_buffer.Span[_tailOffset..]);
|
|
buffer.Slice(index + tailLength, count - tailLength).CopyTo(_buffer.Span);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
buffer.Slice(index, count).CopyTo(_buffer.Span[_tailOffset..]);
|
|
}
|
|
|
|
_size += count;
|
|
_tailOffset = (_tailOffset + count) % _buffer.Length;
|
|
}
|
|
}
|
|
|
|
public int Read(Span<byte> buffer, int index, int count)
|
|
{
|
|
if (count == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
lock (_lock)
|
|
{
|
|
if (count > _size)
|
|
{
|
|
count = _size;
|
|
}
|
|
|
|
if (_headOffset < _tailOffset)
|
|
{
|
|
_buffer.Span.Slice(_headOffset, count).CopyTo(buffer[index..]);
|
|
}
|
|
else
|
|
{
|
|
int tailLength = _buffer.Length - _headOffset;
|
|
|
|
if (tailLength >= count)
|
|
{
|
|
_buffer.Span.Slice(_headOffset, count).CopyTo(buffer[index..]);
|
|
}
|
|
else
|
|
{
|
|
_buffer.Span.Slice(_headOffset, tailLength).CopyTo(buffer[index..]);
|
|
_buffer.Span[..(count - tailLength)].CopyTo(buffer[(index + tailLength)..]);
|
|
}
|
|
}
|
|
|
|
_size -= count;
|
|
_headOffset = (_headOffset + count) % _buffer.Length;
|
|
|
|
if (_size == 0)
|
|
{
|
|
_headOffset = 0;
|
|
_tailOffset = 0;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
}
|
|
}
|
|
}
|