X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Fkern%2Fpreempt.c;h=4b1ad9ee2d5dea8e213570eeb1c59fc400290fa6;hb=e62ca0b357f09804d7d894949df44224c9d74bb7;hp=dfa343d7a9b702c769a590d8b76e0a409bdec9e2;hpb=0315f64ec2ee2c5eb10634360fb8874c52dbbabf;p=bertos.git diff --git a/bertos/kern/preempt.c b/bertos/kern/preempt.c index dfa343d7..4b1ad9ee 100644 --- a/bertos/kern/preempt.c +++ b/bertos/kern/preempt.c @@ -26,161 +26,140 @@ * 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. + * + * All voluntary and preemptive context switching happens on exit from + * a common interrupt (signal) dispatcher. Preemption on quantum timeout + * is regulated by a soft-timer. Other kinds of preemption could happen + * if an interrupt sends a signal to a higher priority process (but this + * is still unimplemented). + * + * In the POSIX implementaiton, context switching is done by the portable + * SVR4 swapcontext() facility. * * \version $Id: proc.c 1616 2008-08-10 19:41:26Z bernie $ * \author Bernie Innocenti - * \author Stefano Fedrigo */ +#include + +#if CONFIG_KERN_PREEMPT + #include "proc_p.h" #include "proc.h" +#include "idle.h" +#include +#include #include // CPU_IDLE +#include // IRQ_DISABLE()... +#include +#include +#include // CONFIG_DEPEND() -#include // XXX alarm() +// Check config dependencies +CONFIG_DEPEND(CONFIG_KERN_PREEMPT, CONFIG_KERN_SCHED && CONFIG_TIMER_EVENTS && CONFIG_KERN_IRQ); +MOD_DEFINE(preempt) -/* - * The time sharing scheduler forces a task switch when the current - * process has exhausted its quantum. - */ -uint16_t Quantum; +/// Global preemption disabling nesting counter +cpu_atomic_t _preempt_forbid_cnt; -/** - * 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; -} +static Timer preempt_timer; -/** - * Re-enable preemptive task switching. - * - * \sa proc_forbid() - */ -void proc_permit(void) + +void proc_schedule(void) { - /* No need to protect against interrupts here. */ - --CurrentProcess->forbid_cnt; -} + IRQ_DISABLE; -static void (*irq_handlers[100])(void); // FIXME + ASSERT(proc_allowed()); + LIST_ASSERT_VALID(&ProcReadyList); + CurrentProcess = (struct Process *)list_remHead(&ProcReadyList); + ASSERT2(CurrentProcess, "no idle proc?"); + IRQ_ENABLE; -void proc_preempt(void) + TRACEMSG("launching %p:%s", CurrentProcess, proc_currentName()); +} + +void proc_preempt(UNUSED_ARG(void *, param)) { - TRACE; + if (proc_allowed()) + { + IRQ_DISABLE; - ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); + #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()); + +// FIXME: this still breaks havoc, probably because of some reentrancy issue +#if 0 + SCHED_ENQUEUE(CurrentProcess); + proc_schedule(); +#endif + #if CONFIG_KERN_PRI + } + #endif - 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; + + timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM); + timer_add(&preempt_timer); } -void proc_preempt_timer(void) +void proc_switch(void) { - // TODO: check Quantum + ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); + TRACEMSG("%p:%s", CurrentProcess, proc_currentName()); + ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); - alarm(1); - ATOMIC(SCHED_ENQUEUE(CurrentProcess)); - proc_schedule(); -} + /* Sleeping with IRQs disabled or preemption forbidden is illegal */ + IRQ_ASSERT_ENABLED(); + ASSERT(proc_allowed()); -void proc_schedule(void) -{ + // Will invoke proc_switch() in interrupt context kill(0, SIGUSR1); } void proc_yield(void) { - ATOMIC(SCHED_ENQUEUE(CurrentProcess)); + TRACEMSG("%p:%s", CurrentProcess, proc_currentName()); - proc_schedule(); + IRQ_DISABLE; + SCHED_ENQUEUE(CurrentProcess); + IRQ_ENABLE; + + proc_switch(); } -/* 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 */ + user_entry(); + proc_exit(); +} - if (CurrentProcess->leaving) - { - TRACEMSG("leaving to %p:%s", CurrentProcess, CurrentProcess->monitor.name); - return; - } +void preempt_init(void) +{ + MOD_CHECK(irq); + MOD_CHECK(timer); - old_process = CurrentProcess; + irq_register(SIGUSR1, proc_schedule); - irq_handlers[signum](); + timer_setSoftint(&preempt_timer, proc_preempt, NULL); + timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM); + timer_add(&preempt_timer); - if (old_process != CurrentProcess) - { - TRACEMSG("launching %p:%s", CurrentProcess, CurrentProcess->monitor.name); - CurrentProcess->leaving = true; - setcontext(&CurrentProcess->context); - /* not reached */ - } + idle_init(); - TRACEMSG("keeping %p:%s", CurrentProcess, CurrentProcess->monitor.name); + MOD_INIT(preempt); } -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); // FIXME -} +#endif // CONFIG_KERN_PREEMPT