Des systèmes classiques aux systèmes temps réels Objectif : Nous revenons sur les principaux mécanismes mis en œuvre dans un système classique. Certains sont utilisés par les systèmes temps réels ; d'autres doivent être abandonnés car ils ne permettent pas la prise en compte de contraintes temporelles.

Plan Services d'un système élémentaire Services multitâches Gestion du processeur Gestion des interruptions et multitâches Partage des ressources et exclusion mutuelle

Vue d'un ordinateur classique Mémoire principale Stockage Secondaire Périphérique E/S CPU Bus Registres Unité de contrôle Unité Arithmétique et Logique

Les services de base qu'un OS offre : Exécution d'un programme dans le processeur Échange avec l'extérieur Gestion mémoire Partage des ressources Gestion du temps Nous allons étudier ces services en étudiants leurs limites vis à vis de la prise en compte des contraintes de temps réel. Dans la suite, nous détaillons uniquement l'exécution du programme dans le processeur en étudiant les limites vis à vis de la prise en compte de contraintes temps réel.

Services d'un système élémentaire Interaction par scrutation cyclique Interaction par Interruption Limites des approches précédentes Nous allons voir l'interaction entre le programme et le monde extérieur. C'est à dire comment le programme réagit à un événement à des instants qu'il ne maîtrise pas.

Les interaction par scrutation cyclique Le programme va interroger (ou scruter) ses périphériques régulièrement. faire vérifier capteur tant que (données non disponibles) lire capteurs traiter les données démarrer les réactions vérifier les actionneurs tant que actions effectuées jusqu'à arrêt du système

Les interactions par interruptions Le programme est averti de la survenue d'un événement. Une interruption interrompt le cours du programme et lui permet de reprendre le programme là où il a été interrompu. Programme de scrutation : traitement différé faire faire vérifier les capteurs tant que (état = données disponibles) lire données mémorisées remettre à zéro état des capteurs Jusqu’à arrêt du système Gestionnaire d'interruption : Prise en compte immédiate Interruption : lire et mémoriser les données positionner (état capteur = données disponibles) acquitter l’interruption

Les interactions Avantages : Simple à programmer s'il y a peu des périphériques Le temps de réaction d'un système est simple à déterminer. Il s'agit du temps de traitement d'une boucle. On peut s'avoir si le système satisfait les contraintes de temps.

Limitations des approches précédentes Inconvénients : Va à l'encontre des pratiques du génie logiciel. Le programme mal structuré devient rapidement illisible et impossible à maintenir. Un nouveau périphérique demande la remise en cause de l'existant. Une grande partie du temps processeur est consacrée à autre chose qu'à l'application.

Exemple : Soit un programme émettant des caractères sur une liaison série à 9600 bauds via un UART. Il possède 2 séries de registres pour transférer et recevoir des caractères. L'UART cause des interruptions différentes pour l'émission et l'arrivée des caractères. L'UART émet un caractère tout les millisecondes environ. L'ordinateur ne peut émettre le caractère suivant que quand l'UART est prêt. Il perd donc beaucoup de temps à tester par scrutation s'il est autorisé à émettre le caractère suivant ou pas.

Exemple suite Pour émettre un caractère, le programme se bloque en faisant appel à l'opération (Attendre). L'UART répond par une interruption (TxReady) lorsqu'il est prêt. Le gestionnaire d'interruption effectue l'opération (Signaler) et le programme suspendu peut rependre le processeur et réémettre un caractère immédiatement. Il faut noter que pendant la milli-seconde qui s'est écoulée entre (Attendre) et l'interruption, d'autres programmes pourraient effectuer un travail utile. C'est pour mieux répondre à ce besoin qu'on a introduit la notion de tâche.

Plan Services d'un système élémentaire Services multitâches Gestion du processeur Partage des ressources et exclusion mutuelle

Introduction à la notion de tâches Le traitement d'un événement externe est partagé entre un traitement immédiat effectué par le gestionnaire d'interruption et le traitement différé confié à une tâche (c'est à dire un code séquentiel dédié à une tâche). Plusieurs tâches peuvent s'exécuter concurremment, on peut donc récupérer les temps morts. C'est cette récupération qui fait tout l'intérêt des modèles multitâches.

Système Multitâches Un programme seul n'occupe pas la capacité totale d'un processeur en particulier lors des E/S. L'idée : une exécution concurrente pour récupérer les temps morts. Le système d'exploitation va gérer l'exécution concurrente des programmes.

Plan Services d'un système élémentaire Services multitâches Gestion du processeur Partage des ressources et exclusion mutuelle

La gestion du processeur Tâches Gestion multitâches Politiques d'ordonnancement classiques Limites de ces mécanismes pour le temps réel

Les tâches : Définitions Un programme est composé d'une suite d'instructions qui agissent sur un ensemble de données : objet statique Processus : lorsque l'on déclenche l'exécution d'un programme, il devient un objet dynamique géré par l'OS. Le contexte d'un processus est l'ensemble des informations qui caractérisent son exécution (Registres, son nom, état …) Un processus est dit lourd lorsque le contexte est volumineux. Un processus est légers lorsqu'il s'exécutent avec d'autre processus au sein d'un même contexte.

États d'une tâche opérationnelle Blocage En_attente Courant Allocation Réveil Préemption Prêt Tâche Active

Etat pour un noyau temps réel Attente d'une durée Exécutée Endormie Suppression Préemption Suppression Election Réveil Prête Attente blocante Suppression Arrivée evt Bloquée Suppression Initialisation Existante Créée Existante non initialilsée

L'ordonnancement La partie du système qui fait évoluer les états des tâches et qui alloue le processeur aux tâches s'appelle l'ordonnanceur (Scheduler). L'OS manipule les tâches aux travers de structures de données appelées descripteurs de tâches (task control block).

L'ordonnancement Code T1 Code T2 Code T3 Liste des tâches prêtes Contexte T1 état = PRET Contexte T2 état = PRET Contexte T3 état = PRET Liste des tâches prêtes Liste des tâches en attente Tâche courante T4 état = Attente T5 état= Attente T6 état=Courant

Les politiques d'ordonnancement classiques Ordonnancement préemptif Un ordonnancement est dit « avec réquisition » ou préemptif si le processus courant peut être désalloué par décision de l'ordonnanceur. Dans le cas d'un système préemptif, une interruption peut survenir en n'importe quel point du déroulement d'une tâche et provoquer une préemption.

Modèle de tâches Période d'activation T ID Depart C D T Etat C_restante P Deadline T1 2 3 5 5 Période d'activation T Borne sur le temps d'exécution C Arrivée Depart Délai critique relatif à T D

Modèle de tâches ID Depart C D T Etat C_restante P Deadline T1 2 3 4 5

Lois d'ordonnancement classique Premier arrivé, premier servi Le tour de rôle ou tourniquet L’ordonnancement par priorité

Exemple : FIFO ID Pr C Depart Critère ID croissant T1 2 6 0 T2 1 3 0 4 5 6 7 8 9 10 11 12 13 14 T1 T2 T3 nop

Robin ID Robin C Depart Critère RR croissant T1 1 6 0 T2 1 3 0 4 5 6 7 8 9 10 11 12 13 14 T1 T2 T3 nop la formule permet de simuler une liste circulaire. =SI(MOD(temps;3)=0;0;SI(MOD(temps;3)=1;2;1)) =SI(MOD(temps;3)=0;1;SI(MOD(temps;3)=1;0;2)) …

Robin avec priorité ID Robin C Depart Critère Robin et 2 critère RR

Robin + incrément de priorité ID Depart C Robin T1 10 1 T2 11 T3 2 T4 3 T5 pour simu, le premier robin avec 100 en tps augmenté le deuxieme avec 10. En 10 T3 a sa priorite qui passe à 1 et rentre dans la pile avec T1 et T2. Elle sera donc ordo 3 tps apres. et T4, T5 passe en 2 et ne sont donc tjs pas ordonnancées.

Exemple : Priorité ID Pr C Depart Critère Pr croissant T1 2 6 0 3 4 5 6 7 8 9 10 11 12 13 14 T2 T1 T3 nop ID Pr C Depart T1 2 6 0 T2 1 3 0 T3 2 4 0

Ordonnancement avec interactions entre les tâches Tâche 1 (prio=2) T1.1 Attendre1s T1.2 Signaler (tache2,evt) T1.3 Tâche 2 (prio=1) T2.1 Attendre(evt) T2.2 1s T1.1 T1.2 T1.3 Tâche1 Tâche2 Tâche de fond* Attendre evt T2.1 T2.2 * fournit le minimum d'exécution sous forme d'une boucle infinie.

Limitations de ces mécanismes pour le temps réel Un exécutif temps réel multitâches offre une politique d'ordonnancement préemptive basée sur les priorités. L’application est testée pour contrôler le bon respect des contraintes temporelles. Limites : Affecter des priorités n'est pas toujours une garantie de maîtrise des contraintes temporelles (variables partagées).

Plan Services d'un système élémentaire Services multitâches Gestion du processeur Partage des ressources et exclusion mutuelle

Partages des ressources et exclusion mutuelle. Une application temps réel est découpée en tâches. Ces tâches mettent en œuvre des algorithmes portant sur un ensemble de ressources qui peuvent être partagées. Problème T1 LireA A=A+10 EcrireA T2 LireA A=A+30 EcrireA Si T2 préempte T1 suite à une interruption : LireA A=A+30 EcrireA A=A+10

Des solutions Les problèmes viennent du fait que l'exécution des séquences est intérrompue On appelle séquence atomique, une suite d'opérations exécutées par un système qui permet de passer d'un état cohérent du système à un autre état cohérent sans possibilité d'interruption. On appelle section critique, une séquence d'opérations qu'il faut effectuer de façon atomique. Les sections critiques portant sur des ressources communes doivent être exécutées en exclusion mutuelle. Solutions : Masquage et sémaphore.

Les sémaphores binaires Un sémaphore est une entité logique gérée par le système d'exploitation associé de manière univoque à une ressource. Deux primitives P et V permettent de manipuler le sémaphore P : Compteur = Compteur-1 si compteur<0 mettre la T en fille d'attente sinon accorder la ressource V : Compteur = Compteur+1 si compteur <=0 sortir une tâche de la fille d'attente

Exemple Le sémaphore S est initialisé à 1. T1 P(s) I=I+J; V(s) T2 P(s) I=I-k; V(s) Lire I dans R1 Lire J dans R2 additionner R1 à R2 …

Listes des mécanismes sémaphores pour le temps réel A partir du moment où une tâche a acquis une ressource (passé le P), toutes les tâches parvenant à un P sur le même sémaphore resteront bloquées, quelle que soit leur priorité. Ces cas de blocage posent un problème car il existe des cas où l'on ne sait pas donner de bornes temporelles à ce type de situation.

Conclusion L'exclusion mutuelle, la communication et la synchronisation sont des problèmes généraux à prendre en compte dès que plusieurs tâches s'exécutent concurremment dans un système. Le maintien de la cohérence des données et des codes du système conduit les tâches à utiliser des services qui génèrent des mises en file d'attente. Un système qui attribue des priorités aux tâches, ne peut plus assurer qu'une tâche de plus faible priorité ne bloque pas une tâche de plus forte priorité.

Nous allons identifier et présenter les mécanismes spécifiques qui permettent de prévoir avec plus d'exactitude le comportement temporel d'un système.