X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Fkern%2Fpreempt.c;h=48a1278ebffa7b0d6df4937a417d2c08eb82b3bf;hb=cf5af2b25de263a964bf29a7465cdfe536d32e59;hp=ab3fc7a8f7db005e5f1e3f2c8623b8647a6a737e;hpb=57da5b0bdc06a8a69c740616f145cb9fe28f8c9f;p=bertos.git diff --git a/bertos/kern/preempt.c b/bertos/kern/preempt.c index ab3fc7a8..48a1278e 100644 --- a/bertos/kern/preempt.c +++ b/bertos/kern/preempt.c @@ -26,127 +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 $ + * 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$ * \author Bernie Innocenti - * \author Stefano Fedrigo */ +#include "cfg/cfg_proc.h" + +#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 && 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; -} - -/** - * 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 +static Timer preempt_timer; -void proc_preempt(void) +void proc_schedule(void) { - TRACE; + IRQ_DISABLE; - ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); + ASSERT(proc_preemptAllowed()); + LIST_ASSERT_VALID(&ProcReadyList); + CurrentProcess = (struct Process *)list_remHead(&ProcReadyList); + ASSERT2(CurrentProcess, "no idle proc?"); - TRACEMSG("hello1"); - IRQ_DISABLE; - /* Poll on the ready queue for the first ready process */ - while (!(CurrentProcess = (struct Process *)list_remHead(&ProcReadyList))) - { - TRACEMSG("hello2"); - /* - * 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; - //FIXME: calls Qt stuff from sighandler! CPU_IDLE; - MEMORY_BARRIER; - IRQ_DISABLE; - TRACEMSG("hello3"); - } IRQ_ENABLE; - TRACEMSG("hello4"); + + TRACEMSG("launching %p:%s", CurrentProcess, proc_currentName()); } -void proc_preempt_timer(void) +void proc_preempt(UNUSED_ARG(void *, param)) { - // TODO: check Quantum + if (proc_preemptAllowed()) + { + IRQ_DISABLE; - alarm(1); + #if CONFIG_KERN_PRI + Process *rival = (Process *)LIST_HEAD(&ProcReadyList); + if (rival && rival->link.pri >= CurrentProcess->link.pri) + { + #endif - if (CurrentProcess) - { - TRACEMSG("preempting %p:%s", CurrentProcess, CurrentProcess->monitor.name); - ATOMIC(SCHED_ENQUEUE(CurrentProcess)); + 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_ENABLE; } + + timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM); + timer_add(&preempt_timer); } -void proc_schedule(void) +void proc_switch(void) { - TRACE; + ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); + TRACEMSG("%p:%s", CurrentProcess, proc_currentName()); + ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); - // Will invoke proc_preempt() in interrupt context + /* Sleeping with IRQs disabled or preemption forbidden is illegal */ + IRQ_ASSERT_ENABLED(); + ASSERT(proc_preemptAllowed()); + + // Will invoke proc_switch() 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(); + proc_switch(); } void proc_entry(void (*user_entry)(void)) @@ -155,54 +146,20 @@ void proc_entry(void (*user_entry)(void)) proc_exit(); } -/* signal handler */ -void irq_entry(int signum) +void preempt_init(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 */ + MOD_CHECK(irq); + MOD_CHECK(timer); -// if (CurrentProcess->leaving) -// { -// TRACEMSG("leaving to %p:%s", CurrentProcess, CurrentProcess->monitor.name); -// return; -// } + irq_register(SIGUSR1, proc_schedule); - old_process = CurrentProcess; + timer_setSoftint(&preempt_timer, proc_preempt, NULL); + timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM); + timer_add(&preempt_timer); - irq_handlers[signum](); + idle_init(); - if (old_process != CurrentProcess) - { - TRACEMSG("switching from %p:%s to %p:%s", - old_process, old_process->monitor.name, - CurrentProcess, CurrentProcess->monitor.name); - swapcontext(&old_process->context, &CurrentProcess->context); -// TRACEMSG("launching %p:%s", CurrentProcess, CurrentProcess->monitor.name); -// CurrentProcess->leaving = true; -// setcontext(&CurrentProcess->context); - /* not reached */ - } - - 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