• Aucun résultat trouvé

[PDF] Cours Paquetage et Héritage en langage ADA | Formation informatique

N/A
N/A
Protected

Academic year: 2021

Partager "[PDF] Cours Paquetage et Héritage en langage ADA | Formation informatique"

Copied!
128
0
0

Texte intégral

(1)

Développement de systèmes

embarqués temps réel avec Ada

Frank Singhoff Bureau C-207

Université de Brest, France LISyC/EA 3883

(2)

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é.

(3)

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

(4)

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).

(5)

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).

(6)

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).

(7)

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

séries, etc Ethernet , liens . TCP/IP sur . TFTP, NFS Environnement de développement Disque NFS Machine cible Hôte (windows) OS temps réel rsh GDB RGDB

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.

(8)

Etat du marché (1)

21.42 19.7 12.84 10.19 6.64 5.96 4.69 2.86 3.89 2.41 2.3 1.95 1.831.721.61 ChorusOS Autres RT-Linux RTX Nucleus+ Windows CE iRMXIII LynxOS VRTX OS9 Windows NT 5 10 15 20 25 30 Pourcentage

Nombre d’entreprises utilisant le système

vxWorks pSOS

Solution propriétaire QNX

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.

(9)

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.

(10)

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, ...

(11)

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 étudiée/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,

(12)

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

(13)

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.

(14)

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.

(15)

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é.

(16)

Introduction au langage Ada 2005 (1)

Pourquoi ce langage :

Abstractions temps réel : tâche, interruption, ordonnancement,

synchronisation, timer et gestion du temps, ...

Langage standardisé par l’ISO (portabilité).

Compilation séparée (logiciel volumineux) et typage fort (fiabilité).

Langage complexe.

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

Exemples : Airbus (320, 380), Boeing (777), Fokker, Tupolev, Eurostar,

Metro (14 Paris), TGV, Ariane (4 et 5), Satellites (Intersat), spatial (sonde

Cassini, Huygens, Soho, Mars Express), militaire (Tigre, Apache, Patriot)

=⇒

http://www.seas.gwu.edu/ mfeldman/ada-project-summary.html.

(17)

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.

(18)

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.

(19)

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

b e g in

−−

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

(20)

C’est quoi un programme Ada (3)

Exemple de procédure principale :

w i t h t e x t _ i o ;

use t e x t _ i o ;

procedure Coucou i s

b e g in

Pu t_ L in e ( " Coucou " ) ;

end Coucou ;

(21)

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

p r i v a t e

−−

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

b e g in

−−

code d ’ i n i t i a l i s a t i o n

(22)

C’est quoi un programme Ada (5)

Spécification d’un paquetage (fichier

lemien.ads

) :

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

: o u t 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 )

r e t u r n i n t e g e r ;

p r i v a t e

v a r i a b l e _ i n t e r n e : i n t e g e r ;

end Lemien ;

(23)

C’est quoi un programme Ada (6)

Implémentation d’un paquetage (

lemien.adb

) :

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 : o u t i n t e g e r ) i s b e g i n 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 ) r e t u r n i n t e g e r i s b e g i n 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 ; b e g i n v a r i a b l e _ i n t e r n e : = 1 0 0 ; end Lemien ;

(24)

C’est quoi un programme Ada (7)

Exemple d’utilisation du paquetage

lemien

:

w i t h t e x t _ i o ;

use t e x t _ i o ;

w i t h Lemien ;

use Lemien ;

procedure p r i n c i s

a : i n t e g e r : = 0 ;

b e g in

somme( 1 0 , 2 0 , a ) ;

P u t _ L in e ( i n t e g e r ’ image ( a ) ) ;

a : =somme ( 4 0 , 5 0 ) ;

P u t _ L in e ( i n t e g e r ’ image ( a ) ) ;

end p r i n c ;

(25)

C’est quoi un programme Ada (8)

Compiler ce programme (avec GNAT) :

>gnatmake p r i n c . adb

gcc

c le mie n . 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

g n a t l i n k p r i n c . 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, lemien.ali, lemien.o, princ.ali

et

(26)

C’est quoi un programme Ada (9)

Exercice 1 :

