TP AADL avec AADLInspector/Cheddar

Frank Singhoff
Université de Brest





Exercice 1, premiers pas avec AADLInspector



Pour cette série d'exercices, nous allons utiliser AADLInspector pour éditer et manipuler nos modèles AADL. L'objectif de ce premier exercice est de prendre en main l'outil.

Afin de pouvoir utiliser AADLInspector sur le réseau enseignement, il faudra auparavant utiliser, dans un shell, la commande suivante :

source ai.bash

puis :

AADLInspector&

Le fichier ai.bash se trouve ici . Une fois votre environnement initialisé, vous pouvez commencer à utiliser AADLInspector.





Exercice 2, premiers modèles AADL : composants, propriétés, bibliothèques et projets

Dans ce deuxième exercice, nous allons éditer nos premiers modèles AADL.


Question 1 :

  1. Editer un modèle AADL comportant un composant process nommé application et qui contient :
  2. Vérifier la correction syntaxique et sémantique de ce modèle.
  3. Afin de vérifier l'ordonnancement de ce modèle, compléter ce modèle en supposant un ordonnanceur POSIX préemptif à priorité fixe (propriété AADL Scheduling_Protocol=>POSIX_1003_HIGHEST_PRIORITY_FIRST_PROTOCOL)
  4. Vérifier son ordonnancement.
  5. Donner le graphe d'instance de ce modèle.


Question 2 :

  1. A partir du modèle de la question 1 et sans introduire de nouveaux types ou changer ceux existants, comment étendre ce modèle afin de déclarer 3 producteurs et 2 consommateurs dont les paramètres sont les suivants :
  2. Vérifier la correction de votre modèle en construisant le graphe d'instance et par des simulations avec Cheddar.


Question 3 :

  1. On souhaite que les threads de la question 2 communiquent grâce à un composant data partagé. On applique ici le procotole PCP pour les accès à ce composant (propriété AADL Concurrency_Control_Protocol => PCP). Tous les producteur accèdent à cette ressource partagée pendant l'intégralité de leur exécution.
  2. Modifier votre précédent modèle et par simulation, identifier les instants de prise et de libération de la ressource.


Question 4 :


Avec AADL, il est possible de construire des collections de composants réutilisables. On cherche maintenant à faire évoluer notre architecture logicielle en proposant plusieurs modèles de processeurs afin de permettre à l'utilisateur de tester la simulation d'une application avec différents algorithmes d'ordonnancement.
  1. Créer un fichier processors.aadl dans votre projet afin d'y spécifier 2 composants processeur : chaque composant processeur héberge respectivement un ordonnanceur POSIX_1003_HIGHEST_PRIORITY_FIRST_PROTOCOL et RM.
  2. Dans le fichier où vous avez défini l'ensemble de vos composants, modifier votre processeur afin qu'il étende l'un des processeurs déclarés dans processors.aadl.
  3. Vérifier la correction de cette nouvelle version du modèle par des simulations.




Exercice 3, inversion de priorité



Cet exercice est extrait de [COT 00] et consiste à diagnostiquer et corriger une version simplifiée du système d'exploration de la mission Mars Pathfinder. En 1997, la mission Mars PathFinder a déployé le robot mobile Sojourner sur Mars. La mission de ce robot et de sa sonde était contrôlée par un logiciel multitâches s'exécutant sur un système VxWorks. Ce logiciel est constitué des tâches suivantes :



Nom des tâches Priorités Périodes/Echéances Temps d'exécution
ORDO_BUS 1 125 ms 25 ms
DONNEES 2 125 ms 25 ms
PILOTAGE 3 250 ms 25 ms
RADIO 4 250 ms 25 ms
CAMERA 5 250 ms 25 ms
MESURE 6 5000 ms 50 ms
METEO 7 5000 ms 50 ms ou 75 ms





  1. Pendant le déroulement de la mission Mars PathFinder, les opérateurs de la NASA ont constaté que certaines échéances de ce logiciel ont été manquées, ce qui a provoqué plusieurs redémarrages du robot ainsi que la perte de données scientifiques.
  2. Proposez un modèle AADL pour cette architecture logicielle composée de threads périodiques et d'un composant data sans propriété Concurrency_Control_Protocol. Quelles sont les échéances qui ne sont pas respectées et pourquoi ?
  3. Modifier ce modèle afin de corriger ce problème.




Exercice 4, calcul holistique

Dans cet exercice, on montre comment utiliser un outil comme AADLInspector pour calculer un pire temps de réponse de bout en bout avec la méthode holistique. On étudie un système constitué de deux processeurs. Le processeur a héberge les tâches T1 et T2. Le processeur b héberge les tâches T3, T4 et T5. Certaines tâches communiquement par échange de messages périodiques :

Les tâches et messages sont définis par les paramètres suivants :

Messages Périodes Temps de communication
M1 120 ms 3 ms
M2 50 ms 1 ms



