Subversion Repositories shark

\documentclass[english]{report}

\usepackage[T1]{fontenc}

\usepackage[latin1]{inputenc}

\usepackage{geometry}

\geometry{verbose,a4paper}

\usepackage{array}

\usepackage{makeidx}

\makeindex

\usepackage{graphicx}

\makeatletter

\usepackage{babel}

\newenvironment{intest}{\noindent\large\bf\hspace*{1pt}}

{\vspace*{-5pt}\\\line(1,0){433}}

\makeatother

\begin{document}

\thispagestyle{empty}

\begin{center}{\LARGE S.Ha.R.K. User Manual}\end{center}{\LARGE \par} \vfill{}

\begin{center}{\large Volume III}\end{center}

\begin{center}

S.Ha.R.K. Modules

\end{center}

\vfill{}

\begin{center}Written by\end{center}

\begin{center}Giorgio Buttazzo (giorgio at sssup.it)\end{center}

\begin{center}Paolo Gai (pj at sssup.it)\end{center}

\begin{center}Luigi Palopoli (luigi at hartik.sssup.it)\end{center}

\begin{center}Marco Caccamo (caccamo at sssup.it)\end{center}

\begin{center}Giuseppe Lipari (lipari at sssup.it) \end{center}

\begin{center}Tullio Facchinetti (tullio.facchinetti at unipv.it) \end{center}

\vfill{}

\begin{center}\includegraphics[width=2cm]{../common/sssup.ps}\end{center}

\begin{center}

Scuola Superiore di Studi e Perfezionamento S. Anna

\end{center}

\begin{center}RETIS Lab\end{center}

\begin{center}Via Carducci, 40 - 56100 Pisa\end{center}

\pagebreak

\tableofcontents{}

\begin{abstract}

The S.Ha.R.K. kernel provides a way to implement in a simple

way a lot of scheduling algorithms that have been proposed by the

Real-Time literature. This Volume simply contains a simple

description on which modules are available and how these modules

can be used. Moreover, to help the implementation of new modules,

a small description of the tricks used in the implementation is

also given.

\end{abstract}

%----------------------------------------------------------------------------

\chapter{Models}

%----------------------------------------------------------------------------

Task Models and Resource Models are the structures used by the

S.Ha.R.K. Kernel to isolate the scheduling parameter needed by the

various Scheduling Modules and Resource Modules.

To simplify the use of the Models, the Kernel provides a set of

macros that can be used to fill their various fields. In the

following paragraphs, the various models are described in detail.

All the Model definitions of this chapter can be found in the file

\texttt{include/kernel/model.h}.

Examples of Models initializations can be found in various

examples through this Volume.

%----------------------------------------------------------------------------

\section{HARD\_TASK\_MODEL}

%----------------------------------------------------------------------------

\begin{tt}

\begin{verbatim}

typedef struct {

    TASK_MODEL t;

    TIME mit;

    TIME drel;

    TIME wcet;

    int periodicity;

} HARD_TASK_MODEL;

\end{verbatim}

\end{tt}

A Hard Task model can be used to model periodic and sporadic

tasks. These tasks are usually guaranteed basing on their minimum

interarrival time (mit) and wcet, and may have a relative

deadline.

Table \ref{tab:HARD_TASK_MODEL_Macros} shows the macros that

applies to a \texttt{HARD\_TASK\_MODEL}.

\begin{table}

\begin{tabular}{|l|p{8cm}|}

\hline Macro name & Behaviour \\ \hline

hard\_task\_default\_model(m) & Default values for the Model

(periodic task, others = 0) \\ \hline

hard\_task\_def\_level(m,l) & Set the Model level to l. A Module

registered at level x can accept a Model only if it has level 0 or

x. The default value is 0. \\ \hline

hard\_task\_def\_arg(m,a) & Set the void * argument passed to

the task the first time it is activated. The default value is

NULL.\\ \hline

hard\_task\_def\_stack(m,s) & Set the task stack size. The default

value is 4096.\\ \hline

hard\_task\_def\_stackaddr(m,s) & If the stack is statically

allocated you can tell its address here. The default is NULL (no

pre-allocated stack).\\ \hline

hard\_task\_def\_group(m,g) & Set the task group to g. Task

grouping influences primitives like group\_activate() or

group\_kill()\\ \hline

hard\_task\_def\_usemath(m) & Declare that the task uses floating

point arithmetic.\\ \hline

hard\_task\_def\_system(m) & Declare that the task is a system