package c a l c u l i s

f u n c t i o n a d d i t i o n n e ( a : i n i n t e g e r ; b : i n i n t e g e r )

r e t u r n i n t e g e r ;

f u n c t i o n m u l t i p l i e ( a : i n i n t e g e r ; b : i n i n t e g e r )

r e t u r n i n t e g e r ;

f u n c t i o n s o u s t r a i t ( a : i n i n t e g e r ; b : i n i n t e g e r )

r e t u r n i n t e g e r ;

f u n c t i o n d i v i s e ( a : i n i n t e g e r ; b : i n i n t e g e r )

r e t u r n i n t e g e r ;

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.

(27)

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é).

Attribut : opérateurs pré-définis pour tous les types,

définis par l’utilisateur ou non.

(28)

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

(29)

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

(30)

Types, opérateurs, variables (4)

Exemples de déclarations :

w i t h 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 i 1 : i n t e g e r ; i 2 : i n t e g e r : = 0 ; s1 : s t r i n g ( 1 . . 1 0 ) ; f 1 : c o n s t a n t f l o a t : = 1 0 . 5 ; b e g i n P u t_ L i n e ( " 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 ) ) ; P u t_ L i n e ( " 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 ;

(31)

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 t e m p e r a t u r e i s new i n t e g e r range

280 . . 3 0 0 ;

t 1 : t e m p e r a t u r e : = 0 ;

t 2 : t e m p e r a t u r e : = 3 0 0 ;

i

: i n t e g e r : = 1 0 ;

b e g in

t 1 : = t 1 + t 2 ;

t 1 : = t 1 + i ;

t 2 : = t 2 + 1 ;

end d e r i v e ;

(32)

Types, opérateurs, variables (6)

Exemples types dérivés et sous types:

procedure d e r i v e i s

subtype t e m p e r a t u r e i s i n t e g e r range

280 . . 3 0 0 ;

t 1 : t e m p e r a t u r e : = 0 ;

t 2 : t e m p e r a t u r e : = 3 0 0 ;

i

: i n t e g e r : = 1 0 ;

b e g in

t 1 : = t 1 + t 2 ;

t 1 : = t 1 + i ;

t 2 : = t 2 + 1 ;

end d e r i v e ;

(33)

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 c o m p i l e c o r r e c t e 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 " ) ; }

(34)

Types, opérateurs, variables (8)

Et la version Ada maintenant :

w i t h 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 c o m p i l e procedure c f a u x i s t y p e t_ok_nok i s ( ok , nok ) ; t y p e t _ o n _ o f f i s ( o f f , on ) ; s t a t u s : t_ok_nok : = nok ; b e g i n i f ( s t a t u s = on ) th e n P u t_ L i n e ( " i s on \ n " ) ; end i f ; end c f a u x ;

(35)

Types, opérateurs, variables (9)

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.

(36)

Types, opérateurs, variables (10)

Exemple d’énumération :

w i t h t e x t _ i o ; use t e x t _ i o ; procedure enumeration i s t y p e u n _ j o u r i s ( l u n d i , mardi , m e r c r e d i , j e u d i , v e n d r e d i , samedi , dimanche ) ; j : u n _ j o u r : = l u n d i ; package i o i s new t e x t _ i o . e n u m e r a t i o n _ i o ( u n _ j o u r ) ; b e g i n i o . Put ( u n _ j o u r ’ f i r s t ) ; i o . Put ( u n _ j o u r ’ l a s t ) ; j : = u n _ j o u r ’ succ ( j ) ; i o . Put ( j ) ; P u t_ L i n e ( u n _ j o u r ’ image ( j ) ) ; end enumeration ;

(37)

Types, opérateurs, variables (11)

Exemple de tableau :

t y p e u n _ j o u r i s ( l u n d i , mardi , m e r c r e d i , j e u d i , v e n d r e d i , samedi , dimanche ) ; t y p e ta b 1 i s a r r a y ( 0 . . 3 ) o f i n t e g e r ; t y p e ta b 2 i s a r r a y ( 1 . . 4 ) o f u n _ j o u r ; t y p e ta b 3 i s a r r a y ( l u n d i . . dimanche ) o f i n t e g e r ; t 1 : ta b 1 : = ( 3 0 , 4 3 , 2 8 , 1 0 0 ) ; t 2 : ta b 2 : = (4= > l u n d i , 2=>mardi , 3=>dimanche , 1=> m e r c r e d i ) ; t 3 : ta b 3 ; b e g i n t 1 ( 0 ) : = t 1 ( 0 )∗2 ; t 2 ( 1 ) : = dimanche ; t 3 ( l u n d i ) : = 2 ; . . .

(38)

Types, opérateurs, variables (12)

Exemple de structure :

w i t h t e x t _ i o ; use t e x t _ i o ; procedure p o i n t i s t y p e u n _ p o i n t i s r e c o r d x : i n t e g e r ; y : i n t e g e r ; 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); b e g i n P u t_ L i n e ( i n t e g e r ’ image ( p1 . x ) ) ; P u t_ L i n e ( i n t e g e r ’ image ( p1 . y ) ) ; end p o i n t ;

