/* * Voluntarily give up the CPU to another thread. * Does nothing if no other threads are ready to run. */ void Yield(void) { Disable_Interrupts(); Make_Runnable(g_currentThread); Schedule(); Enable_Interrupts(); }
/* * Wake up a single thread waiting on given wait queue * (if there are any threads waiting). Chooses the highest priority thread. * Interrupts must be disabled! */ void Wake_Up_Thread(struct Thread_Queue* waitQueue, int pid) { struct Kernel_Thread* thread = Lookup_Thread(pid);; KASSERT(!Interrupts_Enabled()); if (thread != 0) { Remove_Thread(waitQueue, thread); Make_Runnable(thread); /*Print("Wake_Up_One: waking up %x from %x\n", best, g_currentThread); */ } }
/* * Wake up a single thread waiting on given wait queue * (if there are any threads waiting). Chooses the highest priority thread. * Interrupts must be disabled! */ void Wake_Up_One(struct Thread_Queue* waitQueue) { struct Kernel_Thread* best; KASSERT(!Interrupts_Enabled()); best = Find_Best(waitQueue); if (best != 0) { Remove_Thread(waitQueue, best); Make_Runnable(best); /*Print("Wake_Up_One: waking up %x from %x\n", best, g_currentThread); */ } }
/* * Wake up all threads waiting on given wait queue. * Must be called with interrupts disabled! * See Keyboard_Interrupt_Handler() function in keyboard.c * for an example. */ void Wake_Up(struct Thread_Queue* waitQueue) { struct Kernel_Thread *kthread = waitQueue->head, *next; KASSERT(!Interrupts_Enabled()); /* * Walk throught the list of threads in the wait queue, * transferring each one to the run queue. */ while (kthread != 0) { next = Get_Next_In_Thread_Queue(kthread); Make_Runnable(kthread); kthread = next; } /* The wait queue is now empty. */ Clear_Thread_Queue(waitQueue); }
/* * Atomically make a thread runnable. * Assumes interrupts are currently enabled. */ void Make_Runnable_Atomic(struct Kernel_Thread* kthread) { Disable_Interrupts(); Make_Runnable(kthread); Enable_Interrupts(); }