X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Fkern%2Fpreempt.c;h=f285d43f5a53c3e3932f3d1d5edca9be072a26d2;hb=ecc3d927e252b3fa278b5320f16364fc14d61220;hp=0cbaf7c902dd2d65a03015cecf2b15804853f17e;hpb=8cfe12e5b95974d75b98ec964fc7edaf37919f0e;p=bertos.git diff --git a/bertos/kern/preempt.c b/bertos/kern/preempt.c index 0cbaf7c9..f285d43f 100644 --- a/bertos/kern/preempt.c +++ b/bertos/kern/preempt.c @@ -26,161 +26,118 @@ * invalidate any other reasons why the executable file might be covered by * the GNU General Public License. * - * Copyright 2001, 2004 Develer S.r.l. (http://www.develer.com/) - * Copyright 1999, 2000, 2001, 2008 Bernie Innocenti + * Copyright 2008 Bernie Innocenti * --> * - * \brief Simple realtime multitasking scheduler. - * Context switching is only done cooperatively. + * \brief Simple preemptive multitasking scheduler. * * \version $Id: proc.c 1616 2008-08-10 19:41:26Z bernie $ * \author Bernie Innocenti - * \author Stefano Fedrigo */ #include "proc_p.h" #include "proc.h" +#include +#include #include // CPU_IDLE +#include // IRQ_DISABLE()... +#include +#include -#include // XXX alarm() +int preempt_forbid_cnt; -/* - * The time sharing scheduler forces a task switch when the current - * process has exhausted its quantum. - */ -uint16_t Quantum; +static Timer preempt_timer; -/** - * Disable preemptive task switching. - * - * The scheduler maintains a per-process nesting counter. Task switching is - * effectively re-enabled only when the number of calls to proc_permit() - * matches the number of calls to proc_forbid(). - * - * Calling functions that could sleep while task switching is disabled - * is dangerous, although supported. Preemptive task switching is - * resumed while the process is sleeping and disabled again as soon as - * it wakes up again. - * - * \sa proc_permit() - */ -void proc_forbid(void) -{ - /* No need to protect against interrupts here. */ - ++CurrentProcess->forbid_cnt; -} -/** - * Re-enable preemptive task switching. - * - * \sa proc_forbid() - */ -void proc_permit(void) -{ - /* No need to protect against interrupts here. */ - --CurrentProcess->forbid_cnt; -} - -static void (*irq_handlers[100])(void); // FIXME +// fwd decl from idle.c +void idle_init(void); void proc_preempt(void) { - TRACE; + IRQ_DISABLE; - ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); + ASSERT(preempt_forbid_cnt == 0); + LIST_ASSERT_VALID(&ProcReadyList); + CurrentProcess = (struct Process *)list_remHead(&ProcReadyList); + ASSERT2(CurrentProcess, "no idle proc?"); - IRQ_DISABLE; - /* Poll on the ready queue for the first ready process */ - 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. - */ - IRQ_ENABLE; - CPU_IDLE; - MEMORY_BARRIER; - IRQ_DISABLE; - } IRQ_ENABLE; + + TRACEMSG("launching %p:%s", CurrentProcess, proc_currentName()); } -void proc_preempt_timer(void) +void proc_preempt_timer(UNUSED_ARG(void *, param)) { - // TODO: check Quantum + if (!preempt_forbid_cnt) + { + IRQ_DISABLE; - alarm(1); - ATOMIC(SCHED_ENQUEUE(CurrentProcess)); - proc_schedule(); + #if CONFIG_KERN_PRI + Process *rival = (Process *)LIST_HEAD(&ProcReadyList); + if (rival && rival->link.pri >= CurrentProcess->link.pri) + { + #endif + + TRACEMSG("preempting %p:%s", CurrentProcess, proc_currentName()); +#if 0 + SCHED_ENQUEUE(CurrentProcess); + proc_preempt(); +#endif + #if CONFIG_KERN_PRI + } + #endif + + IRQ_ENABLE; + } + + timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM); + timer_add(&preempt_timer); } void proc_schedule(void) { + ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); + TRACEMSG("%p:%s", CurrentProcess, proc_currentName()); + ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); + + /* Sleeping with IRQs disabled or preemption forbidden is illegal */ + ASSERT_IRQ_ENABLED(); + ASSERT(preempt_forbid_cnt == 0); + + // Will invoke proc_preempt() in interrupt context kill(0, SIGUSR1); } void proc_yield(void) { - ATOMIC(SCHED_ENQUEUE(CurrentProcess)); + TRACEMSG("%p:%s", CurrentProcess, proc_currentName()); + + IRQ_DISABLE; + SCHED_ENQUEUE(CurrentProcess); + IRQ_ENABLE; proc_schedule(); } -/* signal handler */ -void irq_entry(int signum) +void proc_entry(void (*user_entry)(void)) { - Process *old_process; - - TRACEMSG("storing %p:%s", CurrentProcess, CurrentProcess->monitor.name); - CurrentProcess->leaving = false; - getcontext(&CurrentProcess->context); - /* We get here in two ways: directly, and after setcontext() below */ - - if (CurrentProcess->leaving) - { - TRACEMSG("leaving to %p:%s", CurrentProcess, CurrentProcess->monitor.name); - return; - } - - old_process = CurrentProcess; - - irq_handlers[signum](); - - if (old_process != CurrentProcess) - { - TRACEMSG("launching %p:%s", CurrentProcess, CurrentProcess->monitor.name); - CurrentProcess->leaving = true; - setcontext(&CurrentProcess->context); - /* not reached */ - } - - TRACEMSG("keeping %p:%s", CurrentProcess, CurrentProcess->monitor.name); + user_entry(); + proc_exit(); } void preempt_init(void) { - struct sigaction act; - act.sa_handler = irq_entry; - sigemptyset(&act.sa_mask); - sigaddset(&act.sa_mask, SIGUSR1); - sigaddset(&act.sa_mask, SIGALRM); - act.sa_flags = SA_RESTART; /* | SA_SIGINFO; */ - - irq_handlers[SIGUSR1] = proc_preempt; - irq_handlers[SIGALRM] = proc_preempt_timer; - sigaction(SIGUSR1, &act, NULL); - sigaction(SIGALRM, &act, NULL); - - alarm(1); + MOD_CHECK(irq); + MOD_CHECK(timer); + + irq_register(SIGUSR1, proc_preempt); + + timer_setSoftint(&preempt_timer, proc_preempt_timer, NULL); + timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM); + timer_add(&preempt_timer); + + idle_init(); }