Cool_Tools/ryujinx
1
0
Fork 0
mirror of https://github.com/ryujinx-mirror/ryujinx.git synced 2024-11-28 01:50:50 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix inconsistencies in progress reporting (#2129)

Browse Source 
Signal and setup events correctly
Eliminate possible races
Use a single event
Mark volatiles and reduce scope of waithandles
Common handler
100ms -> 50ms
This commit is contained in:
mageven 2021-03-23 00:10:07 +05:30 committed by GitHub
parent 0b022cad1e
commit 69f8722e79
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 128 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
ARMeilleure/Translation/PTC/Ptc.cs
View File

@ -52,14 +52,10 @@ namespace ARMeilleure.Translation.PTC
private static readonly ManualResetEvent _waitEvent;
private static readonly AutoResetEvent _loggerEvent;
private static readonly object _lock;
private static bool _disposed;
private static volatile int _translateCount;
internal static PtcJumpTable PtcJumpTable { get; private set; }
internal static string TitleIdText { get; private set; }
@ -70,9 +66,10 @@ namespace ARMeilleure.Translation.PTC
internal static PtcState State { get; private set; }
// Progress update events
public static event Action<bool> PtcTranslationStateChanged;
public static event Action<int, int> PtcTranslationProgressChanged;
// Progress reporting helpers
private static volatile int _translateCount;
private static volatile int _translateTotalCount;
public static event Action<PtcLoadingState, int, int> PtcStateChanged;
static Ptc()
{
@ -82,8 +79,6 @@ namespace ARMeilleure.Translation.PTC
_waitEvent = new ManualResetEvent(true);
_loggerEvent = new AutoResetEvent(false);
_lock = new object();
_disposed = false;
@ -773,10 +768,20 @@ namespace ARMeilleure.Translation.PTC
}
_translateCount = 0;
_translateTotalCount = profiledFuncsToTranslate.Count;
ThreadPool.QueueUserWorkItem(TranslationLogger, profiledFuncsToTranslate.Count);
PtcStateChanged?.Invoke(PtcLoadingState.Start, _translateCount, _translateTotalCount);
PtcTranslationStateChanged?.Invoke(true);
using AutoResetEvent progressReportEvent = new AutoResetEvent(false);
Thread progressReportThread = new Thread(ReportProgress)
{
Name = "Ptc.ProgressReporter",
Priority = ThreadPriority.Lowest,
IsBackground = true
};
progressReportThread.Start(progressReportEvent);
void TranslateFuncs()
{
@ -825,8 +830,12 @@ namespace ARMeilleure.Translation.PTC
threads.Clear();
_loggerEvent.Set();
PtcTranslationStateChanged?.Invoke(false);
progressReportEvent.Set();
progressReportThread.Join();
PtcStateChanged?.Invoke(PtcLoadingState.Loaded, _translateCount, _translateTotalCount);
Logger.Info?.Print(LogClass.Ptc, $"{_translateCount} of {_translateTotalCount} functions translated");
PtcJumpTable.Initialize(jumpTable);
@ -838,19 +847,25 @@ namespace ARMeilleure.Translation.PTC
preSaveThread.Start();
}
private static void TranslationLogger(object state)
private static void ReportProgress(object state)
{
const int refreshRate = 100; // ms
const int refreshRate = 50; // ms
int profiledFuncsToTranslateCount = (int)state;
AutoResetEvent endEvent = (AutoResetEvent)state;
int count = 0;
do
{
PtcTranslationProgressChanged?.Invoke(_translateCount, profiledFuncsToTranslateCount);
}
while (!_loggerEvent.WaitOne(refreshRate));
int newCount = _translateCount;
Logger.Info?.Print(LogClass.Ptc, $"{_translateCount} of {profiledFuncsToTranslateCount} functions translated");
if (count != newCount)
{
PtcStateChanged?.Invoke(PtcLoadingState.Loading, newCount, _translateTotalCount);
count = newCount;
}
}
while (!endEvent.WaitOne(refreshRate));
}
internal static void WriteInfoCodeRelocUnwindInfo(ulong address, ulong guestSize, bool highCq, PtcInfo ptcInfo)
@ -968,8 +983,6 @@ namespace ARMeilleure.Translation.PTC
Wait();
_waitEvent.Dispose();
_loggerEvent.Dispose();
DisposeMemoryStreams();
}
}

9
ARMeilleure/Translation/PTC/PtcLoadingState.cs Normal file
View File

@ -0,0 +1,9 @@
namespace ARMeilleure.Translation.PTC
{
public enum PtcLoadingState
{
Start,
Loading,
Loaded
}
}

15
Ryujinx.Graphics.Gpu/GpuContext.cs
View File