Tâche Période Capacité Priorité Processeur
T1 120 ms 3 ms 1 a
T2 50 ms 2 ms 2 a
T3 120 ms 7 ms 2 b
T4 70 ms 1 ms 1 b
T5 50 ms 3 ms 3 b



Notez que la priorité 3 est le niveau de priorité le plus fort et 1 le niveau de priorité le plus faible. Le temps de communication inclut les temps de propagation, d'accès, de transmission et de traversée des couches. Le temps de réponse final d'un message i est obtenu par la somme de son Jitter et de son temps de communication.

Le temps de réponse des tâches est calculé avec la méthode de Joseph et Pandia étendue avec les Jitters.


On souhaite calculer les délais de bout en bout de chaque tâche du système. Pour ce faire, nous allons appliquer la méthode Holistique :
  1. Récupérer le modèle AADL suivant. Ce modèle vous montre comment calculer le pire temps de réponse d'un thread en spécifiant un Jitter sur son activation périodique. Avec AADLInspector, pour calculer ce pire temps de réponse, il vous faut appuyer sur le bouton Theoritical schedulability tests.
  2. Modifier ce modèle en ajoutant un thread AADL pour chacune des tâches T1 à T5 décrites ci-dessus.
  3. On affecte dans un premier temps les Jitters à zéro. Avec AADLInspector, quels sont les temps de réponse des tâches/threads ? Les temps de réponse des messages peuvent être calculés manuellement.
  4. Pour quels tâches/messages doit on modifier le paramètre Jitter. Donner les valeurs du Jitter pour les tâches/messages concernés.
  5. Recalculer avec AADLInspector les pire temps de réponse après avoir modifié les Jitters dans votre modèle AADL. Quels sont les nouveaux temps de réponse ?
  6. Refaire les opérations 4 et 5 jusqu'à convergence des temps de réponse. Quels sont les délais de bout en bout des chaines de traitement T1/T3 et T5/T2 ?




Exercice 5, modèle de calcul basé sur les data ports



L'objectif de ce nouvel exercice est de découvrir l'utilisation des data ports.

Question 1 :


Un des moyens classiques de communications d'une information entre deux threads consiste à utiliser les data ports. L'utilisation de data ports permet à un ensemble de threads d'échanger des messages périodiquement tout en respectant diverses contraintes de cohérence sur les données.

Question 2 :


Nous regardons maintenant un modèle AADL qui exploite le concept de data port.





La figure ci-dessus présente l'architecture d'un logiciel embarqué dans un avion. Ce logiciel permet d'afficher l'altitude de son appareil sur une console. Ce logiciel est constitué des traitements suivants, chacun de ces traitements étant implanté par un thread périodique :

Vous avez ci-dessous les paramètres de ces threads :


Threads Périodes Capacités Priorité
ALTIMETRE1 1000 ms 200 ms 10
ALTIMETRE2 1000 ms 200 ms 20
ALTIMETRE3 1000 ms 200 ms 30
VOTEUR 1000 ms 100 ms 40
COMMANDE 1000 ms 100 ms 10
ANALYSE 1000 ms 50 ms 20
AFFICHAGE 1000 ms 40 ms 30



  1. Proposer un modèle AADL décrivent le processus AADL de la figure ci-dessus, puis, simuler son ordonnancement. Que constatez vous ?
  2. On souhaite répartir cette application sur deux processeurs. Découper le processus en deux processus, chacun s'executant sur un processeur dédié. Sur le premier processeur, vous placerez les altimètres ainsi que le voteur, sur le second processeur, toutes les autres tâches. Simuler l'ordonnancement de ce nouveau modèle. Que constatez-vous ?


Projet CC UE VFS partie "ordonnancement" 2017/2018