(39)

Types, opérateurs, variables (13)

Exercice 2 : pour chaque affectation, indiquez si elle est correcte ou non.

t y p e t 1 i s new i n t e g e r range 0 . . 1 0 ; t y 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 : t 1 ; c : t 2 ; d : t 3 ; e , f : t 4 ; a : = b+c ; d : = c∗a ; d : = c∗f ; f : = a+b ; e : = e∗100;

(40)

Flots de contrôle (1)

Séquence :

i 1 ; i 2

Conditionnelle :

i f cond th e n i 1 ; e l s e i 2 ; end i f ;

(41)

Flots de contrôle (2)

Diverses formes d’itération :

w h i l e cond l o o p i 1 ; i 2 ; end l o o p ; l o o p i 1 ; i 2 ; e x i t cond ; end l o o p ; f o r i i n a . . b l o o p i 1 ; i 2 ; end l o o p ;

(42)

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 . . 1 0 l o o p s1 : = s1+ i ; end l o o p ; f o r j i n i n d i c e ’ f i r s t . . i n d i c e ’ l a s t l o o p 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 ;

(43)

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

(44)

Entrées/sorties (2)

Spécification de Text_Io:

package Ada . Text_IO i s

procedure Get ( Ite m : o u t S t r i n g ) ; procedure Put ( Ite m : S t r i n g ) ;

procedure Get_Line ( Ite m : o u t S t r i n g ; L a s t : o u t N a t u r a l ) ;

procedure P u t_ L i n e ( Ite m : S t r i n g ) ;

procedure New_Line ( Spacing : P o s i t i v e _ C o u n t : = 1 ) ;

g e n e r i c t y p e Num i s range < >; package I n t e g e r _ I O i s . . . g e n e r i c t y p e Num i s range < >; package Enumeration_IO i s . . .

(45)

Entrées/sorties (3)

Exemple du générique Integer_Io:

g e n e r i c

t y 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 ; De fa u l t_ B a s e : Number_Base : = 1 0 ; procedure Put ( Ite m : Num; Width : F i e l d : = D e f a u l t _ W i d t h ; Base : Number_Base : = De fa u l t_ B a s e ) ; procedure Get ( Ite m : o u t Num; L a s t : o u t P o s i t i v e ) ; end Ada . Text_IO . I n t e g e r _ I O ;

(46)

Entrées/sorties (4)

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 t y p e t e m p e r a t u r e i s new i n t e g e r range −300..300; 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 ( t e m p e r a t u r e ) ; t1 , t 2 : t e m p e r a t u r e ; b e g i n Put ( " S a i s i r t e m p e r a t u 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 t e m p e r a t u 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 ;

e x c e p t i o n

when D a t a _ E r r o r =>

P u t _ l i n e ( " Donnee s a i s i e non conforme au t y p e ’ te m p e r a tu r e ’ " ) ;

(47)

Entrées/sorties (5)

Exercice 3 :

Écrire un programme qui permet de saisir des entiers et

affiche la somme des valeurs saisies. Le programme doit

s’arrêter lorsque l’utilisateur saisie le chiffre zéro et doit

s’arrêter et afficher une erreur lorsque les données saisies

ne sont pas entières.

(48)

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 ;

p o i n t e u r 1 : I n t e g e r _ P t r : = 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

.

(49)

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 ) ; t y p e I n t e g e r _ P t r i s access I n t e g e r ; I : I n t e g e r : = 1 1 0 ; P1 , P2 , P3 , P4 : I n t e g e r _ P t r ; b e g i n 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 ;

