Les Systèmes d'exploitation temps réels

A-  Introduction

Une application est dite temps réelle si elle a la capacité de traiter en un temps déterminé un flux d'évènements issus d'un processus, sans perdre un seul de ces évènements. Une application est dite temps réelle lorsque son temps de réponse est négligeable par rapport aux phénomènes physiques observés.

Pour qu'une application traitant un phénomène soit temps-réel il faut que le temps de traitement du phénomène soit inférieur à sa variation.

Si un afficheur de température dans un bureau met 1 seconde à afficher une nouvelle température, personne ne le remarquera car les variations se font très lentement.

Le concept du temps-réel est relatif à l'application concernée : selon le traitement demandé, une application sera considérée comme temps-réelle ou non.

Un logiciel capable d'effectuer des traitements en une demi-seconde serait apte à gérer en temps réel l'affichage sur le tableau de bord d'un véhicule mais serait inapte à gérer en temps réel le guidage d'un missile.

B-    Système d'exploitation : définition

Un système d'exploitation ou Operating System (OS) est un programme qui agit comme un intermédiaire entre l'utilisateur et la machine.

Son but est de fournir un environnement dans lequel un utilisateur peut exécuter des programmes et son rôle est de coordonner l'exécution simultanée de plusieurs taches utilisateurs.

Il doit répartir les ressources du système telles que le CPU, la mémoire, les périphériques. Il a aussi pour rôle de fournir des services tels que la communication entre processus, la synchronisation, l'affichage, …

C-   Pourquoi un système d'exploitation temps réel ?

Un Système d'Exploitation Temps Réel ou Real Time Operating System (RTOS) est utilisé quand il y a des exigences temporelles fixe sur les opérations d'un processeur ou sur le flux de données.

Il possède des contraintes de temps fixes et bien définies : le traitement doit être effectué dans la contrainte de temps sinon le système échoue.

La gestion d'un airbag est temps réelle : quand un capteur détecte une déformation de la carrosserie suffisamment importante, il envoie un signal au contrôleur qui doit avoir gonflé les airbags dans les 10 ms sous peine d'arriver trop tard ce qui aurait des conséquences désastreuses pour les occupants de la voiture.

Un RTOS permet de réaliser un système complexe à l'aide de petites taches simples. Ces petites taches permettent de répondre rapidement à des évènements importants tout en définissant une priorité des taches à effectuer.

D-   Zone critique et exclusion mutuelle

Zone critique

Une zone critique peut être une structure de données, une ressource partagée, une section de code au timing délicat, une zone de mémoire.

Une zone critique ne peut être interrompue une fois commencée. Il faut donc désactiver les interruptions à l'entrée de la section critique et les réactiver à la sortie.

Une seule tache a le droit d'accéder à une zone critique. Elle doit être protégée pour que les autres taches ne puissent modifier les données ou l'état du matériel. La technique des sémaphores que nous verrons plus loin doit donc être utilisée.

Exclusion mutuelle

Lorsqu'une ressource n'est pas partageable entre plusieurs taches, un mécanisme doit en assurer l'accès exclusif. Un tel mécanisme est appelé exclusion mutuelle : lorsqu'une tache utilise la ressource, aucune autre tâche ne peut l'utiliser.

