Some improvements to SetThreadCoreMask, simplified implementation of wait lists

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(
+                    int ActualCore = Thread.ActualCore;
-                        Thread.ActualCore,
+
-                        Thread.ActualPriority);
+                    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,11 +208,10 @@ 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))
@@ -213,10 +222,11 @@ namespace Ryujinx.Core.OsHle.Handles
 
                         return true;
                     }
+                }
+            }
 
             return false;
         }
-        }
 
         public void Resume(KThread Thread)
         {
@@ -289,19 +299,26 @@ 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 (IdealCore != -1)
+                {
+                    CoreMask = 1 << IdealCore;
 
                     if ((ActiveCores & CoreMask) == 0)
                     {
                         ActiveCores |= CoreMask;
 
-                    Thread.ActualCore = Thread.IdealCore;
+                        Thread.ActualCore = IdealCore;
 
                         return true;
                     }
+                }
 
                 //If that fails, then try running on any core allowed by Core Mask.
                 CoreMask = Thread.CoreMask & ~ActiveCores;
@@ -341,6 +358,7 @@ namespace Ryujinx.Core.OsHle.Handles
         {
             Log.PrintDebug(LogClass.KernelScheduler, "(" +
                 "ThreadId = "       + Thread.ThreadId                + ", " +
+                "CoreMask = 0x"     + Thread.CoreMask.ToString("x1") + ", " +
                 "ActualCore = "     + Thread.ActualCore              + ", " +
                 "IdealCore = "      + Thread.IdealCore               + ", " +
                 "ActualPriority = " + Thread.ActualPriority          + ", " +

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 List<KThread> MutexWaiters { get; private set; }
-        public KThread NextCondVarThread { get; 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<KThread>();
+
             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;
-            }
-        }
     }
 }

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;
@@ -158,6 +163,8 @@ namespace Ryujinx.Core.OsHle.Kernel
             else if (IdealCore != -3)
             {
                 if ((uint)IdealCore > 3)
+                {
+                    if ((IdealCore | 2) != -1)
                     {
                         Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core id 0x{IdealCore:x8}!");
 
@@ -165,8 +172,8 @@ namespace Ryujinx.Core.OsHle.Kernel
 
                         return;
                     }
-
+                }
-                if ((CoreMask & (1 << IdealCore)) == 0)
+                else if ((CoreMask & (1 << IdealCore)) == 0)
                 {
                     Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core mask 0x{CoreMask:x8}!");
 
@@ -185,9 +192,14 @@ namespace Ryujinx.Core.OsHle.Kernel
                 return;
             }
 
-            if (IdealCore == -3)
+            //-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)
             {
-                if ((CoreMask & (1 << Thread.IdealCore)) == 0)
+                Thread.IdealCore = IdealCore;
+            }
+            else if ((CoreMask & (1 << Thread.IdealCore)) == 0)
             {
                 Ns.Log.PrintWarning(LogClass.KernelSvc, $"Invalid core mask 0x{CoreMask:x8}!");
 
@@ -195,17 +207,17 @@ namespace Ryujinx.Core.OsHle.Kernel
 
                 return;
             }
-            }
-            else
-            {
-                Thread.IdealCore = IdealCore;
-            }
 
             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;

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,9 +112,9 @@ namespace Ryujinx.Core.OsHle.Kernel
             ulong Timeout        =       ThreadState.X3;
 
             Ns.Log.PrintDebug(LogClass.KernelSvc,
-                "OwnerThreadHandle = " + MutexAddress  .ToString("x16") + ", " +
+                "MutexAddress = "   + MutexAddress  .ToString("x16") + ", " +
-                "MutexAddress = "      + CondVarAddress.ToString("x16") + ", " +
+                "CondVarAddress = " + CondVarAddress.ToString("x16") + ", " +
-                "WaitThreadHandle = "  + ThreadHandle  .ToString("x8")  + ", " +
+                "ThreadHandle = "   + ThreadHandle  .ToString("x8")  + ", " +
                 "Timeout = "        + Timeout       .ToString("x16"));
 
             if (IsPointingInsideKernel(MutexAddress))
@@ -181,6 +183,8 @@ namespace Ryujinx.Core.OsHle.Kernel
 
             Ns.Log.PrintDebug(LogClass.KernelSvc, "MutexValue = " + MutexValue.ToString("x8"));
 
