Subversion Repositories shark

/*

 * Project: S.Ha.R.K.

 *

 * Coordinators:

 *   Giorgio Buttazzo    <giorgio@sssup.it>

 *   Paolo Gai           <pj@gandalf.sssup.it>

 *

 * Authors     :

 *   Paolo Gai           <pj@gandalf.sssup.it>

 *   Massimiliano Giorgi <massy@gandalf.sssup.it>

 *   Luca Abeni          <luca@gandalf.sssup.it>

 *   (see the web pages for full authors list)

 *

 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)

 *

 * http://www.sssup.it

 * http://retis.sssup.it

 * http://shark.sssup.it

 */

/**

 ------------

 CVS :        $Id: slsh.c,v 1.5 2003-12-17 13:52:47 giacomo Exp $

 File:        $File$

 Revision:    $Revision: 1.5 $

 Last update: $Date: 2003-12-17 13:52:47 $

 ------------

 This file contains the scheduling module for Slot-Shifting.

 Read slsh.h for further details.

**/

/*

 * Copyright (C) 2000 Paolo Gai

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "slsh.h"

#include <ll/stdio.h>

#include <ll/stdlib.h>

#include <ll/string.h>

#include <ll/math.h>    /* for ceil(...) */

#include <ll/ll.h>      /* for memcpy(...) */

#include <kernel/model.h>

#include <kernel/descr.h>

#include <kernel/var.h>

#include <kernel/func.h>

//#define eslsh_printf kern_printf

#define slsh_printf printk

/* Keeps information about static and guaranteed tasks */

typedef struct {

        int est;

        int dabs;

        int interval;

} SLSH_task;

/*+ Status used in the level +*/

#define SLSH_READY                      MODULE_STATUS_BASE

#define SLSH_WAIT                       MODULE_STATUS_BASE + 1

#define SLSH_IDLE                       MODULE_STATUS_BASE + 2

#define SLSH_WCET_VIOLATED      MODULE_STATUS_BASE + 3

/*+ defines +*/

#define MAX_INTERVALS 1000              /* 1000 intervals is max, for now */

/******+ the level redefinition for the SLOT SHIFT level +*******/

typedef struct {

        level_des l;                    /*+ the standard level descriptor+*/

        /* task lists */

        SLSH_task tasks[MAX_PROC];  /* est and dl's for static and guaranteed task */

        IQUEUE idle_statics; /* finished static tasks */

        IQUEUE unspecified;     /* tasks with only a wcet */

        /* the Intervals list */

        SLSH_interval intervals[MAX_INTERVALS];

        int current;                    /* current interval */

        int last;                       /* last interval */

        int slot;                       /* slot shifting time */

        TIME slot_length;       /* slothlength in real system time*/

        int LCM;                        /* length (in slots) of ofline schedule */

        int slot_event;         /* save the event */

} SLSH_level_des;

/* check if some tasks are ready, return 0 if ready, -1 otherwise */

static int SLSH_R(SLSH_task* tasks)

{

        int s;

        /* for all static tasks */

        for(s = 0; tasks[s].est != -1; ++s)

        {

           if(proc_table[s].status == SLSH_READY)

               return 0;

        }

        return -1;

}

/* check if unspecified exists, return 0 if it exists, -1 otherwise */

static int SLSH_T(IQUEUE *unspecified)

{

        if(!iq_isempty(unspecified))

                return 0;

        else

                return -1;

}

/* return the sc in an interval */

static int SLSH_sc(SLSH_interval* intervals, int i)

{

        return intervals[i].sc;

}

/* return a static task from current interval or a guaranted task */

static PID SLSH_staticOrGuaranteed(SLSH_level_des* lev)

