public bool HasThread(SchedulerThread SchedThread) { lock (Threads) { return(Threads.Contains(SchedThread)); } }
public void StartThread(HThread Thread) { lock (SchedLock) { if (AllThreads.ContainsKey(Thread)) { return; } SchedulerThread SchedThread = new SchedulerThread(Thread); AllThreads.Add(Thread, SchedThread); if (!ActiveProcessors.Contains(Thread.ProcessorId)) { ActiveProcessors.Add(Thread.ProcessorId); Thread.Thread.Execute(); SetThreadAsRunning(SchedThread); SchedThread.State = ThreadState.Running; } else { InsertSorted(SchedThread); SchedThread.State = ThreadState.WaitingToRun; Logging.Debug($"{GetDbgThreadInfo(SchedThread.Thread)} waiting to run."); } } }
public void Push(SchedulerThread Thread) { lock (Threads) { Threads.Add(Thread); } }
private void TryRunningWaitingThead(int ProcessorId) { Logging.Debug($"TryRunningWaitingThead core {ProcessorId}."); lock (SchedLock) { if (!ActiveProcessors.Contains(ProcessorId) && WaitingThreads[ProcessorId].Count > 0) { SchedulerThread SchedThread = WaitingThreads[ProcessorId].Dequeue(); Logging.Debug($"Now trying to run {GetDbgThreadInfo(SchedThread.Thread)}."); if (!SchedThread.Thread.Thread.Execute()) { SchedThread.WaitEvent.Set(); } else { SetThreadAsRunning(SchedThread); } } else { Logging.Debug($"Processor id {ProcessorId} already being used or no waiting threads."); } } }
public void StartThread(HThread Thread) { lock (SchedLock) { SchedulerThread SchedThread = new SchedulerThread(Thread); if (!AllThreads.TryAdd(Thread, SchedThread)) { return; } if (!ActiveProcessors.Contains(Thread.ProcessorId)) { ActiveProcessors.Add(Thread.ProcessorId); Thread.Thread.Execute(); Logging.Debug($"{GetDbgThreadInfo(Thread)} running."); } else { WaitingToRun[Thread.ProcessorId].Push(SchedThread); Logging.Debug($"{GetDbgThreadInfo(SchedThread.Thread)} waiting to run."); } } }
public SchedulerThread Pop(int Core, int MinPriority = LowestPriority) { lock (ListLock) { int CoreMask = 1 << Core; SchedulerThread Prev = null; SchedulerThread Curr = Head; while (Curr != null) { KThread Thread = Curr.Thread; if (Thread.ActualPriority <= MinPriority && (Thread.CoreMask & CoreMask) != 0) { if (Prev != null) { Prev.Next = Curr.Next; } else { Head = Head.Next; } break; } Prev = Curr; Curr = Curr.Next; } return(Curr); } }
private void InsertSorted(SchedulerThread SchedThread) { HThread Thread = SchedThread.Thread; Queue <SchedulerThread> CoreQueue = WaitingThreads[Thread.ProcessorId]; Queue <SchedulerThread> TempQueue = new Queue <SchedulerThread>(CoreQueue.Count); while (CoreQueue.Count > 0) { if (CoreQueue.Peek().Thread.Priority >= Thread.Priority) { break; } TempQueue.Enqueue(CoreQueue.Dequeue()); } CoreQueue.Enqueue(SchedThread); while (CoreQueue.Count > 0) { TempQueue.Enqueue(CoreQueue.Dequeue()); } while (TempQueue.Count > 0) { CoreQueue.Enqueue(TempQueue.Dequeue()); } }
public bool Remove(SchedulerThread Thread) { lock (ListLock) { if (Head == null) { return(false); } else if (Head == Thread) { Head = Head.Next; return(true); } SchedulerThread Prev = Head; SchedulerThread Curr = Head.Next; while (Curr != null) { if (Curr == Thread) { Prev.Next = Curr.Next; return(true); } Prev = Curr; Curr = Curr.Next; } return(false); } }
private void SetThreadAsRunning(SchedulerThread SchedThread) { ActiveProcessors.Add(SchedThread.Thread.ProcessorId); SchedThread.State = ThreadState.Running; SchedThread.Signaled = false; Logging.Debug($"{GetDbgThreadInfo(SchedThread.Thread)} running."); }
private void RunThread(SchedulerThread SchedThread) { if (!SchedThread.Thread.Thread.Execute()) { SchedThread.WaitEvent.Set(); } else { Logging.Debug($"{GetDbgThreadInfo(SchedThread.Thread)} running."); } }
public bool Resort(SchedulerThread Thread) { lock (ListLock) { if (Remove(Thread)) { Push(Thread); return(true); } return(false); } }
public void Suspend(int ProcessorId) { lock (SchedLock) { SchedulerThread SchedThread = WaitingToRun[ProcessorId].Pop(); if (SchedThread != null) { RunThread(SchedThread); } else { ActiveProcessors.Remove(ProcessorId); } } }
public bool HasThread(SchedulerThread Thread) { lock (ListLock) { SchedulerThread Curr = Head; while (Curr != null) { if (Curr == Thread) { return(true); } Curr = Curr.Next; } return(false); } }
private void TryResumingExecution(SchedulerThread SchedThread) { HThread Thread = SchedThread.Thread; lock (SchedLock) { if (ActiveProcessors.Add(Thread.ProcessorId)) { Logging.Debug($"{GetDbgThreadInfo(Thread)} resuming execution..."); return; } WaitingToRun[Thread.ProcessorId].Push(SchedThread); } SchedThread.WaitEvent.WaitOne(); Logging.Debug($"{GetDbgThreadInfo(Thread)} resuming execution..."); }
public void Start() { if (!IsRunning) { try { System.Log.Debug($"Starting {SchedulerThread.Name}"); CancelToken = new CancellationTokenSource(); IsRunning = true; SchedulerThread.Start(); } catch (ThreadStateException e) { // We don't care System.Log.Verbose(e, $"{SchedulerThread.Name}"); } } else { System.Log.Debug($"Tried starting {SchedulerThread.Name} but it is already running"); } }
public void Push(SchedulerThread Wait) { lock (ListLock) { //Ensure that we're not creating circular references //by adding a thread that is already on the list. if (HasThread(Wait)) { return; } if (Head == null || Head.Thread.ActualPriority > Wait.Thread.ActualPriority) { Wait.Next = Head; Head = Wait; return; } SchedulerThread Curr = Head; while (Curr.Next != null) { if (Curr.Next.Thread.ActualPriority > Wait.Thread.ActualPriority) { break; } Curr = Curr.Next; } Wait.Next = Curr.Next; Curr.Next = Wait; } }
private void InsertAtEnd(SchedulerThread SchedThread) { WaitingThreads[SchedThread.Thread.ProcessorId].Enqueue(SchedThread); }