Modélisation de systèmes en AADL

Au cours de ce TP, vous allez écrire pas à pas la modélisation d'un système constitué de noeuds se transmettant des messages.

Des noeuds émettent des messages vers d'autres noeuds qui les reçoivent. Les noeuds sont modélisés par des processus ; leur structure interne changera selon les exercices, mais leur interface restera la même.

Pour éditer vos fichiers AADL, vous utiliserez Eclipse avec l'extension OSATE. Pour vous aider dans la syntaxe, les transparents du cours sont accessibles ici.

La modélisation que vous allez réaliser au cours de ce TP utilisera plusieurs fichiers. Certains fichiers vous sont déjà fournis ; vous pouvez vous en inspirer pour répondre aux différents exercices.

Récupérez les fichiers et ouvrez-les avec Emacs ou Eclipse, pour voir les éléments de l'architecture dont vous disposez.

• raar.aadl contient les déclaration des composants de base que vous allez utiliser pour commencer ;
• arao.aadl contient les déclarations de propriétés supplémentaires utilisées par le générateur de code ;
• repository.ads et repository.adb contiennent les implantations en code source associées aux sous-programmes AADL définis dans raar.aadl.

Le fichier raar.aadl contient des déclarations de composants simples, ainsi qu'un type système, appelé transmissions.

Vous allez créer une implantation du système transmission qui décrira la façon dont sont utilisés ces composants : leur attachement à un processeur, les connexions entre eux, etc. Il s'agit donc de décrire le déploiement de vos composants. Cette implantation de système s'appelera transmissions.simple. Elle devra comporter les éléments suivants :

• un processus émetteur d'implantation proc_sender.simple, appelé sd1 ;
• un processus récepteur d'implantation proc_receiver.simple, appelé rc1 ;
• un processeur de type proc, appelé pr.

Vous modéliserez les connexions entre les différents composants de l'architecture. Tous les processus seront attachés au processeur pr. Éditez le fichier raar.aadl pour ajouter cette implantation de système.

Vous avez à présent une description complète d'architecture en AADL, avec des processus attachés à un processeur. L'étape suivante est de générer un système exécutable. Pour cela, il est nécessaire d'associer une description comportementale aux composants AADL. Les descriptions comportementales concernent les éléments logiciels de l'architecture.

Les composants logiciels de votre description sont des processus, des threads et des sous-programmes. Les processus n'ont pas de description comportementale, car ils définissent seulement les espaces de mémoire dans lesquels vont s'exécuter les threads. Les threads eux-mêmes se résument à des séquences d'appels pour coordonner les sous-programmes. Les sous-programmes, en revanche, décrivent la partie applicative de l'architecture. Ils correspondent aux procédures que vous écririez avec un langage de programmation.

La liaison entre la description architecturale et la description comportementale se fait au niveau des fichiers AADL : il faut indiquer le code source correspondant aux implantations des sous-programmes AADL. Il faut utiliser deux propriétés source_language et source_code :

subprogram implementation sp.impl
properties
  source_language => Ada95;
  source_code => "Repository";
end sp.impl;

Ces propriétés indiquent que la description comportementale des sous-programmes est faite en Ada, et qu'elle se situe dans le package Ada « Repository ».

Dans cet exercice, vous allez produire une application exécutable à partir de votre description AADL. Il s'agit pour cela d'instancier le système transmissions.simple et traduire les constructions AADL en code exécutable. Vous allez utiliser Ocarina, un compilateur pour AADL, et PolyORB, un intergiciel schizophrène. Ces outils s'utilisent en ligne de commande. Le fichier env.sh contient les différentes variables d'environnement nécessaires à l'exécution des outils :

source Applications/tp_aadl/env.sh

Pour produire du code avec Ocarina à partir de votre description AADL, tapez :

ocarina -c -t ada -g ada raar.aadl

Ocarina va créer un répertoire correspondant au nom de votre système global transmission.simple. Ce répertoire contiendra autant de sous-répertoires que d'instances de processus dans votre architecture (il devrait donc y avoir deux sous-répertoires).

