public override void OnThreadBlocked(Thread thread, SchedulerTime stop) { // Assert preconditions VTable.Assert(thread == Thread.CurrentThread); if (stop != SchedulerTime.MaxValue) { // Enqueue timer so that if it expires we will notice it right a way EnqueueTimer(thread, stop); } // Thread is blocked now - indicate this to dispatcher. Dispatcher will make // make sure that thread's scheduler is aware of the blockage ProcessorDispatcher.SwitchContext(ThreadState.Blocked); // We just got unblocked and happilly running. We need to remove ourselves // from the timer queue if we are unblocked by signal rather than by timeout if (thread.UnblockedBy != WaitHandle.WaitTimeout) { // One of our buddies unblocked us - remove the time out. Before we can // actually assert that we were indeed unblocked by someone. VTable.Assert(thread.UnblockedBy != WaitHandle.UninitWait); // Remove a timer from the timer queue and happilly continue! RemoveTimer(thread); } }
public override void OnThreadUnblocked(Thread thread) { // Only call this method if thread is Indeed blocked VTable.Assert(thread.IsBlocked); // Thread is ready to run: Add it to dispatcher ProcessorDispatcher.AddRunnableThread(thread); }
public override void OnThreadStart(Thread thread) { // Initialize thread's affinity thread.Affinity = (int)ProcessorDispatcher.Affinity.All; // Enqueue thread into dispatcher. ProcessorDispatcher.AddRunnableThread(thread); }
internal override UIntPtr Callback(UIntPtr param) { unsafe { ThreadContext *newContext = (ThreadContext *)param; // Switch our thread context, synchronizing with the dispatcher as necessary. ProcessorDispatcher.TransferToThreadContext(ref *GetCurrentThreadContext(), ref *newContext); // Resume in the new context. Note that this call does not return. newContext->threadRecord.spill.Resume(); return(0); } }
public override void OnThreadFreezeDecrement(Thread thread) { bool shouldPutThreadOnRunnableQueue = false; // Assert preconditions DebugStub.Assert(thread.FreezeCount > 0); // Update threads: Freeze count if (thread.DecrementFreezeCounter(ref shouldPutThreadOnRunnableQueue) == 0 && shouldPutThreadOnRunnableQueue) { // Thread became runnable - add it to runnable queue ProcessorDispatcher.AddRunnableThread(thread); } }
private static void InitSchedulerTypes() { InitType(typeof(Processor)); InitType(typeof(Scheduler)); InitType(typeof(ProcessorDispatcher)); // InitType(typeof(AffinityScheduler)); InitType(typeof(MinScheduler)); ARM_PROGRESS("Kernel!013"); // Create scheduler before initializing processes scheduler = new MinScheduler(); ARM_PROGRESS("Kernel!017"); // Initialize processor dispatcher ProcessorDispatcher.StaticInitialize(scheduler); }
public static bool IsIdleThread(int threadIdx) { return(ProcessorDispatcher.IsIdleThread(threadIdx)); }
public override void OnThreadStop(Thread thread) { // Perform a context switch: If thread is stopped it will be cleaned up, otherwise // it is suspended and will be cleaned up latter ProcessorDispatcher.SwitchContext(ThreadState.Stopped); }
public override void OnThreadYield(Thread thread) { // Perform a context switch: If thread is runnable it will be put on a runnable queue // by dispatcher. ProcessorDispatcher.SwitchContext(ThreadState.Running); }