task. System tasks behaves differently at shutdown. See the

Architecture manual for details.\\ \hline

hard\_task\_def\_nokill(m) & Declare that the task can not be

killed. These tasks behaves differently at shutdown. See the

Architecture manual for details.\\ \hline

hard\_task\_def\_ctrl\_jet(m) & If called, the Kernel must store

JET informations for the task.\\ \hline

hard\_task\_def\_mit(m,p) & Set the Minimum Interarrival Time

(MIT) of the Model to p.\\ \hline

hard\_task\_def\_drel(m,d) & Set the relative deadline to

d.\\ \hline

hard\_task\_def\_wcet(m,w) & Set the Worst Case Execution Time to

w.\\ \hline

hard\_task\_def\_periodic(m) & Declare that the task is

Periodic.\\ \hline

hard\_task\_def\_aperiodic(m) & Declare that the task is Sporadic

(Aperiodic).\\ \hline

hard\_task\_def\_joinable(m) & Declare that the task is joinable

with task\_join()/pthread\_join().\\ \hline

hard\_task\_def\_unjoinable(m) & Declare that the task is not

joinable (is detached) with

task\_join()/pthread\_join().\\ \hline

hard\_task\_def\_trace(m) & Declare that the task has to be traced

by the Tracer.\\ \hline

hard\_task\_def\_notrace(m) & Declare that the task has not to be

traced by the Tracer.\\ \hline

\end{tabular}

\caption{HARD\_TASK\_MODEL Macros}

\label{tab:HARD_TASK_MODEL_Macros}

\end{table}

%----------------------------------------------------------------------------

\section{SOFT\_TASK\_MODEL}

%----------------------------------------------------------------------------

\begin{tt}

\begin{verbatim}

typedef struct {

    TASK_MODEL t;

    TIME period;

    TIME met;

    TIME wcet;

    int periodicity;

    int arrivals;

} SOFT_TASK_MODEL;

\end{verbatim}

\end{tt}

A Soft Task model can be used to model periodic and aperiodic

tasks usually not guaranteed or guaranteed basing on their period

and mean execution time (met). A Soft task can also record pending

activations if the arrivals are set to SAVE\_ACTIVATIONS. A wcet

field is also present for those servers that need it (i.e., TBS).

Table \ref{tab:SOFT_TASK_MODEL_Macros} shows the macros that

applies to a \texttt{SOFT\_TASK\_MODEL}.

\begin{table}

\begin{tabular}{|l|p{8cm}|}

\hline Macro name & Behaviour\\ \hline

soft\_task\_default\_model(m) & Default values for the Model

(periodic task, save arrivals, others = 0).\\ \hline

soft\_task\_def\_level(m,l) & Set the Model level to l. A Module

registered at level x can accept a Model only if it has level 0 or

x. The default value is 0.\\ \hline

soft\_task\_def\_arg(m,a) & Set the void * argument passed to

the task the first time it is activated. The default value is

NULL.\\ \hline

soft\_task\_def\_stack(m,s) & Set the task stack size. The default

value is 4096.\\ \hline

soft\_task\_def\_stackaddr(m,s) & If the stack is statically

allocated you can tell its address here. The default is NULL (no

pre-allocated stack).\\ \hline

soft\_task\_def\_group(m,g) & Set the task group to g. Task

grouping influences primitives like group\_activate() or

group\_kill()\\ \hline

soft\_task\_def\_usemath(m) & Declare that the task uses floating

point arithmetic.\\ \hline

soft\_task\_def\_system(m) & Declare that the task is a system

task. System tasks behaves differently at shutdown. See the

Architecture manual for details.\\ \hline

soft\_task\_def\_nokill(m) & Declare that the task can not be

killed. These tasks behaves differently at shutdown. See the

Architecture manual for details.\\ \hline

soft\_task\_def\_ctrl\_jet(m) & If called, the Kernel must store

JET informations for the task.\\ \hline

soft\_task\_def\_period(m,p) & Set the task period to

p.\\ \hline

soft\_task\_def\_met(m,d) & Set the task Mean Execution Time (MET)

to d.\\ \hline

soft\_task\_def\_wcet(m,w) & Set the Worst Case Execution Time to

w.\\ \hline

soft\_task\_def\_periodic(m) & Declare that the task is

Periodic.\\ \hline

soft\_task\_def\_aperiodic(m) & Declare that the task is Sporadic

(Aperiodic).\\ \hline

soft\_task\_def\_joinable(m) & Declare that the task is joinable

