Ryujinx/Ryujinx.Graphics.Gpu/Image/Pool.cs

157 lines
4.8 KiB
C#
Raw Normal View History

using Ryujinx.Common;
using Ryujinx.Graphics.Gpu.Memory;
2019-10-13 08:02:07 +02:00
using System;
namespace Ryujinx.Graphics.Gpu.Image
{
/// <summary>
/// Represents a pool of GPU resources, such as samplers or textures.
/// </summary>
/// <typeparam name="T">Type of the GPU resource</typeparam>
2019-10-13 08:02:07 +02:00
abstract class Pool<T> : IDisposable
{
protected const int DescriptorSize = 0x20;
protected GpuContext Context;
protected T[] Items;
/// <summary>
/// The maximum ID value of resources on the pool (inclusive).
/// </summary>
2020-01-01 16:39:09 +01:00
/// <remarks>
/// The maximum amount of resources on the pool is equal to this value plus one.
/// </remarks>
public int MaximumId { get; }
/// <summary>
/// The address of the pool in guest memory.
/// </summary>
2019-10-13 08:02:07 +02:00
public ulong Address { get; }
/// <summary>
/// The size of the pool in bytes.
/// </summary>
public ulong Size { get; }
2019-10-13 08:02:07 +02:00
private readonly (ulong, ulong)[] _modifiedRanges;
2019-10-13 08:02:07 +02:00
public Pool(GpuContext context, ulong address, int maximumId)
{
Context = context;
MaximumId = maximumId;
2019-10-13 08:02:07 +02:00
int count = maximumId + 1;
ulong size = (ulong)(uint)count * DescriptorSize;;
Items = new T[count];
Address = address;
Size = size;
ulong endAddress = BitUtils.AlignUp(Address + Size, PhysicalMemory.PageSize);
ulong pagesCount = (endAddress - BitUtils.AlignDown(Address, PhysicalMemory.PageSize)) / PhysicalMemory.PageSize;
_modifiedRanges = new (ulong, ulong)[pagesCount];
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Gets the GPU resource with the given ID.
/// </summary>
/// <param name="id">ID of the resource. This is effectively a zero-based index</param>
/// <returns>The GPU resource with the given ID</returns>
2019-10-13 08:02:07 +02:00
public abstract T Get(int id);
/// <summary>
/// Synchronizes host memory with guest memory.
/// This causes invalidation of pool entries,
/// if a modification of entries by the CPU is detected.
/// </summary>
2019-10-13 08:02:07 +02:00
public void SynchronizeMemory()
{
int count = Context.PhysicalMemory.QueryModified(Address, Size, ResourceName.TexturePool, _modifiedRanges);
2019-10-13 08:02:07 +02:00
for (int index = 0; index < count; index++)
2019-10-13 08:02:07 +02:00
{
(ulong mAddress, ulong mSize) = _modifiedRanges[index];
2019-10-13 08:02:07 +02:00
if (mAddress < Address)
{
mAddress = Address;
}
ulong maxSize = Address + Size - mAddress;
if (mSize > maxSize)
{
mSize = maxSize;
}
InvalidateRangeImpl(mAddress, mSize);
}
}
private void InvalidateRangeInternal(ulong offset, int size)
{
InvalidateRangeImpl(Address + offset, (ulong)size);
}
/// <summary>
/// Invalidates a range of memory of the GPU resource pool.
/// Entries that falls inside the speicified range will be invalidated,
/// causing all the data to be reloaded from guest memory.
/// </summary>
/// <param name="address">The start address of the range to invalidate</param>
/// <param name="size">The size of the range to invalidate</param>
2019-10-13 08:02:07 +02:00
public void InvalidateRange(ulong address, ulong size)
{
ulong endAddress = address + size;
ulong texturePoolEndAddress = Address + Size;
// If the range being invalidated is not overlapping the texture pool range,
// then we don't have anything to do, exit early.
if (address >= texturePoolEndAddress || endAddress <= Address)
{
return;
}
if (address < Address)
{
address = Address;
}
if (endAddress > texturePoolEndAddress)
{
endAddress = texturePoolEndAddress;
}
size = endAddress - address;
2019-10-13 08:02:07 +02:00
InvalidateRangeImpl(address, size);
}
protected abstract void InvalidateRangeImpl(ulong address, ulong size);
protected abstract void Delete(T item);
/// <summary>
/// Performs the disposal of all resources stored on the pool.
/// It's an error to try using the pool after disposal.
/// </summary>
2019-10-13 08:02:07 +02:00
public void Dispose()
{
if (Items != null)
{
for (int index = 0; index < Items.Length; index++)
{
Delete(Items[index]);
}
Items = null;
}
}
}
}