Développement de systèmes

embarqués temps réel avec Ada

Frank Singhoff
Bureau C-203
Université de Brest, France
Laboratoire Lab-STICC UMR CNRS 6285
singhoff@[Link]

UE systèmes temps réel Univ. Brest/Lab-STICC Page 1/133

Sommaire
1. Généralités sur les systèmes embarqués temps réel.
2. Introduction au langage Ada 2005.
3. Concurrence.
4. Temps réel.
5. Exemples de runtimes Ada.
6. Résumé.
7. Références.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 2/133

Présentation
• Caractéristiques des systèmes embarqués temps
réel et objectifs :

1. Comme tous systèmes temps réel : déterminisme

logique, temporel et fiabilité.
2. Mais en plus :
Ressources limitées (mémoire a , vitesse
processeur, énergie).
Accessibilité réduite.
Autonomie élevée.
Interaction avec son environnement (capteurs).

=⇒ Environnements d’exécution spécifiques.

a
footprint ou empreinte mémoire.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 3/133
Systèmes d’exploitation temps réel (1)
• Caractérisques :
Aussi appelé "Moniteur" ou "Exécutif".

Modulaire et de petite taille. Flexible vis-à-vis de l’application.

Accès aisé aux ressources physiques.

Abstractions adaptées (parallélisme, exception, interruption, tâches,

...)

Support de langages pour le temps réel (ex : C, Ada).

Livré avec ses performances temporelles (en théorie).

Améliorer la portabilité : architecture + standardisation (du langage

de programmation, des services du système d’exploitation).

UE systèmes temps réel Univ. Brest/Lab-STICC Page 4/133

Systèmes d’exploitation temps réel (2)

• Architecture en couches :
Bibliothèque langage (ou runtime) constituant l’environnement
d’exécution d’un programme (C, Ada). Portabilité de l’application
(adapte le langage au système d’exploitation).
BSP/Board support package : portabilité du système d’exploitation
(adapte le système d’exploitation au matériel).
UE systèmes temps réel Univ. Brest/Lab-STICC Page 5/133
Systèmes d’exploitation temps réel (3)
• Performance connue et déterministe:
Doit permettre l’évaluation de la capacité des tâches par exemple.
Utilisation de benchmarks (ex : Rhealstone, Hartstone, etc).

• Critères de performances :
Latence sur interruption.
Latence sur commutation de contexte/tâche.
Latence sur préemption.
Sémaphore "shuffle" (temps écoulé entre la libération d’un
sémaphore et la réactivation d’une tâche bloquée sur celui-ci).
Temps de réponse pour chaque service (appel système, fonctions de
bibliothèque).
etc.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 6/133
Systèmes d’exploitation temps réel (4)
. TCP/IP sur
Ethernet , liens
séries, etc
. TFTP, NFS
Environnement de
développement Machine cible

GDB RGDB

rsh

Hôte (windows)

OS temps réel

Disque NFS

• Phase de développement : édition du source, compilation croisée,

téléchargement, exécution et tests.
• Phase d’exploitation : construction d’une image minimale (exécutif +
application) sans les services de développement. Stockage en EEPROM,
Flash.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 7/133
Etat du marché (1)
30
Nombre d’entreprises utilisant le système

25
21.42
19.7
20

Pourcentage
15
12.84
10.19
10
6.64 5.96
5
4.69
3.89
2.86 2.41 2.3 1.95
1.83 1.72 1.61

N CE
Ly X

do III
iR S

S
-L X
S9

+
T
S

Ch ux

s
ire

X
ks

re
us
RT
O

sN

RT RT
N

W MX
O
or

in
ta

nx

us
pS

ut
s

le
Q

w
rié

V
W

A
or
uc
do
vx

op

in
in
pr

W
n
tio
lu
So

Systèmes temps réel embarqués

• Caractéristiques du marché [TIM 00] :

Diversité des produits présents =⇒ produits généralistes ou

spécifiques à des applications types.
Présence importante de produits "maisons".
UE systèmes temps réel Univ. Brest/Lab-STICC Page 8/133
Etat du marché (2)
• Quelques exemples de produits industriels :

VxWorks : produit généraliste et largement répandu (PABX, terminal

X de HP, Pathfinder, satellite CNES, etc).
pSOS édité par ISI (appli militaire, tél. portable).
VRTX édité par Microtec (appli militaire, tél. portable).
LynxOs (Unix temps réel).
Windows CE/Microsoft (systèmes embarqués peu temps réel).

• Produits "open-source" :

OSEK-VDX (appli. automobile).

RTEMS de Oar (appli. militaire).
eCos de cygnus.
RT-Linux.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 9/133
Etat du marché (3)
• Quelques standards :

Langages de conception logicielle: UML/MARTE,

AADL, HOOD HRT, ...
Langages de programmation : Ada 2005, C, ...
Systèmes d’exploitation : POSIX, ARINC 653, OSEK
VDX, ...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 10/133

La norme POSIX (1)
• Objectif : définir une interface standard des services offerts par
UNIX[VAH 96, J. 93] afin d’offrir une certaine portabilité des applications.

• Norme publiée conjointement par l’ISO et l’ANSI.

• Problèmes :
Portabilité difficile car il existe beaucoup de différences entre les
UNIX.
Tout n’est pas (et ne peut pas ?) être normalisé.
Divergence dans l’implantation des services POSIX (ex : threads sur
Linux).
Architecture de la norme.
• Exemple de systèmes POSIX : Lynx/OS, VxWorks, Solaris, Linux,
QNX, etc .. (presque tous les systèmes temps réel).

UE systèmes temps réel Univ. Brest/Lab-STICC Page 11/133

La norme POSIX (2)
• Architecture de la norme : découpée en chapitres
optionnels et obligatoires. Chaque chapitre contient des
parties obligatoirement présentes, et d’autres optionnelles.

• Exemple de chapitres de la norme POSIX :

Chapitres Signification
POSIX 1003.1 Services de base (ex : f ork ,
exec, ect)
POSIX 1003.2 Commandes shell (ex : sh)
POSIX 1003.1b [GAL 95] Temps réel
POSIX 1003.1c [RIF 95] Threads
POSIX 1003.5 POSIX et Ada
etc

UE systèmes temps réel Univ. Brest/Lab-STICC Page 12/133

La norme POSIX (3)
• Cas du chapitre POSIX 1003.1b : presque tout les composants sont
optionnels !!

Nom Signification
_POSIX_PRIORITY_SCHEDULING Ordonnancement
à priorité fixe
_POSIX_REALTIME_SIGNALS Signaux temps réel
_POSIX_ASYNCHRONOUS_IO E/S asynchrones
_POSIX_TIMERS Chien de garde
_POSIX_SEMAPHORES Sémaphores
etc ...

• Conséquence : que veut dire "être conforme POSIX 1003.1b" ... pas
grand chose puisque la partie obligatoire n’est pas suffisante pour
construire des applications temps réel.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 13/133

La norme POSIX (4)
Les threads POSIX.
Services d’ordonnancement.
Outils de synchronisation.
Les signaux temps réel.
La manipulation du temps.
Les entrées/sorties asynchrones.
Les files de messages.
La gestion mémoire.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 14/133

Sommaire
1. Généralités sur les systèmes embarqués temps réel.
2. Introduction au langage Ada 2005.
3. Concurrence.
4. Temps réel.
5. Exemples de runtimes Ada.
6. Résumé.
7. Références.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 15/133

Introduction au langage Ada 2005 (1)
Abstractions temps réel : tâche, interruption, ordonnancement,
synchronisation, timer et gestion du temps, ...
Standards ISO/IEC (portabilité): Ada 83, 95, 2005, 2012, 2022.
Lien avec d’autres standards SAE, ARINC, IEEE, ...
Langage complexe mais fiabilité et prédictibilité : compilation
séparée, typage fort, analyses statiques, pas d’allocation dynamique
ni dépendance cyclique.

• Domaines : transport (avionique et ferroviaire), spatial, militaire.

• Exemples : Airbus (320, 380), Boeing (777), Eurofighter Typhoon,

Fokker, Tupolev, Eurostar, Metro (14 Paris), TGV, Ariane (4 et 5), Satellites
(Intersat), spatial (sonde Cassini, Huygens, Soho, Mars Express), militaire
(Tigre, Apache, Patriot) =⇒
[Link]
UE systèmes temps réel Univ. Brest/Lab-STICC Page 16/133
Introduction au langage Ada 2005 (2)
1. C’est quoi un programme Ada ?
2. Types, opérateurs, variables, constantes.
3. Structure et flot de contrôle.
4. Entrées/sorties.
5. Pointeur et allocation dynamique.
6. Paquetages génériques.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 17/133

C’est quoi un programme Ada (1)
• Compilation séparée : unité de programme = entité
logicielle compilable indépendamment. Logiciels de grande
taille.

• Catégories d’unité de programme (fichiers GNAT) :

Procédure principale : point d’entrée d’un programme (fichier .adb).
Paquetage : collection de déclarations (sous programmes, types,
tâches, ...).
Partie visible (spécification du paquetage, fichier .ads).
Partie cachée (corps du paquetage, fichier .adb).
Tâches : spécification (fichier .ads) et implémentation (fichier .adb).
Unités génériques: unités (paquetage ou sous programmes)
paramétrées par types, constantes, sous-programmes ou
paquetages.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 18/133
C’est quoi un programme Ada (2)
• Structure d’une procédure principale :

w i t h nom_paquetage1 ; use nom_paquetage1 ;

w i t h nom_paquetage2 ; use nom_paquetage2 ;

procedure n o m _ p r o c e d u r e _ p r i n c i p a l e i s
−− d e c l a r a t i o n s
begin
−− i n s t r u c t i o n s
end n o m _ p r o c e d u r e _ p r i n c i p a l e ;

