mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-09-11 10:18:52 +02:00
* Initial implementation of buffer flush (VERY WIP) * Host shaders need to be rebuilt for the SSBO write flag. * New approach with reserved regions and gl sync * Fix a ton of buffer issues. * Remove unused buffer unmapped behaviour * Revert "Remove unused buffer unmapped behaviour" This reverts commit f1700e52fb8760180ac5e0987a07d409d1e70ece. * Delete modified ranges on unmap Fixes potential crashes in Super Smash Bros, where a previously modified range could lie on either side of an unmap. * Cache some more delegates. * Dispose Sync on Close * Also create host sync for GPFifo syncpoint increment. * Copy buffer optimization, add docs * Fix race condition with OpenGL Sync * Enable read tracking on CommandBuffer, insert syncpoint on WaitForIdle * Performance: Only flush individual pages of SSBO at a time This avoids flushing large amounts of data when only a small amount is actually used. * Signal Modified rather than flushing after clear * Fix some docs and code style. * Introduce a new test for tracking memory protection. Sucessfully demonstrates that the bug causing write protection to be cleared by a read action has been fixed. (these tests fail on master) * Address Comments * Add host sync for SetReference This ensures that any indirect draws will correctly flush any related buffer data written before them. Fixes some flashing and misplaced world geometry in MH rise. * Make PageAlign static * Re-enable read tracking, for reads.
225 lines
8.5 KiB
C#
225 lines
8.5 KiB
C#
using Ryujinx.Graphics.Device;
|
|
using Ryujinx.Graphics.Gpu.Engine.MME;
|
|
using Ryujinx.Graphics.Gpu.State;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
|
|
namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|
{
|
|
/// <summary>
|
|
/// Represents a GPU General Purpose FIFO class.
|
|
/// </summary>
|
|
class GPFifoClass : IDeviceState
|
|
{
|
|
private readonly GpuContext _context;
|
|
private readonly GPFifoProcessor _parent;
|
|
private readonly DeviceState<GPFifoClassState> _state;
|
|
|
|
private const int MacrosCount = 0x80;
|
|
|
|
// Note: The size of the macro memory is unknown, we just make
|
|
// a guess here and use 256kb as the size. Increase if needed.
|
|
private const int MacroCodeSize = 256 * 256;
|
|
|
|
private readonly Macro[] _macros;
|
|
private readonly int[] _macroCode;
|
|
|
|
/// <summary>
|
|
/// Creates a new instance of the GPU General Purpose FIFO class.
|
|
/// </summary>
|
|
/// <param name="context">GPU context</param>
|
|
/// <param name="parent">Parent GPU General Purpose FIFO processor</param>
|
|
public GPFifoClass(GpuContext context, GPFifoProcessor parent)
|
|
{
|
|
_context = context;
|
|
_parent = parent;
|
|
_state = new DeviceState<GPFifoClassState>(new Dictionary<string, RwCallback>
|
|
{
|
|
{ nameof(GPFifoClassState.Semaphored), new RwCallback(Semaphored, null) },
|
|
{ nameof(GPFifoClassState.Syncpointb), new RwCallback(Syncpointb, null) },
|
|
{ nameof(GPFifoClassState.WaitForIdle), new RwCallback(WaitForIdle, null) },
|
|
{ nameof(GPFifoClassState.SetReference), new RwCallback(SetReference, null) },
|
|
{ nameof(GPFifoClassState.LoadMmeInstructionRam), new RwCallback(LoadMmeInstructionRam, null) },
|
|
{ nameof(GPFifoClassState.LoadMmeStartAddressRam), new RwCallback(LoadMmeStartAddressRam, null) },
|
|
{ nameof(GPFifoClassState.SetMmeShadowRamControl), new RwCallback(SetMmeShadowRamControl, null) }
|
|
});
|
|
|
|
_macros = new Macro[MacrosCount];
|
|
_macroCode = new int[MacroCodeSize];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads data from the class registers.
|
|
/// </summary>
|
|
/// <param name="offset">Register byte offset</param>
|
|
/// <returns>Data at the specified offset</returns>
|
|
public int Read(int offset) => _state.Read(offset);
|
|
|
|
/// <summary>
|
|
/// Writes data to the class registers.
|
|
/// </summary>
|
|
/// <param name="offset">Register byte offset</param>
|
|
/// <param name="data">Data to be written</param>
|
|
public void Write(int offset, int data) => _state.Write(offset, data);
|
|
|
|
/// <summary>
|
|
/// Writes a GPU counter to guest memory.
|
|
/// </summary>
|
|
/// <param name="argument">Method call argument</param>
|
|
public void Semaphored(int argument)
|
|
{
|
|
ulong address = ((ulong)_state.State.SemaphorebOffsetLower << 2) |
|
|
((ulong)_state.State.SemaphoreaOffsetUpper << 32);
|
|
|
|
int value = _state.State.SemaphorecPayload;
|
|
|
|
SemaphoredOperation operation = _state.State.SemaphoredOperation;
|
|
|
|
// TODO: Acquire operations (Wait), interrupts for invalid combinations.
|
|
if (operation == SemaphoredOperation.Release)
|
|
{
|
|
_context.MemoryManager.Write(address, value);
|
|
}
|
|
else if (operation == SemaphoredOperation.Reduction)
|
|
{
|
|
bool signed = _state.State.SemaphoredFormat == SemaphoredFormat.Signed;
|
|
|
|
int mem = _context.MemoryManager.Read<int>(address);
|
|
|
|
switch (_state.State.SemaphoredReduction)
|
|
{
|
|
case SemaphoredReduction.Min:
|
|
value = signed ? Math.Min(mem, value) : (int)Math.Min((uint)mem, (uint)value);
|
|
break;
|
|
case SemaphoredReduction.Max:
|
|
value = signed ? Math.Max(mem, value) : (int)Math.Max((uint)mem, (uint)value);
|
|
break;
|
|
case SemaphoredReduction.Xor:
|
|
value ^= mem;
|
|
break;
|
|
case SemaphoredReduction.And:
|
|
value &= mem;
|
|
break;
|
|
case SemaphoredReduction.Or:
|
|
value |= mem;
|
|
break;
|
|
case SemaphoredReduction.Add:
|
|
value += mem;
|
|
break;
|
|
case SemaphoredReduction.Inc:
|
|
value = (uint)mem < (uint)value ? mem + 1 : 0;
|
|
break;
|
|
case SemaphoredReduction.Dec:
|
|
value = (uint)mem > 0 && (uint)mem <= (uint)value ? mem - 1 : value;
|
|
break;
|
|
}
|
|
|
|
_context.MemoryManager.Write(address, value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Apply a fence operation on a syncpoint.
|
|
/// </summary>
|
|
/// <param name="argument">Method call argument</param>
|
|
public void Syncpointb(int argument)
|
|
{
|
|
SyncpointbOperation operation = _state.State.SyncpointbOperation;
|
|
|
|
uint syncpointId = (uint)_state.State.SyncpointbSyncptIndex;
|
|
|
|
if (operation == SyncpointbOperation.Wait)
|
|
{
|
|
uint threshold = (uint)_state.State.SyncpointaPayload;
|
|
|
|
_context.Synchronization.WaitOnSyncpoint(syncpointId, threshold, Timeout.InfiniteTimeSpan);
|
|
}
|
|
else if (operation == SyncpointbOperation.Incr)
|
|
{
|
|
_context.CreateHostSyncIfNeeded();
|
|
_context.Synchronization.IncrementSyncpoint(syncpointId);
|
|
}
|
|
|
|
_context.AdvanceSequence();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Waits for the GPU to be idle.
|
|
/// </summary>
|
|
/// <param name="argument">Method call argument</param>
|
|
public void WaitForIdle(int argument)
|
|
{
|
|
_context.Methods.PerformDeferredDraws();
|
|
_context.Renderer.Pipeline.Barrier();
|
|
|
|
_context.CreateHostSyncIfNeeded();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used as an indirect data barrier on NVN. When used, access to previously written data must be coherent.
|
|
/// </summary>
|
|
/// <param name="argument">Method call argument</param>
|
|
public void SetReference(int argument)
|
|
{
|
|
_context.CreateHostSyncIfNeeded();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sends macro code/data to the MME.
|
|
/// </summary>
|
|
/// <param name="argument">Method call argument</param>
|
|
public void LoadMmeInstructionRam(int argument)
|
|
{
|
|
_macroCode[_state.State.LoadMmeInstructionRamPointer++] = argument;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Binds a macro index to a position for the MME
|
|
/// </summary>
|
|
/// <param name="argument">Method call argument</param>
|
|
public void LoadMmeStartAddressRam(int argument)
|
|
{
|
|
_macros[_state.State.LoadMmeStartAddressRamPointer++] = new Macro(argument);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Changes the shadow RAM control.
|
|
/// </summary>
|
|
/// <param name="argument">Method call argument</param>
|
|
public void SetMmeShadowRamControl(int argument)
|
|
{
|
|
_parent.SetShadowRamControl((ShadowRamControl)argument);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pushes an argument to a macro.
|
|
/// </summary>
|
|
/// <param name="index">Index of the macro</param>
|
|
/// <param name="argument">Argument to be pushed to the macro</param>
|
|
public void MmePushArgument(int index, int argument)
|
|
{
|
|
_macros[index].PushArgument(argument);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prepares a macro for execution.
|
|
/// </summary>
|
|
/// <param name="index">Index of the macro</param>
|
|
/// <param name="argument">Initial argument passed to the macro</param>
|
|
public void MmeStart(int index, int argument)
|
|
{
|
|
_macros[index].StartExecution(argument);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Executes a macro.
|
|
/// </summary>
|
|
/// <param name="index">Index of the macro</param>
|
|
/// <param name="state">Current GPU state</param>
|
|
public void CallMme(int index, GpuState state)
|
|
{
|
|
_macros[index].Execute(_macroCode, state);
|
|
}
|
|
}
|
|
}
|