{

        int lowest_dl = 0;      /* lowest dl found */

        PID pid = 0;            /* static or guaranteed task */

        int t;

        /* Decide according to EDF, go through all static & guaranteed tasks */

        for(t = 0; t < MAX_PROC; ++t)

        {

                /* static tasks */

                if(proc_table[t].pclass == STATIC_PCLASS)

                {

                        /* static task must belong to current interval */

                        if(lev->tasks[t].interval == lev->current)

                        {

                                /* only ready tasks */

                                if(proc_table[t].status == SLSH_READY)

                                {

                                        /* a new lower dl was found */

                                        if(lev->tasks[t].dabs < lowest_dl)

                                        {

                                                lowest_dl = lev->tasks[t].dabs;

                                                pid = t;

                                        }

                                }

                        }

                } /* guaranteed tasks */

                else if(proc_table[t].pclass == HARD_PCLASS)

                {

                        /* only ready tasks */

                        if(proc_table[t].status == SLSH_READY)

                        {

                                /* a new lower dl was found */

                                if(lev->tasks[t].dabs < lowest_dl)

                                {

                                        lowest_dl = lev->tasks[t].dabs;

                                        pid = t;

                        }

                        }

                }

        }/* for all tasks */

        return pid;    

}

/* return a static task among the candidates, all ready statics */

static PID SLSH_candidates(SLSH_task* tasks)

{

        int lowest_dl = 0;

        PID pid = -1;

        int t;

        /* Use the EDL algorithm again to decide which task to run */

        for(t = 0; t < MAX_PROC; ++t)

        {

                /* only static tasks */

                if(proc_table[t].pclass == STATIC_PCLASS)

                {

                        /* only ready tasks */

                        if(proc_table[t].status == SLSH_READY)

                        {      

                                /* a new lower dl was found */

                                if(tasks[t].dabs < lowest_dl)

                                {

                                        lowest_dl = tasks[t].dabs;

                                        pid = t;

                                }

                        }/* all ready tasks */

                }/* all static tasks */

        }/* for all tasks */

        return pid;

}

/* decrease the sc in a interval by amount */

void SLSH_decSc(SLSH_interval* intervals, int i, int amount)

{

        intervals[i].sc -= amount;

}

void SLSH_incSc(SLSH_interval* intervals, int i, int amount)

{

        intervals[i].sc += amount;

}

/* swap the sc between intervals, also consider intervals with negative sc */

void SLSH_swapSc(SLSH_interval* intervals, int current, int task_interval)

{

        /* decrease the sc in the current interval */

        SLSH_decSc(intervals, current, 1);

        /* update the other interval(s) */

        if(intervals[task_interval].sc < 0)     /* negative sc */

        {

                /* special case, increase next interval sc by 1 and also current interval (borrowing) */

                if(task_interval == current + 1)

                {

                        SLSH_incSc(intervals, task_interval, 1);

                        SLSH_incSc(intervals, current, 1);

                }

                else /* increase every interval sc that is negative between current and task_interval */

                {

                        while(task_interval > current && intervals[task_interval].sc < 0)

                        {

                                SLSH_incSc(intervals, task_interval, 1);

                                task_interval--;

                        }

                }

        }

        else /* ordinary swapping */

                SLSH_incSc(intervals, task_interval, 1);

}

/* The scheduler, decides which task to run. */

static PID SLSH_public_scheduler(LEVEL l)

{

        SLSH_level_des* lev = (SLSH_level_des *)(level_table[l]);

        PID pid;

        /* The scheduler choses among static, guaranteed (hard aperiodic) and

             unspecified (soft aperiodic) tasks */

        /* no ready tasks and no sc, execute idle task */

        if(SLSH_R(lev->tasks) == 0 && SLSH_sc(lev->intervals, lev->current) == 0)

                return NIL;

        /* must execute a static from current intervall or a guaranteed task */

        else if(SLSH_R(lev->tasks) > 0 && SLSH_sc(lev->intervals, lev->current) == 0)

                return SLSH_staticOrGuaranteed(lev);

        /* sc available... */

        else if(SLSH_R(lev->tasks) > 0 && SLSH_sc(lev->intervals, lev->current) > 0)

        {

                /* If unspecified exist, execute it according to FIFO order */

                if(SLSH_T(&lev->unspecified) == 0)

                {

                        SLSH_decSc(lev->intervals, lev->current, 1);    /* decrease sc by 1 */

                        return iq_getfirst(&lev->unspecified);

                }

                else /* No unspecified, execute task from candidates (statics) */

                {              

                        pid = SLSH_candidates(lev->tasks);

                        /* sc needs to be swapped */

                        if(lev->tasks[pid].interval != lev->current)

                                SLSH_swapSc(lev->intervals, lev->tasks[pid].interval, lev->current);

                        return pid;            

                }              

        }

        kern_printf("(SLSH s)");

        return NIL;

}

