Vous êtes sur la page 1sur 104

Des systèmes classiques aux systèmes

temps réel : mécanismes fondamentaux

Maria ZRIKEM

Ensa de Marrakech

Plan du cours

➢ Gestion multitâches, ordonnancement

➢ Gestion des interruptions et multitâche


➢ Partage des ressources et exclusion mutuelle
➢ Synchronisation

➢ Gestion des Entrées/Sorties


➢ Gestion de la mémoire


Services d’un système élémentaire
Contexte : Un système simple qui exécute un seul programme.
Processeur + Mémoire + E/S + Bus
Programme en interaction avec l’extérieur, et est composé de 3 phases :
• phase d’acquisition des données (E/S),
• phase de calcul,
• phase de restitution des résultats (E/S)
⇒ Le système interagit avec l’environnement à des moments fixes

Si un événement survient à n’importe quel moment et doit être pris par le


système dans un délai max ⇒ Logique STR
✓ Interaction par scrutation cyclique
✓ Interaction par interruption

Interaction par scrutation cyclique


Le processeur scrute (interroge) ses périphériques de manière périodique
pour voir si des données sont prêtes (demande du temps CPU inutile si
aucune donnée n’est disponible) ⇒ Système = boucle infinie

Exemple d’un système avec capteurs et


actionneurs : ⇒ Temps de réaction du système
simple à déterminer.
Faire
⇒ Modèle simple à programmer
Faire si peu de periphs
vérifier capteurs
Tant que données non disponibles ⇐ Perte du temps CPU
Lire capteurs
Traiter les donnée ⇐ Programmation très ardue s’il
y a beaucoup de periphs ou si
Démarrer les réactions les fréquences de traitement
Faire des periphs sont différentes
vérifier les actionneurs ⇐ Insertion d’un nouveau periph
Tant que actions à effectuer impose une remise en cause
Jusqu’à arrêt du système complète de l’existant

Interaction par interruptions


Le programme est averti de la survenue d’un événement par un mécanisme
qui interrompe le cours normal de l’exécution du programme et qui permette
aussi de reprendre le programme là où il a été interrompu ⇒ Interruption
Catégories d’interruptions :
✓ Matérielle : signal physique câblé sur le processeur. Un changement
d’état du signal provoque une rupture de séquence sur le µp. Elle génère
une tâche immédiate.
✓Logicielle (trap, exception) : elle est générée par une application ou par le
système.
Origines d’interruptions
✓ Équipement périphérique externe
✓ Horloge temps réel (occurrence d’un événement signifiant par exemple la
fin d’un délai de garde)
✓ Processus plus prioritaire que le processus actif

Les interruptions sont codifiées en fonction de l’événement auquel elles


