Somewhat better implementation of thread yield

4 files changed, 29 insertions, 19 deletions

diff --git a/Ryujinx.Core/OsHle/Handles/KProcessScheduler.cs b/Ryujinx.Core/OsHle/Handles/KProcessScheduler.cs
index c1c10314..63046a72 100644
--- a/Ryujinx.Core/OsHle/Handles/KProcessScheduler.cs
+++ b/Ryujinx.Core/OsHle/Handles/KProcessScheduler.cs
@@ -197,30 +197,40 @@ namespace Ryujinx.Core.OsHle.Handles
 
             if (NeedsReschedule)
             {
-                PrintDbgThreadInfo(Thread, "yielded execution.");
-
-                lock (SchedLock)
-                {
-                    int ActualCore = Thread.ActualCore;
+                Yield(Thread, Thread.ActualPriority - 1);
+            }
+        }
 
-                    SchedulerThread NewThread = WaitingToRun.Pop(ActualCore, Thread.ActualPriority);
+        public void Yield(KThread Thread)
+        {
+            Yield(Thread, Thread.ActualPriority);
+        }
 
-                    if (NewThread == null)
-                    {
-                        PrintDbgThreadInfo(Thread, "resumed because theres nothing better to run.");
+        private void Yield(KThread Thread, int MinPriority)
+        {
+            PrintDbgThreadInfo(Thread, "yielded execution.");
 
-                        return;
-                    }
+            lock (SchedLock)
+            {
+                int ActualCore = Thread.ActualCore;
 
-                    NewThread.Thread.ActualCore = ActualCore;
+                SchedulerThread NewThread = WaitingToRun.Pop(ActualCore, MinPriority);
 
-                    CoreThreads[ActualCore] = NewThread.Thread;
+                if (NewThread == null)
+                {
+                    PrintDbgThreadInfo(Thread, "resumed because theres nothing better to run.");
 
-                    RunThread(NewThread);
+                    return;
                 }
 
-                Resume(Thread);
+                NewThread.Thread.ActualCore = ActualCore;
+
+                CoreThreads[ActualCore] = NewThread.Thread;
+
+                RunThread(NewThread);
             }
+
+            Resume(Thread);
         }
 
         public void Resume(KThread Thread)
diff --git a/Ryujinx.Core/OsHle/Handles/ThreadQueue.cs b/Ryujinx.Core/OsHle/Handles/ThreadQueue.cs
index 491b77c8..7bb2314e 100644
--- a/Ryujinx.Core/OsHle/Handles/ThreadQueue.cs
+++ b/Ryujinx.Core/OsHle/Handles/ThreadQueue.cs
@@ -2,7 +2,7 @@ namespace Ryujinx.Core.OsHle.Handles
 {
     class ThreadQueue
     {
-        private const int LowestPriority = 0x40;
+        private const int LowestPriority = 0x3f;
 
         private SchedulerThread Head;
 
@@ -63,7 +63,7 @@ namespace Ryujinx.Core.OsHle.Handles
                 {
                     KThread Thread = Curr.Thread;
 
-                    if (Thread.ActualPriority < MinPriority && (Thread.CoreMask & CoreMask) != 0)
+                    if (Thread.ActualPriority <= MinPriority && (Thread.CoreMask & CoreMask) != 0)
                     {
                         if (Prev != null)
                         {
diff --git a/Ryujinx.Core/OsHle/Kernel/SvcThread.cs b/Ryujinx.Core/OsHle/Kernel/SvcThread.cs
index 8aa26dd3..11841758 100644
--- a/Ryujinx.Core/OsHle/Kernel/SvcThread.cs
+++ b/Ryujinx.Core/OsHle/Kernel/SvcThread.cs
@@ -87,7 +87,7 @@ namespace Ryujinx.Core.OsHle.Kernel
 
             if (TimeoutNs == 0)
             {
-                Process.Scheduler.SetReschedule(CurrThread.ActualCore);
+                Process.Scheduler.Yield(CurrThread);
             }
             else
             {
diff --git a/Ryujinx.Core/OsHle/Kernel/SvcThreadSync.cs b/Ryujinx.Core/OsHle/Kernel/SvcThreadSync.cs
index e762c396..70107c3a 100644
--- a/Ryujinx.Core/OsHle/Kernel/SvcThreadSync.cs
+++ b/Ryujinx.Core/OsHle/Kernel/SvcThreadSync.cs
@@ -206,7 +206,7 @@ namespace Ryujinx.Core.OsHle.Kernel
         {
             lock (Process.ThreadSyncLock)
             {
-                //This is the new thread that will not own the mutex.
+                //This is the new thread that will now own the mutex.
                 //If no threads are waiting for the lock, then it should be null.
                 KThread OwnerThread = PopThread(CurrThread.MutexWaiters, x => x.MutexAddress == MutexAddress);