mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-09-10 17:58:50 +02:00
237 lines
8.1 KiB
C#
237 lines
8.1 KiB
C#
|
using System;
|
|||
|
using System.Runtime.CompilerServices;
|
|||
|
|
|||
|
namespace Ryujinx.Memory.Tracking
|
|||
|
{
|
|||
|
/// <summary>
|
|||
|
/// A MultiRegionHandle that attempts to segment a region's handles into the regions requested
|
|||
|
/// to avoid iterating over granular chunks for canonically large regions.
|
|||
|
/// If minimum granularity is to be expected, use MultiRegionHandle.
|
|||
|
/// </summary>
|
|||
|
public class SmartMultiRegionHandle : IMultiRegionHandle
|
|||
|
{
|
|||
|
/// <summary>
|
|||
|
/// A list of region handles starting at each granularity size increment.
|
|||
|
/// </summary>
|
|||
|
private readonly RegionHandle[] _handles;
|
|||
|
private readonly ulong _address;
|
|||
|
private readonly ulong _granularity;
|
|||
|
private readonly ulong _size;
|
|||
|
private MemoryTracking _tracking;
|
|||
|
|
|||
|
public bool Dirty { get; private set; } = true;
|
|||
|
|
|||
|
internal SmartMultiRegionHandle(MemoryTracking tracking, ulong address, ulong size, ulong granularity)
|
|||
|
{
|
|||
|
// For this multi-region handle, the handle list starts empty.
|
|||
|
// As regions are queried, they are added to the _handles array at their start index.
|
|||
|
// When a region being added overlaps another, the existing region is split.
|
|||
|
// A query can therefore scan multiple regions, though with no overlaps they can cover a large area.
|
|||
|
|
|||
|
_tracking = tracking;
|
|||
|
_handles = new RegionHandle[size / granularity];
|
|||
|
_granularity = granularity;
|
|||
|
|
|||
|
_address = address;
|
|||
|
_size = size;
|
|||
|
}
|
|||
|
|
|||
|
public void SignalWrite()
|
|||
|
{
|
|||
|
Dirty = true;
|
|||
|
}
|
|||
|
|
|||
|
public void QueryModified(Action<ulong, ulong> modifiedAction)
|
|||
|
{
|
|||
|
if (!Dirty)
|
|||
|
{
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
Dirty = false;
|
|||
|
|
|||
|
QueryModified(_address, _size, modifiedAction);
|
|||
|
}
|
|||
|
|
|||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|||
|
private ulong HandlesToBytes(int handles)
|
|||
|
{
|
|||
|
return (ulong)handles * _granularity;
|
|||
|
}
|
|||
|
|
|||
|
private void SplitHandle(int handleIndex, int splitIndex)
|
|||
|
{
|
|||
|
RegionHandle handle = _handles[handleIndex];
|
|||
|
ulong address = _address + HandlesToBytes(handleIndex);
|
|||
|
ulong size = HandlesToBytes(splitIndex - handleIndex);
|
|||
|
|
|||
|
// First, the target handle must be removed. Its data can still be used to determine the new handles.
|
|||
|
handle.Dispose();
|
|||
|
|
|||
|
RegionHandle splitLow = _tracking.BeginTracking(address, size);
|
|||
|
splitLow.Parent = this;
|
|||
|
_handles[handleIndex] = splitLow;
|
|||
|
|
|||
|
RegionHandle splitHigh = _tracking.BeginTracking(address + size, handle.Size - size);
|
|||
|
splitHigh.Parent = this;
|
|||
|
_handles[splitIndex] = splitHigh;
|
|||
|
}
|
|||
|
|
|||
|
private void CreateHandle(int startHandle, int lastHandle)
|
|||
|
{
|
|||
|
ulong startAddress = _address + HandlesToBytes(startHandle);
|
|||
|
|
|||
|
// Scan for the first handle before us. If it's overlapping us, it must be split.
|
|||
|
for (int i = startHandle - 1; i >= 0; i--)
|
|||
|
{
|
|||
|
RegionHandle handle = _handles[i];
|
|||
|
if (handle != null)
|
|||
|
{
|
|||
|
if (handle.EndAddress > startAddress)
|
|||
|
{
|
|||
|
SplitHandle(i, startHandle);
|
|||
|
return; // The remainer of this handle should be filled in later on.
|
|||
|
}
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// Scan for handles after us. We should create a handle that goes up to this handle's start point, if present.
|
|||
|
for (int i = startHandle + 1; i <= lastHandle; i++)
|
|||
|
{
|
|||
|
RegionHandle handle = _handles[i];
|
|||
|
if (handle != null)
|
|||
|
{
|
|||
|
// Fill up to the found handle.
|
|||
|
handle = _tracking.BeginTracking(startAddress, HandlesToBytes(i - startHandle));
|
|||
|
handle.Parent = this;
|
|||
|
_handles[startHandle] = handle;
|
|||
|
return;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// Can fill the whole range.
|
|||
|
_handles[startHandle] = _tracking.BeginTracking(startAddress, HandlesToBytes(1 + lastHandle - startHandle));
|
|||
|
_handles[startHandle].Parent = this;
|
|||
|
}
|
|||
|
|
|||
|
public void QueryModified(ulong address, ulong size, Action<ulong, ulong> modifiedAction)
|
|||
|
{
|
|||
|
int startHandle = (int)((address - _address) / _granularity);
|
|||
|
int lastHandle = (int)((address + (size - 1) - _address) / _granularity);
|
|||
|
|
|||
|
ulong rgStart = _address + (ulong)startHandle * _granularity;
|
|||
|
ulong rgSize = 0;
|
|||
|
|
|||
|
ulong endAddress = _address + ((ulong)lastHandle + 1) * _granularity;
|
|||
|
|
|||
|
int i = startHandle;
|
|||
|
|
|||
|
while (i <= lastHandle)
|
|||
|
{
|
|||
|
RegionHandle handle = _handles[i];
|
|||
|
if (handle == null)
|
|||
|
{
|
|||
|
// Missing handle. A new handle must be created.
|
|||
|
CreateHandle(i, lastHandle);
|
|||
|
handle = _handles[i];
|
|||
|
}
|
|||
|
|
|||
|
if (handle.EndAddress > endAddress)
|
|||
|
{
|
|||
|
// End address of handle is beyond the end of the search. Force a split.
|
|||
|
SplitHandle(i, lastHandle + 1);
|
|||
|
handle = _handles[i];
|
|||
|
}
|
|||
|
|
|||
|
if (handle.Dirty)
|
|||
|
{
|
|||
|
rgSize += handle.Size;
|
|||
|
handle.Reprotect();
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
// Submit the region scanned so far as dirty
|
|||
|
if (rgSize != 0)
|
|||
|
{
|
|||
|
modifiedAction(rgStart, rgSize);
|
|||
|
rgSize = 0;
|
|||
|
}
|
|||
|
rgStart = handle.EndAddress;
|
|||
|
}
|
|||
|
|
|||
|
i += (int)(handle.Size / _granularity);
|
|||
|
}
|
|||
|
|
|||
|
if (rgSize != 0)
|
|||
|
{
|
|||
|
modifiedAction(rgStart, rgSize);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
public void QueryModified(ulong address, ulong size, Action<ulong, ulong> modifiedAction, int sequenceNumber)
|
|||
|
{
|
|||
|
int startHandle = (int)((address - _address) / _granularity);
|
|||
|
int lastHandle = (int)((address + (size - 1) - _address) / _granularity);
|
|||
|
|
|||
|
ulong rgStart = _address + (ulong)startHandle * _granularity;
|
|||
|
ulong rgSize = 0;
|
|||
|
|
|||
|
ulong endAddress = _address + ((ulong)lastHandle + 1) * _granularity;
|
|||
|
|
|||
|
int i = startHandle;
|
|||
|
|
|||
|
while (i <= lastHandle)
|
|||
|
{
|
|||
|
RegionHandle handle = _handles[i];
|
|||
|
if (handle == null)
|
|||
|
{
|
|||
|
// Missing handle. A new handle must be created.
|
|||
|
CreateHandle(i, lastHandle);
|
|||
|
handle = _handles[i];
|
|||
|
}
|
|||
|
|
|||
|
if (handle.EndAddress > endAddress)
|
|||
|
{
|
|||
|
// End address of handle is beyond the end of the search. Force a split.
|
|||
|
SplitHandle(i, lastHandle + 1);
|
|||
|
handle = _handles[i];
|
|||
|
}
|
|||
|
|
|||
|
if (handle.Dirty && sequenceNumber != handle.SequenceNumber)
|
|||
|
{
|
|||
|
rgSize += handle.Size;
|
|||
|
handle.Reprotect();
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
// Submit the region scanned so far as dirty
|
|||
|
if (rgSize != 0)
|
|||
|
{
|
|||
|
modifiedAction(rgStart, rgSize);
|
|||
|
rgSize = 0;
|
|||
|
}
|
|||
|
rgStart = handle.EndAddress;
|
|||
|
}
|
|||
|
|
|||
|
handle.SequenceNumber = sequenceNumber;
|
|||
|
|
|||
|
i += (int)(handle.Size / _granularity);
|
|||
|
}
|
|||
|
|
|||
|
if (rgSize != 0)
|
|||
|
{
|
|||
|
modifiedAction(rgStart, rgSize);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
public void Dispose()
|
|||
|
{
|
|||
|
foreach (var handle in _handles)
|
|||
|
{
|
|||
|
handle?.Dispose();
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|