Mirrors/Ryujinx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Replace CacheResourceWrite with more general "precise" write (#2684)

Browse source 
* 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.
This commit is contained in:
riperiperi 2021-09-29 01:27:03 +01:00 • committed by GitHub
parent b6e093b0fc
commit d92fff541b
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
31 changed files with 338 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Ryujinx.Memory/Tracking/AbstractRegion.cs
View file

@ -52,6 +52,14 @@ namespace Ryujinx.Memory.Tracking
/// <param name="write">Whether the region was written to or read</param>
public abstract void Signal(ulong address, ulong size, bool write);
/// <summary>
/// Signals to the handles that a precise memory event has occurred. Assumes that the tracking lock has been obtained.
/// </summary>
/// <param name="address">Address accessed</param>
/// <param name="size">Size of the region affected in bytes</param>
/// <param name="write">Whether the region was written to or read</param>
public abstract void SignalPrecise(ulong address, ulong size, bool write);
/// <summary>
/// Split this region into two, around the specified address.
/// This region is updated to end at the split address, and a new region is created to represent past that point.

1
Ryujinx.Memory/Tracking/IRegionHandle.cs
View file

@ -13,5 +13,6 @@ namespace Ryujinx.Memory.Tracking
void ForceDirty();
void Reprotect(bool asDirty = false);
void RegisterAction(RegionSignal action);
void RegisterPreciseAction(PreciseRegionSignal action);
}
}

17
Ryujinx.Memory/Tracking/MemoryTracking.cs
View file

@ -190,12 +190,15 @@ namespace Ryujinx.Memory.Tracking
/// <summary>
/// Signal that a virtual memory event happened at the given location.
/// This can be flagged as a precise event, which will avoid reprotection and call special handlers if possible.
/// A precise event has an exact address and size, rather than triggering on page granularity.
/// </summary>
/// <param name="address">Virtual address accessed</param>
/// <param name="size">Size of the region affected in bytes</param>
/// <param name="write">Whether the region was written to or read</param>
/// <param name="precise">True if the access is precise, false otherwise</param>
/// <returns>True if the event triggered any tracking regions, false otherwise</returns>
public bool VirtualMemoryEvent(ulong address, ulong size, bool write)
public bool VirtualMemoryEvent(ulong address, ulong size, bool write, bool precise = false)
{
// Look up the virtual region using the region list.
// Signal up the chain to relevant handles.
@ -206,7 +209,7 @@ namespace Ryujinx.Memory.Tracking
int count = _virtualRegions.FindOverlapsNonOverlapping(address, size, ref overlaps);
if (count == 0)
if (count == 0 && !precise)
{
if (!_memoryManager.IsMapped(address))
{
@ -224,7 +227,15 @@ namespace Ryujinx.Memory.Tracking
for (int i = 0; i < count; i++)
{
VirtualRegion region = overlaps[i];
region.Signal(address, size, write);
if (precise)
{
region.SignalPrecise(address, size, write);
}
else
{
region.Signal(address, size, write);
}
}
}

11
Ryujinx.Memory/Tracking/MultiRegionHandle.cs
View file

@ -206,6 +206,17 @@ namespace Ryujinx.Memory.Tracking
}
}
public void RegisterPreciseAction(ulong address, ulong size, PreciseRegionSignal action)
{
int startHandle = (int)((address - Address) / Granularity);
int lastHandle = (int)((address + (size - 1) - Address) / Granularity);
for (int i = startHandle; i <= lastHandle; i++)
{
_handles[i].RegisterPreciseAction(action);
}
}
public void Dispose()
{
foreach (var handle in _handles)

4
Ryujinx.Memory/Tracking/PreciseRegionSignal.cs Normal file
View file

@ -0,0 +1,4 @@
namespace Ryujinx.Memory.Tracking
{
public delegate bool PreciseRegionSignal(ulong address, ulong size, bool write);
}

35
Ryujinx.Memory/Tracking/RegionHandle.cs
View file

@ -37,6 +37,7 @@ namespace Ryujinx.Memory.Tracking
private object _preActionLock = new object();
private RegionSignal _preAction; // Action to perform before a read or write. This will block the memory access.
private PreciseRegionSignal _preciseAction; // Action to perform on a precise read or write.
private readonly List<VirtualRegion> _regions;
private readonly MemoryTracking _tracking;
private bool _disposed;
@ -113,7 +114,10 @@ namespace Ryujinx.Memory.Tracking
/// <summary>
/// Signal that a memory action occurred within this handle's virtual regions.
/// </summary>
/// <param name="address">Address accessed</param>
/// <param name="size">Size of the region affected in bytes</param>
/// <param name="write">Whether the region was written to or read</param>
/// <param name="handleIterable">Reference to the handles being iterated, in case the list needs to be copied</param>
internal void Signal(ulong address, ulong size, bool write, ref IList<RegionHandle> handleIterable)
{
// If this handle was already unmapped (even if just partially),
@ -163,6 +167,27 @@ namespace Ryujinx.Memory.Tracking
}
}
/// <summary>
/// Signal that a precise memory action occurred within this handle's virtual regions.
/// If there is no precise action, or the action returns false, the normal signal handler will be called.
/// </summary>
/// <param name="address">Address accessed</param>
/// <param name="size">Size of the region affected in bytes</param>
/// <param name="write">Whether the region was written to or read</param>
/// <param name="handleIterable">Reference to the handles being iterated, in case the list needs to be copied</param>
/// <returns>True if a precise action was performed and returned true, false otherwise</returns>
internal bool SignalPrecise(ulong address, ulong size, bool write, ref IList<RegionHandle> handleIterable)
{
if (!Unmapped && _preciseAction != null && _preciseAction(address, size, write))
{
return true;
}
Signal(address, size, write, ref handleIterable);
return false;
}
/// <summary>
/// Force this handle to be dirty, without reprotecting.
/// </summary>
@ -243,6 +268,16 @@ namespace Ryujinx.Memory.Tracking
}
}
/// <summary>
/// Register an action to perform when a precise access occurs (one with exact address and size).
/// If the action returns true, read/write tracking are skipped.
/// </summary>
/// <param name="action">Action to call on read or write</param>
public void RegisterPreciseAction(PreciseRegionSignal action)
{
_preciseAction = action;
}
/// <summary>
/// Register an action to perform when the region is written to.
/// This action will not be removed when it is called - it is called each time the dirty flag is set.

11
Ryujinx.Memory/Tracking/SmartMultiRegionHandle.cs
View file

@ -63,6 +63,17 @@ namespace Ryujinx.Memory.Tracking
}
}
public void RegisterPreciseAction(PreciseRegionSignal action)
{
foreach (var handle in _handles)
{
if (handle != null)
{
handle?.RegisterPreciseAction((address, size, write) => action(handle.Address, handle.Size, write));
}
}
}
public void QueryModified(Action<ulong, ulong> modifiedAction)
{
if (!Dirty)

19
Ryujinx.Memory/Tracking/VirtualRegion.cs
View file

@ -31,6 +31,25 @@ namespace Ryujinx.Memory.Tracking
UpdateProtection();
}
public override void SignalPrecise(ulong address, ulong size, bool write)
{
IList<RegionHandle> handles = Handles;
bool allPrecise = true;
for (int i = 0; i < handles.Count; i++)
{
allPrecise &= handles[i].SignalPrecise(address, size, write, ref handles);
}
// Only update protection if a regular signal handler was called.
// This allows precise actions to skip reprotection costs if they want (they can still do it manually).
if (!allPrecise)
{
UpdateProtection();
}
}
/// <summary>
/// Signal that this region has been mapped or unmapped.
/// </summary>