/* not used, slot-shifting handles all guarantees itself, it handles all bandwidth */

static int SLSH_public_guarantee(LEVEL l, bandwidth_t *freebandwidth)

{

        *freebandwidth = 0;

        return 1;

}

/* get the interval that x is in */

static int SLSH_getInterval(SLSH_interval* intervals, int x, int last)

{

        int i;

        /* search through the intervals  */

        for(i = 0; i <= last; ++i)

        {

                /* I is in the interval where start is smaller or equal and end is bigger */           

                if(intervals[i].start <= x && x < intervals[i].end)

                        return i;

        }

        return -1;

}

/* get the start of the interval I */

static int SLSH_intervalStart(SLSH_interval* intervals, int I)

{

        return intervals[I].start;

}

/* split interval I into two parts, slow because of copying. OBS!!! no check if there is

    enough space in the intervals array */

static void SLSH_splitInterval(SLSH_level_des* lev, int I, int dabs)

{

        SLSH_interval left_interval;

        int i;

        lev->last++;

        /* move every interval above and including I */

        for(i = lev->last; i > I; --i)

                memcpy(&lev->intervals[i], &lev->intervals[i - 1], sizeof(SLSH_interval));

        /* Left interval start, end and length */

        left_interval.start = lev->intervals[I].start;

        left_interval.end = dabs;

        left_interval.length = left_interval.end - left_interval.start;

        /* Right interval (uses old interval struct) start and length end remains as the old value */

        lev->intervals[I + 1].start = dabs;

        lev->intervals[I + 1].length = lev->intervals[I + 1].end - lev->intervals[I + 1].start;

        /* check if sc still exists in the right interval */

        if(lev->intervals[I + 1].length - lev->intervals[I + 1].maxt > 0)

        {

                lev->intervals[I + 1].sc = lev->intervals[I + 1].length - lev->intervals[I + 1].maxt;

                left_interval.sc = left_interval.length; /* the whole interval is free, for now... */

        }

        else /* no sc in the right interval */

        {

                lev->intervals[I + 1].maxt = lev->intervals[I + 1].length;

                left_interval.sc = lev->intervals[I + 1].sc; /* all sc in left interval */

                lev->intervals[I + 1].sc = 0;

        }        

        /* insert the new interval */

        memcpy(&lev->intervals[I], &left_interval, sizeof(SLSH_interval));

}

/* Reduce the sc from back to front by the wcet amount, interval splitting may be neccesary */

static void SLSH_updateSc(SLSH_level_des* lev, HARD_TASK_MODEL* h)

{

        int dabs = ceil((lev->slot + h->drel)/lev->slot_length); /* absolute deadline of request */

        int dabs_interval = SLSH_getInterval(lev->intervals, dabs, lev->last); /* interval where dabs is */

        int C = ceil(h->wcet/lev->slot_length); /* amount of sc to reduce */   

        int sc = 0;

        int i;

        /* check if interval splitting is neccesary */

        if(lev->intervals[dabs_interval].end != dabs)

                SLSH_splitInterval(lev, dabs_interval, dabs);

        /* decrease sc in all intervals that are neccesary from dabs_interval o current */

        for(i = dabs_interval; i >= lev->current && C > 0; --i)

        {

                if((sc = SLSH_sc(lev->intervals, i)) >= 0) /* only decrease where sc exists */

                {

                        if(sc > C) /* the last sc dec */

                        {

                                SLSH_decSc(lev->intervals, i, C);

                                C = 0;

                        }

                        else    /* to little sc in this interval, decrease it to 0 */

                        {

                                C -= SLSH_sc(lev->intervals, i);

                                SLSH_decSc(lev->intervals, i, SLSH_sc(lev->intervals, i));

                        }              

                }

        }/* for all intervals */

}

/* the guarantee algorithm for hard aperiodic requests */

static int SLSH_guarantee(SLSH_level_des* lev, HARD_TASK_MODEL* h)

