diff options
Diffstat (limited to 'Ryujinx.Graphics.Gpu/Synchronization')
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; + } +} |