Fichier nom_procedure_principale.adb
Clauses with et use
Use est optionnel => fiabilité. Notation pointée sinon.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 19/133

C’est quoi un programme Ada (3)
• Exemple de procédure principale :
with text_io ;
use t e x t _ i o ;

procedure Coucou i s
begin
Put_Line ( " Coucou " ) ;
end Coucou ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 20/133

C’est quoi un programme Ada (4)
• Structure d’une spécification de paquetage :
package nom_du_paquetage i s
−− d e c l a r a t i o n s p u b l i q u e s
private
−− d e c l a r a t i o n s p r i v e e s
end nom_du_paquetage ;
• Structure d’une implémentation de paquetage :
package body nom_du_paquetage i s
−− sous programmes
begin
−− code d ’ i n i t i a l i s a t i o n
end nom_du_paquetage ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 21/133

C’est quoi un programme Ada (5)
• Spécification d’un paquetage (fichier [Link]) :
package Lemien i s

procedure somme( a : i n i n t e g e r ;
b : i n i n t e g e r ; r e s u l t a t : out i n t e g e r ) ;
f u n c t i o n somme( a : i n i n t e g e r ; b : i n i n t e g e r )
return integer ;

private
variable_interne : integer ;
end Lemien ;

Surchage => fiabilité.

Contrôle arguments in/out => fiabilité.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 22/133
C’est quoi un programme Ada (6)
• Implémentation d’un paquetage ([Link]) :
package body Lemien i s

procedure somme( a : i n i n t e g e r ;
b : i n i n t e g e r ; r e s u l t a t : out i n t e g e r ) i s
begin
r e s u l t a t : = a+b+ v a r i a b l e _ i n t e r n e ;
end somme;
f u n c t i o n somme( a : i n i n t e g e r ; b : i n i n t e g e r )
return integer is
begin
r e t u r n a+b+ v a r i a b l e _ i n t e r n e ;
end somme;

begin
va ri a b l e _ i n te rn e :=100;
end Lemien ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 23/133

C’est quoi un programme Ada (7)
• Exemple d’utilisation du paquetage lemien :
with t e x t _ io ;
use t e x t _ i o ;
w i t h Lemien ;
use Lemien ;

procedure p r i n c i s
a : integer :=0;
begin
somme( 1 0 , 2 0 , a ) ;
Put_Line ( i n t e g e r ’ image ( a ) ) ;
a : =somme( 4 0 , 5 0 ) ;
Put_Line ( i n t e g e r ’ image ( a ) ) ;
end p r i n c ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 24/133
C’est quoi un programme Ada (8)
• Compiler ce programme (avec GNAT) :
>gnatmake p r i n c . adb
gcc −c lemien . adb
gcc −c p r i n c . adb
g n a t b i n d −x p r i n c . a l i
gnatlink princ . a l i

gnatmake : gestion des dépendances entre unités de programme.

gcc : compilation
gnatbind : phase d’élaboration (initialisation des paquetages).
gnatlink : édition des liens.
Résultats : princ, [Link], lemien.o, [Link] et
princ.o

UE systèmes temps réel Univ. Brest/Lab-STICC Page 25/133

C’est quoi un programme Ada (9)
• Exercice 1 :
package c a l c u l i s
function additionne (a : in integer ; b : in integer )
return integer ;
function multiplie (a : in integer ; b : in integer )
return integer ;
function soustrait (a : in integer ; b : in integer )
return integer ;
function divise (a : in integer ; b : in integer )
return integer ;
end c a l c u l ;

Écrire une procédure principale qui , grâce au paquetage calcul, calcule

et affiche l’expression suivante (2 · 3) + 4. Écrire l’implémentation du
paquetage.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 26/133
Types, opérateurs, variables (1)
• Typage fort:
Améliorer la maintenabilité (lisibilité).
Améliorer la sécurité: analyse statique à la compilation
et à l’exécution (exception).
Interdire les opérations entre variables de types
différents (pas de cast implicite).

• Type:
Type = taille mémoire + représentation + plage de
valeurs + attributs/opérateurs.
Plage de valeurs définie par la norme (portabilité).
Attributs : opérateurs pré-définis pour tous les types,
définis par l’utilisateur ou non.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 27/133
Types, opérateurs, variables (2)
• Types scalaires :
float, integer, boolean, character, acces
ainsi que les énumérations.
Exemples d’attribut : integer’last,
integer’first, integer’range

• Types composés : array, string (qui est un array),

record, union, task, protected

• Principaux opérateurs :
Arithmétiques : +, -, *, /, mod
Relationnels : =, /=, <=, >=, in, not, and,
or, xor

UE systèmes temps réel Univ. Brest/Lab-STICC Page 28/133

Types, opérateurs, variables (3)
Types dérivés : si a est un type dérivé de b, alors a et b
sont deux types différents, et ne sont pas compatibles.
Sous types : si a est un sous type de b, alors a et b
sont compatibles. a est un alias de b.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 29/133

Types, opérateurs, variables (4)
• Exemples de déclarations :
with t e x t _ i o ;
use t e x t _ i o ;

procedure d e c l a r e _ v a r i s
i1 : integer ;
i2 : i nteger := 0;
s1 : s t r i n g ( 1 . . 1 0 ) ;
f1 : constant f l o a t := 10.5;
begin
Put_Line ( " i n t e g e r ’ f i r s t =" & i n t e g e r ’ image ( i n t e g e r ’ f i r s t ) ) ;
Put_Line ( " i n t e g e r ’ l a s t =" & i n t e g e r ’ image ( i n t e g e r ’ l a s t ) ) ;
end d e c l a r e _ v a r ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 30/133

Types, opérateurs, variables (5)
• Exemples types dérivés et sous types:
procedure d e r i v e i s
t y p e te mp e ra tu re i s new i n t e g e r range −280 . . 300;

t 1 : te mp e ra tu re : = 0 ;
t 2 : te mp e ra tu re : = 300;
i : integer :=10;

begin
t1 := t1+t2 ;
t1 := t1+ i ;
t 2 : = t 2 +1;
end d e r i v e ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 31/133

Types, opérateurs, variables (6)
• Exemples types dérivés et sous types:
procedure d e r i v e i s
subtype te mp e ra tu re i s i n t e g e r range −280 . . 300;

t 1 : te mp e ra tu re : = 0 ;
t 2 : te mp e ra tu re : = 300;
i : integer :=10;

begin
t1 := t1+t2 ;
t1 := t1+ i ;
t 2 : = t 2 +1;
end d e r i v e ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 32/133

Types, opérateurs, variables (7)
Le typage fort facilite l’analyse statique.
Exemple du programme C de D. Lesens [LES 10].

/ / Programme C i n c o r r e c t
/ / q u i compile c o r r e c te m e n t
t y p e d e f enum { ok , nok } t_ok_nok ;
t y p e d e f enum { o f f , on } t _ o n _ o f f ;

v o i d main ( ) {
t_ok_nok s t a t u s = nok ;
i f ( s t a t u s == on )
p r i n t f ( " i s on \ n " ) ;
}

UE systèmes temps réel Univ. Brest/Lab-STICC Page 33/133

Types, opérateurs, variables (8)
Et la version Ada maintenant :

with t e x t _ i o ;
use t e x t _ i o ;

−− Programme Ada i n c o r r e c t
−− q u i NE compile PAS
procedure c fa u x i s

ty p e t_ok_nok i s ( ok , nok ) ;
ty p e t _ o n _ o f f i s ( o f f , on ) ;

s t a t u s : t_ok_nok : = nok ;
begin
i f ( s t a t u s = on )
then Put_Line ( " i s on \ n " ) ;
end i f ;
end c fa u x ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 34/133
Types, opérateurs, variables (9)
Raisonner sur les types :