Regardez les codes sources générés. Ils font référence au package Repository. Pour compiler les différents exécutables de l'application, vous devez copier les fichiers repository.ads et repository.adb dans les sous-répertoires. Utilisez ensuite gnatmake pour compiler chaque exécutable :

gnatmake <programme> `polyorb-config`

Vous pouvez à présent lancer les deux exécutables pour faire fonctionner l'application.

Votre architecture fait intervenir deux processus : un émetteur simple et un récepteur simple. Ces processus contiennent chacun un thread. Le but de l'exercice est d'ajouter un nouveau type de thread afin de modéliser un transmetteur.

Un thread transmetteur a un port d'événement/donnée en entrée et un port d'événement/donnée en sortie. Ces deux ports sont associés au composant de donnée message. Déclarez le type de processus thread_transmitter correspondant à cette interface. Définissez également deux implantations de thread transmetteur :

• thread_transmitter.simple, qui appelle un sous-programme d'implantation sp_transmitter.impl ;
• thread_transmitter.complex, qui effectue deux appels successifs au sous-programme d'implantation sp_transmitter.impl.

Le type sous-programme sp_transmitter a l'interface suivante :

• un paramètre en entrée, associé à la donnée message ;
• un paramètre en sortie, associé à la donnée message.

Créez alors une nouvelle implantation proc_sender.complex, qui contient à la fois un thread thread_sender.simple et un thread thread_transmitter.simple. Cette implantation de processus s'appellera proc_sender.complex.

Finalement, créez une nouvelle implantation tranmissions.simple2 du système transmissions. Cette implanntation est identique à transmissions.simple, mais l'émetteur sd1 est d'implantation proc_sender.complex. Notez que la représentation graphique de l'architecture ne change pas, puisque vous ne faites que remplacer une implantation de composant par une autre.

Écrivez un code source pour le sous-programme sp_transmitter. Regénérez le code source de l'application et testez votre application.

Vous êtes libre d'écrire le code que vous voulez. Dans la mesure où le type de données dt à la sémantique d'un entier, vous pouvez par exemple faire une addition. Ceci permettra de vérifier que le sous-programme est effectivement appelé, puisque les données auront été modifiées entre l'entrée et la sortie.

Vous avez maintenant généré un système réparti qui s'exécute. Tous les composants AADL nécessaires ont été définis ; vous avez associé une description comportementale aux composants applicatifs (les sous-programmes). Ce dernier exercice va consister en la modification de l'architecture.

Vous allez créer une troisième implantation transmissions.complex. Cette implantation reprend les éléments de tranmissions.simple2, en ajoutant un nouveau récepteur rc2, identique à rc1. Ajoutez les connexions nécessaires, de sorte que la sortie de tr1 soit connectée à la fois à l'entrée de rc1 et à l'entrée de rc2. Tous les processus sont toujours attachés au processeur proc1. L'architecture à modéliser est donc la suivante :

Cet exercice est moins directif que les autres, pour vous permettre d'expérimenter par vous-même.

Jusqu'ici, vous avez utilisé les threads pour séquencer des sous-programmes AADL. Les sous-programmes sont vus comme des éléments « terminaux » de l'architecure : ils ne contiennent rien. Le but de cet exercice est de décrire une architecture d'application de façon plus élaborée.

Définissez une implantation de processus proc_receiver.complex, qui contiendra une implantation de thread thread_receiver.complex. Cette implantation de thread contiendra un appel à un sous-programme d'implantation sp_transmitter.seq. Cette implantation doit contenir la séquence d'appels suivante :

1. sp_transmitter.impl
2. sp_receiver.impl

Définissez une nouvelle implantation du système transmissions, où vous ferez apparaître la nouvelle implantation de processus proc_receiver.complex. Vous êtes libre de décrire ce nouveau déploiement comme bon vous semble. Notamment, vous pouvez faire apparaître plusieurs processeurs.