Disable memory checks by default, even on debug, move ram memory allocation inside the CPU, since the size if fixed anyway, better heap region size

12 files changed, 158 insertions, 188 deletions

diff --git a/ChocolArm64/AOptimizations.cs b/ChocolArm64/AOptimizations.cs
index cbfd1ce5..0cdbd76e 100644
--- a/ChocolArm64/AOptimizations.cs
+++ b/ChocolArm64/AOptimizations.cs
@@ -1,4 +1,4 @@
 public static class AOptimizations
 {
-
+    public static bool EnableMemoryChecks = false;
 }
\ No newline at end of file
diff --git a/ChocolArm64/AThread.cs b/ChocolArm64/AThread.cs
index 6e018db6..cec26817 100644
--- a/ChocolArm64/AThread.cs
+++ b/ChocolArm64/AThread.cs
@@ -10,7 +10,7 @@ namespace ChocolArm64
         public AThreadState ThreadState { get; private set; }
         public AMemory      Memory      { get; private set; }
 
-        public long EntryPoint { get; private set; }
+        private long EntryPoint;
 
         private ATranslator Translator;
 
diff --git a/ChocolArm64/Memory/AMemory.cs b/ChocolArm64/Memory/AMemory.cs
index 0d202fed..7f2dd7d3 100644
--- a/ChocolArm64/Memory/AMemory.cs
+++ b/ChocolArm64/Memory/AMemory.cs
@@ -3,10 +3,11 @@ using ChocolArm64.State;
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace ChocolArm64.Memory
 {
-    public unsafe class AMemory
+    public unsafe class AMemory : IDisposable
     {
         private const long ErgMask = (4 << AThreadState.ErgSizeLog2) - 1;
 
@@ -39,9 +40,11 @@ namespace ChocolArm64.Memory
 
         private HashSet<long> ExAddrs;
 
+        public IntPtr Ram { get; private set; }
+
         private byte* RamPtr;
 
-        public AMemory(IntPtr Ram)
+        public AMemory()
         {
             Manager = new AMemoryMgr();
 
@@ -49,6 +52,8 @@ namespace ChocolArm64.Memory
 
             ExAddrs = new HashSet<long>();
 
+            Ram = Marshal.AllocHGlobal((IntPtr)AMemoryMgr.RamSize + AMemoryMgr.PageSize);
+
             RamPtr = (byte*)Ram;
         }
 
@@ -142,9 +147,7 @@ namespace ChocolArm64.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public byte ReadByte(long Position)
         {
-#if DEBUG
             EnsureAccessIsValid(Position, AMemoryPerm.Read);
-#endif
 
             return *((byte*)(RamPtr + (uint)Position));
         }
@@ -152,9 +155,8 @@ namespace ChocolArm64.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ushort ReadUInt16(long Position)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Read);
-#endif
+            EnsureAccessIsValid(Position + 0, AMemoryPerm.Read);
+            EnsureAccessIsValid(Position + 1, AMemoryPerm.Read);
 
             return *((ushort*)(RamPtr + (uint)Position));
         }
@@ -162,9 +164,8 @@ namespace ChocolArm64.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public uint ReadUInt32(long Position)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Read);
-#endif
+            EnsureAccessIsValid(Position + 0, AMemoryPerm.Read);
+            EnsureAccessIsValid(Position + 3, AMemoryPerm.Read);
 
             return *((uint*)(RamPtr + (uint)Position));
         }
@@ -172,9 +173,8 @@ namespace ChocolArm64.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ulong ReadUInt64(long Position)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Read);
-#endif
+            EnsureAccessIsValid(Position + 0, AMemoryPerm.Read);
+            EnsureAccessIsValid(Position + 7, AMemoryPerm.Read);
 
             return *((ulong*)(RamPtr + (uint)Position));
         }