/ * En C compile e t p l a n t e pas : − ( * /
masse1 , temperature1 : f l o a t ;
masse1=masse1+ temperature1 ;

−− en Ada : on r a i s o n n e s u r l e s ty p e s
ty p e M i s new i n t e g e r 5000 . . . 20000;
ty p e T i s new i n t e g e r −50 . . 5 0 ;

masse1 : M;
temperature1 : T ;

−− Compile pas
masse1 : = masse1+temperature1 ;
−− Compile mais CONSTRAINT ERROR
masse1 : = masse1+ M( temperature1 ) ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 35/133

Types, opérateurs, variables (10)
• Types composés :
1. Constructeurs de type : type
2. Énumération : type discret, implantation mémoire cachée (ex: enum
en C) mais attributs spécifiques (succ et pos).
3. Structure : constructeur record. Initialisation des attributs par ordre
de déclaration ou en les nommant.
4. Tableau : constructeur array, une ou deux dimensions, indices de
type discret (entier, énumération), taille connue à la définition du type
ou à la déclaration du tableau.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 36/133

Types, opérateurs, variables (11)
• Exemple d’énumération :
with t e x t _ i o ;
use t e x t _ i o ;
procedure enumeration i s

ty p e u n _ j o u r i s ( l u n d i , mardi , mercredi , j e u d i ,
vendredi , samedi , dimanche ) ;
j : un_jour := l u n d i ;

package i o i s new t e x t _ i o . e n u m e r a ti o n _ i o ( u n _ j o u r ) ;

begin
i o . Put ( un_jour ’ f i r s t ) ;
i o . Put ( un_jour ’ l a s t ) ;
j : = un_jour ’ succ ( j ) ;
i o . Put ( j ) ; Put_Line ( un_jour ’ image ( j ) ) ;
end enumeration ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 37/133

Types, opérateurs, variables (12)
• Autre exemple de contrôle sur les énumérations :
v o i d main ( ) {
t y p e d e f enum { l u n d i , mardi , mercredi ,
j e u d i , vendredi , samedi } u n _ j o u r ;
un_jour j ;
j = j * mardi ;
}

w i t h t e x t _ i o ; use t e x t _ i o ;
procedure enumeration2 i s
ty p e u n _ j o u r i s ( l u n d i , mardi , mercredi , j e u d i ,
vendredi , samedi , dimanche ) ;
j : un_jour := l u n d i ;
begin
j : = j * mardi ;
end enumeration2 ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 38/133
Types, opérateurs, variables (13)
• Exemple de tableau :
ty p e u n _ j o u r i s ( l u n d i , mardi , mercredi , j e u d i ,
vendredi , samedi , dimanche ) ;

ty p e tab1 i s a r r a y ( 0 . . 3 ) o f i n t e g e r ;
ty p e tab2 i s a r r a y ( 1 . . 4 ) o f u n _ j o u r ;
ty p e tab3 i s a r r a y ( l u n d i . . dimanche ) o f i n t e g e r ;

t 1 : tab1 : = ( 3 0 , 4 3 , 2 8 , 1 0 0 ) ;
t 2 : tab2 : = (4= > l u n d i , 2=>mardi ,
3=>dimanche , 1=> m e r c r e d i ) ;
t 3 : tab3 ;

begin
t1 (0):= t1 ( 0 ) * 2 ;
t 2 ( 1 ) : = dimanche ;
t3 ( lundi ) :=2 ;
...
UE systèmes temps réel Univ. Brest/Lab-STICC Page 39/133
Types, opérateurs, variables (14)
• Exemple de structure :
with t e x t _ i o ;
use t e x t _ i o ;
procedure p o i n t i s

ty p e u n _ p o i n t i s r e c o r d
x : integer ;
y : integer ;
end r e c o r d ;

p1 : u n _ p o i n t : = ( 1 0 , 2 0 ) ;
p2 : u n _ p o i n t : = ( y = >20 , x = >10);

begin
Put_Line ( i n t e g e r ’ image ( p1 . x ) ) ;
Put_Line ( i n t e g e r ’ image ( p1 . y ) ) ;
end p o i n t ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 40/133

Types, opérateurs, variables (15)
• Exercice 2 : pour chaque affectation, indiquez si elle est correcte ou non.

ty p e t 1 i s new i n t e g e r range 0 . . 1 0 ;
ty p e t 2 i s new i n t e g e r range 0 . . 1 0 0 ;
subtype t 3 i s t 1 ;
subtype t 4 i s t 3 ;
subtype t 5 i s t 2 ;

a , b : t1 ;
c : t2 ;
d : t3 ;
e, f : t4 ;

a : = b+c ;
d:= c *a ;
d:= c * f ;
f : = a+b ;
e:=e*100;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 41/133

Flots de contrôle (1)
Séquence :
i1 ; i2

Conditionnelle :
i f cond
then i 1 ;
else i2 ;
end i f ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 42/133

Flots de contrôle (2)
Diverses formes d’itération :
w h i l e cond
loop
i1 ; i2 ;
end l o o p ;

loop
i1 ; i2 ;
e x i t when cond ;
end l o o p ;

f o r i i n a . . b loop
i1 ; i2 ;
end l o o p ;

• Boucle for rigide => fiabilité.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 43/133

Flots de contrôle (3)
• Exemple employant des attributs:
s1 , s2 , s3 : i n t e g e r : = 0 ;
subtype i n d i c e i s i n t e g e r range 1 . . 1 0 ;
...
f o r i i n 1..10 loop
s1 : = s1+ i ;
end l o o p ;

f o r j i n indice ’ f i r s t . . indice ’ l a s t loop

s2 : = s2+ j ;
end l o o p ;

f o r k i n i n d i c e ’ range l o o p
s3 : = s3+k ;
end l o o p ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 44/133

Entrées/sorties (1)
Typage fort : chaque type doit disposer des services
d’entrées/sorties mais familles de type.
Services offerts par le paquetage Text_Io : pour les
types String et Character uniquement (extrait de
GNAT):
Get : saisie d’une chaîne de caractères de taille fixe.
Put : affichage d’une chaîne de caractères.
New_Line : retour chariot
Put_Line : Put + New_Line
Get_Line : saisie d’une chaîne de caractères de
taille variable.
Autres types : instancier les paquetages génériques
Float_Io, Integer_Io, Enumeration_Io, ...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 45/133

Entrées/sorties (2)
• Spécification de Text_Io:

package Ada . Text_IO i s

procedure Get ( Item : o u t S t r i n g ) ;
procedure Put ( Item : S t r i n g ) ;
procedure Get_Line ( Item : o u t S t r i n g ;
Last : out Natural ) ;
procedure Put_Line ( Item : S t r i n g ) ;
procedure New_Line ( Spacing : P o s i t i v e _ C o u n t : = 1 ) ;

generic
ty p e Num i s range < >;
package I n t e g e r _ I O i s . . .

generic
ty p e Num i s range < >;
package Enumeration_IO i s . . .

UE systèmes temps réel Univ. Brest/Lab-STICC Page 46/133

Entrées/sorties (3)
• Exemple du générique Integer_Io:

generic
ty p e Num i s range < >;
package Ada . Text_IO . I n t e g e r _ I O i s

D e f a u l t _ W i d t h : F i e l d : = Num’ Width ;
Default_Base : Number_Base : = 1 0 ;

procedure Put
( Item : Num;
Width : F i e l d : = D e f a u l t _ W i d t h ;
Base : Number_Base : = Default_Base ) ;
procedure Get
( Item : o u t Num ) ;
end Ada . Text_IO . I n t e g e r _ I O ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 47/133

Entrées/sorties (4)
• Exemple du générique Float_Io:

generic
ty p e Num i s d i g i t s < >;

package Ada . Text_IO . F l o a t _ I O i s

procedure Get
( Item : o u t Num;
Width : i n F i e l d : = 0 ) ;

procedure Put
Item : i n Num;
Fore : i n F i e l d : = D e f a u l t _ F o r e ;
Aft : in Field := Default_Aft ;
Exp : i n F i e l d : = Default_Exp ) ;
end Ada . Text_IO . I n t e g e r _ I O ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 48/133

Entrées/sorties (5)
• Exemple d’utilisation de Integer_Io:

w i t h t e x t _ i o ; use t e x t _ i o ;
procedure I n t i o i s
ty p e te m p e r a tu r e i s new i n t e g e r range −3 0 0 ..3 0 0 ;
package t e m p e r a t u r e _ i o i s new t e x t _ i o . i n t e g e r _ i o ( te m p e r a tu r e ) ;
t1 , t 2 : te m p e r a tu r e ;
begin
Put ( " S a i s i r te m p e r a tu r e 1 : " ) ;
t e m p e r a t u r e _ i o . Get ( t 1 ) ;
New_Line ; Put ( " S a i s i r te m p e r a tu r e 2 : " ) ;
t e m p e r a t u r e _ i o . Get ( t 2 ) ;
New_Line ;
Put ( "Somme = " ) ; t e m p e r a t u r e _ i o . Put ( t 1 + t 2 ) ;
New_Line ;
exception
when Da ta _ E r r o r =>
P u t _ l i n e ( " Donnee s a i s i e non conforme au ty p e ’ temperature ’ " ) ;
end I n t i o ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 49/133
Entrées/sorties (5)
• Exercice 3 :
Écrire un programme qui permet de saisir des entiers et af-
fiche la somme des valeurs saisies au fur et à mesure des
saisies. Le programme doit afficher une erreur lorsque les
données saisies ne sont pas entières.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 50/133

Pointeurs, allocations dynamiques (1)
• Généralement pas de pointeur et pas d’allocation dynamique dans
les systèmes temps réel, mais :

Typage fort : un pointeur ne peut adresser qu’un seul type de

donnée. Pointeur typé.
Contrôle sur l’utilisation des pointeurs : fiabilité.
Exemple de déclarations :

t y p e I n t e g e r _ P t r i s access I n t e g e r ;
pointeur1 : Integer_Ptr := n u l l ;
mon_integer : I n t e g e r ;
p o i n t e u r 2 : I n t e g e r _ P t r : = mon_integer ’ access ;

Allocation dynamique : opérateur new.

Désallocation : non standardisée.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 51/133

Pointeurs, allocations dynamiques (2)
• Exemple :

w i t h T e x t _ I o ; use T e x t _ I o ;
procedure P o i n t e u r i s
package I o i s new T e x t _ I o . I n t e g e r _ I o ( I n t e g e r ) ;
ty p e I n t e g e r _ P t r i s access I n t e g e r ;
I : Integer : = 110;
P1 , P2 , P3 , P4 : I n t e g e r _ P t r ;
begin
P1 : = new I n t e g e r ;
P1 . a l l : = 1 0 0 ;
P2 : = new I n t e g e r ’ ( I ) ;
P4 : = new I n t e g e r ’ ( 1 0 ) ;
I o . Put ( P1 . a l l ) ;
I o . Put ( P2 . a l l ) ;
I o . Put ( P4 . a l l ) ;
I o . Put ( P3 . a l l ) ;
end P o i n t e u r ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 52/133

Pointeurs, allocations dynamiques (3)
• Contrôle sur l’utilisation des pointeurs : fiabilité.

w i t h T e x t _ I o ; use T e x t _ I o ;
procedure Alloc_Faux i s

ty p e I n t e g e r _ P t r i s access I n t e g e r ;
Global : I n t e g e r _ P t r ;

procedure A f f e c t e r _ V a l e u r i s
I 1 : I n t e g e r : = 100;
begin
G l o b a l : = I1 ’ access ;
end A f f e c t e r _ V a l e u r ;