{

        int total_sc = 0;

        int temp, i;

        int dabs = ceil((lev->slot + h->drel)/lev->slot_length); /* absolute deadline of request */

        int dabs_interval = SLSH_getInterval(lev->intervals, dabs, lev->last); /* interval where dabs is */

        /* check if the sc up until request deadline is >= request wcet */

        /* 1. the sc of the current interal */

        total_sc = SLSH_sc(lev->intervals, lev->current);

        /* 2. the sc for all whole intervals between current and the interval

            with the request deadline */

        for(i = (lev->current) + 1; i < dabs_interval; ++i)

        {

                if((temp = SLSH_sc(lev->intervals, i)) > 0)

                        total_sc += temp;

        }

        /* 3. the min of sc or the execution need in the last interval */

        total_sc += min(SLSH_sc(lev->intervals, dabs_interval),

                                dabs - SLSH_intervalStart(lev->intervals,

                                dabs_interval));

        if(total_sc >= h->wcet)

        {       /* update the sc in the intervals from back to front */

                SLSH_updateSc(lev, h);

                return 0;

        }

        else

                return -1;

}

/* check if task model is accepted and store nessecary parameters */

static int SLSH_public_create(LEVEL l, PID p, TASK_MODEL *m)

{

        SLSH_level_des *lev = (SLSH_level_des *)(level_table[l]);

        STATIC_TASK_MODEL* s;

        HARD_TASK_MODEL* h;

        SOFT_TASK_MODEL* u;

        /* Check the models */

        switch(m->pclass)

        {

        case STATIC_PCLASS:             /* offline scheduled tasks */

          break;

        case HARD_PCLASS:               /* hard aperiodic tasks */

          h = (HARD_TASK_MODEL *) m;

          if (h->drel == 0 || h->wcet == 0)     /* must be set */

            return -1;

          break;

        case SOFT_PCLASS:               /* soft aperiodic tasks */

          u = (SOFT_TASK_MODEL *) m;

          if(u->wcet == 0)              /* must be set */

            return -1;

          break;

        default:

          return -1;

        }

        /* if the SLSH_task_create is called, then the pclass must be a

        valid pclass. Slot-shifting accepts STATIC_TASK, HARD_TASK

        and SOFT_TASK models with some restrictions */

        /* est, dl and wcet is saved in slotlengths */

        switch(m->pclass)

        {      

                case STATIC_PCLASS:     /* offline scheduled tasks */

                        s = (STATIC_TASK_MODEL *) m;

                        lev->tasks[p].est = ceil(s->est/lev->slot_length);             

                        lev->tasks[p].dabs = ceil(s->dabs/lev->slot_length);

                        lev->tasks[p].interval = s->interval;

                        proc_table[p].avail_time = s->wcet;                    

                        proc_table[p].wcet = s->wcet;

                        break;

                case HARD_PCLASS:       /* hard aperiodic tasks */

                        h = (HARD_TASK_MODEL *) m;

                        if(SLSH_guarantee(lev, h) == 0)

                        {

                                /* convert drel to dabs */                     

                                lev->tasks[p].dabs = ceil((lev->slot + h->drel)/lev->slot_length);

                                proc_table[p].avail_time = h->wcet;

                                proc_table[p].wcet = h->wcet;

                        }

                        else /* task not guaranteed */

                                return -1;                     

                        break;

                case SOFT_PCLASS:

                        u = (SOFT_TASK_MODEL *) m;

                        proc_table[p].avail_time = u->wcet;

                        proc_table[p].wcet = u->wcet;

                        iq_insertlast(p, &lev->unspecified);    /* respect FIFO order */

                        break;

                default:        /* a task model not supported */

                        return -1;

        }

        /* enable wcet check in the kernel */

        proc_table[p].control |= CONTROL_CAP;

        return 0;

}

/************* The slot end event handler *************/

static void SLSH_slot_end(void* p)

