Thread scheduler rewrite (#393)

* Started to rewrite the thread scheduler

* Add a single core-like scheduling mode, enabled by default

* Clear exclusive monitor on context switch

* Add SetThreadActivity, misc fixes

* Implement WaitForAddress and SignalToAddress svcs, misc fixes

* Misc fixes (on SetActivity and Arbiter), other tweaks

* Rebased

* Add missing null check

* Rename multicore key on config, fix UpdatePriorityInheritance

* Make scheduling data MLQs private

* nit: Ordering

1 files changed, 0 insertions, 111 deletions

diff --git a/Ryujinx.HLE/HOS/Kernel/AddressArbiter.cs b/Ryujinx.HLE/HOS/Kernel/AddressArbiter.cs
deleted file mode 100644
index d7df0a72..00000000
--- a/Ryujinx.HLE/HOS/Kernel/AddressArbiter.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-using ChocolArm64.Memory;
-using ChocolArm64.State;
-
-using static Ryujinx.HLE.HOS.ErrorCode;
-
-namespace Ryujinx.HLE.HOS.Kernel
-{
-    static class AddressArbiter
-    {
-        static ulong WaitForAddress(Process Process, AThreadState ThreadState, long Address, ulong Timeout)
-        {
-            KThread CurrentThread = Process.GetThread(ThreadState.Tpidr);
-
-            Process.Scheduler.SetReschedule(CurrentThread.ProcessorId);
-
-            CurrentThread.ArbiterWaitAddress = Address;
-            CurrentThread.ArbiterSignaled    = false;
-
-            Process.Scheduler.EnterWait(CurrentThread, NsTimeConverter.GetTimeMs(Timeout));
-
-            if (!CurrentThread.ArbiterSignaled)
-            {
-                return MakeError(ErrorModule.Kernel, KernelErr.Timeout);
-            }
-
-            return 0;
-        }
-
-        public static ulong WaitForAddressIfLessThan(Process      Process,
-                                                     AThreadState ThreadState,
-                                                     AMemory      Memory,
-                                                     long         Address,
-                                                     int          Value,
-                                                     ulong        Timeout,
-                                                     bool         ShouldDecrement)
-        {
-            Memory.SetExclusive(ThreadState, Address);
-
-            int CurrentValue = Memory.ReadInt32(Address);
-
-            while (true)
-            {
-                if (Memory.TestExclusive(ThreadState, Address))
-                {
-                    if (CurrentValue < Value)
-                    {
-                        if (ShouldDecrement)
-                        {
-                            Memory.WriteInt32(Address, CurrentValue - 1);
-                        }
-
-                        Memory.ClearExclusiveForStore(ThreadState);
-                    }
-                    else
-                    {
-                        Memory.ClearExclusiveForStore(ThreadState);
-
-                        return MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
-                    }
-
-                    break;
-                }
-
-                Memory.SetExclusive(ThreadState, Address);
-
-                CurrentValue = Memory.ReadInt32(Address);
-            }
-
-            if (Timeout == 0)
-            {
-                return MakeError(ErrorModule.Kernel, KernelErr.Timeout);
-            }
-
-            return WaitForAddress(Process, ThreadState, Address, Timeout);
-        }
-
-        public static ulong WaitForAddressIfEqual(Process      Process,
-                                                  AThreadState ThreadState,
-                                                  AMemory      Memory,
-                                                  long         Address,
-                                                  int          Value,
-                                                  ulong        Timeout)
-        {
-            if (Memory.ReadInt32(Address) != Value)
-            {
-                return MakeError(ErrorModule.Kernel, KernelErr.InvalidState);
-            }
-
-            if (Timeout == 0)
-            {
-                return MakeError(ErrorModule.Kernel, KernelErr.Timeout);
-            }
-
-            return WaitForAddress(Process, ThreadState, Address, Timeout);
-        }
-    }
-
-    enum ArbitrationType : int
-    {
-        WaitIfLessThan,
-        DecrementAndWaitIfLessThan,
-        WaitIfEqual
-    }
-
-    enum SignalType : int
-    {
-        Signal,
-        IncrementAndSignalIfEqual,
-        ModifyByWaitingCountAndSignalIfEqual
-    }
-}