package I o i s new T e x t _ I o . I n t e g e r _ I o ( I n t e g e r ) ;
begin
Affecter_Valeur ;
I o . Put ( G l o b a l . a l l ) ;
end Alloc_Faux ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 53/133
Unités de programme génériques (1)
Unité de programme paramétrée par : types, constantes,
sous-programmes, paquetages.
Procédure ou paquetage générique.
Permet d’effectuer un traitement identique sur plusieurs entités
différentes (ex : types).
Instanciation : une unité de programme générique ne peut pas être
employée sans être instanciée, c-à-d donner une valeur pour
chaque paramètre.
Structure :
generic
−− paramètres du générique
package fo o . . .
package body fo o . . .
−− u t i l i s a t i o n des paramètres dans l a s p é c i f i c a t i o n
−− e t l ’ i m p l é m e n t a t i o n du générique

UE systèmes temps réel Univ. Brest/Lab-STICC Page 54/133

Unités de programme génériques (2)
generic
ty p e Element i s p r i v a t e ;
w i t h procedure A ffi c h e _ Un ( E : i n Element ) ;
package L i s t e s i s
ty p e Element_Ptr i s access Element ;
ty p e C e l l u l e i s p r i v a t e ;
ty p e L i e n i s access C e l l u l e ;

procedure A f f i c h e r ( L : i n L i e n ) ;
procedure A j o u t e r ( L : i n o u t L i e n ; E : i n Element_Ptr ) ;
private
ty p e C e l l u l e i s r e c o r d
Suivant : Lien ;
Info : Element_Ptr ;
end r e c o r d ;
end L i s t e s ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 55/133

Unités de programme génériques (3)
package body L i s t e s i s
procedure A j o u t e r ( L : i n o u t L i e n ; E : i n Element_Ptr ) i s
Nouveau : L i e n ;
begin
Nouveau : = new C e l l u l e ;
Nouveau . I n f o : =E ; Nouveau . S u i v a n t : = L ; L : = Nouveau ;
end A j o u t e r ;

procedure A f f i c h e r ( L : i n L i e n ) i s
Courant : L i e n : = L ;
begin
w h i l e Courant / = n u l l l o o p
A ffi c h e _ Un ( Courant . I n f o . a l l ) ;
Courant : = Courant . S u i v a n t ;
end l o o p ;
end A f f i c h e r ;
end L i s t e s ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 56/133

Unités de programme génériques (4)
with Listes ;
procedure T e s t e _ L i s t e s i s

ty p e Personne i s r e c o r d ...
procedure A f f i c h e ( A : i n Personne ) i s ...

package Ma_Liste i s new L i s t e s ( Personne , A f f i c h e ) ;

use Ma_Liste ;

Une_Liste : L i e n ;
P : Ma_Liste . Element_Ptr ; −− p o i n t e u r s u r
−− une personne
begin
P: = new Personne ;
A j o u t e r ( Une_Liste , P ) ;
A f f i c h e r ( Une_Liste ) ;
...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 57/133

Sommaire
1. Généralités sur les systèmes embarqués temps réel.
2. Introduction au langage Ada 2005.
3. Concurrence.
4. Temps réel.
5. Exemples de runtimes Ada.
6. Résumé.
7. Références.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 58/133

Concurrence
Tâche
Synchronisation et communication par rendez vous.
Communication par objets protégés.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 59/133

Tâche (1)
• Une tâche Ada est constituée :
D’une spécification qui décrit son interface. Partie
visible.
D’une implémentation qui contient le code exécuté par
la tâche. Partie cachée.
Éventuellement d’un type. Dans le cas contraire, on
parle de tâche anonyme.

• Une tâche Ada est déclarée par :

Les instructions task/task type (spécification de la
tâche) et task body (implantation de la tâche).
La procédure principale est aussi une tâche.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 60/133

Tâche (2)
• Exemple d’une tâche anonyme, allouée statiquement :
w i t h T e x t _ I o ; use T e x t _ I o ;
procedure Tache_anonyme i s
t a s k Ma_Tache ;
t a s k body Ma_Tache i s
begin
loop
Put_Line ( " tache a c t i v e e " ) ;
delay 1 . 0 ;
end l o o p ;
end Ma_Tache ;
begin
null ;
end Tache_anonyme ;

• Combien de tâches ici ?

UE systèmes temps réel Univ. Brest/Lab-STICC Page 61/133

Tâche (3)
• Exemple de tâches typées, allouées statiquement :
w i t h T e x t _ I o ; use T e x t _ I o ;
procedure Tache_type i s
t a s k ty p e Un_Type ;
t a s k body Un_Type i s
begin
loop
Put_Line ( " tache a c t i v e e " ) ;
delay 1 . 0 ;
end l o o p ;
end Un_Type ;
T1 , T2 : Un_Type ;
T : a r r a y ( 1 . . 1 0 ) o f Un_Type ;
begin
null ;
end Tache_type ;

• Combien de tâches ici ?

UE systèmes temps réel Univ. Brest/Lab-STICC Page 62/133
Tâche (4)
• Exemple de tâches typées, allouées dynamiquement :
w i t h T e x t _ I o ; use T e x t _ I o ;
procedure Tache_dynam i s
t a s k ty p e Un_Type ;
t a s k body Un_Type i s
begin
loop
Put_Line ( " tache a c t i v e e " ) ;
delay 1 . 0 ;
end l o o p ;
end Un_Type ;
ty p e Un_Type_Ptr i s access Un_Type ;
T : a r r a y ( 1 . . 3 ) o f Un_Type_Ptr ;
begin
f o r i i n 1 . . 3 loop
T ( i ) : = new Un_Type ;
end l o o p ;
end Tache_dynam ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 63/133
Tâche (5)
• Une tâche peut être : active, avortée, achevée, terminée.
• Règles d’activation :
Tâche allouée statiquement: au début de bloc où la tâche est définie.
Tâche allouée dynamiquement : lors de l’allocation dynamique.

• Règles de terminaison :
Sur exception: l’exception est perdue si non rattrapée.
Lorsque toutes les tâches de niveau inférieur sont achevée.

• Avortement : grâce à l’instruction abort x, avec x le nom de la tâche.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 64/133

Tâche (6)
• Ce programme est faux. Pourquoi ?
procedure T a c h e _ i n c o r r e c t e i s
cpt : integer :=0;
t a s k ty p e Un_Type ;
t a s k body Un_Type i s
begin
loop
c p t : = c p t +1;
delay 1 . 0 ;
end l o o p ;
end Un_Type ;
T1 , T2 : Un_Type ;
begin
delay 3 . 0 ;
c p t : = c p t +1;
a b o r t T1 ; a b o r t T2 ;
end T a c h e _ i n c o r r e c t e ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 65/133

Tâche (7)
• Exercice 4 :
Dites pour les exemples de programme des pages 58, 59
et 60 quand les tâches sont activées et quand elles sont
terminées.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 66/133

Tâche (8)
• Exercice 5 :
Écrire un programme qui contient deux tâches. La première
tâche calcule et affiche les éléments de la suite Un = Un−1 ∗2
avec U0 = 1. La tâche doit attendre une seconde entre le
calcul/affichage de deux éléments successifs. La deuxième
tâche calcule et affiche les éléments de la suite Un = Un−1 +2
avec U0 = 0. La tâche doit attendre deux secondes entre le
calcul/affichage de deux éléments successifs.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 67/133

Concurrence
Tâche
Synchronisation et communication par rendez vous.
Communication par objets protégés.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 68/133

Mécanisme de rendez vous (1)

• Le rendez vous est un mécanisme :

Asymétrique : tâche appelante et tâche appelée.
Qui permet de synchroniser deux tâches : le rendez vous nécessite
que les deux tâches soient simultanément prêtes.
Qui permet l’échange de données entre deux tâches.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 69/133
Mécanisme de rendez vous (2)
• Mise en œuvre des rendez vous avec Ada :
Notion d’entrée: point de rendez vous déclaré dans la
spécification de la tâche. Interface de la tâche.
Spécification de tâche : peut comporter plusieurs
entrées.
Instruction accept : permet à une tâche d’attendre un
rendez vous sur l’une de ses entrées, puis, d’exécuter
une séquence d’instructions pendant le rendez vous.
Appelants : se placent en position de rendez vous en
référençant l’entrée voulue.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 70/133

Mécanisme de rendez vous (3)
• Exemple de rendez vous (synchronisation uniquement):
w i t h T e x t _ I o ; use T e x t _ I o ;
procedure H e l l o i s
t a s k Ma_Tache i s
e n t r y Hello_World ;
end Ma_Tache ;
t a s k body Ma_Tache i s
begin
loop
accept Hello_World do
Put_Line ( " H e l l o word " ) ;
end Hello_World ;
end l o o p ;
end Ma_Tache ;
begin
Ma_Tache . Hello_World ;
a b o r t Ma_Tache ;
end H e l l o ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 71/133
Mécanisme de rendez vous (4)
• Rendez vous avec communication:
t a s k ty p e Ma_Tache i s
e n t r y I n c r e m e n t e r ( S1 : i n o u t I n t e g e r ) ;
end Ma_Tache ;
t a s k body Ma_Tache i s
begin
loop
accept I n c r e m e n t e r ( S1 : i n o u t I n t e g e r ) do
S1 : = S1+1;
end I n c r e m e n t e r ;
end l o o p ;
end Ma_Tache ;
T1 : Ma_Tache ;
Val : I n t e g e r : = 0 ;
begin
T1 . I n c r e m e n t e r ( Val ) ;
Put_Line ( " Val = " & i n t e g e r ’ image ( Val ) ) ;
a b o r t T1 ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 72/133
Mécanisme de rendez vous (5)
• Quelques clauses additionnelles :
Clause select : permet d’attendre simultanément sur
plusieurs entrées.
Clause terminate : utilisée conjointement avec
select, permet d’interrompre proprement une
instruction accept
Entrée gardée : condition booléenne d’éligibilité de
l’entrée.
Clause else : attente non bloquante sur les entrées.
...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 73/133

