The-Homebrew-Cloud/Ryujinx
2
0
Fork 0
mirror of https://github.com/Ryujinx/Ryujinx.git synced 2024-09-19 01:29:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

Query multiple pages at once with GetWriteWatch (#222)

Browse Source 
* Query multiple pages at once with GetWriteWatch

* Allow multiple buffer types to share the same page, aways use the physical address as cache key

* Remove a variable that is no longer needed
This commit is contained in:
gdkchan 2018-07-08 16:55:15 -03:00 committed by GitHub
parent 0f8f40486d
commit 095db47e13
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 145 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
ChocolArm64/Memory/AMemory.cs
View File

@ -33,19 +33,25 @@ namespace ChocolArm64.Memory
private byte* RamPtr; private byte* RamPtr;
private int HostPageSize;
public AMemory() public AMemory()
{ {
Manager = new AMemoryMgr(); Manager = new AMemoryMgr();
Monitors = new Dictionary<int, ArmMonitor>(); Monitors = new Dictionary<int, ArmMonitor>();
IntPtr Size = (IntPtr)AMemoryMgr.RamSize + AMemoryMgr.PageSize;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{ {
Ram = AMemoryWin32.Allocate((IntPtr)AMemoryMgr.RamSize + AMemoryMgr.PageSize); Ram = AMemoryWin32.Allocate(Size);
HostPageSize = AMemoryWin32.GetPageSize(Ram, Size);
} }
else else
{ {
Ram = Marshal.AllocHGlobal((IntPtr)AMemoryMgr.RamSize + AMemoryMgr.PageSize); Ram = Marshal.AllocHGlobal(Size);
} }
RamPtr = (byte*)Ram; RamPtr = (byte*)Ram;
@ -149,49 +155,53 @@ namespace ChocolArm64.Memory
} }
} }
public long GetHostPageSize() public int GetHostPageSize()
{ {
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) return HostPageSize;
{
return AMemoryMgr.PageSize;
}
IntPtr MemAddress = new IntPtr(RamPtr);
IntPtr MemSize = new IntPtr(AMemoryMgr.RamSize);
long PageSize = AMemoryWin32.IsRegionModified(MemAddress, MemSize, Reset: false);
if (PageSize < 1)
{
throw new InvalidOperationException();
}
return PageSize;
} }
public bool IsRegionModified(long Position, long Size) public bool[] IsRegionModified(long Position, long Size)
{ {
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{ {
return true; return null;
} }
long EndPos = Position + Size; long EndPos = Position + Size;
if ((ulong)EndPos < (ulong)Position) if ((ulong)EndPos < (ulong)Position)
{ {
return false; return null;
} }
if ((ulong)EndPos > AMemoryMgr.RamSize) if ((ulong)EndPos > AMemoryMgr.RamSize)
{ {
return false; return null;
} }
IntPtr MemAddress = new IntPtr(RamPtr + Position); IntPtr MemAddress = new IntPtr(RamPtr + Position);
IntPtr MemSize = new IntPtr(Size); IntPtr MemSize = new IntPtr(Size);
return AMemoryWin32.IsRegionModified(MemAddress, MemSize, Reset: true) != 0; int HostPageMask = HostPageSize - 1;
Position &= ~HostPageMask;
Size = EndPos - Position;
IntPtr[] Addresses = new IntPtr[(Size + HostPageMask) / HostPageSize];
AMemoryWin32.IsRegionModified(MemAddress, MemSize, Addresses, out int Count);
bool[] Modified = new bool[Addresses.Length];
for (int Index = 0; Index < Count; Index++)
{
long VA = Addresses[Index].ToInt64() - Ram.ToInt64();
Modified[(VA - Position) / HostPageSize] = true;
}
return Modified;
} }
public sbyte ReadSByte(long Position) public sbyte ReadSByte(long Position)

29
ChocolArm64/Memory/AMemoryWin32.cs
View File

