NvServices refactoring (#120)

* Initial implementation of NvMap/NvHostCtrl

* More work on NvHostCtrl

* Refactoring of nvservices, move GPU Vmm, make Vmm per-process, refactor most gpu devices, move Gpu to Core, fix CbBind

* Implement GetGpuTime, support CancelSynchronization, fix issue on InsertWaitingMutex, proper double buffering support (again, not working properly for commercial games, only hb)

* Try to fix perf regression reading/writing textures, moved syncpts and events to a UserCtx class, delete global state when the process exits, other minor tweaks

* Remove now unused code, add comment about probably wrong result codes

Ryujinx.Core/Gpu/NvGpuFifo.cs

@@ -0,0 +1,174 @@
+using System.Collections.Concurrent;
+
+namespace Ryujinx.Core.Gpu
+{
+    public class NvGpuFifo
+    {
+        private const int MacrosCount    = 0x80;
+        private const int MacroIndexMask = MacrosCount - 1;
+
+        private NvGpu Gpu;
+
+        private ConcurrentQueue<(NvGpuVmm, NvGpuPBEntry)> BufferQueue;
+
+        private NvGpuEngine[] SubChannels;
+
+        private struct CachedMacro
+        {
+            public long Position { get; private set; }
+
+            private MacroInterpreter Interpreter;
+
+            public CachedMacro(NvGpuFifo PFifo, INvGpuEngine Engine, long Position)
+            {
+                this.Position = Position;
+
+                Interpreter = new MacroInterpreter(PFifo, Engine);
+            }
+
+            public void PushParam(int Param)
+            {
+                Interpreter?.Fifo.Enqueue(Param);
+            }
+
+            public void Execute(NvGpuVmm Vmm, int Param)
+            {
+                Interpreter?.Execute(Vmm, Position, Param);
+            }
+        }
+
+        private long CurrMacroPosition;
+        private int  CurrMacroBindIndex;
+
+        private CachedMacro[] Macros;
+
+        public NvGpuFifo(NvGpu Gpu)
+        {
+            this.Gpu = Gpu;
+
+            BufferQueue = new ConcurrentQueue<(NvGpuVmm, NvGpuPBEntry)>();
+
+            SubChannels = new NvGpuEngine[8];
+
+            Macros = new CachedMacro[MacrosCount];
+        }
+
+        public void PushBuffer(NvGpuVmm Vmm, NvGpuPBEntry[] Buffer)
+        {
+            foreach (NvGpuPBEntry PBEntry in Buffer)
+            {
+                BufferQueue.Enqueue((Vmm, PBEntry));
+            }
+        }
+
+        public void DispatchCalls()
+        {
+            while (Step());
+        }
+
+        public bool Step()
+        {
+            if (BufferQueue.TryDequeue(out (NvGpuVmm Vmm, NvGpuPBEntry PBEntry) Tuple))
+            {
+                CallMethod(Tuple.Vmm, Tuple.PBEntry);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        private void CallMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            if (PBEntry.Method < 0x80)
+            {
+                switch ((NvGpuFifoMeth)PBEntry.Method)
+                {
+                    case NvGpuFifoMeth.BindChannel:
+                    {
+                        NvGpuEngine Engine = (NvGpuEngine)PBEntry.Arguments[0];
+
+                        SubChannels[PBEntry.SubChannel] = Engine;
+
+                        break;
+                    }
+
+                    case NvGpuFifoMeth.SetMacroUploadAddress:
+                    {
+                        CurrMacroPosition = (long)((ulong)PBEntry.Arguments[0] << 2);
+
+                        break;
+                    }
+
+                    case NvGpuFifoMeth.SendMacroCodeData:
+                    {
+                        long Position = CurrMacroPosition;
+
+                        foreach (int Arg in PBEntry.Arguments)
+                        {
+                            Vmm.WriteInt32(Position, Arg);
+
+                            CurrMacroPosition += 4;
+
+                            Position += 4;
+                        }
+                        break;
+                    }
+
+                    case NvGpuFifoMeth.SetMacroBindingIndex:
+                    {
+                        CurrMacroBindIndex = PBEntry.Arguments[0];
+
+                        break;
+                    }
+
+                    case NvGpuFifoMeth.BindMacro:
+                    {
+                        long Position = (long)((ulong)PBEntry.Arguments[0] << 2);
+
+                        Macros[CurrMacroBindIndex] = new CachedMacro(this, Gpu.Engine3d, Position);
+
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                switch (SubChannels[PBEntry.SubChannel])
+                {
+                    case NvGpuEngine._2d: Call2dMethod(Vmm, PBEntry); break;
+                    case NvGpuEngine._3d: Call3dMethod(Vmm, PBEntry); break;
+                }
+            }
+        }
+
+        private void Call2dMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            Gpu.Engine2d.CallMethod(Vmm, PBEntry);
+        }
+
+        private void Call3dMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            if (PBEntry.Method < 0xe00)
+            {
+                Gpu.Engine3d.CallMethod(Vmm, PBEntry);
+            }
+            else
+            {
+                int MacroIndex = (PBEntry.Method >> 1) & MacroIndexMask;
+
+                if ((PBEntry.Method & 1) != 0)
+                {
+                    foreach (int Arg in PBEntry.Arguments)
+                    {
+                        Macros[MacroIndex].PushParam(Arg);
+                    }
+                }
+                else
+                {
+                    Macros[MacroIndex].Execute(Vmm, PBEntry.Arguments[0]);
+                }
+            }
+        }
+    }
+}