Mécanisme de rendez vous (6)
• Tâches avec plusieurs entrées :
t a s k body Ma_Tache i s
Bool : Boolean : = False ;
begin
loop t a s k Ma_Tache i s
select e n t r y Hello_World ;
accept Hello_World do e n t r y Do_Exit ;
Put_Line ( " H e l l o word " ) ; end Ma_Tache ;
end Hello_World ;
or
accept Do_Exit do
Put_Line ( " Bye bye " ) ; begin
Bool : = True ; Ma_Tache . Hello_World ;
end Do_Exit ; Ma_Tache . Do_Exit ;
end s e l e c t ; end Main ;
e x i t when Bool ;
end l o o p ;
end Ma_Tache ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 74/133
Mécanisme de rendez vous (7)
• Exemple avec la clause terminate :
t a s k body Ma_Tache i s
t a s k Ma_Tache i s
begin
entry Incrementer
loop
( S1 : i n o u t I n t e g e r ) ;
select
end Ma_Tache ;
accept I n c r e m e n t e r
( S1 : i n o u t I n t e g e r ) do
Val : I n t e g e r : = 0 ;
S1 : = S1+1;
end I n c r e m e n t e r ;
begin
or
Ma_Tache . I n c r e m e n t e r ( Val ) ;
terminate ;
P u t _ l i n e ( " Val = " &
end s e l e c t ;
i n t e g e r ’ image ( Val ) ) ;
end l o o p ;
end i n c r e m e n t _ t e r m i n a t e ;
end Ma_Tache ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 75/133

Concurrence
Tâche
Synchronisation et communication par rendez vous.
Communication par objets protégés.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 76/133

Objets et types protégés (1)
• Un objet protégé c’est :
Une structure de données comportant plusieurs variables
accessibles de façon concurrente.
Un mécanisme de synchronisation proche du modèle
lecteur-rédacteur.

• Un objet protégé est constitué :

D’une spécification qui décrit son interface: procédures, fonctions et
entrées. Partie visible.
D’une implémentation qui inclue les variables protégées et le code
des fonctions, procédures et entrées. Partie cachée.
Éventuellement d’un type. Dans le cas contraire, on parle d’objet
anonyme.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 77/133

Objets et types protégés (2)
• Verrous mis en œuvre par un objet protégé :
Fonctions : peuvent être exécutées de façon
concurrente car ne change pas l’état des variables
protégées : lecture des variables seulement.
Procédures : exécutées en exclusion mutuelle sur les
variables protégées.

=⇒ Verrous fonctions et procédures =

lecteurs/rédacteurs.
Entrées : idem procédure + garde booléenne. Une
entrée dont la garde est à false ne peut pas être
exécutée (blocage de la tâche), même si aucune
procédure/entrée/fonction utilise l’objet.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 78/133

Objets et types protégés (3)
• Exemple d’une variable protégée (spécification) :

package Vars i s
p r o t e c t e d t y p e Var i s
procedure E c r i t u r e ( Va le u r : i n I n t e g e r ) ;
f u n c t i o n Lecture re tu rn Integer ;
private
Variable : Integer :=0;
end Var ;
end Vars ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 79/133

Objets et types protégés (4)
• Exemple d’une variable protégée (corps) :

package body Vars i s

p r o t e c t e d body Var i s
procedure E c r i t u r e ( Va le u r : i n I n t e g e r ) i s
begin
V a r i a b l e : = Va le u r ;
end E c r i t u r e ;
f u n c t i o n Lecture re tu rn Integer i s
begin
return Variable ;
end L e c t u r e ;
end Var ;
end Vars ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 80/133
Objets et types protégés (5)
• Exemple d’une variable protégée (utilisation) :

w i t h Vars ; use Vars ;

procedure V a r i a b l e _ P r o t e g e e i s
Une : Vars . Var ;
t a s k Ma_Tache ;
t a s k body Ma_Tache i s
begin
loop
Put_Line ( " Val = " & i n t e g e r ’ image ( Une . L e c t u r e ) ) ;
end l o o p ;
end Ma_Tache ;
I : Integer :=0;
begin
loop
Une . E c r i t u r e ( I ) ;
I : = I +1;
end l o o p ;
end V a r i a b l e _ P r o t e g e e ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 81/133
Objets et types protégés (6)
• Exemple d’un sémaphore (spécification):
package Semaphores i s
p r o t e c t e d t y p e Semaphore i s
entry P;
procedure V ;
procedure I n i t (
Val : i n N a t u r a l ) ;
private
Value : N a t u r a l : = 1 ;
end Semaphore ;
end Semaphores ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 82/133

Objets et types protégés (7)
• Exemple d’un sémaphore (corps):

package body Semaphores i s

p r o t e c t e d body Semaphore i s
e n t r y P when Value > 0 i s
begin
Value : = Value −1;
end P ;
procedure V i s
begin
Value : = Value +1;
end V ;
procedure I n i t ( Val : i n N a t u r a l ) i s
begin
Value : = Val ;
end I n i t ;
end Semaphore ;
end Semaphores ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 83/133

Objets et types protégés (8)
Mutex : Semaphore ;
t a s k ty p e Une ;
t a s k body Une i s
begin
loop
Mutex . P ;
Put_Line ( " en s e c t i o n c r i t i q u e !!");
Mutex . V ;
end l o o p ;
end Une ;
ty p e Une_Ptr i s access Une ;
P l u s i e u r s : a r r a y ( 1 . . 1 0 ) o f Une_Ptr ;

begin
Mutex . I n i t ( 1 ) ;
f o r i i n 1..10 loop
P l u s i e u r s ( i ) : = new Une ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 84/133

Objets et types protégés (9)
• Exemple d’un lecteur/rédacteur :

package Lecteurs_Redacteurs i s
protected ty p e Lecteur_Redacteur i s
e n t r y Debut_Lecture ;
procedure F i n _ L e c t u r e ;
entry Debut_Ecriture ;
procedure F i n _ E c r i t u r e ;
private
Nb_Lecteurs : N a t u r a l : = 0 ;
Nb_Redacteurs : N a t u r a l : = 0 ;
end Lecteur_Redacteur ;
end l e c t e u r s _ R e d a c t e u r s ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 85/133

Objets et types protégés (10)
p r o t e c t e d body Lecteur_Redacteur i s
e n t r y Debut_Lecture when Nb_Redacteurs = 0 i s
begin
Nb_Lecteurs : = Nb_Lecteurs +1;
end Debut_Lecture ;
e n t r y D e b u t _ E c r i t u r e when Nb_Lecteurs + Nb_Redacteurs = 0 i s
begin
Nb_Redacteurs : = Nb_Redacteurs +1;
end D e b u t _ E c r i t u r e ;
procedure F i n _ L e c t u r e i s
begin
Nb_Lecteurs : = Nb_Lecteurs −1;
end F i n _ L e c t u r e ;
procedure F i n _ E c r i t u r e i s
begin
Nb_Redacteurs : = Nb_Redacteurs −1;
end F i n _ E c r i t u r e ;
end Lecteur_Redacteur ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 86/133
Sommaire
1. Généralités sur les systèmes embarqués temps réel.
2. Introduction au langage Ada 2005.
3. Concurrence.
4. Temps réel.
5. Exemples de runtimes Ada.
6. Résumé.
7. Références.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 87/133

Temps réel

• Services temps réel disponibles via les standards:

ISO/IEC Ada 1995/2005 : et en particulier les annexes
C (Systems programming) et D (Real-Time) [TAF 06].
"Binding" Ada POSIX 1003 [BUR 07, GAL 95].
ARINC 653 [ARI 97].
...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 88/133

Temps réel et Ada 2005
• Avec Ada 2005, services temps réel offerts via des
pragmas et des paquetages spécifiques:

Comment implanter une tâche périodique :

1. Représenter le temps (paquetage
Ada.Real_Time).
2. Implanter les réveils périodiques (instruction delay).
3. Affecter des priorités (pragma).
Comment activer un protocole d’héritage de priorité
(pour des objets/types protégés).
Comment sélectionner un ordonnanceur (RM, EDF, ...).
...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 89/133

Ada 2005: tâches périodiques (1)
package Ada . Real_Time i s
ty p e Time i s p r i v a t e ;
Time_Unit : c o n s t a n t : = i m p l e m e n ta ti o n − d e f i n e d ;
ty p e Time_Span i s p r i v a t e ;
...
f u n c t i o n Clock r e t u r n Time ;
...
f u n c t i o n Nanoseconds (NS : I n t e g e r ) r e t u r n Time_Span ;
f u n c t i o n Microseconds (NS : I n t e g e r ) r e t u r n Time_Span ;
f u n c t i o n Seconds (S : I n t e g e r ) r e t u r n Time_Span ;
f u n c t i o n Minutes (M : I n t e g e r ) r e t u r n Time_Span ;
...

• Ada.Real_Time est un paquetage qui offre une horloge haute résolu-

tion and documentée, ainsi que des sous-programmes pour la manipuler.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 90/133

Ada 2005: tâches périodiques (2)
• Principaux types et sous-programmes :

Time implémente un date absolue. Ce type doit

permettre d’exprimer des dates de 50 ans au moins.

Time_Span représente une durée.

Time_Unit la plus petite unité de temps représentable

par le type Time. Défini par l’implémentation, mais doit
être inférieur ou égal à 20 micro-secondes.