{

        SLSH_level_des* lev = (SLSH_level_des *) p;

        PID pid;

        int i;

        /* increase slot "time" by 1 */

        if(lev->slot < lev->LCM)

        {

                lev->slot++;

                /* check if new statics are ready */

                for(i = 0; lev->tasks[i].interval != -1; ++i)

                {

                        if(lev->tasks[i].est <= lev->slot && proc_table[i].status == SLSH_WAIT)

                                proc_table[i].status = SLSH_READY;

                }

                /* check if current (interval) needs updating */

                if(lev->current < SLSH_getInterval(lev->intervals, lev->slot, lev->last))

                        lev->current++;

        }

        else /* restart from the beginning of the offline schedule */

        {

                lev->slot = 0;

                while((pid = iq_getfirst(&lev->idle_statics)) != NIL)

                {

                        if(lev->tasks[pid].est <= lev->slot)

                                proc_table[pid].status = SLSH_READY;

                        else

                                proc_table[pid].status = SLSH_WAIT;

                }

        }

        /* call for a rescheduling, reset event flag and increase slot by 1  */

        lev->slot_event = -1;

        kern_printf("*");

        event_need_reschedule();

}

/* when a task becomes executing (EXE status) */

static void SLSH_public_dispatch(LEVEL l, PID pid, int nostop)

{

        SLSH_level_des *lev = (SLSH_level_des *)(level_table[l]);

        struct timespec t;

        /* the task state is set EXE by the scheduler()

        we extract the task from the unspecified queue.

        NB: we can't assume that p is the first task in the queue!!! */

        if(proc_table[pid].pclass == SOFT_PCLASS)

                iq_extract(pid, &lev->unspecified);

        /* also start the timer for one slot length */

        lev->slot_event = kern_event_post(&TIME2TIMESPEC(lev->slot_length, t),

                                          SLSH_slot_end, (void*) lev);

}

/* called when task is moved from EXE status */

static void SLSH_public_epilogue(LEVEL l, PID pid)

{

        SLSH_level_des *lev = (SLSH_level_des *)(level_table[l]);

        /* check if the wcet is finished... */

        if (proc_table[pid].avail_time <= 0)

        {

                /* if it is, raise a XWCET_VIOLATION exception */

                kern_raise(XWCET_VIOLATION, pid);

                proc_table[pid].status = SLSH_WCET_VIOLATED;

        }

        else /* the end of a slot. the task returns into the ready queue... */

        {

                if(proc_table[pid].pclass == SOFT_PCLASS)

                        iq_insertfirst(pid,&lev->unspecified);

                proc_table[pid].status = SLSH_READY;

        }

}

/* when task go from SLEEP to SLSH_READY or SLSH_WAIT */

static void SLSH_public_activate(LEVEL l, PID pid)

{

        SLSH_level_des *lev = (SLSH_level_des *)(level_table[l]);

        WORD type = proc_table[pid].pclass;

        /* Test if we are trying to activate a non sleeping task    */

        /* Ignore this; the task is already active                  */

        if (proc_table[pid].status != SLEEP && proc_table[pid].status != SLSH_WCET_VIOLATED)

                return;

        /* make task ready or waiting, dependong on slot (the time) for static tasks only*/

        if(type == STATIC_PCLASS && lev->tasks[pid].est <= lev->slot)

                proc_table[pid].status = SLSH_READY;

        else

                proc_table[pid].status = SLSH_WAIT;

        if(type == HARD_PCLASS)

                proc_table[pid].status = SLSH_READY;

        /* insert unspecified tasks in QQUEUE and make it ready */

        if(type == SOFT_PCLASS)

        {              

                iq_insertlast(pid ,&lev->unspecified);

                proc_table[pid].status = SLSH_READY;

        }

}

/* when a task i returned to module from a semaphore, mutex ... */

static void SLSH_public_unblock(LEVEL l, PID pid)

{

        SLSH_level_des *lev = (SLSH_level_des *)(level_table[l]);

        /* change staus of task */

        proc_table[pid].status = SLSH_READY;

        if(proc_table[pid].pclass == SOFT_PCLASS)

                iq_insertfirst(pid ,&lev->unspecified);

}

/* when a semaphore, mutex ... taskes a task from module */

static void SLSH_public_block(LEVEL l, PID pid)

