X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Fkern%2Fpreempt.c;h=756a38fe0b89d1073b0c4585f8b702050877901a;hb=40c25a4b1d0f1c23478c2d681b74662de968f671;hp=dfa343d7a9b702c769a590d8b76e0a409bdec9e2;hpb=0315f64ec2ee2c5eb10634360fb8874c52dbbabf;p=bertos.git diff --git a/bertos/kern/preempt.c b/bertos/kern/preempt.c index dfa343d7..756a38fe 100644 --- a/bertos/kern/preempt.c +++ b/bertos/kern/preempt.c @@ -26,161 +26,132 @@ * 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; +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) +void proc_preempt(void) { - /* No need to protect against interrupts here. */ - --CurrentProcess->forbid_cnt; -} + IRQ_DISABLE; -static void (*irq_handlers[100])(void); // FIXME + LIST_ASSERT_VALID(&ProcReadyList); + CurrentProcess = (struct Process *)list_remHead(&ProcReadyList); + LIST_ASSERT_VALID(&ProcReadyList); + ASSERT2(CurrentProcess, "no idle proc?"); + IRQ_ENABLE; -void proc_preempt(void) -{ - TRACE; + TRACEMSG("new proc: %p:%s", CurrentProcess, CurrentProcess ? CurrentProcess->monitor.name : "---"); + monitor_report(); +} - ATOMIC(LIST_ASSERT_VALID(&ProcReadyList)); +void proc_preempt_timer(UNUSED_ARG(void *, param)) +{ + /* Abort if task preemption is disabled */ + if (preempt_forbid_cnt) + return; IRQ_DISABLE; - /* Poll on the ready queue for the first ready process */ - while (!(CurrentProcess = (struct Process *)list_remHead(&ProcReadyList))) +/* + if (!CurrentProcess->forbid_cnt) { - /* - * 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; + TRACEMSG("preempting %p:%s", CurrentProcess, CurrentProcess->monitor.name); + SCHED_ENQUEUE(CurrentProcess); + proc_preempt(); } +*/ IRQ_ENABLE; -} -void proc_preempt_timer(void) -{ - // TODO: check Quantum - - alarm(1); - ATOMIC(SCHED_ENQUEUE(CurrentProcess)); - proc_schedule(); + 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; - } + user_entry(); + proc_exit(); +} - old_process = CurrentProcess; - irq_handlers[signum](); +static cpustack_t idle_stack[CONFIG_PROC_DEFSTACKSIZE / sizeof(cpustack_t)]; - if (old_process != CurrentProcess) +// FIXME: move this to kern/idle.c +/** + * The idle process + * + * This process never dies and never sleeps. It's also quite lazy, apathic + * and a bit antisocial. + * + * Having an idle process costs some stack space, but simplifies the + * interrupt-driven preemption logic because there is always a user + * context to which we can return. + */ +static NORETURN void idle(void) +{ + for (;;) { - TRACEMSG("launching %p:%s", CurrentProcess, CurrentProcess->monitor.name); - CurrentProcess->leaving = true; - setcontext(&CurrentProcess->context); - /* not reached */ + TRACE; + //monitor_report(); + proc_yield(); // FIXME: CPU_IDLE } - - TRACEMSG("keeping %p:%s", CurrentProcess, CurrentProcess->monitor.name); } 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 + 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); + + proc_new(idle, NULL, sizeof(idle_stack), idle_stack); }