ryujinx/Ryujinx.Graphics.Gpu/Synchronization/Syncpoint.cs
Thog 644de99e86
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
2020-04-19 11:25:57 +10:00

100 lines
2.8 KiB
C#

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;
}
}
}