@@ -182,50 +182,30 @@ namespace ChocolArm64.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public AVec ReadVector8(long Position)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Read);
-#endif
-
             return new AVec() { B0 = ReadByte(Position) };
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public AVec ReadVector16(long Position)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Read);
-#endif
-
             return new AVec() { H0 = ReadUInt16(Position) };
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public AVec ReadVector32(long Position)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Read);
-#endif
-
             return new AVec() { W0 = ReadUInt32(Position) };
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public AVec ReadVector64(long Position)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Read);
-#endif
-
             return new AVec() { X0 = ReadUInt64(Position) };
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public AVec ReadVector128(long Position)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Read);
-#endif
-
             return new AVec()
             {
                 X0 = ReadUInt64(Position + 0),
@@ -241,9 +221,7 @@ namespace ChocolArm64.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteByte(long Position, byte Value)
         {
-#if DEBUG
             EnsureAccessIsValid(Position, AMemoryPerm.Write);
-#endif
 
             *((byte*)(RamPtr + (uint)Position)) = Value;
         }
@@ -251,9 +229,8 @@ namespace ChocolArm64.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteUInt16(long Position, ushort Value)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Write);
-#endif
+            EnsureAccessIsValid(Position + 0, AMemoryPerm.Write);
+            EnsureAccessIsValid(Position + 1, AMemoryPerm.Write);
 
             *((ushort*)(RamPtr + (uint)Position)) = Value;
         }
@@ -261,9 +238,8 @@ namespace ChocolArm64.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteUInt32(long Position, uint Value)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Write);
-#endif
+            EnsureAccessIsValid(Position + 0, AMemoryPerm.Write);
+            EnsureAccessIsValid(Position + 3, AMemoryPerm.Write);
 
             *((uint*)(RamPtr + (uint)Position)) = Value;
         }
@@ -271,9 +247,8 @@ namespace ChocolArm64.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteUInt64(long Position, ulong Value)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Write);
-#endif
+            EnsureAccessIsValid(Position + 0, AMemoryPerm.Write);
+            EnsureAccessIsValid(Position + 7, AMemoryPerm.Write);
 
             *((ulong*)(RamPtr + (uint)Position)) = Value;
         }
@@ -281,64 +256,64 @@ namespace ChocolArm64.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteVector8(long Position, AVec Value)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Write);
-#endif
-
             WriteByte(Position, Value.B0);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteVector16(long Position, AVec Value)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Write);
-#endif
-
             WriteUInt16(Position, Value.H0);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteVector32(long Position, AVec Value)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Write);
-#endif
-
             WriteUInt32(Position, Value.W0);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteVector64(long Position, AVec Value)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Write);
-#endif
-
             WriteUInt64(Position, Value.X0);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteVector128(long Position, AVec Value)
         {
-#if DEBUG
-            EnsureAccessIsValid(Position, AMemoryPerm.Write);
-#endif
-
             WriteUInt64(Position + 0, Value.X0);
             WriteUInt64(Position + 8, Value.X1);
         }
 
         private void EnsureAccessIsValid(long Position, AMemoryPerm Perm)
         {
-            if (!Manager.IsMapped(Position))
+#if DEBUG
+            if (AOptimizations.EnableMemoryChecks)
             {
-                throw new VmmPageFaultException(Position);
+                if (!Manager.IsMapped(Position))
+                {
+                    throw new VmmPageFaultException(Position);
+                }
+
+                if (!Manager.HasPermission(Position, Perm))
+                {
+                    throw new VmmAccessViolationException(Position, Perm);
+                }
             }
+#endif
+        }
 
-            if (!Manager.HasPermission(Position, Perm))
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (Ram != IntPtr.Zero)
             {
-                throw new VmmAccessViolationException(Position, Perm);
+                Marshal.FreeHGlobal(Ram);
+
+                Ram = IntPtr.Zero;
             }
         }
     }
