X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Fkern%2Fpreempt.c;h=4b1ad9ee2d5dea8e213570eeb1c59fc400290fa6;hb=ebd302f4820855188df16ee8422a947751bf2c50;hp=339dc09fe089e8e00e7e38b5e77c04a412f22016;hpb=7aba26c4dd422016f6c27db30f6eaa686b87fd7e;p=bertos.git diff --git a/bertos/kern/preempt.c b/bertos/kern/preempt.c index 339dc09f..4b1ad9ee 100644 --- a/bertos/kern/preempt.c +++ b/bertos/kern/preempt.c @@ -29,125 +29,115 @@ * 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 */ +#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() +// Check config dependencies +CONFIG_DEPEND(CONFIG_KERN_PREEMPT, CONFIG_KERN_SCHED && CONFIG_TIMER_EVENTS && CONFIG_KERN_IRQ); -/* - * The time sharing scheduler forces a task switch when the current - * process has exhausted its quantum. - */ -uint16_t Quantum; - -Timer preempt_timer; +MOD_DEFINE(preempt) -/** - * 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; -} +/// Global preemption disabling nesting counter +cpu_atomic_t _preempt_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_allowed()); + 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(UNUSED_ARG(void *, param)) +void proc_preempt(UNUSED_ARG(void *, param)) { - IRQ_DISABLE; - if (CurrentProcess) + if (proc_allowed()) { - TRACEMSG("preempting %p:%s", CurrentProcess, CurrentProcess->monitor.name); + IRQ_DISABLE; + + #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_ENABLE; - proc_preempt(); } - 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_allowed()); + + // 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)) @@ -156,63 +146,20 @@ void proc_entry(void (*user_entry)(void)) proc_exit(); } -/* signal handler */ -void irq_entry(int signum) +void preempt_init(void) { - Process * const old_process = CurrentProcess; + MOD_CHECK(irq); + MOD_CHECK(timer); - irq_handlers[signum](); + irq_register(SIGUSR1, proc_schedule); - if (!CurrentProcess) - { - TRACEMSG("no runnable processes!"); - IRQ_ENABLE; - pause(); - } - else - { - if (old_process != CurrentProcess) - { - TRACEMSG("switching from %p:%s to %p:%s", - old_process, old_process ? old_process->monitor.name : "-", - CurrentProcess, CurrentProcess->monitor.name); - - if (old_process) - swapcontext(&old_process->context, &CurrentProcess->context); - else - setcontext(&CurrentProcess->context); - - /* not reached */ - } - TRACEMSG("keeping %p:%s", CurrentProcess, CurrentProcess->monitor.name); - } -} + timer_setSoftint(&preempt_timer, proc_preempt, NULL); + timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM); + timer_add(&preempt_timer); -void irq_register(int irq, void (*callback)(void)) -{ - irq_handlers[irq] = callback; -} + idle_init(); -void irq_init(void) -{ - struct sigaction act; - act.sa_handler = irq_entry; - sigemptyset(&act.sa_mask); - //sigaddset(&act.sa_mask, irq); - act.sa_flags = SA_RESTART; /* | SA_SIGINFO; */ - - sigaction(SIGUSR1, &act, NULL); - #if !(ARCH & ARCH_QT) - sigaction(SIGALRM, &act, NULL); - #endif + MOD_INIT(preempt); } -void preempt_init(void) -{ - irq_init(); // FIXME: move before - irq_register(SIGUSR1, proc_preempt); - - timer_setSoftInt(&preempt_timer, proc_preempt_timer, NULL); - timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM); - timer_add(&preempt_timer); -} +#endif // CONFIG_KERN_PREEMPT