Concepts de Base des Systèmes Temps Réel (STR)

Cette conférence présente les concepts fondamentaux des systèmes temps réel (STR), essentiels dans la conception et la gestion de systèmes embarqués et critiques. Elle s'inscrit dans un cours sur les systèmes informatiques ou l'ingénierie des systèmes, en introduisant les notions clés telles que les tâches, la gestion des priorités, les contraintes temporelles, ainsi que les notions de fiabilité et de criticité.

Définition d’un système et d’une tâche dans un STR

Un système est un ensemble organisé destiné à résoudre un problème spécifique. Par exemple, un lave-vaisselle est un système composé de plusieurs sous-systèmes : arrivée et évacuation d’eau, fonctionnement du moteur, ouverture et fermeture de la porte, et état de l’affichage. Ces opérations sont gérées par un microcontrôleur qui coordonne les différentes fonctions.

Une tâche (ou job) est un groupe d’instructions qui exécutent une fonction spécifique au sein du système. Dans le cas du lave-vaisselle, les tâches peuvent être le gestionnaire de l’eau, le gestionnaire du moteur, le gestionnaire de la porte, ou encore le gestionnaire de l’affichage. Chaque tâche réalise une fonction précise et contribue au fonctionnement global du système.

Le multitâche et la gestion des priorités

Le multitâche consiste à exécuter plusieurs tâches simultanément. Dans un système temps réel, le microcontrôleur embarqué peut gérer plusieurs tâches en parallèle, telles que la gestion de l’eau, du moteur, de la porte, et de l’affichage. Pour organiser cette exécution simultanée, chaque tâche se voit attribuer une priorité qui détermine son ordre d’exécution.

Les tâches importantes ont une priorité plus élevée, tandis que les tâches moins critiques ont une priorité inférieure. Cette hiérarchie permet au système de répondre efficacement aux événements les plus urgents.

La préemption est un mécanisme clé dans les STR : elle permet à une tâche de priorité élevée d’interrompre temporairement une tâche de priorité inférieure. Cela garantit que les tâches critiques sont traitées en temps voulu, ce qui est indispensable pour maintenir l’intégrité du système.

Par exemple, dans le système du lave-vaisselle, le planificateur (ou ordonnanceur) décide quelle tâche doit s’exécuter en fonction des priorités. Si le gestionnaire de l’eau a une priorité plus élevée que le gestionnaire de l’affichage, le scheduler suspendra temporairement ce dernier pour exécuter la gestion de l’eau. Une fois cette tâche terminée, le gestionnaire de l’affichage reprend son exécution.

Contraintes temporelles et types de systèmes temps réel

La caractéristique la plus importante d’un système temps réel est la contrainte temporelle, souvent appelée deadline (date limite). Chaque tâche doit terminer son exécution avant cette date limite pour que le système fonctionne correctement. Le non-respect de ces contraintes peut entraîner des conséquences graves.

On distingue deux types principaux de systèmes temps réel :

• STR rigide (hard real-time) : les contraintes temporelles doivent être respectées sans exception. Toute violation entraîne une défaillance du système. Par exemple, le contrôleur de mouvement vertical d’un ascenseur doit impérativement respecter ses deadlines, faute de quoi l’ascenseur pourrait s’arrêter entre deux étages.
• STR souple (soft real-time) : les contraintes peuvent être parfois violées sans entraîner la panne du système. Par exemple, un système téléphonique peut échouer à établir une connexion, mais l’utilisateur peut simplement réessayer.

Entre ces deux extrêmes, la plupart des systèmes temps réel se situent sur un continuum entre rigide et souple.

Les contraintes temporelles sont souvent déterministes, c’est-à-dire exprimées en valeurs fixes et exactes. Par exemple, la porte d’un passage à niveau doit toujours être fermée lorsqu’un train arrive, et non seulement la plupart du temps.

Concurrence, synchronisation et gestion des ressources

Dans un STR, plusieurs tâches peuvent être en concurrence pour accéder à des ressources limitées telles que le processeur, la mémoire ou des périphériques. Cette concurrence nécessite des mécanismes pour éviter les conflits et garantir la cohérence des accès.

