More flexible memory manager (#307)

* Keep track mapped buffers with fixed offsets

* Started rewriting the memory manager

* Initial support for MapPhysicalMemory and UnmapPhysicalMemory, other tweaks

* MapPhysicalMemory/UnmapPhysicalMemory support, other tweaks

* Rebased

* Optimize the map/unmap physical memory svcs

* Integrate shared font support

* Fix address space reserve alignment

* Some fixes related to gpu memory mapping

* Some cleanup

* Only try uploading const buffers that are really used

* Check if memory region is contiguous

* Rebased

* Add missing count increment on IsRegionModified

* Check for reads/writes outside of the address space, optimize translation with a tail call

1 files changed, 130 insertions, 0 deletions

diff --git a/Ryujinx.HLE/Memory/DeviceMemory.cs b/Ryujinx.HLE/Memory/DeviceMemory.cs
new file mode 100644
index 00000000..3c5f2e5f
--- /dev/null
+++ b/Ryujinx.HLE/Memory/DeviceMemory.cs
@@ -0,0 +1,130 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.Memory
+{
+    class DeviceMemory : IDisposable
+    {
+        public const long RamSize = 4L * 1024 * 1024 * 1024;
+
+        public ArenaAllocator Allocator { get; private set; }
+
+        public IntPtr RamPointer { get; private set; }
+
+        private unsafe byte* RamPtr;
+
+        public unsafe DeviceMemory()
+        {
+            Allocator = new ArenaAllocator(RamSize);
+
+            RamPointer = Marshal.AllocHGlobal(new IntPtr(RamSize));
+
+            RamPtr = (byte*)RamPointer;
+        }
+
+        public sbyte ReadSByte(long Position)
+        {
+            return (sbyte)ReadByte(Position);
+        }
+
+        public short ReadInt16(long Position)
+        {
+            return (short)ReadUInt16(Position);
+        }
+
+        public int ReadInt32(long Position)
+        {
+            return (int)ReadUInt32(Position);
+        }
+
+        public long ReadInt64(long Position)
+        {
+            return (long)ReadUInt64(Position);
+        }
+
+        public unsafe byte ReadByte(long Position)
+        {
+            return *((byte*)(RamPtr + Position));
+        }
+
+        public unsafe ushort ReadUInt16(long Position)
+        {
+            return *((ushort*)(RamPtr + Position));
+        }
+
+        public unsafe uint ReadUInt32(long Position)
+        {
+            return *((uint*)(RamPtr + Position));
+        }
+
+        public unsafe ulong ReadUInt64(long Position)
+        {
+            return *((ulong*)(RamPtr + Position));
+        }
+
+        public void WriteSByte(long Position, sbyte Value)
+        {
+            WriteByte(Position, (byte)Value);
+        }
+
+        public void WriteInt16(long Position, short Value)
+        {
+            WriteUInt16(Position, (ushort)Value);
+        }
+
+        public void WriteInt32(long Position, int Value)
+        {
+            WriteUInt32(Position, (uint)Value);
+        }
+
+        public void WriteInt64(long Position, long Value)
+        {
+            WriteUInt64(Position, (ulong)Value);
+        }
+
+        public unsafe void WriteByte(long Position, byte Value)
+        {
+            *((byte*)(RamPtr + Position)) = Value;
+        }
+
+        public unsafe void WriteUInt16(long Position, ushort Value)
+        {
+            *((ushort*)(RamPtr + Position)) = Value;
+        }
+
+        public unsafe void WriteUInt32(long Position, uint Value)
+        {
+            *((uint*)(RamPtr + Position)) = Value;
+        }
+
+        public unsafe void WriteUInt64(long Position, ulong Value)
+        {
+            *((ulong*)(RamPtr + Position)) = Value;
+        }
+
+        public void FillWithZeros(long Position, int Size)
+        {
+            int Size8 = Size & ~(8 - 1);
+
+            for (int Offs = 0; Offs < Size8; Offs += 8)
+            {
+                WriteInt64(Position + Offs, 0);
+            }
+
+            for (int Offs = Size8; Offs < (Size - Size8); Offs++)
+            {
+                WriteByte(Position + Offs, 0);
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool Disposing)
+        {
+            Marshal.FreeHGlobal(RamPointer);
+        }
+    }
+}
\ No newline at end of file