Query multiple pages at once with GetWriteWatch

ChocolArm64/Memory/AMemory.cs

@@ -33,19 +33,25 @@ namespace ChocolArm64.Memory
 
         private byte* RamPtr;
 
+        private int HostPageSize;
+
         public AMemory()
         {
             Manager = new AMemoryMgr();
 
             Monitors = new Dictionary<int, ArmMonitor>();
 
+            IntPtr Size = (IntPtr)AMemoryMgr.RamSize + AMemoryMgr.PageSize;
+
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
-                Ram = AMemoryWin32.Allocate((IntPtr)AMemoryMgr.RamSize + AMemoryMgr.PageSize);
+                Ram = AMemoryWin32.Allocate(Size);
+
+                HostPageSize = AMemoryWin32.GetPageSize(Ram, Size);
             }
             else
             {
-                Ram = Marshal.AllocHGlobal((IntPtr)AMemoryMgr.RamSize + AMemoryMgr.PageSize);
+                Ram = Marshal.AllocHGlobal(Size);
             }
 
             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))
             {
-                return true;
+                return null;
             }
 
             long EndPos = Position + Size;
 
             if ((ulong)EndPos < (ulong)Position)
             {
-                return false;
+                return null;
             }
 
             if ((ulong)EndPos > AMemoryMgr.RamSize)
             {
-                return false;
+                return null;
             }
 
             IntPtr MemAddress = new IntPtr(RamPtr + Position);
             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)

ChocolArm64/Memory/AMemoryWin32.cs

@@ -49,7 +49,7 @@ namespace ChocolArm64.Memory
             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];
 
@@ -57,17 +57,36 @@ namespace ChocolArm64.Memory
 
             long Granularity;
 
-            int Flags = Reset ? WRITE_WATCH_FLAG_RESET : 0;
-
             GetWriteWatch(
-                Flags,
+                0,
                 Address,
                 Size,
                 Addresses,
                 &Count,
                 &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;
         }
     }
 }

Ryujinx.HLE/Gpu/Memory/NvGpuVmmCache.cs

@@ -83,6 +83,13 @@ namespace Ryujinx.HLE.Gpu.Memory
             long            PA,
             long            Size)
         {
+            bool[] Modified = Memory.IsRegionModified(PA, Size);
+
+            if (Modified == null)
+            {
+                return true;
+            }
+
             ClearCachedPagesIfNeeded();
 
             long PageSize = Memory.GetHostPageSize();
@@ -94,6 +101,8 @@ namespace Ryujinx.HLE.Gpu.Memory
 
             bool RegMod = false;
 
+            int Index = 0;
+
             while (VA < VAEnd)
             {
                 long Key    = VA & ~Mask;
@@ -118,14 +127,13 @@ namespace Ryujinx.HLE.Gpu.Memory
 
                     SortedCache.Remove(Cp.Node);
 
-                    if (Cp.PABase     != PABase ||
+                    if (Cp.PABase != PABase || Cp.BufferType != BufferType)
-                        Cp.BufferType != BufferType)
                     {
                         PgReset = true;
                     }
                 }
 
-                PgReset |= Memory.IsRegionModified(PA, PAPgEnd - PA) && IsCached;
+                PgReset |= Modified[Index++] && IsCached;
 
                 if (PgReset)
                 {