public NvInternalResult SignalEvent(uint eventId)
{
if (eventId >= EventsCount)
{
return(NvInternalResult.InvalidInput);
}
NvHostEvent hostEvent = Events[eventId];
if (hostEvent == null)
{
return(NvInternalResult.InvalidInput);
}
NvHostEventState oldState = hostEvent.State;
if (oldState == NvHostEventState.Waiting)
{
hostEvent.State = NvHostEventState.Cancelling;
hostEvent.Cancel(_device.Gpu);
}
hostEvent.State = NvHostEventState.Cancelled;
return(NvInternalResult.Success);
}
private NvInternalResult EventSignal(ref uint userEventId)
{
uint eventId = userEventId & ushort.MaxValue;
if (eventId >= EventsCount)
{
return(NvInternalResult.InvalidInput);
}
lock (_events)
{
NvHostEvent hostEvent = _events[eventId];
if (hostEvent == null)
{
return(NvInternalResult.InvalidInput);
}
hostEvent.Cancel(_device.Gpu);
_device.System.HostSyncpoint.UpdateMin(hostEvent.Fence.Id);
return(NvInternalResult.Success);
}
}
private NvInternalResult EventUnregister(ref uint userEventId)
{
lock (_events)
{
if (userEventId >= EventsCount)
{
return(NvInternalResult.InvalidInput);
}
NvHostEvent hostEvent = _events[userEventId];
if (hostEvent == null)
{
return(NvInternalResult.Success);
}
if (hostEvent.State == NvHostEventState.Available ||
hostEvent.State == NvHostEventState.Cancelled ||
hostEvent.State == NvHostEventState.Signaled)
{
_events[userEventId].CloseEvent(Context);
_events[userEventId] = null;
return(NvInternalResult.Success);
}
return(NvInternalResult.Busy);
}
}
private NvInternalResult EventSignal(ref uint userEventId)
{
uint eventId = userEventId & ushort.MaxValue;
if (eventId >= EventsCount)
{
return(NvInternalResult.InvalidInput);
}
NvHostEvent hostEvent = _events[eventId];
if (hostEvent == null)
{
return(NvInternalResult.InvalidInput);
}
NvHostEventState oldState = hostEvent.State;
if (oldState == NvHostEventState.Waiting)
{
hostEvent.State = NvHostEventState.Cancelling;
hostEvent.Cancel(_device.Gpu);
}
hostEvent.State = NvHostEventState.Cancelled;
return(NvInternalResult.Success);
}
public NvInternalResult RegisterEvent(uint eventId)
{
NvInternalResult result = UnregisterEvent(eventId);
if (result == NvInternalResult.Success)
{
Events[eventId] = new NvHostEvent(this, eventId, _device.System);
}
return(result);
}
private NvInternalResult EventRegister(ref uint userEventId)
{
NvInternalResult result = EventUnregister(ref userEventId);
if (result == NvInternalResult.Success)
{
_events[userEventId] = new NvHostEvent(_device.System.HostSyncpoint, userEventId, _device.System);
}
return(result);
}
private static NvHostEvent GetFreeEvent(
ServiceCtx context,
NvHostSyncpt syncpt,
int id,
out int eventIndex)
{
NvHostEvent[] events = GetUserCtx(context).Events;
eventIndex = NvHostCtrlUserCtx.EventsCount;
int nullIndex = NvHostCtrlUserCtx.EventsCount;
for (int index = 0; index < NvHostCtrlUserCtx.EventsCount; index++)
{
NvHostEvent Event = events[index];
if (Event != null)
{
if (Event.State == NvHostEventState.Registered ||
Event.State == NvHostEventState.Free)
{
eventIndex = index;
if (Event.Id == id)
{
return(Event);
}
}
}
else if (nullIndex == NvHostCtrlUserCtx.EventsCount)
{
nullIndex = index;
}
}
if (nullIndex < NvHostCtrlUserCtx.EventsCount)
{
eventIndex = nullIndex;
return(events[nullIndex] = new NvHostEvent());
}
if (eventIndex < NvHostCtrlUserCtx.EventsCount)
{
return(events[eventIndex]);
}
return(null);
}
public NvHostEvent GetFreeEvent(uint id, out uint eventIndex)
{
eventIndex = EventsCount;
uint nullIndex = EventsCount;
for (uint index = 0; index < EventsCount; index++)
{
NvHostEvent Event = Events[index];
if (Event != null)
{
if (Event.State == NvHostEventState.Availaible ||
Event.State == NvHostEventState.Signaled ||
Event.State == NvHostEventState.Cancelled)
{
eventIndex = index;
if (Event.Fence.Id == id)
{
return(Event);
}
}
}
else if (nullIndex == EventsCount)
{
nullIndex = index;
}
}
if (nullIndex < EventsCount)
{
eventIndex = nullIndex;
RegisterEvent(eventIndex);
return(Events[nullIndex]);
}
if (eventIndex < EventsCount)
{
return(Events[eventIndex]);
}
return(null);
}
public override void Close()
{
Logger.Warning?.Print(LogClass.ServiceNv, "Closing channel");
lock (_events)
{
// If the device file need to be closed, cancel all user events and dispose events.
for (int i = 0; i < _events.Length; i++)
{
NvHostEvent evnt = _events[i];
if (evnt != null)
{
lock (evnt.Lock)
{
if (evnt.State == NvHostEventState.Waiting)
{
evnt.State = NvHostEventState.Cancelling;
evnt.Cancel(_device.Gpu);
}
else if (evnt.State == NvHostEventState.Signaling)
{
// Wait at max 9ms if the guest app is trying to signal the event while closing it..
int retryCount = 0;
do
{
if (retryCount++ > 9)
{
break;
}
// TODO: This should be handled by the kernel (reschedule the current thread ect), waiting for Kernel decoupling work.
Thread.Sleep(1);
} while (evnt.State != NvHostEventState.Signaled);
}
evnt.CloseEvent(Context);
_events[i] = null;
}
}
}
}
}
private NvHostEvent GetFreeEvent(int id, out int eventIndex)
{
eventIndex = EventsCount;
int nullIndex = EventsCount;
for (int index = 0; index < EventsCount; index++)
{
NvHostEvent Event = _events[index];
if (Event != null)
{
if (Event.State == NvHostEventState.Registered ||
Event.State == NvHostEventState.Free)
{
eventIndex = index;
if (Event.Id == id)
{
return(Event);
}
}
}
else if (nullIndex == EventsCount)
{
nullIndex = index;
}
}
if (nullIndex < EventsCount)
{
eventIndex = nullIndex;
return(_events[nullIndex] = new NvHostEvent());
}
if (eventIndex < EventsCount)
{
return(_events[eventIndex]);
}
return(null);
}
public NvInternalResult UnregisterEvent(uint eventId)
{
if (eventId >= EventsCount)
{
return(NvInternalResult.InvalidInput);
}
NvHostEvent hostEvent = Events[eventId];
if (hostEvent == null)
{
return(NvInternalResult.Success);
}
if (hostEvent.State == NvHostEventState.Availaible || hostEvent.State == NvHostEventState.Cancelled || hostEvent.State == NvHostEventState.Signaled)
{
Events[eventId] = null;
return(NvInternalResult.Success);
}
return(NvInternalResult.Busy);
}
