mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-20 07:38:42 +02:00
* Reset queries on same command buffer Vulkan seems to complain when the queries are reset on another command buffer. No idea why, the spec really could be written better in this regard. This fixes complaints, and hopefully any implementations that care extensively about them. This change _guesses_ how many queries need to be reset and resets as many as possible at the same time to avoid splitting render passes. If it resets too many queries, we didn't waste too much time - if it runs out of resets it will batch reset 10 more. The number of queries reset is the maximum number of queries in the last 3 frames. This has been worked into the AutoFlushCounter so that it only resets up to 32 if it is yet to force a command buffer submission in this attachment. This is only done for samples passed queries right now, as they have by far the most resets. * Address Feedback
246 lines
7.2 KiB
C#
246 lines
7.2 KiB
C#
using Ryujinx.Graphics.GAL;
|
|
using Silk.NET.Vulkan;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
using System.Linq;
|
|
|
|
namespace Ryujinx.Graphics.Vulkan.Queries
|
|
{
|
|
class CounterQueue : IDisposable
|
|
{
|
|
private const int QueryPoolInitialSize = 100;
|
|
|
|
private readonly VulkanRenderer _gd;
|
|
private readonly Device _device;
|
|
private readonly PipelineFull _pipeline;
|
|
|
|
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;
|
|
|
|
public int ResetSequence { get; private set; }
|
|
|
|
internal CounterQueue(VulkanRenderer gd, Device device, PipelineFull pipeline, CounterType type)
|
|
{
|
|
_gd = gd;
|
|
_device = device;
|
|
_pipeline = pipeline;
|
|
|
|
Type = type;
|
|
|
|
_queryPool = new Queue<BufferedQuery>(QueryPoolInitialSize);
|
|
for (int i = 0; i < QueryPoolInitialSize; i++)
|
|
{
|
|
// AMD Polaris GPUs on Windows seem to have issues reporting 64-bit query results.
|
|
_queryPool.Enqueue(new BufferedQuery(_gd, _device, _pipeline, type, gd.IsAmdWindows));
|
|
}
|
|
|
|
_current = new CounterQueueEvent(this, type, 0);
|
|
|
|
_consumerThread = new Thread(EventConsumer);
|
|
_consumerThread.Start();
|
|
}
|
|
|
|
public void ResetCounterPool()
|
|
{
|
|
ResetSequence++;
|
|
}
|
|
|
|
public void ResetFutureCounters(CommandBuffer cmd, int count)
|
|
{
|
|
// Pre-emptively reset queries to avoid render pass splitting.
|
|
lock (_queryPool)
|
|
{
|
|
count = Math.Min(count, _queryPool.Count);
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
_queryPool.ElementAt(i).PoolReset(cmd, ResetSequence);
|
|
}
|
|
}
|
|
}
|
|
|
|
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(_gd, _device, _pipeline, Type, _gd.IsAmdWindows);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void ReturnQueryObject(BufferedQuery query)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
// The query will be reset when it dequeues.
|
|
_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 && Type != CounterType.TransformFeedbackPrimitivesWritten);
|
|
_events.Enqueue(_current);
|
|
|
|
_current.OnResult += resultHandler;
|
|
|
|
result = _current;
|
|
|
|
_current = new CounterQueueEvent(this, Type, lastDrawIndex);
|
|
}
|
|
|
|
_queuedEvent.Set();
|
|
|
|
return result;
|
|
}
|
|
|
|
public void QueueReset(ulong lastDrawIndex)
|
|
{
|
|
ulong draws = lastDrawIndex - _current.DrawIndex;
|
|
|
|
lock (_lock)
|
|
{
|
|
_current.Clear(draws != 0);
|
|
}
|
|
}
|
|
|
|
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();
|
|
|
|
_current?.Dispose();
|
|
|
|
foreach (BufferedQuery query in _queryPool)
|
|
{
|
|
query.Dispose();
|
|
}
|
|
|
|
_queuedEvent.Dispose();
|
|
_wakeSignal.Dispose();
|
|
_eventConsumed.Dispose();
|
|
}
|
|
}
|
|
}
|