L’approche d´eclarative

loop await e2 ; call code_E2(); end loop loop pause; pause; emit e1; end loop || loop pause; pause; pause; emit e2; end loop

Figure3.3 – CodeEsterel repr´esentant une application (`a gauche) et son environnement (`a droite).

Le programme Esterel d´ecrit sur la Fig. 3.3 repr´esente une application (partie gauche) et son environnement (partie droite). Les deux sous-programmes communiquent par ´echange de signaux : l’environnement ´emet deux ´ev´enementse1 ete2, r´ecup´er´es par l’application. Cela est exprim´e `a travers la composition parall`ele de deux boucles (loop ... end loop) conte-nant les ´emissions d’´ev´enements (emit e1etemit e2). L’application attend donc l’´emission des ´ev´enements (await e1etawait e2). Sur r´eception de ces derniers et en fonction de l’´ev´enement, un traitement sp´ecifique (code_E1() pour e1) est effectu´e via un m´ecanisme d’appel (call). On remarquera l’op´erateur de composition s´equentielle entre la r´eception et l’appel au sein des boucles, dans l’application.

Un aspect int´eressant des langages synchrones est leur capacit´e `a analyser les propri´et´es des programmes. En particulier, l’analyse de la consistance de l’ensemble des contraintes sur les horloges (instants de pr´esence) des signaux permet de v´erifier des propri´et´es sur les comporte-ments du programme (exemple : absence de blocage). Cette analyse fait g´en´eralement partie de la compilation. Par exemple, un programme source Esterel peut ˆetre compil´e en automates [101], en circuits [35], ou bien dans un format interm´ediaire sous la forme d’un graphe de flots de contrˆole [176].

Des versions acad´emiques de plates-formes de d´eveloppement `a l’aide du langageEsterel, comprenant compilateur et outils de v´erification, sont propos´ees par le CMA, France T´el´ecom et l’universit´e de Columbia (New-York). La version industrielle, appel´ee Esterel Studio est commercialis´ee par la soci´et´eEsterel Technologies. On rencontre des utilisations concr`etes deEstereldans des domaines tels que l’avionique ou l’automobile, pour la sp´ecification d’ap-plications embarqu´ees. Il est aussi utilis´e pour la conception conjointe ou co-design (cf. Po-lisci-dessous).

3.2.2 L’approche d´eclarative

Les langages orient´es flot de donn´ees trouvent leur origine dans des ´etudes qui remontent aux ann´ees 70. Parmi ces ´etudes, on peut citer les travaux de Kahn sur la s´emantique des r´eseaux de processus communiquant par files d’attentes [132]. Il utilise les flots de donn´ees pour

repr´esenter le comportement. Nous soulignons ´egalement l’apport de Dennis et son ´equipe au M.I.T.9, qui ont beaucoup contribu´e au d´eveloppement des langages orient´es flot de donn´ees [76] [77]. D’autres travaux allant dans le mˆeme sens ont conduit `a la d´efinition du formalisme

Lucid. Celui-ci est le premier langage fond´e sur les flots de donn´ees ; il a ´et´e d´efini par Ash-croft et Wadge [212]. Le mod`ele de programmation propos´e par Lucid est assez proche des math´ematiques, facilitant ainsi le raisonnement sur les comportements des programmes. Cepen-dant, le langage n’encourage pas une approche op´erationnelle dans la programmation, comme c’est le cas dans les langages imp´eratifs classiques. D’o`u quelques difficult´es, notamment en ce qui concerne la d´efinition d’un sch´ema de g´en´eration de code s´equentiel efficace.

Toutes ces ´etudes (entre autres) ont largement servi d’inspiration pour le d´eveloppement des langages synchrones que nous pr´esentons dans cette section, `a savoirLustre,Lucid Syn-chrone etSignal. Seuls les deux premiers langages sont abord´es ici.Signal est pr´esent´e en d´etail dans le chapitre suivant, consacr´e `a la technonologie polychrone.

3.2.2.1 Lustre

Le langage Lustre [111] est d´evelopp´e au laboratoire Verimag¹⁰ (Grenoble). Il est adapt´e pour sp´ecifier des syst`emes r´eactifs qui manipulent essentiellement des flots de donn´ees sous forme d’´equations.

Dans Lustre, les objets de base sont lesignal et le nœud (node). Un signal d´enot´e par la variable xrepr´esente le flot de donn´ees infinix₁, x₂, ..., x_k, ...o`u x_i est la ieme occurrence de x. Ainsi, chaque signal est caract´eris´e par :

– l’ensemble des instants auxquels il apparaˆıt, appel´e son horloge. Cette derni`ere est en-cod´ee par un flot bool´een dans lequel les occurrences valant vrai d´enotent la pr´esence du signal. Sur la trace de laFig. 3.4,brepr´esente l’horloge du signaly. On parle de signaux

synchrones lorsque ceux-ci ont la mˆeme horloge.

– la suite des valeurs port´ees lorsqu’il est pr´esent. Le type de ces valeurs peut ˆetre simple (sur laFig. 3.4,xetbsont respectivement de type entier et bool´een) ou composite (par exemple tableau).

Un nœud repr´esente l’unit´e de programmation, et d´efinit une fonction (le langageLustreest fonctionnel). Il comprend d’une part une interface form´ee par les signaux d’entr´ee/sortie, et d’autre part un corps constitu´e d’un ensemble d’´equations, avec ´eventuellement des variables locales.

b : f aux vrai f aux vrai f aux f aux vrai vrai ...

x : 1 2 3 4 5 6 7 8 ...

y = x when b : 2 4 7 8 ...

z = current y : nil 2 2 4 4 4 7 8 ...

Figure 3.4 – Un exemple de trace d’op´erateurs Lustre.

Parmi les op´erateurs, on distingue des extensions des op´erateurs classiques de l’arithm´etique, de la logique, et conditionnels (if... then...else...). L’op´erateurprepermet de m´emoriser la valeur pr´ec´edente d’un signal. La valeur initiale d’un signal est d´efinie `a l’aide de l’op´erateur

9. http://web.mit.edu.

-> : l’expression `a gauche de la fl`eche repr´esente la valeur d’initialisation de l’expression de droite (cf. l’exemple sur la Fig. 3.5). Tous ces op´erateurs imposent `a la fois aux arguments et au r´esultat d’ˆetre synchrones.

L’op´erateurwhenpermet d’extraire une sous-suite d’un signal. Seuls les arguments doivent ˆetre synchrones (par exemple sur laFig. 3.4,betxont la mˆeme horloge). Enfin, l’op´erateurcurrent

permet de m´emoriser les valeurs d’un signal `a l’horloge la plus rapide du nœud (cf. Fig. 3.4 o`u le signal zest d´efini avec cet op´erateur, initialement il vautnil).

`

A chaque nœud est associ´ee une horloge de base (horloge la plus rapide), repr´esent´ee par un flot bool´een qui porte la valeur vrai `a toutes ses occurrences. Toutes les constantes du nœud sont `a cette horloge. Les signaux d’entr´ee sont soit `a l’horloge de base soit `a une horloge moins fr´equente sp´ecifi´ee par un signal bool´een (i.e. incluse dans l’horloge de base). De cette fa¸con, `a chaque invocation d’un nœud, il y a au moins un signal qui est disponible.

Le programme Lustre de la Fig. 3.5 d´ecrit un compteur r´einitialisable. Une invocation du nœud correspondant est : val = COUNTER(0, true).

node COUNTER(init : int; reset : bool) returns (n : int)

let

n = init -> if reset then init else pre(n) + 1 tel

Figure 3.5 – CodeLustre repr´esentant un compteur r´einitialisable.

La compilation d’un programmeLustre peut ˆetre obtenue dans un format ditObject Code

(OC), dont la structure de contrˆole est donn´ee sous forme d’automates ´etendus [114]. Elle peut aussi produire du code dans les formats communs aux langages synchrones comme Declarative Code (DC) [85].

Une plate-forme acad´emique de Lustre est fournie par le laboratoire Verimag. Elle com-porte un compilateur, ainsi que d’autres outils de v´erification (par exemple, Lesar [112]) et de test. La version industrielle du langage est mise en œuvre dans l’outil Scade (Safety Critical Application Development Environment), commercialis´e actuellement par Esterel

-Technologies. `A traversScade, le langageLustreest utilis´e dans des domaines critiques tels que l’avionique. Par exemple, dans le projetSafeAir, il repr´esente le format d’interop´erabilit´e. Les automates de modes [158] sont un formalisme synchrone bas´e sur Lustre. Ils ont ´et´e in-troduits pour mod´eliser les modes d’ex´ecution d’un syst`eme. C’est une notion qui est pr´esente dans beaucoup de syst`emes temps r´eel, par exemple les syst`emes embarqu´es dans les avions. Un automate de modes peut ˆetre vu comme une sorte de r´eseau, o`u les nœuds repr´esentent des programmes Lustre. Les ´etats courants de l’automate d´eclenchent l’ex´ecution des nœuds associ´es.

3.2.2.2 Lucid synchrone

Lucid Synchrone[59] est un langage d´evelopp´e au Laboratoire d’Informatique de Paris 6. C’est un langage fonctionnel d’ordre sup´erieur qui manipule des s´equences infinies de valeurs. Il adopte des caract´eristiques de Lustre (en s’inspirant de certains op´erateurs, par exemple, l’op´erateur -> de Lustre est d´enot´e ici par fby - followed by), et des langages fonctionnels

(la syntaxe est un sous-ensemble de celle de Ocaml - Objective CAML). Une sp´ecificit´e de

Lucid Synchrone est son calcul d’horloges qui est effectu´e `a l’aide de calculs de types. Par ailleurs, il existe un encodage du langage dans l’outil d’aide `a la preuve Coq, cela dans le but d’aborder la question de la certification des programmes synchrones [47].