Optimized memory modified check (#538)
* Optimized memory modified check This was initially in some cases more expensive than plainly sending the data. Now it should have way better performance. * Small refactoring * renamed InvalidAccessEventArgs * Renamed PtPageBits * Removed ValueRange(set) They are currently unused and won't be likely to be used in the near future
This commit is contained in:
Roderick Sieben
gdkchan
parent
36e8e074c9
commit
2e143365eb
7 changed files with 84 additions and 409 deletions
|
|
@ -36,7 +36,7 @@ namespace Ryujinx.Graphics.Memory
|
|||
{
|
||||
this.Memory = Memory;
|
||||
|
||||
Cache = new NvGpuVmmCache();
|
||||
Cache = new NvGpuVmmCache(Memory);
|
||||
|
||||
PageTable = new long[PTLvl0Size][];
|
||||
}
|
||||
|
|
@ -262,7 +262,7 @@ namespace Ryujinx.Graphics.Memory
|
|||
|
||||
public bool IsRegionModified(long PA, long Size, NvGpuBufferType BufferType)
|
||||
{
|
||||
return Cache.IsRegionModified(Memory, BufferType, PA, Size);
|
||||
return Cache.IsRegionModified(PA, Size, BufferType);
|
||||
}
|
||||
|
||||
public bool TryGetHostAddress(long Position, long Size, out IntPtr Ptr)
|
||||
|
|
|
|||
|
|
@ -1,130 +1,83 @@
|
|||
using ChocolArm64.Events;
|
||||
using ChocolArm64.Memory;
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
|
||||
namespace Ryujinx.Graphics.Memory
|
||||
{
|
||||
class NvGpuVmmCache
|
||||
{
|
||||
private struct CachedResource
|
||||
private const int PageBits = MemoryManager.PageBits;
|
||||
|
||||
private const long PageSize = MemoryManager.PageSize;
|
||||
private const long PageMask = MemoryManager.PageMask;
|
||||
|
||||
private ConcurrentDictionary<long, int>[] CachedPages;
|
||||
|
||||
private MemoryManager _memory;
|
||||
|
||||
public NvGpuVmmCache(MemoryManager memory)
|
||||
{
|
||||
public long Key;
|
||||
public int Mask;
|
||||
_memory = memory;
|
||||
|
||||
public CachedResource(long Key, int Mask)
|
||||
{
|
||||
this.Key = Key;
|
||||
this.Mask = Mask;
|
||||
}
|
||||
_memory.ObservedAccess += MemoryAccessHandler;
|
||||
|
||||
public override int GetHashCode()
|
||||
{
|
||||
return (int)(Key * 23 + Mask);
|
||||
}
|
||||
|
||||
public override bool Equals(object obj)
|
||||
{
|
||||
return obj is CachedResource Cached && Equals(Cached);
|
||||
}
|
||||
|
||||
public bool Equals(CachedResource other)
|
||||
{
|
||||
return Key == other.Key && Mask == other.Mask;
|
||||
}
|
||||
CachedPages = new ConcurrentDictionary<long, int>[1 << 20];
|
||||
}
|
||||
|
||||
private ValueRangeSet<CachedResource> CachedRanges;
|
||||
|
||||
public NvGpuVmmCache()
|
||||
private void MemoryAccessHandler(object sender, MemoryAccessEventArgs e)
|
||||
{
|
||||
CachedRanges = new ValueRangeSet<CachedResource>();
|
||||
long pa = _memory.GetPhysicalAddress(e.Position);
|
||||
|
||||
CachedPages[pa >> PageBits]?.Clear();
|
||||
}
|
||||
|
||||
public bool IsRegionModified(MemoryManager Memory, NvGpuBufferType BufferType, long Start, long Size)
|
||||
public bool IsRegionModified(long position, long size, NvGpuBufferType bufferType)
|
||||
{
|
||||
(bool[] Modified, long ModifiedCount) = Memory.IsRegionModified(Start, Size);
|
||||
long pa = _memory.GetPhysicalAddress(position);
|
||||
|
||||
//Remove all modified ranges.
|
||||
int Index = 0;
|
||||
long addr = pa;
|
||||
|
||||
long Position = Start & ~NvGpuVmm.PageMask;
|
||||
long endAddr = (addr + size + PageMask) & ~PageMask;
|
||||
|
||||
while (ModifiedCount > 0)
|
||||
int newBuffMask = 1 << (int)bufferType;
|
||||
|
||||
_memory.StartObservingRegion(position, size);
|
||||
|
||||
long cachedPagesCount = 0;
|
||||
|
||||
while (addr < endAddr)
|
||||
{
|
||||
if (Modified[Index++])
|
||||
{
|
||||
CachedRanges.Remove(new ValueRange<CachedResource>(Position, Position + NvGpuVmm.PageSize));
|
||||
long page = addr >> PageBits;
|
||||
|
||||
ModifiedCount--;
|
||||
ConcurrentDictionary<long, int> dictionary = CachedPages[page];
|
||||
|
||||
if (dictionary == null)
|
||||
{
|
||||
dictionary = new ConcurrentDictionary<long, int>();
|
||||
|
||||
CachedPages[page] = dictionary;
|
||||
}
|
||||
|
||||
Position += NvGpuVmm.PageSize;
|
||||
if (dictionary.TryGetValue(pa, out int currBuffMask))
|
||||
{
|
||||
if ((currBuffMask & newBuffMask) != 0)
|
||||
{
|
||||
cachedPagesCount++;
|
||||
}
|
||||
else
|
||||
{
|
||||
dictionary[pa] |= newBuffMask;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
dictionary[pa] = newBuffMask;
|
||||
}
|
||||
|
||||
addr += PageSize;
|
||||
}
|
||||
|
||||
//Mask has the bit set for the current resource type.
|
||||
//If the region is not yet present on the list, then a new ValueRange
|
||||
//is directly added with the current resource type as the only bit set.
|
||||
//Otherwise, it just sets the bit for this new resource type on the current mask.
|
||||
//The physical address of the resource is used as key, those keys are used to keep
|
||||
//track of resources that are already on the cache. A resource may be inside another
|
||||
//resource, and in this case we should return true if the "sub-resource" was not
|
||||
//yet cached.
|
||||
int Mask = 1 << (int)BufferType;
|
||||
|
||||
CachedResource NewCachedValue = new CachedResource(Start, Mask);
|
||||
|
||||
ValueRange<CachedResource> NewCached = new ValueRange<CachedResource>(Start, Start + Size);
|
||||
|
||||
ValueRange<CachedResource>[] Ranges = CachedRanges.GetAllIntersections(NewCached);
|
||||
|
||||
bool IsKeyCached = Ranges.Length > 0 && Ranges[0].Value.Key == Start;
|
||||
|
||||
long LastEnd = NewCached.Start;
|
||||
|
||||
long Coverage = 0;
|
||||
|
||||
for (Index = 0; Index < Ranges.Length; Index++)
|
||||
{
|
||||
ValueRange<CachedResource> Current = Ranges[Index];
|
||||
|
||||
CachedResource Cached = Current.Value;
|
||||
|
||||
long RgStart = Math.Max(Current.Start, NewCached.Start);
|
||||
long RgEnd = Math.Min(Current.End, NewCached.End);
|
||||
|
||||
if ((Cached.Mask & Mask) != 0)
|
||||
{
|
||||
Coverage += RgEnd - RgStart;
|
||||
}
|
||||
|
||||
//Highest key value has priority, this prevents larger resources
|
||||
//for completely invalidating smaller ones on the cache. For example,
|
||||
//consider that a resource in the range [100, 200) was added, and then
|
||||
//another one in the range [50, 200). We prevent the new resource from
|
||||
//completely replacing the old one by spliting it like this:
|
||||
//New resource key is added at [50, 100), old key is still present at [100, 200).
|
||||
if (Cached.Key < Start)
|
||||
{
|
||||
Cached.Key = Start;
|
||||
}
|
||||
|
||||
Cached.Mask |= Mask;
|
||||
|
||||
CachedRanges.Add(new ValueRange<CachedResource>(RgStart, RgEnd, Cached));
|
||||
|
||||
if (RgStart > LastEnd)
|
||||
{
|
||||
CachedRanges.Add(new ValueRange<CachedResource>(LastEnd, RgStart, NewCachedValue));
|
||||
}
|
||||
|
||||
LastEnd = RgEnd;
|
||||
}
|
||||
|
||||
if (LastEnd < NewCached.End)
|
||||
{
|
||||
CachedRanges.Add(new ValueRange<CachedResource>(LastEnd, NewCached.End, NewCachedValue));
|
||||
}
|
||||
|
||||
return !IsKeyCached || Coverage != Size;
|
||||
return cachedPagesCount != (endAddr - pa + PageMask) >> PageBits;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
namespace Ryujinx.Graphics
|
||||
{
|
||||
struct ValueRange<T>
|
||||
{
|
||||
public long Start { get; private set; }
|
||||
public long End { get; private set; }
|
||||
|
||||
public T Value { get; set; }
|
||||
|
||||
public ValueRange(long Start, long End, T Value = default(T))
|
||||
{
|
||||
this.Start = Start;
|
||||
this.End = End;
|
||||
this.Value = Value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,234 +0,0 @@
|
|||
using System.Collections.Generic;
|
||||
|
||||
namespace Ryujinx.Graphics
|
||||
{
|
||||
class ValueRangeSet<T>
|
||||
{
|
||||
private List<ValueRange<T>> Ranges;
|
||||
|
||||
public ValueRangeSet()
|
||||
{
|
||||
Ranges = new List<ValueRange<T>>();
|
||||
}
|
||||
|
||||
public void Add(ValueRange<T> Range)
|
||||
{
|
||||
if (Range.End <= Range.Start)
|
||||
{
|
||||
//Empty or invalid range, do nothing.
|
||||
return;
|
||||
}
|
||||
|
||||
int First = BinarySearchFirstIntersection(Range);
|
||||
|
||||
if (First == -1)
|
||||
{
|
||||
//No intersections case.
|
||||
//Find first greater than range (after the current one).
|
||||
//If found, add before, otherwise add to the end of the list.
|
||||
int GtIndex = BinarySearchGt(Range);
|
||||
|
||||
if (GtIndex != -1)
|
||||
{
|
||||
Ranges.Insert(GtIndex, Range);
|
||||
}
|
||||
else
|
||||
{
|
||||
Ranges.Add(Range);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
(int Start, int End) = GetAllIntersectionRanges(Range, First);
|
||||
|
||||
ValueRange<T> Prev = Ranges[Start];
|
||||
ValueRange<T> Next = Ranges[End];
|
||||
|
||||
Ranges.RemoveRange(Start, (End - Start) + 1);
|
||||
|
||||
InsertNextNeighbour(Start, Range, Next);
|
||||
|
||||
int NewIndex = Start;
|
||||
|
||||
Ranges.Insert(Start, Range);
|
||||
|
||||
InsertPrevNeighbour(Start, Range, Prev);
|
||||
|
||||
//Try merging neighbours if the value is equal.
|
||||
if (NewIndex > 0)
|
||||
{
|
||||
Prev = Ranges[NewIndex - 1];
|
||||
|
||||
if (Prev.End == Range.Start && CompareValues(Prev, Range))
|
||||
{
|
||||
Ranges.RemoveAt(--NewIndex);
|
||||
|
||||
Ranges[NewIndex] = new ValueRange<T>(Prev.Start, Range.End, Range.Value);
|
||||
}
|
||||
}
|
||||
|
||||
if (NewIndex < Ranges.Count - 1)
|
||||
{
|
||||
Next = Ranges[NewIndex + 1];
|
||||
|
||||
if (Next.Start == Range.End && CompareValues(Next, Range))
|
||||
{
|
||||
Ranges.RemoveAt(NewIndex + 1);
|
||||
|
||||
Ranges[NewIndex] = new ValueRange<T>(Ranges[NewIndex].Start, Next.End, Range.Value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private bool CompareValues(ValueRange<T> LHS, ValueRange<T> RHS)
|
||||
{
|
||||
return LHS.Value?.Equals(RHS.Value) ?? RHS.Value == null;
|
||||
}
|
||||
|
||||
public void Remove(ValueRange<T> Range)
|
||||
{
|
||||
int First = BinarySearchFirstIntersection(Range);
|
||||
|
||||
if (First == -1)
|
||||
{
|
||||
//Nothing to remove.
|
||||
return;
|
||||
}
|
||||
|
||||
(int Start, int End) = GetAllIntersectionRanges(Range, First);
|
||||
|
||||
ValueRange<T> Prev = Ranges[Start];
|
||||
ValueRange<T> Next = Ranges[End];
|
||||
|
||||
Ranges.RemoveRange(Start, (End - Start) + 1);
|
||||
|
||||
InsertNextNeighbour(Start, Range, Next);
|
||||
InsertPrevNeighbour(Start, Range, Prev);
|
||||
}
|
||||
|
||||
private void InsertNextNeighbour(int Index, ValueRange<T> Range, ValueRange<T> Next)
|
||||
{
|
||||
//Split last intersection (ordered by Start) if necessary.
|
||||
if (Range.End < Next.End)
|
||||
{
|
||||
InsertNewRange(Index, Range.End, Next.End, Next.Value);
|
||||
}
|
||||
}
|
||||
|
||||
private void InsertPrevNeighbour(int Index, ValueRange<T> Range, ValueRange<T> Prev)
|
||||
{
|
||||
//Split first intersection (ordered by Start) if necessary.
|
||||
if (Range.Start > Prev.Start)
|
||||
{
|
||||
InsertNewRange(Index, Prev.Start, Range.Start, Prev.Value);
|
||||
}
|
||||
}
|
||||
|
||||
private void InsertNewRange(int Index, long Start, long End, T Value)
|
||||
{
|
||||
Ranges.Insert(Index, new ValueRange<T>(Start, End, Value));
|
||||
}
|
||||
|
||||
public ValueRange<T>[] GetAllIntersections(ValueRange<T> Range)
|
||||
{
|
||||
int First = BinarySearchFirstIntersection(Range);
|
||||
|
||||
if (First == -1)
|
||||
{
|
||||
return new ValueRange<T>[0];
|
||||
}
|
||||
|
||||
(int Start, int End) = GetAllIntersectionRanges(Range, First);
|
||||
|
||||
return Ranges.GetRange(Start, (End - Start) + 1).ToArray();
|
||||
}
|
||||
|
||||
private (int Start, int End) GetAllIntersectionRanges(ValueRange<T> Range, int BaseIndex)
|
||||
{
|
||||
int Start = BaseIndex;
|
||||
int End = BaseIndex;
|
||||
|
||||
while (Start > 0 && Intersects(Range, Ranges[Start - 1]))
|
||||
{
|
||||
Start--;
|
||||
}
|
||||
|
||||
while (End < Ranges.Count - 1 && Intersects(Range, Ranges[End + 1]))
|
||||
{
|
||||
End++;
|
||||
}
|
||||
|
||||
return (Start, End);
|
||||
}
|
||||
|
||||
private int BinarySearchFirstIntersection(ValueRange<T> Range)
|
||||
{
|
||||
int Left = 0;
|
||||
int Right = Ranges.Count - 1;
|
||||
|
||||
while (Left <= Right)
|
||||
{
|
||||
int Size = Right - Left;
|
||||
|
||||
int Middle = Left + (Size >> 1);
|
||||
|
||||
ValueRange<T> Current = Ranges[Middle];
|
||||
|
||||
if (Intersects(Range, Current))
|
||||
{
|
||||
return Middle;
|
||||
}
|
||||
|
||||
if (Range.Start < Current.Start)
|
||||
{
|
||||
Right = Middle - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
Left = Middle + 1;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
private int BinarySearchGt(ValueRange<T> Range)
|
||||
{
|
||||
int GtIndex = -1;
|
||||
|
||||
int Left = 0;
|
||||
int Right = Ranges.Count - 1;
|
||||
|
||||
while (Left <= Right)
|
||||
{
|
||||
int Size = Right - Left;
|
||||
|
||||
int Middle = Left + (Size >> 1);
|
||||
|
||||
ValueRange<T> Current = Ranges[Middle];
|
||||
|
||||
if (Range.Start < Current.Start)
|
||||
{
|
||||
Right = Middle - 1;
|
||||
|
||||
if (GtIndex == -1 || Current.Start < Ranges[GtIndex].Start)
|
||||
{
|
||||
GtIndex = Middle;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Left = Middle + 1;
|
||||
}
|
||||
}
|
||||
|
||||
return GtIndex;
|
||||
}
|
||||
|
||||
private bool Intersects(ValueRange<T> LHS, ValueRange<T> RHS)
|
||||
{
|
||||
return LHS.Start < RHS.End && RHS.Start < LHS.End;
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue