Fichier Cours TR GLSR 09 Chap1 Rc1

Les Systèmes Temps Réels
ENSPS 3A, spécialité GLRS (édition 2009-2010)
Christophe DOIGNON
Maître de Conférences à l’ENSPS
(membre de l’IEEE Computer Society )
Ecole Nationale Supérieure de Physique de Strasbourg

Bureau C418 – courriel : [email protected]
Université de Strasbourg, FRANCE
http://lsiit-cnrs.unistra.fr/avr/~christophe 1
Les Systèmes Temps Réels - Ch. DOIGNON ENSP Strasbourg (Edition 2009-2010)
Bibliographie
« Les systèmes d'exploitation » Conception et mise en oeuvre

Andrew Tanenbaum, InterEditions, Paris, ISBN : 2-7296-0259-2, 756 pages, 1991
« Systèmes d'exploitation : concepts et algorithmes »,

J. Beauquier, B. Bérard, Ediscience internationale, ISBN : 2-84074-025-7, 538 pages
« Programming for the real world – POSIX 4 »

Bill O. Gallmeister, O'Reilly & Associates, inc., ISBN : 1-56592-074-0, 550 pages
« Ordonnancement temps réel »

F. Cottet, J. Delacroix, C. Kaiser, Z. Mammeri, Hermes, ISBN : 2-7462-0099-6, 205 pages
« Commande en temps réel: conception et mise en œuvre d’un exécutif multitâches

D.Tschirhart, Dunod-Bordas, Paris, ISBN : 2-04-018983-1, 215 pages, 1990
2
Plan du cours
Chapitre 1 : Généralités, concepts et terminologie
• Les systèmes temps réels : définition, terminologie et contraintes temporelles
• Modèles de tâches (états, contexte)
• Architecture logicielle des processus informatiques – mémoire virtuelle
• Exemples de quelques SETR
Chapitre 2 : Multiprogrammation et ordonnancement

• Multiprogrammation
• Stratégies d’ordonnancement
Chapitre 3 : Mise en œuvre : signaux, gestion du temps et multi-activités

• Signaux
• Mesure et gestion du temps
• Multi-activités
• Sections critiques
Chapitre 4 : Protection et communication rapide entre processus locaux

• Verrouillage de pages en mémoire
• Entrées/sorties non bloquantes et asynchrones
• Communication par segments partagés,
• Projection des fichiers en mémoire
• File de messages 3
Chapitre 1
Généralités, Concepts
et
Terminologies
4
DEFINITION (tentative)
Un système temps réel est un système d’exploitation (SETR) ou un ensemble

d'applications informatique qui doit répondre à des stimuli fournis par un
environnement externe afin de le contrôler.
• Il se caractérise non seulement par la justesse des calculs mais aussi par temps
nécessaire pour fournir le résultat d’un ensemble de traitements.
• Un système temps réel interagit avec un environnement extérieur et en évolution.

Il doit pouvoir interagir avec différents types d'éléments matériels et prendre en
compte des contraintes temporelles imposées par ceux-ci.
5
TEMPS REEL DUR
• On parle de Temps Réel dur (Hard Real Time) quand les événements traités trop
tardivement ou perdus provoquent des conséquences catastrophiques pour la bonne
marche du système (perte d ’informations cruciales, plantage…).
• Les systèmes à contraintes temporelles dures ne tolèrent qu’une gestion stricte du

temps afin de conserver l'intégrité du service rendu.
– exemple: les contrôles de processus industriels sensibles comme la régulation des

centrales nucléaires ou les systèmes embarqués utilisés dans l'aéronautique.
• Un système d ’exploitation est dit Temps Réel dur s’il est capable de répondre à des
sollicitations ou événements (internes ou externes) dans un temps maximum connu.
• Ces systèmes garantissent un temps maximum d'exécution pour chaque tâche. On a

une répartition totalitaire du temps CPU entre tâches. On peut dire qu'un système
temps réel doit être déterministe et prévisible (predictible), les contraintes
temporelles pouvant s'échelonner entre quelques μs et plusieurs secondes.
6
TEMPS REEL MOU
• On parle de Temps Réel mou (Soft Real Time) quand les événements traités trop
tardivement ou perdus sont sans conséquence catastrophique pour la bonne marche
du système. On ne garantit qu’un pourcentage moyen d’utilisation du temps CPU.
• Les systèmes à contraintes temporelles souples ou molles (soft real time) acceptent
des variations dans le traitement des données. On parle alors de Qualité de Services.
– exemple des systèmes multimédia : si quelques images ne sont pas affichées, cela
ne met pas en péril le fonctionnement correct de l'ensemble du système.
• Ces systèmes se rapprochent fortement des systèmes d'exploitation classiques à

temps partagé. Ils garantissent un temps moyen d'exécution pour chaque tâche (un
débit, une bande passante , une qualité de services).
• On a ici une répartition égalitaire du temps CPU entre processus.
7
CLASSIFICATION
• Temps réel dur (hard real-time) : le non respect des contraintes temporelles entraîne
la faute du système.
– exemple: contrôle de trafic aérien, système de conduite de missile, ...
• Temps réel souple (soft real-time) : le respect des échéances est important mais le
non respect de toutes éles chéances ne peut pas occasionner de graves conséquences.
– exemple: système d'acquisition de données pour affichage
REMARQUES
• Il ne faut pas confondre contrainte temporelle (qui dépend de l'application et de

l'environnement) et rapidité de traitement (qui dépend de la technologie utilisée
et de la conception d’un exécutif).
• Un système temps-réel inclut généralement différents sous-systèmes chacun

pouvant avoir ses propres contraintes temporelles (dures ou souples)
8
UTILISATION DU TEMPS
Au sein d'une application ou d'un système temps-réel, il faut pouvoir gérer le temps
(horloge). Le temps sera utilisé de plusieurs façons:
– Soit en définissant la date à laquelle une action doit être commencée
– Soit en définissant la date à laquelle une action doit être finie
• Il peut être nécessaire de pouvoir modifier ces paramètres en cours d'exécution et

de pouvoir préciser les actions à prendre en cas de faute temporelle.
DECOUPAGE EN TACHES OU EN PROCESSUS (concurrents)
Dans le monde réel les périphériques et l'environnement du système évoluent

simultanément (en parallèle et parfois en concurrence). Pour calquer fidèlement la
réalité il faut s'appuyer sur de la programmation concurrente :
– utiliser un modèle de tâches,
– utiliser des moyens de communication et de synchronisation inter-tâches ou inter-
processus (mémoire partagée, boites aux lettres, files de messages, sémaphores ...)
9
REMARQUES
• L'exécution des applications temps réel se fait généralement dans un

environnement monoprocesseur.
• On "simule" l'exécution concurrente des processus par la mise en œuvre du
pseudo-parallélisme : le parallélisme est apparent à l'échelle de l'utilisateur mais
le traitement sur le processeur (unique) est fait séquentiellement en tirant profit
des entrées/sorties réalisées par les processus.
Tâches ou processus exécutés en apparence en parallèle 10

• Dans un tel contexte, quels intérêts a-t-on de concevoir un programme s’exécutant

sur plusieurs processus ?
• Comment décomposer les instructions et/ou les données sur plusieurs processus ?
• Comment communiquer entre processus ?
Tâches ou processus exécutés séquentiellement en réalité (env. mono-processeur) 11

PREEMPTION
Un système d’exploitation est dit à noyau préemptif (ou aussi à réquisition -
preemptive scheduling – le processus du système d’exploitation qui contrôle tout)
lorsqu’aucune requête (appel système) est nécessaire pour effectuer l’attribution
du processeur à un processus. C’est le système d’exploitation qui interrompt ou
reprend l’exécution des processus informatiques.
Mono- Multi-
Système Codage Mono-tâche Multitâche
utilisateur utilisateur
DOS 16 bits X X
Windows3.1 16/32 bits X non préemptif
Windows95/98/Me 32 bits X coopératif
WindowsNT/2000 32 bits X préemptif
WindowsXP 32/64 bits X préemptif

Windows7 32/64 bits X préemptif
Unix / Linux 32/64 bits X préemptif
MAC/OS X 32 bits X préemptif
VMS 32 bits X préemptif
12
RESPECT DES ECHEANCES TEMPORELLES : ordonnancement
La limitation des ressources (en particulier du processeur) conduit à bloquer des

processus (ils ne peuvent progresser du fait de manque de ressource).
Afin de respecter en permanence les échéances, il faut gérer efficacement la
pénurie et tenter de favoriser les processus dont l'avancement est le plus urgent.
• Un ordonnancement consiste à définir un ordre sur l'utilisation des ressources du

système afin de respecter les échéances temporelles. On appelle ordonnanceur
(scheduler) le processus système qui gère l'ordonnancement des processus.
• Un algorithme d'ordonnancement est une méthode ou stratégie utilisée pour

ordonnancer les processus. Un tel algorithme s'appuie sur la connaissance de
certaines caractéristiques des processus ou du système :
– processus périodiques ou apériodiques,
– processus cycliques,
– préemption possible ou pas (pas de réquisition),
– échéance et pire temps d'exécution des processus,
– système à priorités fixes, dynamiques ou à échéance,
– charge du système,...
13
RESPECT DES ECHEANCES TEMPORELLES : ordonnancement
Un SETR préemptif est piloté par le temps: le processeur commute de processus en

processus sous le contrôle d’un module du noyau appelé ordonnanceur (scheduler).
Le processeur est alors attribué à un processus pendant un quantum de temps dt
(time slice ou tick) indivisible, sauf lors d'arrivée de signaux ou d’interruptions.
Algorithmes classiques d'ordonnancement (exemples parmi d’autres…)

– RR (Round Robin) : algorithme (du tourniquet) pour priorités fixes: chaque
processus dispose du processeur à tour de rôle.
– RM (Rate Monotonic) : algorithme à priorité fixe pour processus cycliques (le

processus le plus prioritaire est celui de plus petite échéance)
– EDF (Earliest Deadline First) : algorithme à priorité dynamique pour processus

cycliques (le processus le plus prioritaire est celui de plus petite échéance)
– DM (Deadline Monotonic) : algorithme d’ordonnancement préemptif à priorités

constantes affectées selon le principe suivant : la tâche la plus prioritaire est celle
dont le délai critique est le plus faible (délai maximum acceptable pour l’exécution
d’une tâche).
14
TYPE DE TACHES
• Tâche/processus : suite d’instructions + données + contexte d’exécution (état).
• Classification des tâches/processus :

• Tâches dépendantes ou non.
• Tâches importantes, urgentes.
• Tâches répétitives : activations successives (tâches périodiques ou
sporadiques) ⇒ tâches critiques.
• Tâches non répétitives/apériodiques : une seule activation ⇒ tâches non
critiques.
15
RESPECT DES ECHEANCES TEMPORELLES : exécutif TR
Exécutif : c’est le cœur d’un système d’exploitation. Son rôle est de :

- Ordonnancer les tâches,
- Protéger l’accès aux ressources partagées
- Recevoir et transmettre les signaux de synchronisations
- Il est composé de modules spécialisés :
• gestion des tâches/processus (commutation, s/r contextes)

• gestion des événements matériels et logiciels (de synchronisation)
• gestion communications entre tâches
• gestion du temps (ordonnanceur)
• gestion des ressources partagées
• gestion de la mémoire
- Il ne gère pas les fichiers (fichiers sur disques).
16
NOYAU vs EXECUTIF vs SETR
Un noyau temps réel (NTR) est le minimum logiciel pour pouvoir faire du
temps réel : ordonnanceur, gestion de tâches, communication inter-tâches.
Un exécutif temps réel possède un noyau temps réel complété de

modules/bibliothèques pour faciliter la conception de l'application temps
réel : gestion de la mémoire, gestion des E/S, gestion de du temps (timers),
gestion d'accès réseau, gestion de fichiers éventuellement.
Lors de la génération de l'exécutif, les bibliothèques sont choisies en fonction
des besoins de l'application temps réel. Pour le développement, on a besoin
d'une machine hôte (host) et de son environnement de développement
croisé (compilateur C croisé, utilitaires, debugger) ainsi que du système cible
(target) sur lequel sera téléchargé (par liaison série ou par le réseau ou par
liaison firewire) l'application temps réel avec l'exécutif.
Un système d'exploitation temps réel (SETR) est le cas particulier où l'on a

confusion entre le système hôte et le système cible qui ne font plus qu'un.
On a donc ici un environnement de développement natif.
17
18
DETERMINISME (temporel)
Définition (tentative) : un système informatique est déterministe si le temps

d’exécution d’un processus considéré dans un environnement mono-processus
est constant, quel que soit le volume et la nature (et valeurs) des données
traitées.
La principale différence entre un OS généraliste (temps partagé) et un OS temps

réel est le comportement très déterministe.
On trouvera quelques différences dans l’API (norme POSIX):

• politique d’ordonnancement plus élaborée,
• gestion plus précise des timers à la résolution plus fine,
• plus d’ouverture sur le matériel en particulier les connexions aux IT matérielles,
• plus de modularité dans la construction du noyau,
19
RESPECT DES ECHEANCES TEMPORELLES : déterminisme et fiabilité (disponibilité)
Les systèmes à contraintes dures doivent répondre à trois critères fondamentaux :

– Le déterminisme logique : les mêmes entrées appliquées au système doivent
produire les mêmes effets.
– Le déterminisme temporel .
– La fiabilité : le système doit être disponible. Cette contrainte est très forte dans le
cas d'un système embarqué car les interventions d'un opérateur (IHM) sont très
difficiles voire même impossibles. Cette contrainte est indépendante de la notion de
temps réel mais la fiabilité du système sera d'autant plus mise à l'épreuve dans le
cas de contraintes dures.
TT ou ET ?
Un système informatique peut être piloté par le temps (TT - Time Triggered) et
disposer alors d’un cadencement par horlogerie ou bien être piloté par événements
(ET - Event Triggered). L’approche TT à l’avantage d’inclure les systèmes distribués
déterministes. En effet, comme le temps physique est l’élément de synchronisation
de tous les traitements, ils peuvent être effectués sur différents calculateurs.
L’approche ET est plus simple à mettre en œuvre, généralement pour une
application spécifique dont l’exécution est sur une machine locale.
20
Exemple : programme terminal simplifié

Un programme terminal consiste à afficher sur l’écran chaque
caractère arrivant sur l’entrée série, et à envoyer le caractère frappé
au clavier sur la sortie série.
Le matériel utilisé dans cet exemple possède les caractéristiques
suivantes:
- vitesse de frappe garantie : 10 caractères/seconde
- vitesse d’affichage sur l’écran : 1000 caractères/seconde
- vitesse de réception ou d’émission des caractères sur la ligne:
50…19200 bauds, format 8 bits, 1 bit START, 1 bit STOP (pas de bits
de parité). La vitesse configurée est de 600 bauds.
Le programme comporte deux tâches (voir ci-contre) :

-une tâche déclenchée par la frappe d’un caractère avec contrainte
temporelle Te1 = 0.1 s,
- une tâche d’affichage déclenchée par la réception d’un caractère
avec contrainte temporelle Te2 = (8+1+1)/600 s.
Le temps de cycle, ty , est essentiellement lié à la vitesse de

l’affichage, nous le supposons égal à ty = 1 ms (cas le plus
défavorable).
La contrainte de temps la plus forte est:

Te2 = (8+1+1)/600 = 16,7 ms ce qui vérifie ty < Te.
Si la vitesse de réception des caractères est 19200 bauds, la

contrainte sera de : Te2 = 10/19200 = 0.52 ms > ty. Terminal fonctionnant par scrutation
21
CONTRAINTES DE TEMPS FAIBLES AVEC EVENEMENTS CONTRAIGNANTS
Si le temps de cycle ne permet pas de satisfaire quelques contraintes, on associe les

fonctions concernées à des interruptions ou à des signaux. Chaque
interruption/signal est associé à un ou plusieurs événements. Le SETR sera ainsi
synchronisé sur ces événements et exécutera les traitements liés aux interruptions
(gestionnaire d’interruption - interrupt handler) en suspendant le programme en
exécution (interrupt driven ou event triggered).
Le traitement d’une interruption allonge le temps de cycle du programme
interrompu. Les contraintes temporelles devront être analysées avec soin. Ci-
dessous un exemple avec deux interruptions signalant des événements à prendre
en compte immédiatement :
Gestion des entrées/sorties avec deux événements contraignants

22
CONTRAINTES DE TEMPS FAIBLES AVEC EVENEMENTS CONTRAIGNANTS
Soient Te0, Te1, Te2 les contraintes de temps liées à la tâche de fond et aux
événements.
• Cas d’une seule interruption IT1 de fréquence constante f1 :

Pour satisfaire les contraintes : ty1 < Te1 et ty0 + f1 ty1 < Te0
• Cas de plusieurs interruptions non imbriquées : soient f1 et f2 les fréquences des

interruptions IT1 et IT2 :
ty0 + f1 ty1 + f2 ty2 < Te0
ty1 + ty2 < Te1 (pour les événements liés à l’interruption IT1)
ty1 + ty2 < Te2 (pour les événements liés à l’interruption IT2)
• Cas de plusieurs interruptions imbriquées : supposons l’interruption IT2 la plus prioritaire :

ty0 + f1 ty1 + f2 ty2 < Te0
Si f1 < f2  ty1 + f2 ty2 < Te1 (pour les événements liés à l’interruption IT1)
Si f1 > f2  ty1 + (f1-f2) ty2 < Te1
ty2 < Te2 (pour les événements liés à l’interruption IT2)
23
DEPENDANCE ET SYNCHRONISATION : les processus peuvent interagir entre eux

selon un ordre prédéterminé ou induit par la communication de données ou par
une relation explicite de synchronisation/rendez-vous (c’est le cas très fréquent où
un processus attend le résultat que doit fournir un autre processus pour poursuivre
son exécution).
Il y a alors une relation de précédence entre processus. Cette relation est statique,
car elle est connue a priori et n’évolue pas. Elle est représentée par un graphe de
précédence.
Des processus sont dits indépendants lorsqu’ils ont entre eux ni de relation de
précédence ni partage de ressources critiques (ressources communes gérées par
des sections de code non-interruptibles, appelées sections critiques).
Exemple de graphe de précédence entre cinq processus 24

ARCHITECTURE LOGICIELLE
Un processus/tâche est tout ou partie d'un programme binaire en exécution.
L'exécution signifie que les instructions du programme sont traitées par le(s)
processeur(s) et que des requêtes à d'autres ressources communes (mémoire,
entrées/sorties) sont effectuées.
Un processus est composé de zones en mémoire (et d’un bloc de contrôle/ou
en-tête) :
- une zone pour les instructions (zone partageable),
- une zone pour les données statiques (zone partageable),
-une zone pour les données dynamiques (zone partageable privée) dont une ou
plusieurs piles (zones non partageables).
Si le système informatique possède plusieurs processeurs, les instructions d'un

programme ne pourront s'exécuter en parallèle (simultanément sur tous les
processeurs) que si le programme binaire est décomposé en au moins autant
de processus ou d’activités : autrement dit, les instructions d'un processus ne
peuvent être traitées que par un processeur.
25
CREATION DYNAMIQUE DE PROCESSUS

Un processus peut créer, durant son exécution (c'est-à-dire dynamiquement),
un autre processus que l'on nomme processus fils. Il ne se substitue pas au
processus père, mais tous les deux sont concurrents pour l'obtention de
toutes les ressources nécessaires au traitement de leurs instructions (à
commencer par le processeur).
FILS D’EXECUTION
Un processus peut être décomposé en plusieurs activités ou fils d’exécution
(threads). Généralement dans les SE actuels, à une tâche correspond un fil
d’exécution.
L’ordonnanceur du SE gère les threads/tâches. La notion de processus définit
un espace d’adressage protégé dans lequel s’exécute au moins une tâche (le
main thread) qui est activé quand le processus est lancé. Le processus se
termine quand la dernière tâche qu’il contient se termine.
Comme les threads se partagent des ressources communes aux processus, il y
a lieu de protéger certains accès aux données.
Dans certains SE simples il n’y a pas d’espace mémoire protégé, il y a alors

équivalence entre les termes: processus = thread = tâche.
26
ARCHITECTURE LOGICIELLE
Zone créée au moment du

chargement en mémoire
(taille minimale)
Zones composant
un processus
Zones créées au moment de

la compilation :
fichier binaire exécutable
27
EXEMPLE : en analysant le programme source simplissime suivant, indiquer dans

quelles zones se trouveront chacun des éléments (données et instructions) du
processus prog0, suite à la compilation ou durant l’exécution.
/**************************************
prog0.c
**************************************/
void afficher( long );
unsigned long n = 32;
int main( void )

{
long i;
for ( i = 0 ; i < n ; i++ ) afficher( i );
return 0;
}
void afficher( long a )

{
printf(«affichage pour la %ld ieme fois parmi %ld.\n»,a,n);
return;
}
28
L'état d'un processus permet d'exprimer si le processus est réellement exécuté,

s'il est seulement prêt à être exécuté, c'est-à-dire en attente du processeur, ou
encore, s'il est en attente d'autres ressources que le processeur ou d'un
événement extérieur. C'est le système d'exploitation qui détermine et modifie
l'état d'un processus.
A cette fin, chaque processus est représenté par une structure appelée bloc de
contrôle ou BPC et qui renferme le contexte du processus : ce contexte
permettra de reprendre l'exécution du processus après une interruption de son
exécution. Les données des contextes contiennent les informations suivantes :
- numéro du processus et de son parent,
- adresse du début du code du processus : adresse de main(),
- adresse de la pile du processus,
- état du processus et la priorité,
- valeurs de certains registres du processeur,
- descripteurs des fichiers ouverts
- masques de signaux.
Les contextes sont liés afin d'enchaîner les processus les uns aux autres (tableau
d'adresses (ou liste chaînée) de début de contexte). L'ordre dans lequel les
processus sont exécutés est fonction de la stratégie d'ordonnancement qui
élabore la table des tâches.
29
Les différents états d’un processus et leurs transitions
30
Le passage d'un état à l'autre s'effectue à l'aide de fonctions programmées dans le

noyau. Ces fonctions sont appelées requêtes du noyau. L'ensemble de ces
requêtes forme les primitives de l'exécutif (ensemble appelé API : Application
Program Interface).
• Etat NON CREE : un processus à l'état NON CREE est un processus inconnu de
l'exécutif. Dans un système comportant des périphériques de stockage (ou
RAMDisk), ces processus ne sont pas chargés en mémoire et ne possèdent pas
(encore, ou plus du tout) de zone de code, de données ou de pile. La seule
transition possible à partir de cet état est celle permettant de faire évoluer le
processus vers l'état CREE.
• Etat CREE ou DORMANT : un processus à l'état CREE est un processus connu de
l'exécutif. Un identificateur lui a été attribué, ainsi qu'une zone de pile. Le
processus reste dans cet état tant qu'une requête ne l'a fait pas évoluer vers un
autre état. Les seules transitions possibles à partir de cet état sont celles vers l'état
PRET (vers une exécution) ou NON CREE (destruction).
• Etat PRET : un processus à l'état prêt est candidat au(x) processeur(s). Son
lancement ne dépend que de sa priorité par rapport aux processus en cours
d'exécution ou aux autres processus à l'état PRET. Lorsque celui-ci devient
prioritaire, l'ordonnanceur lui attribue le processeur (virtuel). A partir de cet état,
le processus peut évoluer vers les états EXEC, DORMANT ou NON CREE.
31
• Etat EXEC : un processus en exécution est en possession du processeur virtuel

ou réel. L'exécution (processeur réel) du processus commence alors dès que le
processus en cours termine son quantum dt (sauf dans le cas d’arrivée de
signaux ou d’interruptions matérielles pour lesquelles le processeur réel est
attribué sans attendre). L'attribution du processeur réel est de la compétence de
l'ordonnanceur et du commutateur. Dans un système monoprocesseur, plusieurs
processus de même priorité peuvent être en exécution virtuelle mais un seul est
en possession du processeur réel. Un processus reste dans cet état tant qu'il est
le plus prioritaire et qu'il ne rencontre pas une condition de blocage.
• Etat BLOQUE ou SUSPENDU : un processus à l'état BLOQUE ou SUSPENDU
n'est plus en possession du processeur. Le processus a été interrompu avant sa
fin (temporairement ou définitivement) sur l'apparition d'une condition de
blocage. Il peut également avoir été suspendu volontairement par une requête
de type mise en sommeil (pause()). Les causes de blocage sont multiples :
ressource non disponible, synchronisation avec un autre processus, exécution
d'un gestionnaire d'interruption, communication par tube,...
Au moment du blocage, tout le contexte du processus est sauvegardé. Il est
important de distinguer l'état PRET de l'état BLOQUE. Lorsqu'un processus passe
en exécution à partir de l'état PRET, il suffit de mettre à jour une variable
signifiant le nouvel état du processus et d'initialiser les registres du processeur.
32
L’ordonnanceur s’acquitte de l’élection du processus pour le prochain

quantum de temps (et donc amenant à des transitions entre états si
changement de processus) selon plusieurs critères :
- le nombre de processus,
- la priorité des processus,
- la stratégie d’ordonnancement.
La commutation entre processus est le rôle d’un autre module particulier
du noyau qui s’appelle le commutateur : plus précisément, il s’occupe de
sauvegarder/restituer des contextes (context switch) au moment du
changement de processus. Cela nécessite un certain temps : le temps de
commutation Tc qui est une caractéristique importante d’un SETR. Tc est
de l’ordre de 10 à 100 microsecondes sur les SETR actuels.
33
TEMPS de LATENCE
La gestion des entrées/sorties peut générer des « temps morts » car une tâche
peut être bloquée en attente d'accès à un élément d'entrée/sortie. La gestion des
interruptions reçues par une tâche n'est pas optimisée sur tous les SETR. Le
temps de latence caractérise le temps maximum écoulé entre la réception de
l'interruption et son traitement garanti par le système. C’est une caractéristique
importante d’un SETR.
GIGUE (JITTER)
Variation du temps de latence d’un SE pour délivrer un signal, en comparaison de

sa cadence (tops d’horloge ou timer tick) .
On distingue deux formes de gigue de tâches :
- la gigue maximale de début d’exécution d’une tâche qui représente la variation
maximale du délai entre deux débuts d’exécution successifs de cette tâche,
- la gigue maximale de temps de réponse d’une tâche qui désigne la variation
maximale du temps de réponse de cette tâche.
34
EXTENSION POSIX
La complexité des systèmes et l'interopérabilité omniprésente nécessitent une
standardisation de plus en plus grande tant au niveau des protocoles utilisés
que du code source des applications. Même si elle n'est pas obligatoire,
l'utilisation de systèmes conformes à POSIX est de plus en plus fréquente.
POSIX est l'acronyme de Portable Operating System Interface ou interface

portable pour les systèmes d'exploitation. Cette norme a été développée par
l'IEEE (Institute of Electrical and Electronic Engineering) et standardisée par
l'ANSI (American National Standards Institute) et l'ISO (International Standards
Organisation). Le but de POSIX est d'obtenir la portabilité des logiciels au
niveau de leur code source.
POSIX a initialement été mis en place pour les systèmes de type UNIX mais
d'autres systèmes d'exploitation comme Windows XP Pro sont aujourd'hui
conformes à POSIX. Le standard POSIX est divisé en plusieurs sous-standards
dont :
• IEEE 1003.1b-1993 : Interface de programmation (API) temps réel, appelée
POSIX.4.
• IEEE 1003.1c-1995 : Interface de programmation (API) pour le multithreading.
35
MEMOIRE VIRTUELLE
Les processus sont composés de segments de code, de segments de données

statiques et de segments de données dynamiques.
Pour faciliter la gestion de l’espace mémoire pour tous les segments de tous les
processus, la mémoire physique (mémoire vive + mémoire d’échange) est
décomposée en pages (page frames) d’une taille constante (4 Ko par exemple).
Ces pages sont mises en correspondance avec les pages de la mémoire virtuelle
qui est un espace mémoire adressable par un processus, indépendamment des
autres processus et indépendamment de la mémoire physique. Ce mécanisme
permet de ne charger en mémoire physique que les pages des segments
concernés pour l’exécution immédiate.
 Possibilité d’exécuter des programmes dont la taille est bien supérieure à celle
de la mémoire physique.
 Sur les ordinateurs actuels, l’espace mémoire virtuel projeté pour un processus
peut atteindre plusieurs Go (32 bits).
36
37
MEMOIRE VIRTUELLE : exercice
On considère un ordinateur dont le système d'exploitation est multitâches. La

mémoire physique totale est de 32 Mo. La mémoire vive (RAM) et la mémoire
d'échange (swap) sont composées de 16 Mo chacune répartis en pages de 4 Ko.
Le système d'exploitation possède, pour lui tout seul, les 6 Mo supérieurs (10 à 16
Mo) de la mémoire vive. Cinq processus utilisateurs se partagent la mémoire vive
restante (10 Mo) sous le contrôle du système d'exploitation. Le premier processus
utilisateur a besoin de placer 4 Mo de données statiques, 512 Ko de code (pour
les instructions) et 8 Ko pour sa zone initiale de données dynamiques (pile initiale
de 8 Ko, tas nul) en mémoire vive. Les autres processus utilisateur sont identiques
entre eux, à savoir :
1 Mo pour les données statiques, 256 Ko pour le code et 8 Ko pour la pile initiale.
a) Combien de pages sont nécessaires à chaque processus utilisateur ?
b) le premier processus utilisateur fait une requête d'allocation dynamique de

