La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Chapitre 5. Le Langage LOTOS

Présentations similaires


Présentation au sujet: "Chapitre 5. Le Langage LOTOS"— Transcription de la présentation:

1 Chapitre 5. Le Langage LOTOS
Language Of Temporal Ordering Specification

2 - LOTOS en bref… - Les versions du langage - Le plan du chapitre
5.1. Introduction - LOTOS en bref… - Les versions du langage - Le plan du chapitre

3 5.1. LOTOS : introduction En bref… LOTOS = Process Algebra (CCS & CSP)
+ Abstract Data Type Algebra (ACT-ONE) => ISO Standard: IS8807 (1987) En LOTOS, un système distribué est représenté par un ensemble de processus communiquant Un processus = une boîte noire capable d'interagir avec son environnement (e.g. d'autres processus) et d'effectuer des actions internes Interactions atomiques = événements Atomique = instantané et un seul par instant Les événements sont produits par des « points d'interaction » appelés « portes » Un événement = support de l'interaction => véhicule des données => permet la synchronisation (rendez-vous) a b c

4 5.1. LOTOS : introduction En bref…
Algèbre de processus = un cadre mathématique (algèbre) qui permet de décrire et d'analyser des processus communicants => algèbre = règles de construction des processus + lois de composition internes définies par des axiomes => possibilité de raisonner sur les termes de l'algèbre (i.e., les processus) => analysibilité des processus Historique : Théorie des automates Théorie des réseaux de PETRI Algèbre de processus CSP (Communicating Sequential Processes) : C.A.R. Hoare (1978) => occam + Transputer => source d'inspiration du langage ADA Algèbre de processus CCS ( Calculus of Communicating Systems) : R. Milner (1981) => LOTOS

5 5.1. LOTOS : introduction En bref…
Types Abstraits de Données = un cadre mathématique (algèbre) qui permet de décrire et d'analyser des formats de données => algèbre = règles de construction des données + lois de composition internes définies par des axiomes => possibilité de raisonner sur les termes de l'algèbre (i.e., les données) => analysibilité des données Historique : La crise des fondements mathématiques (début XXème siècle) => la logique formelle => la théorie axiomatique des ensembles => le -calcul => la théorie des types Théorie des types => les langages de programmation typés (Pascal, ADA…) => les types abstraits de données (ACT-ONE… ) => Programmation objet

6 5.1. LOTOS : introduction LOTOS : trois versions principales
Basic LOTOS : processus sans données Full LOTOS : processus avec données Enhancement of LOTOS (E-LOTOS) : normalisé ISO/IEC 15437, 2001

7 5.1. LOTOS : introduction Plan du chapitre 5.1. Introduction
5.2. Algèbre de processus : aspects principaux 5.3. Basic LOTOS => sans les données 5.4. Exemple (Basic LOTOS) 5.5. Full LOTOS => avec les données 5.6. Les données dans LOTOS : => types abstraits de données (ADT) 5.7. Exemple (Full LOTOS) 5.8. Résumé et conclusion sur LOTOS

8 5.2. Algèbre de processus : aspects principaux
- Les concepts principaux… - Les principales lois de compositions… - Le coté algébrique : l'axiomatisation…

9 5.2. Algèbre de processus : aspects principaux
Concepts fondamentaux… Objet : spécification des systèmes concurrents en insistant sur les aspects communication et synchronisation => Un alphabet d'actions l'évolution d'un processus est décrite à l'aide des noms des actions qu'il entreprend => Des lois de compositions un processus = une expression régulière obtenue par la combinaison de noms d'action (alphabet) à l'aide d'opérateurs prédéfinis => Des constantes des processus élémentaires : STOP : processus qui ne termine pas

10 5.2. Algèbre de processus : aspects principaux
lire traiter ecrire stop Les principaux opérateurs des algèbres de processus… la séquence (préfixage) notée « ; » lire ; traiter ; ecrire ; STOP le choix non déterministe noté « [] » (lire ; STOP) [] (ecrire ; ((traiter ; STOP) (ouvrir ; STOP))) le parallélisme avec communication synchrone noté « | […] | » (a ; b ; c ; STOP) | [a, b] | (a ; d ; b ; STOP) lire traiter ecrire ouvrir stop a b c d stop