Une imprimante peut être utilisée par plusieurs processus (par exemple, par Word, par Excel, et d'autres logiciels) mais son accès est exclusif. Sinon, on pourrait avoir un mélange de fichiers si plusieurs processus se mettent à imprimer en même temps.

L'exclusion mutuelle peut être réalisée de différentes façons :

le verrouillage matériel est réalisé à l'aide d'un drapeau binaire qui indique si la ressource est libre ou utilisée. Chaque tache va tester le drapeau avant d'utiliser la ressource, si elle est déjà utilisée par une autre tâche, elle va se mettre en attente,

le verrouillage du CPU permet d'éviter l'accès concurrent à une ressource non partageable. La distribution du CPU d'une tache à l'autre est interdite pendant cet accès.

C-  Tache

Une tache est un programme qui s'exécute comme s'il était le seul à utiliser le CPU. Il possède une priorité, du code à effectuer, une partie de la mémoire et une zone de pile.

Une tache peut être dans différents états comme le montre le schéma suivant :

• dormante : La tâche est en mémoire mais n'est pas considéré par l'Ordonnanceur,
• exécutable : La tâche est prête à être exécutée mais n'a pas le CPU,
• active : La tâche est exécutée par le CPU,
• bloquée : La tâche est en attente d'un signal ou d'une ressource pour poursuivre,
• interrompue : La tâche est Suspendue par une interruption.

Le tableau suivant montre dans quel cas une tache peut passer d'un état à un autre :

Etat d'origine	Nouvel Etat	Evènement provoquant la transition
Dormante	Exécutable	La tâche est activée
Exécutable	Active	L'Ordonnanceur donne le CPU à la tache
Active	Bloquée	La tâche est en attente d'une ressource (bloquée par un sémaphore).
Bloquée	Exécutable	La ressource dont la tâche était en attente est libérée
Active	Exécutable	L'Ordonnanceur donne le CPU à une autre tâche (préemption)
Active	Interrompue	Une interruption stoppe la tache
Interrompue	Active	Le traitement de l'interruption est terminé

 Multitâches

Un OS multitâches permet l'exécution simultanée de plusieurs taches. Pour un système monoprocesseur (CPU unique avec exécution séquentielle des instructions), l'exécution simultanée est simulée : chaque tache a l'impression de posséder le CPU mais c'est l'ordonnateur qui répartit le CPU.

Le processus de conception pour les applications temps-réelles implique de diviser le travail à effectuer entre différentes taches chacune responsables d'une partie du problème.

Ordonnanceur

L'Ordonnanceur est le composant du noyau responsable de la distribution du temps CPU entre les différentes taches. Il est basé sur le principe de la priorité : chaque tache possède une priorité dépendant de son importance (plus une tache est importante, plus sa priorité est élevée). Il attribue le processeur à la tache exécutable (non dormante et non bloquée) de plus haute priorité.

Lorsque qu'une tache T2 plus prioritaire que la tache active T1 passe de l'état bloqué à l'état exécutable, T1 est suspendue et l'Ordonnanceur attribue le processeur à T2. C'est le principe de la préemption. La préemption permet un temps de réponse des taches optimum.

Changement de contexte

Quand l'ordonnanceur doit transférer l'usage du processeur d'une tache à l'autre, il opère un changement de contexte. Le contexte représente l'état du processeur à un moment donné.

La tache suspendue doit pouvoir continuer son exécution sans être affectée, la première opération à effectuer est donc la sauvegarde de l'état du processeur au moment de la suspension. Le noyau possède pour chaque tache non dormante un espace mémoire réservé à cet effet.

Les données temporaires utilisées par la tache suspendue doivent être préservées lors des opérations de la nouvelle tâche active. Ces données sont organisées sous forme de pile contenant le contexte des appels de sous routines en cours (adresse de retour, valeur des registres) ainsi que les paramètres et les variables temporaires de ses sous-routines.

Une tache peut être suspendue à tout moment et l'usage du processeur transféré vers une autre tâche susceptible d'appeler des sous-routines et d'allouer des variables temporaires. Chaque tache possède sa propre pile.

Le temps requis pour un changement de contexte est déterminé par le nombre de registres à sauvegarder et à restaurer par le CPU.

Niveau de contrainte temporelle

Un système temps réel se compose de plusieurs taches. Pourtant, toutes ces taches ne relèvent pas du temps réel. On peut distinguer trois niveaux de contraintes temporelles :

• Sévère : les taches temps réelle critiques doivent absolument respecter les échéances prévues,
• Ferme : les taches temps réelle non critique peuvent répondre avec un certain retard sachant que la cohérence du système en sera dégradée,
• Souple : les autres taches, qui n'ont pas de contrainte de temps, n'auront qu'à répondre au mieux.

Dans un avion, l'altimètre sera une tache très critique, tandis que la jauge sera seulement critique et que la gestion du bar sera une tache sans contrainte de temps réel. 

Priorité des taches

Ainsi, chaque tache se voit attribuer une priorité qui est fonction de son caractère critique. Plus une tache est importante, plus sa priorité est élevée. Il existe deux types de priorité de taches :

• Priorité statique : la priorité de chaque tâche n'évolue pas durant l'exécution. Chaque tache reçoit une priorité fixe lors de sa création. Toutes les taches et leurs contraintes temporelles sont connues à la compilation.
• Priorité dynamique : La priorité de chaque tache peut évoluer durant l'exécution. Cette caractéristique des RTOS permet d'éviter l'inversion de priorité.

L'inversion de priorité est un problème qui survient lorsqu'une tache est suspendue dans l'attente d'une ressource contrôlée par une tache moins prioritaire. Par exemple, s'il existe deux taches T1 et T2 avec T1 plus prioritaire que T2. T1 attend qu'un événement se produise dans T2 (par exemple la libération d'un sémaphore). Dans ce cas, la priorité effective de T1 est réduite à celle de T2 car elle est en attente d'une ressource détenue par T2.

Pour résoudre ce problème, il suffit d'élever temporairement le priorité de T2 en la rendant égale à celle de T1 pendant le laps de temps qu'elle utilise la ressource en ensuite de restaurer sa priorité normale.

E-   Communication entre taches

Problématique

Le transfert correct de données entre taches dans un programme temps-réel soulève des problèmes plus importants que dans le cas d'un programme unique communiquant avec des routines d'interruption car :

• chacune des taches peut voir son exécution suspendue après chaque instruction afin de transférer l'usage du processeur à l'autre tâche,
• les changements de contexte ne peuvent être évités qu'en interagissant avec l'ordonnateur.

Pour communiquer entre différentes taches, le noyau fourni des services destinés à :

• assurer la synchronisation des taches communicantes,
• organiser le transfert de données d'une tache à l'autre.

Sémaphore

Le concept de sémaphore est utilisé pour contrôler l'accès à une ressource. Lorsqu'une tache accède à une ressource non partageable, le sémaphore à l'entrée de celle-ci devient bloqué et le reste tant que la tache a relâché la ressource. Il empêche ainsi tout autre tâche à accéder à cette ressource.

Dans la signalisation ferroviaire, il ne doit y avoir qu'un train au maximum par tronçon de voie ferrée. Lorsqu'un train entre dans ce tronçon, aucun autre train de peut y entrer tant que le premier train ne l'a pas quitté.

Un sémaphore peut être généralisé au cas où une ressource est accessible par n taches simultanément. Dans ce cas, le sémaphore peut prendre n + 1 états qui seront représentés par un compteur.

Un sémaphore possède une valeur entière s qui représente le nombre de taches qui accèdent à la ressource qu'il surveille. Sa valeur est positive ou nulle et est uniquement manipulable à l'aide de deux opérations : wait(s) et sinal(s) :

• wait(s) est l'action d'attente. Si le sémaphore est libre (s supérieur à 0), la tache continue son exécution et la valeur de s est décrémentée. Si le sémaphore est bloqué (s = 0), la tâche est placée à la fin de la file d'attente du sémaphore.
• sinal(s) est l'action de signalisation. Si le sémaphore est libre, il reste libre et sa valeur est incrémentée. Si le sémaphore est bloqué et qu'aucune tâche n'est en attente, il devient libre. Si le sémaphore est bloqué et qu'au moins une tache est en attente, alors la première tâche de la file d'attente du sémaphore est débloquée. 

Mutex

Un sémaphore qui ne peut prendre que deux états (libre et bloqué) est appelé sémaphore binaire ou mutex. Dans ce cas, une seule tache peut avoir accès à la ressource.
Les files de communication

Une file d'attente est un objet permettant la communication synchrone ou asynchrone de valeurs entre des taches. Les caractéristiques d'une file de communication sont les suivantes :

• la capacité maximum de la file (représentant le nombre maximum de valeurs écrites et non encore lues) et la taille de chaque valeur sont fixées.
• Une tache en attente de données depuis la file est suspendue par l'Ordonnanceur (état bloqué).

Les performances temporelles d'un RTOS dépendent évidemment des performances du RTOS lui-même mais aussi de la plate-forme matérielle sur lequel il fonctionne et des procédures de tests et de mesures (très difficiles à réaliser ce qui implique qu'il est toujours très difficile de comparer deux RTOS).