IP N72TR 5 Lotos

Chapitre 5.
Le Langage LOTOS
Language
Of
Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Temporal
Ordering
Specification
LOTOS… -1
5.1. Introduction

- LOTOS en bref…
- Les versions du langage
- Le plan du chapitre
LOTOS… -2
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 » b c
– Un événement = support de l'interaction
=> véhicule des données a
=> permet la synchronisation (rendez-vous)
LOTOS… -3
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
LOTOS… -4
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
LOTOS… -5
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

LOTOS… -6
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
LOTOS… -7
5.2. Algèbre de processus :
aspects principaux

- Les concepts principaux…
- Les principales lois de compositions…
- Le coté algébrique : l'axiomatisation…
LOTOS… -8
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
LOTOS… -9
lire
Les principaux opérateurs des algèbres de
processus… traiter
– la séquence (préfixage) notée « ; »
lire ; traiter ; ecrire ; STOP ecrire
stop
– le choix non déterministe noté « [] »

lire ecrire
(lire ; STOP)
stop
[]
(ecrire ; ((traiter ; STOP)
traiter ouvrir
[]

stop stop
(ouvrir ; STOP)))
– le parallélisme avec communication synchrone

a a
noté « | […] | »

(a ; b ; c ; STOP) d
| [a, b] | b b
(a ; d ; b ; STOP)
stop
c
LOTOS… -10 stop

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.
LOTOS… -11
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
LOTOS… -12
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
LOTOS… -13
5.3. Basic LOTOS
Pour continuer…
– La structure du langage : Nom du processus
Liste des portes

du processus
process <process_id> <parameter_part> :=

<behaviour_expression>
endproc Expression régulière

définissant le comportement
du processus
a b c
Exemple : process P [a, b, c] := … endproc P
LOTOS… -14
5.3. Basic LOTOS
Les opérateurs et constructions du langage

– Le processus élémentaire stop
Processus qui ne peut rien faire
process inaction [a, b] := a b

stop
endproc
inaction

=> stop est assimilé à un deadlock
LOTOS… -15
5.3. Basic LOTOS

– préfixage : a ; B
• a est une action atomique
• B est une expression de comportement
Exemple : out_data
process P [out_data] :=
out_data ; stop
out_data P
stop
endproc

process Q [in_data, out_data] := in_data out_data
in_data ; out_data ; stop in_data
endproc P
out_data
stop
LOTOS… -16
5.3. Basic LOTOS

– 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 a b
[]
b ; stop
endproc a b choix
stop stop
LOTOS… -17
5.3. Basic LOTOS
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_a out_a
[]
in_b ; (in_a ; (out_b ; out_a ; stop duplex
[] out_a ; out_b ; stop)
[] out_b ; in_a ; ou_a ; stop) in_b out_b
endproc

in_a in_b
in_b out_a out_a in_a
out_a out_b in_b in_b out_a out_b
out_b out_a out_b out_b out_b out_a
stop stop stop stop stop stop

LOTOS… -18
5.3. Basic LOTOS

– Instanciation de processus :
Instanciation du processus P en
séquence de l'action in_data
Exemple :
process Q' [in_data, out_data] :=
in_data ; P[out_data]
where process P [a] := a ; stop endproc
endproc

in_data
in_data
P[out_data]
équivalent à
out_data
out_data
stop
stop
LOTOS… -19
5.3. Basic LOTOS

– Instanciation de processus :
Exemple :
process generator [in_data, out_data] :=
in_data
in_data ; out_data ;
generator[in_data, out_data]
out_data
endproc

process abba [a, b] := a b b a
a ; b ; abba[b, a]
endproc
LOTOS… -20
5.3. Basic LOTOS
– Parallélisme sans interaction : B1 ||| B2
• 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] := b
a
a ; stop ||| b ; stop
stop stop
endproc
a b
équivalent à a
b
stop stop
LOTOS… -21
5.3. Basic LOTOS
Exemple :
process duplex [in_a, in_b, out_a, out_b] := in_a out_a
line[in_a, out_a]
||| line[in_a, ou_a]
line[in_b, out_b] duplex
line[in_b, out_b]
where process line[in, out] :=

in ; out ; stop in_b out_b
endproc
endproc
LOTOS… -22
5.3. Basic LOTOS

