Modélisation des systèmes temps-réel répartis embarqués pour la ...

Chapitre VII – Vérification formelle de la structure des applications
VII-5 Modélisation de l’implantation des composants
Jusqu’ici, nous avons modélisé les opérations de traitement des composants par une transition.
La représentation de l’implantation d’un composant consiste à remplacer cette transition par le
sous-réseau de Petri décrivant les séquences d’appel décrits dans l’implantation du composant. Le
réseau de Petri fait alors apparaître les connexions entre les différents sous-éléments du composant.
VII-5.1 Modélisation des sous-composants
En section VII-4.1.2, nous avons indiqué que la représentation en réseaux de Petri se basait sur
les composants actifs de l’architecture. D’après ce que nous avons établi dans la règle VII.7, un
composant possédant des sous-composants est systématiquement remplacé par ces derniers. Seuls
les sous-composants sont donc représentés dans un réseau de Petri ; cette situation a donc déjà été
traitée en section VII-4.1.2.
VII-5.2 Modélisation des sous-programmes
Contrairement à la génération de code que nous avons présentée au chapitre V, la traduction en
réseau de Petri rend compte des flux d’exécution. Selon cette approche, chaque sous-programme
est modélisé dans le réseau autant de fois qu’il est appelé. Chaque appel de sous-programme est
donc assimilé à une instance. Il en est par conséquent de même pour un accès requis à un sousprogramme.
Règle VII.12 (Traduction des accès à sous-programme)
L’appel d’un sous-programme dont l’accès est requis par un thread ou un sousprogramme
est assimilé à un appel normal au sous-programme correspondant.
De la même façon que les composants de haut niveau, les sous-programmes sont modélisés
par une transition entourée de places modélisant les paramètres d’entrée et de sortie.
Règle VII.13 (Traduction des sous-programmes)
Un appel de sous-programme AADL est traduit par une transition et des places correspondant
à ses différents paramètres. Le flux d’exécution contrôlant l’appel du sousprogramme
est matérialisé par deux places transmettant un jeton de contrôle à la transition
du sous-programme. Ce jeton de contrôle est celui du thread dans lequel l’appel est
effectué.
Les places d’entrée sont connectées à la transition du sous-programme par un arc simple,
de la même façon que pour les places de contrôle. Les places de sortie ont un marquage
initial fixé à u. La transition du sous-programme consomme et réinjecte les jetons issus
de ces places. Une garde est associée à la transition pour empêcher la consommation de
la valeur indéfinie u.
Un paramètre d’entrée sortie est traduit par une place d’entrée et une place de sortie.
Les paramètres de sortie des sous-programmes modélisent des variables : leur valeur doit pouvoir
être lue plusieurs fois, par différents sous-programmes. C’est pourquoi la transition du sousprogramme
doit remplacer un jeton qui est constamment à disposition.
Le cas d’un appel à un sous-programme distant – dont l’accès est fourni par un autre thread –
présente quelques spécificités. En effet, un tel sous-programme met en jeu à la fois le thread local,
qui effectue l’appel, et le thread distant, qui exécute effectivement le sous-programme. L’exécution
du sous-programme nécessite donc les ressources d’exécution des deux threads.
c○ 2007 Thomas Vergnaud 133