mirror of
https://github.com/GreemDev/Ryujinx
synced 2024-12-12 03:00:00 +01:00
d92fff541b
* Replace CacheResourceWrite with more general "precise" write The goal of CacheResourceWrite was to notify GPU resources when they were modified directly, by looking up the modified address/size in a structure and calling a method on each resource. The downside of this is that each resource cache has to be queried individually, they all have to implement their own way to do this, and it can only signal to resources using the same PhysicalMemory instance. This PR adds the ability to signal a write as "precise" on the tracking, which signals a special handler (if present) which can be used to avoid unnecessary flush actions, or maybe even more. For buffers, precise writes specifically do not flush, and instead punch a hole in the modified range list to indicate that the data on GPU has been replaced. The downside is that precise actions must ignore the page protection bits and always signal - as they need to notify the target resource to ignore the sequence number optimization. I had to reintroduce the sequence number increment after I2M, as removing it was causing issues in rabbids kingdom battle. However - all resources modified by I2M are notified directly to lower their sequence number, so the problem is likely that another unrelated resource is not being properly updated. Thankfully, doing this does not affect performance in the games I tested. This should fix regressions from #2624. Test any games that were broken by that. (RF4, rabbids kingdom battle) I've also added a sequence number increment to ThreedClass.IncrementSyncpoint, as it seems to fix buffer corruption in OpenGL homebrew. (this was a regression from removing sequence number increment from constant buffer update - another unrelated resource thing) * Add tests. * Add XML docs for GpuRegionHandle * Skip UpdateProtection if only precise actions were called This allows precise actions to skip reprotection costs.
160 lines
No EOL
5.4 KiB
C#
160 lines
No EOL
5.4 KiB
C#
using Ryujinx.Cpu.Tracking;
|
|
using Ryujinx.Graphics.Gpu.Memory;
|
|
using System;
|
|
|
|
namespace Ryujinx.Graphics.Gpu.Image
|
|
{
|
|
/// <summary>
|
|
/// Represents a pool of GPU resources, such as samplers or textures.
|
|
/// </summary>
|
|
/// <typeparam name="T1">Type of the GPU resource</typeparam>
|
|
/// <typeparam name="T2">Type of the descriptor</typeparam>
|
|
abstract class Pool<T1, T2> : IDisposable where T2 : unmanaged
|
|
{
|
|
protected const int DescriptorSize = 0x20;
|
|
|
|
protected GpuContext Context;
|
|
protected PhysicalMemory PhysicalMemory;
|
|
protected int SequenceNumber;
|
|
|
|
protected T1[] Items;
|
|
protected T2[] DescriptorCache;
|
|
|
|
/// <summary>
|
|
/// The maximum ID value of resources on the pool (inclusive).
|
|
/// </summary>
|
|
/// <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>
|
|
public ulong Address { get; }
|
|
|
|
/// <summary>
|
|
/// The size of the pool in bytes.
|
|
/// </summary>
|
|
public ulong Size { get; }
|
|
|
|
private readonly CpuMultiRegionHandle _memoryTracking;
|
|
private readonly Action<ulong, ulong> _modifiedDelegate;
|
|
|
|
/// <summary>
|
|
/// Creates a new instance of the GPU resource pool.
|
|
/// </summary>
|
|
/// <param name="context">GPU context that the pool belongs to</param>
|
|
/// <param name="physicalMemory">Physical memory where the resource descriptors are mapped</param>
|
|
/// <param name="address">Address of the pool in physical memory</param>
|
|
/// <param name="maximumId">Maximum index of an item on the pool (inclusive)</param>
|
|
public Pool(GpuContext context, PhysicalMemory physicalMemory, ulong address, int maximumId)
|
|
{
|
|
Context = context;
|
|
PhysicalMemory = physicalMemory;
|
|
MaximumId = maximumId;
|
|
|
|
int count = maximumId + 1;
|
|
|
|
ulong size = (ulong)(uint)count * DescriptorSize;
|
|
|
|
Items = new T1[count];
|
|
DescriptorCache = new T2[count];
|
|
|
|
Address = address;
|
|
Size = size;
|
|
|
|
_memoryTracking = physicalMemory.BeginGranularTracking(address, size);
|
|
_memoryTracking.RegisterPreciseAction(address, size, PreciseAction);
|
|
_modifiedDelegate = RegionModified;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the descriptor for a given ID.
|
|
/// </summary>
|
|
/// <param name="id">ID of the descriptor. This is effectively a zero-based index</param>
|
|
/// <returns>The descriptor</returns>
|
|
public T2 GetDescriptor(int id)
|
|
{
|
|
return PhysicalMemory.Read<T2>(Address + (ulong)id * DescriptorSize);
|
|
}
|
|
|
|
/// <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>
|
|
public abstract T1 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>
|
|
public void SynchronizeMemory()
|
|
{
|
|
_memoryTracking.QueryModified(_modifiedDelegate);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicate that a region of the pool was modified, and must be loaded from memory.
|
|
/// </summary>
|
|
/// <param name="mAddress">Start address of the modified region</param>
|
|
/// <param name="mSize">Size of the modified region</param>
|
|
private void RegionModified(ulong mAddress, ulong mSize)
|
|
{
|
|
if (mAddress < Address)
|
|
{
|
|
mAddress = Address;
|
|
}
|
|
|
|
ulong maxSize = Address + Size - mAddress;
|
|
|
|
if (mSize > maxSize)
|
|
{
|
|
mSize = maxSize;
|
|
}
|
|
|
|
InvalidateRangeImpl(mAddress, mSize);
|
|
}
|
|
|
|
/// <summary>
|
|
/// An action to be performed when a precise memory access occurs to this resource.
|
|
/// Makes sure that the dirty flags are checked.
|
|
/// </summary>
|
|
/// <param name="address">Address of the memory action</param>
|
|
/// <param name="size">Size in bytes</param>
|
|
/// <param name="write">True if the access was a write, false otherwise</param>
|
|
private bool PreciseAction(ulong address, ulong size, bool write)
|
|
{
|
|
if (write && Context.SequenceNumber == SequenceNumber)
|
|
{
|
|
SequenceNumber--;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected abstract void InvalidateRangeImpl(ulong address, ulong size);
|
|
|
|
protected abstract void Delete(T1 item);
|
|
|
|
/// <summary>
|
|
/// Performs the disposal of all resources stored on the pool.
|
|
/// It's an error to try using the pool after disposal.
|
|
/// </summary>
|
|
public virtual void Dispose()
|
|
{
|
|
if (Items != null)
|
|
{
|
|
for (int index = 0; index < Items.Length; index++)
|
|
{
|
|
Delete(Items[index]);
|
|
}
|
|
|
|
Items = null;
|
|
}
|
|
_memoryTracking.Dispose();
|
|
}
|
|
}
|
|
} |