b3f0978869
The AutoFlushCounter would flush command buffers on any attachment change (write mask or bindings change) if there was a pending query. This is to get query results as soon as possible for draw skips, but it's assuming that a full occlusion query _pass_ happened, that we want to flush it's data before getting onto draws, rather than the queries being randomly interspersed throughout a pass that also draws. Xenoblade 2 repeatedly switches between performing a samples passed query and outputting to a render target on each draw, and flips the write mask to do so. Flushing the command buffer every 2 draws isn't ideal, so it's best that we only do this if the pattern matches the large block style of occlusion query. This change makes this flush only happen after a few consecutive query reports. "Consecutive" is interrupted by attachment changes or command buffer flush. This doesn't really solve the issue where it resets more queries than it uses, it just stops the game doing it as often. I'm not sure of the best way to do that. The cost of resetting could probably be reduced by using query pools with more than one element and resetting in bulk.
113 lines
3.0 KiB
C#
113 lines
3.0 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
|
|
namespace Ryujinx.Graphics.Vulkan
|
|
{
|
|
internal class AutoFlushCounter
|
|
{
|
|
// How often to flush on framebuffer change.
|
|
private readonly static long FramebufferFlushTimer = Stopwatch.Frequency / 1000;
|
|
|
|
private const int MinDrawCountForFlush = 10;
|
|
private const int MinConsecutiveQueryForFlush = 10;
|
|
private const int InitialQueryCountForFlush = 32;
|
|
|
|
private long _lastFlush;
|
|
private ulong _lastDrawCount;
|
|
private bool _hasPendingQuery;
|
|
private int _consecutiveQueries;
|
|
private int _queryCount;
|
|
|
|
private int[] _queryCountHistory = new int[3];
|
|
private int _queryCountHistoryIndex;
|
|
private int _remainingQueries;
|
|
|
|
public void RegisterFlush(ulong drawCount)
|
|
{
|
|
_lastFlush = Stopwatch.GetTimestamp();
|
|
_lastDrawCount = drawCount;
|
|
|
|
_hasPendingQuery = false;
|
|
_consecutiveQueries = 0;
|
|
}
|
|
|
|
public bool RegisterPendingQuery()
|
|
{
|
|
_hasPendingQuery = true;
|
|
_consecutiveQueries++;
|
|
_remainingQueries--;
|
|
|
|
_queryCountHistory[_queryCountHistoryIndex]++;
|
|
|
|
// Interrupt render passes to flush queries, so that early results arrive sooner.
|
|
if (++_queryCount == InitialQueryCountForFlush)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public int GetRemainingQueries()
|
|
{
|
|
if (_remainingQueries <= 0)
|
|
{
|
|
_remainingQueries = 16;
|
|
}
|
|
|
|
if (_queryCount < InitialQueryCountForFlush)
|
|
{
|
|
return Math.Min(InitialQueryCountForFlush - _queryCount, _remainingQueries);
|
|
}
|
|
|
|
return _remainingQueries;
|
|
}
|
|
|
|
public bool ShouldFlushQuery()
|
|
{
|
|
return _hasPendingQuery;
|
|
}
|
|
|
|
public bool ShouldFlushAttachmentChange(ulong drawCount)
|
|
{
|
|
_queryCount = 0;
|
|
|
|
// Flush when there's an attachment change out of a large block of queries.
|
|
if (_consecutiveQueries > MinConsecutiveQueryForFlush)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
_consecutiveQueries = 0;
|
|
|
|
long draws = (long)(drawCount - _lastDrawCount);
|
|
|
|
if (draws < MinDrawCountForFlush)
|
|
{
|
|
if (draws == 0)
|
|
{
|
|
_lastFlush = Stopwatch.GetTimestamp();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
long flushTimeout = FramebufferFlushTimer;
|
|
|
|
long now = Stopwatch.GetTimestamp();
|
|
|
|
return now > _lastFlush + flushTimeout;
|
|
}
|
|
|
|
public void Present()
|
|
{
|
|
_queryCountHistoryIndex = (_queryCountHistoryIndex + 1) % 3;
|
|
|
|
_remainingQueries = _queryCountHistory.Max() + 10;
|
|
|
|
_queryCountHistory[_queryCountHistoryIndex] = 0;
|
|
}
|
|
}
|
|
}
|