X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Fkern%2Fcoop.c;h=542ed67844a7dc0acddb63196369c68572a50c31;hb=7b47f57c871da92ea81d28a18f91fae04f3072b3;hp=aa370ae589f6c5c589b851afe817030a1dd9e224;hpb=e62ca0b357f09804d7d894949df44224c9d74bb7;p=bertos.git diff --git a/bertos/kern/coop.c b/bertos/kern/coop.c index aa370ae5..542ed678 100644 --- a/bertos/kern/coop.c +++ b/bertos/kern/coop.c @@ -32,7 +32,7 @@ * * \brief Simple cooperative multitasking scheduler. * - * \version $Id: proc.c 1616 2008-08-10 19:41:26Z bernie $ + * \version $Id$ * \author Bernie Innocenti * \author Stefano Fedrigo */ @@ -51,93 +51,53 @@ #include /** - * CPU dependent context switching routines. + * Define function prototypes exported outside. * - * Saving and restoring the context on the stack is done by a CPU-dependent - * support routine which usually needs to be written in assembly. + * Required to silent gcc "no previous prototype" warnings. */ -EXTERN_C void asm_switch_context(cpu_stack_t **new_sp, cpu_stack_t **save_sp); - +void coop_yield(void); +void coop_switch(void); +void coop_wakeup(Process *proc); /** - * System scheduler: pass CPU control to the next process in - * the ready queue. + * Give the control of the CPU to another process. + * + * \note Assume the current process has been already added to a wait queue. + * + * \warning This should be considered an internal kernel function, even if it + * is allowed, usage from application code is strongly discouraged. */ -static void proc_schedule(void) +void coop_switch(void) { - cpu_flags_t flags; - - ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); - ASSERT_USER_CONTEXT(); - IRQ_ASSERT_ENABLED(); - - /* Poll on the ready queue for the first ready process */ - IRQ_SAVE_DISABLE(flags); - while (!(CurrentProcess = (struct Process *)list_remHead(&ProcReadyList))) - { - /* - * Make sure we physically reenable interrupts here, no matter what - * the current task status is. This is important because if we - * are idle-spinning, we must allow interrupts, otherwise no - * process will ever wake up. - * - * During idle-spinning, an interrupt can occur and it may - * modify \p ProcReadyList. To ensure that compiler reload this - * variable every while cycle we call CPU_MEMORY_BARRIER. - * The memory barrier ensure that all variables used in this context - * are reloaded. - * \todo If there was a way to write sig_wait() so that it does not - * disable interrupts while waiting, there would not be any - * reason to do this. - */ - IRQ_ENABLE; - CPU_IDLE; - MEMORY_BARRIER; - IRQ_DISABLE; - } - IRQ_RESTORE(flags); + ATOMIC(proc_schedule()); } -void proc_switch(void) +/** + * Immediately wakeup a process, dispatching it to the CPU. + */ +void coop_wakeup(Process *proc) { - /* Remember old process to save its context later */ - Process * const old_process = CurrentProcess; - - proc_schedule(); + ASSERT(proc_preemptAllowed()); + ASSERT(current_process); + IRQ_ASSERT_DISABLED(); - /* - * Optimization: don't switch contexts when the active - * process has not changed. - */ - if (CurrentProcess != old_process) + if (prio_proc(proc) >= prio_curr()) { - cpu_stack_t *dummy; + Process *old_process = current_process; - #if CONFIG_KERN_MONITOR - LOG_INFO("Switch from %p(%s) to %p(%s)\n", - old_process, proc_name(old_process), - CurrentProcess, proc_currentName()); - #endif - - /* Save context of old process and switch to new process. If there is no - * old process, we save the old stack pointer into a dummy variable that - * we ignore. In fact, this happens only when the old process has just - * exited. - * TODO: Instead of physically clearing the process at exit time, a zombie - * list should be created. - */ - asm_switch_context(&CurrentProcess->stack, old_process ? &old_process->stack : &dummy); + SCHED_ENQUEUE(current_process); + current_process = proc; + proc_switchTo(current_process, old_process); } - - /* This RET resumes the execution on the new process */ + else + SCHED_ENQUEUE_HEAD(proc); } - /** * Co-operative context switch */ -void proc_yield(void) +void coop_yield(void) { - ATOMIC(SCHED_ENQUEUE(CurrentProcess)); - proc_switch(); + ATOMIC(SCHED_ENQUEUE(current_process)); + coop_switch(); }