+            lock (Process.ThreadSyncLock)
+            {
                 if (MutexValue != (OwnerThreadHandle | MutexHasListenersMask))
                 {
                     return;
@@ -190,6 +194,7 @@ namespace Ryujinx.Core.OsHle.Kernel
                 CurrThread.MutexAddress = MutexAddress;
 
                 InsertWaitingMutexThread(OwnerThreadHandle, WaitThread);
+            }
 
             Ns.Log.PrintDebug(LogClass.KernelSvc, "Entering wait state...");
 
@@ -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;
+                KThread OwnerThread = GetHighestPriority(CurrThread.MutexWaiters, MutexAddress);
-
-                while (OwnerThread != null && OwnerThread.MutexAddress != MutexAddress)
-                {
-                    OwnerThread = OwnerThread.NextMutexThread;
-                }
-
-                UpdateMutexOwner(CurrThread, OwnerThread, MutexAddress);
-
-                CurrThread.NextMutexThread = null;
-
-                CurrThread.UpdatePriority();
 
                 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;
+                Process.ThreadArbiterList.Add(WaitThread);
-
-                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;
-                    }
-                }
             }
 
             Ns.Log.PrintDebug(LogClass.KernelSvc, "Entering wait state...");
@@ -319,24 +288,10 @@ namespace Ryujinx.Core.OsHle.Kernel
         {
             lock (Process.ThreadArbiterListLock)
             {
-                KThread PrevThread = null;
+                KThread CurrThread = GetHighestPriority(CondVarAddress);
-                KThread CurrThread = Process.ThreadArbiterListHead;
 
-                while (CurrThread != null && (Count == -1 || Count > 0))
+                while (CurrThread != null && (Count == -1 || Count-- > 0))
                 {
-                    if (CurrThread.CondVarAddress == CondVarAddress)
-                    {
-                        if (PrevThread != null)
-                        {
-                            PrevThread.NextCondVarThread = CurrThread.NextCondVarThread;
-                        }
-                        else
-                        {
-                            Process.ThreadArbiterListHead = CurrThread.NextCondVarThread;
-                        }
-
-                        CurrThread.NextCondVarThread = null;
-
                     AcquireMutexValue(CurrThread.MutexAddress);
 
                     int MutexValue = Process.Memory.ReadInt32(CurrThread.MutexAddress);
@@ -370,11 +325,7 @@ namespace Ryujinx.Core.OsHle.Kernel
 
                     ReleaseMutexValue(CurrThread.MutexAddress);
 
-                        Count--;
+                    CurrThread = GetHighestPriority(CondVarAddress);
-                    }
-
-                    PrevThread = CurrThread;
-                    CurrThread = CurrThread.NextCondVarThread;
                 }
             }
         }
@@ -390,57 +341,66 @@ namespace Ryujinx.Core.OsHle.Kernel
                 return;
             }
 
+            InsertWaitingMutexThread(OwnerThread, WaitThread);
+        }
+
+        private void InsertWaitingMutexThread(KThread OwnerThread, KThread WaitThread)
+        {
+            lock (Process.ThreadSyncLock)
+            {
                 WaitThread.MutexOwner = OwnerThread;
 
-            lock (OwnerThread)
+                if (!OwnerThread.MutexWaiters.Contains(WaitThread))
                 {
-                KThread CurrThread = OwnerThread;
+                    OwnerThread.MutexWaiters.Add(WaitThread);
-
-                while (CurrThread.NextMutexThread != null)
-                {
-                    if (CurrThread == WaitThread)
-                    {
-                        return;
-                    }
-
-                    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();
                 }
+            }
+        }
 
         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;
+            lock (Process.ThreadSyncLock)
+            {
+                for (int Index = 0; Index < CurrThread.MutexWaiters.Count; Index++)
+                {
+                    KThread Thread = CurrThread.MutexWaiters[Index];
 
-            while (CurrThread != null)
+                    if (Thread.MutexAddress == MutexAddress)
                     {
-                if (CurrThread.MutexAddress == MutexAddress)
+                        CurrThread.MutexWaiters.RemoveAt(Index--);
-                {
+
-                    CurrThread.MutexOwner = NewOwner;
+                        Thread.MutexOwner = NewOwner;
+
+                        NewOwner.MutexWaiters.Add(Thread);
+                    }
+                }
+            }
         }
 
-                CurrThread = CurrThread.NextMutexThread;
+        private KThread GetHighestPriority(List<KThread> 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<KThread> Threads, Func<KThread, bool> Predicate)
+        {
+            KThread Thread = Threads.OrderBy(x => x.ActualPriority).FirstOrDefault(Predicate);
+
+            if (Thread != null)
+            {
+                Threads.Remove(Thread);
+            }
+
+            return Thread;
         }
 
         private void AcquireMutexValue(long MutexAddress)

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<KThread> 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<KThread>();
+
             ThreadArbiterListLock = new object();
 
+            ThreadSyncLock = new object();
+
             HandleTable = new KProcessHandleTable();
 
             AppletState = new AppletStateMgr();