drashna/ryujinx
1
0
Fork 0
Code Activity Actions

Optimized memory modified check (#538)

Browse source 
* 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 2018-12-12 02:48:54 +01:00 • committed by gdkchan
parent 36e8e074c9
commit 2e143365eb
7 changed files with 84 additions and 409 deletions
Download patch file Download diff file Expand all files Collapse all files

159
Ryujinx.Graphics/Memory/NvGpuVmmCache.cs
View file

@ -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;
}
}
}