Réalisation Assistée d`Applications Réparties Examen

Master UPMC Sciences et Technologies, mention Informatique
Spécialité Systèmes et Applications Réparties
Réalisation Assistée d’Applications Réparties
Examen
B.Bérard, F. Kordon & B. Zalila
19 Novembre 2008
Durée : 2h
Seul document autorisé : mémento de B. Bérard
Les téléphones portables doivent être éteints et dans les sacs
Chacune des parties de ce sujet doit être traitée sur une copie différente
Avant-propos
Toutes vos réponses doivent être claires et justifiées (une réponse non justifiée peut être considérée comme
fausse). Les barêmes associés aux questions sont indicatifs.
Ne confondez pas « bonne réponse » avec « longue réponse » ;-)
Partie I
Prototypage, génération automatique de programmes (10 points)
1 Sur le cours
Question I.1 (1,5 point) Pouvez-vous replacer rapidement les évolutions dans l’architecture des middleware (15 ignes maximum)
Question I.2 (1,5 point) Reliez entre elles les notions suivantes : prototypage, MDD, génération de code
(15 ignes maximum).
Question I.3 (1,5 point) On souhaite intégrer la notion d’automates dans AADL. Dans quelle(s) entité(s)
AADL suggèreriez-vous leur intégration ? comment les connecteriez-vous à la partie architecturale (20 lignes
maximum)
1
•
a
•• e
d
t1
•• k
i
t4
2
t6
b
l
f
t3
t7
c
g
m
j
t2
t5
2
h
t8
n
F IG . 1 – Réseau de Petri à étudier.
2 Génération de programmes
Nous souhaitons générer un programme associé au réseau de Petri de la figure 1.
L’invocation d’un outil approprié nous ramène le calcul des invariants suivants :
F1 2×a + 2×c + d + 2× f + i + k = cst
F2 2×a + 2×c + d + e + 2× f = cst
F3 2× f + 2×g + 2×i + j + 2×k + n = cst
F4 2×e + 2× f + 2×g + j + n = cst
F5 f + g + h + i + k = cst
F6 e + f + g + h = cst
F7 a + b + c = cst
F8 k + l + m + n = cst
Question I.4 (1 point) Une analyse préliminaire de ces invariants nous permet-elle d’en suprimer certains ?
Justifiez votre réponse
Question I.5 (1 point) Peut-on proposer un (ou plusieurs) partitionnement(s) du modèle ? expliquez brièvement pourquoi et explicitez ce (ces) partitionnement(s).
Question I.6 (1 point) Indiquez tous les objets de génération associés au(x) partitionnement(s) que vous
proposez.
Question I.7 (1 point) Pouvez-vous indiquer combien de threads aura l’implémentation de cette spécification (vous devez le faire pour chaque décomposition que vous aurez trouvé) ?
Question I.8 (1,5 point) On souhaite répartir la gestion des « ressources » en utilisant la structure de la
spécification (approche hybrique de gestion des ressources). Proposez un partitionnement des ressources
en conséquence. Justifiez ce découpage.
Partie II
Sémantique d’exécution des applications réparties (5 points)
Dans cet exercice, on cherche à réaliser un tampon de taille n au moyen de n tampons de taille 1.
2
Un tampon de taille 1 est spécifié par le processus B, défini simplement par les termes suivants (dans
l’algèbre de processus du cours) :
B def
= in.B′
= out.B
B′ def
qui correspond au système de transitions suivant :
in
B′
B
out
Un tampon de taille n, pour n ≥ 3, est spécifié par un processus Tn , défini par les termes suivants :
def
= in.S1
= in.S2 + out.Tn
def
= in.Sk+1 + out.Sk−1 pour 2 ≤ k ≤ n − 1,
def
= out.Sn−1
Tn
S1
Sk
Sn
def
Pour n = 2, on considère simplement que les définitions intermédiaires (pour 2 ≤ k ≤ n − 1) sont omises.
Question II.1 (1 point) Dessiner les systèmes de transitions associés respectivement aux tampons T2 et
T3 .
Soient deux copies B1 et B2 du tampon de taille 1, définies par :
B1 def
= in.B′1
def
B2 = o1 .B′2
B′1 def
= o1 .B1
B′2 def
= out.B2
Question II.2 (1 point) Vérifier que (B1 k B2 ) \ {o1 } est faiblement bisimilaire à T2 .
On considère maintenant trois copies B1 , B2 et B3 du tampon de taille 1, définies par :
B1 def
= in.B′1
def
B2 = o1 .B′2
B3 def
= o2 .B′3
B′1 def
= o1 .B1
B′2 def
= o2 .B2
B′3 def
= out.B3
et le processus (B1 k B2 k B3 ) \ K , où K est le sous-ensemble d’actions du système défini par K = {o1 , o2 }.
Question II.3 (3 points)
A) Justifier par un arbre d’inférence chacune des transitions suivantes :
in
• (B1 k B2 k B3 ) \ K −
→ (B′1 k B2 k B3 ) \ K
ε
• (B′1 k B2 k B3 ) \ K −
→ (B1 k B′2 k B3 ) \ K
B) En donnant simplement la correspondance, vérifier que le processus (B1 k B2 k B3 ) \ K est fortement
bisimilaire à E0 dans le système T suivant :
out
out
E0
in
E1
ε
E2
in
E3
ε
out
ε
out
E5
in
E4
3
ε
E6
in
E7
C) En déduire que (B1 k B2 k B3 ) \ K est faiblement bisimilaire à T3 .
D) Que suggérez-vous de démontrer dans le cas général pour Tn ?
Partie III
Modélisation en AADL (5 points)
3 Analyse architecturale
On considère le modèle AADL suivant :
process Alarm_Process
features
Img_In : in data port Image;
end Alarm_Process;
data Image
end Image;
thread Detect_Motion
features
Img_In
: in data port Image;
Motion_Detected : out event port;
properties
Dispatch_Protocol
=> Periodic;
Period
=> 50 Ms;
Compute_Execution_Time => 0 Ms .. 30 Ms;
end Detect_Motion;
process implementation Alarm_Process.Impl
subcomponents
Detector : thread Detect_Motion.Impl;
Handler : thread
Handle_Motion_Detection;
connections
data port Img_In -> Detector.Img_In;
event port Detector.Motion_Detected
-> Handler.Motion_Detected;
end Alarm_Process.Impl;
thread implementation Detect_Motion.Impl
subcomponents
Last_Image : data Image;
calls {
S : subprogram Process_Image;
};
connections
parameter Img_In -> S.Img_In;
data access Last_Image -> S.Last_Image;
event port S.Motion_Detected
-> Motion_Detected;
end Detect_Motion.Impl;
processor CPU
end CPU;
system Alarm_System
end Alarm_System;
system implementation Alarm_System.Impl
subcomponents
The_CPU
: processor CPU;
The_Camera
: device Camera;
The_Alarm_Handler : process
Alarm_Process.Impl;
connections
data port The_Camera.Img
-> The_Alarm_Handler.Img_In;
properties
Actual_Processor_Binding => reference The_CPU
applies to The_Alarm_Handler;
end Alarm_System.Impl;
thread Handle_Motion_Detection
features
Motion_Detected : in event port;
properties
Dispatch_Protocol => Sporadic;
end Handle_Motion_Detection;
Il décrit un système d’alarme basé sur la détection de mouvement. Une caméra délivre des images. Ces
images sont traitées par un thread périodique, Detect_Motion, qui calcule la différence entre l’image reçue
dans le cycle courant et celle reçue dans le cycle précédant, qu’il stocke dans une variable, Last_Image.
Le comportement du thread Detect_Motion se résume à appeler le sous-programme, Process_Image qui
fait les calculs nécessaires et émet l’événement Motion_Detected en cas de détection de mouvement.
Un thread sporadique Handle_Motion_Detection reçoit l’événement Motion_Detected et effectue la
levée de l’alarme. Le comportement interne de ce thread n’est pas donné.
Un processus AADL (Alarm_Process.Impl) rassemble les deux threads et un système global permet de
rassembler le processus, la caméra et un processeur (composant CPU).
Question 3.1 (1 point) Déduire à partir du modèle AADL des déclarations minimales pour les composants
Process_Image et Camera.
Question 3.2 (1 point) On suppose maintenant que le composant Camera possède la propriété suivante :
4
Period => 100 Ms;
Ceci veut dire que la caméra délivre 10 images par secondes.
Peut-on optimiser le comportement du thread Detect_Motion ? Justifier
Question 3.3 (2 points) On désire rendre notre application répartie en lui ajoutant un second processus
qui implante un système d’enregistrement de toutes les images prises par la caméra lors de la détection de
mouvement et jusqu’à la fin de cette détection. Ceci permettra à un contrôleur humain de décider s’il s’agit
d’une fausse alarme ou pas.
Pour cela on modifie l’interface du thread Detect_Motion comme suit :
thread Detect_Motion
features
Img_In : in data port Image;
Img_Out : out event data port Image; -- New Added port
Motion_Detected : out event port;
properties
-- [...]
end Detect_Motion;
Et celle du processus Alarm_Process comme suit :
process Alarm_Process
features
Img_In : in data port Image;
Img_Out : out event data port Image; -- New Added port
end Alarm_Process;
Pendant toute la durée de la détection de mouvement, le thread Detect_Motion émet des événements
messages sur le nouveau port Img_Out ajouté. Ce port est connecté au port portant le même nom du
processus Alarm_Process.
Compléter la connexion entre les deux ports Img_Out dans la section connections du processus Alarm_Process.Impl
(0.5 pt).
Proposer le modèle d’un thread sporadique Record_Images, qui sera déclenché par les événements messages du thread Detect_Motion. On ne demande pas de décrire le comportement interne du thread ajouté
(0.75 pt).
Proposer un modèle pour le second processus Motion_Recorder.Impl qui contiendra le thread Record_Images.
On demande de donner la déclaration du processus Motion_Recorder ainsi que l’implantation Motion_Recorder.Impl
(0.75 pt).
Question 3.4 (1 point) Compléter le modèle du système global Alarm_System.Impl en y ajoutant la déclaration du sous-composant The_Motion_Recorder (instance de Motion_Recorder.Impl). Il faut compléter aussi les sections connections et properties du système.
5