Ryujinx-git/Ryujinx.Graphics.Gpu/Memory/Buffer.cs

171 lines
5.9 KiB
C#
Raw Normal View History

2019-10-13 06:02:07 +00:00
using Ryujinx.Graphics.GAL;
using System;
namespace Ryujinx.Graphics.Gpu.Memory
{
/// <summary>
/// Buffer, used to store vertex and index data, uniform and storage buffers, and others.
/// </summary>
2019-12-31 22:37:00 +00:00
class Buffer : IRange, IDisposable
2019-10-13 06:02:07 +00:00
{
2019-12-31 22:37:00 +00:00
private readonly GpuContext _context;
2019-10-13 06:02:07 +00:00
/// <summary>
/// Host buffer object.
/// </summary>
2019-12-31 22:37:00 +00:00
public IBuffer HostBuffer { get; }
2019-10-27 02:41:01 +00:00
/// <summary>
/// Start address of the buffer in guest memory.
/// </summary>
2019-10-13 06:02:07 +00:00
public ulong Address { get; }
/// <summary>
/// Size of the buffer in bytes.
/// </summary>
public ulong Size { get; }
/// <summary>
/// End address of the buffer in guest memory.
/// </summary>
2019-10-13 06:02:07 +00:00
public ulong EndAddress => Address + Size;
private int[] _sequenceNumbers;
/// <summary>
/// Creates a new instance of the buffer.
/// </summary>
/// <param name="context">GPU context that the buffer belongs to</param>
/// <param name="address">Start address of the buffer</param>
/// <param name="size">Size of the buffer in bytes</param>
2019-10-13 06:02:07 +00:00
public Buffer(GpuContext context, ulong address, ulong size)
{
_context = context;
Address = address;
Size = size;
2019-12-31 22:37:00 +00:00
HostBuffer = context.Renderer.CreateBuffer((int)size);
2019-10-13 06:02:07 +00:00
_sequenceNumbers = new int[size / MemoryManager.PageSize];
Invalidate();
}
/// <summary>
/// Gets a sub-range from the buffer.
/// </summary>
2020-01-01 15:39:09 +00:00
/// <remarks>
/// This can be used to bind and use sub-ranges of the buffer on the host API.
/// </remarks>
/// <param name="address">Start address of the sub-range, must be greater than or equal to the buffer address</param>
/// <param name="size">Size in bytes of the sub-range, must be less than or equal to the buffer size</param>
/// <returns>The buffer sub-range</returns>
2019-10-13 06:02:07 +00:00
public BufferRange GetRange(ulong address, ulong size)
{
int offset = (int)(address - Address);
2019-12-31 22:37:00 +00:00
return new BufferRange(HostBuffer, offset, (int)size);
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Checks if a given range overlaps with the buffer.
/// </summary>
/// <param name="address">Start address of the range</param>
/// <param name="size">Size in bytes of the range</param>
/// <returns>True if the range overlaps, false otherwise</returns>
2019-10-13 06:02:07 +00:00
public bool OverlapsWith(ulong address, ulong size)
{
return Address < address + size && address < EndAddress;
}
/// <summary>
/// Performs guest to host memory synchronization of the buffer data.
2020-01-01 15:39:09 +00:00
/// </summary>
/// <remarks>
/// This causes the buffer data to be overwritten if a write was detected from the CPU,
/// since the last call to this method.
2020-01-01 15:39:09 +00:00
/// </remarks>
/// <param name="address">Start address of the range to synchronize</param>
/// <param name="size">Size in bytes of the range to synchronize</param>
2019-10-13 06:02:07 +00:00
public void SynchronizeMemory(ulong address, ulong size)
{
int currentSequenceNumber = _context.SequenceNumber;
bool needsSync = false;
ulong buffOffset = address - Address;
ulong buffEndOffset = (buffOffset + size + MemoryManager.PageMask) & ~MemoryManager.PageMask;
int startIndex = (int)(buffOffset / MemoryManager.PageSize);
int endIndex = (int)(buffEndOffset / MemoryManager.PageSize);
for (int index = startIndex; index < endIndex; index++)
{
if (_sequenceNumbers[index] != currentSequenceNumber)
{
_sequenceNumbers[index] = currentSequenceNumber;
needsSync = true;
}
}
if (!needsSync)
{
return;
}
(ulong, ulong)[] modifiedRanges = _context.PhysicalMemory.GetModifiedRanges(address, size, ResourceName.Buffer);
2019-10-13 06:02:07 +00:00
for (int index = 0; index < modifiedRanges.Length; index++)
{
(ulong mAddress, ulong mSize) = modifiedRanges[index];
int offset = (int)(mAddress - Address);
HostBuffer.SetData(offset, _context.PhysicalMemory.GetSpan(mAddress, mSize));
2019-10-13 06:02:07 +00:00
}
}
/// <summary>
/// Performs copy of all the buffer data from one buffer to another.
/// </summary>
/// <param name="destination">The destination buffer to copy the data into</param>
/// <param name="dstOffset">The offset of the destination buffer to copy into</param>
2019-10-13 06:02:07 +00:00
public void CopyTo(Buffer destination, int dstOffset)
{
2019-12-31 22:37:00 +00:00
HostBuffer.CopyTo(destination.HostBuffer, 0, dstOffset, (int)Size);
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Flushes a range of the buffer.
/// This writes the range data back into guest memory.
/// </summary>
/// <param name="address">Start address of the range</param>
/// <param name="size">Size in bytes of the range</param>
2019-10-27 02:41:01 +00:00
public void Flush(ulong address, ulong size)
{
int offset = (int)(address - Address);
2019-12-31 22:37:00 +00:00
byte[] data = HostBuffer.GetData(offset, (int)size);
2019-10-27 02:41:01 +00:00
_context.PhysicalMemory.Write(address, data);
}
/// <summary>
/// Invalidates all the buffer data, causing it to be read from guest memory.
/// </summary>
2019-10-13 06:02:07 +00:00
public void Invalidate()
{
HostBuffer.SetData(0, _context.PhysicalMemory.GetSpan(Address, Size));
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Disposes the host buffer.
/// </summary>
2019-10-13 06:02:07 +00:00
public void Dispose()
{
2019-12-31 22:37:00 +00:00
HostBuffer.Dispose();
2019-10-13 06:02:07 +00:00
}
}
}