with task\_join()/pthread\_join().\\ \hline

soft\_task\_def\_unjoinable(m) & Declare that the task is not

joinable (is detached) with

task\_join()/pthread\_join().\\ \hline

soft\_task\_def\_trace(m) & Declare that the task has to be traced

by the Tracer.\\ \hline

soft\_task\_def\_notrace(m) & Declare that the task has not to be

traced by the Tracer.\\ \hline

soft\_task\_def\_save\_arrivals(m) & The task will save a pending

activation if it arrives when the task is already

active.\\ \hline

soft\_task\_def\_skip\_arrivals(m) & The task will ignore a

pending activation if it arrives when the task is already

active.\\ \hline

\end{tabular}

\caption{SOFT\_TASK\_MODEL Macros}

\label{tab:SOFT_TASK_MODEL_Macros}

\end{table}

\pagebreak

%----------------------------------------------------------------------------

\section{NRT\_TASK\_MODEL}

%----------------------------------------------------------------------------

\begin{tt}

\begin{verbatim}

typedef struct {

    TASK_MODEL t;

    int weight;

    TIME slice;

    int arrivals;

    int policy;

    int inherit;

} NRT_TASK_MODEL;

\end{verbatim}

\end{tt}

A NRT task has a weight and a time slice, plus a policy attribute.

It can be used to model Round Robin, Proportional Share, POSIX,

and Priority tasks.

Note that policy and inherit are inserted in the model to support

POSIX compliant scheduling without adding another Task Model;

weight can be used to contain the fixed priority of a task; slice

can be used to contain the RR slice of the task.

Table \ref{tab:NRT_TASK_MODEL_Macros} shows the macros that

applies to a \texttt{NRT\_TASK\_MODEL}.

\begin{table}

\begin{tabular}{|c|p{8cm}|}

\hline Macro name & Behaviour\\ \hline

nrt\_task\_default\_model(m) & Default values for the Model (save

arrivals, NRT\_RR\_POLICY, NRT\_EXPLICIT\_SCHED, others =

0).\\ \hline

nrt\_task\_def\_level(m,l) & Set the Model level to l. A Module

registered at level x can accept a Model only if it has level 0 or

x. The default value is 0.\\ \hline

nrt\_task\_def\_arg(m,a) & Set the void * argument passed to the

task the first time it is activated. The default value is

NULL.\\ \hline

nrt\_task\_def\_stack(m,s) & Set the task stack size. The default

value is 4096.\\ \hline

nrt\_task\_def\_stackaddr(m,s) & If the stack is statically

allocated you can tell its address here. The default is NULL (no

pre-allocated stack).\\ \hline

nrt\_task\_def\_group(m,g) & Set the task group to g. Task

grouping influences primitives like group\_activate() or

group\_kill()\\ \hline

nrt\_task\_def\_usemath(m) & Declare that the task uses floating

point arithmetic.\\ \hline

nrt\_task\_def\_system(m) & Declare that the task is a system

task. System tasks behaves differently at shutdown. See the

Architecture manual for details.\\ \hline

nrt\_task\_def\_nokill(m) & Declare that the task can not be

killed. These tasks behaves differently at shutdown. See the

Architecture manual for details.\\ \hline

nrt\_task\_def\_ctrl\_jet(m) & If called, the Kernel must store

JET informations for the task.\\ \hline

nrt\_task\_def\_weight(m,w) & Set the task weight to

w.\\ \hline

nrt\_task\_def\_slice(m,d) & Set the timeslice to

d.\\ \hline

nrt\_task\_def\_policy(m,p) & Set the policy of the task. p can be

NRT\_RR\_POLICY or NRT\_FIFO\_POLICY. (used for POSIX

scheduling)\\ \hline

nrt\_task\_def\_inherit(m,i) & Tell if the task should inherit the

same properties of the father. i can be NRT\_INHERIT\_SCHED or

NRT\_EXPLICIT\_SCHED. (used for POSIX scheduling)\\

\hline

nrt\_task\_def\_joinable(m) & Declare that the task is joinable

with task\_join()/pthread\_join().\\ \hline

nrt\_task\_def\_unjoinable(m) & Declare that the task is not

joinable (is detached) with

task\_join()/pthread\_join().\\ \hline

nrt\_task\_def\_trace(m) & Declare that the task has to be traced

by the Tracer.\\ \hline

nrt\_task\_def\_notrace(m) & Declare that the task has not to be

traced by the Tracer.\\ \hline