Les solutions incluent :

• Des politiques d’ordonnancement des tâches pour gérer l’accès au processeur.
• La communication inter-tâches via des synchronisations ou des messages.
• La modélisation de l’accès cohérent aux ressources partagées, notamment par l’utilisation de mutex (verrous mutuellement exclusifs).

On distingue également l’asynchronisme, où les événements se produisent indépendamment, et la synchronisation, qui intervient lorsque des dépendances existent entre les activités.

Correction, robustesse et fiabilité

Un système est dit correct lorsqu’il réalise toujours la fonction souhaitée. Il est robuste s’il continue à fonctionner correctement même en présence de circonstances imprévues ou de pannes partielles.

Les concepteurs doivent gérer plusieurs problèmes critiques :

• Deadlock : situation où une tâche attend indéfiniment une condition qui ne se produit jamais.
• Conditions exceptionnelles : identification des pannes et mise en œuvre de mesures correctives, comme la répétition d’un traitement pour restaurer un état correct.
• Conditions de course (race conditions) : conflits d’accès aux ressources partagées pouvant entraîner des comportements imprévus.

La fiabilité mesure la probabilité qu’un système fonctionne correctement sur une période donnée, tandis que la tolérance aux fautes concerne la détection et la gestion des échecs pour éviter les pannes.

La criticité évalue le coût d’une défaillance : plus ce coût est élevé, plus le système est critique. Par exemple, un contrôleur d’avion ou de centrale nucléaire est très critique, alors qu’un jeu vidéo, bien que dur (rigide), n’est pas critique.

Tâches, processus et ressources

Une tâche (job) est une unité de travail planifiable par le système d’exploitation, telle que le calcul d’un contrôle, la transmission d’un paquet de données ou la récupération d’un fichier.

Un processus (task) est un ensemble de tâches ayant un objectif commun, par exemple, un ensemble de tâches assurant la « constante de maintien de l’altitude » d’un avion.

Chaque tâche possède une deadline, c’est-à-dire le dernier instant pour son achèvement.

Les tâches s’exécutent sur un ou plusieurs processeurs, qui sont des composants actifs planifiant les tâches. Chaque processeur possède un attribut de vitesse, comme le nombre d’instructions par seconde pour un CPU ou la bande passante d’un réseau. Deux processeurs sont du même type s’ils sont fonctionnellement identiques et interchangeables.

Les ressources, quant à elles, sont des entités passives nécessaires à l’exécution des tâches, telles que la mémoire, les séquences de nombres, les mutex ou les verrous de base de données. Une ressource ne peut être utilisée que par une seule tâche à la fois (accès mutuellement exclusif). Une tâche accède à la ressource, l’utilise, puis la libère.

Modèles d’exécution des tâches

Les tâches peuvent être classées selon leur mode de déclenchement :

• Tâches event-driven (réactives) : elles réagissent à des événements externes. Elles peuvent être :
• Sporadiques : avec des délais rigides.
• Apériodiques : avec des délais souples ou sans délai.
• Tâches time-driven : elles sont déclenchées par le passage du temps, généralement par des horloges. Elles sont souvent périodiques avec des délais rigides.

Points clés

• Un système temps réel est composé de tâches qui doivent respecter des contraintes temporelles strictes (deadlines).
• Les tâches ont des priorités qui déterminent leur ordre d’exécution, avec possibilité de préemption pour garantir la réactivité.
• Les systèmes temps réel peuvent être rigides (hard) ou souples (soft) selon la sévérité des contraintes temporelles.
• La gestion de la concurrence et de l’accès aux ressources partagées est essentielle pour éviter les conflits et garantir la cohérence.
• La correction, la robustesse, la fiabilité et la tolérance aux fautes sont des critères fondamentaux pour la conception des STR.
• La criticité mesure l’importance du coût d’une défaillance, distincte de la rigidité temporelle.
• Les tâches peuvent être déclenchées par des événements externes ou par le temps, avec des modèles d’exécution adaptés.