From 6bfe4715f05be10c73a788abd8727293a7eca77e Mon Sep 17 00:00:00 2001 From: gdkchan Date: Wed, 22 Apr 2020 03:00:11 -0300 Subject: [PATCH] Initial conditional rendering support (#1012) * Initial conditional rendering support * Properly reset state * Support conditional modes and skeleton a counter cache for future host conditional rendering * Address PR feedback --- Ryujinx.Graphics.Gpu/Engine/MethodClear.cs | 5 + .../Engine/MethodConditionalRendering.cs | 82 ++++++++++ Ryujinx.Graphics.Gpu/Engine/MethodDraw.cs | 9 +- Ryujinx.Graphics.Gpu/Engine/MethodReport.cs | 7 + Ryujinx.Graphics.Gpu/Engine/Methods.cs | 2 + Ryujinx.Graphics.Gpu/Memory/CounterCache.cs | 140 ++++++++++++++++++ Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs | 9 +- Ryujinx.Graphics.Gpu/Memory/UnmapEventArgs.cs | 14 ++ Ryujinx.Graphics.Gpu/State/GpuState.cs | 3 + 9 files changed, 269 insertions(+), 2 deletions(-) create mode 100644 Ryujinx.Graphics.Gpu/Engine/MethodConditionalRendering.cs create mode 100644 Ryujinx.Graphics.Gpu/Memory/CounterCache.cs create mode 100644 Ryujinx.Graphics.Gpu/Memory/UnmapEventArgs.cs diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodClear.cs b/Ryujinx.Graphics.Gpu/Engine/MethodClear.cs index ff538df332..a555015d48 100644 --- a/Ryujinx.Graphics.Gpu/Engine/MethodClear.cs +++ b/Ryujinx.Graphics.Gpu/Engine/MethodClear.cs @@ -13,6 +13,11 @@ namespace Ryujinx.Graphics.Gpu.Engine /// Method call argument private void Clear(GpuState state, int argument) { + if (!GetRenderEnable(state)) + { + return; + } + // Scissor affects clears aswell. if (state.QueryModified(MethodOffset.ScissorState)) { diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodConditionalRendering.cs b/Ryujinx.Graphics.Gpu/Engine/MethodConditionalRendering.cs new file mode 100644 index 0000000000..4775de02f7 --- /dev/null +++ b/Ryujinx.Graphics.Gpu/Engine/MethodConditionalRendering.cs @@ -0,0 +1,82 @@ +using Ryujinx.Common.Logging; +using Ryujinx.Graphics.Gpu.State; + +namespace Ryujinx.Graphics.Gpu.Engine +{ + partial class Methods + { + /// + /// Checks if draws and clears should be performed, according + /// to currently set conditional rendering conditions. + /// + /// GPU state + /// True if rendering is enabled, false otherwise + private bool GetRenderEnable(GpuState state) + { + ConditionState condState = state.Get(MethodOffset.ConditionState); + + switch (condState.Condition) + { + case Condition.Always: + return true; + case Condition.Never: + return false; + case Condition.ResultNonZero: + return CounterNonZero(condState.Address.Pack()); + case Condition.Equal: + return CounterCompare(condState.Address.Pack(), true); + case Condition.NotEqual: + return CounterCompare(condState.Address.Pack(), false); + } + + Logger.PrintWarning(LogClass.Gpu, $"Invalid conditional render condition \"{condState.Condition}\"."); + + return true; + } + + /// + /// Checks if the counter value at a given GPU memory address is non-zero. + /// + /// GPU virtual address of the counter value + /// True if the value is not zero, false otherwise + private bool CounterNonZero(ulong gpuVa) + { + if (!FindAndFlush(gpuVa)) + { + return false; + } + + return _context.MemoryAccessor.ReadUInt64(gpuVa) != 0; + } + + /// + /// Checks if the counter at a given GPU memory address passes a specified equality comparison. + /// + /// GPU virtual address + /// True to check if the values are equal, false to check if they are not equal + /// True if the condition is met, false otherwise + private bool CounterCompare(ulong gpuVa, bool isEqual) + { + if (!FindAndFlush(gpuVa) && !FindAndFlush(gpuVa + 16)) + { + return false; + } + + ulong x = _context.MemoryAccessor.ReadUInt64(gpuVa); + ulong y = _context.MemoryAccessor.ReadUInt64(gpuVa + 16); + + return isEqual ? x == y : x != y; + } + + /// + /// Tries to find a counter that is supposed to be written at the specified address, + /// flushing if necessary. + /// + /// GPU virtual address where the counter is supposed to be written + /// True if a counter value is found at the specified address, false otherwise + private bool FindAndFlush(ulong gpuVa) + { + return _counterCache.Contains(gpuVa); + } + } +} diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodDraw.cs b/Ryujinx.Graphics.Gpu/Engine/MethodDraw.cs index b13cc9cab3..68131f6262 100644 --- a/Ryujinx.Graphics.Gpu/Engine/MethodDraw.cs +++ b/Ryujinx.Graphics.Gpu/Engine/MethodDraw.cs @@ -35,8 +35,15 @@ namespace Ryujinx.Graphics.Gpu.Engine /// Method call argument private void DrawEnd(GpuState state, int argument) { - if (_instancedDrawPending) + bool renderEnable = GetRenderEnable(state); + + if (!renderEnable || _instancedDrawPending) { + if (!renderEnable) + { + PerformDeferredDraws(); + } + _drawIndexed = false; return; diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodReport.cs b/Ryujinx.Graphics.Gpu/Engine/MethodReport.cs index 15151c62ac..eeec3569cb 100644 --- a/Ryujinx.Graphics.Gpu/Engine/MethodReport.cs +++ b/Ryujinx.Graphics.Gpu/Engine/MethodReport.cs @@ -1,5 +1,6 @@ using Ryujinx.Common; using Ryujinx.Graphics.GAL; +using Ryujinx.Graphics.Gpu.Memory; using Ryujinx.Graphics.Gpu.State; using System; using System.Runtime.InteropServices; @@ -11,6 +12,10 @@ namespace Ryujinx.Graphics.Gpu.Engine private const int NsToTicksFractionNumerator = 384; private const int NsToTicksFractionDenominator = 625; + private ulong _runningCounter; + + private readonly CounterCache _counterCache = new CounterCache(); + /// /// Writes a GPU counter to guest memory. /// @@ -98,6 +103,8 @@ namespace Ryujinx.Graphics.Gpu.Engine var rs = state.Get(MethodOffset.ReportState); _context.MemoryAccessor.Write(rs.Address.Pack(), data); + + _counterCache.AddOrUpdate(rs.Address.Pack()); } /// diff --git a/Ryujinx.Graphics.Gpu/Engine/Methods.cs b/Ryujinx.Graphics.Gpu/Engine/Methods.cs index 39a902e891..2e6c9828cd 100644 --- a/Ryujinx.Graphics.Gpu/Engine/Methods.cs +++ b/Ryujinx.Graphics.Gpu/Engine/Methods.cs @@ -52,6 +52,8 @@ namespace Ryujinx.Graphics.Gpu.Engine BufferManager = new BufferManager(context); TextureManager = new TextureManager(context); + + context.MemoryManager.MemoryUnmapped += _counterCache.MemoryUnmappedHandler; } /// diff --git a/Ryujinx.Graphics.Gpu/Memory/CounterCache.cs b/Ryujinx.Graphics.Gpu/Memory/CounterCache.cs new file mode 100644 index 0000000000..3110cdcc49 --- /dev/null +++ b/Ryujinx.Graphics.Gpu/Memory/CounterCache.cs @@ -0,0 +1,140 @@ +using System.Collections.Generic; + +namespace Ryujinx.Graphics.Gpu.Memory +{ + /// + /// Represents the GPU counter cache. + /// + class CounterCache + { + private struct CounterEntry + { + public ulong Address { get; } + + public CounterEntry(ulong address) + { + Address = address; + } + } + + private readonly List _items; + + /// + /// Creates a new instance of the GPU counter cache. + /// + public CounterCache() + { + _items = new List(); + } + + /// + /// Adds a new counter to the counter cache, or updates a existing one. + /// + /// GPU virtual address where the counter will be written in memory + public void AddOrUpdate(ulong gpuVa) + { + int index = BinarySearch(gpuVa); + + CounterEntry entry = new CounterEntry(gpuVa); + + if (index < 0) + { + _items.Insert(~index, entry); + } + else + { + _items[index] = entry; + } + } + + /// + /// Handles removal of counters written to a memory region being unmapped. + /// + /// Sender object + /// Event arguments + public void MemoryUnmappedHandler(object sender, UnmapEventArgs e) => RemoveRange(e.Address, e.Size); + + private void RemoveRange(ulong gpuVa, ulong size) + { + int index = BinarySearch(gpuVa + size - 1); + + if (index < 0) + { + index = ~index; + } + + if (index >= _items.Count || !InRange(gpuVa, size, _items[index].Address)) + { + return; + } + + int count = 1; + + while (index > 0 && InRange(gpuVa, size, _items[index - 1].Address)) + { + index--; + count++; + } + + _items.RemoveRange(index, count); + } + + /// + /// Checks whenever an address falls inside a given range. + /// + /// Range start address + /// Range size + /// Address being checked + /// True if the address falls inside the range, false otherwise + private static bool InRange(ulong startVa, ulong size, ulong gpuVa) + { + return gpuVa >= startVa && gpuVa < startVa + size; + } + + /// + /// Check if any counter value was written to the specified GPU virtual memory address. + /// + /// GPU virtual address + /// True if any counter value was written on the specified address, false otherwise + public bool Contains(ulong gpuVa) + { + return BinarySearch(gpuVa) >= 0; + } + + /// + /// Performs binary search of an address on the list. + /// + /// Address to search + /// Index of the item, or complement of the index of the nearest item with lower value + private int BinarySearch(ulong address) + { + int left = 0; + int right = _items.Count - 1; + + while (left <= right) + { + int range = right - left; + + int middle = left + (range >> 1); + + CounterEntry item = _items[middle]; + + if (item.Address == address) + { + return middle; + } + + if (address < item.Address) + { + right = middle - 1; + } + else + { + left = middle + 1; + } + } + + return ~left; + } + } +} diff --git a/Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs b/Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs index e89255c884..f4af86f312 100644 --- a/Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs +++ b/Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs @@ -1,3 +1,5 @@ +using System; + namespace Ryujinx.Graphics.Gpu.Memory { /// @@ -27,7 +29,9 @@ namespace Ryujinx.Graphics.Gpu.Memory private const ulong PteUnmapped = 0xffffffff_ffffffff; private const ulong PteReserved = 0xffffffff_fffffffe; - private ulong[][] _pageTable; + private readonly ulong[][] _pageTable; + + public event EventHandler MemoryUnmapped; /// /// Creates a new instance of the GPU memory manager. @@ -181,6 +185,9 @@ namespace Ryujinx.Graphics.Gpu.Memory { SetPte(va + offset, PteUnmapped); } + + // Event handlers are not expected to be thread safe. + MemoryUnmapped?.Invoke(this, new UnmapEventArgs(va, size)); } } diff --git a/Ryujinx.Graphics.Gpu/Memory/UnmapEventArgs.cs b/Ryujinx.Graphics.Gpu/Memory/UnmapEventArgs.cs new file mode 100644 index 0000000000..305747f855 --- /dev/null +++ b/Ryujinx.Graphics.Gpu/Memory/UnmapEventArgs.cs @@ -0,0 +1,14 @@ +namespace Ryujinx.Graphics.Gpu.Memory +{ + public class UnmapEventArgs + { + public ulong Address { get; } + public ulong Size { get; } + + public UnmapEventArgs(ulong address, ulong size) + { + Address = address; + Size = size; + } + } +} diff --git a/Ryujinx.Graphics.Gpu/State/GpuState.cs b/Ryujinx.Graphics.Gpu/State/GpuState.cs index 9e0e50a04a..981b96b7fd 100644 --- a/Ryujinx.Graphics.Gpu/State/GpuState.cs +++ b/Ryujinx.Graphics.Gpu/State/GpuState.cs @@ -133,6 +133,9 @@ namespace Ryujinx.Graphics.Gpu.State // Default front stencil mask. _backingMemory[0x4e7] = 0xff; + // Conditional rendering condition. + _backingMemory[0x556] = (int)Condition.Always; + // Default color mask. for (int index = 0; index < Constants.TotalRenderTargets; index++) {