mémoire. Combien d'octets peuvent-ils être alloués pour lui sans faire appel à la
mémoire d'échange ?
(remarque : 1 Mo = 1024 Ko)
38
EXEMPLES DE QUELQUES SETR
• RTEMS (Real-Time Executive for Multiprocessor Systems) est un SETR libre pour
les systèmes embarqués (http://www.rtems.com).
Il permet de développer des programmes dans lesquels le temps de réponse et la
réactivité sont des contraintes fortes (temps-réel dur). Il a été porté sur de
nombreux processeurs (ARM, i386, m68k, MIPS, PowerPC) et est très complet.
Caractéristiques :
- conforme à la norme POSIX 1003.1b (API)
- système multitâches incluant les multi-activités (threads),
- supporte les systèmes multiprocesseurs homogènes ou non,
- supporte le pilotage par événement,
- ordonnancement préemptif basé priorités,
- supporte l’ordonnancement RM (rate-monotonic scheduling),
- communication and synchronisation entre tâches
- héritage de priorités,
- gestion des réponses aux interruptions,
- supporte l’allocation dynamique de la mémoire
- pile TCP/IP
39
• VxWorks est aujourd'hui l'exécutif temps réel le plus utilisé dans l'industrie.
VxWorks est fiable, généralement utilisé dans les systèmes embarqués et porté sur
un nombre important de processeurs (PowerPC, 68K, ColdFire, MCORE, 80x86,
Pentium, i960, ARM, StrongARM, MIPS, SPARC, NECV8xx,…).
Un point fort de VxWorks a été le support réseau (sockets, NFS,...) dès son
apparition. VxWorks est également conforme à POSIX 1003.1b.
Caractéristiques :
- noyau TR multitâches préemptif avec ordonnancement round robin,
- faible temps de latence,
- mémoire protégée – permet d’isoler les applications utilisateurs du noyau,
- support des multi-processeurs,
- communication inter-tâches,
- implémente l’exclusion mutuelle par sémaphores,
- héritage de priorités,
- gestion de file de messages locales et distribuées
- système de fichiers,
- pile TCP/IP IPV6
- latence moyenne de 1.7 ms, latence max de 6.8 ms sur Pentium 200 MHz
(http://www.windriver.com)
40
• QNX est un SETR adapté aux applications critiques. Développé par QNX
Software Systems, sa structure est de type Unix et il est compatible POSIX.
On le retrouve entre autres dans le développement de logiciels, le contrôle de
robots industriels et les ordinateurs embarqués. Son micro-noyau Neutrino peu
gourmand en ressource confère à QNX des capacités temps-réel très
performantes avec un temps de latence très faible (0.55 µsec sur un Pentium III).
Il dispose d’une interface graphique nommée Photon (version 4.x). Le temps de
commutation de tâches est très faible (< 1 µsec)
Caractéristiques :
- supporte la norme POSIX 1003.1b.
- micro-noyau Neutrino,
- zone mémoire protégée (Runtime Memory protection),
- multi-tâches préemptif,
- micro-GUI Photon,
- supporte les processeurs x86, SMP jusqu'à 8 processeurs,
- système de fichiers.
(http://www.qnx.com/ - version actuelle : 6.4)
41
• mC/OS-II est un exécutif temps réel destiné à des environnements de très petite
taille construits autour de microcontrôleurs de type Freescale 68HC11. Il est
maintenant disponible sur un grand nombre de processeurs et peut intégrer des
protocoles standards comme TCP/IP (µC/IP) pour assurer une connectivité IP sur
une liaison série par PPP.
Caractéristiques :
- écrit entièrement en langage C,
- support de nombreux micro-processeurs et micro-contrôleurs (Atmel, ARM, Freescale, x86,
Motorola, NEC, MicroChip, OpenRISC,…),
- bus CAN et MOD-bus,
- exécutif préemptif basé priorités,
- support de TCP/IP et USB,
- support d’un système de fichier (µC/FS),
- nécessite peu de mémoire (quelques Ko),
-il est utilisable gratuitement pour l'enseignement.
(http://micrium.com)
42
• Windows CE est une variation de Windows pour les systèmes embarqués. Il

utilise un noyau distinct des autres Windows et supporte les architectures Intel
x86, MIPS, ARM et aussi Hitachi SH. Windows CE est optimisé pour les appareils
possédant une faible capacité de stockage; le noyau peut tourner avec moins
d'un mégaoctet de mémoire vive.
Windows CE est un SETR. Il supporte 256 niveaux de priorité et permet
l'inversement de priorité. À l'inverse des systèmes basés sur UNIX, l'unité
fondamentale d'exécution est le thread. Windows Mobile est une version de CE
pour Smartphone et Pocket PC.
Caractéristiques :
- Windows CE peut fonctionner en RAM ou exclusivement en ROM,
- ordonnancement préemptif à 256 niveaux de priorités fixes,
- temps de latence déterministe des interruptions,
- supporte la communication sérielle, Bluetooth, Ethernet (TCP/IP), wifi,
- gestion des fichiers (exFAT),
- système 32 bits (2 Go pour le noyau, 2Go espace virtuel/réel projeté pour un ou plusieurs
processus sur espace utilisateur),
- jusqu’à 32768 processus,
- développement d’applications avec Embedded Visual C ou WinDev Mobile
43
LINUX ET LE TEMPS REEL
Linux n’est pas un SETR dur car le noyau Linux possède de longues sections de
code où tous les événements extérieurs sont masqués (non interruptibles) et le
noyau Linux n’est pas préemptible durant toute l’exécution d’un appel système
(structure monolithique) par un processus et ne le redevient qu’en retour d’appel
système (mode utilisateur – user mode). Le noyau Linux n’est pas préemptible non
plus durant le service d’une interruption (ISR - Interrupt Software Routine). La
routine ISR acquitte l’interruption puis traite les données de façon non préemptive
immédiatement avant de retourner en mode utilisateur.
Linux n’est pas un SETR dur car en cas d’occurrence d ’une interruption durant
l’exécution d ’un appel système en mode noyau, le traitement des données
(appelé BH – Bottom Half) programmé par l’ISR et éventuellement les autres BH
des autres ISR) ne sera exécuté qu’à la fin de l’exécution complète de l’appel
système d ’où un temps de latence important et non borné.
44
LINUX ET LE TEMPS REEL (suite)

Linux n’est pas un SETR dur car l’ordonnanceur de Linux essaye d’attribuer de
façon équitable le CPU à l ’ensemble des processus (ordonnancement de type
old aging mise en oeuvre pour favoriser l’accès CPU aux processus récents). C’est
une approche égalitaire. Un ordonnanceur TR donnera toujours la main à la
tâche prête de plus forte priorité.
Le noyau Linux standard peut être considéré comme Temps Réel mou par
définition si un temps de latence de l ’ordre de la centaine de ms ou plus
convient.
Il existe des solutions Linux Temps Réel dur pour un temps de latence de
quelques dizaines de μs (RTLinux, RTAI, Xenomai). Entre les deux, il existe des
solutions Linux Temps Réel mou par application de patchs dits préemptifs (RT-
Fedora Cora) sur un noyau Linux standard pour une latence de quelques
centaines de μs. Ainsi deux patchs (Prempt Kernel et Low latency) ont été
implémentés dans le noyau 2.6 de Linux.
45
• RTLinux se présente sous la forme d’un micro-noyau prenant place entre la

machine réelle (matériel) et le noyau Linux. Il intègre un gestionnaire de tâches
(qui dans la pratique est un module). Le noyau de Linux partage le temps
processeur avec les autres tâches temps réel et devient une tâche du SETR. Il est
utilisé pour des produits sensibles dans le domaine des télécommunications ou
des applications militaires. RTLinux propose des systèmes de communication de
type FIFO ou mémoire partagée entre les tâches temps réel (dans l’espace noyau)
et l'espace utilisateur dans lequel s'exécutent habituellement les applications.
Initialement produit libre, il est maintenant devenu un produit commercialisé par
la société FSMLabs (http://www.fsmlabs.com). Une version libre supporte les
noyaux Linux avant 2.6.
Caractéristiques :
- système préemptif, ordonnanceur à priorités fixes,
- supporte plusieurs processeurs (SMP),
- supporte les architectures x86, PPC Alpha (DEC), MIPS, StrongARM, …
- autorise la communication et synchronisation IPC (Inter Process Communication : tubes,
files de messages, sémaphores, mémoire partagée,…),
- communication entre processus utilisateurs et noyau (tâches temps réel) par FIFO,
mémoire partagée ou signaux,
- noyau Linux est alors une tâche de faible priorité (idle task).
46
• RTAI/ADEOS est un produit Open Source basé sur RTLinux qui intègre la gestion
des nombres à virgules flottantes. Les développeurs de RTAI ont récemment fait
un effort particulier sur une extension appelée LXRT (LinuX Real Time) permettant
de développer des tâches temps réel dans l'espace utilisateur et non plus dans
l'espace noyau.
La structure de RTAI est proche de celle de RTLinux. De même, les fonctionnalités

du type FIFO de communication ou mémoire partagée sont également
disponibles avec RTAI.
http://www.rtai.org
47
48

Fichier Cours TR GLSR 09 Chap1 Rc1

Transféré par

Droits d'auteur :

Formats disponibles

Fichier Cours TR GLSR 09 Chap1 Rc1

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Fichier Cours TR GLSR 09 Chap1 Rc1

Transféré par

Droits d'auteur :

Formats disponibles

Les Systèmes Temps Réels

ENSPS 3A, spécialité GLRS (édition 2009-2010)

Ecole Nationale Supérieure de Physique de Strasbourg

Université de Strasbourg, FRANCE

« Les systèmes d'exploitation » Conception et mise en oeuvre

« Systèmes d'exploitation : concepts et algorithmes »,

« Programming for the real world – POSIX 4 »

« Ordonnancement temps réel »

« Commande en temps réel: conception et mise en œuvre d’un exécutif multitâches

Chapitre 2 : Multiprogrammation et ordonnancement

Chapitre 3 : Mise en œuvre : signaux, gestion du temps et multi-activités

Chapitre 4 : Protection et communication rapide entre processus locaux

Un système temps réel est un système d’exploitation (SETR) ou un ensemble

• Un système temps réel interagit avec un environnement extérieur et en évolution.

TEMPS REEL DUR

• Les systèmes à contraintes temporelles dures ne tolèrent qu’une gestion stricte du

– exemple: les contrôles de processus industriels sensibles comme la régulation des

• Ces systèmes garantissent un temps maximum d'exécution pour chaque tâche. On a

TEMPS REEL MOU

• Ces systèmes se rapprochent fortement des systèmes d'exploitation classiques à

• On a ici une répartition égalitaire du temps CPU entre processus.

• Il ne faut pas confondre contrainte temporelle (qui dépend de l'application et de

• Un système temps-réel inclut généralement différents sous-systèmes chacun

• Il peut être nécessaire de pouvoir modifier ces paramètres en cours d'exécution et

DECOUPAGE EN TACHES OU EN PROCESSUS (concurrents)

Dans le monde réel les périphériques et l'environnement du système évoluent

• L'exécution des applications temps réel se fait généralement dans un

Tâches ou processus exécutés en apparence en parallèle 10

• Dans un tel contexte, quels intérêts a-t-on de concevoir un programme s’exécutant

Tâches ou processus exécutés séquentiellement en réalité (env. mono-processeur) 11

Windows3.1 16/32 bits X non préemptif

Windows95/98/Me 32 bits X coopératif

WindowsNT/2000 32 bits X préemptif

WindowsXP 32/64 bits X préemptif

RESPECT DES ECHEANCES TEMPORELLES : ordonnancement

La limitation des ressources (en particulier du processeur) conduit à bloquer des

• Un ordonnancement consiste à définir un ordre sur l'utilisation des ressources du

• Un algorithme d'ordonnancement est une méthode ou stratégie utilisée pour

RESPECT DES ECHEANCES TEMPORELLES : ordonnancement

Un SETR préemptif est piloté par le temps: le processeur commute de processus en

Algorithmes classiques d'ordonnancement (exemples parmi d’autres…)

– RM (Rate Monotonic) : algorithme à priorité fixe pour processus cycliques (le

– EDF (Earliest Deadline First) : algorithme à priorité dynamique pour processus

– DM (Deadline Monotonic) : algorithme d’ordonnancement préemptif à priorités

• Tâche/processus : suite d’instructions + données + contexte d’exécution (état).

• Classification des tâches/processus :

RESPECT DES ECHEANCES TEMPORELLES : exécutif TR

Exécutif : c’est le cœur d’un système d’exploitation. Son rôle est de :

- Il est composé de modules spécialisés :

• gestion des tâches/processus (commutation, s/r contextes)

- Il ne gère pas les fichiers (fichiers sur disques).

NOYAU vs EXECUTIF vs SETR

Un exécutif temps réel possède un noyau temps réel complété de

Un système d'exploitation temps réel (SETR) est le cas particulier où l'on a

Définition (tentative) : un système informatique est déterministe si le temps

La principale différence entre un OS généraliste (temps partagé) et un OS temps

On trouvera quelques différences dans l’API (norme POSIX):

RESPECT DES ECHEANCES TEMPORELLES : déterminisme et fiabilité (disponibilité)

Les systèmes à contraintes dures doivent répondre à trois critères fondamentaux :

Exemple : programme terminal simplifié