0
0
Fork 0
This repository has been archived on 2024-10-12. You can view files and clone it, but cannot push or open issues or pull requests.
ryujinx-final/Ryujinx.HLE/HOS/Kernel/KTimeManager.cs
gdkchan b8133c1997
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
2018-09-18 20:36:43 -03:00

134 lines
No EOL
3.4 KiB
C#

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
namespace Ryujinx.HLE.HOS.Kernel
{
class KTimeManager : IDisposable
{
private class WaitingObject
{
public IKFutureSchedulerObject Object { get; private set; }
public long TimePoint { get; private set; }
public WaitingObject(IKFutureSchedulerObject Object, long TimePoint)
{
this.Object = Object;
this.TimePoint = TimePoint;
}
}
private List<WaitingObject> WaitingObjects;
private AutoResetEvent WaitEvent;
private Stopwatch Counter;
private bool KeepRunning;
public KTimeManager()
{
WaitingObjects = new List<WaitingObject>();
Counter = new Stopwatch();
Counter.Start();
KeepRunning = true;
Thread Work = new Thread(WaitAndCheckScheduledObjects);
Work.Start();
}
public void ScheduleFutureInvocation(IKFutureSchedulerObject Object, long Timeout)
{
lock (WaitingObjects)
{
long TimePoint = Counter.ElapsedMilliseconds + ConvertNanosecondsToMilliseconds(Timeout);
WaitingObjects.Add(new WaitingObject(Object, TimePoint));
}
WaitEvent.Set();
}
private long ConvertNanosecondsToMilliseconds(long Timeout)
{
Timeout /= 1000000;
if ((ulong)Timeout > int.MaxValue)
{
return int.MaxValue;
}
return Timeout;
}
public void UnscheduleFutureInvocation(IKFutureSchedulerObject Object)
{
lock (WaitingObjects)
{
WaitingObjects.RemoveAll(x => x.Object == Object);
}
}
private void WaitAndCheckScheduledObjects()
{
using (WaitEvent = new AutoResetEvent(false))
{
while (KeepRunning)
{
Monitor.Enter(WaitingObjects);
WaitingObject Next = WaitingObjects.OrderBy(x => x.TimePoint).FirstOrDefault();
Monitor.Exit(WaitingObjects);
if (Next != null)
{
long TimePoint = Counter.ElapsedMilliseconds;
if (Next.TimePoint > TimePoint)
{
WaitEvent.WaitOne((int)(Next.TimePoint - TimePoint));
}
Monitor.Enter(WaitingObjects);
bool TimeUp = Counter.ElapsedMilliseconds >= Next.TimePoint && WaitingObjects.Remove(Next);
Monitor.Exit(WaitingObjects);
if (TimeUp)
{
Next.Object.TimeUp();
}
}
else
{
WaitEvent.WaitOne();
}
}
}
}
public void Dispose()
{
Dispose(true);
}
protected virtual void Dispose(bool Disposing)
{
if (Disposing)
{
KeepRunning = false;
WaitEvent?.Set();
}
}
}
}