@ -80,25 +80,14 @@ namespace Ryujinx.Graphics.Gpu
internal Capabilities Capabilities => _caps.Value;
/// <summary>
/// Signaled when shader cache begins and ends loading.
/// Signals true when loading has started, false when ended.
/// Event for signalling shader cache loading progress.
/// </summary>
public event Action<bool> ShaderCacheStateChanged
public event Action<Shader.ShaderCacheState, int, int> ShaderCacheStateChanged
{
add => Methods.ShaderCache.ShaderCacheStateChanged += value;
remove => Methods.ShaderCache.ShaderCacheStateChanged -= value;
}
/// <summary>
/// Signaled while shader cache is loading to indicate current progress.
/// Provides current and total number of shaders loaded.
/// </summary>
public event Action<int, int> ShaderCacheProgressChanged
{
add => Methods.ShaderCache.ShaderCacheProgressChanged += value;
remove => Methods.ShaderCache.ShaderCacheProgressChanged -= value;
}
/// <summary>
/// Creates a new instance of the GPU emulation context.
/// </summary>

61
Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs
View File

@ -38,10 +38,9 @@ namespace Ryujinx.Graphics.Gpu.Shader
private const ulong ShaderCodeGenVersion = 2088;
// Progress reporting helpers
private int _shaderCount;
private readonly AutoResetEvent _progressReportEvent;
public event Action<bool> ShaderCacheStateChanged;
public event Action<int, int> ShaderCacheProgressChanged;
private volatile int _shaderCount;
private volatile int _totalShaderCount;
public event Action<ShaderCacheState, int, int> ShaderCacheStateChanged;
/// <summary>
/// Creates a new instance of the shader cache.
@ -57,8 +56,6 @@ namespace Ryujinx.Graphics.Gpu.Shader
_gpPrograms = new Dictionary<ShaderAddresses, List<ShaderBundle>>();
_gpProgramsDiskCache = new Dictionary<Hash128, ShaderBundle>();
_cpProgramsDiskCache = new Dictionary<Hash128, ShaderBundle>();
_progressReportEvent = new AutoResetEvent(false);
}
/// <summary>
@ -85,11 +82,25 @@ namespace Ryujinx.Graphics.Gpu.Shader
ReadOnlySpan<Hash128> guestProgramList = _cacheManager.GetGuestProgramList();
_progressReportEvent.Reset();
_shaderCount = 0;
using AutoResetEvent progressReportEvent = new AutoResetEvent(false);
ShaderCacheStateChanged?.Invoke(true);
ThreadPool.QueueUserWorkItem(ProgressLogger, guestProgramList.Length);
_shaderCount = 0;
_totalShaderCount = guestProgramList.Length;
ShaderCacheStateChanged?.Invoke(ShaderCacheState.Start, _shaderCount, _totalShaderCount);
Thread progressReportThread = null;
if (guestProgramList.Length > 0)
{
progressReportThread = new Thread(ReportProgress)
{
Name = "ShaderCache.ProgressReporter",
Priority = ThreadPriority.Lowest,
IsBackground = true
};
progressReportThread.Start(progressReportEvent);
}
for (int programIndex = 0; programIndex < guestProgramList.Length; programIndex++)
{
@ -318,7 +329,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
_gpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shaders));
}
_shaderCount = programIndex;
_shaderCount = programIndex + 1;
}
if (!isReadOnly)
@ -329,26 +340,37 @@ namespace Ryujinx.Graphics.Gpu.Shader
_cacheManager.Synchronize();
}
_progressReportEvent.Set();
ShaderCacheStateChanged?.Invoke(false);
progressReportEvent.Set();
progressReportThread?.Join();
ShaderCacheStateChanged?.Invoke(ShaderCacheState.Loaded, _shaderCount, _totalShaderCount);
Logger.Info?.Print(LogClass.Gpu, $"Shader cache loaded {_shaderCount} entries.");
}
}
/// <summary>
/// Raises ShaderCacheProgressChanged events periodically.
/// Raises ShaderCacheStateChanged events periodically.
/// </summary>
private void ProgressLogger(object state)
private void ReportProgress(object state)
{
const int refreshRate = 100; // ms
const int refreshRate = 50; // ms
AutoResetEvent endEvent = (AutoResetEvent)state;
int count = 0;
int totalCount = (int)state;
do
{
ShaderCacheProgressChanged?.Invoke(_shaderCount, totalCount);
int newCount = _shaderCount;
if (count != newCount)
{
ShaderCacheStateChanged?.Invoke(ShaderCacheState.Loading, newCount, _totalShaderCount);
count = newCount;
}
while (!_progressReportEvent.WaitOne(refreshRate));
}
while (!endEvent.WaitOne(refreshRate));
}
/// <summary>
@ -833,7 +855,6 @@ namespace Ryujinx.Graphics.Gpu.Shader
}
}
_progressReportEvent?.Dispose();
_cacheManager?.Dispose();
}
}