(50)

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 A l l o c _ F a u x i s t y p e I n t e g e r _ P t r i s access I n t e g e r ; G l o b a l : 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 : = 1 0 0 ; b e g i n 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 ) ; b e g i n A f f e c t e r _ V a l e u r ; I o . Put ( G l o b a l . a l l ) ; end A l l o c _ F a u x ;

(51)

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).

Instantiation : 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 :

g e n e r i c −− paramètres du g é n é r i q u e package f o o . . . package body f o 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

(52)

Unités de programme génériques (2)

g e n e r i c

t y p e Element i s p r i v a t e ;

w i t h procedure Put ( E : i n Element ) ; package L i s t e s i s t y p e E l e m e n t_ P tr i s access Element ; t y p e C e l l u l e i s p r i v a t e ; t y 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 E l e m e n t_ P tr ) ; p r i v a t e t y p e C e l l u l e i s r e c o r d S u i v a n t : L i e n ; I n f o : E l e m e n t_ P tr ; end r e c o r d ; end L i s t e s ;

(53)

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 E l e m e n t_ P tr ) i s Nouveau : L i e n ; b e g i n 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 ; b e g i n w h i l e Courant / = n u l l l o o p Put ( 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 ;

(54)

Unités de programme génériques (4)

w i t h L i s t e s ;

procedure T e s t e _ L i s t e s i s

t y 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 . E l e m e n t_ P tr ; −− p o i n t e u r s u r −− une personne b e g i n P: = new Personne ; A j o u t e r ( Une_Liste , P ) ; A f f i c h e r ( Une_Liste ) ; . . .

(55)

Concurrence

Tâche

Synchronisation et communication par rendez vous.

Communication par objets protégés.

(56)

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).

(57)

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 b e g i n l o o p P u t_ L i n e ( " ta c h e a c t i v e e " ) ; d e l a y 1 . 0 ; end l o o p ; end Ma_Tache ; b e g i n n u l l ; end Tache_anonyme ;

(58)

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 t y p e Un_Type ; t a s k body Un_Type i s b e g i n l o o p P u t_ L i n e ( " ta c h e a c t i v e e " ) ; d e l a y 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 ; b e g i n n u l l ; end Tache_type ;

(59)

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 t y p e Un_Type ; t a s k body Un_Type i s b e g i n l o o p P u t_ L i n e ( " ta c h e a c t i v e e " ) ; d e l a y 1 . 0 ; end l o o p ; end Un_Type ;

t y p e Un_Type_Ptr i s access Un_Type ; T : a r r a y ( 1 . . 3 ) o f Un_Type_Ptr ; b e g i n f o r i i n 1 . . 3 l o o p T ( i ) : = new Un_Type ; end l o o p ; end Tache_dynam ;

(60)

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 terminée.

(61)

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 c p t : i n t e g e r : = 0 ; t a s k t y p e Un_Type ; t a s k body Un_Type i s b e g i n l o o p c p t : = c p t +1 ; d e l a y 1 . 0 ; end l o o p ; end Un_Type ; T1 , T2 : Un_Type ; b e g i n d e l a y 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 ;

(62)

Tâche (7)

Exercice 4 :

Dites pour les exemples de programme des pages 57, 58

et 59 quand les tâches sont activées et quand elles sont

terminées.

(63)

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

U

n

=

U

n−1

2

avec

U

0

= 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

U

n

=

U

n−1

+2

avec

U

0

= 0

. La tâche doit attendre deux secondes entre le

(64)

Concurrence

Tâche

Synchronisation et communication par rendez vous.

(65)

Mécanismes 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.

(66)

Mécanismes 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

(67)

