mirror of
https://github.com/GreemDev/Ryujinx
synced 2024-12-05 07:52:10 +01:00
6e9bd4de13
* GPU: Scale counter results before addition Counter results were being scaled on ReportCounter, which meant that the _total_ value of the counter was being scaled. Not only could this result in very large numbers and weird overflows if the game doesn't clear the counter, but it also caused the result to change drastically. This PR changes scaling to be done when the value is added to the counter on the backend. This should evaluate the scale at the same time as before, on report counter, but avoiding the issue with scaling the total. Fixes scaling in Warioware, at least in the demo, where it seems to compare old/new counters and broke down when scaling was enabled. * Fix issues when result is partially uploaded. Drivers tend to write the low half first, then the high half. Retry if the high half is FFFFFFFF.
245 lines
7.2 KiB
C#
245 lines
7.2 KiB
C#
using Ryujinx.Graphics.GAL;
|
|
using Silk.NET.Vulkan;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
|
|
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, _pipeline.GetCounterDivisor(Type));
|
|
_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();
|
|
}
|
|
}
|
|
}
|