eb528ae0f0
* Add workflow to perform automated checks for PRs * Downgrade Microsoft.CodeAnalysis to 4.4.0 This is a workaround to fix issues with dotnet-format. See: - https://github.com/dotnet/format/issues/1805 - https://github.com/dotnet/format/issues/1800 * Adjust editorconfig to be more compatible with Ryujinx code-style * Adjust .editorconfig line endings to match .gitattributes * Disable 'prefer switch expression' rule * Remove naming styles These are the default rules, so we don't need to override them. * Silence IDE0060 in .editorconfig * Slightly adjust .editorconfig * Add lost workflow changes * Move .editorconfig comment to the top * .editorconfig: private static readonly fields should be _lowerCamelCase * .editorconfig: Remove alignment for declarations as well * editorconfig: Add rule for local constants * Disable CA1822 for HLE services * Disable CA1822 for ViewModels Bindings won't work with static members, but this issue is silently ignored. * Run dotnet format for the whole solution * Check result code of SDL_GetDisplayBounds * Fix dotnet format style issues * Add missing trailing commas * Update Microsoft.CodeAnalysis.CSharp to 4.6.0 Skipping 4.5.0 since it breaks dotnet format * Restore old default naming rules for dotnet format * Add naming rule exception for CPU tests * checks: Include all files before excluding paths * Fix dotnet format issues * Check dotnet format version * checks: Run dotnet format with severity info again * checks: Disable naming style rules until they won't crash the process anymore * Remove unread private member * checks: Attempt to run analyzers 3 times before giving up * checks: Enable naming style rules again with the new retry logic
172 lines
4.8 KiB
C#
172 lines
4.8 KiB
C#
using OpenTK.Graphics.OpenGL;
|
|
using Ryujinx.Common.Logging;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace Ryujinx.Graphics.OpenGL
|
|
{
|
|
class Sync : IDisposable
|
|
{
|
|
private class SyncHandle
|
|
{
|
|
public ulong ID;
|
|
public IntPtr Handle;
|
|
}
|
|
|
|
private ulong _firstHandle = 0;
|
|
private static ClientWaitSyncFlags SyncFlags => HwCapabilities.RequiresSyncFlush ? ClientWaitSyncFlags.None : ClientWaitSyncFlags.SyncFlushCommandsBit;
|
|
|
|
private readonly List<SyncHandle> _handles = new();
|
|
|
|
public void Create(ulong id)
|
|
{
|
|
SyncHandle handle = new()
|
|
{
|
|
ID = id,
|
|
Handle = GL.FenceSync(SyncCondition.SyncGpuCommandsComplete, WaitSyncFlags.None),
|
|
};
|
|
|
|
|
|
if (HwCapabilities.RequiresSyncFlush)
|
|
{
|
|
// Force commands to flush up to the syncpoint.
|
|
GL.ClientWaitSync(handle.Handle, ClientWaitSyncFlags.SyncFlushCommandsBit, 0);
|
|
}
|
|
|
|
lock (_handles)
|
|
{
|
|
_handles.Add(handle);
|
|
}
|
|
}
|
|
|
|
public ulong GetCurrent()
|
|
{
|
|
lock (_handles)
|
|
{
|
|
ulong lastHandle = _firstHandle;
|
|
|
|
foreach (SyncHandle handle in _handles)
|
|
{
|
|
lock (handle)
|
|
{
|
|
if (handle.Handle == IntPtr.Zero)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (handle.ID > lastHandle)
|
|
{
|
|
WaitSyncStatus syncResult = GL.ClientWaitSync(handle.Handle, SyncFlags, 0);
|
|
|
|
if (syncResult == WaitSyncStatus.AlreadySignaled)
|
|
{
|
|
lastHandle = handle.ID;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
lock (result)
|
|
{
|
|
if (result.Handle == IntPtr.Zero)
|
|
{
|
|
return;
|
|
}
|
|
|
|
WaitSyncStatus syncResult = GL.ClientWaitSync(result.Handle, SyncFlags, 1000000000);
|
|
|
|
if (syncResult == WaitSyncStatus.TimeoutExpired)
|
|
{
|
|
Logger.Error?.PrintMsg(LogClass.Gpu, $"GL Sync Object {result.ID} failed to signal within 1000ms. Continuing...");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
break;
|
|
}
|
|
|
|
WaitSyncStatus syncResult = GL.ClientWaitSync(first.Handle, SyncFlags, 0);
|
|
|
|
if (syncResult == WaitSyncStatus.AlreadySignaled)
|
|
{
|
|
// Delete the sync object.
|
|
lock (_handles)
|
|
{
|
|
lock (first)
|
|
{
|
|
_firstHandle = first.ID + 1;
|
|
_handles.RemoveAt(0);
|
|
GL.DeleteSync(first.Handle);
|
|
first.Handle = IntPtr.Zero;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This sync handle and any following have not been reached yet.
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
lock (_handles)
|
|
{
|
|
foreach (SyncHandle handle in _handles)
|
|
{
|
|
lock (handle)
|
|
{
|
|
GL.DeleteSync(handle.Handle);
|
|
handle.Handle = IntPtr.Zero;
|
|
}
|
|
}
|
|
|
|
_handles.Clear();
|
|
}
|
|
}
|
|
}
|
|
}
|