correspondent (E/S, horloge, défaut de page de mémoire
5

Interaction par interruptions


Le programme est averti de la survenue d’un événement par un mécanisme
qui interrompe le cours normal de l’exécution du programme et qui permette
aussi de reprendre le programme là où il a été interrompu ⇒ Interruption

• Tâche immédiate : générées par une interruption sur le µp (en général par
une E/S), elles doivent être traitées rapidement et sont toujours plus
prioritaires que les tâches différées. Elles sont traitées par le système
d’interruption
ex : suite à une INT horloge, le SE incrémente son compteur de temps
horloge et décrémente le temps restant à attendre pour des tâches mises en
pause pour une durée fixe.

• Tâche différée : générées par une application logicielle. Elles peuvent faire
l’objet d’une programmation d’ordonnancement spécifique.



Interaction par interruptions


Le contexte d’une tâche se définit comme l’ensemble des éléments
permettant la poursuite de l’exécution à l’instant où une tâche est
interrompue

Un processus se compose de différentes zones mémoires (segments) :


✓ Segment de code (code segment) : contient les instructions codées par le
programmeur (langage machine).
✓ segment de données (data segment) : contient les données modifiées,
stockées et générées par le programme.
✓ segment de pile (stack segment) : contient des données temporaires
(accessibles plus facilement).
✓le tas (heap) : allocation dynamique à la suite du data segment. (non-
systématique).

Interaction par interruptions


Le contexte d’une tâche se définit comme l’ensemble des éléments permettant la
poursuite de l’exécution à l’instant où une tâche est interrompue
État du programme ou contexte d’exécution :
✓ Valeur du compteur ordinal
✓ Pointeur sur l’ensemble des variables locales et privées
✓ Priorité et statut du processus
✓ Contenu des divers registres du processeur
✓ droits d’accès (ressources matérielles et logicielles accessibles)
✓ identificateur de l’état courant.
✓….

Interaction par interruptions


Changement de contexte d’exécution
✓ mise en attente du processus actif
✓ sauvegarde de son contexte d’exécution
✓ recherche (élection) du processus le plus prioritaire
✓ restauration de son contexte d’exécution (charger les registres du
processeur par le contenu qu’ils avaient lorsque le processus choisi
s’exécutait)
Gestionnaire
✓Activation du processus élu d’interruptions
Traitement de
l’interruption
Sauvegarde du Restauration du
contexte contexte

événemen
t

Déroulement normal Déroulement normal


du programme du programme
9

Interaction par interruptions


Scrutation des interruptions
Faire
Faire
vérifier état des 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
INTERRUPTION :
Lire et mémoriser la données
Positionner (état capteurs = données disponibles)
Acquitter l’interruption

Même défauts que le mécanisme précèdent, mais on espère de


meilleurs temps de réponse si les stimuli les plus fréquents peuvent
être traités entièrement sous interruption

10

Interaction par interruptions


Attention

A ne pas mélanger :
• Une interruption matérielle engendre la création d’une tâche immédiate (et
donc prioritaire par rapport à toutes celles dans les les d’attente de
l’ordonnanceur). Cette tâche correspond souvent à une routine (petit
programme en dur)
• une interruption logicielle provoque une commutation de tâches différées.

• une tâche différée peut demander à générer une interruption logicielle si elle
supervise la tâche courante.

11


fi

Limites des approches précédentes
Exemple
• Un programme émet des caractères sur une liaison série via un UART (Universel
Asynchronous Receiver Transmitter)
• UART est un composant électronique qui gère une ligne série, dispose de 2 séries
de registres pour transférer et recevoir des caractères et cause des interruptions
pour l’émission et l’arrivée d’un caractère.
• L’UART émet toutes les ms.
• Le programme ne peut émettre que quand l’UART est prêt ⇒ perd beaucoup de
temps à tester s’il est autorisé à émettre le caractère suivant ou pas.
Mécanisme ATTENDRE-SIGNALER
• Pour émettre un caractère, le programme se bloque en faisant appel à l’opération
ATTENDRE.
• Lorsque l’UART est prêt à recevoir un caractère, il génère une interruption
(TxReady). Le gestionnaire d’interruption correspondant effectue l’opération
SIGNALER et débloque le programme qui peut émettre immédiatement.
Une grande partie du temps processeur est consacrée à autre chose qu’à
l’application
Modèles multitâches

12

Gestion multitâches et Ordonnancement

13
Services des systèmes multitâches
Un système multitâches est un système ou plusieurs programmes
(processus ou tâches) partagent les mêmes ressources du processeur

Gestion plus complexe des ressources par le système d’exploitation :


✓ Exécution d’un programme dans le processeur, éventuellement
concurremment à d’autres (tâches, ordonnancement)
✓ Échange avec le monde extérieur (E/S, interruption)
✓ Gestion de la mémoire
✓ Partage des ressources, synchronisation, communication,
✓ Gestion du temps, horloge

14

Les groupes de tâches dans un systèmes multitâches

▪ Tâches d’entrées/sorties : ces tâches permettent d’accéder aux données


externes par l’intermédiaire de cartes d’entrées/sorties et ensuite de
capteurs et d’actionneurs directement liés au procédé géré. Ces tâches
peuvent être activées de façon régulière ou par interruption.
▪ Tâches de traitement : ces tâches constituent le cœur de l’application. Elles
intègrent des traitements de signaux (analyse spectrale, corrélation,
traitement d’images, etc.) ou des lois de commande.
▪ Tâches de gestion de l’interface utilisateur : ces tâches permettent de
présenter l’état du procédé ou de sa gestion l’utilisateur. En réponse,
l’opérateur peut modifier les consignes données ou changer les commandes.

15

Les groupes de tâches dans un systèmes multitâches

▪ Tâches de communications : ces tâches sont destinées gérer les


messages envoyés ou reçus travers un ou plusieurs réseaux ou bus de
terrain. Si ce type de t ches existe, l’application est dite distribuée ou
répartie.
▪ Tâches de sauvegarde : ces tâches permettent de stocker l’état du
système des instants fixés. Cette sauvegarde peut être utilisée à posteriori
pour analyser le fonctionnement de l’application ou lors d’une reprise
d’exécution une étape précédente.

16






Les groupes de tâches dans un systèmes multitâches
Architecture logicielle d’une application

17
Types de relations dans un systèmes multitâches

▪ Synchronisation : cela se traduit par une relation de précédence


d’exécution entre les tâches ;
▪ Communications : la notion de précédence, traduite par la
synchronisation, s’ajoute le transfert de données entre les tâches ;
▪ Partage de ressources : les tâches utilisent des éléments mis en commun
au niveau du système comme des zones mémoire, des cartes d’entrées/
sorties, cartes réseau, etc. Certaines de ces ressources, comme par
exemple les zones mémoire, ne sont pas ou ne doivent pas être accessibles,
pour avoir un fonctionnement correct, par plus d’une tâche la fois, elles
sont dites ressources critiques.

18


Types de relations dans un systèmes multitâches

Représentation schématique de l’architecture multitâche d’une


application temps réel

19
Gestion multitâches, ordonnancement
États des tâches
blocage
- courante : c’est l’état de la tâche courant En-attente
qui possède le processeur ou
tâche « élue » préemption
- prête : La tâche demande le
processeur, tâche « éligible » allocation
réveil
prêt
- en-attente : la tâche est bloquée
en attente d’un événement
- non opérationnelle (ou hors
service) : elle existe et est présente
en mémoire mais ne demande pas lancement
encore l’UC non opérationnel
opérationnel arrêt
- inexistante : non créée, non
initialisée ou morte. destruction
création destruction
La partie du SE qui fait évoluer les non-existant
états des tâches et qui alloue le
processeur aux tâches est États de création des tâches
l’ORDONNANCEUR (scheduler)
20


Gestion multitâches, ordonnancement
Transitions d’états
• Cour → NonOp : la tâche vient de se blocage
terminer courant En-attente
• Cour → prête : la tâche est interrompue par le SE
préemption
(préemption)
• Cour → attente : la tâche demande au SE d’être allocation
mise en attente, car elle a besoin de qqch qui réveil
prêt
n’est pas encore disponible.
• prête → NonOP : à la demande d’une autre tâche
qui supervise.
• NonOP → prête : à la demande d’une autre tâche lancement
qui supervise.
non opérationnel
opérationnel arrêt
• Prête → attente : à la demande d’une autre tâche
qui supervise. destruction
• en attente → prête (réveil) : délai de mise création
en attente terminée OU événement survenu OU destruction
ressource libérée OU sur demande d’une autre non-existant
tâche qui supervise.
• NonOp → inexistant : libération mémoire.
États de création des tâches

• Inexistant → NonOp : allocation mémoire. 21



Gestion multitâches, ordonnancement
Transitions d’états
Nota Bene :

Une transition a lieu si


• la tâche le demande,
• une tâche supérieure qui supervise le demande,
• le SE en décide ainsi (ordonnancement).
Quand une tâche perd la main, tout son contexte doit être sauvegardé pour qu’une fois
qu’elle la récupère, elle reprenne là où elle en était.
Paradoxe : une commutation de tâches est coûteuse en temps, mais on ne peut pas faire
de temps réel sans cet outil.

22

Structures de données de l’ordonnanceur

Code Code Code


Tâche Tâche Tâche
Application
1 2 3

Contexte Contexte Contexte


Tâche1 Tâche2 Tâche3
Liste
des
tâches État = prêt État = prêt État = prêt
prêtes

Liste Des. T1 Des. T2 Des. T3


des
tâches
en État = État = Systèmes d’exploitation
attente Attente Attente

tâche Des. T4 Des. T5


courante

État =
Courant

Des. T6

23


Politiques d’ordonnancement classiques

✓ L’ordonnanceur a pour rôle d’allouer le processeur aux divers tâches


✓ L’ordonnanceur est une procédure du SE
✓ Lors de l’exécution de son code, une tâche appel le SE (primitive
SIGNALER), Le SE détermine si l’appel justifie un rérdonnancement dans
quel cas il invoquera son ordonnanceur ⇒ l’ordonnanceur prend ses
décisions en ligne (on line)
✓ L’ordonnancement peut aussi être fait hors ligne (off line),
préalablement au démarrage du système
✓ Un ordonnanceur est dit « avec réquisition » ou préemptif, si le
processus courant peut être désalloué par décision de l’ordonnanceur. Il
est dit « sans réquisition » ou non préemptif dans le cas échéant.
✓ Dans un SE non préemptif, une commutation de contexte ne peut avoir
lieu que quand le SE est appelé.
✓Dans un SE préemptif, une interruption peut survenir en n’importe quel
point du déroulement d’une tâche, et provoque une préemption.

24

Politiques d’ordonnancement classiques


tâches et priorités
✓ La priorité d’une tâche est une métrique qui caractérise son importance.
✓ Principe général : plus la tâche est importante et critique du point de
vue temporel, plus la priorité qu’on lui assigne est élevée
✓ Les priorités des tâches peuvent être :
- Statiques : les priorités ne changent pas de valeur pendant
l’exécution de l’application.
- dynamiques : les priorités peuvent changer de valeur pendant
l’exécution de l’application.
Problème d’assignation des priorités
✓La conception des systèmes temps réel rend difficile le processus
d’assignation des priorités aux tâches.
✓ Il est nécessaire de faire une analyse précise, afin de déterminer les
tâches critiques et non critiques du système (surtout pour les systèmes
temps réel avec contraintes dures)

25

Politiques d’ordonnancement classiques


Lois d’ordonnancement classiques
Les lois d’ordonnancement déterminent la politique de choix de la
prochaine tâche qui sera mise dans l’état « courant ». Les lois les plus
répandues à ce jour sont :

✓ Premier arrivé, premier servi – PAPS (FIFO) : les tâches «prêtes» sont
placées dans une file gérée suivant la politique premier arrivé, premier
servi. Une tâche réveillée ou préemptée vient s’insérer en fin de file, et
lorsque la tâche courante termine, ou se bloque en attente, c’est la tâche
en tête de file qui devient la tâche courante
• algorithme non-préemtif.
• + : simple à mettre en oeuvre.
• - : inadapté au temps réel (respect des contraintes de temps non garantissable).

26


Politiques d’ordonnancement classiques
Lois d’ordonnancement classiques
✓ Le tour de rôle ou tourniquet (round robin) : les tâches sont placées
dans une file PAPS et sont activées périodiquement. La période
d’activation s’appelle un quantum du temps. A la fin d’un quantum, la
tâche qui est activée est placée à la fin de la file et la tâche qui est en tête
de file est activée.
• algorithme non-préemtif.
• fonctionnement en FIFO avec commutation à chaque quantum.
• nouvelle arrivante placée en queue de le.
• + : assurance d’un partage de l’UC.
• - : ajustement du quantum très délicat, pas de possibilité de prendre en compte une
tâche urgente.

27

fi

Politiques d’ordonnancement classiques


Lois d’ordonnancement classiques
✓ L’ordonnancement par priorité : une priorité est associée à chaque
tâche. Si l’ordonnanceur met en œuvre une politique de priorités
préemptives, la tâche courante (non bloquée) est toujours la plus
prioritaire; s’il met en œuvre une politique de priorité non préemptives,
c’est la tâche prête la plus prioritaire au moment de la décision
d’ordonnancement qui devient la tâche courante.
• algorithme préemtif.
• fonctionnement en FIFO ou tourniquet pour tâches de même priorité (politique
mixte).
• + : traitement de tˆaches urgentes possible (solution retenue pour les systèmes
temps réel).
• - : assignation des priorités délicate, risque de ”famine” pour les tâches peu
prioritaires.

28

Politiques d’ordonnancement classiques


Exemple 1 : Tourniquet
✓Trois tâches T1, T2 et T3 à exécuter, de durées respectives 6, 3, 4
✓Les tâches démarrent à l’instant 0, et leur ordre d’arrivée est T1, T2, T3
✓ Le quantum de temps est d’une unité de temps

T1 T2 T3 T1 T2 T3 T1 T2 T3 T1 T3 T1 T1

Exemple 2 : Priorité
✓Les 3 tâches T1, T2 et T3 à exécuter ont des priorités respectives 1, 2, 1
(2 étant le niveau de priorité le plus élevé)

T2 T2 T2 T1 T1 T1 T1 T1 T1 T3 T3 T3 T3

Exemple 3 : Ordonnancement mixte (priorité avec tourniquet)


✓La gestion de chaque niveau de priorité s’effectue en tourniquet

T2 T2 T2 T1 T3 T1 T3 T1 T3 T1 T3 T1 T1

29

Politiques d’ordonnancement classiques

Exemples d’ordonnancement avec interaction entre tâches

✓ Exemples combinant priorité et tourniquet


✓ La tâche 1 est la tâche courante au début de l’exemple
✓ Les priorités sont ordonnées en ordre croissant : le plus petit numéro
correspond à la priorité la plus faible
✓ ATTENDRE est une primitive du SE qui provoque la mise en attente de
la tâche
✓ SIGNALER est adressé à la tâche qui s’est mise en attente et aura
pour effet de la débloquer.
✓ T[x.n] : la n-ieme suite d’instructions de la tâche x

30

Exemples d’ordonnancement avec interaction entre tâches


Exemple 1
tâche 1 (prio =2) tâche 2 (prio =1)

T[1.1] T[2.1]
ATTENDRE(evt) SIGNALER(tâche1,evt)
T[1.2] T[2.2]

tâche 1 (prio =2) tâche 2 (prio =1)


T[1.1]
Enchaînement des ATTENDRE(evt)
actions T[2.1]
SIGNALER(tâche1,evt)
T[1.2]
attendre (evt)
T[2.2]

tâche 1 T1.1 T1.2

Diagramme
T2.1 T2.2
temporel
tâche 2
temps
signaler (tâche1,evt)

31

Exemples d’ordonnancement avec interaction entre tâches


Exemple 2 Enchaînement des actions
tâche 1 (prio =2) tâche 2 (prio =1) tâche 1 (prio =2) tâche 2 (prio =1)
T[1.1] T[1.1]
ATTENDRE 1 seconde T[2.1]
ATTENDRE 1 seconde
T[1.2] ATTENDRE (evt)
SIGNALER(tâche2,evt) T[2.2] T[2.1]
T[1.3] ATTENDRE (evt)

(♦) tâche de fond au plus une seconde
T[1.2]
SIGNALER(tâche2,evt)
Attendre (1 S) T[1.3]
T[2.2]

tâche 1 T1. signaler (tâche1,evt)


T1. T1.
1
attendre (evt) 2 3
Signaler
tâche 2 T2.1 (tâche2,evt) T2.2 Diagramme
temps
temporel
tâche de fond`
Au plus 1 S
32

Exemples d’ordonnancement avec interaction entre tâches


Exemple 3
tâche 1 (prio =2) tâche 2 (prio =2) tâche 3 (prio =3)

T[1.1] T[2.1] Non démarrée


SIGNALER (tâche1,evt) T[3.1]
ATTENDRE (evt) T[2.2] ATTENDRE (1 seconde)
T[1.2] Démarrer Tâche3 T[3.2]

♦ S’il y a préemption
attendre (evt)

T1. T1.
T1 1 2
signaler (tâche1,evt)
Démarrer tâche3
T2.1 T2.2
T2
Attendre (1 S)

T3. T3.
T3 1 2

T fond` 1 seconde
temps

33

Exemples d’ordonnancement avec interaction entre tâches


Exemple 3
tâche 1 (prio =2) tâche 2 (prio =2) tâche 3 (prio =3)

T[1.1] T[2.1] Non démarrée


SIGNALER (tâche1,evt) T[3.1]
ATTENDRE (evt) T[2.2] ATTENDRE (1 seconde)
T[1.2] Démarrer Tâche3 T[3.2]

♦ S’il n’y a pas préemption


attendre (evt)

T1. T1.
T1 1 2
signaler (tâche1,evt) Démarrer tâche3

T2.1 T2.2
T2
Attendre (1 S)

T3. T3.
T3 1 2
Reste 1 S
T fond` temps
1 Seconde

34

tâches et priorités
Modèle de tâches avec noyau non préemptif (multitâche coopératif)
✓ temps de réponse a une interruption très court .
✓ possibilité d’utiliser des fonctions non-réentrantes
✓ moins de protection sur les données partagées
✓ temps de réponse du système plus élevé et non déterministe.

Modèle de tâches avec noyau préemptif


✓ temps de réponse rapide et déterminé.
✓ utilisation de fonctions réentrantes obligatoires
✓ protection adéquate des données partagées
✓ le modèle le plus utilisé pour le temps réel

35

Politiques d’ordonnancement classiques


Limites de ces mécanismes pour le temps réel

Par opposition aux systèmes basés sur l’allocation successives de quota


de temps à chaque tâche, les exécutifs temps réel multitâches offrent
généralement une politique d’ordonnancement préemptive basée sur les
priorités. A partir de cette politique l’application est divisé en tâches dont
le traitement est plus urgent pour certaines que pour d’autres. On essaye
de satisfaire d’abord les traitements les plus urgents.

L’application est testée pour contrôler le bon respect des contraintes


temporelles. Si elles ne le sont pas, on se retourne généralement vers
plus de puissance de traitement. Cette approche à ses limites : affecter
des priorités n’est pas toujours une garantie de maîtrise des contraintes;
il n’est pas toujours évident que le système soit toujours en position de
donner du temps processeur aux tâches de plus fortes priorités.

36

Gestion des interruptions et multitâche

37
Gestion des interruptions et multitâche

Étapes de prise en compte des interruptions


1. Aiguillage des interruptions : généralement entièrement réalisée par le
matériel
✓ Sauvegarder le contexte de la tâche courante,
✓ Déterminer la source de l’interruption : contenu du registre mot
d’état des composants matériels.
✓ Invoquer le gestionnaire d’interruption correspondant.

Le matériel fournit une notion de priorité associée à une interruption.


On peut interdire la prise en compte des interruptions par des
instructions spécifiques du processeur : soit interdire l’ensemble des
interruptions du système, soit les interdire de façon individuelle en
agissant par masque sur le mot de contrôle des différents sources
d’interruption ⇒ l’interruption est dite inhibée
Lorsque plusieurs interruptions arrivent en même temps, la plus
prioritaire est traitée immédiatement.

38

Gestion des interruptions et multitâche

Étapes de prise en compte des interruptions


2. Relation entre gestionnaire d’interruption (GI) et tâche

Dans le cas où le traitement associé à une interruption est très court, il


n’est pas nécessaire d’appeler une tâche spécifique pour effectuer le
traitement

⇒ On reste dans le contexte du gestionnaire d’interruption

39

Gestion des interruptions et multitâche

Étapes de prise en compte des interruptions


2. Relation entre gestionnaire d’interruption (GI) et tâche
Dans le cas où le traitement est très long ou complexe, on associe une
tâche au gestionnaire d’interruption et on utilise le mode ATTENDRE-
SIGNALER : la tâche chargée d’effectuer le traitement se bloque en
appelant ATTENDRE. Lorsque l’interruption arrive, le gestionnaire
d’interruption exécute son code et débloque la tâche de traitement
correspondante en faisant appel à SIGNALER. Pendant le traitement,
l’interruption correspondante est masquée de façon à ne pas
interrompre le travail en cours par l’arrivée de la même interruption.
A la sortie du gestionnaire d’interruption, Il se peut que d’autres
interruptions soient en attente, les autres gestionnaires d’interruptions
seront exécutés avant d’entrer dans le code de la tâche associée au
premier gestionnaire.

40

Gestion des interruptions et multitâche

Étapes de prise en compte des interruptions


3. Activation de la tâche associée a une interruption

A la sortie du gestionnaire d’interruption, si la tâche qui a été


interrompue exécutait une primitive du système d’exploitation
qui inhibe la préemption, il faut attendre la fin de cette primitive.
L’ordonnanceur est appelé ensuite pour sélectionner la tâche
qui doit prendre le processeur.
Le changement de contexte a lieu si la tâche sélectionnée est
différente de la tâche courante.

41

Gestion des interruptions et multitâche

Étapes de prise en compte des interruptions

42
Gestion des interruptions et multitâche
Bilan temporel du traitement des interruption
✓ Temps de commutation : temps moyen pris par le système pour
commuter entre deux tâches
✓ Temps de sélection : temps moyen pris par le système pour déterminer
l’identité de la prochaine tâche courante
✓ Temps de préemption : temps de sélection + temps de commutation
✓ Temps de latence des interruptions : intervalle du temps entre le moment
ou le processeur reçoit l’interruption et le moment ou la premier
instruction du gestionnaire d’interruption est exécutée
✓ Temps de latence d’entrée dans la tâche ou temps de réponse :
Temps de traitement de l’interruption + Temps de préemption +
Temps de latence des interruptions

43

Gestion des interruptions et multitâche

Bilan temporel du traitement des interruption

⇒ Délai dû au matériel qui termine l’instruction courante, puis fait le


branchement sur le gestionnaire d’interruption,

⇒ Délai dû au gestionnaire d’interruption (sauvegarde de contexte,


service de l’interruption, restauration du contexte),

⇒ Délai dû au SE qui détermine le besoin de changer le contexte et


effectue la commutation.

44

Gestion des interruptions et multitâche


Bilan temporel du traitement des interruption

sélection
éventuelle commutation
entrée dans le
arrivée IT sortie début des instructions
gérant d’IT
de la tâche courante

matériel gestionnaire traitement nouvelle tâche


d’IT d’éventuelles courante
autres ITs

temps de latence des ITs temps de préemption

+ = Temps de réponse

45

Gestion des interruptions et multitâche

Pour gérer les interruptions, il faut également être capable :


- de stocker les interruptions en le d’attente,
- de déterminer l’origine d’une interruption (directe, scrutation, vectorisation).

46
fi

Gestion des interruptions et multitâche


Limites de ces mécanismes pour le temps réel

Les SE classiques n’offrent pas de garantie sur le temps de latence des


ITs. Accéder à un niveau aussi proche du matériel est, la plupart du
temps, réservé à des programmes spéciaux tels que les gestionnaires
de périphériques.

Les SE dits “temps réel” offrent des niveaux de priorité suffisants pour
répartir les degrés d’urgence des interruptions. Pour éviter que les
interruptions causent trop d’aléas dans le comportement temporel des
tâches, on préfère déporter le traitement effectif lié à une IT, vers le
domaine applicatif, pour ne garder que le strict minimum dans le
gestionnaires d’Its (les traitements qui ne peuvent pas attendre). Ce
minimum peut être évalué et constitue un paramètre fixe du système.

47

Partage des ressources et exclusion mutuelle

48
Partage des ressources et exclusion mutuelle
Présentation du problème

• Exemple d’une séquence d’opérations « Lire/ Tâche 1 Tâche 2


modifier/écrire » sur une variable globale
Lire A Lire A
A=A+10 A=A+30
• 2 tâches mettant en jour une même variable A Ecrire A Ecrire A

Suite a une interruption, T2 préempte T1. On a le scénario suivant :


Tâche 1 Tâche 2 • Séquence atomique : suite d’opérations exécutées
par un système qui permet de passer d’un état
Lire A cohérent du système a un autre état cohérent sans
possibilité d’interruption durant la séquence.
Lire A
A=A+30 • Section critique: séquence d’opérations qu’iI faut
Écrire A effectuer de façon atomique.
• les sections critiques portant sur des ressources
A=A+10 communes doivent être exécutées en exclusion
Écrire A mutuelle.

49

Partage des ressources et exclusion mutuelle


Ressources partagées
• Une ressource est une entité utilisée par une tâche (dispositif I/O, tableau,
variable, structure de données, …)
• Une ressource partagée est une entité utilisée par plusieurs tâches
• Certaines ressources peuvent être corrompues si consultées par plusieurs
tâches simultanément
Il faut obtenir l’accès exclusive à une telle ressource avant de l’utiliser.
Si l’accès exclusif n’est pas obtenu, l’ordre d’exécution des tâches
pourrait altérer les résultats.

Réentrances des fonctions

• Pour éviter la corruption des données, les routines d’une applications


temps réel doivent être réentrantes
• Une fonction réentrante est une fonction dont les résultats ne sont pas
altères si elle est exécutée par plusieurs tâches

50

Partage des ressources et exclusion mutuelle


Mécanismes pour assurer la réentrances des fonctions

• utiliser seulement des variables locales;


• garder par des sémaphores l’accès aux variables partagées
(globales ou statiques);
• désactiver les interruptions ou l’ordonnanceur avant d’accéder
aux variables globales ou statiques.

51

Mécanismes d’exclusion mutuelle


Masquage par verrou

Si deux tâches veulent utiliser une même ressource elle peuvent


convenir d’utiliser une variable (var_acces) pour signaler que la
ressource est “occupée”.

l’algorithme :

Si (var_acces =0) alors


var_acces = 1;
acceder_ressource;
var_acces = 0;
Ffsi

52



Mécanismes d’exclusion mutuelle


Masquage par verrou

Si une interruption arrive pendant cette séquence : que peut il se passer ?

l’algorithme :

interdire_interruption;
Si (var_acces =0) alors
var_acces = 1;
autoriser_interruption
acceder_ressource;
interdire_interruption;
var_acces = 0;
autoriser_interruption;
Fsi
autoriser_interruption;

53






Mécanismes d’exclusion mutuelle


Masquage matériel

C’est la méthode la plus radicale pour assurer l’atomicité d’opérations.


Elle consiste à masquer les interruptions et à n’effectuer aucun appel
au système susceptible de provoquer une préemption ⇒ aucun code
autre que celui de la tâche courante ne peut être exécuté.

✓ ne devra être utilisée que pour des séquences très (c’est aussi le seul
moyen de protéger une ressource et/ou un traitement utilisé par une
interruption)

✓ permet d’assurer l’atomicité d’une séquence vis à vis à la fois des


interruptions et des tâches

54

Mécanismes d’exclusion mutuelle


Masquage logiciel
Consiste à inhiber l’ordonnancement pendant le déroulement de la
section critique.

2 primitives sont fournies par le SE temps réel :


⇒ DébutSection qui inhibe l’ordonnancement
⇒ FinSection qui l’autorise.

✓Si une tâche plus prioritaire que la courante a été activée durant la
section critique, elle la préempte lors de l’exécution de FinSection.

✓Ne permet d’assurer l’atomicité que vis à vis des tâches. Durant la
section critique les interruptions sont gérées normalement.

55

Mécanismes d’exclusion mutuelle


Sémaphores

✓ Introduit en 1960 par Edgser Dijkstra.


✓ Protocole très utilisé dans les SEs multitâches.
✓ Contrôler l’accès à une ressource partagée.
✓ Exclusion mutuelle (mutex).
✓ Signaler des événements.
✓ Synchroniser des tâches.

56

Mécanismes d’exclusion mutuelle


Sémaphore binaire

✓ Le sémaphore est la clé pour accéder à la ressource,


✓ Si je veux accéder à la ressource “je demande la clé”,
✓ J’accède à la ressource, je rends la clé.
✓ Si la clé est prise, j’attends la ressource pour y accéder.

57

Mécanismes d’exclusion mutuelle


Sémaphore binaire

✓ Un sémaphore est une entité logique gérée par le SE, associé de


manière univoque à une ressource
✓ 2 primitives P et V permettent de manipuler le sémaphore
✓ Toute section de code manipulant une ressource critique commence par
requérir le sémaphore; cette opération notée P(Sémaphore) correspond
à une entrée en section critique. Elle peut provoquer la préemption de la
tâche invoquante si un P a déjà été effectué sur le même sémaphore.
✓ A fin de la section de code critique, le sémaphore est libéré, cette
opération notée V(Sémaphore) correspond à une sortie de la section
critique. Elle peut provoquer la préemption de la tâche invoquante si
une tâche plus prioritaire était bloquée à la suite du P correspondant.
Un sémaphore est implémenté sous forme d’un compteur initialise à 1
et une file d’attente de tâches.

Tâche 1 Tâche 2 Tâche 1 Tâche 2

P(S) P(S) Interblocage P(Metex) P(Mutex)


I=I+J I=I-K Attendre(evt) Signaler(T1,evt)
V(S) V(S) V(Mutex) V(Mutex)

58

Mécanismes d’exclusion mutuelle


Sémaphore binaire (algorithme)

P
cpt = cpt -1
si cpt < 0 alors
interrompre tâche;
file <- ;
sinon donner acces;
V
cpt++;
si cpt >= 0 alors sortir_tache_file;
Initialiser
cpt = 1;

59







Mécanismes d’exclusion mutuelle


Exemple

Toutes les tâches ont P en entrée et V en sortie et partage un


sémaphore S pour la ressource I

Donner le comportement du sémaphore S et de la file F

60

Mécanismes d’exclusion mutuelle

61
Mécanismes d’exclusion mutuelle

62
Mécanismes d’exclusion mutuelle

✓ T2 est mise en attente


✓ T1 est en attente de T2
✓ Solution :
✓ délai d’attente

63

Mécanismes d’exclusion mutuelle


Sémaphore à n position

✓On utilise un sémaphore à n positions (ou compteur) quand plusieurs


tâches peuvent utiliser une même ressource
✓exemple : tampon d’impression
✓Initialisation de S à la valeur n (nombre de positions)

P V
cpt = cpt -1 cpt++;
si cpt < 0 alors si cpt >= 0 alors
sortir_tache_file;
interrompre
tâche;
file <- tache
sinon donner acces Initialiser
cpt = n

64

Mécanismes d’exclusion mutuelle


Limites de ces mécanismes pour le temps réel : sémaphore et priorité

A partir du moment ou une tâche a acquis une ressource (passe le P), toutes
les tâches parvenant à un P sur le même sémaphore resteront bloquées,
quelles que soit leur priorité.

Lorsque la tâche libère la ressource, le choix de la tâche passant de l’état


« en attente » à l’état « actif » peut se faire soit selon un loi FIFO, soit suivant
la priorité des tâches en attente. Toutefois, la loi des priorités est risquée
dans le cas d’une ressource fréquemment accédée : les tâches de faible
priorité n’ont que peu de chance d’arriver à l’acquérir

65

Mécanismes d’exclusion mutuelle


Limites de ces mécanismes pour le temps réel : sémaphore et priorité

Il est nécessaire d’appliquer l’exclusion au niveau approprié : par exemple


l’émission d’un caractère sur une ligne série requiert l’usage d’un sémaphore
pour préserver les registres de l’UART. Si on se contente de cela et que 2
tâches tentent d’émettre simultanément deux messages de 10 caractères
chacun, les 20 caractères des 2 messages seront émis mais mêlés entre eux.
Il est donc nécessaire d’appliquer l’exclusion à un niveau plus haut, à savoir
celui de l’émission d’un message.

66

Synchronisation : Purquoi?

▪ Partage de ressources : garantir que l’exécution en parallèle de


plusieurs processus fournit le même résultat qu’une exécution
strictement séquentielle (pas d’interférences)

▪ Communication, coopération : garantir que l’échange


d’information entre tâches obéit à un protocole défini.

67

Synchronisation

La synchronisation consiste à imposer un ordre sur l’exécution


des instructions des processeurs. Notons que l’exclusion mutuelle
est un cas particulier de synchronisation ; un processus ne peut
rentrer en section critique que quand le précèdent a terminé
l’exécution de sa section critique.

Parmi les modèles de gestion de la synchronisation fréquemment


rencontrés dans les systèmes : l’exclusion mutuelle, le rendez-
vous et les modèles « producteur - consommateur »

Plusieurs types :
- Directe : les tâches en relation connaissent leurs « identité » respectives,
- Indirecte : pas besoin d’identi cation .

68

fi

Synchronisation
Méthode directe : tâche B supervise tâche A
• deux variables booléennes : ETAT (0 = bloquée, 1 = éveillée), FANION (1 = signal
d’éveil envoyé
• deux primitives : BLOQUER() et EVEILLER(A)

BLOQUER () (appelée par A) :


Si FANION = 1 alors FANION ← 0
Sinon appel système pour passer en attente, ETAT ← 0
EVEILLER (A) (appelée par B) :
Si ETAT = 0 alors appel système pour réveiller A, ETAT ← 1
Sinon FANION ← 1

69
)

Synchronisation

Méthode indirecte : par sémaphore


Sémaphore S initialisé à 0, le code de la tâche A contient un P (S) et celui de
la tâche B un V (S) ⇒ A est bloquée tant que B n’a pas fait toutes les
instructions précédant le V (S).

70

Synchronisation : solutions

Une solution au problème de l’exclusion mutuelle est correcte si elle vérifie


les propriétés :

❑ La solution est indépendante de la vitesse d’exécution des programmes.

❑ Deux processus (ou plus) ne peuvent se trouver simultanément en


section critique.

❑ Un processus hors de sa section critique et qui ne demande pas à y


entrer ne doit pas empêcher un autre d’entrer en section critique.

❑ Deux processus ne doivent pas s’empêcher mutuellement et


indéfiniment d’enter en section critique (interblocage).

❑ Un processus entre toujours en section critique au bout d’un temps fini


(pas de famine).

71

Synchronisation
La signalisation par événement

✓ exemple classique : une tâche attend un traitement effectua par un


périphérique. Une fois terminé, le périphérique lève une interruption, la
routine signale l’événement, la tâche en attente peut continuer.
✓ l’événement peut être global (concerne toutes les tâches, ou un groupe de
tâche) ou local (une tâche en particulier)
✓ une variable booléenne Ev ( 0 = non arrivé, 1 = arrivé)
✓ une file d’attente F (Ev)
✓ trois primitives SIGNALER(), ATTENDRE() et RESET()

72

Synchronisation
La signalisation par événement
SIGNALER() (appelé par routine ou tâche) :
Ev ← 1
répéter
si F (Ev) ̸ = ∅ alors
appel système pour débloquer le processus en attente
fin si
jusqu’`a F (Ev) = ∅

73

Synchronisation
La signalisation par événement
ATTENDRE() (appelé par la ou les tâche(s) ayant besoin du signal) :
si Ev = 0 alors
insérer la tâche dans F (Ev)
fin si

RESET () (appelé par une tâche satisfaite) :


Ev ← 0
vider F (Ev)

Remarques :
Attention à ne pas effacer un signal avant de l’avoir pris en compte

74

Synchronisation
La signalisation par événement

✓La raison première du mécanisme de signalisation Attendre-signaler, est


de récupérer les temps morts, i. e. les temps de traitement par les
périphériques du processeur. Mais on trouve également des signalisations
entre tâches.
✓L’interprétation d’un mécanisme de signalisation est simple pour un
scénario dans lequel l’appel à ATTENDRE est effectué avant l’appel de
SIGNALER. Dans le cas contraire, différentes classes de mécanismes se
rencontrent :
- les mécanismes à impulsion ou événement global, dans lesquels la
signalisation est perdue si personne ne l’attendait.
- les mécanismes à état ou événement local, dans lesquels la
signalisation est mémorisée.

75

Synchronisation
Dans les mécanismes de
signalisation vus jusqu’ici, la tâche
émettrice poursuit son exécution Tâche 1 Tâche 2
sans se soucier de la tâche
réceptrice. Ceci oblige Signaler(tâche2,evt)
Attendre(evt)
fréquemment à gérer des Traiter le signal
Attendre(ask)
Signaler(tâche2,ask)
acquittements par retour de
signalisation.

76

Synchronisation

La signalisation par sémaphore

Le sémaphore utilisé pour assurer l’exclusion mutuelle peut


être vu comme une signalisation avec effacement automatique.
La tâche effectuant le V signale la disponibilité de la source à
celle qui avait fait un P sur le même sémaphore : cette dernière
tâche peut alors poursuivre son exécution. Si un V est effectué
alors que personne ne l’attend, il reste mémorisé jusqu’au
prochain P. Dans ce contexte, une tâche appelle toujours V
après avoir appelé P.

77

Synchronisation
Synchronisation par rendez-vous
Dans les mécanisme de rendez-vous, les tâches émettrices et
réceptrices doivent se bloquer au point de rendez-vous pour que la
synchronisation ait lieu

Le rendez-vous à N points d’entrées :

• N tâches (au max) peuvent demander un rdv,


• besoin d’un compteur de tâches en attente CPT
• besoin d’un système de masquage pour rendre le code gérant le rdv
ininterruptible
• besoin de signaux pour gérer la file d’attente des tâches

78


Synchronisation
Synchronisation par rendez-vous

Le rendez-vous à N points d’entrées (code générique):

RDV init() :
mutex ← 1
CPT ← 0 (nbr de tâches arrivées)

79

Synchronisation
Synchronisation par rendez-vous

Le rendez-vous à N points d’entrées (code générique):

RDV proc() :
P (mutex)
CPT ← CPT + 1
si CPT < N alors
V (mutex)
ATTENDRE()
sinon
service éventuel
SIGNALER(all) (réveil des tâches par diffusion)
CPT ← 0
V (mutex)
fin si

Remarque : pas forcément besoin de connaître l’identité des tâches


entrantes. 80

Synchronisation
Communication entre tâches

Communication = synchronisation + transmission de données.


Techniques les plus répandues
• une variable globale,
• le schéma producteur-consommateur,
• la boîte aux lettres,
• le tube.

81

Synchronisation
Communication entre tâches : Le schéma producteur-consommateur
• un tampon est alloué et sert à déposer des messages fournis par des
producteurs.
• les consommateurs accèdent en lecture au tampon et libèrent un
emplacement par lecture.
• le tampon a une taille limitée de N messages.
• dans un tube, pas de limite sur N.

82

Synchronisation
Communication entre tâches : Le schéma Boites aux lettres
• un tampon est alloué et sert à déposer des messages fournis par des
producteurs.
• les consommateurs accèdent en lecture au tampon et libèrent un
emplacement par lecture.
• le tampon a une taille limitée de N messages.
• dans un tube, pas de limite sur N.

83

Synchronisation
Communication entre tâches : Le schéma Boites aux lettres
✓ Les boites aux lettres permettent de gérer un mécanisme d’échange de messages
asynchrones. Un message est généralement de taille limitée (un mot mémoire)
mais il peut présenter un pointeur vers une zone mémoire plus étendue.
✓ identique au schéma producteur-consommateur mais tous les messages sont au
même format.
✓ La boite aux lettres est un objet gérée par le SE dont l’état est composée d’une file
de messages et d’une file de tâches. A tout moment, l’une des deux files est vide.
✓ 1 sémaphore place correspond à des jetons de places disponibles dans le tampon
(init à N),
✓ 1 sémaphore mail correspond à des jetons de messages disponibles dans le
tampon (init à 0),
✓ le dépôt de message doit être non interruptible,
✓ La boite aux lettres offre aux tâches les mécanismes d’envoi et de réception (send
et receive) :

84

Synchronisation
Synchronisation par les données : les boites aux lettres
La boite aux lettres offre aux tâches les mécanismes d’envoi et de
réception (send et receive) :

- la primitive Receive(mailbox, out message) est bloquante pour une


tâche qui désire recevoir un message alors que celui-ci n’a pas
encore été envoyé : les tâches qui se trouvent dans cet état sont
placées dans une file associée à la boite aux lettres.

- la primitive Send(mailbox, in message) n’est pas bloquante pour la


tâche qui l’invoque. Les tâches sont envoyés à destination de la
BL. Tant qu’il y’a des tâches en attente de réception, les messages
envoyés sont consommés immédiatement. Si aucune tâche ne
s’est mise en attente de la réception alors le message envoyé est
stocké dans une file d’attente associée à la BL.

85

Synchronisation
Exemple 1 : sémaphores pour synchroniser deux tâches
Les sémaphores s1 et s2 sont initialisés à 0 et sont donc bloquants pour
la primitive P. S1 est associe à la ressource x et s2 à la ressource y.

La tâche 2 ne lit x que si la tâche 1 a écrit dans x. De même la tâche 1 ne


lit y que si la tâche 2 a écrit dans y

Tâche 1 Tâche 2

Tantque (true)
Tantque (true)
{ autres traitements;
{ P(s1);
écrire (x);
Lire (x);
V(s1)
autres traitements;
Autres traitements;
écrire (y);
P(s2);
V(s2)
Lire (y);
Autres traitements;
}
}

86

Synchronisation
Exemple 2 : tampon mémoire borné (producteur consommateur)

✓ Un système comporte 2 tâches, l’une produit des informations


(producteur), l’autre utilise ces informations (consommateur). Les 2
tâches communiquent via des zones mémoires tampon :
- Le producteur acquiert un tampon vide d’un ensemble de tampons
vides, remplit les informations et rend le tampon à un ensemble de
tampons pleins
- Le consommateur obtient les informations en accèdent à un tampon
rempli, il copie alors les informations et restitue le tampon à
l’ensemble des tampons libres.
✓ Le nombre de tampons est limité à N.
✓ On a besoin d’exclusion mutuelle pour l’accès au tampon :
- Il ne faut pas que le système donne le même tampon simultanément
au producteur et au consommateur
- Si tous les tampons sont pleins, le producteur doit attendre,
- Si tous les tampons sont vides, le consommateur doit attendre

87

Synchronisation
Exemple 2 : tampon mémoire borné (producteur consommateur)
Sémaphore s = 1; --- protége l’accès au tampon
Sémaphore plein = 0; --- présence d’un tampon contenant un message
Sémaphore vide = N --- limite à N le nombre de tampon
Buf_type tampon[N];

producteur( ) Consommateur( )
Buf_type *suivant, *ici Buf_type *suivant, *ici
Tantque (VRAI) Tantque (VRAI)
{ produire_elemt(suivant); { --- message à consommer
--- y a-t-il un tampon vide? P(plein);
P(vide); P(s);
P(s); ici = obtenir(plein);
---obtention du tampon V(s);
ici = obtenir(vide); copier_tampon( ici, suivant);
V(s); --- accès au tampon
copier_tampon (suivant, ici); P(s);
P(s); -- met tampon ds liste tampons vides
-- met tampon ds liste tampons pleins libérer (ici, vide);
libérer (ici, plein); V(s);
V(s); V(vide);
--- signale présence tampon plein ---- signale libération du tampon
V(plein); consom_elemt (suivant);
} }
88

Interblocage (Dead Lock)


Définition
Un processus est en état d’interblocage s’il est bloqué en attente d’une
condition qui ne se produira jamais.
Conditions nécessaires :
1. Les processus accèdent en exclusion mutuelle à des ressources critiques.
2. Les processus gardent les ressources acquises pendant qu’ils sont
bloqués en attente d’une ressource.
3 Les ressources acquises par un processus ne peuvent lui être retirées de
l’extérieur.
4 Il existe un cycle de processus où chacun attend une ressource acquise
par un autre.

89

Interblocage : traitement
2 approches :
Prévenir (éviter)
+ prévention (statique)
+ esquive (dynamique)
Guérir (vivre avec)
+ détection
+ récupération

90



Interblocage : prévention
Prévention statique
Il suffit qu’une seule des conditions nécessaires (1, 2, 3, 4) soit fausse :
▪ Pas de partage de ressources (pas intéressant)
▪ Allocation globale des ressources en une seule fois
▪ Libération des ressources acquises avant blocage (allocation conditionnelle)
▪ Ordonnancement de l’allocation des ressources

91

Synchronisation

Limites de ces mécanismes pour le temps réel


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.
Dans un système classique qui traite chaque activité d’une façon
égale, faire passer une activité devant une autre est un prix
acceptable pour assurer la sûreté de fonctionnement de
l’ensemble. Par contre 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 une tâche de plus forte priorité

92

Synchronisation

Limites de ces mécanismes pour le temps réel


Les remèdes classiques sont :
⇒ Gestion des attente par priorité : les files de tâches en attente sont
triées par priorité. La primitives bloquante est donc légèrement
modifiée pour tenir compte de la priorité de la tâche qui l’invoque; les
tâches seront débloquées en fonction de leur priorité; il y a donc un
risque de famine dans le système pour les tâches de plus faible
priorité qui risquent de ne jamais être débloquées.
⇒ Fournir des primitives de « test de disponibilité » : en cas
d’indisponibilité de la ressource, on n’attend pas. La tâche appelante
récupère un statut qui lui permet de continuer son exécution en
sachant qu’elle n’a pas obtenu la ressource espérée.
⇒ Associer un temps d’attente maximum aux primitives bloquantes

93

La mémoire

Rôle : stockage des programmes et des données en cours d’exécution.


▪ adressable par mots de 8, 16, 32 ou 64 bits
▪ découpée en blocs physiques de 64, 128, 256 koctets ou 1 Moctet.
▪ accessible simultanément par plusieurs éléments.
▪ gestion optimisée des temps d’accès.

94

Gestion de la mémoire

Les mécanismes de gestion de la mémoire doivent permettre de


satisfaire aux mieux les besoins en mémoire, en limitant tout
risque d’overflow (débordement) ou de sous utilisation, et en
minimisant l’overhead lors de l’allocation des buffers.
Parmi les différentes organisations de la gestion de la mémoire, on
cite dans un ordre croissant de la complexité :
Technique de swapping (va et vient)

C’est la technique la plus simple. On charge un processus, on


l’exécute jusqu’à son terme, puis on le vide sur disque pour
charger le suivant.
limites pour une utilisation TR
✓ Ne permet pas le parallélisme (une seule zone de données)
✓ Overhead très élevé lorsque l’on doit charger un nouveau
processus

95

Gestion de la mémoire

Technique de partition fixe de la mémoire

La mémoire est partagée en un nombre fixe de zones lors de la


génération du système.
limites pour une utilisation TR
✓ S’il y a plus de processus que de zones, alors une technique de
swapping est nécessaire. Elle peut introduire un overhead
élevé si le multiplexage des zones est important.
✓ Cette technique peut conduire à une mauvaise utilisation de la
mémoire si les besoins des divers processus sont trop
différents
✓ En pratique, cette technique est limitée aux systèmes pour
lesquels le nombre de tâches est fixe et connu à priori

96

Gestion de la mémoire

Technique de partition variable de la mémoire


Le partage en zones est redéfini à chaque fin d’exécution de
processus. La mémoire libérée est alors disponible.
Une conséquence est que les processus sont chargés à des
adresses non connus à l’avance, ce qui impose aux exécutables
d’être relogeables (ce n’est pas le cas pour les deux techniques
précédentes).
limites pour une utilisation TR
✓ Cette technique permet une bonne utilisation de la mémoire,
mais l’overhead liée aux changements de processus est plus
élevé qu’avec une partition fixe.
✓ L’intérêt est limité pour une application temps réel.

97

Gestion de la mémoire
Technique de pagination, mémoire virtuelle mémoire physique découpée
en segments de même taille
Si un processeur accède à que les pages
une page en MV qui n’est à un mapping
moment donné associée à

@ physiques
1
3
aucun segment physique, elle 2
se trouve sur le disque. Le
2
mécanisme de pagination

@ virtuelle
déclanche alors une exception Table des
du type «défaut de page». La pages
routine de traitement du
défaut de page : 3
“défaut de page”
- cherche la place en MPH, 1
mémoire virtuelle
- si besoin, vide un segment Découpée en pages 1
physique sur disque afin de de taille fixe
libérer de la place
- récupère la page manquante
depuis le disque, disque contenant
les anciennes pages
- met à jour la table des pages de la mémoire virtuelle

98

Gestion de la mémoire
Technique de pagination, mémoire virtuelle
limites pour une utilisation TR

✓ La complexité est élevée.


✓ Cette technique nécessite un dispositif matériel MMU (Memory
Managment Unit) pour assurer la conversion des @ virtuelles
manipulées par les tâches en @ physiques. Cela engendre un petit
overhead.
✓ Le temps requis pour rapatrier une page du disque vers la mémoire
physique peut poser problème dans le cas d’une application critique.
✓ Le temps de réponse d’un exécutif n’est pas prévisible du fait de la
présence possible d’un défaut de page.

⇒ Mécanisme de verrouillage mémoire

99

Gestion de la mémoire
Technique de pagination, mémoire virtuelle
Mécanisme de verrouillage mémoire

Pour éviter les problèmes d’indisponibilité des ressources, qui peuvent


empêcher le respect des contraintes temporelles, les STR ont
généralement recours à la préservation des ressources. En cas de la
pagination mémoire, le code et les données des processus TR critiques
sont entièrement verrouillés en mémoire. Ainsi aucun défaut de page ne
peut avoir lieu. La limite de cette technique est que cela réduit la place
disponible pour les autres processus.

100

Gestion des Entrées/Sorties


✓ Problème de première importance du à la grande différence de vitesse
ente les traitements dans l’unité centrale et les E/S
✓ Les SE comportent généralement une couche spécialisée pour le
traitement des E/S.
✓ On distingue les E/S synchrones et les E/S asynchrones

Traitement de l’E/S Traitement de l’E/S


Par le SE Par le SE

En //

Exécution du Poursuite de Exécution du


Exécution du Exécution du
L’exécution
programme Programme programme programme programme
suspendu Demande d’E/S
Demande d’E/S Fin d’E/S Fin d’E/S
Éventuellement
sous-programme
de resynchronisation
101

Gestion des Entrées/Sorties


Limites de ces mécanismes pour le temps réel
Les E/S ont une incidence importante sur l’exécution des processus.
Les problèmes qu’on rencontre dans le cadre TR :
✓ Il est souvent difficile, voire impossible, de borner le temps de
traitement de l’E/S et le temps de blocage et déblocage ou de
resynchronisation des processus associés.
✓ Il est difficile de gérer des priorités entre E/S
⇒ Ceci rend difficile la maîtrise du temps d’exécution
Les remèdes sont :
⇒ Utiliser les E/S asynchrones
⇒ Mettre des limites temporelles aux E/S
Dans le cas du TR, les lectures et écritures dans des fichiers
doivent prendre un temps bien défini. Ceci implique que les
fichiers sont préalloués dans des zones contigües des disques, et
que le SE affecte des priorités aux accès disques.

102

Horloge et gestion de temps


Horloge
■ Horloge (à base d’un quartz) génère des interruptions
⇒ active la tâche horloge

Tâche horloge
■ Temporisation (compteur de temps) : pour sortir des attentes lors de dépassement de délais
■ Réveils :
⇒ signaler des événements (avec/sans période)
⇒ watchdog/chien de garde

103

Horloge et gestion de temps

Limites pour le temps réel


■ Précision des horloges insuffisantes

■ Difficulté de mesurer les aspects temps avec un manque de précision

■ A la charge de l’application de gérer les intervalles de temps

■ Dans les STR outillage de gestion du temps: compteurs d’intervalles gérés par le
matériel (plus de précision)

104

Vous aimerez peut-être aussi