Mécanismes 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 He l l o _ W o r l d ; end Ma_Tache ; t a s k body Ma_Tache i s b e g i n l o o p a c c e p t He l l o _ W o r l d do P u t_ L i n e ( " H e l l o word " ) ; end He l l o _ W o r l d ; end l o o p ; end Ma_Tache ; b e g i n Ma_Tache . He l l o _ W o r l d ; a b o r t Ma_Tache ; end H e l l o ;

(68)

Mécanismes de rendez vous (4)

Rendez vous avec communication:

t a s k t y 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 b e g i n l o o p a c c e p t 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 ; b e g i n T1 . I n c r e m e n t e r ( Val ) ;

P u t_ L i n e ( " Val = " & i n t e g e r ’ image ( Val ) ) ; a b o r t T1 ;

(69)

Mécanismes 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’interompre 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.

(70)

Mécanismes de rendez vous (6)

Tâches avec plusieurs entrées :

t a s k body Ma_Tache i s Bool : Boolean : = F a l s e ; b e g i n l o o p s e l e c t a c c e p t He l l o _ W o r l d do P u t_ L i n e ( " H e l l o word " ) ; end He l l o _ W o r l d ; o r a c c e p t Do_Exit do P u t_ L i n e ( " Bye bye " ) ; Bool : = True ; end Do_Exit ; end s e l e c t ; e x i t when Bool ; end l o o p ; end Ma_Tache ; t a s k Ma_Tache i s e n t r y He l l o _ W o r l d ; e n t r y Do_Exit ; end Ma_Tache ; b e g i n Ma_Tache . He l l o _ W o r l d ; Ma_Tache . Do_Exit ; end Main ;

(71)

Mécanismes de rendez vous (7)

Exemple avec la clause

terminate

:

t a s k body Ma_Tache i s b e g i n l o o p s e l e c t a c c e p t 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 ; o r t e r m i n a t e ; end s e l e c t ; end l o o p ; end Ma_Tache ; t a s k 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 ; Val : I n t e g e r : = 0 ; b e g i n Ma_Tache . I n c r e m e n t e r ( Val ) ; P u t _ l i n e ( " Val = " & i n t e g e r ’ image ( Val ) ) ; end i n c r e m e n t _ t e r m i n a t e ;

(72)

Concurrence

Tâche

Synchronisation et communication par rendez vous.

(73)

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.

(74)

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 par l’objet protégé: 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 être exécutée

(blocage de la tâche), même si aucune

procédure/entrée utilise l’objet.

(75)

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 ( V a l e u r : i n I n t e g e r ) ;

f u n c t i o n L e c t u r e r e t u r n I n t e g e r ;

p r i v a t e

V a r i a b l e : I n t e g e r : = 0 ;

end Var ;

end Vars ;

(76)

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 ( V a l e u r : i n I n t e g e r ) i s

b e g in

V a r i a b l e : = V a l e u r ;

end E c r i t u r e ;

f u n c t i o n L e c t u r e r e t u r n I n t e g e r i s

b e g in

r e t u r n V a r i a b l e ;

end L e c t u r e ;

end Var ;

end Vars ;

(77)

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 b e g i n

l o o p

P u t_ L i n e ( " 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 : I n t e g e r : = 0 ; b e g i n l o o p 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 ;

(78)

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

e n t r y P ;

procedure V ;

procedure I n i t

(

Val : i n N a t u r a l ) ;

p r i v a t e

Value : N a t u r a l : = 1 ;

end Semaphore ;

end Semaphores ;

(79)

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 b e g i n Value : = Value−1; end P ; procedure V i s b e g i n Value : = Value +1 ; end V ; procedure I n i t ( Val : i n N a t u r a l ) i s b e g i n Value : = Val ; end I n i t ; end Semaphore ; end Semaphores ;

(80)

Objets et types protégés (8)

Mutex : Semaphore ; t a s k t y p e Une ; t a s k body Une i s b e g i n l o o p Mutex . P ; P u t_ L i n e ( " 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 ;

t y 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 ;

b e g i n

Mutex . I n i t ( 1 ) ;

f o r i i n 1 . . 1 0 l o o p

(81)

Objets et types protégés (9)

Exemple d’un lecteur/rédacteur :

package L e c te u r s _ Re d a c te u r s i s p r o t e c t e d t y p e L e c te u r _ Re d a c te u r i s e n t r y Debut_Lecture ; procedure F i n _ L e c t u r e ; e n t r y D e b u t _ E c r i t u r e ; procedure F i n _ E c r i t u r e ; p r i v a t e Nb_Lecteurs : N a t u r a l : = 0 ; Nb_Redacteurs : N a t u r a l : = 0 ; end L e c te u r _ Re d a c te u r ; end l e c t e u r s _ R e d a c t e u r s ;

(82)

Objets et types protégés (10)

p r o t e c t e d body L e c te u r _ Re d a c te u r i s

e n t r y Debut_Lecture when Nb_Redacteurs = 0 i s b e g i n

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 b e g i n 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 b e g i n 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 b e g i n Nb_Redacteurs : = Nb_Redacteurs−1; end F i n _ E c r i t u r e ; end L e c te u r _ Re d a c te u r ;

(83)

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].

(84)

Temps réel

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, ...).