nrt\_task\_def\_save\_arrivals(m) & The task will save a pending

activation if it arrives when the task is already

active.\\ \hline

nrt\_task\_def\_skip\_arrivals(m) & The task will ignore a pending

activation if it arrives when the task is already

active.\\ \hline

\end{tabular}

\caption{NRT\_TASK\_MODEL Macros}

\label{tab:NRT_TASK_MODEL_Macros}

\end{table}

%----------------------------------------------------------------------------

\section{JOB\_TASK\_MODEL}

%----------------------------------------------------------------------------

\begin{tt}

\begin{verbatim}

typedef struct {

    TASK_MODEL t;

    TIME period;

    struct timespec deadline;

    int noraiseexc;

} JOB_TASK_MODEL;

\end{verbatim}

\end{tt}

This model implements a Job with an optional period and a starting

deadline (for the first activation). A Job task can raise a

XDEADLINE\_MISS exception; if the flag noraiseexc is != 0, the

exception is not raised.

This model is normally used with aperiodic servers: the aperiodic

server insert a guest task in another level with that model

calling \texttt{guest\_create} and \texttt{guest\_activate}. When

the task has to be removed, \texttt{guest\_end} is called.

Note that there is no capacity control on this model. Note that

the task that accept this task DOESN'T reactivate the task after a

period... There is NOT a guest\_endcycle defined for this model...

Table \ref{tab:JOB_TASK_MODEL_Macros} shows the macros that

applies to a \texttt{JOB\_TASK\_MODEL}.

\begin{table}

\begin{tabular}{|l|p{8cm}|}

\hline Macro name& Behaviour\\ \hline

job\_task\_default\_model(m,dl) & Default values for the Model

(period = 0, deadline = dl, noraiseexc = 0)\\ \hline

job\_task\_def\_level(m,l) & Set the Model level to l. A Module

registered at level x can accept a Model only if it has level 0 or

x. The default value is 0.\\ \hline

job\_task\_def\_arg(m,a) & Set the void * argument passed to the

task the first time it is activated. The default value is

NULL.\\ \hline

job\_task\_def\_stack(m,s) & Set the task stack size. The default

value is 4096.\\ \hline

job\_task\_def\_stackaddr(m,s) & If the stack is statically

allocated you can tell its address here. The default is NULL (no

pre-allocated stack).\\ \hline

job\_task\_def\_group(m,g) & Set the task group to g. Task

grouping influences primitives like group\_activate() or

group\_kill()\\ \hline

job\_task\_def\_usemath(m) & Declare that the task uses floating

point arithmetic.\\ \hline

job\_task\_def\_system(m) & Declare that the task is a system

task. System tasks behaves differently at shutdown. See the

Architecture manual for details.\\ \hline

job\_task\_def\_nokill(m) & Declare that the task can not be

killed. These tasks behaves differently at shutdown. See the

Architecture manual for details.\\ \hline

job\_task\_def\_ctrl\_jet(m) & If called, the Kernel must store

JET informations for the task.\\ \hline

job\_task\_def\_period(m,p) & Set the period to p.\\ \hline

job\_task\_def\_deadline(m,dl) & Set the deadline to

dl.\\ \hline

job\_task\_def\_noexc(m) & Set noraiseexc = 1.\\ \hline

job\_task\_def\_yesexc(m) & Set noraiseexc = 1.\\ \hline

job\_task\_def\_joinable(m) & Declare that the task is joinable

with task\_join()/pthread\_join().\\ \hline

job\_task\_def\_unjoinable(m) & Declare that the task is not joinable (is

detached) with task\_join()/pthread\_join().\\ \hline

job\_task\_def\_trace(m) & Declare that the task has to be traced

by the Tracer.\\ \hline

job\_task\_def\_notrace(m) & Declare that the task has not to be

traced by the Tracer.\\ \hline

\end{tabular}

\caption{HARD\_TASK\_MODEL Macros}

\label{tab:JOB_TASK_MODEL_Macros}

\end{table}

%----------------------------------------------------------------------------

\section{BDEDF\_RES\_MODEL (BlockDevice EDF resource model)}

%----------------------------------------------------------------------------

TBD

%----------------------------------------------------------------------------

\section{BDPSCAN\_RES\_MODEL (Block Device PSCAN resource model)}

%----------------------------------------------------------------------------

TBD

%----------------------------------------------------------------------------

\section{PC\_RES\_MODEL (Priority Ceiling Resource Model)}

%----------------------------------------------------------------------------

\begin{tt}