diff --git a/ChocolArm64/Memory/AMemoryMgr.cs b/ChocolArm64/Memory/AMemoryMgr.cs
index bc364452..8a165b07 100644
--- a/ChocolArm64/Memory/AMemoryMgr.cs
+++ b/ChocolArm64/Memory/AMemoryMgr.cs
@@ -4,8 +4,8 @@ namespace ChocolArm64.Memory
 {
     public class AMemoryMgr
     {
-        public const long AddrSize = RamSize;
         public const long RamSize  = 4L * 1024 * 1024 * 1024;
+        public const long AddrSize = RamSize;
 
         private const int PTLvl0Bits = 10;
         private const int PTLvl1Bits = 10;
@@ -19,8 +19,8 @@ namespace ChocolArm64.Memory
         private const int PTLvl1Mask = PTLvl1Size - 1;
         public  const int PageMask   = PageSize   - 1;
 
-        private const int PTLvl0Bit  = PTPageBits + PTLvl1Bits;
-        private const int PTLvl1Bit  = PTPageBits;
+        private const int PTLvl0Bit = PTPageBits + PTLvl1Bits;
+        private const int PTLvl1Bit = PTPageBits;
 
         private enum PTMap
         {
diff --git a/Ryujinx.Core/Hid/Hid.cs b/Ryujinx.Core/Hid/Hid.cs
index 249747c1..16976889 100644
--- a/Ryujinx.Core/Hid/Hid.cs
+++ b/Ryujinx.Core/Hid/Hid.cs
@@ -1,7 +1,5 @@
-using ChocolArm64.Memory;
-using Ryujinx.Core.OsHle.Handles;
+using Ryujinx.Core.OsHle.Handles;
 using System;
-using System.Diagnostics;
 
 namespace Ryujinx.Core.Input
 {
@@ -66,11 +64,15 @@ namespace Ryujinx.Core.Input
 
         private long[] ShMemPositions;
 
-        private IntPtr Ram;
+        private long CurrControllerEntry;
+        private long CurrTouchEntry;
+        private long CurrTouchSampleCounter;
 
-        public Hid(IntPtr Ram)
+        private Switch Ns;
+
+        public Hid(Switch Ns)
         {
-            this.Ram = Ram;
+            this.Ns = Ns;
 
             ShMemLock = new object();
 
@@ -136,20 +138,20 @@ namespace Ryujinx.Core.Input
 
             HidControllerColorDesc SplitColorDesc = 0;
 
-            WriteInt32(BaseControllerOffset + 0x0,  (int)Type);
+            Ns.Memory.WriteInt32(BaseControllerOffset + 0x0,  (int)Type);
 
-            WriteInt32(BaseControllerOffset + 0x4,  IsHalf ? 1 : 0);
+            Ns.Memory.WriteInt32(BaseControllerOffset + 0x4,  IsHalf ? 1 : 0);
 
-            WriteInt32(BaseControllerOffset + 0x8,  (int)SingleColorDesc);
-            WriteInt32(BaseControllerOffset + 0xc,  (int)SingleColorBody);
-            WriteInt32(BaseControllerOffset + 0x10, (int)SingleColorButtons);
-            WriteInt32(BaseControllerOffset + 0x14, (int)SplitColorDesc);
+            Ns.Memory.WriteInt32(BaseControllerOffset + 0x8,  (int)SingleColorDesc);
+            Ns.Memory.WriteInt32(BaseControllerOffset + 0xc,  (int)SingleColorBody);
+            Ns.Memory.WriteInt32(BaseControllerOffset + 0x10, (int)SingleColorButtons);
+            Ns.Memory.WriteInt32(BaseControllerOffset + 0x14, (int)SplitColorDesc);
 
-            WriteInt32(BaseControllerOffset + 0x18, (int)LeftColorBody);
-            WriteInt32(BaseControllerOffset + 0x1c, (int)LeftColorButtons);
+            Ns.Memory.WriteInt32(BaseControllerOffset + 0x18, (int)LeftColorBody);
+            Ns.Memory.WriteInt32(BaseControllerOffset + 0x1c, (int)LeftColorButtons);
 
-            WriteInt32(BaseControllerOffset + 0x20, (int)RightColorBody);
-            WriteInt32(BaseControllerOffset + 0x24, (int)RightColorButtons);
+            Ns.Memory.WriteInt32(BaseControllerOffset + 0x20, (int)RightColorBody);
+            Ns.Memory.WriteInt32(BaseControllerOffset + 0x24, (int)RightColorButtons);
         }
 
         public void SetJoyconButton(
@@ -163,45 +165,60 @@ namespace Ryujinx.Core.Input
             {
                 foreach (long Position in ShMemPositions)
                 {
-                    long ControllerOffset = Position + HidControllersOffset;
+                    WriteJoyconButtons(
+                        Position,
+                        ControllerId,
+                        ControllerLayout,
+                        Buttons,
+                        LeftStick,
+                        RightStick);
+                }
+            }
+        }
 
-                    ControllerOffset += (int)ControllerId * HidControllerSize;
+        private void WriteJoyconButtons(
+            long                 BasePosition,
+            HidControllerId      ControllerId,
+            HidControllerLayouts ControllerLayout,
+            HidControllerButtons Buttons,
+            HidJoystickPosition  LeftStick,
+            HidJoystickPosition  RightStick)
+        {
+            long ControllerOffset = BasePosition + HidControllersOffset;
 
-                    ControllerOffset += HidControllerHeaderSize;
+            ControllerOffset += (int)ControllerId * HidControllerSize;
 
-                    ControllerOffset += (int)ControllerLayout * HidControllerLayoutsSize;
+            ControllerOffset += HidControllerHeaderSize;
 
-                    long LastEntry = ReadInt64(ControllerOffset + 0x10);
+            ControllerOffset += (int)ControllerLayout * HidControllerLayoutsSize;
 
-                    long CurrEntry = (LastEntry + 1) % HidEntryCount;
+            CurrControllerEntry = (CurrControllerEntry + 1) % HidEntryCount;
 
-                    long Timestamp = Stopwatch.GetTimestamp();
+            long Timestamp = GetTimestamp();
 
-                    WriteInt64(ControllerOffset + 0x0,  Timestamp);
-                    WriteInt64(ControllerOffset + 0x8,  HidEntryCount);
-                    WriteInt64(ControllerOffset + 0x10, CurrEntry);
-                    WriteInt64(ControllerOffset + 0x18, HidEntryCount - 1);
+            Ns.Memory.WriteInt64(ControllerOffset + 0x0,  Timestamp);
+            Ns.Memory.WriteInt64(ControllerOffset + 0x8,  HidEntryCount);
+            Ns.Memory.WriteInt64(ControllerOffset + 0x10, CurrControllerEntry);
+            Ns.Memory.WriteInt64(ControllerOffset + 0x18, HidEntryCount - 1);
 
-                    ControllerOffset += HidControllersLayoutHeaderSize;
+            ControllerOffset += HidControllersLayoutHeaderSize;
 
-                    ControllerOffset += CurrEntry * HidControllersInputEntrySize;
+            ControllerOffset += CurrControllerEntry * HidControllersInputEntrySize;
 
-                    WriteInt64(ControllerOffset + 0x0,  Timestamp);
-                    WriteInt64(ControllerOffset + 0x8,  Timestamp);
+            Ns.Memory.WriteInt64(ControllerOffset + 0x0,  Timestamp);
+            Ns.Memory.WriteInt64(ControllerOffset + 0x8,  Timestamp);
 
-                    WriteInt64(ControllerOffset + 0x10, (uint)Buttons);
+            Ns.Memory.WriteInt64(ControllerOffset + 0x10, (uint)Buttons);
 
-                    WriteInt32(ControllerOffset + 0x18, LeftStick.DX);
-                    WriteInt32(ControllerOffset + 0x1c, LeftStick.DY);
+            Ns.Memory.WriteInt32(ControllerOffset + 0x18, LeftStick.DX);
+            Ns.Memory.WriteInt32(ControllerOffset + 0x1c, LeftStick.DY);
 
-                    WriteInt64(ControllerOffset + 0x20, RightStick.DX);
-                    WriteInt64(ControllerOffset + 0x24, RightStick.DY);
+            Ns.Memory.WriteInt32(ControllerOffset + 0x20, RightStick.DX);
+            Ns.Memory.WriteInt32(ControllerOffset + 0x24, RightStick.DY);
 
-                    WriteInt64(ControllerOffset + 0x28,
-                        (uint)HidControllerConnState.Controller_State_Connected |
-                        (uint)HidControllerConnState.Controller_State_Wired);
-                }
-            }
+            Ns.Memory.WriteInt64(ControllerOffset + 0x28,
+                (uint)HidControllerConnState.Controller_State_Connected |
+                (uint)HidControllerConnState.Controller_State_Wired);
         }
 
         public void SetTouchPoints(params HidTouchPoint[] Points)
@@ -210,72 +227,57 @@ namespace Ryujinx.Core.Input
             {
                 foreach (long Position in ShMemPositions)
                 {
-                    long TouchScreenOffset = Position + HidTouchScreenOffset;
-
-                    long LastEntry = ReadInt64(TouchScreenOffset + 0x10);
-
-                    long CurrEntry = (LastEntry + 1) % HidEntryCount;
+                    WriteTouchPoints(Position, Points);
+                }
+            }
+        }
 
-                    long Timestamp = ReadInt64(TouchScreenOffset) + 1;
+        private void WriteTouchPoints(long BasePosition, params HidTouchPoint[] Points)
+        {
+            long TouchScreenOffset = BasePosition + HidTouchScreenOffset;
 
-                    WriteInt64(TouchScreenOffset + 0x0,  Timestamp);
-                    WriteInt64(TouchScreenOffset + 0x8,  HidEntryCount);
-                    WriteInt64(TouchScreenOffset + 0x10, CurrEntry);
-                    WriteInt64(TouchScreenOffset + 0x18, HidEntryCount - 1);
-                    WriteInt64(TouchScreenOffset + 0x20, Timestamp);            
+            long Timestamp = GetTimestamp();
 
-                    long TouchEntryOffset = TouchScreenOffset + HidTouchHeaderSize;
+            CurrTouchEntry = (CurrTouchEntry + 1) % HidEntryCount;
 
-                    long LastEntryOffset = TouchEntryOffset + LastEntry * HidTouchEntrySize;
+            Ns.Memory.WriteInt64(TouchScreenOffset + 0x0,  Timestamp);
+            Ns.Memory.WriteInt64(TouchScreenOffset + 0x8,  HidEntryCount);
+            Ns.Memory.WriteInt64(TouchScreenOffset + 0x10, CurrTouchEntry);
+            Ns.Memory.WriteInt64(TouchScreenOffset + 0x18, HidEntryCount - 1);
+            Ns.Memory.WriteInt64(TouchScreenOffset + 0x20, Timestamp);            
 
-                    TouchEntryOffset += CurrEntry * HidTouchEntrySize;            
+            long TouchEntryOffset = TouchScreenOffset + HidTouchHeaderSize;
 
-                    WriteInt64(TouchEntryOffset + 0x0, Timestamp);
-                    WriteInt64(TouchEntryOffset + 0x8, Points.Length);
+            TouchEntryOffset += CurrTouchEntry * HidTouchEntrySize;            
 
-                    TouchEntryOffset += HidTouchEntryHeaderSize;
+            Ns.Memory.WriteInt64(TouchEntryOffset + 0x0, CurrTouchSampleCounter++);
+            Ns.Memory.WriteInt64(TouchEntryOffset + 0x8, Points.Length);
 
-                    const int Padding = 0;
+            TouchEntryOffset += HidTouchEntryHeaderSize;
 
-                    int Index = 0;
+            const int Padding = 0;
 
-                    foreach (HidTouchPoint Point in Points)
-                    {
-                        WriteInt64(TouchEntryOffset + 0x0,  Timestamp);
-                        WriteInt32(TouchEntryOffset + 0x8,  Padding);
-                        WriteInt32(TouchEntryOffset + 0xc,  Index++);
-                        WriteInt32(TouchEntryOffset + 0x10, Point.X);
-                        WriteInt32(TouchEntryOffset + 0x14, Point.Y);
-                        WriteInt32(TouchEntryOffset + 0x18, Point.DiameterX);
-                        WriteInt32(TouchEntryOffset + 0x1c, Point.DiameterY);
-                        WriteInt32(TouchEntryOffset + 0x20, Point.Angle);
-                        WriteInt32(TouchEntryOffset + 0x24, Padding);
+            int Index = 0;
 
-                        TouchEntryOffset += HidTouchEntryTouchSize;
-                    }
-                }
+            foreach (HidTouchPoint Point in Points)
+            {
+                Ns.Memory.WriteInt64(TouchEntryOffset + 0x0,  Timestamp);
+                Ns.Memory.WriteInt32(TouchEntryOffset + 0x8,  Padding);
+                Ns.Memory.WriteInt32(TouchEntryOffset + 0xc,  Index++);
+                Ns.Memory.WriteInt32(TouchEntryOffset + 0x10, Point.X);
+                Ns.Memory.WriteInt32(TouchEntryOffset + 0x14, Point.Y);
+                Ns.Memory.WriteInt32(TouchEntryOffset + 0x18, Point.DiameterX);
+                Ns.Memory.WriteInt32(TouchEntryOffset + 0x1c, Point.DiameterY);
+                Ns.Memory.WriteInt32(TouchEntryOffset + 0x20, Point.Angle);
+                Ns.Memory.WriteInt32(TouchEntryOffset + 0x24, Padding);
+
+                TouchEntryOffset += HidTouchEntryTouchSize;
             }
         }
 
