mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-20 15:48:43 +02:00
This fixes a rare bug where reporting a counter for a region containing 0 draws could deadlock the GPU. If this write overlaps with a tracking action, then the GPU could end up waiting on something that it's meant to do in the future, so it would just get stuck. Before, this reported immediately and wrote the result to guest memory (tracked) from the backend thread. The backend thread cannot be allowed to trigger read actions that wait on the GPU, as it will end up waiting on itself, and never advancing. In the case of backend multithreading's `SyncMap`, it would try to wait for a backend sync object that does not yet exist, as the sync object would exist according to the GPU and tracking, but it has not yet been created by the backend (and never will be, since it's stuck). The fix is to queue the 0 draw event just like any other, its _bufferMap value is just forced to 0. This affects games that use Conditional Rendering: SMO, Splatoon 2, MK8. Was generally indicated by a red message in log saying that the query result timed out after 5000 tries, but not always the cause.
226 lines
6.4 KiB
C#
226 lines
6.4 KiB
C#
using OpenTK.Graphics.OpenGL;
|
|
using Ryujinx.Graphics.GAL;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
|
|
namespace Ryujinx.Graphics.OpenGL.Queries
|
|
{
|
|
class CounterQueue : IDisposable
|
|
{
|
|
private const int QueryPoolInitialSize = 100;
|
|
|
|
public CounterType Type { get; }
|
|
public bool Disposed { get; private set; }
|
|
|
|
private Queue<CounterQueueEvent> _events = new Queue<CounterQueueEvent>();
|
|
private CounterQueueEvent _current;
|
|
|
|
private ulong _accumulatedCounter;
|
|
private int _waiterCount;
|
|
|
|
private object _lock = new object();
|
|
|
|
private Queue<BufferedQuery> _queryPool;
|
|
private AutoResetEvent _queuedEvent = new AutoResetEvent(false);
|
|
private AutoResetEvent _wakeSignal = new AutoResetEvent(false);
|
|
private AutoResetEvent _eventConsumed = new AutoResetEvent(false);
|
|
|
|
private Thread _consumerThread;
|
|
|
|
internal CounterQueue(CounterType type)
|
|
{
|
|
Type = type;
|
|
|
|
QueryTarget glType = GetTarget(Type);
|
|
|
|
_queryPool = new Queue<BufferedQuery>(QueryPoolInitialSize);
|
|
for (int i = 0; i < QueryPoolInitialSize; i++)
|
|
{
|
|
_queryPool.Enqueue(new BufferedQuery(glType));
|
|
}
|
|
|
|
_current = new CounterQueueEvent(this, glType, 0);
|
|
|
|
_consumerThread = new Thread(EventConsumer);
|
|
_consumerThread.Start();
|
|
}
|
|
|
|
private void EventConsumer()
|
|
{
|
|
while (!Disposed)
|
|
{
|
|
CounterQueueEvent evt = null;
|
|
lock (_lock)
|
|
{
|
|
if (_events.Count > 0)
|
|
{
|
|
evt = _events.Dequeue();
|
|
}
|
|
}
|
|
|
|
if (evt == null)
|
|
{
|
|
_queuedEvent.WaitOne(); // No more events to go through, wait for more.
|
|
}
|
|
else
|
|
{
|
|
// Spin-wait rather than sleeping if there are any waiters, by passing null instead of the wake signal.
|
|
evt.TryConsume(ref _accumulatedCounter, true, _waiterCount == 0 ? _wakeSignal : null);
|
|
}
|
|
|
|
if (_waiterCount > 0)
|
|
{
|
|
_eventConsumed.Set();
|
|
}
|
|
}
|
|
}
|
|
|
|
internal BufferedQuery GetQueryObject()
|
|
{
|
|
// Creating/disposing query objects on a context we're sharing with will cause issues.
|
|
// So instead, make a lot of query objects on the main thread and reuse them.
|
|
|
|
lock (_lock)
|
|
{
|
|
if (_queryPool.Count > 0)
|
|
{
|
|
BufferedQuery result = _queryPool.Dequeue();
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
return new BufferedQuery(GetTarget(Type));
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void ReturnQueryObject(BufferedQuery query)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
_queryPool.Enqueue(query);
|
|
}
|
|
}
|
|
|
|
public CounterQueueEvent QueueReport(EventHandler<ulong> resultHandler, ulong lastDrawIndex, bool hostReserved)
|
|
{
|
|
CounterQueueEvent result;
|
|
ulong draws = lastDrawIndex - _current.DrawIndex;
|
|
|
|
lock (_lock)
|
|
{
|
|
// A query's result only matters if more than one draw was performed during it.
|
|
// Otherwise, dummy it out and return 0 immediately.
|
|
|
|
if (hostReserved)
|
|
{
|
|
// This counter event is guaranteed to be available for host conditional rendering.
|
|
_current.ReserveForHostAccess();
|
|
}
|
|
|
|
_current.Complete(draws > 0);
|
|
_events.Enqueue(_current);
|
|
|
|
_current.OnResult += resultHandler;
|
|
|
|
result = _current;
|
|
|
|
_current = new CounterQueueEvent(this, GetTarget(Type), lastDrawIndex);
|
|
}
|
|
|
|
_queuedEvent.Set();
|
|
|
|
return result;
|
|
}
|
|
|
|
public void QueueReset()
|
|
{
|
|
lock (_lock)
|
|
{
|
|
_current.Clear();
|
|
}
|
|
}
|
|
|
|
private static QueryTarget GetTarget(CounterType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case CounterType.SamplesPassed: return QueryTarget.SamplesPassed;
|
|
case CounterType.PrimitivesGenerated: return QueryTarget.PrimitivesGenerated;
|
|
case CounterType.TransformFeedbackPrimitivesWritten: return QueryTarget.TransformFeedbackPrimitivesWritten;
|
|
}
|
|
|
|
return QueryTarget.SamplesPassed;
|
|
}
|
|
|
|
public void Flush(bool blocking)
|
|
{
|
|
if (!blocking)
|
|
{
|
|
// Just wake the consumer thread - it will update the queries.
|
|
_wakeSignal.Set();
|
|
return;
|
|
}
|
|
|
|
lock (_lock)
|
|
{
|
|
// Tell the queue to process all events.
|
|
while (_events.Count > 0)
|
|
{
|
|
CounterQueueEvent flush = _events.Peek();
|
|
if (!flush.TryConsume(ref _accumulatedCounter, true))
|
|
{
|
|
return; // If not blocking, then return when we encounter an event that is not ready yet.
|
|
}
|
|
_events.Dequeue();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void FlushTo(CounterQueueEvent evt)
|
|
{
|
|
// Flush the counter queue on the main thread.
|
|
|
|
Interlocked.Increment(ref _waiterCount);
|
|
|
|
_wakeSignal.Set();
|
|
|
|
while (!evt.Disposed)
|
|
{
|
|
_eventConsumed.WaitOne(1);
|
|
}
|
|
|
|
Interlocked.Decrement(ref _waiterCount);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
lock (_lock)
|
|
{
|
|
while (_events.Count > 0)
|
|
{
|
|
CounterQueueEvent evt = _events.Dequeue();
|
|
|
|
evt.Dispose();
|
|
}
|
|
|
|
Disposed = true;
|
|
}
|
|
|
|
_queuedEvent.Set();
|
|
|
|
_consumerThread.Join();
|
|
|
|
foreach (BufferedQuery query in _queryPool)
|
|
{
|
|
query.Dispose();
|
|
}
|
|
|
|
_queuedEvent.Dispose();
|
|
_wakeSignal.Dispose();
|
|
_eventConsumed.Dispose();
|
|
}
|
|
}
|
|
}
|