– Parallélisme avec interaction : B1 |[a1, …, an]| B2
• 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] := b
a ; stop |[a]| b ; a ; stop
endproc a a
stop stop
LOTOS… -23
5.3. Basic LOTOS
Exemple :
process two_buffers [in, out] := in
buff[in, middle]
|[middle]| buff[in, middle]
buff[middle, out] middle
buff[middle, out]
where process buff[in, out] :=

in ; out ; stop out
endproc
endproc in
middle middle
stop
out
stop
LOTOS… -24
5.3. Basic LOTOS

Exemple :
int1 int2
entity1 entity2
int3 int4
service

process protocol-v1 [int1, int2, int3, int3] :=
entity1[int1, int3]
|[int3]|
service[int3, int4]
|[int4]|
entity1[int2, int4]
where ...
endproc
LOTOS… -25
5.3. Basic LOTOS

Exemple : (autre modélisation équivalente)
int1 int2
entity1 entity2
int3 int4
service

process protocol-v2 [int1, int2, int3, int3] :=
(entity1[int1, int3] ||| entity1[int2, int4])
|[int3, int4]|
service[int3, int4]
where ...
endproc
LOTOS… -26
5.3. Basic LOTOS
– Hiding : hide a1, …, an in B
• 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
– … int1 int2
entity1 entity2

int3 int4
service
process protocol-v3 [int1, int2] :=
hide int3, int4 in
(entity1[int1, int3] ||| entity1[int2, int4])
|[int3, int4]|
service[int3, int4]
where ...
endproc
LOTOS… -27
5.3. Basic LOTOS
– 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)

LOTOS… -28
5.3. Basic LOTOS
– 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
LOTOS… -29
5.3. Basic LOTOS
– 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
LOTOS… -30
5.4. Basic LOTOS : exemple

- Les trois philosophes en LOTOS
LOTOS… -31
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
LOTOS… -32

1. Modélisation d'un philosophe
• alphabet :
– pense
– prd-fdroite pense mange
– prd-fgauche
prd-fgauche prd-fdroite
– mange
– pose-fdroite philo
pose-fgauche 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
LOTOS… -33

2. Modélisation d'une fourchette
• alphabet :
– prise-droite, prise-gauche
– rendue-droite, rendue-gauche
prise-gauche prise-droite
fourchette
rendue-gauche rendue-droite

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
LOTOS… -34

3. Modélisation des interactions
• alphabet global
– philo1-pense, philo1- mange, philo1-prd-fdroite, philo1-pose-fdroite, philo1-prd-
fgauche, philo1-pose-fgauche,
– fourchette1-prise-droite, fouchette1-rendue-droite, fourchette1-prise-gauche,

fourchette1-rendue-gauche
LOTOS… -35

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



LOTOS… -36

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)
…/…
LOTOS… -37
(philo[philo1-pense, philo1-mange,
fourche2-prise-gauche, fourche1-prise-droite,
fourche2-rendue-gauche, fourche1-rendue-droite]
|||
philo[philo2-pense, philo2-mange,
fourche3-rendue-gauche, fourche2-rendue-droite]
|||
philo[philo3-pense, philo3-mange,
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
LOTOS… -38
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
LOTOS… -39
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
LOTOS… -40
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
LOTOS… -41
5.5. Full LOTOS

– préfixage : a !E ; B
• a est un identificateur de porte
• E une valeur ou une expression de valeur
=> offre la valeur de E sur la porte a, puis exécute B
– préfixage : a ?x: t ; B

• a est un identificateur de porte
• 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
LOTOS… -42
5.5. Full LOTOS
• Synchronisation : value matching
process process Synchron. condition Type of interaction Effect
g !E1 g !E2 value(E1) = value(E2) value matching synchronisation
• Synchronisation : value passing


value(E)  t synchronisation
g ?x: t g !E value passing
et x=value(E)
• Synchronisation : value generation

synchronisation
g ?x: t g ?y: u t=u value generation et x=y=v
où v est une valeur
LOTOS… -43
quelconque de la sort t
5.5. Full LOTOS

=> 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)
LOTOS… -44
5.5. Full LOTOS

=> 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) g1(x:=1) g1(x:=2)
g2(x)
stop
LOTOS… -45
5.5. Full LOTOS