-        private unsafe long ReadInt64(long Position)
-        {
-            if ((ulong)Position + 8 > AMemoryMgr.AddrSize) return 0;
-
-            return *((long*)((byte*)Ram + Position));
-        }
-
-        private unsafe void WriteInt32(long Position, int Value)
+        private long GetTimestamp()
         {
-            if ((ulong)Position + 4 > AMemoryMgr.AddrSize) return;
-
-            *((int*)((byte*)Ram + Position)) = Value;
-        }
-
-        private unsafe void WriteInt64(long Position, long Value)
-        {
-            if ((ulong)Position + 8 > AMemoryMgr.AddrSize) return;
-
-            *((long*)((byte*)Ram + Position)) = Value;
+            return Environment.TickCount * 19_200;
         }
     }
 }
\ No newline at end of file
diff --git a/Ryujinx.Core/OsHle/MemoryRegions.cs b/Ryujinx.Core/OsHle/MemoryRegions.cs
index 7f5ab0ed..75b97b1f 100644
--- a/Ryujinx.Core/OsHle/MemoryRegions.cs
+++ b/Ryujinx.Core/OsHle/MemoryRegions.cs
@@ -9,6 +9,9 @@ namespace Ryujinx.Core.OsHle
         public const long MapRegionAddress = 0x10000000;
         public const long MapRegionSize    = 0x20000000;
 