...

(85)

Ada 2005: tâches périodiques (1)

package Ada . Real_Time i s t y 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 t a t i o n−d e f i n e d ; t y 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

(86)

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

,

(87)

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

(88)

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 ) ; b e g i n

l o o p

−− Read t h 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 ;

Utiliser

delay until

plutôt que

delay

afin d’éviter la dérive.

(89)

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 ) M a x _ P r i o r i t y : c o n s t a n t P o s i t i v e : = 3 0 ; M a x _ I n t e r r u p t _ P r i o r i t y : c o n s t a n t P o s i t i v e : = 3 1 ; subtype A n y _ P r i o r i t y i s I n t e g e r range 0 . . 3 1 ; subtype P r i o r i t y i s A n y _ P r i o r i t y range 0 . . 3 0 ; 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 : c o n s t a n t P r i o r i t y : = 1 5 ; . . .

System.Priority

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.

(90)

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.

(91)

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 t y 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 t y p e T ( M y _ P r i o r i t y : System . P r i o r i t y ) i s

e n t r y S e r v i c e ( . . .

pragma P r i o r i t y ( M y _ P r i o r i t y ) ; end T ;

(92)

Ada 2005: tâches périodiques (8)

Soit le jeu de tâches :

Tache

Période

Priorité

(milli-secondes)

T

display

P

display

= 100

12

T

engine

P

engine

= 500

10

T

speed

P

speed

= 250

11

Et le code de chaque tâche :

procedure Display_Speed i s b e g i n P u t_ L i n e ( " T d i s p l a y d i s p l a y s t h e speed o f t h e c a r " ) ; end Display_Speed ; procedure Read_Speed i s . . . procedure M o n i to r _ E n g i n e i s . . .

(93)

Ada 2005: tâches périodiques (9)

w i t h System ; g e n e r i c w i t h procedure Run ; package G e n e r i c _ P e r i o d i c _ T a s k i s t a s k t y 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 ; P e r i o d _ I n _ M i l l i s e c o n d s : N a t u r a l ) 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 d i c _ T a s k ;

(94)

Ada 2005: tâches périodiques (10)

package body G e n e r i c _ P e r i o d i c _ T a s 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 ;

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 ( P e r i o d _ I n _ M i l l i s e c o n d s ) ; b e g i n l o o p 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 d i c _ T a s k ;

(95)

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 d i c _ T a s k ( Run => Display_Speed ) ; package P2 i s new G e n e r i c _ P e r i o d i c _ T a s k ( Run => Read_Speed ) ;

package P3 i s new G e n e r i c _ P e r i o d i c _ T a s k ( Run => M o n i to r _ E n g i n e ) ;

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 ) ; b e g i n P u t_ L i n e ( " Les tâ c h e s 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 ;

(96)

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

(97)

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 ) ;

e n t r y E . . .

procedure P . . .

end A_Mutex ;

Pour activer le protocole ICPP :

(98)

Ordonnancement avec Ada 2005 (1)

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, ...).

...

(99)

Ordonnancement avec Ada 2005 (2)

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 un tâche.

2. Choisir la tâche à exécuter parmi les tâches de la file d’attente sélectionné en (1), et selon la politique de la file.