=> 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
LOTOS… -46
5.5. Full LOTOS

=> 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 équivalent à (en pseudo code C)
[] if x>0 then g(x);
[x=0] -> erreur ; exit) else if x<0 then g(-x)
>> B else erreur();
endif;
endif;
B();
LOTOS… -47
5.5. Full LOTOS
=> 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)
LOTOS… -48
5.5. Full LOTOS

=> 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
LOTOS… -49
5.6. Les Abstract Data Types dans LOTOS
LOTOS… -50
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
LOTOS… -51
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 !

LOTOS… -52

=> Trois parties (suite)
• définition des opérations par un ensemble d'axiomes
Remarque : eqns forall x, y : nat (pour tout terme x, y  nat)
la commutativité
et la distributivité x+0 = x (x+0 et x représentent la même valeur)
de + découlent de x+succ(y) = succ(x+y) …
ces deux équations
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, … }
LOTOS… -53

=> 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), …}
…
LOTOS… -54

=> 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
LOTOS… -55
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
LOTOS… -56
5.7. Full LOTOS : exemples

- Un routeur simple
- Une FIFO avec mécanisme de gestion du trop plein
LOTOS… -57
5.7. Full LOTOS : exemple 1
Un routeur simple
paquet
inp
data Router data

left right

– Fonction :
aiguille le contenu des paquets vers la droite ou la gauche en fonction
de la destination du paquet
LOTOS… -58
Un routeur simple p(de, da): paquet
inp
da: data Router da: data

left right
– 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}
LOTOS… -59
héritage de
type Data
Un routeur simple sorts
=> La spécification du type abstrait "Packet" data
opns …
eqns …
type Packet is Data endtype
sorts défini ailleurs (en bibliothèque)
packet, dest
opns
trois opérations
mkpacket: dest, data -> packet sur les sorts packet,
getdest: packet -> dest data et dest définies
deux constantes

getdata: packet -> data par leur signature
de sorts dest
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
les axiomes définissant
les trois opérations
LOTOS… -60
Un routeur simple p(de, da)
inp
da Router da
left right
– Dynamique :

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
LOTOS… -61
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
endproc
LOTOS… -62
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
LOTOS… -63
Mécanisme de gestion de trop plein d'une FIFO

input Drop_Tail_Queue
Drop_Tail FIFO_Queue
forward
output

– 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
LOTOS… -64
=> 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
LOTOS… -65
=> 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
LOTOS… -66

=> 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 Drop_Tail_Queue
Drop_Tail FIFO_Queue
forward
output
LOTOS… -67

=> 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

LOTOS… -68

=> 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
LOTOS… -69
5.8. Résumé et conclusion
LOTOS… -70
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…
LOTOS… -71
Mais
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).
LOTOS… -72

IP N72TR 5 Lotos

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

IP N72TR 5 Lotos

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 5.

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

– En LOTOS, un système distribué est représenté par un ensemble de processus

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

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

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

=> Un alphabet d'actions

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

– le choix non déterministe noté « [] »

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

– le parallélisme avec communication synchrone

noté « | […] | »

LOTOS… -10 stop

=> possibilité de manipulations formelles symboliques sur les termes de

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

=> Un cadre mathématique support de LOTOS.

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

L'environnement d'un processus est composé des autres processus

Liste des portes

process <process_id> <parameter_part> :=

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Exemple : process P [a, b, c] := … endproc P

Les opérateurs et constructions du langage

process inaction [a, b] := a b

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Les opérateurs et constructions du langage

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Les opérateurs et constructions du langage

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

in_b out_a out_a in_a

out_a out_b in_b in_b out_a out_b

out_b out_a out_b out_b out_b out_a

stop stop stop stop stop stop

Les opérateurs et constructions du langage

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Les opérateurs et constructions du langage

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Les opérateurs et constructions du langage

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Les opérateurs et constructions du langage

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Les opérateurs et constructions du langage

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Les opérateurs et constructions du langage

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Les opérateurs et constructions du langage

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

– Terminaison avec succès : le processus élémentaire exit

– Terminaison sans succès : le processus élémentaire stop

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux

Ingénierie des protocoles - 2ème année N7 Télécom et Réseaux