+        public const long HeapRegionAddress = MapRegionAddress + MapRegionSize;
+        public const long HeapRegionSize    = TlsPagesAddress - HeapRegionAddress;
+
         public const long MainStackSize = 0x100000;
 
         public const long MainStackAddress = AMemoryMgr.AddrSize - MainStackSize;
@@ -17,8 +20,6 @@ namespace Ryujinx.Core.OsHle
 
         public const long TlsPagesAddress = MainStackAddress - TlsPagesSize;
 
-        public const long HeapRegionAddress = MapRegionAddress + MapRegionSize;
-
         public const long TotalMemoryUsed = HeapRegionAddress + TlsPagesSize + MainStackSize;
 
         public const long TotalMemoryAvailable = AMemoryMgr.RamSize - AddrSpaceStart;
diff --git a/Ryujinx.Core/OsHle/Process.cs b/Ryujinx.Core/OsHle/Process.cs
index f549b027..a919f1af 100644
--- a/Ryujinx.Core/OsHle/Process.cs
+++ b/Ryujinx.Core/OsHle/Process.cs
@@ -45,7 +45,7 @@ namespace Ryujinx.Core.OsHle
             this.Ns        = Ns;
             this.ProcessId = ProcessId;
 
-            Memory = new AMemory(Ns.Ram);
+            Memory = Ns.Memory;
 
             Scheduler = new KProcessScheduler();
 