Clock retourne le temps écoulé depuis epoch.

Sous-programmes pour convertir des données

temporelles en Time_Span : Nanoseconds,
Microseconds, ...
UE systèmes temps réel Univ. Brest/Lab-STICC Page 91/133
Ada 2005: tâches périodiques (3)
• L’instruction delay :

1. delay expr : bloque une tâche pendant au moins

expr unités de temps.
2. delay until expr : bloque une tâche jusqu’au
moins la date expr.

• Une tâche ne peut pas être réveillée avant le délai/date

spécifié par l’instruction delay.

• Mais une tâche peut très bien être réveillée après le

délai/date spécifié par l’instruction delay. Une borne
maximale doit être documentée par l’éditeur du compilateur.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 92/133

Ada 2005: tâches périodiques (4)
• Exemple d’une tâche périodique :
w i t h Ada . Real_Time ; use Ada . Real_Time ;
...
t a s k Tspeed i s
end Tspeed ;

t a s k body Tspeed i s
Next_Time : Ada . Real_Time . Time : = Clock ;
P e r i o d : c o n s t a n t Time_Span : = M i l l i s e c o n d s ( 2 5 0 ) ;
begin
loop
−− Read th e c a r speed sensor
Read_Speed ;
Next_Time : = Next_Time + P e r i o d ;
d e l a y u n t i l Next_Time ;
end l o o p ;
end Tspeed ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 93/133

• Utiliser delay until plutôt que delay afin d’éviter la dérive.

Ada 2005: tâches périodiques (5)
package System i s
−− P r i o r i t y − r e l a t e d D e c l a r a t i o n s (RM D. 1 )
Max_Priority : constant P o s i t i v e := 30;
M a x _ I n t e r r u p t _ P r i o r i t y : constant P o s i t i v e := 31;

subtype A n y _ P r i o r i t y is Integer range 0 . . 31;

subtype P r i o r i t y i s A n y _ P r i o r i t y range 0 . . 30;
subtype I n t e r r u p t _ P r i o r i t y i s A n y _ P r i o r i t y range 31 . . 3 1 ;

D e f a u l t _ P r i o r i t y : constant P r i o r i t y := 15;
...

[Link] doit offrir au moins 30 niveaux de priorité, mais

plus, c’est mieux pour l’analyse de l’ordonnancement.
Priorité de Base = priorité affectée statiquement.
Priorité active = priorité héritée (accès aux objets protégés).

UE systèmes temps réel Univ. Brest/Lab-STICC Page 94/133

Ada 2005: tâches périodiques (6)
• Règles d’assignation des priorités avec Ada 2005:
Toute tâche a une priorité par défaut (voir le paquetage
System).
Le pragma Priority peut être employé dans la
spécification d’une tâche.
Le pragma Priority peut être employé dans une
procédure principale.
Sans pragma, toute tâche hérite de la priorité de la
tâche qui l’a instanciée.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 95/133

Ada 2005: tâches périodiques (7)
Déclaration d’une tâche :

t a s k Tspeed i s
pragma P r i o r i t y ( 1 0 ) ;
end Tspeed ;

Déclaration d’un type tâche :

t a s k ty p e T i s
pragma P r i o r i t y ( 1 0 ) ;
end T ;
Tspeed : T

Déclaration d’un type tâche avec discriminant :

