Evaluation du coût des threads dans un système temps réel
Sommaire
Cahier des charges
Objectif
L'objectif du projet est mesurer les coûts d'utilisation (mémoire, changement de contexte, ...) d'un grand nombre de threads dans un système temps.
Description
Dans le cadre de travaux de recherche sur le regroupement des tâches pour limiter le nombre de threads, l'idée est de mesurer l'impact de ces nombreux threads sur un système temps réel. Pour cela, deux programmes fesant les mêmes tâches mais avec un nombre de threads différents seront tester sur un microcontrôleur (Hercules TMS570) avec un OS Temps Réel.
Gestion de projet
Date clées
- Début du projet: lundi 27/01
- Rendu du dossier: mardi 25/02 à 13h
- Soutenance: jeudi 27/02
Planning
L'avancement du projet peut être divisé en trois quatre grande phase:
- Prise en main
- Mesure des coûts mémoire
- Recherche concernant les mesures de temps d'exécution
- Rédaction des livrables
Le diagramme de Gantt suivant montre l'organisation de ces phases.
Matériel et logiciels utilisé
Pour ce projet le matériel utilisé est:
- un kit de dévellopement Hercules TMS570LS31x fabriqué par Texas Instruments
- l'IDE Code Composer Studio (CCS) de Texas Instruments
CCS peut être téléchargé ici et les instructions pour l'installer sous Linux sont disponibles là.
- le logiciel HalCoGen de Texas Instruments
- le système d'exploitation temps réel FreeRTOS
Avancement du projet
Semaine 5
Lundi 27/01 au Dimanche 02/02
Objectifs de la semaine
- Réussir à exécuter un programme quelconque sur la carte.
- Réussir à exécuter un programme Temps réel sur la carte.
Réalisation
- Prise en main du sujet et du matériel.
- Lecture d'un article et de documentations.
- Installation des logiciels nécessaire à la programmation du microcontrolleur sur une plateforme Windows (l'IDE Code Composer Studio et HalCoGen).
- Essais pour lancer un programme d'exemple sur le microcontrôlleur.
Les programmes d'exemples fournient par Texas Instruments (avec ou sans OS Temps Réel) ont des erreurs difficiles à réparer étant donné les messages d'erreurs du compilateur ("unresolved symbol remain", rien de plus). Il a donc été décidé de passer sous une platforme Linux (Ubuntu 10.04 ici) afin de pouvoir compiler le projet avec GCC au lieu du compilateur de TI en espérant que les messages d'erreur soit plus clair.
- Installation des bibliothèques nécessaires et de l'IDE Code Composer Studio (basé sur Eclipse) fournit par Texas Instruments.
- Essais pour lancer un programme d'exemple sur le microcontrôlleur avec Linux.
Il s'avère qu'une erreur plus précise à permis de se rendre compte qu'un paramètre du compilateur n'était pas bon et donc de finalement compiler un des programmes d'exemple, celui avec un OS Temps Réels appelée FreeRTOS.
Cependant, avec cet exemple les tâches temps réels ne se lance pas. Il est seulement possible d'allumer une LED dans la fonction principale.
Reste à faire
- Réussir à éxecuter des tâches temps réel sur le microcontrolleur.
Semaine 6
Lundi 03/02 au Dimanche 09/02
Objectifs de la semaine
- Réussir à éxecuter des tâches temps réels sur le microcontrolleur.
- Commencer les mesures de mémoires utiliser par les tâches et les temps d'éxecution.
Realisation
- Essais de lancement de tâches temps réels sur le microcontrolleur.
Il s'avère que dans le programme d'exemple avec FreeRTOS utilisé jusqu'à présent le timer n'est pas bien régler et aucun tick n'est généré. Les tâches ne se lancent donc jamais.
Cependant, le logiciel HalCoGen permet de généré le code C nécessaire au bon fonctionnement du microcontrolleur. Il est également possible de généré le code en intégrant FreeRTOS. Ce code généré est correct, compile et fonctionne en utilisant Windows comme Linux.
- Mesures de la mémoire utiliser par les tâches.
FreeRTOS permet de choisir lors de la création d'une tâche la quantité de mémoire alloué à celle-ci. On veut donc vérifier si ce qu'on mesures correspond à ce qui est annoncé par FreeRTOS.
D'après les mesures effectuer le quantité de mémoire alloué pour chaque tâches varie selon quelques paramètres et calculable facilement.
Reste à faire
- Mesurer les temps d'execution des tâches.
Semaine 7
Lundi 10/02 au Dimanche 16/02
Prévisions
- Finir les mesures sur les coûts mémoires et de temps d'éxecution.
Objectifs de la semaine
- Mesurer les temps d'execution d'un grand nombre de tâches.
- Créer une tâche qui prend du temps à s'executer (mesurable).
- Déterminer le nombre de tâches maximum qui peuvent être créer sur le microcontrolleur (limite de mémoire)
- Générer un jeux de test: créer un grand nombre de tâches identiques
Réalisation
- Création d'une tâche qui prend du temps à s'éxecuter.
Ajout d'une boucle for dans certaines tâches afin d'obtenir des temps d'exécution mesurable. La désynchronisation des LEDs nous indique que certaines tâches ont un temps d'exécution plus long que d'autre. Cela est du a une mauvaise initialisation du timer permettant les mesures.
- Utilisation possible de FreeRTOS+Trace un logiciel distribué par Percepio. Il permet de visualiser la trace du programme et notamment de mesurer les temps d'exécution.
Reste à faire
- Mesure de temps d'exécution
Semaine 8
Lundi 17/02 au Dimanche 23/02
Prévisions
- Écriture du rapport
Réalisation
- Écriture du rapport
Reste à faire
- Finalisation du rapport
Semaine 9
Lundi 24/02 au Dimanche 02/03
Prévisions
- Finalisation du rapport.
- Préparation de la soutenance.
Réalisation
- Finalisation du rapport et rendu du rapport le Mardi 25 Février.
- Finalisation de la page wiki.
- Préparation de la soutenance.
Résultats
Coûts mémoire
Le tableau suivant illustre les différentes mesures réalisé:
FreeRTOS annonce un coût de 64 octets par tâche en plus de la mémoire alloué par l'utilisateur.
| Mémoire Allouée (en octet) | Valeur théorique (en octet) | Valeur mesurée (en octet) | Écart (en octet) | |
|---|---|---|---|---|
| 64 | 320 | 408 | 88 | |
| 128 | 576 | 664 | 88 | |
| 199 | 860 | 952 | 92 | |
| 200 | 864 | 952 | 88 | |
| 201 | 868 | 960 | 92 | |
| 202 | 872 | 960 | 88 | |
| 203 | 876 | 968 | 92 | |
| 204 | 880 | 968 | 88 | |
| 255 | 1084 | 1176 | 92 |
On observe un coût mémoire de 88 ou 92 octets en plus de ce qu'annonce FreeRTOS. Cependant le coût reste constant par tâche, quelque soit la tâche.
Le coût mémoire total lié à l'OS est donc linéaire au nombre de tâches.
Temps d'éxecution
Pas de résultats obtenus en raison de la courte durée du projet.
Bilan
Rapport
Média:Rapport_Evaluation_du_couts_des_threads.pdf
Sources
- article "A heuristic to minimize the cardinality of a real-time taskset by automated task clustering" écrit par Antoine Bertout, Julien Forget et Richard Olejnik
- master thesis de l'université de Chalmers, Göteborg, Suède "Design and Implementation of a central control unit in an automotive drive-by-wire system" écrit par Alexandra Angerd et Andreas Johansson [1]
- site de Texas Instruments [2]
- site de FreeRTOS [3]
- site de Percepio pour FreeRTOS+trace [4]