11 5.2. Algèbre de processus : aspects principaux
Les caractéristiques des algèbres de processus… axiomatisation des opérateurs : P [] Q = Q [] P P [] (Q [] R) = (P [] Q) [] R P |[L]| Q = Q |[L]| P (a;P) |[L]| (b;Q) = (a;(P |[L]| (b;Q))) [] (b;((a;P)|[L]|Q)) si a, b  L => possibilité de manipulations formelles symboliques sur les termes de l'algèbre => méthodes d'analyses formelles. => Un cadre mathématique support de LOTOS.

12 5.3. Basic LOTOS Basic LOTOS = sous-ensemble de LOTOS sans les données
=> seuls les comportements sont spécifiés => pas de spécification de données

13 5.3. Basic LOTOS Pour commencer…
Le comportement d'un processus détermine, à tout moment, quelles actions sont possibles comme action suivante du processus On distingue des actions qu'un processus peut effectuer de façon interne et indépendante (par souci d'abstraction) : i appelée action interne ou silencieuse des actions qui nécessitent une synchronisation avec l'environnement pour être effectuées : elles sont alors offertes sur des points de synchronisation appelées portes (gates) => une action représente l'identification d'une porte. L'environnement d'un processus est composé des autres processus LOTOS, de l'utilisateur, ou d'autres systèmes externes à LOTOS

14 5.3. Basic LOTOS Pour continuer… P La structure du langage :
process <process_id> <parameter_part> := <behaviour_expression> endproc Exemple : process P [a, b, c] := … endproc Nom du processus Liste des portes du processus Expression régulière définissant le comportement du processus P a b c

15 5.3. Basic LOTOS inaction Les opérateurs et constructions du langage
Le processus élémentaire stop Processus qui ne peut rien faire process inaction [a, b] := stop endproc => stop est assimilé à un deadlock inaction a b

16 5.3. Basic LOTOS Les opérateurs et constructions du langage
préfixage : a ; B a est une action atomique B est une expression de comportement Exemple : process P [out_data] := out_data ; stop endproc process Q [in_data, out_data] := in_data ; out_data ; stop P out_data out_data stop P out_data in_data in_data out_data stop

17 5.3. Basic LOTOS Les opérateurs et constructions du langage
Choix non déterminste : B1 [] B2 B1 et B2 sont des expressions de comportement B1 [] B2 se comporte comme B1 ou comme B2 selon le comportement de l'environnement du processus ou de façon non-déterministe si l'environnement offre l'action initiale de B1, alors B1 est sélectionné si l'environnement offre l'action initiale de B2, alors B2 est sélectionné Axiomes : B1 [] B2 = B2 [] B1 (commutativité) B [] B = B (idempotence) B1 [] (B2 [] B3) = (B1 [] B2) [] B3 (associativité) Exemple : process choix [a, b] := a ; stop [] b ; stop endproc choix b a a stop b

18 5.3. Basic LOTOS Les opérateurs et constructions du langage Exemple :
process duplex [in_a, in_b, out_a, out_b] := in_a ; (in_b ; (out_a ; out_b ; stop [] out_b ; out_a ; stop) [] out_a ; in_b ; out_b ; stop) [] in_b ; (in_a ; (out_b ; out_a ; stop [] out_a ; out_b ; stop) [] out_b ; in_a ; ou_a ; stop) endproc duplex out_a in_a out_b in_b in_a stop in_b out_a out_b

19 Instanciation du processus P en séquence de l'action in_data
5.3. Basic LOTOS Les opérateurs et constructions du langage Instanciation de processus : Exemple : process Q' [in_data, out_data] := in_data ; P[out_data] where process P [a] := a ; stop endproc endproc Instanciation du processus P en séquence de l'action in_data in_data P[out_data] out_data stop équivalent à

20 5.3. Basic LOTOS Les opérateurs et constructions du langage
Instanciation de processus : Exemple : process generator [in_data, out_data] := in_data ; out_data ; generator[in_data, out_data] endproc process abba [a, b] := a ; b ; abba[b, a] in_data out_data a b

21 5.3. Basic LOTOS Les opérateurs et constructions du langage
Parallélisme sans interaction : B1 ||| B2 B1 et B2 sont des expressions de comportement B1 ||| B2 se comporte comme B1 et comme B2 sans interactions Axiomes : B1 ||| B2 = B2 ||| B1 B1 ||| (B2 ||| B3) = (B1 ||| B2) ||| B3 B ||| stop = B (a; B1) ||| (b; B2) = a; (B1 ||| (b; B2)) [] b; ((a; B1) ||| B2) Exemple : process parallel [a, b] := a ; stop ||| b ; stop endproc a stop b a b stop équivalent à

22 5.3. Basic LOTOS Les opérateurs et constructions du langage Exemple :
process duplex [in_a, in_b, out_a, out_b] := line[in_a, out_a] ||| line[in_b, out_b] where process line[in, out] := in ; out ; stop endproc duplex out_a in_a line[in_a, ou_a] line[in_b, out_b] out_b in_b

23 5.3. Basic LOTOS Les opérateurs et constructions du langage
Parallélisme avec interaction : B1 |[a1, …, an]| B2 B1 et B2 sont des expressions de comportement B1 |[a1, …, an]| B2 se comporte comme B1 et comme B2 en synchronisant chaque action ai de B1 avec l'action ai de B2 => chaque ai de B1 est exécutée simultanément avec l'action ai de B2 (et inversement) Axiomes : B1 |[]| B2 = B1 ||| B2 B1 |[L]| B2 = B2 |[L]| B1 (a; B1) |[L]| (b; B2) = a; (B1 |[L]| (b; B2)) [] b; ((a; B1) |[L]| B2) si a, b  L (a; B1) |[L]| (b; B2) = a;(B1 |[L]| B2) si a  L (a; B1) |[L]| (b; B2) = stop a, b  L Exemple : process parallel [a, b] := a ; stop |[a]| b ; a ; stop endproc a stop b

24 5.3. Basic LOTOS Les opérateurs et constructions du langage Exemple :
process two_buffers [in, out] := buff[in, middle] |[middle]| buff[middle, out] where process buff[in, out] := in ; out ; stop endproc in buff[in, middle] buff[middle, out] out middle in middle out stop

25 5.3. Basic LOTOS Les opérateurs et constructions du langage Exemple :
process protocol-v1 [int1, int2, int3, int3] := entity1[int1, int3] |[int3]| service[int3, int4] |[int4]| entity1[int2, int4] where ... endproc int3 service entity1 int1 entity2 int2 int4

26 5.3. Basic LOTOS Les opérateurs et constructions du langage
Exemple : (autre modélisation équivalente) process protocol-v2 [int1, int2, int3, int3] := (entity1[int1, int3] ||| entity1[int2, int4]) |[int3, int4]| service[int3, int4] where ... endproc int3 service entity1 int1 entity2 int2 int4

27 5.3. Basic LOTOS Les opérateurs et constructions du langage
Hiding : hide a1, …, an in B B est une expression de comportement a1, …, an sont des actions offertes par B et cachées à l'environnement de B => ces actions ne peuvent pas se synchroniser avec des actions de l'environnement => a1, …, an sont internes à B Axiomes : hide a, b in B = hide a in (hide b in B) hide a in a ; B = i ; hide a in B process protocol-v3 [int1, int2] := hide int3, int4 in (entity1[int1, int3] ||| entity1[int2, int4]) |[int3, int4]| service[int3, int4] where ... endproc int3 service entity1 int1 entity2 int2 int4

28 5.3. Basic LOTOS Les opérateurs et constructions du langage
Terminaison avec succès : le processus élémentaire exit processus qui ne fait rien et qui retourne une terminaison avec succès (=> similaire respectivement à « return(1) » en C) Terminaison sans succès : le processus élémentaire stop processus deadlock (=> similaire respectivement à « return(0) » en C)

29 5.3. Basic LOTOS Les opérateurs et constructions du langage
Séquence de processus : B1 >> B2 B2 est exécuté si et seulement si B1 termine avec succès (en exécutant exit) Remarque : si B1 est composé de plusieurs sous-processus en parallèle, B1 termine avec succès si et seulement si tous ses sous-processus terminent avec succès. Axiomes : B1 >> (B2 >> B3) = (B1 >> B2) >> B3 stop >> B = stop exit >> B = i; B (a ; B1) >> B2 = a ; (B1 >> B2) Exemple : process sender [ConReq, ConConf, Data] := connection_phase[COnReq, ConConf] >> data_phase[Data] where process connection_phase[CR, CC] := CR; CC; exit endproc process data_phase[D] := D; data_phase[D] endproc endproc

30 5.3. Basic LOTOS Les opérateurs et constructions du langage
Préemption de processus : B1 [> B2 B1 peut être interrompue à tout moment par B2. Alors B2 continue à s'exécuter sans reprise de B1. Axiomes : B1 [> (B2 [> B3) = (B1 [> B2) [> B3 stop [> B = B B [> stop = B (a; B1) [> (b; B2) = (a ; B1 [> (b; B2)) [] (b; B2) Exemple : process data_transfer [DatReq, DatConf, DisReq] := normal_transfer[DatReq, DatConf] [> disconnect_phase[DisReq] where process normal_transfer[DR, DC] := CR; CC; normal_transfert[DR, DC] endproc process disconnect_phase[DR] := DR; stop endproc endproc

31 - Les trois philosophes en LOTOS
5.4. Basic LOTOS : exemple - Les trois philosophes en LOTOS

32 5.4. Basic LOTOS : exemple Un exemple… : les 3 philosophes revisités ?
=> système = 3 philosophes 3 fourchettes synchronisation entre les philosophes et les fourchettes pas de synchronisation entre philosophes pas de synchronisation entre fourchettes fourchette3 philo3 philo2 ? fourchette1 fourchette2 philo1

33 5.4. Basic LOTOS : exemple Un exemple… : les 3 philosophes revisités
1. Modélisation d'un philosophe alphabet : pense prd-fdroite prd-fgauche mange pose-fdroite pose-fgauche process philo [pense, mange, prd-fdroite, prd-fgauche, pose-fdroite, pose-fgauche] := pense; (prd-fdroite; exit ||| prd-fgauche; exit) >> mange; (pose-fdroite; exit ||| pose-fgauche; exit) >> philo[pense, mange, prd-fdroite, prd-fgauche, pose-fdroite, pose-fgauche] endproc philo pense mange prd-fdroite pose-fdroite prd-fgauche pose-fgauche

34 5.4. Basic LOTOS : exemple Un exemple… : les 3 philosophes revisités
2. Modélisation d'une fourchette alphabet : prise-droite, prise-gauche rendue-droite, rendue-gauche process fourche [prise-droite, rendue-droite, prise-gauche, rendue-gauche] := (prise-droite ; rendu-droite ; exit [] prise-gauche ; rendue-gauche ; exit) >> fourche [prise-droite, rendue-droite, prise-gauche, rendue-gauche] endproc fourchette prise-droite prise-gauche rendue-gauche rendue-droite

35 5.4. Basic LOTOS : exemple Un exemple… : les 3 philosophes revisités
3. Modélisation des interactions alphabet global philo1-pense, philo1- mange, philo1-prd-fdroite, philo1-pose-fdroite, philo1-prd-fgauche, philo1-pose-fgauche, philo2-pense, philo2- mange, philo2-prd-fdroite, philo2-pose-fdroite, philo2-prd-fgauche, philo2-pose-fgauche, philo3-pense, philo3- mange, philo3-prd-fdroite, philo3-pose-fdroite, philo3-prd-fgauche, philo3-pose-fgauche, fourchette1-prise-droite, fouchette1-rendue-droite, fourchette1-prise-gauche, fourchette1-rendue-gauche fourchette2-prise-droite, fouchette2-rendue-droite, fourchette2-prise-gauche, fourchette2-rendue-gauche fourchette3-prise-droite, fouchette3-rendue-droite, fourchette3-prise-gauche, fourchette3-rendue-gauche

36 5.4. Basic LOTOS : exemple Un exemple… : les 3 philosophes revisités
3. Modélisation des interactions synchronisation : philo1-prd-fdroite avec fourchette2-prise-gauche = fourche2-prise-gauche philo1-pose-fdroite avec fourchette2-rendue-gauche = fourche2-rendue-gauche philo1-prd-fgauche avec fourchette1-prise-droite = fourche1-prise-droite philo1-pose-fgauche avec fourchette1-rendue-droite = fourche1-rendue-droite philo2-prd-fdroite avec fourchette3-prise-gauche = fourche3-prise-gauche philo2-pose-fdroite avec fourchette3-rendue-gauche = fourche3-rendue-gauche philo2-prd-fgauche avec fourchette2-prise-droite = fourche2-prise-droite philo2-pose-fgauche avec fourchette2-rendue-droite = fourche2-rendue-droite philo3-prd-fdroite avec fourchette1-prise-gauche = fourche1-prise-gauche philo3-pose-fdroite avec fourchette1-rendue-gauche = fourche1-rendue-gauche philo3-prd-fgauche avec fourchette3-prise-droite = fourche3-prise-droite philo3-pose-fgauche avec fourchette3-rendue-droite = fourche3-rendue-droite

37 5.4. Basic LOTOS : exemple Un exemple… : les 3 philosophes revisités
4. Modélisation du système global process trois-philo [philo1-pense, philo1-mange, philo2-pense, philo2-mange, philo3-pense, philo3-mange] := hide fourche1-prise-gauche, fourche1-rendue-gauche, fourche1-prise-droite, fourche1-rendue-droite, fourche2-prise-gauche, fourche2-rendue-gauche, fourche2-prise-droite, fourche2-rendue-droite, fourche3-prise-gauche, fourche3-rendue-gauche, fourche3-prise-droite, fourche3-rendue-droite in (suite page suivante) …/…

38 5.4. Basic LOTOS : exemple (philo[philo1-pense, philo1-mange,
fourche2-prise-gauche, fourche1-prise-droite, fourche2-rendue-gauche, fourche1-rendue-droite] ||| philo[philo2-pense, philo2-mange, fourche3-prise-gauche, fourche2-prise-droite, fourche3-rendue-gauche, fourche2-rendue-droite] philo[philo3-pense, philo3-mange, fourche1-prise-gauche, fourche3-prise-droite, fourche1-rendue-gauche, fourche3-rendue-droite]) |[fourche1-prise-gauche, fourche1-rendue-gauche, fourche1-prise-droite, fourche1-rendue-droite, fourche2-prise-gauche, fourche2-rendue-gauche, fourche2-prise-droite, fourche2-rendue-droite, fourche3-prise-gauche, fourche3-rendue-gauche, fourche3-prise-droite, fourche3-rendue-droite ]| (fourche[fourche1-prise-droite, fourche1-rendue-droite, fourche1-prise-gauche, fourche1-rendue-gauche] fourche[fourche2-prise-droite, fourche2-rendue-droite, fourche2-prise-gauche, fourche2-rendue-gauche] fourche[fourche3-prise-droite, fourche3-rendue-droite, fourche3-prise-gauche, fourche3-rendue-gauche]) where … endproc

39 5.4. Full LOTOS - Les idées … - Les enrichissements par rapport à Basic LOTOS échange de valeurs à travers des portes synchronisation par "value passing" "value matching" "value génération" prédicats et expressions gardées

40 5.5. Full LOTOS Full LOTOS = Basic LOTOS + les données
=> Augmentation de Basic LOTOS avec la spécification des données leur utilisation dans les comportements => Enrichissement de la notion d'action : Une action = l'identification d'une porte une liste de valeurs requises (avec éventuellement des contraintes) soumises aux autres processus éventuellement une garde Les processus se synchronisent sur deux actions ssi ils utilisent le même identificateur de porte ils ont des listes de données en correspondance de même type les contraintes sur les données sont satisfaites

41 5.5. Full LOTOS Exemple d'actions en Full LOTOS
p ?x: nat !1 [x>=0] attend de l'environnement sur la porte p un entier positif ou nul, placé dans la variable x, puis émet la valeur 1. p ?x: nat !0 [x<0] attend de l'environnement sur la porte p un entier négatif, placé dans la variable x, puis émet la valeur 0. => Types de données : Les valeurs de données et les expressions de données sont définies dans un langage de types de données abstraits : ACT-ONE

42 5.5. Full LOTOS Les opérateurs et constructions du langage
préfixage : a !E ; B a est un identificateur de porte E une valeur ou une expression de valeur B est une expression de comportement => offre la valeur de E sur la porte a, puis exécute B préfixage : a ?x: t ; B x est un nom de variable t est un identificateur de sort (le domaine de valeurs de x) => place dans x une valeur de type t compatible avec les messages reçus sur la porte a

43 5.5. Full LOTOS Les opérateurs et constructions du langage
Synchronisation : value matching Synchronisation : value passing Synchronisation : value generation process Synchron. condition Type of interaction Effect g !E1 g !E2 value(E1) = value(E2) value matching synchronisation process Synchron. condition Type of interaction Effect g ?x: t g !E value(E)  t value passing synchronisation et x=value(E) process Synchron. condition Type of interaction Effect g ?x: t g ?y: u t = u value generation synchronisation et x=y=v où v est une valeur quelconque de la sort t

44 5.5. Full LOTOS Les opérateurs et constructions du langage
=> généralisation aux échanges multiples Exemple : A := g !3 ?x :primitive ; B A' := g !3 !connect_request ; B' => A' peut se synchroniser avec A (si connect_request est de type primitive) A'' := g !3 !true ; B'' => A'' ne peut pas se synchroniser avec A (car true n'est pas de type primitive) A''' := g !4 !connect_request ; B''' => A''' ne peut pas se synchroniser avec A (car 34)

45 5.5. Full LOTOS Les opérateurs et constructions du langage
=> prédicat et expression gardée Un prédicat P peut être associé à une action g ?x: t [P(x)] P(x) impose une restriction sur les valeurs possibles de x Exemple : g1 ?x: nat [x<3] ; g2 !x; stop g1(x:=0) g2(x) stop g1(x:=1) g1(x:=2)

46 5.5. Full LOTOS Les opérateurs et constructions du langage
=> mécanisme de négociation de valeurs entre processus Exemple : g ?qos: nat [qos < max] ; B1 |[g]| g ?qos: nat [qos > min] ; B2 => synchronisation possible uniquement sur une valeur de qos comprise en min et max => équivalent à g ?qos: nat [qos < max and qos > min] ; (B1 |[g]| B2) => ~ Programmation par contraintes

47 5.5. Full LOTOS Les opérateurs et constructions du langage
=> prédicat et expression gardée Une expression de comportement peut être précédée par une garde (i.e., un prédicat et une flèche) [P(x)] -> B; B ne peut être exécuté que si P(x) est vrai. Exemple : ([x>0] -> g !x ; exit [] [x<0] -> g!-x ; exit [x=0] -> erreur ; exit) >> B équivalent à (en pseudo code C) if x>0 then g(x); else if x<0 then g(-x) else erreur(); endif; B();

48 5.5. Full LOTOS Les opérateurs et constructions du langage
=> instanciation de processus et passage de paramètres Un processus peut être paramétré par des variables typées et instancié par des valeurs Exemple : process compare [in, out](min, max: nat) := in ?x: nat; ( [min<x<max] -> out !x; compare[in, out](min, max) [] [x<min] -> out !min; compare[in, out](x, max) [] [x>max] -> out !max; compare[in, out](min, x) ) endproc => exemple d'instanciation : compare[input, output](5, 10)

49 5.5. Full LOTOS Les opérateurs et constructions du langage
=> instanciation de processus et passage de paramètres Exemple : g ?qos: nat [qos < max] ; B1[a,b](qos) |[g]| g ?qos: nat [qos > min] ; B2[c,d,e](qos) où B1 et B2 sont des processus prenant en paramètre un nat process B1 [in, out](q: nat) := … endproc process B2 [toto, titi, tata](truc: nat) := … endproc

50 5.6. Les Abstract Data Types dans LOTOS

51 5.6. Les Abstract Data Types dans LOTOS
Les Types abstraits de données cadre formel (mathématique) pour la définition des types, leur ensemble de données, et leurs opérations => pas d'ambiguïté pas de référence à l'implantation => abstrait (niveau modèle) pas de propriétés implicites => tout doit être écrit => ce qui n'est pas écrit est faux

52 5.6. Les Abstract Data Types dans LOTOS
Les Types abstraits de données dans LOTOS (ACT-ONE) => Trois parties déclaration des ensembles de valeurs (appelés "sort") sorts nat déclaration des opérations manipulant les objets des sorts déclarées opns succ : nat -> nat 0 : -> nat _+_: nat -> nat => permet de construire l'ensemble des termes de l'algèbre, c'est-à-dire des valeurs de la sort nat 0, succ(0), 0+0, 0+succ(0), succ(succ(0))… => mais : à priori, rien n'indique que 0+0 = 0, ni que succ(succ(0)+succ(0)) = succ(succ(succ(0))) => il manque les équations ! !

53 5.6. Les Abstract Data Types dans LOTOS
Les Types abstraits de données dans LOTOS (ACT-ONE) => Trois parties (suite) définition des opérations par un ensemble d'axiomes eqns forall x, y : nat (pour tout terme x, y  nat) x+0 = x (x+0 et x représentent la même valeur) x+succ(y) = succ(x+y) … Remarque : on peut écrire des axiomes conditionnels y=0 => x+y=x (si y=0, alors x+y et x représentent la même valeur) Les équations définissent une relation d'équivalence entre les termes de nat => chaque classe d'équivalence correspond à une valeur unique Ex. : la valeur 1 correspond à la classe {succ(0), succ(0)+0, 0+succ(0), succ(0+0), (succ(0)+0)+0, … } Remarque : la commutativité et la distributivité de + découlent de ces deux équations

54 5.6. Les Abstract Data Types dans LOTOS
Les Types abstraits de données dans LOTOS (ACT-ONE) => Le type complet type Nat_Number is sorts nat opns succ : nat -> nat 0 : -> nat _+_: nat -> nat eqns forall x, y : nat x+0 = x x+succ(y) = succ(x+y) => définit les valeurs 0 = {0, 0+0, (0+0)+0, …} 1 = {succ(0), succ(0+0), …} 2 = {succ(succ(0)), succ(succ(0+0)), succ(0)+succ(0), …}

55 5.6. Les Abstract Data Types dans LOTOS
Les Types abstraits de données dans LOTOS (ACT-ONE) => Héritage de type type Nat_Number_with_multiplication is Nat_Number opns _*_: nat -> nat eqns forall x, y : nat 0*x = 0 succ(x)*y = (x*y) + y => nat_number_with_multiplication hérite des sorts, opérations et équation de nat_number => structuration hiérarchique des types

56 5.6. Les Abstract Data Types dans LOTOS
En bref… : intérêt des Types abstraits de données dans LOTOS déclaratifs => indépendantes de l'implémentation => plus grande abstraction modulaires et structurés formels => possibilité de manipulations automatiques (et symboliques) sur les données => possibilité d'effectuer des preuves de consistance sur les définitions de opérations

57 - Un routeur simple - Une FIFO avec mécanisme de gestion du trop plein
5.7. Full LOTOS : exemples - Un routeur simple - Une FIFO avec mécanisme de gestion du trop plein

58 5.7. Full LOTOS : exemple 1 Un routeur simple Fonction : paquet inp
aiguille le contenu des paquets vers la droite ou la gauche en fonction de la destination du paquet left Router inp right paquet data

59 5.7. Full LOTOS : exemple 1 Un routeur simple Structure des données
Les paquets sont composés d'un champ destination et d'un champ donnée => gestdest(p) retourne la destination de p => getdata(p) retourne la donnée de p => il y a deux destinations : L (left) R (right) => domaine des valeurs du champ destination ={L, R} left Router inp right p(de, da): paquet da: data

60 5.7. Full LOTOS : exemple 1 Un routeur simple
héritage de type Data sorts data opns … eqns … endtype défini ailleurs (en bibliothèque) Un routeur simple => La spécification du type abstrait "Packet" type Packet is Data sorts packet, dest opns mkpacket: dest, data -> packet getdest: packet -> dest getdata: packet -> data L: -> dest R: -> dest eqns forall p: packet, de: dest, da: data mkpacket (getdest(p), getdata(p)) = p getdest (mkpacket(de, da)) = de getdata (mkpacket(de, da)) = da endtype trois opérations sur les sorts packet, data et dest définies par leur signature deux constantes de sorts dest les axiomes définissant les trois opérations

61 5.7. Full LOTOS : exemple 1 Un routeur simple Dynamique : p(de, da)
Lorsque le routeur reçoit des paquets sur son port inp Si l'adresse du paquet est L, alors envoyer la donnée transportée par le paquet sur le port left Si l'adresse du paquet est R, alors envoyer la donnée transportée par le paquet sur le port right Se remettre ensuite en attente d'un nouveau paquet left Router inp right p(de, da) da

62 5.7. Full LOTOS : exemple 1 Un routeur simple
=> La spécification du comportement du routeur process Router [inp, left, right] := inp ?p: packet; Emit[left, right](p) >> Router[inp, left, right] where process Emit[r, l](pack: packet) := [getdest(p) = L] -> l !getdata(p); exit [] [getdest(p) = R] -> r !getdata(p); exit endproc

63 5.7. Full LOTOS : exemple 1 Un routeur simple
… ou encore sous une forme équivalente plus simple : process Router [inp, left, right] := inp ?p: packet; ( [getdest(p) = L] -> left !getdata(p); exit [] [getdest(p) = R] -> right !getdata(p); exit ) >> Router[inp, left, right] endproc

64 5.7. Full LOTOS : exemple 2 Mécanisme de gestion de trop plein d'une FIFO Le processus Drop_Tail, lorsqu'il reçoit un message (input) teste la longueur de la FIFO : si le message peut entrer dans la FIFO, il est envoyé vers la FIFO (forward) si le message n'entre pas dans la FIFO, le message est perdu input output forward Drop_Tail_Queue Drop_Tail FIFO_Queue

65 5.7. Full LOTOS : exemple 2 Mécanisme de gestion de trop plein d'une FIFO => La spécification des données : On parle de : FIFO => il se faut se donner : une constante empty_queue (une FIFO vide) une opération d'empilage : enqueue une opération de dépilage : dequeue une opération qui retourne le premier élément de la file : first une opération de test d'une file : isempty paquets => il faut se donner : une opérations retournant la taille su paquet : getsize une opération retournant le champ donnée d'un paquet : getdata

66 5.7. Full LOTOS : exemple 2 Mécanisme de gestion de trop plein d'une FIFO => La spécification des données type Packet_Queue is Data, Bool, Nat_Number sorts packet, fifo opns mkpacket: nat, data -> packet getsize: packet -> nat getdata: packet -> data empty_queue: -> fifo isempty: fifo -> bool enqueue: fifo, packet -> fifo dequeue: fifo, packet -> fifo first: fifo -> packet eqns forall x: packet, q: fifo isempty(empty) = true getsize(empty_queue) = 0 first(empty_queue) = error_data getsize(enqueue(x, q)) = getsize(q) + 1 ... endtype

67 5.7. Full LOTOS : exemple 2 Mécanisme de gestion de trop plein d'une FIFO => La spécification de l'architecture de Drop_Tail_Queue process Drop_Tail_Queue [input, output, right](maxqlen: nat) := hide forward in Drop_Tail[input, forward, output](maxqlen, 0) |[forward, output]| FIFO_Queue[forward, output](empty_queue) endhide where ... endproc input output forward Drop_Tail_Queue Drop_Tail FIFO_Queue

68 5.7. Full LOTOS : exemple 2 Mécanisme de gestion de trop plein d'une FIFO => La spécification du comportement de FIFO_Queue process FIFO_Queue [input, output](q: fifo) := input ?x: packet; FIFO_Queue[input, output](enqueue(q, x)) [] output !first(q) [not isempty(q)] ; FIFO_Queue(dequeue(q)) endproc

69 5.7. Full LOTOS : exemple 2 Mécanisme de gestion de trop plein d'une FIFO => La spécification du comportement de Drop_Tail process Drop_Tail [input, forward, output](maxqlen, qlen: nat) := input ?x: packet [qlen + getsize(x) <= maxqlen]; forward !x Drop_Tail[input, forward, output](maxqlen, qlen + getsize(x)) [] input ?x [qlen + getsize(x) > maxqlen]; Drop_Tail[input, forward, output](maxqlen, qlen) output ?x; Drop_Tail[input, forward, output](maxqlen, qlen - getsize(x)) endproc

70 5.8. Résumé et conclusion

71 5.8. Résumé et conclusion ! LOTOS : une base formelle bien établie :
développé à partir d'une base théorique solide (les algèbres de processus et les algèbres de types de données) => manipulations symboliques formelles Expressivité permet la description d'architectures (système = assemblage de blocs) permet l'expression de comportements dynamiques concurrence, non déterminisme, communication synchrone et asynchrone permet la représentation de structures de données avec leurs opérations Mais, pas de représentation du temps, de priorités… => Extensions : RT-LOTOS, UML-LOTOS… !

72 5.8. Résumé et conclusion Mais ! => Besoins d'une méthodologie
LOTOS = Lots Of Terribly Obscure Symbols LOTOS = Language Of Thousands of Styles => Besoins d'une méthodologie de modélisation pour les niveaux abstraits de conception pour les niveaux concrets… => Besoin d'une simplification syntaxique et d'un enrichissement conceptuel E-LOTOS (normalisé en 2001). !


Télécharger ppt "Chapitre 5. Le Langage LOTOS"

Présentations similaires


Annonces Google