@ -49,7 +49,7 @@ namespace ChocolArm64.Memory
VirtualFree(Address, IntPtr.Zero, MEM_RELEASE); VirtualFree(Address, IntPtr.Zero, MEM_RELEASE);
} }
public unsafe static long IsRegionModified(IntPtr Address, IntPtr Size, bool Reset) public unsafe static int GetPageSize(IntPtr Address, IntPtr Size)
{ {
IntPtr[] Addresses = new IntPtr[1]; IntPtr[] Addresses = new IntPtr[1];
@ -57,17 +57,36 @@ namespace ChocolArm64.Memory
long Granularity; long Granularity;
int Flags = Reset ? WRITE_WATCH_FLAG_RESET : 0;
GetWriteWatch( GetWriteWatch(
Flags, 0,
Address, Address,
Size, Size,
Addresses, Addresses,
&Count, &Count,
&Granularity); &Granularity);
return Count != 0 ? Granularity : 0; return (int)Granularity;
}
public unsafe static void IsRegionModified(
IntPtr Address,
IntPtr Size,
IntPtr[] Addresses,
out int AddrCount)
{
long Count = Addresses.Length;
long Granularity;
GetWriteWatch(
WRITE_WATCH_FLAG_RESET,
Address,
Size,
Addresses,
&Count,
&Granularity);
AddrCount = (int)Count;
} }
} }
} }

32
Ryujinx.HLE/Gpu/Engines/NvGpuEngine3d.cs
View File

@ -464,19 +464,17 @@ namespace Ryujinx.HLE.Gpu.Engines
GalTextureSampler Sampler = TextureFactory.MakeSampler(Gpu, Vmm, TscPosition); GalTextureSampler Sampler = TextureFactory.MakeSampler(Gpu, Vmm, TscPosition);
long TextureAddress = Vmm.ReadInt64(TicPosition + 4) & 0xffffffffffff; long Key = Vmm.ReadInt64(TicPosition + 4) & 0xffffffffffff;
long Key = TextureAddress; Key = Vmm.GetPhysicalAddress(Key);
TextureAddress = Vmm.GetPhysicalAddress(TextureAddress); if (IsFrameBufferPosition(Key))
if (IsFrameBufferPosition(TextureAddress))
{ {
//This texture is a frame buffer texture, //This texture is a frame buffer texture,
//we shouldn't read anything from memory and bind //we shouldn't read anything from memory and bind
//the frame buffer texture instead, since we're not //the frame buffer texture instead, since we're not
//really writing anything to memory. //really writing anything to memory.
Gpu.Renderer.FrameBuffer.BindTexture(TextureAddress, TexIndex); Gpu.Renderer.FrameBuffer.BindTexture(Key, TexIndex);
} }
else else
{ {
@ -544,6 +542,8 @@ namespace Ryujinx.HLE.Gpu.Engines
{ {
long IndexPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.IndexArrayAddress); long IndexPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.IndexArrayAddress);
long IboKey = Vmm.GetPhysicalAddress(IndexPosition);
int IndexEntryFmt = ReadRegister(NvGpuEngine3dReg.IndexArrayFormat); int IndexEntryFmt = ReadRegister(NvGpuEngine3dReg.IndexArrayFormat);
int IndexFirst = ReadRegister(NvGpuEngine3dReg.IndexBatchFirst); int IndexFirst = ReadRegister(NvGpuEngine3dReg.IndexBatchFirst);
int IndexCount = ReadRegister(NvGpuEngine3dReg.IndexBatchCount); int IndexCount = ReadRegister(NvGpuEngine3dReg.IndexBatchCount);
@ -561,16 +561,16 @@ namespace Ryujinx.HLE.Gpu.Engines
{ {
int IbSize = IndexCount * IndexEntrySize; int IbSize = IndexCount * IndexEntrySize;
bool IboCached = Gpu.Renderer.Rasterizer.IsIboCached(IndexPosition, (uint)IbSize); bool IboCached = Gpu.Renderer.Rasterizer.IsIboCached(IboKey, (uint)IbSize);
if (!IboCached || Vmm.IsRegionModified(IndexPosition, (uint)IbSize, NvGpuBufferType.Index)) if (!IboCached || Vmm.IsRegionModified(IboKey, (uint)IbSize, NvGpuBufferType.Index))
{ {
byte[] Data = Vmm.ReadBytes(IndexPosition, (uint)IbSize); byte[] Data = Vmm.ReadBytes(IndexPosition, (uint)IbSize);
Gpu.Renderer.Rasterizer.CreateIbo(IndexPosition, Data); Gpu.Renderer.Rasterizer.CreateIbo(IboKey, Data);
} }
Gpu.Renderer.Rasterizer.SetIndexArray(IndexPosition, IbSize, IndexFormat); Gpu.Renderer.Rasterizer.SetIndexArray(IboKey, IbSize, IndexFormat);
} }
List<GalVertexAttrib>[] Attribs = new List<GalVertexAttrib>[32]; List<GalVertexAttrib>[] Attribs = new List<GalVertexAttrib>[32];
@ -619,20 +619,22 @@ namespace Ryujinx.HLE.Gpu.Engines
continue; continue;
} }
long VboKey = Vmm.GetPhysicalAddress(VertexPosition);
int Stride = Control & 0xfff; int Stride = Control & 0xfff;
long VbSize = (VertexEndPos - VertexPosition) + 1; long VbSize = (VertexEndPos - VertexPosition) + 1;
bool VboCached = Gpu.Renderer.Rasterizer.IsVboCached(VertexPosition, VbSize); bool VboCached = Gpu.Renderer.Rasterizer.IsVboCached(VboKey, VbSize);
if (!VboCached || Vmm.IsRegionModified(VertexPosition, VbSize, NvGpuBufferType.Vertex)) if (!VboCached || Vmm.IsRegionModified(VboKey, VbSize, NvGpuBufferType.Vertex))
{ {
byte[] Data = Vmm.ReadBytes(VertexPosition, VbSize); byte[] Data = Vmm.ReadBytes(VertexPosition, VbSize);
Gpu.Renderer.Rasterizer.CreateVbo(VertexPosition, Data); Gpu.Renderer.Rasterizer.CreateVbo(VboKey, Data);
} }
Gpu.Renderer.Rasterizer.SetVertexArray(Index, Stride, VertexPosition, Attribs[Index].ToArray()); Gpu.Renderer.Rasterizer.SetVertexArray(Index, Stride, VboKey, Attribs[Index].ToArray());
} }
GalPrimitiveType PrimType = (GalPrimitiveType)(PrimCtrl & 0xffff); GalPrimitiveType PrimType = (GalPrimitiveType)(PrimCtrl & 0xffff);
@ -641,7 +643,7 @@ namespace Ryujinx.HLE.Gpu.Engines
{ {
int VertexBase = ReadRegister(NvGpuEngine3dReg.VertexArrayElemBase); int VertexBase = ReadRegister(NvGpuEngine3dReg.VertexArrayElemBase);
Gpu.Renderer.Rasterizer.DrawElements(IndexPosition, IndexFirst, VertexBase, PrimType); Gpu.Renderer.Rasterizer.DrawElements(IboKey, IndexFirst, VertexBase, PrimType);
} }
else else
{ {

3
Ryujinx.HLE/Gpu/Memory/NvGpuBufferType.cs
View File

@ -4,6 +4,7 @@ namespace Ryujinx.HLE.Gpu.Memory
{ {
Index, Index,
Vertex, Vertex,
Texture Texture,
Count
} }
} }