{

        /* Extract the running task from the level

        . we have already extract it from the ready queue at the dispatch time.

        . the capacity event have to be removed by the generic kernel

        . the wcet don't need modification...

        . the state of the task is set by the calling function

        . the deadline must remain...

        So, we do nothing!!!

        */

}

/* the task has finihed its wcet, kill task (dont kill static tasks)  */

static void SLSH_public_end(LEVEL l, PID pid)

{

        SLSH_level_des *lev = (SLSH_level_des *)(level_table[l]);

        if(proc_table[pid].pclass == SOFT_PCLASS)

        {      

                if (proc_table[pid].status == SLSH_READY)

                        iq_extract(pid, &lev->unspecified);

        }

        else if(proc_table[pid].pclass == HARD_PCLASS)

        {

                if (proc_table[pid].status == SLSH_READY)

                        lev->tasks[pid].dabs = 0;

        }

        /* static tasks: put them in idle QUEUE, reset status and avail_time */

        else if(proc_table[pid].pclass == STATIC_PCLASS)

        {

                proc_table[pid].avail_time = proc_table[pid].wcet;

                proc_table[pid].status = SLSH_IDLE;

                iq_priority_insert(pid, &lev->idle_statics);

        }

        proc_table[pid].status = FREE;

}

/* called when a task should sleep but not execute for awhile, mabe a mode change */

//static void SLSH_task_sleep(LEVEL l, PID pid)

//{

//

//      /* the task has terminated his job before it consume the wcet. All OK! */

//      proc_table[pid].status = SLEEP;

//      

//      /* we reset the capacity counters... only for static tasks */

//      if (proc_table[pid].pclass == STATIC_PCLASS)

//              proc_table[pid].avail_time = proc_table[pid].wcet;

//              

//}

/** Guest Functions, slot shifing accepts no guests, so all generates exceptions **/

/******* Registration functions *******/

/*+ Registration function: */

LEVEL SLSH_register_level()

{

        LEVEL l;            /* the level that we register */

        SLSH_level_des *lev;  /* for readableness only */

        PID i;              /* a counter */

        kern_printf("SLSH_register_level\n");

        /* request an entry in the level_table */

        l = level_alloc_descriptor(sizeof(SLSH_level_des));

        lev = (SLSH_level_des *)level_table[l];

        printk("    lev=%d\n",(int)lev);

        /* fill the standard descriptor */

        lev->l.public_scheduler = SLSH_public_scheduler;

        lev->l.public_guarantee = SLSH_public_guarantee;

        lev->l.public_create    = SLSH_public_create;

        lev->l.public_end       = SLSH_public_end;

        lev->l.public_dispatch  = SLSH_public_dispatch;

        lev->l.public_epilogue  = SLSH_public_epilogue;

        lev->l.public_activate  = SLSH_public_activate;

        lev->l.public_unblock   = SLSH_public_unblock;

        lev->l.public_block     = SLSH_public_block;

        /* fill the SLSH descriptor part */

        for(i = 0; i < MAX_PROC; i++)

        {

                lev->tasks[i].est = -1;

                lev->tasks[i].dabs = 0;

                lev->tasks[i].interval = -1;

        }

        for(i = 0; i < MAX_INTERVALS; i++)

        {

                lev->intervals[i].start = -1;

                lev->intervals[i].end = -1;

                lev->intervals[i].length = 0;

                lev->intervals[i].maxt = 0;

                lev->intervals[i].sc = 0;

        }

        lev->current = 0;

        lev->last = NIL;

        lev->slot = 0;

        lev->slot_length = 0;

        lev->slot_event = -1;

        return l;

}

void SLSH_set_interval(LEVEL l, int start, int end, int maxt)

{

        SLSH_level_des* lev = (SLSH_level_des *)(level_table[l]);

        static int i = -1;     

        i++;

        lev->intervals[i].start = start;

        lev->intervals[i].end = end;

        lev->intervals[i].length = end - start;

        lev->intervals[i].maxt = maxt;

        lev->intervals[i].sc = lev->intervals[i].length - maxt;

        lev->last = i;

}

void SLSH_set_variables(LEVEL l, TIME length)

{

        SLSH_level_des* lev = (SLSH_level_des *)(level_table[l]);

        lev->slot_length = length;                     

}