(100)

Ordonnancement avec Ada 2005 (3)

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

(101)

Ordonnancement avec Ada 2005 (4)

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 (

N o n _ P r e e m p t i v e _ F I F O _ W i t h i n _ P r i o r i t i e s ) ;

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 ( E D F _ A c r o s s _ P r i o r i t i e s ) ;

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 ( R o u n d _ R o b i n _ W i t h i n _ P r i o r i t i e s ) ;

(102)

Ordonnancement avec Ada 2005 (5)

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 ( F I F O _ W i t h i n _ P r i o r i t i e s , 3 , 3 1 ) ; 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 ( E D F _ A c r o s s _ P r i o r i t i e s , 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 ( R o u n d _ R o b i n _ W i t h i n _ P r i o r i t i e s , 0 , 1 ) ;

(103)

Ordonnancement avec Ada 2005 (6)

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 g n a t . 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 ) ;

(104)

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 :

(105)

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 , N o _ D y n a m i c _ P r i o r i t i e s , N o _ I m p l i c i t _ H e a p _ A l l o c a t i o n s ,

No _ L o c a l _ P r o te cte d_O b jec ts , No_Local_Timing_Events ,

N o _ P r o t e c t e d _ T y p e _ A l l o c a t o r s , No_Relative_Delay , No_Requeue_Statements , No_Select_Statements , N o _ S p e c i f i c _ T e r m i n a t i o n _ H a n d l e r s , No _ T a s k _ A l l o c a tor s , No_Task_Hierarchy , No_Task_Termination , S i m p l e _ B a r r i e r s , Max_Entry_Queue_Length => 1 , M a x _ P r o t e c t e d _ E n t r i e s => 1 , Max_Task_Entries => 0 ,

No_Dependence => Ada . Asynchronous_Task_Control , No_Dependence => Ada . Calendar ,

. . . ) ;

(106)

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].

...

(107)

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).

(108)

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.

SCH ED

_

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

).

(109)

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 ; t y 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 : c o n s t a n t S c h e d u l i n g _ P o l i c y : = . . . Sched_RR : c o n s t a n t S c h e d u l i n g _ P o l i c y : = . . . 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 : = . . . t y p e Scheduling_Parameters i s p r i v a t e ;

(110)

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 ) r e t u r n S c h e d u l i n g _ P r i o r i t y ; f u n c t i o n G e t _ M i n i m u m _ P r i o r i t y ( P o l i c y : S c h e d u l i n g _ P o l i c y ) r e t u r n S c h e d u l i n g _ P r i o r i t y ; f u n c t i o n G e t_ Ro u n d _ Robin_Inte rva l ( 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 ; . . .

(111)

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 ; P r i o r i t y : S c h e d u l i n g _ P r i o r i t y ) ; 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 . . . f u n c t i o n G e t _ P r i o r i t y . . . f u n c t i o n Get_Scheduling_Parameters . . .

(112)

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 ;

b e g i n

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 ) ;

(113)

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 ?

(114)

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é.

Références

Documents relatifs

Among the different cell lines that have been examined over the years, and that can actually support a productive reovirus infection, some of these nevertheless exhibit

Ce sont, à mon avis, ces paramètres (acte poïétique, prise de risque, formation d’une situation) et cette manière de concevoir la transindividuation (à travers l’émergence

Yuan- Yuan, « Simulation of transition from townsend mode to glow discharge mode in a helium dielectric barrier discharge at atmospheric pressure », Chi- nese Physics B , vol.

Firstly, a resolution approach for a 1D-beam simplified model of bonded joint stress analysis under linear elastic material is presented.. This approach, named the

Effectivement, médecins comme infirmières considèrent souvent ces situations délicates, épineuses ou même pénibles, mais souvent pour des raisons différentes

The present Research aims to open a scientific angle that has not been studied before, as far as we know, and we have not found a scientific or academic research that deal

In this paper, we analyzed the runtime resulting from the authentication of a joining node by a distributed AAA framework within a mobile ad-hoc network. The built model

Nous effectuons une étude pilote visant à mettre en place un programme de transition entre les soins en gastroentérologie pédiatrique du CHU Sainte-Justine vers la