t a s k ty p e T ( M y _ P r i o r i t y : System . P r i o r i t y ) i s
entry Service ( . . .
pragma P r i o r i t y ( M y _ P r i o r i t y ) ;
end T ;
Tspeed : T ( M y _ P r i o r i t y = >10);

UE systèmes temps réel Univ. Brest/Lab-STICC Page 96/133

Ada 2005: tâches périodiques (8)
• Soit le jeu de tâches :
Tache Période Priorité
(milli-secondes)
Tdisplay Pdisplay = 100 12
Tengine Pengine = 500 10
Tspeed Pspeed = 250 11

• Et le code de chaque tâche :

procedure Display_Speed i s
begin
Put_Line ( " T d i s p l a y d i s p l a y s th e speed o f th e c a r " ) ;
end Display_Speed ;

procedure Read_Speed i s . . .
procedure Monitor_Engine i s ...
UE systèmes temps réel Univ. Brest/Lab-STICC Page 97/133
Ada 2005: tâches périodiques (9)
w i t h System ;
generic
w i t h procedure Run ;
package G e n e r i c _ P e r i o d ic _T a sk i s
t a s k ty p e P e r i o d i c _ T a s k ( T a s k _ P r i o r i t y : System . P r i o r i t y ;
Period_In_Milliseconds : Natural ) i s
pragma P r i o r i t y ( T a s k _ P r i o r i t y ) ;
end P e r i o d i c _ T a s k ;
end G e n e r i c _ P e r i o di c_ T as k ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 98/133

Ada 2005: tâches périodiques (10)
package body G e n e r i c _ P e r i o di c_ T as k i s
t a s k body P e r i o d i c _ T a s k i s
Next_Time : Ada . Real_Time . Time : = Clock ;
Period : c o n s t a n t Time_Span : =
Milliseconds ( Period_In_Milliseconds ) ;
begin
loop
Run ;
Next_Time : = Next_Time + P e r i o d ;
d e l a y u n t i l Next_Time ;
end l o o p ;
end P e r i o d i c _ T a s k ;
end G e n e r i c _ P e r i o di c_ T as k ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 99/133

Ada 2005: tâches périodiques (11)
procedure Car_System i s
package P1 i s new G e n e r i c _ P e r i o di c_ T as k ( Run => Display_Speed ) ;
package P2 i s new G e n e r i c _ P e r i o di c_ T as k ( Run => Read_Speed ) ;
package P3 i s new G e n e r i c _ P e r i o di c_ T as k ( Run => Monitor_Engine ) ;

T d i s p l a y : P1 . P e r i o d i c _ T a s k ( T a s k _ P r i o r i t y => 12 ,
P e r i o d _ I n _ M i l l i s e c o n d s => 1 0 0 ) ;
Tspeed : P2 . P e r i o d i c _ T a s k ( T a s k _ P r i o r i t y => 11 ,
P e r i o d _ I n _ M i l l i s e c o n d s => 2 5 0 ) ;
Tengine : P3 . P e r i o d i c _ T a s k ( T a s k _ P r i o r i t y => 10 ,
P e r i o d _ I n _ M i l l i s e c o n d s => 5 0 0 ) ;

pragma P r i o r i t y ( 2 0 ) ;

begin
Put_Line ( " Les tâches démarrent s u r l a t e r m i n a i s o n de
l a procedure p r i n c i p a l e " ) ;
end Car_System ;
UE systèmes temps réel Univ. Brest/Lab-STICC Page 100/133
Ada 2005: types/objets protégés (1)
• Protocole d’héritage de priorités supportés par Ada
2005 : ICPP (Immediate Ceiling Priority Protocol) et PLCP
(Preemption Level Control Protocol).

• ICPP est une variation de PCP dont le

fonctionnement est:
Priorité plafond d’un objet protégé = maximum des
priorités de base des tâches qui l’emploient.
Priorité active d’une tâche = maximum entre sa priorité
de base et la priorité plafond de tous les objets
protégés qu’elle a verrouillés.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 101/133

Ada 2005: types/objets protégés (2)

• Affectation d’une priorité plafond à un objet protégé :

p r o t e c t e d A_Mutex i s
pragma P r i o r i t y ( 1 5 ) ;
entry E . . .
procedure P . . .
end A_Mutex ;

• Pour activer le protocole ICPP :

pragma L o c k i n g _ P o l i c y ( C e i l i n g _ L o c k i n g ) ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 102/133

Temps réel et Ada 2005
• Avec Ada 2005, services temps réel offerts via des
pragmas et des paquetages spécifiques:

Comment implanter une tâche périodique :

1. Représenter le temps (paquetage
Ada.Real_Time).
2. Implanter les réveils périodiques (instruction delay).
3. Affecter des priorités (pragma).
Comment activer un protocole d’héritage de priorité
(pour des objets/types protégés).
Comment sélectionner un ordonnanceur (RM, EDF, ...).
...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 103/133

Ordonnancement avec Ada 2005 (1)

Une file d’attente pour chaque niveau de priorité. Toutes les tâches prêtes de même
priorité sont insérées dans la même file d’attente.
Chaque file d’attente a une politique (ou dispatching policy ).
Deux niveaux d’ordonnancement:
1. Choisir la file d’attente de priorité maximale avec au moins une tâche.
2. Choisir la tâche à exécuter parmi les tâches de la file d’attente sélectionnée en
(1), et selon la politique de la file.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 104/133

Ordonnancement avec Ada 2005 (2)

• Exemple de la politique d’ordonnancement préemptive à priorité fixe (politique

FIFO_Within_Priorities) :
Quand une tâche devient prête, elle est insérée à la queue de file associée à sa
priorité.
La tâche en tête de file obtient le processeur quand sa file est la file de plus haute
priorité avec une tâche prête.
Quand la tâche en cours d’exécution passe à l’état bloquée ou terminée, alors elle
quitte la file.

=⇒ Il est facile d’appliquer les tests de faisabilité (cf. cours sur Rate Monotonic), si les
priorités sont correctement affectées (priorités uniques et selon la période).

UE systèmes temps réel Univ. Brest/Lab-STICC Page 105/133

Ordonnancement avec Ada 2005 (3)
• Activation de la politique FIFO_Within_Priorities par :
pragma T a s k _ D i s p a t c h i n g _ P o l i c y ( F I F O _ W i t h i n _ P r i o r i t i e s ) ;

• Autres politiques d’ordonnancement d’Ada 2005 :

1. Ordonnancement non préemptif à priorités fixes :

pragma T a s k _ D i s p a t c h i n g _ P o l i c y (
Non_Preemptive_FIFO_Within_Priorities ) ;

2. Ordonnancement Earliest deadline first :

pragma T a s k _ D i s p a t c h i n g _ P o l i c y (
EDF_Across_Priorities ) ;

3. Ordonnancement Round robin :

pragma T a s k _ D i s p a t c h i n g _ P o l i c y (
Round_Robin_Within_Priorities ) ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 106/133

Ordonnancement avec Ada 2005 (4)

• Cohabitation de tâches critiques et non critiques grâce à des

politiques différentes selon les niveaux de priorité :
pragma P r i o r i t y _ S p e c i f i c _ D i s p a t c h i n g (
FIFO_Within_Priorities , 3 , 31);
pragma P r i o r i t y _ S p e c i f i c _ D i s p a t c h i n g (
EDF_Across_Priorities , 2 , 2 ) ;
pragma P r i o r i t y _ S p e c i f i c _ D i s p a t c h i n g (
Round_Robin_Within_Priorities , 0 , 1 ) ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 107/133

Ordonnancement avec Ada 2005 (5)
• Exemple de notre application automobile :
procedure Car_System i s
...
T d i s p l a y : P1 . P e r i o d i c _ T a s k ( T a s k _ P r i o r i t y => 12 ,
P e r i o d _ I n _ M i l l i s e c o n d s => 1 0 0 ) ;
Tspeed : P2 . P e r i o d i c _ T a s k ( T a s k _ P r i o r i t y => 11 ,
P e r i o d _ I n _ M i l l i s e c o n d s => 2 5 0 ) ;
Tengine : P3 . P e r i o d i c _ T a s k ( T a s k _ P r i o r i t y => 10 ,
P e r i o d _ I n _ M i l l i s e c o n d s => 5 0 0 ) ;
pragma P r i o r i t y ( 2 0 ) ;
...
end Car_System ;

−− F i c h i e r gnat . adc ( ou d i r e c t e m e n t dans l ’ u n i t é de programme )

pragma T a s k _ D i s p a t c h i n g _ P o l i c y ( F I F O _ W i t h i n _ P r i o r i t i e s ) ;
pragma L o c k i n g _ P o l i c y ( C e i l i n g _ L o c k i n g ) ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 108/133

Le profil Ravenscar (1)
• Comment être certain que l’application peut être
analysée avec les tests de faisabilité de Rate
Monotonic ? =⇒ utiliser Ravenscar.

Ravenscar = sous-ensemble d’Ada compatible avec

les tests de faisabilité.
Ravenscar = profil défini par le standard Ada 2005.
Profil = ensemble de restrictions, exprimées par des
pragmas et vérifiées par le compilateur, et donc
assurées à l’exécution.
Activation de Ravenscar :
pragma p r o f i l e ( Ravenscar ) ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 109/133

Le profil Ravenscar (2)
• Restrictions de Ravenscar :

pragma T a s k _ D i s p a t c h i n g _ P o l i c y ( F I F O _ W i t h i n _ P r i o r i t i e s ) ;
pragma L o c k i n g _ P o l i c y ( C e i l i n g _ L o c k i n g ) ;
pragma R e s t r i c t i o n s (
No_Abort_Statements , No_Dynamic_Attachment ,
No_Dynamic_Priorities , No_Implicit_Heap_Allocations ,
No_Local_Protected_Objects , No_Local_Timing_Events ,
No _ P r o te c te d_T y pe_A lloc ators , No_Relative_Delay ,
No_Requeue_Statements , No_Select_Statements ,
No _ S p e c i fi c _ T e r m i n a ti o n _ Ha n d l e r s , No_Task_Allocators ,
No_Task_Hierarchy , No_Task_Termination ,
Simple_Barriers ,
Max_Entry_Queue_Length => 1 , M a x _ P r o te c te d _ E n tri es => 1 ,
Max_Task_Entries => 0 ,
No_Dependence => Ada . Asynchronous_Task_Control ,
No_Dependence => Ada . Calendar ,
...
);
UE systèmes temps réel Univ. Brest/Lab-STICC Page 110/133
Temps réel

• Services temps réel disponibles via les standards :

ISO/IEC Ada 1995 and 2005 : et en particulier les
annexes C (Systems programming) et D (Real-Time)
[TAF 06].
Binding Ada POSIX 1003 [BUR 07, GAL 95].
ARINC 653 [ARI 97].
...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 111/133

Standard POSIX 1003 (1)

Ordonnancement préemptif à priorités fixes. Au moins 32 niveaux de

priorités. Files d’attente de tâches prêtes pour chaque priorité.
Ordonnancement à deux niveaux :
1. Choisir la file d’attente de priorité maximale avec au moins une
tâche (prête).
2. Choisir la tâche de la file sélectionnée en (1) selon une politique.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 112/133
Standard POSIX 1003 (2)

• Politiques POSIX :
1. SCHED_FIFO : identique à FIFO_Within_Priorities. La tâche
quitte la tête de file si :
Terminaison de la tâche.
Blocage de la tâche (E/S, attente d’un délai) => remise en queue.
Libération explicite => remise en queue.
2. SCHED_RR : idem SCHED_FIFO mais en plus, la tâche en tête de
file est déplacée en queue après expiration d’un quantum (round
robin).
3. SCHED_OT HERS : fonctionnement non normalisé.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 113/133
Standard POSIX 1003 (3)
• Comment utiliser POSIX 1003.1b dans une application
Ada : en utilisant le "binding" Ada POSIX 1003.5 (ex :
Florist d’AdaCore).

• Florist est un ensemble de paquetage permettant de

manipuler les concepts de priorité et politique POSIX :
package POSIX . Process_Scheduling i s

subtype S c h e d u l i n g _ P r i o r i t y i s I n t e g e r ;

ty p e S c h e d u l i n g _ P o l i c y i s new I n t e g e r ;
Sched_FIFO : constant Scheduling_Policy := . . .
Sched_RR : constant Scheduling_Policy := . . .
Sched_Other : c o n s t a n t S c h e d u l i n g _ P o l i c y : = . . .

ty p e Scheduling_Parameters i s p r i v a t e ;

UE systèmes temps réel Univ. Brest/Lab-STICC Page 114/133

Standard POSIX 1003 (4)
• Sous-programmes qui permettent à l’application de s’adapter au
système sous jacent :
package POSIX . Process_Scheduling i s
...
f u n c t i o n Get_Maximum_Priority ( P o l i c y : S c h e d u l i n g _ P o l i c y )
return Scheduling_Priority ;
f u n c t i o n G e t_ M i n i m u m _ P r io r ity ( P o l i c y : S c h e d u l i n g _ P o l i c y )
return Scheduling_Priority ;

f u n c t i o n Get_Round_Robin_Interval
( Process : P O S I X _ P r o c e s s _ I d e n t i f i c a t i o n . Process_ID )
r e t u r n POSIX . Timespec ;
...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 115/133

Standard POSIX 1003 (5)
• Consultation/modification de la priorité d’un processus :

package POSIX . Process_Scheduling i s

procedure S e t _ P r i o r i t y
( Parameters : i n o u t Scheduling_Parameters ;
Priority : Scheduling_Priority ) ;
procedure S e t _ S c h e d u l i n g _ P o l i c y
( Process : P O S I X _ P r o c e s s _ I d e n t i f i c a t i o n . Process_ID ;
New_Policy : S c h e d u l i n g _ P o l i c y ;
Parameters : Scheduling_Parameters ) ;
procedure Set_Scheduling_Parameters
( Process : P O S I X _ P r o c e s s _ I d e n t i f i c a t i o n . Process_ID ;
Parameters : Scheduling_Parameters ) ;

f u n c t i o n G e t_ S c h e d u l i n g _ P o l i c y . . .
function Get_Priority ...
f u n c t i o n Get_Scheduling_Parameters . . .
UE systèmes temps réel Univ. Brest/Lab-STICC Page 116/133
Standard POSIX 1003 (6)
• Exemple :
w i t h POSIX . P r o c e s s _ I d e n t i f i c a t i o n ;
use POSIX . P r o c e s s _ I d e n t i f i c a t i o n ;
w i t h POSIX . Process_Scheduling ;
use POSIX . Process_Scheduling ;

Pid1 : Process_ID ;
Sched1 : Scheduling_Parameters ;

begin
Pid1 : = Get_Process_Id ;
Sched1 : = Get_Scheduling_Parameters ( Pid1 ) ;

S e t _ P r i o r i t y ( Sched1 , 1 0 ) ;
S e t _ S c h e d u l i n g _ P o l i c y ( Pid1 , SCHED_FIFO , Sched1 ) ;
Set_Scheduling_Parameters ( Pid1 , Sched1 ) ;
...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 117/133

Standard POSIX 1003 (7)
• Doit on utiliser POSIX avec Ada ?

• Points positifs de POSIX:

POSIX est supporté par de nombreux systèmes d’exploitation temps
réel.
Les tests de faisabilité de Rate Monotonic sont utilisables avec
POSIX (à condition que toutes les tâches aient des priorités uniques).

• Points négatifs de POSIX :

Un processus Unix, c’est quoi dans une runtime Ada ? Et les threads
POSIX ?
POSIX est il portable ?

UE systèmes temps réel Univ. Brest/Lab-STICC Page 118/133

Sommaire
1. Généralités sur les systèmes embarqués temps réel.
2. Introduction au langage Ada 2005.
3. Concurrence.
4. Temps réel.
5. Exemples de runtimes Ada.
6. Résumé.
7. Références.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 119/133

Exemples de runtimes Ada (1)
• Rappels sur les runtimes :
Bibliothèques constituant l’environnement d’exécution d’un
programme Ada.
Doit permettre d’exécuter un même programme de façon identique
sur des matériels/systèmes d’exploitation différents.
Adapte les services du système d’exploitation aux abstractions du
langage.
Attention, une runtime peut ne pas contenir tous les éléments du
langage:
1. Le compilateur peut aider à détecter les éléments disponibles au
non.
2. Le paquetage System peut aider à détecter les éléments
disponibles ou non.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 120/133

Exemples de runtimes Ada (2)
Open-Ravenscar, basé sur le système d’exploitation ORK.
Compatible Ada 2005. (Universidad Politécnica de Madrid,
[Link]

Marte OS + compilateur GNAT. (Universidad de Cantabria,

[Link]

Runtime GNAT disponibles pour Windows, Linux, Solaris et de

nombreux autres systèmes
(AdaCore,[Link]

RTEMS operating system (OAR Corporation,

[Link]
...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 121/133

Exemples de runtimes Ada (3)

• Runtime RTEMS :
RTEMS : système d’exploitation temps réel/GNU GPL pour
applications C et Ada critiques de faible envergure.
Disponible pour de nombreux BSP (dont processeur Leon : 32 bits,
VHDL open-source, SMP ou AMP, compatible SPARC, applications
aéronautiques/spatials).
Compilateur GNAT/Ada 2005 (société AdaCore).
Compilation croisée : compilation sur Linux, exécution sur Leon.
UE systèmes temps réel Univ. Brest/Lab-STICC Page 122/133
Exemples de runtimes Ada (4)
• Compilation croisée :
1. Compilation sur Linux et génération d’un binaire SPARC :
# sparc −rtems4 .8 − gnatmake coucou
sparc −rtems4 .8 − gcc −c coucou . adb
sparc −rtems4 .8 − g n a t b i n d coucou . a l i
sparc −rtems4 .8 − g n a t l i n k coucou . a l i −o coucou . o b j
sparc −rtems4 .8 − s i z e coucou . o b j
text data bss dec hex f i l e n a m e
288800 13012 17824 319636 4e094 coucou . o b j
sparc −rtems4 .8 −nm coucou . o b j >coucou . num
# f i l e coucou . o b j
coucou . o b j : ELF 32− b i t MSB executable , SPARC, v e r s i o n 1 (SYSV) ,
s t a t i c a l l y linked , not s tr i p p e d
# f i l e / bin / l s
/ b i n / l s : ELF 32− b i t LSB executable , I n t e l 80386 , v e r s i o n 1 (SYSV) ,
d y n a m i c a l l y l i n k e d ( uses shared l i b s ) , f o r GNU/ L i n u x 2 . 6 . 1 5 , s t r i p p e d

UE systèmes temps réel Univ. Brest/Lab-STICC Page 123/133

Exemples de runtimes Ada (5)
• Compilation croisée (suite) :
2 Transfert du binaire vers la carte Leon (lien série, TCP/IP, ...)
3 Exécution sur une carte Leon. Logiciel tsim (émulateur de
processeur Leon 3).
# tsim −leon3 coucou . o b j
TSIM / LEON3 SPARC s i m u l a t o r , v e r s i o n 2 . 0 . 1 5 ( e v a l u a t i o n v e r s i o n )
a l l o c a t e d 4096 K RAM memory , i n 1 bank ( s )
a l l o c a t e d 32 M SDRAM memory , i n 1 bank
a l l o c a t e d 2048 K ROM memory
read 2257 symbols
tsim > go
resuming a t 0x40000000
** I n i t start **
* * I n i t end * *
coucou
Program e x i t e d n o r m a l l y .
tsim >
UE systèmes temps réel Univ. Brest/Lab-STICC Page 124/133
Exemples de runtimes Ada (6)
• Paquetage [Link] pour RTEMS :

package System i s
Tick : constant := 0.01;

ty p e B i t _ O r d e r i s ( H i g h _ O r d e r _ F i r s t , Low_Order_First ) ;
Default_Bit_Order : constant Bit_Order := High_Order_First ;

−− P r i o r i t y − r e l a t e d D e c l a r a t i o n s (RM D. 1 )
−− RTEMS p r o v i d e s 0 . . 2 5 5 p r i o r i t y l e v e l s
−−
Max_Priority : constant P o s i t i v e := 30;
M a x _ I n t e r r u p t _ P r i o r i t y : constant P o s i t i v e := 31;
subtype A n y _ P r i o r i t y is Integer range 0 . . 31;
subtype P r i o r i t y i s A n y _ P r i o r i t y range 0 . . 30;
subtype I n t e r r u p t _ P r i o r i t y i s A n y _ P r i o r i t y range 31 . . 3 1 ;
D e f a u l t _ P r i o r i t y : constant P r i o r i t y := 15;
...

UE systèmes temps réel Univ. Brest/Lab-STICC Page 125/133

Exemples de runtimes Ada (7)
• Runtime GNAT intel/Linux :

Linux/intel : système d’exploitation non temps réel mais service

temps réel souple via POSIX 1003.
Destiné aux applications temps réel non critiques.
Compilateur/runtime GNAT.
Compatible Ada 2005 mais aussi POSIX 1003 (avec binding
Ada/POSIX 1003.5, florist)
Pas de compilation croisée.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 126/133

Exemples de runtimes Ada (8)
• Spécificités :

Rappel ordonnancement Linux : priorité 0 pour SCHED_OTHER

(temps partagé) et priorités 1 à 99 pour SCHED_FIFO/SCHED_RR
(temps réel).
Les changements de priorité nécessitent les privilèges root, ignorés
dans le cas contraire.

GNAT/intel/Linux traduit les priorités Ada en priorités Linux selon la

politique du processus :
1. Processus en SCHED_OTHER : priorités Ada ignorées.
2. Processus en SCHED_RR ou SCHED_FIFO : priorités Ada
traduites dans la plage des priorités offertes par Linux pour ces
politiques.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 127/133

Exemples de runtimes Ada (9)
• Paquetage System de GNAT/Linux intel:
package System i s
Tick : c o n s t a n t : = 0.000 _001 ;

ty p e B i t _ O r d e r i s ( H i g h _ O r d e r _ F i r s t , Low_Order_First ) ;
D e f a u l t _ B i t _ O r d e r : c o n s t a n t B i t _ O r d e r : = Low_Order_First ;

−− P r i o r i t y − r e l a t e d D e c l a r a t i o n s (RM D. 1 )
−− L i n u x p r o v i d e s 0 . . 9 9 p r i o r i t y l e v e l s ( 0 f o r SCHED_OTHER, 1_99
−− f o r SCHED_FIFO /SCHED_RR
−−
Max_Priority : constant P o s i t i v e := 97;
M a x _ I n t e r r u p t _ P r i o r i t y : constant P o s i t i v e := 98;
subtype A n y _ P r i o r i t y is Integer range 0 . . 98;
subtype P r i o r i t y i s A n y _ P r i o r i t y range 0 . . 97;
subtype I n t e r r u p t _ P r i o r i t y i s A n y _ P r i o r i t y range 98 . . 9 8 ;
D e f a u l t _ P r i o r i t y : constant P r i o r i t y := 48;
...
UE systèmes temps réel Univ. Brest/Lab-STICC Page 128/133
Sommaire
1. Généralités sur les systèmes embarqués temps réel.
2. Introduction au langage Ada 2005.
3. Concurrence.
4. Temps réel.
5. Exemples de runtimes Ada.
6. Résumé.
7. Références.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 129/133

Résumé
Pourquoi Ada : fiabilité, abstractions temps réel,
compilation séparée, portabilité (modulo les
capacités/caractéristiques de la runtime).
Concurrence, synchronisation et communication :
tâches Ada, rendez vous et objets protégés.
Implanter une tâche périodique : priorités, réveils
périodiques, instant critique.
Être compatible avec les méthodes analytiques
d’ordonnançabilité.
Notions de compilation croisée et de runtime.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 130/133

Sommaire
1. Généralités sur les systèmes embarqués temps réel.
2. Introduction au langage Ada 2005.
3. Concurrence.
4. Temps réel.
5. Exemples de runtimes Ada.
6. Résumé.
7. Références.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 131/133

Références

[ARI 97] Arinc. Avionics Application Software Standard Interface. The Arinc Committee,
January 1997.

[BUR 07] A. Burns and A. Wellings. Concurrent and Real Time programming in Ada. 2007.
Cambridge University Press, 2007.

[GAL 95] B. O. Gallmeister. POSIX 4 : Programming for the Real World . O’Reilly and
Associates, January 1995.

[J. 93] J. M. Rifflet. La programmation sous UNIX. Addison-Wesley, 3rd edition, 1993.

[LES 10] D. Lesens. « Using Static Analysis in Space. Why doing so ? ». pages 51–70.
Proceedings of the SAS 2010 conference, Springer Verlag, LNCS, volume 6337,
September 2010.

[RIF 95] J. M. Rifflet. La communication sous UNIX : applications réparties. Ediscience

International, 2rd edition, 1995.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 132/133

Références

[TAF 06] S. T. Taft, R. A. Duff, R. L. Brukardt, E. Ploedereder, and P. Leroy. Ada 2005
Reference Manual. Language and Standard Libraries. International Standard ISO/IEC
8652/1995(E) with Technical Corrigendum 1 and Amendment 1. LNCS Springer Verlag,
number XXII, volume 4348., 2006.

[TIM 00] M. Timmerman. « RTOS Market survey : preliminary result ». Dedicated System
Magazine, (1):6–8, January 2000.

[VAH 96] U. Vahalia. UNIX Internals : the new frontiers. Prentice Hall, 1996.

UE systèmes temps réel Univ. Brest/Lab-STICC Page 133/133