\begin{verbatim}

typedef struct {

    RES_MODEL r;

    DWORD priority;

} PC_RES_MODEL;

\end{verbatim}

\end{tt}

This Resource Model signal to the Priority Ceiling (PC) Module

that the task may use the PC protocol for some mutexes.

Note that the PC Module consider the tasks created without using

this resource models to have priority = MAX\_DWORD (the lowest).

The macro that can be used to setup the Resource Model are the

following:

\texttt{PC\_res\_default\_model(res, prio) }

Initializes a PC\_RES\_MODEL with a priority equal to prio.

\texttt{PC\_res\_def\_level(res,l)}

Set the Model level to l (in a way similar to what happens to task

models).

%----------------------------------------------------------------------------

\section{SRP\_RES\_MODEL (Stack Resource Policy resource model)}

%----------------------------------------------------------------------------

\begin{tt}

\begin{verbatim}

typedef struct {

    RES_MODEL r;

    DWORD preempt;

} SRP_RES_MODEL;

\end{verbatim}

\end{tt}

This Resource Model signal to the Stack Resource Policy (PC)

Module that the task will use the SRP protocol.

Note that the SRP Module does not influence the schedule of any

task that did not pass a SRP\_RES\_MODEL at its creation. The SRP

Module uses another resource model that is embedded into the mutex

structure. See \texttt{modules/srp/srp.c} for details.

The macro that can be used to setup the Resource Model are the

following:

\texttt{SRP\_res\_default\_model(res, pre) }

Initializes a SRP\_RES\_MODEL with a preemption level equal to

prio.

\texttt{SRP\_res\_def\_level(res,l)}

Set the Model level to l (in a way similar to what happens to task

models).

%----------------------------------------------------------------------------

\chapter{Mutex attributes}

%----------------------------------------------------------------------------

Every mutex attribute encode a particular mutex protocol, and one

of them must be passed to the mutex\_init() primitive to specify

the protocol used by a particular mutex. The following paragraphs

describe in detail the mutex attributes. Their definitions can be

found in \texttt{include/kernel/model.h}. Examples of use of mutex

attributes can be found later in this document.

%----------------------------------------------------------------------------

\section{PI\_mutexattr\_t (Priority Inheritance Mutex Attribute)}

%----------------------------------------------------------------------------

\texttt{typedef mutexattr\_t PI\_mutexattr\_t;}

The Priority Ceiling Mutex Attribute.

You can initialize that attribute using the static initializer

\texttt{PI\_MUTEXATTR\_INITIALIZER} or calling the macro

\texttt{PI\_mutexattr\_default(a)}

where a is the mutex attribute.

%----------------------------------------------------------------------------

\section{NPP\_mutexattr\_t (Non Preemptive Protocol Mutex Attribute)}

%----------------------------------------------------------------------------

\texttt{typedef mutexattr\_t NPP\_mutexattr\_t;}

The Non Preemptive Protocol Mutex Attribute. You can initialize

that attribute using the static initializer

\texttt{NPP\_MUTEXATTR\_INITIALIZER} or calling the macro

\texttt{NPP\_mutexattr\_default(a)}

where a is the mutex attribute.

%----------------------------------------------------------------------------

\section{PC\_mutexattr\_t (Priority Ceiling Mutex Attribute)}

%----------------------------------------------------------------------------

\texttt{typedef struct \{ mutexattr\_t a; DWORD ceiling; \}

PC\_mutexattr\_t;}

The Priority Ceiling Mutex Attribute.

You can initialize that attribute using the static initializer

\texttt{PC\_MUTEXATTR\_INITIALIZER} or calling the macro

\texttt{PC\_mutexattr\_default(at,c) }

where at is the mutex attribute, and c is the ceiling of the

mutex.

%----------------------------------------------------------------------------

\section{SRP\_mutexattr\_t (Stack Resource Policy Mutex Attribute)}

%----------------------------------------------------------------------------

\texttt{typedef mutexattr\_t SRP\_mutexattr\_t;}

The Stack Resource Policy Mutex Attribute. You can initialize that

attribute using the static initializer

\texttt{SRP\_MUTEXATTR\_INITIALIZER} or calling the macro

\texttt{SRP\_mutexattr\_default(a) }

where at is the mutex attribute.

%----------------------------------------------------------------------------

\section{NOP\_mutexattr\_t (No Protocol Mutex Attribute)}

%----------------------------------------------------------------------------

\texttt{typedef mutexattr\_t NOP\_mutexattr\_t;}

