From ee0b14ba0811a76a306c1546be90de128a17f5cc Mon Sep 17 00:00:00 2001 From: gdkchan Date: Mon, 14 May 2018 03:01:10 -0300 Subject: [PATCH] Some improvements to SetThreadCoreMask, simplified implementation of wait lists --- .../OsHle/Handles/KProcessScheduler.cs | 78 +++--- Ryujinx.Core/OsHle/Handles/KThread.cs | 150 +---------- Ryujinx.Core/OsHle/Kernel/SvcThread.cs | 48 ++-- Ryujinx.Core/OsHle/Kernel/SvcThreadSync.cs | 240 ++++++++---------- Ryujinx.Core/OsHle/Process.cs | 8 +- 5 files changed, 199 insertions(+), 325 deletions(-) diff --git a/Ryujinx.Core/OsHle/Handles/KProcessScheduler.cs b/Ryujinx.Core/OsHle/Handles/KProcessScheduler.cs index 33f7fb1449..487a8147f6 100644 --- a/Ryujinx.Core/OsHle/Handles/KProcessScheduler.cs +++ b/Ryujinx.Core/OsHle/Handles/KProcessScheduler.cs @@ -66,17 +66,21 @@ namespace Ryujinx.Core.OsHle.Handles SchedThread.Dispose(); } - SchedulerThread NewThread = WaitingToRun.Pop(Thread.ActualCore); + int ActualCore = Thread.ActualCore; + + SchedulerThread NewThread = WaitingToRun.Pop(ActualCore); if (NewThread == null) { - Log.PrintDebug(LogClass.KernelScheduler, $"Nothing to run on core {Thread.ActualCore}!"); + Log.PrintDebug(LogClass.KernelScheduler, $"Nothing to run on core {ActualCore}!"); - RemoveActiveCore(Thread.ActualCore); + RemoveActiveCore(ActualCore); return; } + NewThread.Thread.ActualCore = ActualCore; + RunThread(NewThread); } } @@ -146,17 +150,21 @@ namespace Ryujinx.Core.OsHle.Handles { PrintDbgThreadInfo(Thread, "suspended."); - SchedulerThread SchedThread = WaitingToRun.Pop(Thread.ActualCore); + int ActualCore = Thread.ActualCore; + + SchedulerThread SchedThread = WaitingToRun.Pop(ActualCore); if (SchedThread != null) { + SchedThread.Thread.ActualCore = ActualCore; + RunThread(SchedThread); } else { Log.PrintDebug(LogClass.KernelScheduler, $"Nothing to run on core {Thread.ActualCore}!"); - RemoveActiveCore(Thread.ActualCore); + RemoveActiveCore(ActualCore); } } } @@ -169,9 +177,9 @@ namespace Ryujinx.Core.OsHle.Handles { lock (SchedLock) { - SchedulerThread SchedThread = WaitingToRun.Pop( - Thread.ActualCore, - Thread.ActualPriority); + int ActualCore = Thread.ActualCore; + + SchedulerThread SchedThread = WaitingToRun.Pop(ActualCore, Thread.ActualPriority); if (SchedThread == null) { @@ -182,6 +190,8 @@ namespace Ryujinx.Core.OsHle.Handles if (SchedThread != null) { + SchedThread.Thread.ActualCore = ActualCore; + RunThread(SchedThread); } } @@ -198,24 +208,24 @@ namespace Ryujinx.Core.OsHle.Handles public bool TryRunning(KThread Thread) { - if (!AllThreads.TryGetValue(Thread, out SchedulerThread SchedThread)) + //Failing to get the thread here is fine, + //the thread may not have been started yet. + if (AllThreads.TryGetValue(Thread, out SchedulerThread SchedThread)) { - throw new InvalidOperationException(); - } - - lock (SchedLock) - { - if (WaitingToRun.HasThread(SchedThread) && AddActiveCore(Thread)) + lock (SchedLock) { - WaitingToRun.Remove(SchedThread); + if (WaitingToRun.HasThread(SchedThread) && AddActiveCore(Thread)) + { + WaitingToRun.Remove(SchedThread); - RunThread(SchedThread); + RunThread(SchedThread); - return true; + return true; + } } - - return false; } + + return false; } public void Resume(KThread Thread) @@ -289,18 +299,25 @@ namespace Ryujinx.Core.OsHle.Handles private bool AddActiveCore(KThread Thread) { + int CoreMask; + lock (SchedLock) { //First, try running it on Ideal Core. - int CoreMask = 1 << Thread.IdealCore; + int IdealCore = Thread.IdealCore; - if ((ActiveCores & CoreMask) == 0) + if (IdealCore != -1) { - ActiveCores |= CoreMask; + CoreMask = 1 << IdealCore; - Thread.ActualCore = Thread.IdealCore; + if ((ActiveCores & CoreMask) == 0) + { + ActiveCores |= CoreMask; - return true; + Thread.ActualCore = IdealCore; + + return true; + } } //If that fails, then try running on any core allowed by Core Mask. @@ -340,11 +357,12 @@ namespace Ryujinx.Core.OsHle.Handles private void PrintDbgThreadInfo(KThread Thread, string Message) { Log.PrintDebug(LogClass.KernelScheduler, "(" + - "ThreadId = " + Thread.ThreadId + ", " + - "ActualCore = " + Thread.ActualCore + ", " + - "IdealCore = " + Thread.IdealCore + ", " + - "ActualPriority = " + Thread.ActualPriority + ", " + - "WantedPriority = " + Thread.WantedPriority + ") " + Message); + "ThreadId = " + Thread.ThreadId + ", " + + "CoreMask = 0x" + Thread.CoreMask.ToString("x1") + ", " + + "ActualCore = " + Thread.ActualCore + ", " + + "IdealCore = " + Thread.IdealCore + ", " + + "ActualPriority = " + Thread.ActualPriority + ", " + + "WantedPriority = " + Thread.WantedPriority + ") " + Message); } public void Dispose() diff --git a/Ryujinx.Core/OsHle/Handles/KThread.cs b/Ryujinx.Core/OsHle/Handles/KThread.cs index a430974c1a..ce9c3db23a 100644 --- a/Ryujinx.Core/OsHle/Handles/KThread.cs +++ b/Ryujinx.Core/OsHle/Handles/KThread.cs @@ -1,5 +1,5 @@ using ChocolArm64; -using System; +using System.Collections.Generic; namespace Ryujinx.Core.OsHle.Handles { @@ -14,16 +14,15 @@ namespace Ryujinx.Core.OsHle.Handles private Process Process; - public KThread NextMutexThread { get; set; } - public KThread NextCondVarThread { get; set; } + public List MutexWaiters { get; private set; } public KThread MutexOwner { get; set; } public int ActualPriority { get; private set; } public int WantedPriority { get; private set; } - public int IdealCore { get; set; } public int ActualCore { get; set; } + public int IdealCore { get; set; } public int WaitHandle { get; set; } @@ -39,6 +38,8 @@ namespace Ryujinx.Core.OsHle.Handles this.Process = Process; this.IdealCore = IdealCore; + MutexWaiters = new List(); + CoreMask = 1 << IdealCore; ActualPriority = WantedPriority = Priority; @@ -57,148 +58,25 @@ namespace Ryujinx.Core.OsHle.Handles int CurrPriority = WantedPriority; - if (NextMutexThread != null && CurrPriority > NextMutexThread.WantedPriority) + lock (Process.ThreadSyncLock) { - CurrPriority = NextMutexThread.WantedPriority; + foreach (KThread Thread in MutexWaiters) + { + if (CurrPriority > Thread.WantedPriority) + { + CurrPriority = Thread.WantedPriority; + } + } } if (CurrPriority != OldPriority) { ActualPriority = CurrPriority; - UpdateWaitLists(); + Process.Scheduler.Resort(this); MutexOwner?.UpdatePriority(); } } - - private void UpdateWaitLists() - { - UpdateMutexList(); - UpdateCondVarList(); - - Process.Scheduler.Resort(this); - } - - private void UpdateMutexList() - { - KThread OwnerThread = MutexOwner; - - if (OwnerThread == null) - { - return; - } - - //The MutexOwner field should only be non-null when the thread is - //waiting for the lock, and the lock belongs to another thread. - if (OwnerThread == this) - { - throw new InvalidOperationException(); - } - - lock (OwnerThread) - { - //Remove itself from the list. - KThread CurrThread = OwnerThread; - - while (CurrThread.NextMutexThread != null) - { - if (CurrThread.NextMutexThread == this) - { - CurrThread.NextMutexThread = NextMutexThread; - - break; - } - - CurrThread = CurrThread.NextMutexThread; - } - - //Re-add taking new priority into account. - CurrThread = OwnerThread; - - while (CurrThread.NextMutexThread != null) - { - if (CurrThread.NextMutexThread.ActualPriority > ActualPriority) - { - break; - } - - CurrThread = CurrThread.NextMutexThread; - } - - NextMutexThread = CurrThread.NextMutexThread; - - CurrThread.NextMutexThread = this; - } - } - - private void UpdateCondVarList() - { - lock (Process.ThreadArbiterListLock) - { - if (Process.ThreadArbiterListHead == null) - { - return; - } - - //Remove itself from the list. - bool Found; - - KThread CurrThread = Process.ThreadArbiterListHead; - - if (Found = (Process.ThreadArbiterListHead == this)) - { - Process.ThreadArbiterListHead = Process.ThreadArbiterListHead.NextCondVarThread; - } - else - { - while (CurrThread.NextCondVarThread != null) - { - if (CurrThread.NextCondVarThread == this) - { - CurrThread.NextCondVarThread = NextCondVarThread; - - Found = true; - - break; - } - - CurrThread = CurrThread.NextCondVarThread; - } - } - - if (!Found) - { - return; - } - - //Re-add taking new priority into account. - if (Process.ThreadArbiterListHead == null || - Process.ThreadArbiterListHead.ActualPriority > ActualPriority) - { - NextCondVarThread = Process.ThreadArbiterListHead; - - Process.ThreadArbiterListHead = this; - - return; - } - - CurrThread = Process.ThreadArbiterListHead; - - while (CurrThread.NextCondVarThread != null) - { - if (CurrThread.NextCondVarThread.ActualPriority > ActualPriority) - { - break; - } - - CurrThread = CurrThread.NextCondVarThread; - } - - NextCondVarThread = CurrThread.NextCondVarThread; - - CurrThread.NextCondVarThread = this; - } - } } } \ No newline at end of file diff --git a/Ryujinx.Core/OsHle/Kernel/SvcThread.cs b/Ryujinx.Core/OsHle/Kernel/SvcThread.cs index 94912f536f..597e42a6d7 100644 --- a/Ryujinx.Core/OsHle/Kernel/SvcThread.cs +++ b/Ryujinx.Core/OsHle/Kernel/SvcThread.cs @@ -146,11 +146,16 @@ namespace Ryujinx.Core.OsHle.Kernel int IdealCore = (int)ThreadState.X1; long CoreMask = (long)ThreadState.X2; + Ns.Log.PrintDebug(LogClass.KernelSvc, + "Handle = " + Handle .ToString("x8") + ", " + + "IdealCore = " + IdealCore.ToString("x8") + ", " + + "CoreMask = " + CoreMask .ToString("x16")); + KThread Thread = GetThread(ThreadState.Tpidr, Handle); if (IdealCore == -2) { - //TODO: Get this value from the NPDM file. + //TODO: Get this valcdue from the NPDM file. IdealCore = 0; CoreMask = 1 << IdealCore; @@ -159,14 +164,16 @@ namespace Ryujinx.Core.OsHle.Kernel { if ((uint)IdealCore > 3) { - Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core id 0x{IdealCore:x8}!"); + if ((IdealCore | 2) != -1) + { + Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core id 0x{IdealCore:x8}!"); - ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidCoreId); + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidCoreId); - return; + return; + } } - - if ((CoreMask & (1 << IdealCore)) == 0) + else if ((CoreMask & (1 << IdealCore)) == 0) { Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core mask 0x{CoreMask:x8}!"); @@ -185,27 +192,32 @@ namespace Ryujinx.Core.OsHle.Kernel return; } - if (IdealCore == -3) - { - if ((CoreMask & (1 << Thread.IdealCore)) == 0) - { - Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core mask 0x{CoreMask:x8}!"); - - ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidCoreMask); - - return; - } - } - else + //-1 is used as "don't care", so the IdealCore value is ignored. + //-2 is used as "use NPDM default core id" (handled above). + //-3 is used as "don't update", the old IdealCore value is kept. + if (IdealCore != -3) { Thread.IdealCore = IdealCore; } + else if ((CoreMask & (1 << Thread.IdealCore)) == 0) + { + Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core mask 0x{CoreMask:x8}!"); + + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidCoreMask); + + return; + } Thread.CoreMask = (int)CoreMask; KThread CurrThread = Process.GetThread(ThreadState.Tpidr); + //Try yielding execution, for the case where the new + //core mask allows the thread to run on the current core. Process.Scheduler.Yield(CurrThread); + + //Try running the modified thread, for the case where one + //of the cores specified on the core mask is free. Process.Scheduler.TryRunning(Thread); ThreadState.X0 = 0; diff --git a/Ryujinx.Core/OsHle/Kernel/SvcThreadSync.cs b/Ryujinx.Core/OsHle/Kernel/SvcThreadSync.cs index 0ca2a5f928..280065ec4c 100644 --- a/Ryujinx.Core/OsHle/Kernel/SvcThreadSync.cs +++ b/Ryujinx.Core/OsHle/Kernel/SvcThreadSync.cs @@ -2,6 +2,8 @@ using ChocolArm64.State; using Ryujinx.Core.Logging; using Ryujinx.Core.OsHle.Handles; using System; +using System.Collections.Generic; +using System.Linq; using System.Threading; using static Ryujinx.Core.OsHle.ErrorCode; @@ -110,10 +112,10 @@ namespace Ryujinx.Core.OsHle.Kernel ulong Timeout = ThreadState.X3; Ns.Log.PrintDebug(LogClass.KernelSvc, - "OwnerThreadHandle = " + MutexAddress .ToString("x16") + ", " + - "MutexAddress = " + CondVarAddress.ToString("x16") + ", " + - "WaitThreadHandle = " + ThreadHandle .ToString("x8") + ", " + - "Timeout = " + Timeout .ToString("x16")); + "MutexAddress = " + MutexAddress .ToString("x16") + ", " + + "CondVarAddress = " + CondVarAddress.ToString("x16") + ", " + + "ThreadHandle = " + ThreadHandle .ToString("x8") + ", " + + "Timeout = " + Timeout .ToString("x16")); if (IsPointingInsideKernel(MutexAddress)) { @@ -181,16 +183,19 @@ namespace Ryujinx.Core.OsHle.Kernel Ns.Log.PrintDebug(LogClass.KernelSvc, "MutexValue = " + MutexValue.ToString("x8")); - if (MutexValue != (OwnerThreadHandle | MutexHasListenersMask)) + lock (Process.ThreadSyncLock) { - return; + if (MutexValue != (OwnerThreadHandle | MutexHasListenersMask)) + { + return; + } + + CurrThread.WaitHandle = WaitThreadHandle; + CurrThread.MutexAddress = MutexAddress; + + InsertWaitingMutexThread(OwnerThreadHandle, WaitThread); } - CurrThread.WaitHandle = WaitThreadHandle; - CurrThread.MutexAddress = MutexAddress; - - InsertWaitingMutexThread(OwnerThreadHandle, WaitThread); - Ns.Log.PrintDebug(LogClass.KernelSvc, "Entering wait state..."); Process.Scheduler.EnterWait(CurrThread); @@ -205,26 +210,22 @@ namespace Ryujinx.Core.OsHle.Kernel return false; } - lock (CurrThread) + lock (Process.ThreadSyncLock) { //This is the new thread that will not own the mutex. //If no threads are waiting for the lock, then it should be null. - KThread OwnerThread = CurrThread.NextMutexThread; - - while (OwnerThread != null && OwnerThread.MutexAddress != MutexAddress) - { - OwnerThread = OwnerThread.NextMutexThread; - } - - UpdateMutexOwner(CurrThread, OwnerThread, MutexAddress); - - CurrThread.NextMutexThread = null; - - CurrThread.UpdatePriority(); + KThread OwnerThread = GetHighestPriority(CurrThread.MutexWaiters, MutexAddress); if (OwnerThread != null) { - int HasListeners = OwnerThread.NextMutexThread != null ? MutexHasListenersMask : 0; + //Remove all waiting mutex from the old owner, + //and insert then on the new owner. + UpdateMutexOwner(CurrThread, OwnerThread, MutexAddress); + + CurrThread.UpdatePriority(); + OwnerThread.UpdatePriority(); + + int HasListeners = OwnerThread.MutexWaiters.Count > 0 ? MutexHasListenersMask : 0; Process.Memory.WriteInt32(MutexAddress, HasListeners | OwnerThread.WaitHandle); @@ -238,12 +239,16 @@ namespace Ryujinx.Core.OsHle.Kernel Process.Scheduler.WakeUp(OwnerThread); + Ns.Log.PrintDebug(LogClass.KernelSvc, "Gave mutex to thread id " + OwnerThread.ThreadId + "!"); + return true; } else { Process.Memory.WriteInt32(MutexAddress, 0); + Ns.Log.PrintDebug(LogClass.KernelSvc, "No threads waiting mutex!"); + return false; } } @@ -262,43 +267,7 @@ namespace Ryujinx.Core.OsHle.Kernel lock (Process.ThreadArbiterListLock) { - KThread CurrThread = Process.ThreadArbiterListHead; - - if (CurrThread == null || CurrThread.ActualPriority > WaitThread.ActualPriority) - { - WaitThread.NextCondVarThread = Process.ThreadArbiterListHead; - - Process.ThreadArbiterListHead = WaitThread; - } - else - { - bool DoInsert = CurrThread != WaitThread; - - while (CurrThread.NextCondVarThread != null) - { - if (CurrThread.NextCondVarThread.ActualPriority > WaitThread.ActualPriority) - { - break; - } - - CurrThread = CurrThread.NextCondVarThread; - - DoInsert &= CurrThread != WaitThread; - } - - //Only insert if the node doesn't already exist in the list. - //This prevents circular references. - if (DoInsert) - { - if (WaitThread.NextCondVarThread != null) - { - throw new InvalidOperationException(); - } - - WaitThread.NextCondVarThread = CurrThread.NextCondVarThread; - CurrThread.NextCondVarThread = WaitThread; - } - } + Process.ThreadArbiterList.Add(WaitThread); } Ns.Log.PrintDebug(LogClass.KernelSvc, "Entering wait state..."); @@ -319,62 +288,44 @@ namespace Ryujinx.Core.OsHle.Kernel { lock (Process.ThreadArbiterListLock) { - KThread PrevThread = null; - KThread CurrThread = Process.ThreadArbiterListHead; + KThread CurrThread = GetHighestPriority(CondVarAddress); - while (CurrThread != null && (Count == -1 || Count > 0)) + while (CurrThread != null && (Count == -1 || Count-- > 0)) { - if (CurrThread.CondVarAddress == CondVarAddress) + AcquireMutexValue(CurrThread.MutexAddress); + + int MutexValue = Process.Memory.ReadInt32(CurrThread.MutexAddress); + + if (MutexValue == 0) { - if (PrevThread != null) - { - PrevThread.NextCondVarThread = CurrThread.NextCondVarThread; - } - else - { - Process.ThreadArbiterListHead = CurrThread.NextCondVarThread; - } + //Give the lock to this thread. + Process.Memory.WriteInt32(CurrThread.MutexAddress, CurrThread.WaitHandle); - CurrThread.NextCondVarThread = null; + CurrThread.WaitHandle = 0; + CurrThread.MutexAddress = 0; + CurrThread.CondVarAddress = 0; - AcquireMutexValue(CurrThread.MutexAddress); + CurrThread.MutexOwner?.UpdatePriority(); - int MutexValue = Process.Memory.ReadInt32(CurrThread.MutexAddress); + CurrThread.MutexOwner = null; - if (MutexValue == 0) - { - //Give the lock to this thread. - Process.Memory.WriteInt32(CurrThread.MutexAddress, CurrThread.WaitHandle); + Process.Scheduler.WakeUp(CurrThread); + } + else + { + //Wait until the lock is released. + MutexValue &= ~MutexHasListenersMask; - CurrThread.WaitHandle = 0; - CurrThread.MutexAddress = 0; - CurrThread.CondVarAddress = 0; + InsertWaitingMutexThread(MutexValue, CurrThread); - CurrThread.MutexOwner?.UpdatePriority(); + MutexValue |= MutexHasListenersMask; - CurrThread.MutexOwner = null; - - Process.Scheduler.WakeUp(CurrThread); - } - else - { - //Wait until the lock is released. - MutexValue &= ~MutexHasListenersMask; - - InsertWaitingMutexThread(MutexValue, CurrThread); - - MutexValue |= MutexHasListenersMask; - - Process.Memory.WriteInt32(CurrThread.MutexAddress, MutexValue); - } - - ReleaseMutexValue(CurrThread.MutexAddress); - - Count--; + Process.Memory.WriteInt32(CurrThread.MutexAddress, MutexValue); } - PrevThread = CurrThread; - CurrThread = CurrThread.NextCondVarThread; + ReleaseMutexValue(CurrThread.MutexAddress); + + CurrThread = GetHighestPriority(CondVarAddress); } } } @@ -390,59 +341,68 @@ namespace Ryujinx.Core.OsHle.Kernel return; } - WaitThread.MutexOwner = OwnerThread; + InsertWaitingMutexThread(OwnerThread, WaitThread); + } - lock (OwnerThread) + private void InsertWaitingMutexThread(KThread OwnerThread, KThread WaitThread) + { + lock (Process.ThreadSyncLock) { - KThread CurrThread = OwnerThread; + WaitThread.MutexOwner = OwnerThread; - while (CurrThread.NextMutexThread != null) + if (!OwnerThread.MutexWaiters.Contains(WaitThread)) { - if (CurrThread == WaitThread) - { - return; - } + OwnerThread.MutexWaiters.Add(WaitThread); - if (CurrThread.NextMutexThread.ActualPriority > WaitThread.ActualPriority) - { - break; - } - - CurrThread = CurrThread.NextMutexThread; - } - - if (CurrThread != WaitThread) - { - if (WaitThread.NextMutexThread != null) - { - throw new InvalidOperationException(); - } - - WaitThread.NextMutexThread = CurrThread.NextMutexThread; - CurrThread.NextMutexThread = WaitThread; + OwnerThread.UpdatePriority(); } } - - OwnerThread.UpdatePriority(); } private void UpdateMutexOwner(KThread CurrThread, KThread NewOwner, long MutexAddress) { //Go through all threads waiting for the mutex, //and update the MutexOwner field to point to the new owner. - CurrThread = CurrThread.NextMutexThread; - - while (CurrThread != null) + lock (Process.ThreadSyncLock) { - if (CurrThread.MutexAddress == MutexAddress) + for (int Index = 0; Index < CurrThread.MutexWaiters.Count; Index++) { - CurrThread.MutexOwner = NewOwner; - } + KThread Thread = CurrThread.MutexWaiters[Index]; - CurrThread = CurrThread.NextMutexThread; + if (Thread.MutexAddress == MutexAddress) + { + CurrThread.MutexWaiters.RemoveAt(Index--); + + Thread.MutexOwner = NewOwner; + + NewOwner.MutexWaiters.Add(Thread); + } + } } } + private KThread GetHighestPriority(List Threads, long MutexAddress) + { + return GetHighestPriority(Threads, x => x.MutexAddress == MutexAddress); + } + + private KThread GetHighestPriority(long CondVarAddress) + { + return GetHighestPriority(Process.ThreadArbiterList, x => x.CondVarAddress == CondVarAddress); + } + + private KThread GetHighestPriority(List Threads, Func Predicate) + { + KThread Thread = Threads.OrderBy(x => x.ActualPriority).FirstOrDefault(Predicate); + + if (Thread != null) + { + Threads.Remove(Thread); + } + + return Thread; + } + private void AcquireMutexValue(long MutexAddress) { while (!Process.Memory.AcquireAddress(MutexAddress)) diff --git a/Ryujinx.Core/OsHle/Process.cs b/Ryujinx.Core/OsHle/Process.cs index 8520b9ad93..c804bd20a0 100644 --- a/Ryujinx.Core/OsHle/Process.cs +++ b/Ryujinx.Core/OsHle/Process.cs @@ -38,10 +38,12 @@ namespace Ryujinx.Core.OsHle public KProcessScheduler Scheduler { get; private set; } - public KThread ThreadArbiterListHead { get; set; } + public List ThreadArbiterList { get; private set; } public object ThreadArbiterListLock { get; private set; } + public object ThreadSyncLock { get; private set; } + public KProcessHandleTable HandleTable { get; private set; } public AppletStateMgr AppletState { get; private set; } @@ -72,8 +74,12 @@ namespace Ryujinx.Core.OsHle Memory = new AMemory(); + ThreadArbiterList = new List(); + ThreadArbiterListLock = new object(); + ThreadSyncLock = new object(); + HandleTable = new KProcessHandleTable(); AppletState = new AppletStateMgr();