13
Ryujinx.Graphics.Gpu/Shader/ShaderCacheState.cs Normal file
View File

@ -0,0 +1,13 @@
namespace Ryujinx.Graphics.Gpu.Shader
{
/// <summary>Shader cache loading states</summary>
public enum ShaderCacheState
{
/// <summary>Shader cache started loading</summary>
Start,
/// <summary>Shader cache is loading</summary>
Loading,
/// <summary>Shader cache finished loading</summary>
Loaded
}
}

60
Ryujinx/Ui/MainWindow.cs
View File

@ -33,6 +33,9 @@ using System.Threading.Tasks;
using GUI = Gtk.Builder.ObjectAttribute;
using PtcLoadingState = ARMeilleure.Translation.PTC.PtcLoadingState;
using ShaderCacheLoadingState = Ryujinx.Graphics.Gpu.Shader.ShaderCacheState;
namespace Ryujinx.Ui
{
public class MainWindow : Window
@ -105,8 +108,6 @@ namespace Ryujinx.Ui
[GUI] Label _loadingStatusLabel;
[GUI] ProgressBar _loadingStatusBar;
private string _loadingStatusTitle = "";
#pragma warning restore CS0649, IDE0044, CS0169
public MainWindow() : this(new Builder("Ryujinx.Ui.MainWindow.glade")) { }
@ -346,43 +347,38 @@ namespace Ryujinx.Ui
private void SetupProgressUiHandlers()
{
Ptc.PtcTranslationStateChanged -= PtcStatusChanged;
Ptc.PtcTranslationStateChanged += PtcStatusChanged;
Ptc.PtcStateChanged -= ProgressHandler;
Ptc.PtcStateChanged += ProgressHandler;
Ptc.PtcTranslationProgressChanged -= LoadingProgressChanged;
Ptc.PtcTranslationProgressChanged += LoadingProgressChanged;
_emulationContext.Gpu.ShaderCacheStateChanged -= ShaderCacheStatusChanged;
_emulationContext.Gpu.ShaderCacheStateChanged += ShaderCacheStatusChanged;
_emulationContext.Gpu.ShaderCacheProgressChanged -= LoadingProgressChanged;
_emulationContext.Gpu.ShaderCacheProgressChanged += LoadingProgressChanged;
_emulationContext.Gpu.ShaderCacheStateChanged -= ProgressHandler;
_emulationContext.Gpu.ShaderCacheStateChanged += ProgressHandler;
}
private void ShaderCacheStatusChanged(bool state)
private void ProgressHandler<T>(T state, int current, int total) where T : Enum
{
_loadingStatusTitle = "Shaders";
Application.Invoke(delegate
bool visible;
string label;
switch (state)
{
_loadingStatusBar.Visible = _loadingStatusLabel.Visible = state;
});
case PtcLoadingState ptcState:
visible = ptcState != PtcLoadingState.Loaded;
label = $"PTC : {current}/{total}";
break;
case ShaderCacheLoadingState shaderCacheState:
visible = shaderCacheState != ShaderCacheLoadingState.Loaded;
label = $"Shaders : {current}/{total}";
break;
default:
throw new ArgumentException($"Unknown Progress Handler type {typeof(T)}");
}
private void PtcStatusChanged(bool state)
{
_loadingStatusTitle = "PTC";
Application.Invoke(delegate
{
_loadingStatusBar.Visible = _loadingStatusLabel.Visible = state;
});
}
private void LoadingProgressChanged(int value, int total)
{
Application.Invoke(delegate
{
_loadingStatusBar.Fraction = (double)value / total;
_loadingStatusLabel.Text = $"{_loadingStatusTitle} : {value}/{total}";
_loadingStatusLabel.Text = label;
_loadingStatusBar.Fraction = total > 0 ? (double)current / total : 0;
_loadingStatusBar.Visible = visible;
_loadingStatusLabel.Visible = visible;
});
}
@ -464,6 +460,8 @@ namespace Ryujinx.Ui
UpdateGraphicsConfig();
SetupProgressUiHandlers();
SystemVersion firmwareVersion = _contentManager.GetCurrentFirmwareVersion();
bool isDirectory = Directory.Exists(path);
@ -584,8 +582,6 @@ namespace Ryujinx.Ui
_deviceExitStatus.Reset();
SetupProgressUiHandlers();
Translator.IsReadyForTranslation.Reset();
#if MACOS_BUILD
CreateGameWindow();