preempt.c

Go to the documentation of this file.

#include "cfg/cfg_proc.h"

#include "proc_p.h"
#include "proc.h"

#include <kern/irq.h>
#include <kern/monitor.h>
#include <cpu/frame.h> // CPU_IDLE
#include <cpu/irq.h>   // IRQ_DISABLE()...
#include <cfg/log.h>
#include <cfg/module.h>
#include <cfg/depend.h>    // CONFIG_DEPEND()

// Check config dependencies
CONFIG_DEPEND(CONFIG_KERN_PREEMPT, CONFIG_KERN);

MOD_DEFINE(preempt)

/* Global preemption nesting counter */
cpu_atomic_t preempt_count;

/*
 * The time sharing interval: when a process is scheduled on a CPU it gets an
 * amount of CONFIG_KERN_QUANTUM clock ticks. When these ticks expires and
 * preemption is enabled a new process is selected to run.
 */
int _proc_quantum;

void preempt_yield(void);
int preempt_needPreempt(void);
void preempt_preempt(void);
void preempt_switch(void);
void preempt_wakeup(Process *proc);
void preempt_init(void);

static void preempt_schedule(void)
{
    _proc_quantum = CONFIG_KERN_QUANTUM;
    proc_schedule();
}

int preempt_needPreempt(void)
{
    if (UNLIKELY(current_process == NULL))
        return 0;
    if (!proc_preemptAllowed())
        return 0;
    return _proc_quantum ? prio_next() > prio_curr() :
            prio_next() >= prio_curr();
}

void preempt_preempt(void)
{
    IRQ_ASSERT_DISABLED();
    ASSERT(current_process);

    /* Perform the kernel preemption */
    LOG_INFO("preempting %p:%s\n", current_process, proc_currentName());
    /* We are inside a IRQ context, so ATOMIC is not needed here */
    SCHED_ENQUEUE(current_process);
    preempt_schedule();
}

void preempt_switch(void)
{
    ASSERT(proc_preemptAllowed());

    ATOMIC(preempt_schedule());
}

void preempt_wakeup(Process *proc)
{
    ASSERT(proc_preemptAllowed());
    ASSERT(current_process);
    IRQ_ASSERT_DISABLED();

    if (prio_proc(proc) >= prio_curr())
    {
        Process *old_process = current_process;

        SCHED_ENQUEUE(current_process);
        _proc_quantum = CONFIG_KERN_QUANTUM;
        current_process = proc;
        proc_switchTo(current_process, old_process);
    }
    else
        SCHED_ENQUEUE_HEAD(proc);
}

void preempt_yield(void)
{
    /*
     * Voluntary preemption while preemption is disabled is considered
     * illegal, as not very useful in practice.
     *
     * ASSERT if it happens.
     */
    ASSERT(proc_preemptAllowed());
    IRQ_ASSERT_ENABLED();

    ATOMIC(
        SCHED_ENQUEUE(current_process);
        preempt_schedule();
    );
}

void preempt_init(void)
{
    MOD_INIT(preempt);
}