/*
* 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();
}