Vous trouverez ci-dessous différentes approches pour la conception et la vérification (généralement de l'ordonnancement) d'une architecture temps réel critique :
  1. Autosar/EAST-ADL.
  2. MARTE/UML et Mast.
  3. TASTE.
  4. Symta/S.
  5. Times.
  6. Polychrony.
  7. SCADE.
  8. UPPAAL.
  9. HRT HOOD.
  10. Giotto.


Il vous est demandé :

Exercice 6, modélisation et analyse d'un switch

On souhaite modéliser et vérifier l'ordonnancement d'un logiciel embarqué dans un commutateur réseau. Le commutateur est constitué:

Les paramètres des tâches sont donnés ci-dessous:



Threads Priorités Temps d'exécution Périodes/Echéances
SUPER 1 Entre 2 et 3 ms 7 ms
STAT 2 7 ms dans certains cas, 6 ms sinon 21 ms
PORT_1 3 Jamais plus de 4 ms 50 ms
PORT_2 4 Jamais plus de 4 ms 50 ms
PORT_3 5 Jamais plus de 4 ms 50 ms
PORT_4 6 Jamais plus de 4 ms 50 ms



Les tâches sont périodiques et indépendantes. Elles démarrent toutes à l'instant zéro. Pour toutes les tâches, les échéances sont égales aux périodes. Enfin, chaque tâche a une priorité fixe. Nous appliquons un ordonnancement préemptif à priorité fixe. Les niveaux de priorités vont de 0 à 255 sachant que le niveau de priorité le plus fort est 0. On applique ici Rate Monotonic.

Question 1 :

Votre responsable vous propose dans un premier temps de déployer cet ensemble de tâches sur une machine disposant d'un processeur. Compléter le modèle AADL ci-dessous afin de pouvoir simuler l'ordonnancement de ce système avec un logiciel comme AADLInspector.

package commutateurs
public 

  thread tache_periodique
    properties
         Dispatch_Protocol => Periodic;
  end tache_periodique;

  thread implementation tache_periodique.Impl
  end tache_periodique.Impl;

  process implementation Application.Impl
  subcomponents
    SUPER : thread tache_periodique.Impl;
    STAT  : thread tache_periodique.Impl;
  end Application.Impl;

  processor cpu
  end cpu;

  system commutateur
  end commutateur;

  system implementation commutateur.Impl
  subcomponents
    process1 : process application.Impl;
    cpu1 : processor cpu;
  end commutateur.Impl;

end commutateurs;


Question 2 :

En fait, ce système n'est pas ordonnançable sur un processeur seulement. On cherche donc à ordonnancer ce jeu de tâches sur une architecture comportant deux processeurs identiques. On applique une approche par partitionnement. Proposer une affectation des tâches sur les deux processeurs qui garantisse le respect des échéances. Montrer, sans calculer l'ordonnancement des tâches, que les tâches respectent effectivement leur échéance.

Question 3 :

Calculer l'ordonnancement sur les 50 premières unités de temps.

Question 4 :

Comment doit-on modifier le modèle AADL proposé dans la question 1 afin de représenter le logiciel déployé sur deux processeurs ? Donner la nouvelle version de ce modèle.

Exercice 7, modélisation et analyse d'un réfrigérateur



On souhaite modéliser et vérifier l'ordonnancement d'un logiciel embarqué dans un réfrigérateur. Ce logiciel contrôle la production de froid, une alarme associée à la porte et à la température ainsi que l'éclairage de l'équipement.

Votre responsable vous demande de vérifier le respect des contraintes temporelles de ce logiciel. On suppose que ce dernier est composé des tâches périodiques suivantes :


Threads Temps d'exécution Périodes/Echéances
Thermostat Jamais plus de 6 ms 15 ms
Porte 4 ms dans certains cas, 2 ms sinon 30 ms
Lampe Jamais plus de 1 ms 7 ms
Alarme Souvent 2 ms, mais parfois jusqu'à 3 ms 10 ms
Sonde Jamais plus de 2 ms 14 ms





Les échéances sont égales aux périodes. La date de première activation de toutes les tâches est identique et est égale à zéro.

Question 1 :

Votre responsable vous propose dans un premier temps d'utiliser un OS disposant d'un seul processeur avec un ordonnanceur Rate Monotonic préemptif. Compléter le modèle AADL ci-dessous afin de pouvoir simuler l'ordonnancement de ce système avec un logiciel comme AADLInspector.
package refrigerateur
public 

  thread tache_periodique
    properties
         Dispatch_Protocol => Periodic;
  end tache_periodique;

  thread implementation tache_periodique.Impl
  end tache_periodique.Impl;
 


  process implementation Application.Impl
  subcomponents
    thermostat : thread tache_periodique.Impl;
    porte : thread tache_periodique.Impl;
    lampe : thread tache_periodique.Impl;
    alarme : thread tache_periodique.Impl;
    sonde : thread tache_periodique.Impl;
  end Application.Impl;

  processor cpu
  end cpu;

  system froid
  end froid;

  system implementation froid.Impl
  subcomponents
    process1 : process application.Impl;
    cpu1 : processor cpu;
  end froid.Impl;

end refrigerateur;


Question 2 :

En fait, ce système n'est pas ordonnançable sur un processeur seulement. On cherche donc à ordonnancer ce jeu de tâches sur une architecture comportant deux processeurs identiques. On hésite à utiliser soit une approche par partitionnement, soit une approche d'ordonnancement global. On applique d'abord la méthode par partitionnement. On suppose que les tâches Lampe et Sonde sont placées sur un processeur et que les autres tâches sont placées sur le second. Donner le chronogramme d'ordonnancement de ce jeu de tâches sur l'hyper-période (ou encore nommée la période d'étude).

Question 3 :

On applique maintenant une approche par ordonnancement global. Les migrations de tâches sont autorisées à tout instant. Donner le chronogramme d'ordonnancement sur les 20 premières unités de temps.