diff --git a/Ryujinx.Core/OsHle/Services/Vi/NvFlinger.cs b/Ryujinx.Core/OsHle/Services/Vi/NvFlinger.cs
index 740a35f9..1d394fb4 100644
--- a/Ryujinx.Core/OsHle/Services/Vi/NvFlinger.cs
+++ b/Ryujinx.Core/OsHle/Services/Vi/NvFlinger.cs
@@ -264,11 +264,11 @@ namespace Ryujinx.Core.OsHle.IpcServices.Android
             int FbWidth  = BufferQueue[Slot].Data.Width;
             int FbHeight = BufferQueue[Slot].Data.Height;
 
-            int FbSize = FbWidth * FbHeight * 4;
+            long FbSize = (uint)FbWidth * FbHeight * 4;
 
             HNvMap NvMap = GetNvMap(Context, Slot);
 
-            if (FbSize < 0 || NvMap.Address < 0 || NvMap.Address + FbSize > AMemoryMgr.AddrSize)
+            if ((ulong)(NvMap.Address + FbSize) > AMemoryMgr.AddrSize)
             {
                 Logging.Error($"Frame buffer address {NvMap.Address:x16} is invalid!");
 
@@ -330,7 +330,7 @@ namespace Ryujinx.Core.OsHle.IpcServices.Android
                 Rotate = -MathF.PI * 0.5f;
             }
 
