1
0
Fork 0
forked from Mirror/Ryujinx
Ryujinx/Ryujinx.Graphics.Vulkan/Queries/BufferedQuery.cs
riperiperi 6e9bd4de13
GPU: Scale counter results before addition ()
* 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.
2023-03-12 18:01:15 +01:00

216 lines
6.7 KiB
C#

using Ryujinx.Common.Logging;
using Ryujinx.Graphics.GAL;
using Silk.NET.Vulkan;
using System;
using System.Runtime.InteropServices;
using System.Threading;
namespace Ryujinx.Graphics.Vulkan.Queries
{
class BufferedQuery : IDisposable
{
private const int MaxQueryRetries = 5000;
private const long DefaultValue = -1;
private const long DefaultValueInt = 0xFFFFFFFF;
private const ulong HighMask = 0xFFFFFFFF00000000;
private readonly Vk _api;
private readonly Device _device;
private readonly PipelineFull _pipeline;
private QueryPool _queryPool;
private readonly BufferHolder _buffer;
private readonly IntPtr _bufferMap;
private readonly CounterType _type;
private bool _result32Bit;
private bool _isSupported;
private long _defaultValue;
private int? _resetSequence;
public unsafe BufferedQuery(VulkanRenderer gd, Device device, PipelineFull pipeline, CounterType type, bool result32Bit)
{
_api = gd.Api;
_device = device;
_pipeline = pipeline;
_type = type;
_result32Bit = result32Bit;
_isSupported = QueryTypeSupported(gd, type);
if (_isSupported)
{
QueryPipelineStatisticFlags flags = type == CounterType.PrimitivesGenerated ?
QueryPipelineStatisticFlags.GeometryShaderPrimitivesBit : 0;
var queryPoolCreateInfo = new QueryPoolCreateInfo()
{
SType = StructureType.QueryPoolCreateInfo,
QueryCount = 1,
QueryType = GetQueryType(type),
PipelineStatistics = flags
};
gd.Api.CreateQueryPool(device, queryPoolCreateInfo, null, out _queryPool).ThrowOnError();
}
var buffer = gd.BufferManager.Create(gd, sizeof(long), forConditionalRendering: true);
_bufferMap = buffer.Map(0, sizeof(long));
_defaultValue = result32Bit ? DefaultValueInt : DefaultValue;
Marshal.WriteInt64(_bufferMap, _defaultValue);
_buffer = buffer;
}
private bool QueryTypeSupported(VulkanRenderer gd, CounterType type)
{
return type switch
{
CounterType.SamplesPassed => true,
CounterType.PrimitivesGenerated => gd.Capabilities.SupportsPipelineStatisticsQuery,
CounterType.TransformFeedbackPrimitivesWritten => gd.Capabilities.SupportsTransformFeedbackQueries,
_ => false
};
}
private static QueryType GetQueryType(CounterType type)
{
return type switch
{
CounterType.SamplesPassed => QueryType.Occlusion,
CounterType.PrimitivesGenerated => QueryType.PipelineStatistics,
CounterType.TransformFeedbackPrimitivesWritten => QueryType.TransformFeedbackStreamExt,
_ => QueryType.Occlusion
};
}
public Auto<DisposableBuffer> GetBuffer()
{
return _buffer.GetBuffer();
}
public void Reset()
{
End(false);
Begin(null);
}
public void Begin(int? resetSequence)
{
if (_isSupported)
{
bool needsReset = resetSequence == null || _resetSequence == null || resetSequence.Value != _resetSequence.Value;
bool isOcclusion = _type == CounterType.SamplesPassed;
_pipeline.BeginQuery(this, _queryPool, needsReset, isOcclusion, isOcclusion && resetSequence != null);
}
_resetSequence = null;
}
public unsafe void End(bool withResult)
{
if (_isSupported)
{
_pipeline.EndQuery(_queryPool);
}
if (withResult && _isSupported)
{
Marshal.WriteInt64(_bufferMap, _defaultValue);
_pipeline.CopyQueryResults(this);
}
else
{
// Dummy result, just return 0.
Marshal.WriteInt64(_bufferMap, 0);
}
}
private bool WaitingForValue(long data)
{
return data == _defaultValue ||
(!_result32Bit && ((ulong)data & HighMask) == ((ulong)_defaultValue & HighMask));
}
public bool TryGetResult(out long result)
{
result = Marshal.ReadInt64(_bufferMap);
return result != _defaultValue;
}
public long AwaitResult(AutoResetEvent wakeSignal = null)
{
long data = _defaultValue;
if (wakeSignal == null)
{
while (WaitingForValue(data))
{
data = Marshal.ReadInt64(_bufferMap);
}
}
else
{
int iterations = 0;
while (WaitingForValue(data) && iterations++ < MaxQueryRetries)
{
data = Marshal.ReadInt64(_bufferMap);
if (WaitingForValue(data))
{
wakeSignal.WaitOne(1);
}
}
if (iterations >= MaxQueryRetries)
{
Logger.Error?.Print(LogClass.Gpu, $"Error: Query result {_type} timed out. Took more than {MaxQueryRetries} tries.");
}
}
return data;
}
public void PoolReset(CommandBuffer cmd, int resetSequence)
{
if (_isSupported)
{
_api.CmdResetQueryPool(cmd, _queryPool, 0, 1);
}
_resetSequence = resetSequence;
}
public void PoolCopy(CommandBufferScoped cbs)
{
var buffer = _buffer.GetBuffer(cbs.CommandBuffer, true).Get(cbs, 0, sizeof(long)).Value;
QueryResultFlags flags = QueryResultFlags.ResultWaitBit;
if (!_result32Bit)
{
flags |= QueryResultFlags.Result64Bit;
}
_api.CmdCopyQueryPoolResults(
cbs.CommandBuffer,
_queryPool,
0,
1,
buffer,
0,
(ulong)(_result32Bit ? sizeof(int) : sizeof(long)),
flags);
}
public unsafe void Dispose()
{
_buffer.Dispose();
if (_isSupported)
{
_api.DestroyQueryPool(_device, _queryPool, null);
}
_queryPool = default;
}
}
}