6
Ryujinx.HLE/Gpu/Memory/NvGpuVmm.cs
View File

@ -274,11 +274,9 @@ namespace Ryujinx.HLE.Gpu.Memory
PageTable[L0][L1] = TgtAddr; PageTable[L0][L1] = TgtAddr;
} }
public bool IsRegionModified(long Position, long Size, NvGpuBufferType BufferType) public bool IsRegionModified(long PA, long Size, NvGpuBufferType BufferType)
{ {
long PA = GetPhysicalAddress(Position); return Cache.IsRegionModified(Memory, BufferType, PA, Size);
return Cache.IsRegionModified(Memory, BufferType, Position, PA, Size);
} }
public byte ReadByte(long Position) public byte ReadByte(long Position)

120
Ryujinx.HLE/Gpu/Memory/NvGpuVmmCache.cs
View File

@ -11,43 +11,53 @@ namespace Ryujinx.HLE.Gpu.Memory
private class CachedPage private class CachedPage
{ {
private List<(long Start, long End)> Regions; private struct Range
{
public long Start;
public long End;
public Range(long Start, long End)
{
this.Start = Start;
this.End = End;
}
}
private List<Range>[] Regions;
public LinkedListNode<long> Node { get; set; } public LinkedListNode<long> Node { get; set; }
public int Count => Regions.Count;
public int Timestamp { get; private set; } public int Timestamp { get; private set; }
public long PABase { get; private set; } public CachedPage()
public NvGpuBufferType BufferType { get; private set; }
public CachedPage(long PABase, NvGpuBufferType BufferType)
{ {
this.PABase = PABase; Regions = new List<Range>[(int)NvGpuBufferType.Count];
this.BufferType = BufferType;
Regions = new List<(long, long)>(); for (int Index = 0; Index < Regions.Length; Index++)
{
Regions[Index] = new List<Range>();
}
} }
public bool AddRange(long Start, long End) public bool AddRange(long Start, long End, NvGpuBufferType BufferType)
{ {
for (int Index = 0; Index < Regions.Count; Index++) List<Range> BtRegions = Regions[(int)BufferType];
{
(long RgStart, long RgEnd) = Regions[Index];
if (Start >= RgStart && End <= RgEnd) for (int Index = 0; Index < BtRegions.Count; Index++)
{
Range Rg = BtRegions[Index];
if (Start >= Rg.Start && End <= Rg.End)
{ {
return false; return false;
} }
if (Start <= RgEnd && RgStart <= End) if (Start <= Rg.End && Rg.Start <= End)
{ {
long MinStart = Math.Min(RgStart, Start); long MinStart = Math.Min(Rg.Start, Start);
long MaxEnd = Math.Max(RgEnd, End); long MaxEnd = Math.Max(Rg.End, End);
Regions[Index] = (MinStart, MaxEnd); BtRegions[Index] = new Range(MinStart, MaxEnd);
Timestamp = Environment.TickCount; Timestamp = Environment.TickCount;
@ -55,12 +65,24 @@ namespace Ryujinx.HLE.Gpu.Memory
} }
} }
Regions.Add((Start, End)); BtRegions.Add(new Range(Start, End));
Timestamp = Environment.TickCount; Timestamp = Environment.TickCount;
return true; return true;
} }
public int GetTotalCount()
{
int Count = 0;
for (int Index = 0; Index < Regions.Length; Index++)
{
Count += Regions[Index].Count;
}
return Count;
}
} }
private Dictionary<long, CachedPage> Cache; private Dictionary<long, CachedPage> Cache;
@ -76,71 +98,61 @@ namespace Ryujinx.HLE.Gpu.Memory
SortedCache = new LinkedList<long>(); SortedCache = new LinkedList<long>();
} }
public bool IsRegionModified( public bool IsRegionModified(AMemory Memory, NvGpuBufferType BufferType, long PA, long Size)
AMemory Memory,
NvGpuBufferType BufferType,
long VA,
long PA,
long Size)
{ {
bool[] Modified = Memory.IsRegionModified(PA, Size);
if (Modified == null)
{
return true;
}
ClearCachedPagesIfNeeded(); ClearCachedPagesIfNeeded();
long PageSize = Memory.GetHostPageSize(); long PageSize = Memory.GetHostPageSize();
long Mask = PageSize - 1; long Mask = PageSize - 1;
long VAEnd = VA + Size;
long PAEnd = PA + Size; long PAEnd = PA + Size;
bool RegMod = false; bool RegMod = false;
while (VA < VAEnd) int Index = 0;
{
long Key = VA & ~Mask; while (PA < PAEnd)
long PABase = PA & ~Mask; {
long Key = PA & ~Mask;
long VAPgEnd = Math.Min((VA + PageSize) & ~Mask, VAEnd);
long PAPgEnd = Math.Min((PA + PageSize) & ~Mask, PAEnd); long PAPgEnd = Math.Min((PA + PageSize) & ~Mask, PAEnd);
bool IsCached = Cache.TryGetValue(Key, out CachedPage Cp); bool IsCached = Cache.TryGetValue(Key, out CachedPage Cp);
bool PgReset = false; if (IsCached)
if (!IsCached)
{ {
Cp = new CachedPage(PABase, BufferType); CpCount -= Cp.GetTotalCount();
Cache.Add(Key, Cp); SortedCache.Remove(Cp.Node);
} }
else else
{ {
CpCount -= Cp.Count; Cp = new CachedPage();
SortedCache.Remove(Cp.Node); Cache.Add(Key, Cp);
if (Cp.PABase != PABase ||
Cp.BufferType != BufferType)
{
PgReset = true;
}
} }
PgReset |= Memory.IsRegionModified(PA, PAPgEnd - PA) && IsCached; if (Modified[Index++] && IsCached)
if (PgReset)
{ {
Cp = new CachedPage(PABase, BufferType); Cp = new CachedPage();
Cache[Key] = Cp; Cache[Key] = Cp;
} }
Cp.Node = SortedCache.AddLast(Key); Cp.Node = SortedCache.AddLast(Key);
RegMod |= Cp.AddRange(VA, VAPgEnd); RegMod |= Cp.AddRange(PA, PAPgEnd, BufferType);
CpCount += Cp.Count; CpCount += Cp.GetTotalCount();
VA = VAPgEnd;
PA = PAPgEnd; PA = PAPgEnd;
} }
@ -169,7 +181,7 @@ namespace Ryujinx.HLE.Gpu.Memory
Cache.Remove(Key); Cache.Remove(Key);
CpCount -= Cp.Count; CpCount -= Cp.GetTotalCount();
TimeDelta = RingDelta(Cp.Timestamp, Timestamp); TimeDelta = RingDelta(Cp.Timestamp, Timestamp);
} }