Implement GPU syncpoints (#980)

* Implement GPU syncpoints

This adds support for GPU syncpoints on the GPU backend & nvservices.

Everything that was implemented here is based on my researches,
hardware testing of the GM20B and reversing of nvservices (8.1.0).

Thanks to @fincs for the informations about some behaviours of the pusher
and for the initial informations about syncpoints.

* syncpoint: address gdkchan's comments

* Add some missing logic to handle SubmitGpfifo correctly

* Handle the NV event API correctly

* evnt => hostEvent

* Finish addressing gdkchan's comments

* nvservices: write the output buffer even when an error is returned

* dma pusher: Implemnet prefetch barrier

lso fix when the commands should be prefetch.

* Partially fix prefetch barrier

* Add a missing syncpoint check in QueryEvent of NvHostSyncPt

* Address Ac_K's comments and fix GetSyncpoint for ChannelResourcePolicy == Channel

* fix SyncptWait & SyncptWaitEx cmds logic

* Address ripinperi's comments

* Address gdkchan's comments

* Move user event management to the control channel

* Fix mm implementation, nvdec works again

* Address ripinperi's comments

* Address gdkchan's comments

* Implement nvhost-ctrl close accurately + make nvservices dispose channels when stopping the emulator

* Fix typo in MultiMediaOperationType

3 files changed, 243 insertions, 0 deletions

diff --git a/Ryujinx.Graphics.Gpu/Synchronization/SynchronizationManager.cs b/Ryujinx.Graphics.Gpu/Synchronization/SynchronizationManager.cs
new file mode 100644
index 00000000..18f614bb
--- /dev/null
+++ b/Ryujinx.Graphics.Gpu/Synchronization/SynchronizationManager.cs
@@ -0,0 +1,134 @@
+using System;
+using System.Threading;
+
+namespace Ryujinx.Graphics.Gpu.Synchronization
+{
+    /// <summary>
+    /// GPU synchronization manager.
+    /// </summary>
+    public class SynchronizationManager
+    {
+        /// <summary>
+        /// The maximum number of syncpoints supported by the GM20B.
+        /// </summary>
+        public const int MaxHardwareSyncpoints = 192;
+
+        /// <summary>
+        /// Array containing all hardware syncpoints.
+        /// </summary>
+        private Syncpoint[] _syncpoints;
+
+        public SynchronizationManager()
+        {
+            _syncpoints = new Syncpoint[MaxHardwareSyncpoints];
+
+            for (uint i = 0; i < _syncpoints.Length; i++)
+            {
+                _syncpoints[i] = new Syncpoint(i);
+            }
+        }
+
+        /// <summary>
+        /// Increment the value of a syncpoint with a given id.
+        /// </summary>
+        /// <param name="id">The id of the syncpoint</param>
+        /// <exception cref="System.ArgumentOutOfRangeException">Thrown when id >= MaxHardwareSyncpoints</exception>
+        /// <returns>The incremented value of the syncpoint</returns>
+        public uint IncrementSyncpoint(uint id)
+        {
+            if (id >= MaxHardwareSyncpoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(id));
+            }
+
+            return _syncpoints[id].Increment();
+        }
+
+        /// <summary>
+        /// Get the value of a syncpoint with a given id.
+        /// </summary>
+        /// <param name="id">The id of the syncpoint</param>
+        /// <exception cref="System.ArgumentOutOfRangeException">Thrown when id >= MaxHardwareSyncpoints</exception>
+        /// <returns>The value of the syncpoint</returns>
+        public uint GetSyncpointValue(uint id)
+        {
+            if (id >= MaxHardwareSyncpoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(id));
+            }
+
+            return _syncpoints[id].Value;
+        }
+
+        /// <summary>
+        /// Register a new callback on a syncpoint with a given id at a target threshold.
+        /// The callback will be called once the threshold is reached and will automatically be unregistered.
+        /// </summary>
+        /// <param name="id">The id of the syncpoint</param>
+        /// <param name="threshold">The target threshold</param>
+        /// <param name="callback">The callback to call when the threshold is reached</param>
+        /// <exception cref="System.ArgumentOutOfRangeException">Thrown when id >= MaxHardwareSyncpoints</exception>
+        /// <returns>The created SyncpointWaiterHandle object or null if already past threshold</returns>
+        public SyncpointWaiterHandle RegisterCallbackOnSyncpoint(uint id, uint threshold, Action callback)
+        {
+            if (id >= MaxHardwareSyncpoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(id));
+            }
+
+            return _syncpoints[id].RegisterCallback(threshold, callback);
+        }
+
+        /// <summary>
+        /// Unregister a callback on a given syncpoint.
+        /// </summary>
+        /// <param name="id">The id of the syncpoint</param>
+        /// <param name="waiterInformation">The waiter information to unregister</param>
+        /// <exception cref="System.ArgumentOutOfRangeException">Thrown when id >= MaxHardwareSyncpoints</exception>
+        public void UnregisterCallback(uint id, SyncpointWaiterHandle waiterInformation)
+        {
+            if (id >= MaxHardwareSyncpoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(id));
+            }
+
+            _syncpoints[id].UnregisterCallback(waiterInformation);
+        }
+
+        /// <summary>
+        /// Wait on a syncpoint with a given id at a target threshold.
+        /// The callback will be called once the threshold is reached and will automatically be unregistered.
+        /// </summary>
+        /// <param name="id">The id of the syncpoint</param>
+        /// <param name="threshold">The target threshold</param>
+        /// <param name="timeout">The timeout</param>
+        /// <exception cref="System.ArgumentOutOfRangeException">Thrown when id >= MaxHardwareSyncpoints</exception>
+        /// <returns>True if timed out</returns>
+        public bool WaitOnSyncpoint(uint id, uint threshold, TimeSpan timeout)
+        {
+            if (id >= MaxHardwareSyncpoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(id));
+            }
+
+            using (ManualResetEvent waitEvent = new ManualResetEvent(false))
+            {
+                var info = _syncpoints[id].RegisterCallback(threshold, () => waitEvent.Set());
+
+                if (info == null)
+                {
+                    return false;
+                }
+
+                bool signaled = waitEvent.WaitOne(timeout);
+
+                if (!signaled && info != null)
+                {
+                    _syncpoints[id].UnregisterCallback(info);
+                }
+
+                return !signaled;
+            }
+        }
+    }
+}
diff --git a/Ryujinx.Graphics.Gpu/Synchronization/Syncpoint.cs b/Ryujinx.Graphics.Gpu/Synchronization/Syncpoint.cs
new file mode 100644
index 00000000..abd86b35
--- /dev/null
+++ b/Ryujinx.Graphics.Gpu/Synchronization/Syncpoint.cs
@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Ryujinx.Graphics.Gpu.Synchronization
+{
+    /// <summary>
+    /// Represents GPU hardware syncpoint.
+    /// </summary>
+    class Syncpoint
+    {
+        private int _storedValue;
+
+        public readonly uint Id;
+
+        // TODO: get rid of this lock
+        private object _listLock = new object();
+
+        /// <summary>
+        /// The value of the syncpoint.
+        /// </summary>
+        public uint Value => (uint)_storedValue;
+
+        // TODO: switch to something handling concurrency?
+        private List<SyncpointWaiterHandle> _waiters;
+
+        public Syncpoint(uint id)
+        {
+            Id       = id;
+            _waiters = new List<SyncpointWaiterHandle>();
+        }
+
+        /// <summary>
+        /// Register a new callback for a target threshold.
+        /// The callback will be called once the threshold is reached and will automatically be unregistered.
+        /// </summary>
+        /// <param name="threshold">The target threshold</param>
+        /// <param name="callback">The callback to call when the threshold is reached</param>
+        /// <returns>The created SyncpointWaiterHandle object or null if already past threshold</returns>
+        public SyncpointWaiterHandle RegisterCallback(uint threshold, Action callback)
+        {
+            lock (_listLock)
+            {
+                if (Value >= threshold)
+                {
+                    callback();
+
+                    return null;
+                }
+                else
+                {
+                    SyncpointWaiterHandle waiterInformation = new SyncpointWaiterHandle
+                    {
+                        Threshold = threshold,
+                        Callback  = callback
+                    };
+
+                    _waiters.Add(waiterInformation);
+
+                    return waiterInformation;
+                }
+            }
+        }
+
+        public void UnregisterCallback(SyncpointWaiterHandle waiterInformation)
+        {
+            lock (_listLock)
+            {
+                _waiters.Remove(waiterInformation);
+            }
+        }
+
+        /// <summary>
+        /// Increment the syncpoint
+        /// </summary>
+        /// <returns>The incremented value of the syncpoint</returns>
+        public uint Increment()
+        {
+            uint currentValue = (uint)Interlocked.Increment(ref _storedValue);
+
+            lock (_listLock)
+            {
+                _waiters.RemoveAll(item =>
+                {
+                    bool isPastThreshold = currentValue >= item.Threshold;
+
+                    if (isPastThreshold)
+                    {
+                        item.Callback();
+                    }
+
+                    return isPastThreshold;
+                });
+            }
+
+            return currentValue;
+        }
+    }
+}
diff --git a/Ryujinx.Graphics.Gpu/Synchronization/SyncpointWaiterHandle.cs b/Ryujinx.Graphics.Gpu/Synchronization/SyncpointWaiterHandle.cs
new file mode 100644
index 00000000..28ce343e
--- /dev/null
+++ b/Ryujinx.Graphics.Gpu/Synchronization/SyncpointWaiterHandle.cs
@@ -0,0 +1,10 @@
+using System;
+
+namespace Ryujinx.Graphics.Gpu.Synchronization
+{
+    public class SyncpointWaiterHandle
+    {
+        internal uint   Threshold;
+        internal Action Callback;
+    }
+}