mirror of
https://github.com/ryujinx-mirror/ryujinx.git
synced 2024-11-22 10:05:10 +00:00
Initial support for GPU channels (#2372)
* Ground work for separate GPU channels * Rename TextureManager to TextureCache * Decouple texture bindings management from the texture cache * Rename BufferManager to BufferCache * Decouple buffer bindings management from the buffer cache * More comments and proper disposal * PR feedback * Force host state update on channel switch * Typo * PR feedback * Missing using
This commit is contained in:
gdkchan
GitHub
parent
12a7a2ead8
commit
a10b2c5ff2
24 changed files with 1745 additions and 1456 deletions
|
|
@ -40,7 +40,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
ulong gpuVa = (uint)qmd.ConstantBufferAddrLower(index) | (ulong)qmd.ConstantBufferAddrUpper(index) << 32;
|
||||
ulong size = (ulong)qmd.ConstantBufferSize(index);
|
||||
|
||||
BufferManager.SetComputeUniformBuffer(index, gpuVa, size);
|
||||
state.Channel.BufferManager.SetComputeUniformBuffer(index, gpuVa, size);
|
||||
}
|
||||
|
||||
ShaderBundle cs = ShaderCache.GetComputeShader(
|
||||
|
|
@ -57,9 +57,9 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
var samplerPool = state.Get<PoolState>(MethodOffset.SamplerPoolState);
|
||||
var texturePool = state.Get<PoolState>(MethodOffset.TexturePoolState);
|
||||
|
||||
TextureManager.SetComputeSamplerPool(samplerPool.Address.Pack(), samplerPool.MaximumId, qmd.SamplerIndex);
|
||||
TextureManager.SetComputeTexturePool(texturePool.Address.Pack(), texturePool.MaximumId);
|
||||
TextureManager.SetComputeTextureBufferIndex(state.Get<int>(MethodOffset.TextureBufferIndex));
|
||||
state.Channel.TextureManager.SetComputeSamplerPool(samplerPool.Address.Pack(), samplerPool.MaximumId, qmd.SamplerIndex);
|
||||
state.Channel.TextureManager.SetComputeTexturePool(texturePool.Address.Pack(), texturePool.MaximumId);
|
||||
state.Channel.TextureManager.SetComputeTextureBufferIndex(state.Get<int>(MethodOffset.TextureBufferIndex));
|
||||
|
||||
ShaderProgramInfo info = cs.Shaders[0].Info;
|
||||
|
||||
|
|
@ -76,7 +76,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
continue;
|
||||
}
|
||||
|
||||
ulong cbDescAddress = BufferManager.GetComputeUniformBufferAddress(0);
|
||||
ulong cbDescAddress = state.Channel.BufferManager.GetComputeUniformBufferAddress(0);
|
||||
|
||||
int cbDescOffset = 0x260 + (cb.Slot - 8) * 0x10;
|
||||
|
||||
|
|
@ -84,14 +84,14 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
SbDescriptor cbDescriptor = _context.PhysicalMemory.Read<SbDescriptor>(cbDescAddress);
|
||||
|
||||
BufferManager.SetComputeUniformBuffer(cb.Slot, cbDescriptor.PackAddress(), (uint)cbDescriptor.Size);
|
||||
state.Channel.BufferManager.SetComputeUniformBuffer(cb.Slot, cbDescriptor.PackAddress(), (uint)cbDescriptor.Size);
|
||||
}
|
||||
|
||||
for (int index = 0; index < info.SBuffers.Count; index++)
|
||||
{
|
||||
BufferDescriptor sb = info.SBuffers[index];
|
||||
|
||||
ulong sbDescAddress = BufferManager.GetComputeUniformBufferAddress(0);
|
||||
ulong sbDescAddress = state.Channel.BufferManager.GetComputeUniformBufferAddress(0);
|
||||
|
||||
int sbDescOffset = 0x310 + sb.Slot * 0x10;
|
||||
|
||||
|
|
@ -99,11 +99,11 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
SbDescriptor sbDescriptor = _context.PhysicalMemory.Read<SbDescriptor>(sbDescAddress);
|
||||
|
||||
BufferManager.SetComputeStorageBuffer(sb.Slot, sbDescriptor.PackAddress(), (uint)sbDescriptor.Size, sb.Flags);
|
||||
state.Channel.BufferManager.SetComputeStorageBuffer(sb.Slot, sbDescriptor.PackAddress(), (uint)sbDescriptor.Size, sb.Flags);
|
||||
}
|
||||
|
||||
BufferManager.SetComputeStorageBufferBindings(info.SBuffers);
|
||||
BufferManager.SetComputeUniformBufferBindings(info.CBuffers);
|
||||
state.Channel.BufferManager.SetComputeStorageBufferBindings(info.SBuffers);
|
||||
state.Channel.BufferManager.SetComputeUniformBufferBindings(info.CBuffers);
|
||||
|
||||
var textureBindings = new TextureBindingInfo[info.Textures.Count];
|
||||
|
||||
|
|
@ -121,7 +121,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
descriptor.Flags);
|
||||
}
|
||||
|
||||
TextureManager.SetComputeTextures(textureBindings);
|
||||
state.Channel.TextureManager.SetComputeTextures(textureBindings);
|
||||
|
||||
var imageBindings = new TextureBindingInfo[info.Images.Count];
|
||||
|
||||
|
|
@ -141,10 +141,10 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
descriptor.Flags);
|
||||
}
|
||||
|
||||
TextureManager.SetComputeImages(imageBindings);
|
||||
state.Channel.TextureManager.SetComputeImages(imageBindings);
|
||||
|
||||
TextureManager.CommitComputeBindings();
|
||||
BufferManager.CommitComputeBindings();
|
||||
state.Channel.TextureManager.CommitComputeBindings();
|
||||
state.Channel.BufferManager.CommitComputeBindings();
|
||||
|
||||
_context.Renderer.Pipeline.DispatchCompute(
|
||||
qmd.CtaRasterWidth,
|
||||
|
|
|
|||
|
|
@ -25,6 +25,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
/// </summary>
|
||||
private struct CommandBuffer
|
||||
{
|
||||
/// <summary>
|
||||
/// Processor used to process the command buffer. Contains channel state.
|
||||
/// </summary>
|
||||
public GPFifoProcessor Processor;
|
||||
|
||||
/// <summary>
|
||||
/// The type of the command buffer.
|
||||
/// </summary>
|
||||
|
|
@ -60,11 +65,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
private readonly ConcurrentQueue<CommandBuffer> _commandBufferQueue;
|
||||
|
||||
private CommandBuffer _currentCommandBuffer;
|
||||
private GPFifoProcessor _prevChannelProcessor;
|
||||
|
||||
private readonly bool _ibEnable;
|
||||
private readonly GpuContext _context;
|
||||
private readonly AutoResetEvent _event;
|
||||
private readonly GPFifoProcessor _processor;
|
||||
|
||||
private bool _interrupt;
|
||||
|
||||
|
|
@ -78,8 +83,6 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
_ibEnable = true;
|
||||
_context = context;
|
||||
_event = new AutoResetEvent(false);
|
||||
|
||||
_processor = new GPFifoProcessor(context);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -94,11 +97,13 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
/// Push a GPFIFO entry in the form of a prefetched command buffer.
|
||||
/// It is intended to be used by nvservices to handle special cases.
|
||||
/// </summary>
|
||||
/// <param name="processor">Processor used to process <paramref name="commandBuffer"/></param>
|
||||
/// <param name="commandBuffer">The command buffer containing the prefetched commands</param>
|
||||
public void PushHostCommandBuffer(int[] commandBuffer)
|
||||
internal void PushHostCommandBuffer(GPFifoProcessor processor, int[] commandBuffer)
|
||||
{
|
||||
_commandBufferQueue.Enqueue(new CommandBuffer
|
||||
{
|
||||
Processor = processor,
|
||||
Type = CommandBufferType.Prefetch,
|
||||
Words = commandBuffer,
|
||||
EntryAddress = ulong.MaxValue,
|
||||
|
|
@ -109,9 +114,10 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
/// <summary>
|
||||
/// Create a CommandBuffer from a GPFIFO entry.
|
||||
/// </summary>
|
||||
/// <param name="processor">Processor used to process the command buffer pointed to by <paramref name="entry"/></param>
|
||||
/// <param name="entry">The GPFIFO entry</param>
|
||||
/// <returns>A new CommandBuffer based on the GPFIFO entry</returns>
|
||||
private CommandBuffer CreateCommandBuffer(GPEntry entry)
|
||||
private static CommandBuffer CreateCommandBuffer(GPFifoProcessor processor, GPEntry entry)
|
||||
{
|
||||
CommandBufferType type = CommandBufferType.Prefetch;
|
||||
|
||||
|
|
@ -124,6 +130,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
|
||||
return new CommandBuffer
|
||||
{
|
||||
Processor = processor,
|
||||
Type = type,
|
||||
Words = null,
|
||||
EntryAddress = startAddress,
|
||||
|
|
@ -134,8 +141,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
/// <summary>
|
||||
/// Pushes GPFIFO entries.
|
||||
/// </summary>
|
||||
/// <param name="processor">Processor used to process the command buffers pointed to by <paramref name="entries"/></param>
|
||||
/// <param name="entries">GPFIFO entries</param>
|
||||
public void PushEntries(ReadOnlySpan<ulong> entries)
|
||||
internal void PushEntries(GPFifoProcessor processor, ReadOnlySpan<ulong> entries)
|
||||
{
|
||||
bool beforeBarrier = true;
|
||||
|
||||
|
|
@ -143,7 +151,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
{
|
||||
ulong entry = entries[index];
|
||||
|
||||
CommandBuffer commandBuffer = CreateCommandBuffer(Unsafe.As<ulong, GPEntry>(ref entry));
|
||||
CommandBuffer commandBuffer = CreateCommandBuffer(processor, Unsafe.As<ulong, GPEntry>(ref entry));
|
||||
|
||||
if (beforeBarrier && commandBuffer.Type == CommandBufferType.Prefetch)
|
||||
{
|
||||
|
|
@ -173,12 +181,24 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
/// </summary>
|
||||
public void DispatchCalls()
|
||||
{
|
||||
// Use this opportunity to also dispose any pending channels that were closed.
|
||||
_context.DisposePendingChannels();
|
||||
|
||||
// Process command buffers.
|
||||
while (_ibEnable && !_interrupt && _commandBufferQueue.TryDequeue(out CommandBuffer entry))
|
||||
{
|
||||
_currentCommandBuffer = entry;
|
||||
_currentCommandBuffer.Fetch(_context);
|
||||
|
||||
_processor.Process(_currentCommandBuffer.Words);
|
||||
// If we are changing the current channel,
|
||||
// we need to force all the host state to be updated.
|
||||
if (_prevChannelProcessor != entry.Processor)
|
||||
{
|
||||
_prevChannelProcessor = entry.Processor;
|
||||
entry.Processor.ForceAllDirty();
|
||||
}
|
||||
|
||||
entry.Processor.Process(_currentCommandBuffer.Words);
|
||||
}
|
||||
|
||||
_interrupt = false;
|
||||
|
|
|
|||
|
|
@ -35,7 +35,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
/// Creates a new instance of the GPU General Purpose FIFO command processor.
|
||||
/// </summary>
|
||||
/// <param name="context">GPU context</param>
|
||||
public GPFifoProcessor(GpuContext context)
|
||||
/// <param name="channel">Channel that the GPFIFO processor belongs to</param>
|
||||
public GPFifoProcessor(GpuContext context, GpuChannel channel)
|
||||
{
|
||||
_context = context;
|
||||
|
||||
|
|
@ -44,7 +45,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
|
||||
for (int index = 0; index < _subChannels.Length; index++)
|
||||
{
|
||||
_subChannels[index] = new GpuState();
|
||||
_subChannels[index] = new GpuState(channel);
|
||||
|
||||
_context.Methods.RegisterCallbacks(_subChannels[index]);
|
||||
}
|
||||
|
|
@ -186,5 +187,17 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
|
|||
_subChannels[i].ShadowRamControl = control;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Forces a full host state update by marking all state as modified,
|
||||
/// and also requests all GPU resources in use to be rebound.
|
||||
/// </summary>
|
||||
public void ForceAllDirty()
|
||||
{
|
||||
for (int index = 0; index < _subChannels.Length; index++)
|
||||
{
|
||||
_subChannels[index].ForceAllDirty();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
UpdateRenderTargetState(state, useControl: false, singleUse: index);
|
||||
|
||||
TextureManager.UpdateRenderTargets();
|
||||
state.Channel.TextureManager.UpdateRenderTargets();
|
||||
|
||||
bool clearDepth = (argument & 1) != 0;
|
||||
bool clearStencil = (argument & 2) != 0;
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
if (completeSource && completeDest)
|
||||
{
|
||||
Image.Texture target = TextureManager.FindTexture(dst, cbp, swizzle, dstLinear);
|
||||
Image.Texture target = TextureCache.FindTexture(dst, cbp, swizzle, dstLinear);
|
||||
if (target != null)
|
||||
{
|
||||
ReadOnlySpan<byte> data;
|
||||
|
|
@ -209,13 +209,13 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
swizzle.UnpackComponentSize() == 4)
|
||||
{
|
||||
// Fast path for clears when remap is enabled.
|
||||
BufferManager.ClearBuffer(cbp.DstAddress, (uint)size * 4, state.Get<uint>(MethodOffset.CopyBufferConstA));
|
||||
BufferCache.ClearBuffer(cbp.DstAddress, (uint)size * 4, state.Get<uint>(MethodOffset.CopyBufferConstA));
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: Implement remap functionality.
|
||||
// Buffer to buffer copy.
|
||||
BufferManager.CopyBuffer(cbp.SrcAddress, cbp.DstAddress, (uint)size);
|
||||
BufferCache.CopyBuffer(cbp.SrcAddress, cbp.DstAddress, (uint)size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -80,7 +80,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
srcX1 = 0;
|
||||
}
|
||||
|
||||
Texture srcTexture = TextureManager.FindOrCreateTexture(srcCopyTexture, offset, srcCopyTextureFormat, true, srcHint);
|
||||
Texture srcTexture = TextureCache.FindOrCreateTexture(srcCopyTexture, offset, srcCopyTextureFormat, true, srcHint);
|
||||
|
||||
if (srcTexture == null)
|
||||
{
|
||||
|
|
@ -101,7 +101,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
dstCopyTextureFormat = dstCopyTexture.Format.Convert();
|
||||
}
|
||||
|
||||
Texture dstTexture = TextureManager.FindOrCreateTexture(dstCopyTexture, 0, dstCopyTextureFormat, srcTexture.ScaleMode == TextureScaleMode.Scaled, dstHint);
|
||||
Texture dstTexture = TextureCache.FindOrCreateTexture(dstCopyTexture, 0, dstCopyTextureFormat, srcTexture.ScaleMode == TextureScaleMode.Scaled, dstHint);
|
||||
|
||||
if (dstTexture == null)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
BufferRange br = new BufferRange(_ibStreamer.GetInlineIndexBuffer(), 0, inlineIndexCount * 4);
|
||||
|
||||
_context.Methods.BufferManager.SetIndexBuffer(br, IndexType.UInt);
|
||||
state.Channel.BufferManager.SetIndexBuffer(br, IndexType.UInt);
|
||||
|
||||
_context.Renderer.Pipeline.DrawIndexed(
|
||||
inlineIndexCount,
|
||||
|
|
|
|||
|
|
@ -74,11 +74,11 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
ulong address = uniformBuffer.Address.Pack();
|
||||
|
||||
BufferManager.SetGraphicsUniformBuffer((int)type, index, address, (uint)uniformBuffer.Size);
|
||||
state.Channel.BufferManager.SetGraphicsUniformBuffer((int)type, index, address, (uint)uniformBuffer.Size);
|
||||
}
|
||||
else
|
||||
{
|
||||
BufferManager.SetGraphicsUniformBuffer((int)type, index, 0, 0);
|
||||
state.Channel.BufferManager.SetGraphicsUniformBuffer((int)type, index, 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
{
|
||||
if (_ubFollowUpAddress != 0)
|
||||
{
|
||||
BufferManager.ForceDirty(_ubFollowUpAddress - _ubByteCount, _ubByteCount);
|
||||
BufferCache.ForceDirty(_ubFollowUpAddress - _ubByteCount, _ubByteCount);
|
||||
|
||||
_ubFollowUpAddress = 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,12 +30,12 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
/// <summary>
|
||||
/// GPU buffer manager.
|
||||
/// </summary>
|
||||
public BufferManager BufferManager { get; }
|
||||
public BufferCache BufferCache { get; }
|
||||
|
||||
/// <summary>
|
||||
/// GPU texture manager.
|
||||
/// </summary>
|
||||
public TextureManager TextureManager { get; }
|
||||
public TextureCache TextureCache { get; }
|
||||
|
||||
private bool _isAnyVbInstanced;
|
||||
private bool _vsUsesInstanceId;
|
||||
|
|
@ -57,12 +57,12 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
_currentProgramInfo = new ShaderProgramInfo[Constants.ShaderStages];
|
||||
|
||||
BufferManager = new BufferManager(context);
|
||||
TextureManager = new TextureManager(context);
|
||||
BufferCache = new BufferCache(context);
|
||||
TextureCache = new TextureCache(context);
|
||||
|
||||
context.MemoryManager.MemoryUnmapped += _counterCache.MemoryUnmappedHandler;
|
||||
context.MemoryManager.MemoryUnmapped += TextureManager.MemoryUnmappedHandler;
|
||||
context.MemoryManager.MemoryUnmapped += BufferManager.MemoryUnmappedHandler;
|
||||
context.MemoryManager.MemoryUnmapped += TextureCache.MemoryUnmappedHandler;
|
||||
context.MemoryManager.MemoryUnmapped += BufferCache.MemoryUnmappedHandler;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -280,7 +280,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
UpdateLogicOpState(state);
|
||||
}
|
||||
|
||||
CommitBindings();
|
||||
CommitBindings(state);
|
||||
|
||||
if (tfEnable && !_prevTfEnable)
|
||||
{
|
||||
|
|
@ -303,18 +303,20 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
/// Ensures that the bindings are visible to the host GPU.
|
||||
/// Note: this actually performs the binding using the host graphics API.
|
||||
/// </summary>
|
||||
private void CommitBindings()
|
||||
/// <param name="state">Current GPU state</param>
|
||||
private void CommitBindings(GpuState state)
|
||||
{
|
||||
UpdateStorageBuffers();
|
||||
UpdateStorageBuffers(state);
|
||||
|
||||
TextureManager.CommitGraphicsBindings();
|
||||
BufferManager.CommitGraphicsBindings();
|
||||
state.Channel.TextureManager.CommitGraphicsBindings();
|
||||
state.Channel.BufferManager.CommitGraphicsBindings();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Updates storage buffer bindings.
|
||||
/// </summary>
|
||||
private void UpdateStorageBuffers()
|
||||
/// <param name="state">Current GPU state</param>
|
||||
private void UpdateStorageBuffers(GpuState state)
|
||||
{
|
||||
for (int stage = 0; stage < _currentProgramInfo.Length; stage++)
|
||||
{
|
||||
|
|
@ -329,7 +331,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
{
|
||||
BufferDescriptor sb = info.SBuffers[index];
|
||||
|
||||
ulong sbDescAddress = BufferManager.GetGraphicsUniformBufferAddress(stage, 0);
|
||||
ulong sbDescAddress = state.Channel.BufferManager.GetGraphicsUniformBufferAddress(stage, 0);
|
||||
|
||||
int sbDescOffset = 0x110 + stage * 0x100 + sb.Slot * 0x10;
|
||||
|
||||
|
|
@ -337,7 +339,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
SbDescriptor sbDescriptor = _context.PhysicalMemory.Read<SbDescriptor>(sbDescAddress);
|
||||
|
||||
BufferManager.SetGraphicsStorageBuffer(stage, sb.Slot, sbDescriptor.PackAddress(), (uint)sbDescriptor.Size, sb.Flags);
|
||||
state.Channel.BufferManager.SetGraphicsStorageBuffer(stage, sb.Slot, sbDescriptor.PackAddress(), (uint)sbDescriptor.Size, sb.Flags);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -372,14 +374,14 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
if (index >= count || !IsRtEnabled(colorState))
|
||||
{
|
||||
changedScale |= TextureManager.SetRenderTargetColor(index, null);
|
||||
changedScale |= state.Channel.TextureManager.SetRenderTargetColor(index, null);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
Texture color = TextureManager.FindOrCreateTexture(colorState, samplesInX, samplesInY, sizeHint);
|
||||
Texture color = TextureCache.FindOrCreateTexture(colorState, samplesInX, samplesInY, sizeHint);
|
||||
|
||||
changedScale |= TextureManager.SetRenderTargetColor(index, color);
|
||||
changedScale |= state.Channel.TextureManager.SetRenderTargetColor(index, color);
|
||||
}
|
||||
|
||||
bool dsEnable = state.Get<Boolean32>(MethodOffset.RtDepthStencilEnable);
|
||||
|
|
@ -391,15 +393,15 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
var dsState = state.Get<RtDepthStencilState>(MethodOffset.RtDepthStencilState);
|
||||
var dsSize = state.Get<Size3D>(MethodOffset.RtDepthStencilSize);
|
||||
|
||||
depthStencil = TextureManager.FindOrCreateTexture(dsState, dsSize, samplesInX, samplesInY, sizeHint);
|
||||
depthStencil = TextureCache.FindOrCreateTexture(dsState, dsSize, samplesInX, samplesInY, sizeHint);
|
||||
}
|
||||
|
||||
changedScale |= TextureManager.SetRenderTargetDepthStencil(depthStencil);
|
||||
changedScale |= state.Channel.TextureManager.SetRenderTargetDepthStencil(depthStencil);
|
||||
|
||||
if (changedScale)
|
||||
{
|
||||
TextureManager.UpdateRenderTargetScale(singleUse);
|
||||
_context.Renderer.Pipeline.SetRenderTargetScale(TextureManager.RenderTargetScale);
|
||||
state.Channel.TextureManager.UpdateRenderTargetScale(singleUse);
|
||||
_context.Renderer.Pipeline.SetRenderTargetScale(state.Channel.TextureManager.RenderTargetScale);
|
||||
|
||||
UpdateViewportTransform(state);
|
||||
UpdateScissorState(state);
|
||||
|
|
@ -436,7 +438,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
int width = scissor.X2 - x;
|
||||
int height = scissor.Y2 - y;
|
||||
|
||||
float scale = TextureManager.RenderTargetScale;
|
||||
float scale = state.Channel.TextureManager.RenderTargetScale;
|
||||
if (scale != 1f)
|
||||
{
|
||||
x = (int)(x * scale);
|
||||
|
|
@ -545,7 +547,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
float width = scaleX * 2;
|
||||
float height = scaleY * 2;
|
||||
|
||||
float scale = TextureManager.RenderTargetScale;
|
||||
float scale = state.Channel.TextureManager.RenderTargetScale;
|
||||
if (scale != 1f)
|
||||
{
|
||||
x *= scale;
|
||||
|
|
@ -670,7 +672,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
? texturePool.MaximumId
|
||||
: samplerPool.MaximumId;
|
||||
|
||||
TextureManager.SetGraphicsSamplerPool(samplerPool.Address.Pack(), maximumId, samplerIndex);
|
||||
state.Channel.TextureManager.SetGraphicsSamplerPool(samplerPool.Address.Pack(), maximumId, samplerIndex);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -681,9 +683,8 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
{
|
||||
var texturePool = state.Get<PoolState>(MethodOffset.TexturePoolState);
|
||||
|
||||
TextureManager.SetGraphicsTexturePool(texturePool.Address.Pack(), texturePool.MaximumId);
|
||||
|
||||
TextureManager.SetGraphicsTextureBufferIndex(state.Get<int>(MethodOffset.TextureBufferIndex));
|
||||
state.Channel.TextureManager.SetGraphicsTexturePool(texturePool.Address.Pack(), texturePool.MaximumId);
|
||||
state.Channel.TextureManager.SetGraphicsTextureBufferIndex(state.Get<int>(MethodOffset.TextureBufferIndex));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -771,7 +772,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
case IndexType.UInt: size *= 4; break;
|
||||
}
|
||||
|
||||
BufferManager.SetIndexBuffer(gpuVa, size, indexBuffer.Type);
|
||||
state.Channel.BufferManager.SetIndexBuffer(gpuVa, size, indexBuffer.Type);
|
||||
|
||||
// The index buffer affects the vertex buffer size calculation, we
|
||||
// need to ensure that they are updated.
|
||||
|
|
@ -792,7 +793,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
if (!vertexBuffer.UnpackEnable())
|
||||
{
|
||||
BufferManager.SetVertexBuffer(index, 0, 0, 0, 0);
|
||||
state.Channel.BufferManager.SetVertexBuffer(index, 0, 0, 0, 0);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
|
@ -828,7 +829,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
size = (ulong)((firstInstance + drawState.First + drawState.Count) * stride);
|
||||
}
|
||||
|
||||
BufferManager.SetVertexBuffer(index, address, size, stride, divisor);
|
||||
state.Channel.BufferManager.SetVertexBuffer(index, address, size, stride, divisor);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1017,10 +1018,10 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
if (info == null)
|
||||
{
|
||||
TextureManager.SetGraphicsTextures(stage, Array.Empty<TextureBindingInfo>());
|
||||
TextureManager.SetGraphicsImages(stage, Array.Empty<TextureBindingInfo>());
|
||||
BufferManager.SetGraphicsStorageBufferBindings(stage, null);
|
||||
BufferManager.SetGraphicsUniformBufferBindings(stage, null);
|
||||
state.Channel.TextureManager.SetGraphicsTextures(stage, Array.Empty<TextureBindingInfo>());
|
||||
state.Channel.TextureManager.SetGraphicsImages(stage, Array.Empty<TextureBindingInfo>());
|
||||
state.Channel.BufferManager.SetGraphicsStorageBufferBindings(stage, null);
|
||||
state.Channel.BufferManager.SetGraphicsUniformBufferBindings(stage, null);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -1040,7 +1041,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
descriptor.Flags);
|
||||
}
|
||||
|
||||
TextureManager.SetGraphicsTextures(stage, textureBindings);
|
||||
state.Channel.TextureManager.SetGraphicsTextures(stage, textureBindings);
|
||||
|
||||
var imageBindings = new TextureBindingInfo[info.Images.Count];
|
||||
|
||||
|
|
@ -1060,10 +1061,10 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
descriptor.Flags);
|
||||
}
|
||||
|
||||
TextureManager.SetGraphicsImages(stage, imageBindings);
|
||||
state.Channel.TextureManager.SetGraphicsImages(stage, imageBindings);
|
||||
|
||||
BufferManager.SetGraphicsStorageBufferBindings(stage, info.SBuffers);
|
||||
BufferManager.SetGraphicsUniformBufferBindings(stage, info.CBuffers);
|
||||
state.Channel.BufferManager.SetGraphicsStorageBufferBindings(stage, info.SBuffers);
|
||||
state.Channel.BufferManager.SetGraphicsUniformBufferBindings(stage, info.CBuffers);
|
||||
|
||||
if (info.SBuffers.Count != 0)
|
||||
{
|
||||
|
|
@ -1076,8 +1077,8 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
}
|
||||
}
|
||||
|
||||
BufferManager.SetGraphicsStorageBufferBindingsCount(storageBufferBindingsCount);
|
||||
BufferManager.SetGraphicsUniformBufferBindingsCount(uniformBufferBindingsCount);
|
||||
state.Channel.BufferManager.SetGraphicsStorageBufferBindingsCount(storageBufferBindingsCount);
|
||||
state.Channel.BufferManager.SetGraphicsUniformBufferBindingsCount(uniformBufferBindingsCount);
|
||||
|
||||
_context.Renderer.Pipeline.SetProgram(gs.HostProgram);
|
||||
}
|
||||
|
|
@ -1094,12 +1095,12 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
|||
|
||||
if (!tfb.Enable)
|
||||
{
|
||||
BufferManager.SetTransformFeedbackBuffer(index, 0, 0);
|
||||
state.Channel.BufferManager.SetTransformFeedbackBuffer(index, 0, 0);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
BufferManager.SetTransformFeedbackBuffer(index, tfb.Address.Pack(), (uint)tfb.Size);
|
||||
state.Channel.BufferManager.SetTransformFeedbackBuffer(index, tfb.Address.Pack(), (uint)tfb.Size);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
78
Ryujinx.Graphics.Gpu/GpuChannel.cs
Normal file
78
Ryujinx.Graphics.Gpu/GpuChannel.cs
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
using Ryujinx.Graphics.Gpu.Engine.GPFifo;
|
||||
using Ryujinx.Graphics.Gpu.Image;
|
||||
using Ryujinx.Graphics.Gpu.Memory;
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu
|
||||
{
|
||||
/// <summary>
|
||||
/// Represents a GPU channel.
|
||||
/// </summary>
|
||||
public class GpuChannel : IDisposable
|
||||
{
|
||||
private readonly GpuContext _context;
|
||||
private readonly GPFifoDevice _device;
|
||||
private readonly GPFifoProcessor _processor;
|
||||
|
||||
/// <summary>
|
||||
/// Channel buffer bindings manager.
|
||||
/// </summary>
|
||||
internal BufferManager BufferManager { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Channel texture bindings manager.
|
||||
/// </summary>
|
||||
internal TextureManager TextureManager { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of a GPU channel.
|
||||
/// </summary>
|
||||
/// <param name="context">GPU context that the channel belongs to</param>
|
||||
internal GpuChannel(GpuContext context)
|
||||
{
|
||||
_context = context;
|
||||
_device = context.GPFifo;
|
||||
_processor = new GPFifoProcessor(context, this);
|
||||
BufferManager = new BufferManager(context);
|
||||
TextureManager = new TextureManager(context, this);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Push a GPFIFO entry in the form of a prefetched command buffer.
|
||||
/// It is intended to be used by nvservices to handle special cases.
|
||||
/// </summary>
|
||||
/// <param name="commandBuffer">The command buffer containing the prefetched commands</param>
|
||||
public void PushHostCommandBuffer(int[] commandBuffer)
|
||||
{
|
||||
_device.PushHostCommandBuffer(_processor, commandBuffer);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Pushes GPFIFO entries.
|
||||
/// </summary>
|
||||
/// <param name="entries">GPFIFO entries</param>
|
||||
public void PushEntries(ReadOnlySpan<ulong> entries)
|
||||
{
|
||||
_device.PushEntries(_processor, entries);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Disposes the GPU channel.
|
||||
/// It's an error to use the GPU channel after disposal.
|
||||
/// </summary>
|
||||
public void Dispose()
|
||||
{
|
||||
_context.DisposedChannels.Enqueue(this);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Performs disposal of the host GPU resources used by this channel, that are not shared.
|
||||
/// This must only be called from the render thread.
|
||||
/// </summary>
|
||||
internal void Destroy()
|
||||
{
|
||||
BufferManager.Dispose();
|
||||
TextureManager.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -72,6 +72,11 @@ namespace Ryujinx.Graphics.Gpu
|
|||
/// </summary>
|
||||
internal List<Action> SyncActions { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Queue with closed channels for deferred disposal from the render thread.
|
||||
/// </summary>
|
||||
internal Queue<GpuChannel> DisposedChannels { get; }
|
||||
|
||||
private readonly Lazy<Capabilities> _caps;
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -111,6 +116,13 @@ namespace Ryujinx.Graphics.Gpu
|
|||
HostInitalized = new ManualResetEvent(false);
|
||||
|
||||
SyncActions = new List<Action>();
|
||||
|
||||
DisposedChannels = new Queue<GpuChannel>();
|
||||
}
|
||||
|
||||
public GpuChannel CreateChannel()
|
||||
{
|
||||
return new GpuChannel(this);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -173,6 +185,18 @@ namespace Ryujinx.Graphics.Gpu
|
|||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Performs deferred disposal of closed channels.
|
||||
/// This must only be called from the render thread.
|
||||
/// </summary>
|
||||
internal void DisposePendingChannels()
|
||||
{
|
||||
while (DisposedChannels.TryDequeue(out GpuChannel channel))
|
||||
{
|
||||
channel.Destroy();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Disposes all GPU resources currently cached.
|
||||
/// It's an error to push any GPU commands after disposal.
|
||||
|
|
@ -181,9 +205,10 @@ namespace Ryujinx.Graphics.Gpu
|
|||
/// </summary>
|
||||
public void Dispose()
|
||||
{
|
||||
DisposePendingChannels();
|
||||
Methods.ShaderCache.Dispose();
|
||||
Methods.BufferManager.Dispose();
|
||||
Methods.TextureManager.Dispose();
|
||||
Methods.BufferCache.Dispose();
|
||||
Methods.TextureCache.Dispose();
|
||||
Renderer.Dispose();
|
||||
GPFifo.Dispose();
|
||||
HostInitalized.Dispose();
|
||||
|
|
|
|||
|
|
@ -218,7 +218,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
{
|
||||
Debug.Assert(!isView);
|
||||
|
||||
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(Info, _context.Capabilities, ScaleFactor);
|
||||
TextureCreateInfo createInfo = TextureCache.GetCreateInfo(Info, _context.Capabilities, ScaleFactor);
|
||||
HostTexture = _context.Renderer.CreateTexture(createInfo, ScaleFactor);
|
||||
|
||||
SynchronizeMemory(); // Load the data.
|
||||
|
|
@ -242,7 +242,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
ScaleFactor = GraphicsConfig.ResScale;
|
||||
}
|
||||
|
||||
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(Info, _context.Capabilities, ScaleFactor);
|
||||
TextureCreateInfo createInfo = TextureCache.GetCreateInfo(Info, _context.Capabilities, ScaleFactor);
|
||||
HostTexture = _context.Renderer.CreateTexture(createInfo, ScaleFactor);
|
||||
}
|
||||
}
|
||||
|
|
@ -284,7 +284,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
ScaleFactor,
|
||||
ScaleMode);
|
||||
|
||||
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(info, _context.Capabilities, ScaleFactor);
|
||||
TextureCreateInfo createInfo = TextureCache.GetCreateInfo(info, _context.Capabilities, ScaleFactor);
|
||||
texture.HostTexture = HostTexture.CreateView(createInfo, firstLayer, firstLevel);
|
||||
|
||||
_viewStorage.AddView(texture);
|
||||
|
|
@ -453,7 +453,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
Info.SwizzleB,
|
||||
Info.SwizzleA));
|
||||
|
||||
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(Info, _context.Capabilities, ScaleFactor);
|
||||
TextureCreateInfo createInfo = TextureCache.GetCreateInfo(Info, _context.Capabilities, ScaleFactor);
|
||||
|
||||
if (_viewStorage != this)
|
||||
{
|
||||
|
|
@ -511,7 +511,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
{
|
||||
if (storage == null)
|
||||
{
|
||||
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(Info, _context.Capabilities, scale);
|
||||
TextureCreateInfo createInfo = TextureCache.GetCreateInfo(Info, _context.Capabilities, scale);
|
||||
storage = _context.Renderer.CreateTexture(createInfo, scale);
|
||||
}
|
||||
|
||||
|
|
@ -558,7 +558,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
Logger.Debug?.Print(LogClass.Gpu, $" Recreating view {Info.Width}x{Info.Height} {Info.FormatInfo.Format.ToString()}.");
|
||||
view.ScaleFactor = scale;
|
||||
|
||||
TextureCreateInfo viewCreateInfo = TextureManager.GetCreateInfo(view.Info, _context.Capabilities, scale);
|
||||
TextureCreateInfo viewCreateInfo = TextureCache.GetCreateInfo(view.Info, _context.Capabilities, scale);
|
||||
ITexture newView = HostTexture.CreateView(viewCreateInfo, view.FirstLayer - FirstLayer, view.FirstLevel - FirstLevel);
|
||||
|
||||
view.ReplaceStorage(newView);
|
||||
|
|
@ -1134,7 +1134,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
|
||||
foreach (Texture view in viewCopy)
|
||||
{
|
||||
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(view.Info, _context.Capabilities, ScaleFactor);
|
||||
TextureCreateInfo createInfo = TextureCache.GetCreateInfo(view.Info, _context.Capabilities, ScaleFactor);
|
||||
|
||||
ITexture newView = parent.HostTexture.CreateView(createInfo, view.FirstLayer + firstLayer, view.FirstLevel + firstLevel);
|
||||
|
||||
|
|
@ -1280,7 +1280,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
_viewStorage.RemoveView(this);
|
||||
}
|
||||
|
||||
_context.Methods.TextureManager.RemoveTextureFromCache(this);
|
||||
_context.Methods.TextureCache.RemoveTextureFromCache(this);
|
||||
}
|
||||
|
||||
Debug.Assert(newRefCount >= 0);
|
||||
|
|
|
|||
|
|
@ -16,9 +16,9 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
private const int SlotHigh = 16;
|
||||
private const int SlotMask = (1 << SlotHigh) - 1;
|
||||
|
||||
private GpuContext _context;
|
||||
private readonly GpuContext _context;
|
||||
|
||||
private bool _isCompute;
|
||||
private readonly bool _isCompute;
|
||||
|
||||
private SamplerPool _samplerPool;
|
||||
|
||||
|
|
@ -27,10 +27,11 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
private ulong _texturePoolAddress;
|
||||
private int _texturePoolMaximumId;
|
||||
|
||||
private TexturePoolCache _texturePoolCache;
|
||||
private readonly GpuChannel _channel;
|
||||
private readonly TexturePoolCache _texturePoolCache;
|
||||
|
||||
private TextureBindingInfo[][] _textureBindings;
|
||||
private TextureBindingInfo[][] _imageBindings;
|
||||
private readonly TextureBindingInfo[][] _textureBindings;
|
||||
private readonly TextureBindingInfo[][] _imageBindings;
|
||||
|
||||
private struct TextureStatePerStage
|
||||
{
|
||||
|
|
@ -38,26 +39,28 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
public ISampler Sampler;
|
||||
}
|
||||
|
||||
private TextureStatePerStage[][] _textureState;
|
||||
private TextureStatePerStage[][] _imageState;
|
||||
private readonly TextureStatePerStage[][] _textureState;
|
||||
private readonly TextureStatePerStage[][] _imageState;
|
||||
|
||||
private int _textureBufferIndex;
|
||||
|
||||
private bool _rebind;
|
||||
|
||||
private float[] _scales;
|
||||
private readonly float[] _scales;
|
||||
private bool _scaleChanged;
|
||||
|
||||
/// <summary>
|
||||
/// Constructs a new instance of the texture bindings manager.
|
||||
/// </summary>
|
||||
/// <param name="context">The GPU context that the texture bindings manager belongs to</param>
|
||||
/// <param name="texturePoolCache">Texture pools cache used to get texture pools from</param>
|
||||
/// <param name="channel">The GPU channel that the texture bindings manager belongs to</param>
|
||||
/// <param name="poolCache">Texture pools cache used to get texture pools from</param>
|
||||
/// <param name="isCompute">True if the bindings manager is used for the compute engine</param>
|
||||
public TextureBindingsManager(GpuContext context, TexturePoolCache texturePoolCache, bool isCompute)
|
||||
public TextureBindingsManager(GpuContext context, GpuChannel channel, TexturePoolCache poolCache, bool isCompute)
|
||||
{
|
||||
_context = context;
|
||||
_texturePoolCache = texturePoolCache;
|
||||
_channel = channel;
|
||||
_texturePoolCache = poolCache;
|
||||
_isCompute = isCompute;
|
||||
|
||||
int stages = isCompute ? 1 : Constants.ShaderStages;
|
||||
|
|
@ -174,11 +177,9 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
|
||||
float scale = texture.ScaleFactor;
|
||||
|
||||
TextureManager manager = _context.Methods.TextureManager;
|
||||
|
||||
if (scale != 1)
|
||||
{
|
||||
Texture activeTarget = manager.GetAnyRenderTarget();
|
||||
Texture activeTarget = _channel.TextureManager.GetAnyRenderTarget();
|
||||
|
||||
if (activeTarget != null && activeTarget.Info.Width / (float)texture.Info.Width == activeTarget.Info.Height / (float)texture.Info.Height)
|
||||
{
|
||||
|
|
@ -319,7 +320,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
// Ensure that the buffer texture is using the correct buffer as storage.
|
||||
// Buffers are frequently re-created to accomodate larger data, so we need to re-bind
|
||||
// to ensure we're not using a old buffer that was already deleted.
|
||||
_context.Methods.BufferManager.SetBufferTextureStorage(hostTexture, texture.Range.GetSubRange(0).Address, texture.Size, bindingInfo, bindingInfo.Format, false);
|
||||
_channel.BufferManager.SetBufferTextureStorage(hostTexture, texture.Range.GetSubRange(0).Address, texture.Size, bindingInfo, bindingInfo.Format, false);
|
||||
}
|
||||
|
||||
Sampler sampler = _samplerPool.Get(samplerId);
|
||||
|
|
@ -392,7 +393,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
format = texture.Format;
|
||||
}
|
||||
|
||||
_context.Methods.BufferManager.SetBufferTextureStorage(hostTexture, texture.Range.GetSubRange(0).Address, texture.Size, bindingInfo, format, true);
|
||||
_channel.BufferManager.SetBufferTextureStorage(hostTexture, texture.Range.GetSubRange(0).Address, texture.Size, bindingInfo, format, true);
|
||||
}
|
||||
else if (isStore)
|
||||
{
|
||||
|
|
@ -454,10 +455,10 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
/// <returns>The packed texture and sampler ID (the real texture handle)</returns>
|
||||
private int ReadPackedId(int stageIndex, int wordOffset, int textureBufferIndex, int samplerBufferIndex)
|
||||
{
|
||||
var bufferManager = _context.Methods.BufferManager;
|
||||
var bufferManager = _context.Methods.BufferCache;
|
||||
ulong textureBufferAddress = _isCompute
|
||||
? bufferManager.GetComputeUniformBufferAddress(textureBufferIndex)
|
||||
: bufferManager.GetGraphicsUniformBufferAddress(stageIndex, textureBufferIndex);
|
||||
? _channel.BufferManager.GetComputeUniformBufferAddress(textureBufferIndex)
|
||||
: _channel.BufferManager.GetGraphicsUniformBufferAddress(stageIndex, textureBufferIndex);
|
||||
|
||||
int handle = _context.PhysicalMemory.Read<int>(textureBufferAddress + (ulong)(wordOffset & HandleMask) * 4);
|
||||
|
||||
|
|
@ -470,8 +471,8 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
if (wordOffset >> HandleHigh != 0)
|
||||
{
|
||||
ulong samplerBufferAddress = _isCompute
|
||||
? bufferManager.GetComputeUniformBufferAddress(samplerBufferIndex)
|
||||
: bufferManager.GetGraphicsUniformBufferAddress(stageIndex, samplerBufferIndex);
|
||||
? _channel.BufferManager.GetComputeUniformBufferAddress(samplerBufferIndex)
|
||||
: _channel.BufferManager.GetGraphicsUniformBufferAddress(stageIndex, samplerBufferIndex);
|
||||
|
||||
handle |= _context.PhysicalMemory.Read<int>(samplerBufferAddress + (ulong)((wordOffset >> HandleHigh) - 1) * 4);
|
||||
}
|
||||
|
|
@ -513,6 +514,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
public void Dispose()
|
||||
{
|
||||
_samplerPool?.Dispose();
|
||||
_texturePoolCache.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
967
Ryujinx.Graphics.Gpu/Image/TextureCache.cs
Normal file
967
Ryujinx.Graphics.Gpu/Image/TextureCache.cs
Normal file
|
|
@ -0,0 +1,967 @@
|
|||
using Ryujinx.Common;
|
||||
using Ryujinx.Graphics.GAL;
|
||||
using Ryujinx.Graphics.Gpu.Image;
|
||||
using Ryujinx.Graphics.Gpu.Memory;
|
||||
using Ryujinx.Graphics.Gpu.State;
|
||||
using Ryujinx.Graphics.Texture;
|
||||
using Ryujinx.Memory.Range;
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Image
|
||||
{
|
||||
/// <summary>
|
||||
/// Texture cache.
|
||||
/// </summary>
|
||||
class TextureCache : IDisposable
|
||||
{
|
||||
private struct OverlapInfo
|
||||
{
|
||||
public TextureViewCompatibility Compatibility { get; }
|
||||
public int FirstLayer { get; }
|
||||
public int FirstLevel { get; }
|
||||
|
||||
public OverlapInfo(TextureViewCompatibility compatibility, int firstLayer, int firstLevel)
|
||||
{
|
||||
Compatibility = compatibility;
|
||||
FirstLayer = firstLayer;
|
||||
FirstLevel = firstLevel;
|
||||
}
|
||||
}
|
||||
|
||||
private const int OverlapsBufferInitialCapacity = 10;
|
||||
private const int OverlapsBufferMaxCapacity = 10000;
|
||||
|
||||
private readonly GpuContext _context;
|
||||
|
||||
private readonly MultiRangeList<Texture> _textures;
|
||||
|
||||
private Texture[] _textureOverlaps;
|
||||
private OverlapInfo[] _overlapInfo;
|
||||
|
||||
private readonly AutoDeleteCache _cache;
|
||||
|
||||
/// <summary>
|
||||
/// Constructs a new instance of the texture manager.
|
||||
/// </summary>
|
||||
/// <param name="context">The GPU context that the texture manager belongs to</param>
|
||||
public TextureCache(GpuContext context)
|
||||
{
|
||||
_context = context;
|
||||
|
||||
_textures = new MultiRangeList<Texture>();
|
||||
|
||||
_textureOverlaps = new Texture[OverlapsBufferInitialCapacity];
|
||||
_overlapInfo = new OverlapInfo[OverlapsBufferInitialCapacity];
|
||||
|
||||
_cache = new AutoDeleteCache();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Handles removal of textures written to a memory region being unmapped.
|
||||
/// </summary>
|
||||
/// <param name="sender">Sender object</param>
|
||||
/// <param name="e">Event arguments</param>
|
||||
public void MemoryUnmappedHandler(object sender, UnmapEventArgs e)
|
||||
{
|
||||
Texture[] overlaps = new Texture[10];
|
||||
int overlapCount;
|
||||
|
||||
lock (_textures)
|
||||
{
|
||||
overlapCount = _textures.FindOverlaps(_context.MemoryManager.Translate(e.Address), e.Size, ref overlaps);
|
||||
}
|
||||
|
||||
for (int i = 0; i < overlapCount; i++)
|
||||
{
|
||||
overlaps[i].Unmapped();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Determines if a given texture is eligible for upscaling from its info.
|
||||
/// </summary>
|
||||
/// <param name="info">The texture info to check</param>
|
||||
/// <returns>True if eligible</returns>
|
||||
private static bool IsUpscaleCompatible(TextureInfo info)
|
||||
{
|
||||
return (info.Target == Target.Texture2D || info.Target == Target.Texture2DArray) && !info.FormatInfo.IsCompressed && UpscaleSafeMode(info);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Determines if a given texture is "safe" for upscaling from its info.
|
||||
/// Note that this is different from being compatible - this elilinates targets that would have detrimental effects when scaled.
|
||||
/// </summary>
|
||||
/// <param name="info">The texture info to check</param>
|
||||
/// <returns>True if safe</returns>
|
||||
private static bool UpscaleSafeMode(TextureInfo info)
|
||||
{
|
||||
// While upscaling works for all targets defined by IsUpscaleCompatible, we additionally blacklist targets here that
|
||||
// may have undesirable results (upscaling blur textures) or simply waste GPU resources (upscaling texture atlas).
|
||||
|
||||
if (info.Levels > 3)
|
||||
{
|
||||
// Textures with more than 3 levels are likely to be game textures, rather than render textures.
|
||||
// Small textures with full mips are likely to be removed by the next check.
|
||||
return false;
|
||||
}
|
||||
|
||||
if (info.Width < 8 || info.Height < 8)
|
||||
{
|
||||
// Discount textures with small dimensions.
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!(info.FormatInfo.Format.IsDepthOrStencil() || info.FormatInfo.Components == 1))
|
||||
{
|
||||
// Discount square textures that aren't depth-stencil like. (excludes game textures, cubemap faces, most 3D texture LUT, texture atlas)
|
||||
// Detect if the texture is possibly square. Widths may be aligned, so to remove the uncertainty we align both the width and height.
|
||||
|
||||
int widthAlignment = (info.IsLinear ? Constants.StrideAlignment : Constants.GobAlignment) / info.FormatInfo.BytesPerPixel;
|
||||
|
||||
bool possiblySquare = BitUtils.AlignUp(info.Width, widthAlignment) == BitUtils.AlignUp(info.Height, widthAlignment);
|
||||
|
||||
if (possiblySquare)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
int aspect = (int)Math.Round((info.Width / (float)info.Height) * 9);
|
||||
if (aspect == 16 && info.Height < 360)
|
||||
{
|
||||
// Targets that are roughly 16:9 can only be rescaled if they're equal to or above 360p. (excludes blur and bloom textures)
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tries to find an existing texture, or create a new one if not found.
|
||||
/// </summary>
|
||||
/// <param name="copyTexture">Copy texture to find or create</param>
|
||||
/// <param name="offset">Offset to be added to the physical texture address</param>
|
||||
/// <param name="formatInfo">Format information of the copy texture</param>
|
||||
/// <param name="preferScaling">Indicates if the texture should be scaled from the start</param>
|
||||
/// <param name="sizeHint">A hint indicating the minimum used size for the texture</param>
|
||||
/// <returns>The texture</returns>
|
||||
public Texture FindOrCreateTexture(CopyTexture copyTexture, ulong offset, FormatInfo formatInfo, bool preferScaling = true, Size? sizeHint = null)
|
||||
{
|
||||
int gobBlocksInY = copyTexture.MemoryLayout.UnpackGobBlocksInY();
|
||||
int gobBlocksInZ = copyTexture.MemoryLayout.UnpackGobBlocksInZ();
|
||||
|
||||
int width;
|
||||
|
||||
if (copyTexture.LinearLayout)
|
||||
{
|
||||
width = copyTexture.Stride / formatInfo.BytesPerPixel;
|
||||
}
|
||||
else
|
||||
{
|
||||
width = copyTexture.Width;
|
||||
}
|
||||
|
||||
TextureInfo info = new TextureInfo(
|
||||
copyTexture.Address.Pack() + offset,
|
||||
width,
|
||||
copyTexture.Height,
|
||||
copyTexture.Depth,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
copyTexture.Stride,
|
||||
copyTexture.LinearLayout,
|
||||
gobBlocksInY,
|
||||
gobBlocksInZ,
|
||||
1,
|
||||
Target.Texture2D,
|
||||
formatInfo);
|
||||
|
||||
TextureSearchFlags flags = TextureSearchFlags.ForCopy;
|
||||
|
||||
if (preferScaling)
|
||||
{
|
||||
flags |= TextureSearchFlags.WithUpscale;
|
||||
}
|
||||
|
||||
Texture texture = FindOrCreateTexture(flags, info, 0, sizeHint);
|
||||
|
||||
texture?.SynchronizeMemory();
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tries to find an existing texture, or create a new one if not found.
|
||||
/// </summary>
|
||||
/// <param name="colorState">Color buffer texture to find or create</param>
|
||||
/// <param name="samplesInX">Number of samples in the X direction, for MSAA</param>
|
||||
/// <param name="samplesInY">Number of samples in the Y direction, for MSAA</param>
|
||||
/// <param name="sizeHint">A hint indicating the minimum used size for the texture</param>
|
||||
/// <returns>The texture</returns>
|
||||
public Texture FindOrCreateTexture(RtColorState colorState, int samplesInX, int samplesInY, Size sizeHint)
|
||||
{
|
||||
bool isLinear = colorState.MemoryLayout.UnpackIsLinear();
|
||||
|
||||
int gobBlocksInY = colorState.MemoryLayout.UnpackGobBlocksInY();
|
||||
int gobBlocksInZ = colorState.MemoryLayout.UnpackGobBlocksInZ();
|
||||
|
||||
Target target;
|
||||
|
||||
if (colorState.MemoryLayout.UnpackIsTarget3D())
|
||||
{
|
||||
target = Target.Texture3D;
|
||||
}
|
||||
else if ((samplesInX | samplesInY) != 1)
|
||||
{
|
||||
target = colorState.Depth > 1
|
||||
? Target.Texture2DMultisampleArray
|
||||
: Target.Texture2DMultisample;
|
||||
}
|
||||
else
|
||||
{
|
||||
target = colorState.Depth > 1
|
||||
? Target.Texture2DArray
|
||||
: Target.Texture2D;
|
||||
}
|
||||
|
||||
FormatInfo formatInfo = colorState.Format.Convert();
|
||||
|
||||
int width, stride;
|
||||
|
||||
// For linear textures, the width value is actually the stride.
|
||||
// We can easily get the width by dividing the stride by the bpp,
|
||||
// since the stride is the total number of bytes occupied by a
|
||||
// line. The stride should also meet alignment constraints however,
|
||||
// so the width we get here is the aligned width.
|
||||
if (isLinear)
|
||||
{
|
||||
width = colorState.WidthOrStride / formatInfo.BytesPerPixel;
|
||||
stride = colorState.WidthOrStride;
|
||||
}
|
||||
else
|
||||
{
|
||||
width = colorState.WidthOrStride;
|
||||
stride = 0;
|
||||
}
|
||||
|
||||
TextureInfo info = new TextureInfo(
|
||||
colorState.Address.Pack(),
|
||||
width,
|
||||
colorState.Height,
|
||||
colorState.Depth,
|
||||
1,
|
||||
samplesInX,
|
||||
samplesInY,
|
||||
stride,
|
||||
isLinear,
|
||||
gobBlocksInY,
|
||||
gobBlocksInZ,
|
||||
1,
|
||||
target,
|
||||
formatInfo);
|
||||
|
||||
int layerSize = !isLinear ? colorState.LayerSize * 4 : 0;
|
||||
|
||||
Texture texture = FindOrCreateTexture(TextureSearchFlags.WithUpscale, info, layerSize, sizeHint);
|
||||
|
||||
texture?.SynchronizeMemory();
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tries to find an existing texture, or create a new one if not found.
|
||||
/// </summary>
|
||||
/// <param name="dsState">Depth-stencil buffer texture to find or create</param>
|
||||
/// <param name="size">Size of the depth-stencil texture</param>
|
||||
/// <param name="samplesInX">Number of samples in the X direction, for MSAA</param>
|
||||
/// <param name="samplesInY">Number of samples in the Y direction, for MSAA</param>
|
||||
/// <param name="sizeHint">A hint indicating the minimum used size for the texture</param>
|
||||
/// <returns>The texture</returns>
|
||||
public Texture FindOrCreateTexture(RtDepthStencilState dsState, Size3D size, int samplesInX, int samplesInY, Size sizeHint)
|
||||
{
|
||||
int gobBlocksInY = dsState.MemoryLayout.UnpackGobBlocksInY();
|
||||
int gobBlocksInZ = dsState.MemoryLayout.UnpackGobBlocksInZ();
|
||||
|
||||
Target target = (samplesInX | samplesInY) != 1
|
||||
? Target.Texture2DMultisample
|
||||
: Target.Texture2D;
|
||||
|
||||
FormatInfo formatInfo = dsState.Format.Convert();
|
||||
|
||||
TextureInfo info = new TextureInfo(
|
||||
dsState.Address.Pack(),
|
||||
size.Width,
|
||||
size.Height,
|
||||
size.Depth,
|
||||
1,
|
||||
samplesInX,
|
||||
samplesInY,
|
||||
0,
|
||||
false,
|
||||
gobBlocksInY,
|
||||
gobBlocksInZ,
|
||||
1,
|
||||
target,
|
||||
formatInfo);
|
||||
|
||||
Texture texture = FindOrCreateTexture(TextureSearchFlags.WithUpscale, info, dsState.LayerSize * 4, sizeHint);
|
||||
|
||||
texture?.SynchronizeMemory();
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tries to find an existing texture, or create a new one if not found.
|
||||
/// </summary>
|
||||
/// <param name="flags">The texture search flags, defines texture comparison rules</param>
|
||||
/// <param name="info">Texture information of the texture to be found or created</param>
|
||||
/// <param name="layerSize">Size in bytes of a single texture layer</param>
|
||||
/// <param name="sizeHint">A hint indicating the minimum used size for the texture</param>
|
||||
/// <param name="range">Optional ranges of physical memory where the texture data is located</param>
|
||||
/// <returns>The texture</returns>
|
||||
public Texture FindOrCreateTexture(TextureSearchFlags flags, TextureInfo info, int layerSize = 0, Size? sizeHint = null, MultiRange? range = null)
|
||||
{
|
||||
bool isSamplerTexture = (flags & TextureSearchFlags.ForSampler) != 0;
|
||||
|
||||
bool isScalable = IsUpscaleCompatible(info);
|
||||
|
||||
TextureScaleMode scaleMode = TextureScaleMode.Blacklisted;
|
||||
if (isScalable)
|
||||
{
|
||||
scaleMode = (flags & TextureSearchFlags.WithUpscale) != 0 ? TextureScaleMode.Scaled : TextureScaleMode.Eligible;
|
||||
}
|
||||
|
||||
ulong address;
|
||||
|
||||
if (range != null)
|
||||
{
|
||||
address = range.Value.GetSubRange(0).Address;
|
||||
}
|
||||
else
|
||||
{
|
||||
address = _context.MemoryManager.Translate(info.GpuAddress);
|
||||
|
||||
if (address == MemoryManager.PteUnmapped)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
int sameAddressOverlapsCount;
|
||||
|
||||
lock (_textures)
|
||||
{
|
||||
// Try to find a perfect texture match, with the same address and parameters.
|
||||
sameAddressOverlapsCount = _textures.FindOverlaps(address, ref _textureOverlaps);
|
||||
}
|
||||
|
||||
Texture texture = null;
|
||||
|
||||
TextureMatchQuality bestQuality = TextureMatchQuality.NoMatch;
|
||||
|
||||
for (int index = 0; index < sameAddressOverlapsCount; index++)
|
||||
{
|
||||
Texture overlap = _textureOverlaps[index];
|
||||
|
||||
TextureMatchQuality matchQuality = overlap.IsExactMatch(info, flags);
|
||||
|
||||
if (matchQuality != TextureMatchQuality.NoMatch)
|
||||
{
|
||||
// If the parameters match, we need to make sure the texture is mapped to the same memory regions.
|
||||
|
||||
// If a range of memory was supplied, just check if the ranges match.
|
||||
if (range != null && !overlap.Range.Equals(range.Value))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
// If no range was supplied, we can check if the GPU virtual address match. If they do,
|
||||
// we know the textures are located at the same memory region.
|
||||
// If they don't, it may still be mapped to the same physical region, so we
|
||||
// do a more expensive check to tell if they are mapped into the same physical regions.
|
||||
// If the GPU VA for the texture has ever been unmapped, then the range must be checked regardless.
|
||||
if ((overlap.Info.GpuAddress != info.GpuAddress || overlap.ChangedMapping) &&
|
||||
!_context.MemoryManager.CompareRange(overlap.Range, info.GpuAddress))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (matchQuality == TextureMatchQuality.Perfect)
|
||||
{
|
||||
texture = overlap;
|
||||
break;
|
||||
}
|
||||
else if (matchQuality > bestQuality)
|
||||
{
|
||||
texture = overlap;
|
||||
bestQuality = matchQuality;
|
||||
}
|
||||
}
|
||||
|
||||
if (texture != null)
|
||||
{
|
||||
if (!isSamplerTexture)
|
||||
{
|
||||
// If not a sampler texture, it is managed by the auto delete
|
||||
// cache, ensure that it is on the "top" of the list to avoid
|
||||
// deletion.
|
||||
_cache.Lift(texture);
|
||||
}
|
||||
|
||||
ChangeSizeIfNeeded(info, texture, isSamplerTexture, sizeHint);
|
||||
|
||||
texture.SynchronizeMemory();
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
// Calculate texture sizes, used to find all overlapping textures.
|
||||
SizeInfo sizeInfo = info.CalculateSizeInfo(layerSize);
|
||||
|
||||
ulong size = (ulong)sizeInfo.TotalSize;
|
||||
|
||||
if (range == null)
|
||||
{
|
||||
range = _context.MemoryManager.GetPhysicalRegions(info.GpuAddress, size);
|
||||
}
|
||||
|
||||
// Find view compatible matches.
|
||||
int overlapsCount;
|
||||
|
||||
lock (_textures)
|
||||
{
|
||||
overlapsCount = _textures.FindOverlaps(range.Value, ref _textureOverlaps);
|
||||
}
|
||||
|
||||
if (_overlapInfo.Length != _textureOverlaps.Length)
|
||||
{
|
||||
Array.Resize(ref _overlapInfo, _textureOverlaps.Length);
|
||||
}
|
||||
|
||||
// =============== Find Texture View of Existing Texture ===============
|
||||
|
||||
int fullyCompatible = 0;
|
||||
|
||||
// Evaluate compatibility of overlaps
|
||||
|
||||
for (int index = 0; index < overlapsCount; index++)
|
||||
{
|
||||
Texture overlap = _textureOverlaps[index];
|
||||
TextureViewCompatibility overlapCompatibility = overlap.IsViewCompatible(info, range.Value, sizeInfo.LayerSize, out int firstLayer, out int firstLevel);
|
||||
|
||||
if (overlapCompatibility == TextureViewCompatibility.Full)
|
||||
{
|
||||
if (overlap.IsView)
|
||||
{
|
||||
overlapCompatibility = TextureViewCompatibility.CopyOnly;
|
||||
}
|
||||
else
|
||||
{
|
||||
fullyCompatible++;
|
||||
}
|
||||
}
|
||||
|
||||
_overlapInfo[index] = new OverlapInfo(overlapCompatibility, firstLayer, firstLevel);
|
||||
}
|
||||
|
||||
// Search through the overlaps to find a compatible view and establish any copy dependencies.
|
||||
|
||||
for (int index = 0; index < overlapsCount; index++)
|
||||
{
|
||||
Texture overlap = _textureOverlaps[index];
|
||||
OverlapInfo oInfo = _overlapInfo[index];
|
||||
|
||||
if (oInfo.Compatibility == TextureViewCompatibility.Full)
|
||||
{
|
||||
TextureInfo adjInfo = AdjustSizes(overlap, info, oInfo.FirstLevel);
|
||||
|
||||
if (!isSamplerTexture)
|
||||
{
|
||||
info = adjInfo;
|
||||
}
|
||||
|
||||
texture = overlap.CreateView(adjInfo, sizeInfo, range.Value, oInfo.FirstLayer, oInfo.FirstLevel);
|
||||
|
||||
ChangeSizeIfNeeded(info, texture, isSamplerTexture, sizeHint);
|
||||
|
||||
texture.SynchronizeMemory();
|
||||
break;
|
||||
}
|
||||
else if (oInfo.Compatibility == TextureViewCompatibility.CopyOnly && fullyCompatible == 0)
|
||||
{
|
||||
// Only copy compatible. If there's another choice for a FULLY compatible texture, choose that instead.
|
||||
|
||||
texture = new Texture(_context, info, sizeInfo, range.Value, scaleMode);
|
||||
texture.InitializeGroup(true, true);
|
||||
texture.InitializeData(false, false);
|
||||
|
||||
overlap.SynchronizeMemory();
|
||||
overlap.CreateCopyDependency(texture, oInfo.FirstLayer, oInfo.FirstLevel, true);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (texture != null)
|
||||
{
|
||||
// This texture could be a view of multiple parent textures with different storages, even if it is a view.
|
||||
// When a texture is created, make sure all possible dependencies to other textures are created as copies.
|
||||
// (even if it could be fulfilled without a copy)
|
||||
|
||||
for (int index = 0; index < overlapsCount; index++)
|
||||
{
|
||||
Texture overlap = _textureOverlaps[index];
|
||||
OverlapInfo oInfo = _overlapInfo[index];
|
||||
|
||||
if (oInfo.Compatibility != TextureViewCompatibility.Incompatible && overlap.Group != texture.Group)
|
||||
{
|
||||
overlap.SynchronizeMemory();
|
||||
overlap.CreateCopyDependency(texture, oInfo.FirstLayer, oInfo.FirstLevel, true);
|
||||
}
|
||||
}
|
||||
|
||||
texture.SynchronizeMemory();
|
||||
}
|
||||
|
||||
// =============== Create a New Texture ===============
|
||||
|
||||
// No match, create a new texture.
|
||||
if (texture == null)
|
||||
{
|
||||
texture = new Texture(_context, info, sizeInfo, range.Value, scaleMode);
|
||||
|
||||
// Step 1: Find textures that are view compatible with the new texture.
|
||||
// Any textures that are incompatible will contain garbage data, so they should be removed where possible.
|
||||
|
||||
int viewCompatible = 0;
|
||||
fullyCompatible = 0;
|
||||
bool setData = isSamplerTexture || overlapsCount == 0 || flags.HasFlag(TextureSearchFlags.ForCopy);
|
||||
|
||||
bool hasLayerViews = false;
|
||||
bool hasMipViews = false;
|
||||
|
||||
for (int index = 0; index < overlapsCount; index++)
|
||||
{
|
||||
Texture overlap = _textureOverlaps[index];
|
||||
bool overlapInCache = overlap.CacheNode != null;
|
||||
|
||||
TextureViewCompatibility compatibility = texture.IsViewCompatible(overlap.Info, overlap.Range, overlap.LayerSize, out int firstLayer, out int firstLevel);
|
||||
|
||||
if (overlap.IsView && compatibility == TextureViewCompatibility.Full)
|
||||
{
|
||||
compatibility = TextureViewCompatibility.CopyOnly;
|
||||
}
|
||||
|
||||
if (compatibility != TextureViewCompatibility.Incompatible)
|
||||
{
|
||||
if (compatibility == TextureViewCompatibility.Full)
|
||||
{
|
||||
if (viewCompatible == fullyCompatible)
|
||||
{
|
||||
_overlapInfo[viewCompatible] = new OverlapInfo(compatibility, firstLayer, firstLevel);
|
||||
_textureOverlaps[viewCompatible++] = overlap;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Swap overlaps so that the fully compatible views have priority.
|
||||
|
||||
_overlapInfo[viewCompatible] = _overlapInfo[fullyCompatible];
|
||||
_textureOverlaps[viewCompatible++] = _textureOverlaps[fullyCompatible];
|
||||
|
||||
_overlapInfo[fullyCompatible] = new OverlapInfo(compatibility, firstLayer, firstLevel);
|
||||
_textureOverlaps[fullyCompatible] = overlap;
|
||||
}
|
||||
fullyCompatible++;
|
||||
}
|
||||
else
|
||||
{
|
||||
_overlapInfo[viewCompatible] = new OverlapInfo(compatibility, firstLayer, firstLevel);
|
||||
_textureOverlaps[viewCompatible++] = overlap;
|
||||
}
|
||||
|
||||
hasLayerViews |= overlap.Info.GetSlices() < texture.Info.GetSlices();
|
||||
hasMipViews |= overlap.Info.Levels < texture.Info.Levels;
|
||||
}
|
||||
else if (overlapInCache || !setData)
|
||||
{
|
||||
if (info.GobBlocksInZ > 1 && info.GobBlocksInZ == overlap.Info.GobBlocksInZ)
|
||||
{
|
||||
// Allow overlapping slices of 3D textures. Could be improved in future by making sure the textures don't overlap.
|
||||
continue;
|
||||
}
|
||||
|
||||
// The overlap texture is going to contain garbage data after we draw, or is generally incompatible.
|
||||
// If the texture cannot be entirely contained in the new address space, and one of its view children is compatible with us,
|
||||
// it must be flushed before removal, so that the data is not lost.
|
||||
|
||||
// If the texture was modified since its last use, then that data is probably meant to go into this texture.
|
||||
// If the data has been modified by the CPU, then it also shouldn't be flushed.
|
||||
bool modified = overlap.ConsumeModified();
|
||||
|
||||
bool flush = overlapInCache && !modified && !texture.Range.Contains(overlap.Range) && overlap.HasViewCompatibleChild(texture);
|
||||
|
||||
setData |= modified || flush;
|
||||
|
||||
if (overlapInCache)
|
||||
{
|
||||
_cache.Remove(overlap, flush);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
texture.InitializeGroup(hasLayerViews, hasMipViews);
|
||||
|
||||
// We need to synchronize before copying the old view data to the texture,
|
||||
// otherwise the copied data would be overwritten by a future synchronization.
|
||||
texture.InitializeData(false, setData);
|
||||
|
||||
for (int index = 0; index < viewCompatible; index++)
|
||||
{
|
||||
Texture overlap = _textureOverlaps[index];
|
||||
|
||||
OverlapInfo oInfo = _overlapInfo[index];
|
||||
|
||||
if (overlap.Group == texture.Group)
|
||||
{
|
||||
// If the texture group is equal, then this texture (or its parent) is already a view.
|
||||
continue;
|
||||
}
|
||||
|
||||
TextureInfo overlapInfo = AdjustSizes(texture, overlap.Info, oInfo.FirstLevel);
|
||||
|
||||
if (texture.ScaleFactor != overlap.ScaleFactor)
|
||||
{
|
||||
// A bit tricky, our new texture may need to contain an existing texture that is upscaled, but isn't itself.
|
||||
// In that case, we prefer the higher scale only if our format is render-target-like, otherwise we scale the view down before copy.
|
||||
|
||||
texture.PropagateScale(overlap);
|
||||
}
|
||||
|
||||
if (oInfo.Compatibility != TextureViewCompatibility.Full)
|
||||
{
|
||||
// Copy only compatibility, or target texture is already a view.
|
||||
|
||||
overlap.SynchronizeMemory();
|
||||
texture.CreateCopyDependency(overlap, oInfo.FirstLayer, oInfo.FirstLevel, false);
|
||||
}
|
||||
else
|
||||
{
|
||||
TextureCreateInfo createInfo = GetCreateInfo(overlapInfo, _context.Capabilities, overlap.ScaleFactor);
|
||||
|
||||
ITexture newView = texture.HostTexture.CreateView(createInfo, oInfo.FirstLayer, oInfo.FirstLevel);
|
||||
|
||||
overlap.SynchronizeMemory();
|
||||
|
||||
overlap.HostTexture.CopyTo(newView, 0, 0);
|
||||
|
||||
overlap.ReplaceView(texture, overlapInfo, newView, oInfo.FirstLayer, oInfo.FirstLevel);
|
||||
}
|
||||
}
|
||||
|
||||
texture.SynchronizeMemory();
|
||||
}
|
||||
|
||||
// Sampler textures are managed by the texture pool, all other textures
|
||||
// are managed by the auto delete cache.
|
||||
if (!isSamplerTexture)
|
||||
{
|
||||
_cache.Add(texture);
|
||||
}
|
||||
|
||||
lock (_textures)
|
||||
{
|
||||
_textures.Add(texture);
|
||||
}
|
||||
|
||||
ShrinkOverlapsBufferIfNeeded();
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Changes a texture's size to match the desired size for samplers,
|
||||
/// or increases a texture's size to fit the region indicated by a size hint.
|
||||
/// </summary>
|
||||
/// <param name="info">The desired texture info</param>
|
||||
/// <param name="texture">The texture to resize</param>
|
||||
/// <param name="isSamplerTexture">True if the texture will be used for a sampler, false otherwise</param>
|
||||
/// <param name="sizeHint">A hint indicating the minimum used size for the texture</param>
|
||||
private void ChangeSizeIfNeeded(TextureInfo info, Texture texture, bool isSamplerTexture, Size? sizeHint)
|
||||
{
|
||||
if (isSamplerTexture)
|
||||
{
|
||||
// If this is used for sampling, the size must match,
|
||||
// otherwise the shader would sample garbage data.
|
||||
// To fix that, we create a new texture with the correct
|
||||
// size, and copy the data from the old one to the new one.
|
||||
|
||||
if (!TextureCompatibility.SizeMatches(texture.Info, info))
|
||||
{
|
||||
texture.ChangeSize(info.Width, info.Height, info.DepthOrLayers);
|
||||
}
|
||||
}
|
||||
else if (sizeHint != null)
|
||||
{
|
||||
// A size hint indicates that data will be used within that range, at least.
|
||||
// If the texture is smaller than the size hint, it must be enlarged to meet it.
|
||||
// The maximum size is provided by the requested info, which generally has an aligned size.
|
||||
|
||||
int width = Math.Max(texture.Info.Width, Math.Min(sizeHint.Value.Width, info.Width));
|
||||
int height = Math.Max(texture.Info.Height, Math.Min(sizeHint.Value.Height, info.Height));
|
||||
|
||||
if (texture.Info.Width != width || texture.Info.Height != height)
|
||||
{
|
||||
texture.ChangeSize(width, height, info.DepthOrLayers);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tries to find an existing texture matching the given buffer copy destination. If none is found, returns null.
|
||||
/// </summary>
|
||||
/// <param name="tex">The texture information</param>
|
||||
/// <param name="cbp">The copy buffer parameters</param>
|
||||
/// <param name="swizzle">The copy buffer swizzle</param>
|
||||
/// <param name="linear">True if the texture has a linear layout, false otherwise</param>
|
||||
/// <returns>A matching texture, or null if there is no match</returns>
|
||||
public Texture FindTexture(CopyBufferTexture tex, CopyBufferParams cbp, CopyBufferSwizzle swizzle, bool linear)
|
||||
{
|
||||
ulong address = _context.MemoryManager.Translate(cbp.DstAddress.Pack());
|
||||
|
||||
if (address == MemoryManager.PteUnmapped)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
int bpp = swizzle.UnpackDstComponentsCount() * swizzle.UnpackComponentSize();
|
||||
|
||||
int addressMatches = _textures.FindOverlaps(address, ref _textureOverlaps);
|
||||
|
||||
for (int i = 0; i < addressMatches; i++)
|
||||
{
|
||||
Texture texture = _textureOverlaps[i];
|
||||
FormatInfo format = texture.Info.FormatInfo;
|
||||
|
||||
if (texture.Info.DepthOrLayers > 1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
bool match;
|
||||
|
||||
if (linear)
|
||||
{
|
||||
// Size is not available for linear textures. Use the stride and end of the copy region instead.
|
||||
|
||||
match = texture.Info.IsLinear && texture.Info.Stride == cbp.DstStride && tex.RegionY + cbp.YCount <= texture.Info.Height;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Bpp may be a mismatch between the target texture and the param.
|
||||
// Due to the way linear strided and block layouts work, widths can be multiplied by Bpp for comparison.
|
||||
// Note: tex.Width is the aligned texture size. Prefer param.XCount, as the destination should be a texture with that exact size.
|
||||
|
||||
bool sizeMatch = cbp.XCount * bpp == texture.Info.Width * format.BytesPerPixel && tex.Height == texture.Info.Height;
|
||||
bool formatMatch = !texture.Info.IsLinear &&
|
||||
texture.Info.GobBlocksInY == tex.MemoryLayout.UnpackGobBlocksInY() &&
|
||||
texture.Info.GobBlocksInZ == tex.MemoryLayout.UnpackGobBlocksInZ();
|
||||
|
||||
match = sizeMatch && formatMatch;
|
||||
}
|
||||
|
||||
if (match)
|
||||
{
|
||||
return texture;
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Resizes the temporary buffer used for range list intersection results, if it has grown too much.
|
||||
/// </summary>
|
||||
private void ShrinkOverlapsBufferIfNeeded()
|
||||
{
|
||||
if (_textureOverlaps.Length > OverlapsBufferMaxCapacity)
|
||||
{
|
||||
Array.Resize(ref _textureOverlaps, OverlapsBufferMaxCapacity);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adjusts the size of the texture information for a given mipmap level,
|
||||
/// based on the size of a parent texture.
|
||||
/// </summary>
|
||||
/// <param name="parent">The parent texture</param>
|
||||
/// <param name="info">The texture information to be adjusted</param>
|
||||
/// <param name="firstLevel">The first level of the texture view</param>
|
||||
/// <returns>The adjusted texture information with the new size</returns>
|
||||
private static TextureInfo AdjustSizes(Texture parent, TextureInfo info, int firstLevel)
|
||||
{
|
||||
// When the texture is used as view of another texture, we must
|
||||
// ensure that the sizes are valid, otherwise data uploads would fail
|
||||
// (and the size wouldn't match the real size used on the host API).
|
||||
// Given a parent texture from where the view is created, we have the
|
||||
// following rules:
|
||||
// - The view size must be equal to the parent size, divided by (2 ^ l),
|
||||
// where l is the first mipmap level of the view. The division result must
|
||||
// be rounded down, and the result must be clamped to 1.
|
||||
// - If the parent format is compressed, and the view format isn't, the
|
||||
// view size is calculated as above, but the width and height of the
|
||||
// view must be also divided by the compressed format block width and height.
|
||||
// - If the parent format is not compressed, and the view is, the view
|
||||
// size is calculated as described on the first point, but the width and height
|
||||
// of the view must be also multiplied by the block width and height.
|
||||
int width = Math.Max(1, parent.Info.Width >> firstLevel);
|
||||
int height = Math.Max(1, parent.Info.Height >> firstLevel);
|
||||
|
||||
if (parent.Info.FormatInfo.IsCompressed && !info.FormatInfo.IsCompressed)
|
||||
{
|
||||
width = BitUtils.DivRoundUp(width, parent.Info.FormatInfo.BlockWidth);
|
||||
height = BitUtils.DivRoundUp(height, parent.Info.FormatInfo.BlockHeight);
|
||||
}
|
||||
else if (!parent.Info.FormatInfo.IsCompressed && info.FormatInfo.IsCompressed)
|
||||
{
|
||||
width *= info.FormatInfo.BlockWidth;
|
||||
height *= info.FormatInfo.BlockHeight;
|
||||
}
|
||||
|
||||
int depthOrLayers;
|
||||
|
||||
if (info.Target == Target.Texture3D)
|
||||
{
|
||||
depthOrLayers = Math.Max(1, parent.Info.DepthOrLayers >> firstLevel);
|
||||
}
|
||||
else
|
||||
{
|
||||
depthOrLayers = info.DepthOrLayers;
|
||||
}
|
||||
|
||||
return new TextureInfo(
|
||||
info.GpuAddress,
|
||||
width,
|
||||
height,
|
||||
depthOrLayers,
|
||||
info.Levels,
|
||||
info.SamplesInX,
|
||||
info.SamplesInY,
|
||||
info.Stride,
|
||||
info.IsLinear,
|
||||
info.GobBlocksInY,
|
||||
info.GobBlocksInZ,
|
||||
info.GobBlocksInTileX,
|
||||
info.Target,
|
||||
info.FormatInfo,
|
||||
info.DepthStencilMode,
|
||||
info.SwizzleR,
|
||||
info.SwizzleG,
|
||||
info.SwizzleB,
|
||||
info.SwizzleA);
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Gets a texture creation information from texture information.
|
||||
/// This can be used to create new host textures.
|
||||
/// </summary>
|
||||
/// <param name="info">Texture information</param>
|
||||
/// <param name="caps">GPU capabilities</param>
|
||||
/// <param name="scale">Texture scale factor, to be applied to the texture size</param>
|
||||
/// <returns>The texture creation information</returns>
|
||||
public static TextureCreateInfo GetCreateInfo(TextureInfo info, Capabilities caps, float scale)
|
||||
{
|
||||
FormatInfo formatInfo = TextureCompatibility.ToHostCompatibleFormat(info, caps);
|
||||
|
||||
if (info.Target == Target.TextureBuffer)
|
||||
{
|
||||
// We assume that the host does not support signed normalized format
|
||||
// (as is the case with OpenGL), so we just use a unsigned format.
|
||||
// The shader will need the appropriate conversion code to compensate.
|
||||
switch (formatInfo.Format)
|
||||
{
|
||||
case Format.R8Snorm:
|
||||
formatInfo = new FormatInfo(Format.R8Sint, 1, 1, 1, 1);
|
||||
break;
|
||||
case Format.R16Snorm:
|
||||
formatInfo = new FormatInfo(Format.R16Sint, 1, 1, 2, 1);
|
||||
break;
|
||||
case Format.R8G8Snorm:
|
||||
formatInfo = new FormatInfo(Format.R8G8Sint, 1, 1, 2, 2);
|
||||
break;
|
||||
case Format.R16G16Snorm:
|
||||
formatInfo = new FormatInfo(Format.R16G16Sint, 1, 1, 4, 2);
|
||||
break;
|
||||
case Format.R8G8B8A8Snorm:
|
||||
formatInfo = new FormatInfo(Format.R8G8B8A8Sint, 1, 1, 4, 4);
|
||||
break;
|
||||
case Format.R16G16B16A16Snorm:
|
||||
formatInfo = new FormatInfo(Format.R16G16B16A16Sint, 1, 1, 8, 4);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int width = info.Width / info.SamplesInX;
|
||||
int height = info.Height / info.SamplesInY;
|
||||
|
||||
int depth = info.GetDepth() * info.GetLayers();
|
||||
|
||||
if (scale != 1f)
|
||||
{
|
||||
width = (int)MathF.Ceiling(width * scale);
|
||||
height = (int)MathF.Ceiling(height * scale);
|
||||
}
|
||||
|
||||
return new TextureCreateInfo(
|
||||
width,
|
||||
height,
|
||||
depth,
|
||||
info.Levels,
|
||||
info.Samples,
|
||||
formatInfo.BlockWidth,
|
||||
formatInfo.BlockHeight,
|
||||
formatInfo.BytesPerPixel,
|
||||
formatInfo.Format,
|
||||
info.DepthStencilMode,
|
||||
info.Target,
|
||||
info.SwizzleR,
|
||||
info.SwizzleG,
|
||||
info.SwizzleB,
|
||||
info.SwizzleA);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Removes a texture from the cache.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// This only removes the texture from the internal list, not from the auto-deletion cache.
|
||||
/// It may still have live references after the removal.
|
||||
/// </remarks>
|
||||
/// <param name="texture">The texture to be removed</param>
|
||||
public void RemoveTextureFromCache(Texture texture)
|
||||
{
|
||||
lock (_textures)
|
||||
{
|
||||
_textures.Remove(texture);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Disposes all textures and samplers in the cache.
|
||||
/// It's an error to use the texture cache after disposal.
|
||||
/// </summary>
|
||||
public void Dispose()
|
||||
{
|
||||
lock (_textures)
|
||||
{
|
||||
foreach (Texture texture in _textures)
|
||||
{
|
||||
texture.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -57,7 +57,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
|
||||
ProcessDereferenceQueue();
|
||||
|
||||
texture = Context.Methods.TextureManager.FindOrCreateTexture(TextureSearchFlags.ForSampler, info, layerSize);
|
||||
texture = Context.Methods.TextureCache.FindOrCreateTexture(TextureSearchFlags.ForSampler, info, layerSize);
|
||||
|
||||
// If this happens, then the texture address is invalid, we can't add it to the cache.
|
||||
if (texture == null)
|
||||
|
|
|
|||
|
|
@ -1,3 +1,4 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Image
|
||||
|
|
@ -7,7 +8,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
/// This can keep multiple texture pools, and return the current one as needed.
|
||||
/// It is useful for applications that uses multiple texture pools.
|
||||
/// </summary>
|
||||
class TexturePoolCache
|
||||
class TexturePoolCache : IDisposable
|
||||
{
|
||||
private const int MaxCapacity = 4;
|
||||
|
||||
|
|
@ -72,5 +73,19 @@ namespace Ryujinx.Graphics.Gpu.Image
|
|||
|
||||
return pool;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Disposes the texture pool cache.
|
||||
/// It's an error to use the texture pool cache after disposal.
|
||||
/// </summary>
|
||||
public void Dispose()
|
||||
{
|
||||
foreach (TexturePool pool in _pools)
|
||||
{
|
||||
pool.Dispose();
|
||||
}
|
||||
|
||||
_pools.Clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
390
Ryujinx.Graphics.Gpu/Memory/BufferCache.cs
Normal file
390
Ryujinx.Graphics.Gpu/Memory/BufferCache.cs
Normal file
|
|
@ -0,0 +1,390 @@
|
|||
using Ryujinx.Graphics.GAL;
|
||||
using Ryujinx.Graphics.Gpu.State;
|
||||
using Ryujinx.Memory.Range;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Memory
|
||||
{
|
||||
/// <summary>
|
||||
/// Buffer cache.
|
||||
/// </summary>
|
||||
class BufferCache : IDisposable
|
||||
{
|
||||
private const int OverlapsBufferInitialCapacity = 10;
|
||||
private const int OverlapsBufferMaxCapacity = 10000;
|
||||
|
||||
private const ulong BufferAlignmentSize = 0x1000;
|
||||
private const ulong BufferAlignmentMask = BufferAlignmentSize - 1;
|
||||
|
||||
private GpuContext _context;
|
||||
|
||||
private readonly RangeList<Buffer> _buffers;
|
||||
|
||||
private Buffer[] _bufferOverlaps;
|
||||
|
||||
private readonly Dictionary<ulong, BufferCacheEntry> _dirtyCache;
|
||||
|
||||
public event Action NotifyBuffersModified;
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of the buffer manager.
|
||||
/// </summary>
|
||||
/// <param name="context">The GPU context that the buffer manager belongs to</param>
|
||||
public BufferCache(GpuContext context)
|
||||
{
|
||||
_context = context;
|
||||
|
||||
_buffers = new RangeList<Buffer>();
|
||||
|
||||
_bufferOverlaps = new Buffer[OverlapsBufferInitialCapacity];
|
||||
|
||||
_dirtyCache = new Dictionary<ulong, BufferCacheEntry>();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Handles removal of buffers written to a memory region being unmapped.
|
||||
/// </summary>
|
||||
/// <param name="sender">Sender object</param>
|
||||
/// <param name="e">Event arguments</param>
|
||||
public void MemoryUnmappedHandler(object sender, UnmapEventArgs e)
|
||||
{
|
||||
Buffer[] overlaps = new Buffer[10];
|
||||
int overlapCount;
|
||||
|
||||
ulong address = _context.MemoryManager.Translate(e.Address);
|
||||
ulong size = e.Size;
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
overlapCount = _buffers.FindOverlaps(address, size, ref overlaps);
|
||||
}
|
||||
|
||||
for (int i = 0; i < overlapCount; i++)
|
||||
{
|
||||
overlaps[i].Unmapped(address, size);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Performs address translation of the GPU virtual address, and creates a
|
||||
/// new buffer, if needed, for the specified range.
|
||||
/// </summary>
|
||||
/// <param name="gpuVa">Start GPU virtual address of the buffer</param>
|
||||
/// <param name="size">Size in bytes of the buffer</param>
|
||||
/// <returns>CPU virtual address of the buffer, after address translation</returns>
|
||||
public ulong TranslateAndCreateBuffer(ulong gpuVa, ulong size)
|
||||
{
|
||||
if (gpuVa == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
ulong address = _context.MemoryManager.Translate(gpuVa);
|
||||
|
||||
if (address == MemoryManager.PteUnmapped)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
CreateBuffer(address, size);
|
||||
|
||||
return address;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new buffer for the specified range, if it does not yet exist.
|
||||
/// This can be used to ensure the existance of a buffer.
|
||||
/// </summary>
|
||||
/// <param name="address">Address of the buffer in memory</param>
|
||||
/// <param name="size">Size of the buffer in bytes</param>
|
||||
public void CreateBuffer(ulong address, ulong size)
|
||||
{
|
||||
ulong endAddress = address + size;
|
||||
|
||||
ulong alignedAddress = address & ~BufferAlignmentMask;
|
||||
|
||||
ulong alignedEndAddress = (endAddress + BufferAlignmentMask) & ~BufferAlignmentMask;
|
||||
|
||||
// The buffer must have the size of at least one page.
|
||||
if (alignedEndAddress == alignedAddress)
|
||||
{
|
||||
alignedEndAddress += BufferAlignmentSize;
|
||||
}
|
||||
|
||||
CreateBufferAligned(alignedAddress, alignedEndAddress - alignedAddress);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Performs address translation of the GPU virtual address, and attempts to force
|
||||
/// the buffer in the region as dirty.
|
||||
/// The buffer lookup for this function is cached in a dictionary for quick access, which
|
||||
/// accelerates common UBO updates.
|
||||
/// </summary>
|
||||
/// <param name="gpuVa">Start GPU virtual address of the buffer</param>
|
||||
/// <param name="size">Size in bytes of the buffer</param>
|
||||
public void ForceDirty(ulong gpuVa, ulong size)
|
||||
{
|
||||
BufferCacheEntry result;
|
||||
|
||||
if (!_dirtyCache.TryGetValue(gpuVa, out result) || result.EndGpuAddress < gpuVa + size || result.UnmappedSequence != result.Buffer.UnmappedSequence)
|
||||
{
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa, size);
|
||||
result = new BufferCacheEntry(address, gpuVa, GetBuffer(address, size));
|
||||
|
||||
_dirtyCache[gpuVa] = result;
|
||||
}
|
||||
|
||||
result.Buffer.ForceDirty(result.Address, size);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new buffer for the specified range, if needed.
|
||||
/// If a buffer where this range can be fully contained already exists,
|
||||
/// then the creation of a new buffer is not necessary.
|
||||
/// </summary>
|
||||
/// <param name="address">Address of the buffer in guest memory</param>
|
||||
/// <param name="size">Size in bytes of the buffer</param>
|
||||
private void CreateBufferAligned(ulong address, ulong size)
|
||||
{
|
||||
int overlapsCount;
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
overlapsCount = _buffers.FindOverlapsNonOverlapping(address, size, ref _bufferOverlaps);
|
||||
}
|
||||
|
||||
if (overlapsCount != 0)
|
||||
{
|
||||
// The buffer already exists. We can just return the existing buffer
|
||||
// if the buffer we need is fully contained inside the overlapping buffer.
|
||||
// Otherwise, we must delete the overlapping buffers and create a bigger buffer
|
||||
// that fits all the data we need. We also need to copy the contents from the
|
||||
// old buffer(s) to the new buffer.
|
||||
ulong endAddress = address + size;
|
||||
|
||||
if (_bufferOverlaps[0].Address > address || _bufferOverlaps[0].EndAddress < endAddress)
|
||||
{
|
||||
for (int index = 0; index < overlapsCount; index++)
|
||||
{
|
||||
Buffer buffer = _bufferOverlaps[index];
|
||||
|
||||
address = Math.Min(address, buffer.Address);
|
||||
endAddress = Math.Max(endAddress, buffer.EndAddress);
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
_buffers.Remove(buffer);
|
||||
}
|
||||
}
|
||||
|
||||
Buffer newBuffer = new Buffer(_context, address, endAddress - address, _bufferOverlaps.Take(overlapsCount));
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
_buffers.Add(newBuffer);
|
||||
}
|
||||
|
||||
for (int index = 0; index < overlapsCount; index++)
|
||||
{
|
||||
Buffer buffer = _bufferOverlaps[index];
|
||||
|
||||
int dstOffset = (int)(buffer.Address - newBuffer.Address);
|
||||
|
||||
buffer.CopyTo(newBuffer, dstOffset);
|
||||
newBuffer.InheritModifiedRanges(buffer);
|
||||
|
||||
buffer.DisposeData();
|
||||
}
|
||||
|
||||
newBuffer.SynchronizeMemory(address, endAddress - address);
|
||||
|
||||
// Existing buffers were modified, we need to rebind everything.
|
||||
NotifyBuffersModified?.Invoke();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// No overlap, just create a new buffer.
|
||||
Buffer buffer = new Buffer(_context, address, size);
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
_buffers.Add(buffer);
|
||||
}
|
||||
}
|
||||
|
||||
ShrinkOverlapsBufferIfNeeded();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Resizes the temporary buffer used for range list intersection results, if it has grown too much.
|
||||
/// </summary>
|
||||
private void ShrinkOverlapsBufferIfNeeded()
|
||||
{
|
||||
if (_bufferOverlaps.Length > OverlapsBufferMaxCapacity)
|
||||
{
|
||||
Array.Resize(ref _bufferOverlaps, OverlapsBufferMaxCapacity);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Copy a buffer data from a given address to another.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// This does a GPU side copy.
|
||||
/// </remarks>
|
||||
/// <param name="srcVa">GPU virtual address of the copy source</param>
|
||||
/// <param name="dstVa">GPU virtual address of the copy destination</param>
|
||||
/// <param name="size">Size in bytes of the copy</param>
|
||||
public void CopyBuffer(GpuVa srcVa, GpuVa dstVa, ulong size)
|
||||
{
|
||||
ulong srcAddress = TranslateAndCreateBuffer(srcVa.Pack(), size);
|
||||
ulong dstAddress = TranslateAndCreateBuffer(dstVa.Pack(), size);
|
||||
|
||||
Buffer srcBuffer = GetBuffer(srcAddress, size);
|
||||
Buffer dstBuffer = GetBuffer(dstAddress, size);
|
||||
|
||||
int srcOffset = (int)(srcAddress - srcBuffer.Address);
|
||||
int dstOffset = (int)(dstAddress - dstBuffer.Address);
|
||||
|
||||
_context.Renderer.Pipeline.CopyBuffer(
|
||||
srcBuffer.Handle,
|
||||
dstBuffer.Handle,
|
||||
srcOffset,
|
||||
dstOffset,
|
||||
(int)size);
|
||||
|
||||
if (srcBuffer.IsModified(srcAddress, size))
|
||||
{
|
||||
dstBuffer.SignalModified(dstAddress, size);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Optimization: If the data being copied is already in memory, then copy it directly instead of flushing from GPU.
|
||||
|
||||
dstBuffer.ClearModified(dstAddress, size);
|
||||
_context.PhysicalMemory.WriteUntracked(dstAddress, _context.PhysicalMemory.GetSpan(srcAddress, (int)size));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Clears a buffer at a given address with the specified value.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Both the address and size must be aligned to 4 bytes.
|
||||
/// </remarks>
|
||||
/// <param name="gpuVa">GPU virtual address of the region to clear</param>
|
||||
/// <param name="size">Number of bytes to clear</param>
|
||||
/// <param name="value">Value to be written into the buffer</param>
|
||||
public void ClearBuffer(GpuVa gpuVa, ulong size, uint value)
|
||||
{
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa.Pack(), size);
|
||||
|
||||
Buffer buffer = GetBuffer(address, size);
|
||||
|
||||
int offset = (int)(address - buffer.Address);
|
||||
|
||||
_context.Renderer.Pipeline.ClearBuffer(buffer.Handle, offset, (int)size, value);
|
||||
|
||||
buffer.SignalModified(address, size);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets a buffer sub-range starting at a given memory address.
|
||||
/// </summary>
|
||||
/// <param name="address">Start address of the memory range</param>
|
||||
/// <param name="size">Size in bytes of the memory range</param>
|
||||
/// <param name="write">Whether the buffer will be written to by this use</param>
|
||||
/// <returns>The buffer sub-range starting at the given memory address</returns>
|
||||
public BufferRange GetBufferRangeTillEnd(ulong address, ulong size, bool write = false)
|
||||
{
|
||||
return GetBuffer(address, size, write).GetRange(address);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets a buffer sub-range for a given memory range.
|
||||
/// </summary>
|
||||
/// <param name="address">Start address of the memory range</param>
|
||||
/// <param name="size">Size in bytes of the memory range</param>
|
||||
/// <param name="write">Whether the buffer will be written to by this use</param>
|
||||
/// <returns>The buffer sub-range for the given range</returns>
|
||||
public BufferRange GetBufferRange(ulong address, ulong size, bool write = false)
|
||||
{
|
||||
return GetBuffer(address, size, write).GetRange(address, size);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets a buffer for a given memory range.
|
||||
/// A buffer overlapping with the specified range is assumed to already exist on the cache.
|
||||
/// </summary>
|
||||
/// <param name="address">Start address of the memory range</param>
|
||||
/// <param name="size">Size in bytes of the memory range</param>
|
||||
/// <param name="write">Whether the buffer will be written to by this use</param>
|
||||
/// <returns>The buffer where the range is fully contained</returns>
|
||||
private Buffer GetBuffer(ulong address, ulong size, bool write = false)
|
||||
{
|
||||
Buffer buffer;
|
||||
|
||||
if (size != 0)
|
||||
{
|
||||
lock (_buffers)
|
||||
{
|
||||
buffer = _buffers.FindFirstOverlap(address, size);
|
||||
}
|
||||
|
||||
buffer.SynchronizeMemory(address, size);
|
||||
|
||||
if (write)
|
||||
{
|
||||
buffer.SignalModified(address, size);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
lock (_buffers)
|
||||
{
|
||||
buffer = _buffers.FindFirstOverlap(address, 1);
|
||||
}
|
||||
}
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Performs guest to host memory synchronization of a given memory range.
|
||||
/// </summary>
|
||||
/// <param name="address">Start address of the memory range</param>
|
||||
/// <param name="size">Size in bytes of the memory range</param>
|
||||
public void SynchronizeBufferRange(ulong address, ulong size)
|
||||
{
|
||||
if (size != 0)
|
||||
{
|
||||
Buffer buffer;
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
buffer = _buffers.FindFirstOverlap(address, size);
|
||||
}
|
||||
|
||||
buffer.SynchronizeMemory(address, size);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Disposes all buffers in the cache.
|
||||
/// It's an error to use the buffer manager after disposal.
|
||||
/// </summary>
|
||||
public void Dispose()
|
||||
{
|
||||
lock (_buffers)
|
||||
{
|
||||
foreach (Buffer buffer in _buffers)
|
||||
{
|
||||
buffer.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,9 +1,7 @@
|
|||
using Ryujinx.Common;
|
||||
using Ryujinx.Common;
|
||||
using Ryujinx.Graphics.GAL;
|
||||
using Ryujinx.Graphics.Gpu.Image;
|
||||
using Ryujinx.Graphics.Gpu.State;
|
||||
using Ryujinx.Graphics.Shader;
|
||||
using Ryujinx.Memory.Range;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Collections.ObjectModel;
|
||||
|
|
@ -14,26 +12,16 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
/// <summary>
|
||||
/// Buffer manager.
|
||||
/// </summary>
|
||||
class BufferManager
|
||||
class BufferManager : IDisposable
|
||||
{
|
||||
private const int StackToHeapThreshold = 16;
|
||||
|
||||
private const int OverlapsBufferInitialCapacity = 10;
|
||||
private const int OverlapsBufferMaxCapacity = 10000;
|
||||
|
||||
private const ulong BufferAlignmentSize = 0x1000;
|
||||
private const ulong BufferAlignmentMask = BufferAlignmentSize - 1;
|
||||
|
||||
private GpuContext _context;
|
||||
|
||||
private RangeList<Buffer> _buffers;
|
||||
|
||||
private Buffer[] _bufferOverlaps;
|
||||
private readonly GpuContext _context;
|
||||
|
||||
private IndexBuffer _indexBuffer;
|
||||
private VertexBuffer[] _vertexBuffers;
|
||||
private BufferBounds[] _transformFeedbackBuffers;
|
||||
private List<BufferTextureBinding> _bufferTextures;
|
||||
private readonly VertexBuffer[] _vertexBuffers;
|
||||
private readonly BufferBounds[] _transformFeedbackBuffers;
|
||||
private readonly List<BufferTextureBinding> _bufferTextures;
|
||||
|
||||
/// <summary>
|
||||
/// Holds shader stage buffer state and binding information.
|
||||
|
|
@ -94,10 +82,10 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
}
|
||||
}
|
||||
|
||||
private BuffersPerStage _cpStorageBuffers;
|
||||
private BuffersPerStage _cpUniformBuffers;
|
||||
private BuffersPerStage[] _gpStorageBuffers;
|
||||
private BuffersPerStage[] _gpUniformBuffers;
|
||||
private readonly BuffersPerStage _cpStorageBuffers;
|
||||
private readonly BuffersPerStage _cpUniformBuffers;
|
||||
private readonly BuffersPerStage[] _gpStorageBuffers;
|
||||
private readonly BuffersPerStage[] _gpUniformBuffers;
|
||||
|
||||
private int _cpStorageBufferBindings;
|
||||
private int _cpUniformBufferBindings;
|
||||
|
|
@ -114,20 +102,14 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
|
||||
private bool _rebind;
|
||||
|
||||
private Dictionary<ulong, BufferCacheEntry> _dirtyCache;
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of the buffer manager.
|
||||
/// </summary>
|
||||
/// <param name="context">The GPU context that the buffer manager belongs to</param>
|
||||
/// <param name="context">GPU context that the buffer manager belongs to</param>
|
||||
public BufferManager(GpuContext context)
|
||||
{
|
||||
_context = context;
|
||||
|
||||
_buffers = new RangeList<Buffer>();
|
||||
|
||||
_bufferOverlaps = new Buffer[OverlapsBufferInitialCapacity];
|
||||
|
||||
_vertexBuffers = new VertexBuffer[Constants.TotalVertexBuffers];
|
||||
|
||||
_transformFeedbackBuffers = new BufferBounds[Constants.TotalTransformFeedbackBuffers];
|
||||
|
|
@ -146,9 +128,10 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
|
||||
_bufferTextures = new List<BufferTextureBinding>();
|
||||
|
||||
_dirtyCache = new Dictionary<ulong, BufferCacheEntry>();
|
||||
context.Methods.BufferCache.NotifyBuffersModified += Rebind;
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Sets the memory range with the index buffer data, to be used for subsequent draw calls.
|
||||
/// </summary>
|
||||
|
|
@ -157,11 +140,11 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
/// <param name="type">Type of each index buffer element</param>
|
||||
public void SetIndexBuffer(ulong gpuVa, ulong size, IndexType type)
|
||||
{
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa, size);
|
||||
ulong address = _context.Methods.BufferCache.TranslateAndCreateBuffer(gpuVa, size);
|
||||
|
||||
_indexBuffer.Address = address;
|
||||
_indexBuffer.Size = size;
|
||||
_indexBuffer.Type = type;
|
||||
_indexBuffer.Size = size;
|
||||
_indexBuffer.Type = type;
|
||||
|
||||
_indexBufferDirty = true;
|
||||
}
|
||||
|
|
@ -188,11 +171,11 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
/// <param name="divisor">Vertex divisor of the buffer, for instanced draws</param>
|
||||
public void SetVertexBuffer(int index, ulong gpuVa, ulong size, int stride, int divisor)
|
||||
{
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa, size);
|
||||
ulong address = _context.Methods.BufferCache.TranslateAndCreateBuffer(gpuVa, size);
|
||||
|
||||
_vertexBuffers[index].Address = address;
|
||||
_vertexBuffers[index].Size = size;
|
||||
_vertexBuffers[index].Stride = stride;
|
||||
_vertexBuffers[index].Size = size;
|
||||
_vertexBuffers[index].Stride = stride;
|
||||
_vertexBuffers[index].Divisor = divisor;
|
||||
|
||||
_vertexBuffersDirty = true;
|
||||
|
|
@ -216,7 +199,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
/// <param name="size">Size in bytes of the transform feedback buffer</param>
|
||||
public void SetTransformFeedbackBuffer(int index, ulong gpuVa, ulong size)
|
||||
{
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa, size);
|
||||
ulong address = _context.Methods.BufferCache.TranslateAndCreateBuffer(gpuVa, size);
|
||||
|
||||
_transformFeedbackBuffers[index] = new BufferBounds(address, size);
|
||||
_transformFeedbackBuffersDirty = true;
|
||||
|
|
@ -236,7 +219,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
|
||||
gpuVa = BitUtils.AlignDown(gpuVa, _context.Capabilities.StorageBufferOffsetAlignment);
|
||||
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa, size);
|
||||
ulong address = _context.Methods.BufferCache.TranslateAndCreateBuffer(gpuVa, size);
|
||||
|
||||
_cpStorageBuffers.SetBounds(index, address, size, flags);
|
||||
}
|
||||
|
|
@ -256,10 +239,10 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
|
||||
gpuVa = BitUtils.AlignDown(gpuVa, _context.Capabilities.StorageBufferOffsetAlignment);
|
||||
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa, size);
|
||||
ulong address = _context.Methods.BufferCache.TranslateAndCreateBuffer(gpuVa, size);
|
||||
|
||||
if (_gpStorageBuffers[stage].Buffers[index].Address != address ||
|
||||
_gpStorageBuffers[stage].Buffers[index].Size != size)
|
||||
_gpStorageBuffers[stage].Buffers[index].Size != size)
|
||||
{
|
||||
_gpStorageBuffersDirty = true;
|
||||
}
|
||||
|
|
@ -276,7 +259,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
/// <param name="size">Size in bytes of the storage buffer</param>
|
||||
public void SetComputeUniformBuffer(int index, ulong gpuVa, ulong size)
|
||||
{
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa, size);
|
||||
ulong address = _context.Methods.BufferCache.TranslateAndCreateBuffer(gpuVa, size);
|
||||
|
||||
_cpUniformBuffers.SetBounds(index, address, size);
|
||||
}
|
||||
|
|
@ -291,7 +274,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
/// <param name="size">Size in bytes of the storage buffer</param>
|
||||
public void SetGraphicsUniformBuffer(int stage, int index, ulong gpuVa, ulong size)
|
||||
{
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa, size);
|
||||
ulong address = _context.Methods.BufferCache.TranslateAndCreateBuffer(gpuVa, size);
|
||||
|
||||
_gpUniformBuffers[stage].SetBounds(index, address, size);
|
||||
_gpUniformBuffersDirty = true;
|
||||
|
|
@ -397,191 +380,6 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
return mask;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Handles removal of buffers written to a memory region being unmapped.
|
||||
/// </summary>
|
||||
/// <param name="sender">Sender object</param>
|
||||
/// <param name="e">Event arguments</param>
|
||||
public void MemoryUnmappedHandler(object sender, UnmapEventArgs e)
|
||||
{
|
||||
Buffer[] overlaps = new Buffer[10];
|
||||
int overlapCount;
|
||||
|
||||
ulong address = _context.MemoryManager.Translate(e.Address);
|
||||
ulong size = e.Size;
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
overlapCount = _buffers.FindOverlaps(address, size, ref overlaps);
|
||||
}
|
||||
|
||||
for (int i = 0; i < overlapCount; i++)
|
||||
{
|
||||
overlaps[i].Unmapped(address, size);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Performs address translation of the GPU virtual address, and creates a
|
||||
/// new buffer, if needed, for the specified range.
|
||||
/// </summary>
|
||||
/// <param name="gpuVa">Start GPU virtual address of the buffer</param>
|
||||
/// <param name="size">Size in bytes of the buffer</param>
|
||||
/// <returns>CPU virtual address of the buffer, after address translation</returns>
|
||||
private ulong TranslateAndCreateBuffer(ulong gpuVa, ulong size)
|
||||
{
|
||||
if (gpuVa == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
ulong address = _context.MemoryManager.Translate(gpuVa);
|
||||
|
||||
if (address == MemoryManager.PteUnmapped)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
CreateBuffer(address, size);
|
||||
|
||||
return address;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new buffer for the specified range, if it does not yet exist.
|
||||
/// This can be used to ensure the existance of a buffer.
|
||||
/// </summary>
|
||||
/// <param name="address">Address of the buffer in memory</param>
|
||||
/// <param name="size">Size of the buffer in bytes</param>
|
||||
public void CreateBuffer(ulong address, ulong size)
|
||||
{
|
||||
ulong endAddress = address + size;
|
||||
|
||||
ulong alignedAddress = address & ~BufferAlignmentMask;
|
||||
|
||||
ulong alignedEndAddress = (endAddress + BufferAlignmentMask) & ~BufferAlignmentMask;
|
||||
|
||||
// The buffer must have the size of at least one page.
|
||||
if (alignedEndAddress == alignedAddress)
|
||||
{
|
||||
alignedEndAddress += BufferAlignmentSize;
|
||||
}
|
||||
|
||||
CreateBufferAligned(alignedAddress, alignedEndAddress - alignedAddress);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Performs address translation of the GPU virtual address, and attempts to force
|
||||
/// the buffer in the region as dirty.
|
||||
/// The buffer lookup for this function is cached in a dictionary for quick access, which
|
||||
/// accelerates common UBO updates.
|
||||
/// </summary>
|
||||
/// <param name="gpuVa">Start GPU virtual address of the buffer</param>
|
||||
/// <param name="size">Size in bytes of the buffer</param>
|
||||
public void ForceDirty(ulong gpuVa, ulong size)
|
||||
{
|
||||
BufferCacheEntry result;
|
||||
|
||||
if (!_dirtyCache.TryGetValue(gpuVa, out result) || result.EndGpuAddress < gpuVa + size || result.UnmappedSequence != result.Buffer.UnmappedSequence)
|
||||
{
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa, size);
|
||||
result = new BufferCacheEntry(address, gpuVa, GetBuffer(address, size));
|
||||
|
||||
_dirtyCache[gpuVa] = result;
|
||||
}
|
||||
|
||||
result.Buffer.ForceDirty(result.Address, size);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new buffer for the specified range, if needed.
|
||||
/// If a buffer where this range can be fully contained already exists,
|
||||
/// then the creation of a new buffer is not necessary.
|
||||
/// </summary>
|
||||
/// <param name="address">Address of the buffer in guest memory</param>
|
||||
/// <param name="size">Size in bytes of the buffer</param>
|
||||
private void CreateBufferAligned(ulong address, ulong size)
|
||||
{
|
||||
int overlapsCount;
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
overlapsCount = _buffers.FindOverlapsNonOverlapping(address, size, ref _bufferOverlaps);
|
||||
}
|
||||
|
||||
if (overlapsCount != 0)
|
||||
{
|
||||
// The buffer already exists. We can just return the existing buffer
|
||||
// if the buffer we need is fully contained inside the overlapping buffer.
|
||||
// Otherwise, we must delete the overlapping buffers and create a bigger buffer
|
||||
// that fits all the data we need. We also need to copy the contents from the
|
||||
// old buffer(s) to the new buffer.
|
||||
ulong endAddress = address + size;
|
||||
|
||||
if (_bufferOverlaps[0].Address > address || _bufferOverlaps[0].EndAddress < endAddress)
|
||||
{
|
||||
for (int index = 0; index < overlapsCount; index++)
|
||||
{
|
||||
Buffer buffer = _bufferOverlaps[index];
|
||||
|
||||
address = Math.Min(address, buffer.Address);
|
||||
endAddress = Math.Max(endAddress, buffer.EndAddress);
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
_buffers.Remove(buffer);
|
||||
}
|
||||
}
|
||||
|
||||
Buffer newBuffer = new Buffer(_context, address, endAddress - address, _bufferOverlaps.Take(overlapsCount));
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
_buffers.Add(newBuffer);
|
||||
}
|
||||
|
||||
for (int index = 0; index < overlapsCount; index++)
|
||||
{
|
||||
Buffer buffer = _bufferOverlaps[index];
|
||||
|
||||
int dstOffset = (int)(buffer.Address - newBuffer.Address);
|
||||
|
||||
buffer.CopyTo(newBuffer, dstOffset);
|
||||
newBuffer.InheritModifiedRanges(buffer);
|
||||
|
||||
buffer.DisposeData();
|
||||
}
|
||||
|
||||
newBuffer.SynchronizeMemory(address, endAddress - address);
|
||||
|
||||
// Existing buffers were modified, we need to rebind everything.
|
||||
_rebind = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// No overlap, just create a new buffer.
|
||||
Buffer buffer = new Buffer(_context, address, size);
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
_buffers.Add(buffer);
|
||||
}
|
||||
}
|
||||
|
||||
ShrinkOverlapsBufferIfNeeded();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Resizes the temporary buffer used for range list intersection results, if it has grown too much.
|
||||
/// </summary>
|
||||
private void ShrinkOverlapsBufferIfNeeded()
|
||||
{
|
||||
if (_bufferOverlaps.Length > OverlapsBufferMaxCapacity)
|
||||
{
|
||||
Array.Resize(ref _bufferOverlaps, OverlapsBufferMaxCapacity);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the address of the compute uniform buffer currently bound at the given index.
|
||||
|
|
@ -624,7 +422,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
{
|
||||
// The storage buffer size is not reliable (it might be lower than the actual size),
|
||||
// so we bind the entire buffer to allow otherwise out of range accesses to work.
|
||||
sRanges[bindingInfo.Binding] = GetBufferRangeTillEnd(
|
||||
sRanges[bindingInfo.Binding] = _context.Methods.BufferCache.GetBufferRangeTillEnd(
|
||||
bounds.Address,
|
||||
bounds.Size,
|
||||
bounds.Flags.HasFlag(BufferUsageFlags.Write));
|
||||
|
|
@ -645,7 +443,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
|
||||
if (bounds.Address != 0)
|
||||
{
|
||||
uRanges[bindingInfo.Binding] = GetBufferRange(bounds.Address, bounds.Size);
|
||||
uRanges[bindingInfo.Binding] = _context.Methods.BufferCache.GetBufferRange(bounds.Address, bounds.Size);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -654,7 +452,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
CommitBufferTextureBindings();
|
||||
|
||||
// Force rebind after doing compute work.
|
||||
_rebind = true;
|
||||
Rebind();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -666,7 +464,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
{
|
||||
foreach (var binding in _bufferTextures)
|
||||
{
|
||||
binding.Texture.SetStorage(GetBufferRange(binding.Address, binding.Size, binding.BindingInfo.Flags.HasFlag(TextureUsageFlags.ImageStore)));
|
||||
var isStore = binding.BindingInfo.Flags.HasFlag(TextureUsageFlags.ImageStore);
|
||||
var range = _context.Methods.BufferCache.GetBufferRange(binding.Address, binding.Size, isStore);
|
||||
binding.Texture.SetStorage(range);
|
||||
|
||||
// The texture must be rebound to use the new storage if it was updated.
|
||||
|
||||
|
|
@ -696,14 +496,14 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
|
||||
if (_indexBuffer.Address != 0)
|
||||
{
|
||||
BufferRange buffer = GetBufferRange(_indexBuffer.Address, _indexBuffer.Size);
|
||||
BufferRange buffer = _context.Methods.BufferCache.GetBufferRange(_indexBuffer.Address, _indexBuffer.Size);
|
||||
|
||||
_context.Renderer.Pipeline.SetIndexBuffer(buffer, _indexBuffer.Type);
|
||||
}
|
||||
}
|
||||
else if (_indexBuffer.Address != 0)
|
||||
{
|
||||
SynchronizeBufferRange(_indexBuffer.Address, _indexBuffer.Size);
|
||||
_context.Methods.BufferCache.SynchronizeBufferRange(_indexBuffer.Address, _indexBuffer.Size);
|
||||
}
|
||||
|
||||
uint vbEnableMask = _vertexBuffersEnableMask;
|
||||
|
|
@ -723,7 +523,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
continue;
|
||||
}
|
||||
|
||||
BufferRange buffer = GetBufferRange(vb.Address, vb.Size);
|
||||
BufferRange buffer = _context.Methods.BufferCache.GetBufferRange(vb.Address, vb.Size);
|
||||
|
||||
vertexBuffers[index] = new VertexBufferDescriptor(buffer, vb.Stride, vb.Divisor);
|
||||
}
|
||||
|
|
@ -741,7 +541,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
continue;
|
||||
}
|
||||
|
||||
SynchronizeBufferRange(vb.Address, vb.Size);
|
||||
_context.Methods.BufferCache.SynchronizeBufferRange(vb.Address, vb.Size);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -761,7 +561,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
continue;
|
||||
}
|
||||
|
||||
tfbs[index] = GetBufferRange(tfb.Address, tfb.Size);
|
||||
tfbs[index] = _context.Methods.BufferCache.GetBufferRange(tfb.Address, tfb.Size);
|
||||
}
|
||||
|
||||
_context.Renderer.Pipeline.SetTransformFeedbackBuffers(tfbs);
|
||||
|
|
@ -777,7 +577,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
continue;
|
||||
}
|
||||
|
||||
SynchronizeBufferRange(tfb.Address, tfb.Size);
|
||||
_context.Methods.BufferCache.SynchronizeBufferRange(tfb.Address, tfb.Size);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -831,9 +631,10 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
|
||||
if (bounds.Address != 0)
|
||||
{
|
||||
var isWrite = bounds.Flags.HasFlag(BufferUsageFlags.Write);
|
||||
ranges[bindingInfo.Binding] = isStorage
|
||||
? GetBufferRangeTillEnd(bounds.Address, bounds.Size, bounds.Flags.HasFlag(BufferUsageFlags.Write))
|
||||
: GetBufferRange(bounds.Address, bounds.Size, bounds.Flags.HasFlag(BufferUsageFlags.Write));
|
||||
? _context.Methods.BufferCache.GetBufferRangeTillEnd(bounds.Address, bounds.Size, isWrite)
|
||||
: _context.Methods.BufferCache.GetBufferRange(bounds.Address, bounds.Size, isWrite);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -869,7 +670,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
continue;
|
||||
}
|
||||
|
||||
SynchronizeBufferRange(bounds.Address, bounds.Size);
|
||||
_context.Methods.BufferCache.SynchronizeBufferRange(bounds.Address, bounds.Size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -885,167 +686,26 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
|||
/// <param name="isImage">Whether the binding is for an image or a sampler</param>
|
||||
public void SetBufferTextureStorage(ITexture texture, ulong address, ulong size, TextureBindingInfo bindingInfo, Format format, bool isImage)
|
||||
{
|
||||
CreateBuffer(address, size);
|
||||
_context.Methods.BufferCache.CreateBuffer(address, size);
|
||||
|
||||
_bufferTextures.Add(new BufferTextureBinding(texture, address, size, bindingInfo, format, isImage));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Copy a buffer data from a given address to another.
|
||||
/// Force all bound textures and images to be rebound the next time CommitBindings is called.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// This does a GPU side copy.
|
||||
/// </remarks>
|
||||
/// <param name="srcVa">GPU virtual address of the copy source</param>
|
||||
/// <param name="dstVa">GPU virtual address of the copy destination</param>
|
||||
/// <param name="size">Size in bytes of the copy</param>
|
||||
public void CopyBuffer(GpuVa srcVa, GpuVa dstVa, ulong size)
|
||||
public void Rebind()
|
||||
{
|
||||
ulong srcAddress = TranslateAndCreateBuffer(srcVa.Pack(), size);
|
||||
ulong dstAddress = TranslateAndCreateBuffer(dstVa.Pack(), size);
|
||||
|
||||
Buffer srcBuffer = GetBuffer(srcAddress, size);
|
||||
Buffer dstBuffer = GetBuffer(dstAddress, size);
|
||||
|
||||
int srcOffset = (int)(srcAddress - srcBuffer.Address);
|
||||
int dstOffset = (int)(dstAddress - dstBuffer.Address);
|
||||
|
||||
_context.Renderer.Pipeline.CopyBuffer(
|
||||
srcBuffer.Handle,
|
||||
dstBuffer.Handle,
|
||||
srcOffset,
|
||||
dstOffset,
|
||||
(int)size);
|
||||
|
||||
if (srcBuffer.IsModified(srcAddress, size))
|
||||
{
|
||||
dstBuffer.SignalModified(dstAddress, size);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Optimization: If the data being copied is already in memory, then copy it directly instead of flushing from GPU.
|
||||
|
||||
dstBuffer.ClearModified(dstAddress, size);
|
||||
_context.PhysicalMemory.WriteUntracked(dstAddress, _context.PhysicalMemory.GetSpan(srcAddress, (int)size));
|
||||
}
|
||||
_rebind = true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Clears a buffer at a given address with the specified value.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Both the address and size must be aligned to 4 bytes.
|
||||
/// </remarks>
|
||||
/// <param name="gpuVa">GPU virtual address of the region to clear</param>
|
||||
/// <param name="size">Number of bytes to clear</param>
|
||||
/// <param name="value">Value to be written into the buffer</param>
|
||||
public void ClearBuffer(GpuVa gpuVa, ulong size, uint value)
|
||||
{
|
||||
ulong address = TranslateAndCreateBuffer(gpuVa.Pack(), size);
|
||||
|
||||
Buffer buffer = GetBuffer(address, size);
|
||||
|
||||
int offset = (int)(address - buffer.Address);
|
||||
|
||||
_context.Renderer.Pipeline.ClearBuffer(buffer.Handle, offset, (int)size, value);
|
||||
|
||||
buffer.SignalModified(address, size);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets a buffer sub-range starting at a given memory address.
|
||||
/// </summary>
|
||||
/// <param name="address">Start address of the memory range</param>
|
||||
/// <param name="size">Size in bytes of the memory range</param>
|
||||
/// <param name="write">Whether the buffer will be written to by this use</param>
|
||||
/// <returns>The buffer sub-range starting at the given memory address</returns>
|
||||
private BufferRange GetBufferRangeTillEnd(ulong address, ulong size, bool write = false)
|
||||
{
|
||||
return GetBuffer(address, size, write).GetRange(address);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets a buffer sub-range for a given memory range.
|
||||
/// </summary>
|
||||
/// <param name="address">Start address of the memory range</param>
|
||||
/// <param name="size">Size in bytes of the memory range</param>
|
||||
/// <param name="write">Whether the buffer will be written to by this use</param>
|
||||
/// <returns>The buffer sub-range for the given range</returns>
|
||||
private BufferRange GetBufferRange(ulong address, ulong size, bool write = false)
|
||||
{
|
||||
return GetBuffer(address, size, write).GetRange(address, size);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets a buffer for a given memory range.
|
||||
/// A buffer overlapping with the specified range is assumed to already exist on the cache.
|
||||
/// </summary>
|
||||
/// <param name="address">Start address of the memory range</param>
|
||||
/// <param name="size">Size in bytes of the memory range</param>
|
||||
/// <param name="write">Whether the buffer will be written to by this use</param>
|
||||
/// <returns>The buffer where the range is fully contained</returns>
|
||||
private Buffer GetBuffer(ulong address, ulong size, bool write = false)
|
||||
{
|
||||
Buffer buffer;
|
||||
|
||||
if (size != 0)
|
||||
{
|
||||
lock (_buffers)
|
||||
{
|
||||
buffer = _buffers.FindFirstOverlap(address, size);
|
||||
}
|
||||
|
||||
buffer.SynchronizeMemory(address, size);
|
||||
|
||||
if (write)
|
||||
{
|
||||
buffer.SignalModified(address, size);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
lock (_buffers)
|
||||
{
|
||||
buffer = _buffers.FindFirstOverlap(address, 1);
|
||||
}
|
||||
}
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Performs guest to host memory synchronization of a given memory range.
|
||||
/// </summary>
|
||||
/// <param name="address">Start address of the memory range</param>
|
||||
/// <param name="size">Size in bytes of the memory range</param>
|
||||
private void SynchronizeBufferRange(ulong address, ulong size)
|
||||
{
|
||||
if (size != 0)
|
||||
{
|
||||
Buffer buffer;
|
||||
|
||||
lock (_buffers)
|
||||
{
|
||||
buffer = _buffers.FindFirstOverlap(address, size);
|
||||
}
|
||||
|
||||
buffer.SynchronizeMemory(address, size);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Disposes all buffers in the cache.
|
||||
/// It's an error to use the buffer manager after disposal.
|
||||
/// Disposes the buffer manager.
|
||||
/// It is an error to use the buffer manager after disposal.
|
||||
/// </summary>
|
||||
public void Dispose()
|
||||
{
|
||||
lock (_buffers)
|
||||
{
|
||||
foreach (Buffer buffer in _buffers)
|
||||
{
|
||||
buffer.Dispose();
|
||||
}
|
||||
}
|
||||
_context.Methods.BufferCache.NotifyBuffersModified -= Rebind;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -129,8 +129,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
public uint QueryConstantBufferUse()
|
||||
{
|
||||
return _compute
|
||||
? _context.Methods.BufferManager.GetComputeUniformBufferUseMask()
|
||||
: _context.Methods.BufferManager.GetGraphicsUniformBufferUseMask(_stageIndex);
|
||||
? _state.Channel.BufferManager.GetComputeUniformBufferUseMask()
|
||||
: _state.Channel.BufferManager.GetGraphicsUniformBufferUseMask(_stageIndex);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -190,11 +190,11 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
{
|
||||
if (_compute)
|
||||
{
|
||||
return _context.Methods.TextureManager.GetComputeTextureDescriptor(_state, handle, cbufSlot);
|
||||
return _state.Channel.TextureManager.GetComputeTextureDescriptor(_state, handle, cbufSlot);
|
||||
}
|
||||
else
|
||||
{
|
||||
return _context.Methods.TextureManager.GetGraphicsTextureDescriptor(_state, _stageIndex, handle, cbufSlot);
|
||||
return _state.Channel.TextureManager.GetGraphicsTextureDescriptor(_state, _stageIndex, handle, cbufSlot);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
using System;
|
||||
using Ryujinx.Graphics.Gpu.Image;
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.State
|
||||
|
|
@ -37,11 +38,19 @@ namespace Ryujinx.Graphics.Gpu.State
|
|||
/// </summary>
|
||||
public ShadowRamControl ShadowRamControl { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// GPU channel for the sub-channel state.
|
||||
/// </summary>
|
||||
public GpuChannel Channel { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of the GPU state.
|
||||
/// </summary>
|
||||
public GpuState()
|
||||
/// <param name="channel">Channel that the sub-channel state belongs to</param>
|
||||
public GpuState(GpuChannel channel)
|
||||
{
|
||||
Channel = channel;
|
||||
|
||||
_memory = new int[RegistersCount];
|
||||
_shadow = new int[RegistersCount];
|
||||
|
||||
|
|
@ -221,6 +230,21 @@ namespace Ryujinx.Graphics.Gpu.State
|
|||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Forces a full host state update by marking all state as modified,
|
||||
/// and also requests all GPU resources in use to be rebound.
|
||||
/// </summary>
|
||||
public void ForceAllDirty()
|
||||
{
|
||||
for (int index = 0; index < _registers.Length; index++)
|
||||
{
|
||||
_registers[index].Modified = true;
|
||||
}
|
||||
|
||||
Channel.BufferManager.Rebind();
|
||||
Channel.TextureManager.Rebind();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Checks if a given register has been modified since the last call to this method.
|
||||
/// </summary>
|
||||
|
|
|
|||
|
|
@ -174,7 +174,7 @@ namespace Ryujinx.Graphics.Gpu
|
|||
{
|
||||
pt.AcquireCallback(_context, pt.UserObj);
|
||||
|
||||
Texture texture = _context.Methods.TextureManager.FindOrCreateTexture(TextureSearchFlags.WithUpscale, pt.Info, 0, null, pt.Range);
|
||||
Texture texture = _context.Methods.TextureCache.FindOrCreateTexture(TextureSearchFlags.WithUpscale, pt.Info, 0, null, pt.Range);
|
||||
|
||||
texture.SynchronizeMemory();
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
using Ryujinx.Common.Collections;
|
||||
using Ryujinx.Common.Logging;
|
||||
using Ryujinx.Common.Logging;
|
||||
using Ryujinx.Graphics.Gpu;
|
||||
using Ryujinx.Graphics.Gpu.Memory;
|
||||
using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostAsGpu;
|
||||
using Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel.Types;
|
||||
|
|
@ -24,7 +24,8 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel
|
|||
private readonly Switch _device;
|
||||
|
||||
private readonly IVirtualMemoryManager _memory;
|
||||
private NvMemoryAllocator _memoryAllocator;
|
||||
private readonly NvMemoryAllocator _memoryAllocator;
|
||||
private readonly GpuChannel _channel;
|
||||
|
||||
public enum ResourcePolicy
|
||||
{
|
||||
|
|
@ -42,12 +43,13 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel
|
|||
|
||||
public NvHostChannelDeviceFile(ServiceCtx context, IVirtualMemoryManager memory, long owner) : base(context, owner)
|
||||
{
|
||||
_device = context.Device;
|
||||
_memory = memory;
|
||||
_timeout = 3000;
|
||||
_submitTimeout = 0;
|
||||
_timeslice = 0;
|
||||
_device = context.Device;
|
||||
_memory = memory;
|
||||
_timeout = 3000;
|
||||
_submitTimeout = 0;
|
||||
_timeslice = 0;
|
||||
_memoryAllocator = _device.MemoryAllocator;
|
||||
_channel = _device.Gpu.CreateChannel();
|
||||
|
||||
ChannelSyncpoints = new uint[MaxModuleSyncpoint];
|
||||
|
||||
|
|
@ -429,10 +431,10 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel
|
|||
|
||||
if (header.Flags.HasFlag(SubmitGpfifoFlags.FenceWait) && !_device.System.HostSyncpoint.IsSyncpointExpired(header.Fence.Id, header.Fence.Value))
|
||||
{
|
||||
_device.Gpu.GPFifo.PushHostCommandBuffer(CreateWaitCommandBuffer(header.Fence));
|
||||
_channel.PushHostCommandBuffer(CreateWaitCommandBuffer(header.Fence));
|
||||
}
|
||||
|
||||
_device.Gpu.GPFifo.PushEntries(entries);
|
||||
_channel.PushEntries(entries);
|
||||
|
||||
header.Fence.Id = _channelSyncpoint.Id;
|
||||
|
||||
|
|
@ -454,7 +456,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel
|
|||
|
||||
if (header.Flags.HasFlag(SubmitGpfifoFlags.FenceIncrement))
|
||||
{
|
||||
_device.Gpu.GPFifo.PushHostCommandBuffer(CreateIncrementCommandBuffer(ref header.Fence, header.Flags));
|
||||
_channel.PushHostCommandBuffer(CreateIncrementCommandBuffer(ref header.Fence, header.Flags));
|
||||
}
|
||||
|
||||
header.Flags = SubmitGpfifoFlags.None;
|
||||
|
|
@ -541,6 +543,9 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostChannel
|
|||
return commandBuffer;
|
||||
}
|
||||
|
||||
public override void Close() { }
|
||||
public override void Close()
|
||||
{
|
||||
_channel.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue