S´ emantique

Dans la sous-section 2.3.3 on a donn´e la description du comportement de chaque instruction r´eactive. Cette description donn´ee en langage naturel s’av`ere utile pour donner une id´ee g´en´erale du comportement de chaque instruction r´eactive. Cependant, lorsqu’on commence `a construire des programmes r´eactifs plus complexes, cette description n’est pas suffisante car elle ne donne pas la description exhaustive de toutes les interactions possibles entre les instructions r´eactives. Pour avoir une description pr´ecise du fonctionnement de Junior, sa s´emantique formelle a ´et´e d´efinie.

Il existe plusieurs fa¸cons de donner une s´emantique formelle `a un langage, dont les plus connues sont les suivantes :

1. S´emantique Op´erationnelle[PLO 81, KAN 87]. Les langages de programmation sont d´efinis par des r`egles de r´eduction qui d´ecrivent comment l’´etat initial du programme est transform´e pas `a pas vers l’´etat final. Ce type de description est utile pour comprendre le comportement dynamique d’un langage, par exemple, pour construire un interpr`ete. Les s´emantiques op´erationnelles font suite aux travaux de G. Plotkin sur les structural operational semantics.

2. S´emantique D´enotationnelle [STO 77, SCH 88]. Les langages de programmation sont d´efinis par une fonction d’´evaluation qui associe `a un programme un objet math´ematique. L’objet math´ematique donne une signification `a ce que fait un programme. Ce type de description est utile pour comprendre la logique interne du langage, par exemple, pour raisonner sur ses propri´et´es. Les s´emantiques d´enotationnelles font suite aux travaux de C. Strachey, D. Scott, J.W. de Bakker et M. Nivat, pour n’en citer que quelques uns. 3. S´emantique Axiomatique [HOR 73, MEY 93, FRA 92]. Les langages de programmation sont d´efinis par des assertions qui d´ecrivent comment tirer des conclusions sur les entr´ees et les sorties du programme. Ce type de description est utile pour comprendre les effet externes du langage, par exemple, pour v´erifier un programme. Les s´emantiques axiomatiques font suite aux travaux de R. Floyd et de C.A.R. Hoare. Il serait erron´e d’opposer ces s´emantiques. Chacune poss`ede son utilit´e. Ainsi, une s´emantique op´erationnelle claire est tr`es utile pour concevoir une impl´ementation, les s´emantiques axiomatiques offrent des syst`emes de preuves ´el´egants pour d´evelopper et v´erifier les programmes, et les s´emantiques d´enotationnelles sont `a l’origine des techniques les plus sophistiqu´ees.

Etudier ces s´emantiques s´epar´ement serait aussi une erreur. Ainsi, ´etablir la correction d’une s´emantique ax-iomatique requiert la connaissance `a priori d’une s´emantique op´erationnelle, voire d´enotationnelle. De mˆeme, l’argumentation de la correction d’une impl´ementation par rapport `a une s´emantique d´enotationnelle requiert le passage par une s´emantique op´erationnelle et son lien avec la s´emantique d´enotationnelle consid´er´ee. Le probl`eme se pose alors naturellement de distinguer parmi les diff´erents types de s´emantiques celles qui corre-spondent le plus ´etroitement aux autres.

Le domaine de la description formelle des langages de programmation est tr`es vaste et bien d’autres types de s´emantique ont ´et´e donn´es: S´emantique Alg´ebrique, S´emantique d’Actions. La s´emantique formelle de Junior est une s´emantique op´erationnelle structurelle que l’on d´ecrit plus en d´etail maintenant.

S´emantique Op´erationnelle Structurelle

La s´emantique op´erationnelle sp´ecifie un langage de programmation comme l’ex´ecution de celui-ci dans une machine abstraite. La S´emantique Op´erationnelle Structurelle (SOS), d´evelopp´ee par Gordon Plotkin en 1981

[PLO 81], repr´esente l’ex´ecution par un syst`eme d´eductif qui ex´ecute la machine abstraite dans un syst`eme d’inf´erence logique. Etant donn´e que la description s´emantique est bas´ee sur une logique d´eductive, les preuves des propri´et´es des programmes sont obtenues directement `a partir des d´efinitions du langage.

La SOS est d´efinie par des r`egles d’inf´erence constitu´ees par une conclusion qui se v´erifie `a partir d’un ensemble de pr´emisses probablement sous le contrˆole de quelques conditions. La forme g´en´erale de la r`egle d’inf´erence est une fraction qui a comme num´erateur les pr´emisses et comme d´enominateur la conclusion; si la condition est pr´esente elle est donn´ee `a droite:

premisse1 premisse2 ... premisse3 conclusion

Si le nombre de pr´emisse est nul, la ligne est omise et on parle d’axiome. Cette syntaxe a ´evolu´e `a partir d’une syntaxe de logique appel´ee d´eduction naturelle.

Plusieurs variantes de la SOS ont ´et´e propos´ees, par exemple la s´emantique big-step ou macro-step qui, par opposition `a la s´emantique small-step ou micro-step, cherche `a capturer le comportement d´ecrit entre deux ´etats consid´er´es comme l’´etat initial et l’´etat final. Un exemple de s´emantique macro-step est celle qui fut d´evelopp´ee par Gilles Kahn, nomm´ee s´emantique naturelle. Les autres s´emantiques op´erationnelles sont la s´emantique de r´eduction[FEL 87], la s´emantique moduler[MOS 99].

La s´emantique formelle de Junior est d´ecrite dans [BOU 00d] et elle est bas´ee sur l’utilisation de r`egles de r´e´ecriture du type SOS. Le format de r´e´ecriture utilis´e est le suivant:

t, E −→ t

, E

qui signifie que l’instruction t ex´ecut´ee dans l’environnement E se transforme (on peut dire, se r´e´ecrit) en t’ avec l’environnement E’, et retourne α comme drapeau de terminaison.

La s´emantique de Junior est compos´ee de 45 r`egles de r´e´ecriture de type micro-step qui d´efinissent les instructions r´eactives du langage Junior et de 3 r`egles micro-step, plus une r`egle de r´e´ecriture de type macro-step, qui d´efinissent la notion d’instant. La notion d’instant du mod`ele r´eactif est divis´ee en instants ou micro-r´eactions; les micro-r´eactions sont impl´ement´ees `a l’aide de trois drapeaux de terminaison:

• TERM qui signifie que l’ex´ecution est termin´ee pour l’instant courant et qu’il ne reste rien `a faire au prochain instant.

• STOP signifie que l’ex´ecution est termin´ee pour l’instant courant mais qu’il reste quelque chose `a faire dans le prochain instant.

• SUSP signifie que l’ex´ecution n’est pas termin´ee pour l’instant courant et qu’elle doit ˆetre reprise dans le mˆeme instant.

La s´emantique repose sur un nombre r´eduit de r`egles que l’on a regroup´ees dans les figures2.6et2.7. Celles-ci fournissent une d´efinition extrˆemement compacte de Junior `a la base de ses impl´ementations. L’interpr´etation de la syntaxe utilis´ee est la suivante :

• Les instructions r´eactives sont repr´esent´ees par leur syntaxe abstraite, et non leur syntaxe concr`ete; par exemple l’instruction Stop qui a la syntaxe concr`eteJr.Stop()est repr´esent´ee par Stop.

• Lorsque les instructions utilisent des param`etres qui sont des programmes r´eactifs, on utilise des let-tres minuscules (en g´en´eral t et u). Par exemple, l’instruction r´eactive Loop qui a la syntaxe concr`ete

Jr.Loop(Program t) est d´enot´e par Loop(t). Si une instruction r´eactive, par exemple t, est r´e´ecrite en un nouveau terme, on le d´enote par t⁰.

• Les ´ev´enements sont d´enot´es par des lettres majuscules: S pour les ´ev´enements simples et C pour les configurations (des conditions ´ev´enementielles form´ees avec des op´erateurs And et Or). Par exemple, l’instruction r´eactive Await qui a la syntaxe concr`eteJr.Await(Config c)est d´enot´ee par Await(C). • Les instructions ´ev´enementielles utilisent 3 pr´edicats : sat(C, E) pour tester si la configuration C est

satis-faite dans l’environnement E, unsat(C, E) lorsque la configuration C n’est pas satissatis-faite, et unknown(C, E) lorsque on peut pas encore savoir son ´etat.

Nothing Stop

N othing, E ^{T ERM}−→ N othing, E Stop, E^{ST OP}−→ N othing, E

Atoms Contexte d’ex´ecution

Atom(a), E ^{T ERM}−→ N othing, E ^{Instant(t),F resh}

α

−→Instant(t0),E ExecContext(t)=⇒ExecContext(t^b 0)

Sequence Await

t,E^{T ERM}−→ t0,E⁰ u,E^{0 α}−→u0,E⁰⁰ Seq(t,u),E−→u^α 0,E00

sat(C,E) eoi(E)=f alse Await(C),E^{T ERM}−→ N othing,E t,E−→t^α 0,E⁰ α6=T ERM

Seq(t,u),E−→Seq(t^α 0,u),E0

sat(C,E) eoi(E)=true Await(C),E^{ST OP}−→ N othing,E

Loop ^unsat(C,E)

Await(C),E^{ST OP}−→ Await(C),E t,E−→t^α 0,E⁰ α6=T ERM

Loop(t),E−→Seq(t^α 0,Loop(t)),E0

unknown(C,E) Await(C),E^{SU SP}−→ Await(C),E t,E^{T ERM}−→ t⁰,E⁰ Loop(t),E^{0 α}−→u,E⁰⁰

Loop(t),E−→u,E^α 00 Until

Repeat ^t,E

α

−→t⁰,E⁰ α6=ST OP U ntil(C,t,u),E−→U ntil(C,t^α 0,u),E0 n≤0

Repeat(n,t),E^{T ERM}−→ N othing,E

t,E^{ST OP}−→ t0,E⁰ U ntil∗(C,t⁰,u),E^{0 α}−→v,E00 U ntil(C,t,u),E−→v,E^α 00

n>0 Seq(t,Repeat(n−1,t)),E−→u,E^α 0 Repeat(n,t),E−→u,E^α 0

sat(C,E) eoi(E)=f alse u,E−→u^α 0,E⁰ U ntil∗(C,t,u),E−→u^α 0,E0

Control ^{sat(C,E) eoi(E)=true}

U ntil∗(C,t,u),E^{ST OP}−→ u,E sat(S,E) t,E−→t^α 0,E⁰

Control(S,t),E−→Control(S,t^α 0),E

unsat(C,E) eoi(E)=true U ntil∗(C,t,u),E^{ST OP}−→ U ntil(C,t,u),E unsat(S,E) Control(S,t),E^{ST OP}−→ Control(S,t),E unknown(C,E) U ntil∗(C,t,u),E^{SU SP}−→ U ntil∗(C,t,u),E unknown(S,E) Control(S,t),E^{SU SP}−→ Control(S,t),E When Local

sat(C,E) eoi(E)=f alse t,E−→t^α 0,E⁰ W hen(C,t,u),E−→t^α 0,E0

t,E−S^{SU SP}−→ t0,E⁰ S6∈E⁰

Local−(S,t),E^{SU SP}−→ Local−(S,t0),E0/E[S] sat(C,E) eoi(E)=true

W hen(C,t,u),E^{ST OP}−→ t,E

t,E−S^{SU SP}−→ t0,E⁰ S∈E⁰

Local−(S,t),E^{SU SP}−→ Local+(S,t0),E0/E[S] unsat(C,E) eoi(E)=f alse u,E−→u^α 0,E⁰

W hen(C,t,u),E−→u^α 0,E0

t,E+S^{SU SP}−→ t0,E⁰

Local+(S,t),E^{SU SP}−→ Local+(S,t0),E0/E[S] unsat(C,E) eoi(E)=true

W hen(C,t,u),E^{ST OP}−→ u,E

t,E−S−→t^α 0,E⁰ α=T ERM or α=ST OP Local−(S,t),E−→Local−(S,t^α 0),E0/E[S] unknown(C,E)

W hen(C,t,u),E^{SU SP}−→ W hen(C,t,u),E

t,E+S−→t^α 0,E⁰ α=T ERM or α=ST OP Local+(S,t),E^alpha−→ Local−(S,t0),E0/E[S] Fig. 2.6: S´^{emantique de Junior 1`ere partie (r`egles de r´e´ecriture)}

Par t,E−→t^α 0,E⁰

P arSU SP,SU SP(t,u),E^{SU SP}−→ P arα,SU SP(t0,u),E0[move=true] u,E−→u^β 0,E⁰

P ar_{SU SP,SU SP}(t,u),E^{SU SP}−→ P arSU SP,β(t,u0),E0[move=true] t,E−→t^α 0,E⁰ u,E^{0 β}−→u0,E⁰⁰

P ar_{SU SP,SU SP}(t,u),E^γ(α,β)−→ P ar_{δ1(α,β),δ2(α,β)}(t0,u0),E00 u,E−→u^β 0,E⁰ t,E^{0 α}−→t0,E⁰⁰

P arSU SP,SU SP(t,u),E^γ(α,β)−→ P ar_{δ1(α,β),δ2(α,β)}(t0,u0),E00 β6=SU SP t,E−→t^α 0,E⁰

P ar_{SU SP,β}(t,u),E^γ(α,β)−→ P ar_{δ1(α,β),δ2(α,β)}(t0,u),E0 α6=SU SP u,E−→u^β 0,E⁰

P arα,SU SP(t,u),E^γ(α,β)−→ P ar_{δ1(α,β),δ2(α,β)}(t,u0),E0

Freezable t,E−→t^α 0,E⁰ α6=ST OP F reezable(S,t),E−→F reezable(S,t^α 0),E0 t,E^{ST OP}−→ t0,E⁰ F reezable∗(S,t⁰),E^{0 α}−→v,E00

F reezable(S,t),E−→v,E^α 00 S∈E eoi(E)=f alse

F reezable∗(S,t),E^{T ERM}−→ N othing,E{S:=P ar(t,E{S})}

S∈E eoi(E)=true

F reezable∗(S,t),E^{ST OP}−→ N othing,E{S:=P ar(t,E{S})}

S6∈E eoi(E)=true

F reezable∗(S,t),E^{ST OP}−→ F reezable(S,t),E S6∈E eoi(E)=f alse

F reezable∗(S,t),E^{SU SP}−→ F reezable∗(S,t),E

Instant

t,E−→t^α 0,E⁰ α6=SU SP Instant(t)−→Instant(t^α 0),E0

t,E^{SU SP}−→ t0,E⁰ move(E⁰)=f alse Instant(t⁰),E⁰[eoi=true]−→u,E^α 00 Instant(t)−→u,E^α 00

t,E^{SU SP}−→ t0,E0 move(E0)=true Instant(t0),E0[move=f alse]−→u,E^α 00 Instant(t)−→u,E^α 00

Generate

Generate(S), E^{T ERM}−→ N othing, (E + S)[move = true] Fig. 2.7: S´^{emantique de Junior 2`eme partie (r`egles de r´e´ecriture)}

• les variables eoi et move de l’environnement E sont test´ees par les pr´edicats eoi(E) et move(E) respec-tivement et modifi´ees par E[eoi = true] et E[move = f alse].

Ce syst`eme de r`egles de r´e´ecriture est d´eterministe (`a l’exception de l’instruction Par) et lorsqu’on ex´ecute un programme r´eactif il n’existe donc qu’une seule r`egle `a appliquer. Par exemple si l’on ex´ecute le programme:

Jr.Seq(Jr.Atom(new MyAction()),Jr.Stop());

on proc`ede de la fa¸con suivante (on utilisant la syntaxe abstraite) :

1. les deux r`egles de la s´equence disent qu’il faut ex´ecuter d’abord la branche gauche qui est un atome : Atom(a), E ^{T ERM}−→ N othing, E

2. la premi`ere r`egle de la s´equence dit qu’il faut ex´ecuter tout de suite la branche droite si la gauche finit, ce qui est le cas :

Stop, E^{ST OP}−→ N othing, E

3. la mˆeme r`egle de la s´equence dit que maintenant on se comporte comme la branche gauche, mais on rend STOP ce qui veut dire que le premier instant est fini.

Seq(Atom(M yAction), Stop), E^{ST OP}−→ N othing, E 4. A l’instant d’apr`es, on ex´ecute Nothing qui rend TERM et on finit l’ex´ecution

N othing, E ^{T ERM}−→ N othing, E

Le syst`eme de r`egles de r´e´ecriture de Junior d´ecrit l’ex´ecution d’un programme Junior par des transformations (r´e´ecritures) des instructions r´eactives. Ces transformations ne doivent ˆetre r´ealis´ees que par le moteur r´eactif pour ´eviter les probl`emes li´es aux modifications concurrentes du programme. L’ajout dynamique de nouveaux comportements r´eactifs, qui implique une modification du programme r´eactif, est une op´eration r´ealis´ee entre deux instant pour ne pas perturber l’instant courant. L’ajout dynamique n’est donc pas d´ecrit par les r`egles de r´e´ecriture et il n’existe aucune instruction r´eactive qui fasse des modifications au programme r´eactif en cours d’ex´ecution. Dans le chapitre suivant on va proposer deux nouvelles instructions qui permettent l’ajout dynamique de comportements r´eactifs intra-instant.