Go to most recent revision |
Blame |
Last modification |
View Log
| RSS feed
/*
* 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.h,v 1.1.1.1 2002-09-02 09:37:41 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-09-02 09:37:41 $
------------
Author: Tomas Lennvall, Date: Feb 2000.
This file contains the scheduling module for Slot shifting.
Title:
Slot Shifting
Task Models Accepted:
STATIC_TASK_MODEL - Periodic Hard tasks that are scheduled by
an off-line scheduler, so that all guarantees regarding precedence, mutex
deadline violation is taken care of. The tasks are in an executione schedule,
that is the order in when they become ready. They have the following fields:
est (earliest start time), wcet and absolute deadline.
HARD_TASK_MODEL - Hard Tasks (Hard aperiodic requests)
wcet field and drel field must be != 0. They are used to set the wcet
and deadline of the tasks.
periodicity field must be APERIODIC
mit field is ignored.
SOFT_TASK_MODEL - Soft Tasks (Unspecified tasks)
wcet field must be != 0. periodicity filed must be APERIODIC
period and met filed is ignored.
Guest Models Accepted:
NONE - Slot shifting handles all tasks by itself (at this moment).
Description:
This module schedules the offline scheduled tasks according to the slot-
shifting paradigm, dividing time into slots of a fixed length and assigning
tasks to execute in those slots. Slot-shifting also keeps track of the free
bandwidth in the schedule by using disjoint intervals and sc (spare capacity).
Each interval has a sc nr that represents the free bandwidth in that interval,
the sc can be used by hard aperiodic tasks, static tasks from later interval or
soft aperiodic tasks. Hard aperiodic tasks are guaranteed an incorporated in
the schedule by reduction of sc before they execute. No guarantee is
performed on the soft aperiodic tasks, they are run when no other task wants
to execute and sc is available.
Description:
This module implements the Slot shifting algorithm, by Gerhard Fohler. Slot shifting
schedules off-line scheduled tasks and also handles hard aperiodic requests by the
guarantee alorithm. Slot shifting can also handle soft aperiodic tasks,
called unspecified. That is tasks without a deadline.
Exceptions raised:
These exceptions are pclass-dependent...
XDEADLINE_MISS
If a task miss his deadline, the exception is raised.
XWCET_VIOLATION
If a task doesn't end the current cycle before if consume the wcet,
an exception is raised, and the task is put in the EDF_WCET_VIOLATED
state. To reactivate it, use EDF_task_activate via task_activate or
manage directly the EDF data structure. Note that the exception is not
handled properly, an XDEADLINE_MISS exeeption will also be raised at
the period end...
Restrictions & special features:
- This level doesn't manage the main task.
- At init time we can choose if the level have to activate
. the wcet check
(If a task require more time than declared, it is stopped and put in
the state EDF_WCET_VIOLATED; a XWCET_VIOLATION exception is raised)
. the task guarantee algorithm
(when all task are created the system will check that the task_set
will not use more than the available bandwidth)
- The level use the priority and timespec_priority fields.
- A function to return the used bandwidth of a level is provided.
- The guest tasks don't provide the guest_endcycle function
**/
/*
* 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
*
*/
#ifndef __SLSH_H__
#define __SLSH_H__
#include <ll/ll.h>
#include <kernel/config.h>
#include <sys/types.h>
#include <kernel/types.h>
#include <modules/codes.h>
#define STATIC_PCLASS 0x0500
#define SLSH_LEVELNAME "Slot Shifting"
#define SLSH_LEVEL_CODE 5
#define SLSH_LEVEL_VERSION 1
/* -----------------------------------------------------------------------
STATIC_TASK_MODEL: offline scheduled Tasks
----------------------------------------------------------------------- */
/* Offline-scheduled tasks are hard periodic tasks that have been
scheduled before runtime. All guarantees are made by the off-
line scheduler so the tasks are already guaranteed.
*/
typedef struct {
TASK_MODEL t;
TIME est;
TIME wcet;
TIME dabs;
int interval; /* used in slot shifting */
} STATIC_TASK_MODEL;
#define static_task_default_model(m) \
task_default_model((m).t,STATIC_PCLASS), \
(m).est = -1, \
(m).dabs = 0, \
(m).wcet = 0, \
(m).interval = -1;
#define static_task_def_level(m,l) task_def_level((m).t,l)
#define static_task_def_arg(m,a) task_def_arg((m).t,a)
#define static_task_def_stack(m,s) task_def_stack((m).t,s)
#define static_task_def_group(m,g) task_def_group((m).t,g)
#define static_task_def_usemath(m) task_def_usemath((m).t)
#define static_task_def_system(m) task_def_system((m).t)
#define static_task_def_nokill(m) task_def_nokill((m).t)
#define static_task_def_ctrl_jet(m) task_def_ctrl_jet((m).t)
#define static_task_def_est(m,p) (m).est = (p)
#define static_task_def_dabs(m,d) (m).dabs = (d)
#define static_task_def_wcet(m,w) (m).wcet = (w)
#define static_task_def_interval(m,i) (m).interval = (i)
#define static_task_def_trace(m) task_def_trace((m).t)
#define static_task_def_notrace(m) task_def_notrace((m).t)
/*#define min(a, b) ((a) < (b) ? (a) : (b))*/
#define TIME2TIMESPEC(T, TS) \
( \
((TS).tv_sec = ((T)/1000000)), \
((TS).tv_nsec = (((T)%1000000) * 1000)), \
(TS) \
)
/* define the interval struct */
typedef struct {
int start; /* start of interval */
int end; /* end of interval */
int length; /* Length of interval */
int maxt; /* maximum execution time in interval */
int sc; /* spare capacity in interval */
} SLSH_interval;
/*+ Registration function: */
void SLSH_register_level();
void SLSH_set_interval(LEVEL l, int start, int end, int maxt);
void SLSH_set_variables(LEVEL l, TIME length);
#endif