mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-20 15:48:43 +02:00
* WIP Range Tracking - Texture invalidation seems to have large problems - Buffer/Pool invalidation may have problems - Mirror memory tracking puts an additional `add` in compiled code, we likely just want to make HLE access slower if this is the final solution. - Native project is in the messiest possible location. - [HACK] JIT memory access always uses native "fast" path - [HACK] Trying some things with texture invalidation and views. It works :) Still a few hacks, messy things, slow things More work in progress stuff (also move to memory project) Quite a bit faster now. - Unmapping GPU VA and CPU VA will now correctly update write tracking regions, and invalidate textures for the former. - The Virtual range list is now non-overlapping like the physical one. - Fixed some bugs where regions could leak. - Introduced a weird bug that I still need to track down (consistent invalid buffer in MK8 ribbon road) Move some stuff. I think we'll eventually just put the dll and so for this in a nuget package. Fix rebase. [WIP] MultiRegionHandle variable size ranges - Avoid reprotecting regions that change often (needs some tweaking) - There's still a bug in buffers, somehow. - Might want different api for minimum granularity Fix rebase issue Commit everything needed for software only tracking. Remove native components. Remove more native stuff. Cleanup Use a separate window for the background context, update opentk. (fixes linux) Some experimental changes Should get things working up to scratch - still need to try some things with flush/modification and res scale. Include address with the region action. Initial work to make range tracking work Still a ton of bugs Fix some issues with the new stuff. * Fix texture flush instability There's still some weird behaviour, but it's much improved without this. (textures with cpu modified data were flushing over it) * Find the destination texture for Buffer->Texture full copy Greatly improves performance for nvdec videos (with range tracking) * Further improve texture tracking * Disable Memory Tracking for view parents This is a temporary approach to better match behaviour on master (where invalidations would be soaked up by views, rather than trigger twice) The assumption is that when views are created to a texture, they will cover all of its data anyways. Of course, this can easily be improved in future. * Introduce some tracking tests. WIP * Complete base tests. * Add more tests for multiregion, fix existing test. * Cleanup Part 1 * Remove unnecessary code from memory tracking * Fix some inconsistencies with 3D texture rule. * Add dispose tests. * Use a background thread for the background context. Rather than setting and unsetting a context as current, doing the work on a dedicated thread with signals seems to be a bit faster. Also nerf the multithreading test a bit. * Copy to texture with matching alignment This extends the copy to work for some videos with unusual size, such as tutorial videos in SMO. It will only occur if the destination texture already exists at XCount size. * Track reads for buffer copies. Synchronize new buffers before copying overlaps. * Remove old texture flushing mechanisms. Range tracking all the way, baby. * Wake the background thread when disposing. Avoids a deadlock when games are closed. * Address Feedback 1 * Separate TextureCopy instance for background thread Also `BackgroundContextWorker.InBackground` for a more sensible idenfifier for if we're in a background thread. * Add missing XML docs. * Address Feedback * Maybe I should start drinking coffee. * Some more feedback. * Remove flush warning, Refocus window after making background context
322 lines
13 KiB
C#
322 lines
13 KiB
C#
using Ryujinx.Memory.Range;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Ryujinx.Memory.Tracking
|
|
{
|
|
/// <summary>
|
|
/// Manages memory tracking for a given virutal/physical memory block.
|
|
/// </summary>
|
|
public class MemoryTracking
|
|
{
|
|
private readonly IVirtualMemoryManager _memoryManager;
|
|
private readonly MemoryBlock _block;
|
|
|
|
// Only use these from within the lock.
|
|
private readonly NonOverlappingRangeList<VirtualRegion> _virtualRegions;
|
|
private readonly NonOverlappingRangeList<PhysicalRegion> _physicalRegions;
|
|
|
|
// Only use these from within the lock.
|
|
private readonly VirtualRegion[] _virtualResults = new VirtualRegion[10];
|
|
private readonly PhysicalRegion[] _physicalResults = new PhysicalRegion[10];
|
|
|
|
private readonly int _pageSize;
|
|
|
|
/// <summary>
|
|
/// This lock must be obtained when traversing or updating the region-handle hierarchy.
|
|
/// It is not required when reading dirty flags.
|
|
/// </summary>
|
|
internal object TrackingLock = new object();
|
|
|
|
public bool EnablePhysicalProtection { get; set; }
|
|
|
|
/// <summary>
|
|
/// Create a new tracking structure for the given "physical" memory block,
|
|
/// with a given "virtual" memory manager that will provide mappings and virtual memory protection.
|
|
/// </summary>
|
|
/// <param name="memoryManager">Virtual memory manager</param>
|
|
/// <param name="block">Physical memory block</param>
|
|
/// <param name="pageSize">Page size of the virtual memory space</param>
|
|
public MemoryTracking(IVirtualMemoryManager memoryManager, MemoryBlock block, int pageSize)
|
|
{
|
|
_memoryManager = memoryManager;
|
|
_block = block;
|
|
_pageSize = pageSize;
|
|
|
|
_virtualRegions = new NonOverlappingRangeList<VirtualRegion>();
|
|
_physicalRegions = new NonOverlappingRangeList<PhysicalRegion>();
|
|
}
|
|
|
|
private (ulong address, ulong size) PageAlign(ulong address, ulong size)
|
|
{
|
|
ulong pageMask = (ulong)_pageSize - 1;
|
|
ulong rA = address & ~pageMask;
|
|
ulong rS = ((address + size + pageMask) & ~pageMask) - rA;
|
|
return (rA, rS);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicate that a virtual region has been mapped, and which physical region it has been mapped to.
|
|
/// Should be called after the mapping is complete.
|
|
/// </summary>
|
|
/// <param name="va">Virtual memory address</param>
|
|
/// <param name="pa">Physical memory address</param>
|
|
/// <param name="size">Size to be mapped</param>
|
|
public void Map(ulong va, ulong pa, ulong size)
|
|
{
|
|
// A mapping may mean we need to re-evaluate each VirtualRegion's affected area.
|
|
// Find all handles that overlap with the range, we need to recalculate their physical regions
|
|
|
|
lock (TrackingLock)
|
|
{
|
|
var results = _virtualResults;
|
|
int count = _virtualRegions.FindOverlapsNonOverlapping(va, size, ref results);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
VirtualRegion region = results[i];
|
|
region.RecalculatePhysicalChildren();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicate that a virtual region has been unmapped.
|
|
/// Should be called after the unmapping is complete.
|
|
/// </summary>
|
|
/// <param name="va">Virtual memory address</param>
|
|
/// <param name="size">Size to be unmapped</param>
|
|
public void Unmap(ulong va, ulong size)
|
|
{
|
|
// An unmapping may mean we need to re-evaluate each VirtualRegion's affected area.
|
|
// Find all handles that overlap with the range, we need to recalculate their physical regions
|
|
|
|
lock (TrackingLock)
|
|
{
|
|
var results = _virtualResults;
|
|
int count = _virtualRegions.FindOverlapsNonOverlapping(va, size, ref results);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
VirtualRegion region = results[i];
|
|
region.RecalculatePhysicalChildren();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a list of virtual regions that a handle covers.
|
|
/// </summary>
|
|
/// <param name="va">Starting virtual memory address of the handle</param>
|
|
/// <param name="size">Size of the handle's memory region</param>
|
|
/// <returns>A list of virtual regions within the given range</returns>
|
|
internal List<VirtualRegion> GetVirtualRegionsForHandle(ulong va, ulong size)
|
|
{
|
|
List<VirtualRegion> result = new List<VirtualRegion>();
|
|
_virtualRegions.GetOrAddRegions(result, va, size, (va, size) => new VirtualRegion(this, va, size));
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a list of physical regions that a virtual region covers.
|
|
/// Note that this becomes outdated if the virtual or physical regions are unmapped or remapped.
|
|
/// </summary>
|
|
/// <param name="va">Virtual memory address</param>
|
|
/// <param name="size">Size of the virtual region</param>
|
|
/// <returns>A list of physical regions the virtual region covers</returns>
|
|
internal List<PhysicalRegion> GetPhysicalRegionsForVirtual(ulong va, ulong size)
|
|
{
|
|
List<PhysicalRegion> result = new List<PhysicalRegion>();
|
|
|
|
// Get a list of physical regions for this virtual region, from our injected virtual mapping function.
|
|
(ulong Address, ulong Size)[] physicalRegions = _memoryManager.GetPhysicalRegions(va, size);
|
|
|
|
if (physicalRegions != null)
|
|
{
|
|
foreach (var region in physicalRegions)
|
|
{
|
|
_physicalRegions.GetOrAddRegions(result, region.Address, region.Size, (pa, size) => new PhysicalRegion(this, pa, size));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove a virtual region from the range list. This assumes that the lock has been acquired.
|
|
/// </summary>
|
|
/// <param name="region">Region to remove</param>
|
|
internal void RemoveVirtual(VirtualRegion region)
|
|
{
|
|
_virtualRegions.Remove(region);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove a physical region from the range list. This assumes that the lock has been acquired.
|
|
/// </summary>
|
|
/// <param name="region">Region to remove</param>
|
|
internal void RemovePhysical(PhysicalRegion region)
|
|
{
|
|
_physicalRegions.Remove(region);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Obtains a memory tracking handle for the given virtual region, with a specified granularity. This should be disposed when finished with.
|
|
/// </summary>
|
|
/// <param name="address">CPU virtual address of the region</param>
|
|
/// <param name="size">Size of the region</param>
|
|
/// <param name="granularity">Desired granularity of write tracking</param>
|
|
/// <returns>The memory tracking handle</returns>
|
|
public MultiRegionHandle BeginGranularTracking(ulong address, ulong size, ulong granularity)
|
|
{
|
|
(address, size) = PageAlign(address, size);
|
|
|
|
return new MultiRegionHandle(this, address, size, granularity);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Obtains a smart memory tracking handle for the given virtual region, with a specified granularity. This should be disposed when finished with.
|
|
/// </summary>
|
|
/// <param name="address">CPU virtual address of the region</param>
|
|
/// <param name="size">Size of the region</param>
|
|
/// <param name="granularity">Desired granularity of write tracking</param>
|
|
/// <returns>The memory tracking handle</returns>
|
|
public SmartMultiRegionHandle BeginSmartGranularTracking(ulong address, ulong size, ulong granularity)
|
|
{
|
|
(address, size) = PageAlign(address, size);
|
|
|
|
return new SmartMultiRegionHandle(this, address, size, granularity);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Obtains a memory tracking handle for the given virtual region. This should be disposed when finished with.
|
|
/// </summary>
|
|
/// <param name="address">CPU virtual address of the region</param>
|
|
/// <param name="size">Size of the region</param>
|
|
/// <returns>The memory tracking handle</returns>
|
|
public RegionHandle BeginTracking(ulong address, ulong size)
|
|
{
|
|
(address, size) = PageAlign(address, size);
|
|
|
|
lock (TrackingLock)
|
|
{
|
|
RegionHandle handle = new RegionHandle(this, address, size);
|
|
|
|
return handle;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Signal that a physical memory event happened at the given location.
|
|
/// </summary>
|
|
/// <param name="address">Physical address accessed</param>
|
|
/// <param name="write">Whether the region was written to or read</param>
|
|
/// <returns>True if the event triggered any tracking regions, false otherwise</returns>
|
|
public bool PhysicalMemoryEvent(ulong address, bool write)
|
|
{
|
|
// Look up the physical region using the region list.
|
|
// Signal up the chain to relevant handles.
|
|
|
|
lock (TrackingLock)
|
|
{
|
|
var results = _physicalResults;
|
|
int count = _physicalRegions.FindOverlapsNonOverlapping(address, 1, ref results); // TODO: get/use the actual access size?
|
|
|
|
if (count == 0)
|
|
{
|
|
_block.Reprotect(address & ~(ulong)(_pageSize - 1), (ulong)_pageSize, MemoryPermission.ReadAndWrite);
|
|
return false; // We can't handle this - unprotect and return.
|
|
}
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
PhysicalRegion region = results[i];
|
|
region.Signal(address, 1, write);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Signal that a virtual memory event happened at the given location (one byte).
|
|
/// </summary>
|
|
/// <param name="address">Virtual address accessed</param>
|
|
/// <param name="write">Whether the address was written to or read</param>
|
|
/// <returns>True if the event triggered any tracking regions, false otherwise</returns>
|
|
public bool VirtualMemoryEventTracking(ulong address, bool write)
|
|
{
|
|
return VirtualMemoryEvent(address, 1, write);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Signal that a virtual memory event happened at the given location.
|
|
/// </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>
|
|
/// <returns>True if the event triggered any tracking regions, false otherwise</returns>
|
|
public bool VirtualMemoryEvent(ulong address, ulong size, bool write)
|
|
{
|
|
// Look up the virtual region using the region list.
|
|
// Signal up the chain to relevant handles.
|
|
|
|
lock (TrackingLock)
|
|
{
|
|
var results = _virtualResults;
|
|
int count = _virtualRegions.FindOverlapsNonOverlapping(address, size, ref results);
|
|
|
|
if (count == 0)
|
|
{
|
|
_memoryManager.TrackingReprotect(address & ~(ulong)(_pageSize - 1), (ulong)_pageSize, MemoryPermission.ReadAndWrite);
|
|
return false; // We can't handle this - it's probably a real invalid access.
|
|
}
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
VirtualRegion region = results[i];
|
|
region.Signal(address, size, write);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reprotect a given physical region, if enabled. This is protected on the memory block provided during initialization.
|
|
/// </summary>
|
|
/// <param name="region">Region to reprotect</param>
|
|
/// <param name="permission">Memory permission to protect with</param>
|
|
internal void ProtectPhysicalRegion(PhysicalRegion region, MemoryPermission permission)
|
|
{
|
|
if (EnablePhysicalProtection)
|
|
{
|
|
_block.Reprotect(region.Address, region.Size, permission);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reprotect a given virtual region. The virtual memory manager will handle this.
|
|
/// </summary>
|
|
/// <param name="region">Region to reprotect</param>
|
|
/// <param name="permission">Memory permission to protect with</param>
|
|
internal void ProtectVirtualRegion(VirtualRegion region, MemoryPermission permission)
|
|
{
|
|
_memoryManager.TrackingReprotect(region.Address, region.Size, permission);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the number of virtual and physical regions currently being tracked.
|
|
/// Useful for tests and metrics.
|
|
/// </summary>
|
|
/// <returns>The number of virtual regions, and the number of physical regions</returns>
|
|
public (int VirtualCount, int PhysicalCount) GetRegionCounts()
|
|
{
|
|
lock (TrackingLock)
|
|
{
|
|
return (_virtualRegions.Count, _physicalRegions.Count);
|
|
}
|
|
}
|
|
}
|
|
}
|