mchapman/Ryujinx-greemdev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert the Metal Experiment (#701)

Browse Source 
Metal sounded like a good idea to get in the emulator but frankly I
underestimated just how experimental and not ready it was.
From my write up in the Discord:
```
As is, Metal supports only a few games.
The games it does support freeze on first use of not playing them via Vulkan, because shader translation is broken.
So you need to use a dirty hack to not delete all your shaders.
Not to mention it breaks many games via MoltenVK because of changes to the shared GPU code.

Merging Metal seemed like a great idea, because of the few games it does support.
But I don't think it's worth it. Many of the games it breaks via MoltenVK *don't work via Metal*. 
Which effectively makes current Ryubing worse for Mac users than Ryujinx 1.1.1403.

I think what I'm gonna do is revert Metal, and reopen it as a PR. That way, you can still take advantage of the Metal backend as is, but without making other games worse with no solution.
```

For what it's worth, the shader translation part could at least be
"fixed" by always applying a 30ms delay for shader translation to Metal.
That being said, that solution sucks ass.
The MoltenVK regressions are even worse.



I hope this is not a let down to the Mac users. I hope you realize I'm
reverting this because you're actively getting a worse experience with
it in the emulator.
This commit is contained in:
Evan Husted
2025-02-22 21:26:46 -06:00
committed by GitHub
parent eb6b0e9adc
commit fe1617ffea
135 changed files with 302 additions and 15077 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
src/Ryujinx.Graphics.Metal/SyncManager.cs
View File

@@ -1,214 +0,0 @@
using Ryujinx.Common.Logging;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.Versioning;
namespace Ryujinx.Graphics.Metal
{
[SupportedOSPlatform("macos")]
class SyncManager
{
private class SyncHandle
{
public ulong ID;
public MultiFenceHolder Waitable;
public ulong FlushId;
public bool Signalled;
public bool NeedsFlush(ulong currentFlushId)
{
return (long)(FlushId - currentFlushId) >= 0;
}
}
private ulong _firstHandle;
private readonly MetalRenderer _renderer;
private readonly List<SyncHandle> _handles;
private ulong _flushId;
private long _waitTicks;
public SyncManager(MetalRenderer renderer)
{
_renderer = renderer;
_handles = [];
}
public void RegisterFlush()
{
_flushId++;
}
public void Create(ulong id, bool strict)
{
ulong flushId = _flushId;
MultiFenceHolder waitable = new();
if (strict || _renderer.InterruptAction == null)
{
_renderer.FlushAllCommands();
_renderer.CommandBufferPool.AddWaitable(waitable);
}
else
{
// Don't flush commands, instead wait for the current command buffer to finish.
// If this sync is waited on before the command buffer is submitted, interrupt the gpu thread and flush it manually.
_renderer.CommandBufferPool.AddInUseWaitable(waitable);
}
SyncHandle handle = new()
{
ID = id,
Waitable = waitable,
FlushId = flushId,
};
lock (_handles)
{
_handles.Add(handle);
}
}
public ulong GetCurrent()
{
lock (_handles)
{
ulong lastHandle = _firstHandle;
foreach (SyncHandle handle in _handles)
{
lock (handle)
{
if (handle.Waitable == null)
{
continue;
}
if (handle.ID > lastHandle)
{
bool signaled = handle.Signalled || handle.Waitable.WaitForFences(false);
if (signaled)
{
lastHandle = handle.ID;
handle.Signalled = true;
}
}
}
}
return lastHandle;
}
}
public void Wait(ulong id)
{
SyncHandle result = null;
lock (_handles)
{
if ((long)(_firstHandle - id) > 0)
{
return; // The handle has already been signalled or deleted.
}
foreach (SyncHandle handle in _handles)
{
if (handle.ID == id)
{
result = handle;
break;
}
}
}
if (result != null)
{
if (result.Waitable == null)
{
return;
}
long beforeTicks = Stopwatch.GetTimestamp();
if (result.NeedsFlush(_flushId))
{
_renderer.InterruptAction(() =>
{
if (result.NeedsFlush(_flushId))
{
_renderer.FlushAllCommands();
}
});
}
lock (result)
{
if (result.Waitable == null)
{
return;
}
bool signaled = result.Signalled || result.Waitable.WaitForFences(true);
if (!signaled)
{
Logger.Error?.PrintMsg(LogClass.Gpu, $"Metal Sync Object {result.ID} failed to signal within 1000ms. Continuing...");
}
else
{
_waitTicks += Stopwatch.GetTimestamp() - beforeTicks;
result.Signalled = true;
}
}
}
}
public void Cleanup()
{
// Iterate through handles and remove any that have already been signalled.
while (true)
{
SyncHandle first = null;
lock (_handles)
{
first = _handles.FirstOrDefault();
}
if (first == null || first.NeedsFlush(_flushId))
{
break;
}
bool signaled = first.Waitable.WaitForFences(false);
if (signaled)
{
// Delete the sync object.
lock (_handles)
{
lock (first)
{
_firstHandle = first.ID + 1;
_handles.RemoveAt(0);
first.Waitable = null;
}
}
}
else
{
// This sync handle and any following have not been reached yet.
break;
}
}
}
public long GetAndResetWaitTicks()
{
long result = _waitTicks;
_waitTicks = 0;
return result;
}
}
}