The No Protocol Mutex Attribute.

You can initialize that attribute using the static initializer

\texttt{NOP\_MUTEXATTR\_INITIALIZER} or calling the macro

\texttt{NOP\_mutexattr\_default(a) }

where at is the mutex attribute.

%----------------------------------------------------------------------------

\section{NOPM\_mutexattr\_t (No Protocol Multiple lock Mutex Attribute)}

%----------------------------------------------------------------------------

typedef mutexattr\_t NOPM\_mutexattr\_t;

The No Protocol Multiple lock Mutex Attribute. You can initialize

that attribute using the static initializer

\texttt{NOPM\_MUTEXATTR\_INITIALIZER} or calling the macro

\texttt{NOPM\_mutexattr\_default(a) }

where at is the mutex attribute.

%----------------------------------------------------------------------------

\chapter{Scheduling algorithms}

%----------------------------------------------------------------------------

%----------------------------------------------------------------------------

\section{DUMMY}

%----------------------------------------------------------------------------

\paragraph{Task Models Accepted:}

\begin{description}

\item [DUMMY\_TASK\_MODEL]- This Model is used only at system

startup to register the dummy task. It cannot be used by the other

modules.

\end{description}

\paragraph{Description:}

This Module implements a \texttt{dummy} task. A dummy task is a

task like all the other task that simply does an infinite loop,

does nothing inside.

Why we need such a Module? Look at the Scheduling Module

Architecture: when the Kernel needs to schedule a task, it asks to

all the registered modules if they have a task to schedule. The

hyphotesis is that there must be ALWAYS a task to schedule. The

dummy Scheduling Modules is used to register a module that have

always a task to schedule (the dummy task).

The dummy Module is not needed if you can ensure that there will

always be a task to schedule.

\paragraph{Exceptions Raised:}

\begin{description}

\item [XUNVALID\_GUEST]This level doesn't support guests. When a

guest operation is called, the exception is raised. \item

[XUNVALID\_DUMMY\_OP]The dummy task can't be created, or

activated, or another (strange) problem occurred.

\end{description}

\paragraph{Usage:}

Usually the Dummy Module is the LAST scheduling module registered

in the function

\texttt{\_\_kernel\_register\_levels\_\_}.

Just insert the following line into

\texttt{\_\_kernel\_register\_levels\_\_} to register the Module:

\texttt{dummy\_register\_level();}

If you have a CPU where the HLT instruction works, you can use the

define \texttt{\_\_HLT\_WORKS\_\_}. If that \texttt{\#define} is

defined, the idle loop of the \texttt{dummy} task will use

\texttt{HLT}, maybe saving power.

\paragraph{Files:}

\texttt{modules/dummy/*}

\paragraph{Implementation hints:}

You can look at the code to learn how to create a new task at

startup using a \texttt{RUNLEVEL\_INIT} function.

%----------------------------------------------------------------------------

\section{IntDrive Interrupt Server}

%----------------------------------------------------------------------------

\input{intserver.tex}

\paragraph{Files:}

\texttt{modules/intdrive/*}

%----------------------------------------------------------------------------

\subsection{Implementation}

%----------------------------------------------------------------------------

\begin{intest}

INTDRIVE\_register\_level \index{INTDRIVE\_register\_level}

\end{intest}

\begin{description}

\item [\textbf{LEVEL INTDRIVE\_register\_level(TIME capacity, TIME q\_theta, int

U, int flags);}]

\item [\textbf{Description:}]This function registers the IntDrive module at

initialization time. This model should be usually registered as the first module

in the \texttt{\_\_kernel\_register\_levels\_\_} function.

\item [\textbf{Parameters:}]~

\begin{itemize}

\item \textbf{capacity}: the server capacity;

\item \textbf{q\_theta}: the server threshold;

\item \textbf{U}: the maximum bandwidth consumed by the server;

\item \textbf{flags}: a set of configuration options. Supported values are:

\begin{itemize}

\item \textbf{INTDRIVE\_CHECK\_WCET}: when a WCET overrun occurs, an exception

is raised.

\end{itemize}

\end{itemize}

\end{description}

\begin{intest}

INTDRIVE\_usedbandwidth \index{INTDRIVE\_usedbandwidth}

\end{intest}

\begin{description}

\item [\textbf{bandwidth\_t INTDRIVE\_usedbandwidth(LEVEL l);}]

\item [\textbf{Description:}]returns the bandwidth used by the IntDrive.

\end{description}

\begin{intest}