-            byte* Fb = (byte*)Context.Ns.Ram + NvMap.Address;
+            byte* Fb = (byte*)Context.Ns.Memory.Ram + NvMap.Address;
 
             Context.Ns.Gpu.Renderer.QueueAction(delegate()
             {
diff --git a/Ryujinx.Core/OsHle/Svc/SvcSystem.cs b/Ryujinx.Core/OsHle/Svc/SvcSystem.cs
index 8a0a3917..a276fe3c 100644
--- a/Ryujinx.Core/OsHle/Svc/SvcSystem.cs
+++ b/Ryujinx.Core/OsHle/Svc/SvcSystem.cs
@@ -197,7 +197,7 @@ namespace Ryujinx.Core.OsHle.Svc
                     break;
 
                 case 5:
-                    ThreadState.X1 = CurrentHeapSize;
+                    ThreadState.X1 = MemoryRegions.HeapRegionSize;
                     break;
 
                 case 6:
diff --git a/Ryujinx.Core/PerformanceStatistics.cs b/Ryujinx.Core/PerformanceStatistics.cs
index 3740daa5..e5d930f9 100644
--- a/Ryujinx.Core/PerformanceStatistics.cs
+++ b/Ryujinx.Core/PerformanceStatistics.cs
@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Text;
+using System.Diagnostics;
 using System.Timers;
 
 namespace Ryujinx.Core
diff --git a/Ryujinx.Core/Switch.cs b/Ryujinx.Core/Switch.cs
index 1acd87f0..dff7802b 100644
--- a/Ryujinx.Core/Switch.cs
+++ b/Ryujinx.Core/Switch.cs
@@ -5,13 +5,12 @@ using Ryujinx.Core.Settings;
 using Ryujinx.Graphics.Gal;
 using Ryujinx.Graphics.Gpu;
 using System;
-using System.Runtime.InteropServices;
 
 namespace Ryujinx.Core
 {
     public class Switch : IDisposable
     {
-        public IntPtr Ram {get; private set; }
+        internal AMemory Memory { get; private set; }
 
         internal NsGpu     Gpu { get; private set; }
         internal Horizon   Os  { get; private set; }
@@ -25,13 +24,13 @@ namespace Ryujinx.Core
 
         public Switch(IGalRenderer Renderer)
         {
-            Ram = Marshal.AllocHGlobal((IntPtr)AMemoryMgr.RamSize);
+            Memory = new AMemory();
 
             Gpu = new NsGpu(Renderer);
 
             VFs = new VirtualFs();
 
-            Hid = new Hid(Ram);
+            Hid = new Hid(this);
 
             Statistics = new PerformanceStatistics();
 
@@ -72,10 +71,10 @@ namespace Ryujinx.Core
         {
             if (disposing)
             {
+                Memory.Dispose();
+
                 VFs.Dispose();
             }
-
-            Marshal.FreeHGlobal(Ram);
         }
     }
 }
\ No newline at end of file
diff --git a/Ryujinx.Tests/Cpu/CpuTest.cs b/Ryujinx.Tests/Cpu/CpuTest.cs
index a4a3b33f..c4f0bbd7 100644
--- a/Ryujinx.Tests/Cpu/CpuTest.cs
+++ b/Ryujinx.Tests/Cpu/CpuTest.cs
@@ -2,8 +2,6 @@ using ChocolArm64;
 using ChocolArm64.Memory;
 using ChocolArm64.State;
 using NUnit.Framework;
-using System;
-using System.Runtime.InteropServices;
 using System.Threading;
 
 namespace Ryujinx.Tests.Cpu
@@ -16,7 +14,6 @@ namespace Ryujinx.Tests.Cpu
 
         private long EntryPoint;
 
-        private IntPtr Ram;
         private AMemory Memory;
         private AThread Thread;
 
@@ -28,9 +25,8 @@ namespace Ryujinx.Tests.Cpu
 
             EntryPoint = Position;
 
-            Ram = Marshal.AllocHGlobal((IntPtr)AMemoryMgr.RamSize);
             ATranslator Translator = new ATranslator();
-            Memory = new AMemory(Ram);
+            Memory = new AMemory();
             Memory.Manager.Map(Position, Size, 2, AMemoryPerm.Read | AMemoryPerm.Write | AMemoryPerm.Execute);
             Thread = new AThread(Translator, Memory, ThreadPriority.Normal, EntryPoint);
         }
@@ -38,9 +34,9 @@ namespace Ryujinx.Tests.Cpu
         [TearDown]
         public void Teardown()
         {
+            Memory.Dispose();
             Thread = null;
             Memory = null;
-            Marshal.FreeHGlobal(Ram);
         }
 
         protected void Reset()