Infor

Systèmes multitâches
Automatismes temps réel
Eric TERNISIEN
IUT de Saint Dié des Vosges 1/152
Département Génie Electrique et informatique Industrielle
Plan
I - Introduction
1 - Historique
2 - Système embarqué et automate différent ?
Eric TERNISIEN
Plan
I - Introduction
1 - Historique
II - Systèmes multitâches
1 - Concepts
2 - Architectures des systèmes multitâches
3 - Les tâches
4 - Le noyau
Eric TERNISIEN
Plan
I - Introduction
1 - Historique
1 - Concepts
3 - Les tâches
4 - Le noyau
III - Systèmes temps réel
1 - Concepts
2 - Composition d’un système temps réel
3 - Types de systèmes temps réel
Eric TERNISIEN
Plan
IV - Les stratégies d’ordonnancement

1 - Généralités
2 - Noyau non-préemptif (coopératif)
3 - Noyau préemptif
Eric TERNISIEN
Plan

V - Communication entre tâches

2 - Synchronisation entre tâches
3 - Partage de ressources et exclusion mutuelle
Eric TERNISIEN
Plan
VI - Automate et multitâche
1 - Rappels
2 - Questions
3 - Ordonnancement des tâches
Eric TERNISIEN
Plan
1 - Rappels
2 - Questions
VII - Automatismes embarqués

1 - Rappels
2 - L’automatisme autrement
3 - Grafcet vs Machine d’états
Eric TERNISIEN
Introduction Historique
Plan
I - Introduction
1 - Historique
Eric TERNISIEN
Avant 1960
Avant 1945 :
I on exécute des jobs de manière séquentielle.
I un seul programme est présent en mémoire.
I programmation en binaire et sans S.E. (ordinateur
avec carte perforées).
Eric TERNISIEN
Avant 1960
Avant 1945 :
1955 :
Des programmeurs du General Motors Research Center
écrivent le premier système d’exploitation : ”a monitor pro-
gram for the IBM 701”.
Eric TERNISIEN
Avant 1960
Avant 1945 :
1955 :
Des programmeurs du General Motors Research Center
écrivent le premier système d’exploitation : ”a monitor pro-
gram for the IBM 701”.
1958 :
Bull sort le Gamma 60, le premier ordinateur multitâche.
Cette machine trop en avance sur son temps sera fabriquée
à 12 exemplaires.
Eric TERNISIEN
1960-1980
1969 :
Ken Thompson de l’AT&T (American Telephone and Telegraph Company)
donne naissance à UNIX premier système multitâche et multi-utilisateur.
Des chercheurs de l’Université de Berkeley apportèrent de nombreuses
améliorations qui conduisirent à la création des versions BSD de Unix (Berke-
ley Software Distribution) qui engendrera NetBSD et FreeBSD, des versions
OpenSource.
Eric TERNISIEN
1960-1980
1969 :
Ken Thompson de l’AT&T (American Telephone and Telegraph Company)
donne naissance à UNIX premier système multitâche et multi-utilisateur.
Des chercheurs de l’Université de Berkeley apportèrent de nombreuses
améliorations qui conduisirent à la création des versions BSD de Unix (Berke-
ley Software Distribution) qui engendrera NetBSD et FreeBSD, des versions
OpenSource.
1974 :
Motorola sort son processeur 6800 et Intel le 8080. Ces
derniers vont être à l’origine de l’essor de l’informatique
embarquée et par conséquent de l’informatique temps réel.
Eric TERNISIEN
1990-2000
1987 :
Apparition de OS/2 premier environnement multitâches
développé conjointement par IBM et Microsoft. A better win-
dows than windows.
Eric TERNISIEN
1990-2000
1987 :
Apparition de OS/2 premier environnement multitâches
développé conjointement par IBM et Microsoft. A better win-
dows than windows.
1994 :
Première version de Linux (1.0) commencée en 1991 et
développé par Linus Torvalds étudiant finlandais de 21 ans en
licence d’info.
Eric TERNISIEN
Et les automates ?
Avant 1970 :
Les automatismes existent sous forme de logique câblée :
I séquenceur pneumatique
I armoire à relais
Eric TERNISIEN
Et les automates ?
Avant 1970 :
Les automatismes existent sous forme de logique câblée :
I séquenceur pneumatique
I armoire à relais
1968 :
Pour répondre à un appel d’offre de General Motors,
Bedford Associates invente le premier automate program-
mable. L’entreprise Modicon se créée pour développer la
fabrication
Eric TERNISIEN
Et les automates ?
1970 :
Premier automate Allen Bradley.
Eric TERNISIEN
Et les automates ?
1970 :
1973 :
Premier automate Siemens. Naissance de la gamme Simatic.
Eric TERNISIEN
Et les automates ?
1970 :
1973 :
Premier automate Siemens. Naissance de la gamme Simatic.
1975 :
Premier automate Télémécanique, le TSP 100.
Eric TERNISIEN
Introduction Système embarqué et automate différent ?
Plan
I - Introduction
1 - Historique
Eric TERNISIEN
Architecture d’un ordinateur

Carte mère Processeur et périphériques
Eric TERNISIEN
Structure externe
Carte embarquée Automate
Eric TERNISIEN
Structure interne
Carte embarquée Automate
Eric TERNISIEN
Pour ou contre ?
I Système embarqué :
X Peu coûteux (PC indus. < 1500e)
X Poids, encombrement et consommation réduits
X Système fragile
X Nécessite des connaissances en programmation
I API :
X Système robuste
X Système facilement maintenable (changement de modules)
X Ajout simple de modules (commande d’axe, module de communication, ...)
X Plus gourmand en énergie et plus volumineux
X Prix plus élevé
Eric TERNISIEN
Systèmes multitâches Concepts
Plan
1 - Concepts
3 - Les tâches
4 - Le noyau
Eric TERNISIEN
Types de systèmes informatiques

1 Systèmes transformationnels (calcul scientifique, gestion de BD)
X les données sont disponibles au lancement.
X les instants de production des résultats ne sont pas contraints.
Eric TERNISIEN

2 Systèmes interactifs (systèmes transactionnels, outils bureautiques)

X les résultats dépendent de données produites par l’environnement.
X les instants de production dépendent de la dynamique du procédé.
Eric TERNISIEN

2 Systèmes interactifs (systèmes transactionnels, outils bureautiques)

X les résultats dépendent de données produites par l’environnement.
3 Systèmes réactifs ou temps réel

X résultats entièrement conditionnés par l’environnement connecté.
Eric TERNISIEN
Qu’est-ce qu’un système multitâche ?

Définition
Un système est dit multitâche s’il permet d’exécuter, de façon (apparemment)
simultanée, plusieurs programmes informatiques. On parle également de mul-
tiprogrammation.
idée reçue n◦ 1
Cette fonction est indépendante du nombre de processeurs présents physi-
quement dans l’ordinateur. En effet un système multiprocesseur n’est pas
nécessaire pour exécuter un système d’exploitation multitâche.
Conditions pour qu’un système soit multitâche

I Si on possède plusieurs processeurs, il faut que le système gère la pa-
rallélisation des tâches.
I Si on possède un seul processeur, il faut que le système propose des
solutions pour ”imiter” une parallélisation des tâches.
Eric TERNISIEN
Objectifs d’un système multitâche
1 Partager le temps entre les différentes tâches en cours d’exécution :

chaque processeur n’exécutant qu’une tâche à la fois, le système passe
très rapidement d’une tâche à l’autre de manière à ce que tout semble se
dérouler en même temps pour l’utilisateur.
Eric TERNISIEN

2 Optimiser le partage des ressources entre les différentes tâches en

exécution (partage de ressources abordé plus tard).
Eric TERNISIEN

2 Optimiser le partage des ressources entre les différentes tâches en

exécution (partage de ressources abordé plus tard).
3 Optimiser l’occupation du processeur en bloquant les tâches en attente

de ressources ou d’événements
⇒ éviter de consommer du temps pour ne rien faire.
Eric TERNISIEN
Systèmes multitâches Architectures des systèmes multitâches
Plan
1 - Concepts
3 - Les tâches
4 - Le noyau
Eric TERNISIEN
Architecture monoprocesseur
ALU
Elle assure les opérations basiques de calcul arithmétique et de logique.
mémoire cache L1
Directement intégrée dans le processeur.
mémoire cache L2
Située au niveau du boı̂tier (chipset), entre le
cache L1 et la mémoire vive, elle est plus rapide
d’accès que cette dernière mais moins rapide
que le cache L1.
DMA (Direct Memory Access)

Il permet l’accès direct des périphériques à la mémoire sans intervention du
processeur. Cela garantie la fluidité de l’OS car il n’est pas bloqué pendant le
transfert des données.
Eric TERNISIEN
Architecture multiprocesseur
Un système multiprocesseur apporte une puissance de calcul accrue. Par
contre, il n’est pas vrai que si l’on utilise N processeurs, on augmente par
N la puissance de calcul.
En effet, des échanges doivent se faire entre les différentes tâches et si les bus
de données prévus à cet effet ne suffisent plus aux cadences de transferts, on
arrive vite à des situations conflictuelles.
La répartition des tâches dans les processeurs, simple à résoudre dans le cas
d’un système monoprocesseur, devient beaucoup plus compliquée avec une
machine multiprocesseur.
Deux grandes familles de systèmes multiprocesseur
I les systèmes à architecture répartie
I les systèmes à architecture distribuée (mémoire partagée)
Eric TERNISIEN
Système multiprocesseur à mémoire partagée (SMP)
Eric TERNISIEN
Système multiprocesseur à mémoire répartie
Eric TERNISIEN
Comparaison entre les 2 architectures multiprocesseurs

Architecture à mémoire Architecture à mémoire
partagée distribuée
Temps d’accès à la mémoire uni- Temps d’accès à la mémoire court
forme (UMA)
Nombre limité de processeurs (2-8) Grand nombre de processeurs
Communication entre tâche plus Communication entre nœud plus
facile complexe (réseau d’intercon-
nexion)
Répartition des tâches par l’OS Répartition des tâches par pro-
grammation

Systèmes multitâches Les tâches
Plan
1 - Concepts
3 - Les tâches
4 - Le noyau
Eric TERNISIEN
Notion de tâche
Définition
Une tâche n’est pas un programme mais une partie d’un programme :
I Un programme est une entité statique regroupant à un endroit de la
mémoire un ensemble de données (code du programme, ressources, va-
riables, ...).
I Une tâche est une entité dynamique lancée par un programme. Son but
est de réaliser une action bien précise pour le programme.
Etats d’une tâche

Du fait de son caractère dynamique, la tâche sera volatile en mémoire et aura
plusieurs états : créée, exécutée, en attente d’exécution, bloquée, détruite.
Eric TERNISIEN
Descripteur de tâche
Pour qu’une tâche s’exécute, il faut lui allouer une zone mémoire composée
de :
Zone programme (code)
Stockage de la séquence d’instructions à réaliser et
des constantes.
Zone de données (tas ou heap)

Stockage des variables globales du programme (qui
sont aussi utilisables dans la tâche), allocation dy-
namique de mémoire.
Pile (stack)
Utilisée pour la manipulation des variables tempo-
raires (variables ou adresses définies dans la tâche).
Eric TERNISIEN
Contenu du descripteur de tâche

I contenus des registres du processeur juste avant d’avoir quitté la tâche.
I les pointeurs CP, HP, et SP.
I identité de la tâche (PID : Process IDentity) sous la forme d’un numéro.
I priorité de la tâche.
I identificateur d’état (status) renseignant sur l’état de la tâche (exécutée,
en attente, bloquée, ...)
On appelle ce descripteur le TIB (Task Information Block).
L’affectation d’un TIB à une tâche est réalisée par le système lors de
la création de la tâche.
Eric TERNISIEN
Exemple de TIB sur la carte BECK 51
#define TASK_STACKSIZE 1024 /* Taille de la pile */
/* Déclaration de la pile */
unsigned int tache1_stack[TASK_STACKSIZE];
int tache1ID; /* Identifiant de la t^
ache */
TaskDefBlock f1defblock =
{
tache1, /* Code de la t^ache */
{’T’,’A’,’S’,’1’},
&tache1_stack[TASK_STACKSIZE], /* Pointeur de pile */
TASK_STACKSIZE*sizeof(int),
0,
26, /* Priorité de la t^
ache */
10, /* Quantum de temps */
0,0,0,0
};
Eric TERNISIEN
Les états d’une tâche
Les 5 états d’une tâche

I non créée : état fictif.
I définie : tâche créée mais pas activée.
I éligible : la tâche possède toutes les
ressources nécessaires à son exécution
et attend l’allocation du processeur.
I élue : la tâche est en cours
d’exécution dans le processeur.
I bloquée : la tâche est en attente d’un
événement ou d’une ressource.
Eric TERNISIEN
Les états d’une tâche

Les transitions
I création : création de la tâche par un
programme.
I démarrage : demande d’activation de
la tâche.
I allocation : réquisition d’une tâche
par le processeur.
I préemption : tâche sortie ”de force”
du processeur.
I suspension : attente d’un événement
ou de la libération d’une ressource.
I réveil : arrivée de l’événement ou de
la libération de la ressource.
I fin : fin de l’exécution de la tâche.
I destruction : suppression de la tâche
du système.
Eric TERNISIEN
Les types de tâche (1)
Point de vue physique

I Tâches matérielles (immédiates) :
X associées aux interruptions ;
X gestion des commutations de manière physique (hardware) ;
X utilisées pour des réponses rapides à des événements extérieurs ;
X assure la liaison du PC avec les monde extérieur.
I Tâches logicielles (différées) :

X moins prioritaires que les tâches matérielles ;
X priorité logicielle affectée par l’utilisateur ;
Eric TERNISIEN
Les types de tâche (2)
Point de vue temporel

I Tâches périodiques :
X période de répétition et durée ;
X échéance rigide.
I Tâches apériodiques :
X non critiques ;
X temps de réponse moyen espéré.
I Tâches sporadiques :
X critiques avec échéances rigides ;
X durée minimale entre les activations.
Eric TERNISIEN
Systèmes multitâches Le noyau
Plan
1 - Concepts
3 - Les tâches
4 - Le noyau
Eric TERNISIEN
Qu’est ce qu’un noyau ?

Définition
Un noyau est un ”programme” permettant de faire cohabiter l’exécution en
parallèle de plusieurs programmes dits tâches ou processus.
Tous les systèmes d’exploitation possèdent un noyau qui sert d’interface entre
le matériel et les programmes.
Sa taille et sa conception sont plus ou moins complexe en fonction du système

d’exploitation.
Son rôle est de :

I gérer l’exécution des tâches ;
I optimiser l’exploitation des ressources matérielles et logicielles ;
I coordonner l’utilisation du ou des processeur(s).
Eric TERNISIEN
Architectures de noyau
En fonction du système d’exploitation, l’architecture du noyau est différentes.
Les 4 grandes familles de noyau sont :

I noyau monolithique : Unix ;
I noyau monolithique modulaire : Linux, LynxOS ;
I micro-noyau : QNX, VxWorks ;
I noyau hybride : Windows, Mac.
Eric TERNISIEN
Fonctionnement d’un noyau
Afin d’assurer la répartition des tâches pour l’occupation du processeur, le

noyau intègre une unité chargé de l’attribution du(des) processeur(s). Cette
unité gère aussi les tâches qui ne sont pas en cours d’exécution et qui sont
organisées en files de tâches suivant leur état.
Fonctionnement
1 Les tâches sont en compétition pour l’obtention du processeur.
2 L’une d’entre elles est choisie par l’ordonnanceur.
3 Elle occupe le processeur pendant un certain temps.
4 Elle perd l’accès au processeur et retourne dans une file d’attente
Les processus bloqués sont répertoriés par le système dans des files d’attente.
Généralement une file d’attente particulière correspond à un type de blocage
(attente de ressource, attente d’événement, attente de fin de timer, etc...).
Eric TERNISIEN
Structure simplifiée d’un noyau
Eric TERNISIEN
Ordonnanceur
L’ordonnanceur est un programme qui choisit les tâches à exécuter en fonction
d’un contexte établi par l’état des files, des ressources et des événements
extérieurs.
I Il intervient chaque fois qu’une tâche change d’état.
I Il assure la gestion des commutations des tâches de l’état bloquée à l’état
éligible.
I Il choisi une tâche dans l’ensemble des tâches éligibles.
I Il communique son TIB au répartiteur.
Critères pour un bon ordonnancement

I Pourcentage d’utilisation CPU.
I Nombre de processus exécutés en un temps donné.
I Temps pour exécuter un processus.
I Temps d’attente d’un processus dans la file
Eric TERNISIEN
Répartiteur
Le répartiteur réalise l’élection effective d’une tâche et le changement de

contexte associé.
Il est déclenché par une interruption, ce qui fait qu’entre 2 exécutions du

répartiteur, la même tâche possède le processeur.
Les 4 phases de la commutation de contexte

1 mise à jour de l’état de la tâche courante.
2 sauvegarde de l’environnement de la tâche
courante.
3 restitution du contexte de la nouvelle
tâche.
4 mise à jour de l’état de la nouvelle tâche.
Eric TERNISIEN
Gestion des tâches par le noyau
Toutes les opérations réalisées sur une tâche sont effectuées au niveau de son
descripteur. Dans la pratique, de nombreux systèmes utilisent une technique
de chaı̂nage de tâches en fonction de leur état et de certains facteurs d’ordre.
Le chaı̂nage de la file est bidirectionnel ce qui permet d’intervenir rapidement

sur une tâche donnée.

A chaque fois que le noyau récupère la main, il actualise tous ses pointeurs
système en fonction de l’évolution du système de tâches. Ces pointeurs lui
permettront de gérer le contenu des descripteurs et ainsi indirectement l’état
des tâches.
Eric TERNISIEN
des tâches.
Eric TERNISIEN
des tâches.
Eric TERNISIEN
des tâches.
Eric TERNISIEN
des tâches.
Eric TERNISIEN
des tâches.
Eric TERNISIEN
des tâches.
Eric TERNISIEN
Type de noyau (1)
Comme nous l’avons vu, c’est le noyau qui gère l’avancement des tâches et
fait évoluer le système d’exploitation.
Noyau non préemptif (coopératif)

Exécution séquentielle des tâches.
Le lancement de t2 n’est effectué
qu’à la fin de t1 .
Noyau préemptif
Exécution alternée des tâches. Les
tâches sont en concurrence pour
accéder au(x) processeur(s).
Eric TERNISIEN
IUT de Saint Di´ 43/152
epartement Génie Electrique et informatique Industrielle
Type de noyau (2)
Noyau coopératif (non préemptif)

Dans ce type de noyau, chaque application qui s’exécute dispose du processeur
(et des ressources associées) puis le libère, permettant ainsi à l’application
suivante dans la file d’attente de disposer à son tour du processeur et des
ressources.
Problème
Si une application boucle sur elle-même, se bloque ou ne libère pas une res-
source, toutes les applications restent en attente et peuvent bloquer le système
d’exploitation.
Eric TERNISIEN
Type de noyau (3)
Noyau préemptif
Dans ce type de noyau, chaque application qui s’exécute peut se voir retirer
le processeur à n’importe quel instant.
Dans les système d’exploitation courants, chaque application dispose du

processeur pendant un laps de temps déterminé à l’avance.
Dans d’autres systèmes comme les systèmes temps réel, des tâches à forte
priorité peuvent également réquisitionner le processeur pour exécuter des trai-
tements importants (souvent liés à des interruptions).
Eric TERNISIEN
Systèmes d’exploitation et noyau
Unix
Multitâche préemptif depuis sa naissance en 1969.
Linux
Multitâche préemptif depuis sa naissance en 1991.
Macintosh
I MacOS à MacOS 9 : multitâche coopératif.
I depuis 2001 et MacOS X : multitâche préemptif.
Windows
I Windows 1.0 à Windows 3.11 : multitâche coopératif.
I Windows 95 à Windows Millenuim : multitâche hybride
I depuis Windows NT : multitâche préemptif.
Eric TERNISIEN
Systèmes temps réel Concepts
Plan

1 - Concepts
Eric TERNISIEN
Systèmes Temps Réel ?
Un système temps réel (ou noyau temps réel) est un ”programme” regroupant
un ensemble de fonctions ou primitives permettant de faire cohabiter
l’exécution en ”parallèle” de plusieurs ”programmes”, dits tâches ou proces-
sus. C’est donc un système multitâche.
La principale différence entre un système multitâche classique et un système

multitâche Temps Réel est le comportement très déterministe et le respect
de contraintes temporelles qui n’existent pas dans les systèmes classiques.
Par rapport à un ordinateur classique avec un système d’exploitation standard,

le noyau Temps Réel a une vocation industrielle. Il est utilisé pour piloter un
système industriel (procédé de fabrication, instrumentation, ...) auquel il est
physiquement connecté.
C’est une alternative aux automates programmables.

Eric TERNISIEN
Systèmes Temps Réel ?
Définition
Un système temps réel est un système capable de piloter à tout instant un
processus évolutif dans le temps.
Un système temps réel doit donc contrôler son environnement en recevant

des informations provenant des capteurs, en les traitant et en retournant les
résultats suffisamment vite pour affecter et modifier le fonctionnement de
l’environnement à chaque instant.
Les résultats produits doivent être logiques et déterministes par rapport aux
entrées fournies.
Tous les changements d’états doivent être prévus y compris les fonctionne-
ments occasionnels type défauts.
Eric TERNISIEN
Qu’est-ce que le Temps Réel ?
Pour introduire la notion de temps réel, considérons l’exemple du système de

navigation d’un robot autonome. Ce système calcule la position du robot.
Pour être exact, le résultat du calcul doit être fourni après un intervalle de
temps raisonnable car durant le calcul, le robot est toujours en mouvement.
Problème
Le robot doit pouvoir, à
l’échelle de réaction hu-
maine, avancer et observer
son entourage.
Eric TERNISIEN
Pour que le robot avance sans problèmes, il faut :

I acquérir toutes les données d’entrées fournies par les capteurs → temps
t1
I traiter les données reçues → temps t2
I calculer la nouvelle trajectoire du robot → temps t3
Conditions
Il faut que t1 + t2 + t3 < tlim . tlim dépendant de la vitesse du robot.
Eric TERNISIEN
Pour que le robot avance sans problèmes, il faut :

I acquérir toutes les données d’entrées fournies par les capteurs → temps
t1
I traiter les données reçues → temps t2
I calculer la nouvelle trajectoire du robot → temps t3
Conditions
Il faut que t1 + t2 + t3 < tlim . tlim dépendant de la vitesse du robot.
Conclusion
L’important n’est pas de connaı̂tre le temps de chaque tâche, mais de connaı̂tre
et de respecter tlim .
Eric TERNISIEN
La notion de temps réel
Un système temps réel n’est pas un système ”qui va le plus vite possible” mais
qui satisfait des contraintes temporelles.
Information boursière en temps réel la minute, le jour, le mois

Données météo en temps réel l’heure, le jour, la semaine
Compression de données la nanoseconde
Acquisition de données la microseconde
Fabrication industrielle le temps de cycle de la machine
Conclusion
La notion de temps réel est quelque chose de flou ! ! !.
Eric TERNISIEN
IUT de Saint Di´ 52/152
epartement Génie Electrique et informatique Industrielle
Classes de systèmes temps réel
Systèmes à contraintes souples (soft real time)

I les contraintes de temps doivent être respectées mais des erreurs occa-
sionnelles sont tolérables.
I les spécifications définissent statistiquement les taux d’erreurs acceptables
(ex : applications multimédia grand public).
Systèmes à contraintes dures (hard real time)

I les contraintes de temps doivent être respectées dans 100% des cas.
I les spécifications sont très précises et exhaustives (ex : applications in-
dustrielles).
Eric TERNISIEN
Classes de systèmes temps réel
Systèmes temps réel critiques

Cette terminologie met l’accent sur les conséquences d’une défaillance du
système et concerne la sûreté de fonctionnement. On dira qu’un système temps
réel est critique si :
I il y a des conséquences humaines en cas de défaillance.
I le coût financier d’une défaillance du système est d’ordre supérieur à celui
qu’a coûté le système.
Eric TERNISIEN
Structure d’un système temps réel
Eric TERNISIEN
Propriétés des systèmes temps réel

Déterminisme logique
le résultat d’un traitement doit être cohérent par rapport aux données d’entrée
du système.
Déterminisme temporel
Les contraintes de temps doivent toujours être respectées. Le fait de dépasser
une échéance est assimilable à une défaillance du système
Prévisibilité
On cherche à savoir a priori si le système temps réel est en mesure de répondre
aux exigences du système contrôlé. Tous les cas doivent être étudiés.
Fiabilité
La fiabilité des composants matériels et logiciels est nécessaire pour garantir
le respect des contraintes.
Eric TERNISIEN
Systèmes temps réel Composition d’un système temps réel
Plan

1 - Concepts
Eric TERNISIEN
Composants d’un système temps réel
Comme précisé au début de cette partie, un système temps réel est un système
multitâche. On va donc retrouver les composants déjà énoncé précédemment :
I Hardware : processeur, mémoire... ;
I Software : noyau avec des stratégies d’ordonnancement.
La complexité de ces composants va dépendre de l’utilisation et des besoins

du système à piloter.
On pourra trouver des cartes embarquées aussi bien que des PCs industriels.
Les fonctionnalités proposées sont bien sûr différentes selon les cas.
Eric TERNISIEN
Quoi de plus ?
Une bibliothèque de fonctions
Avec un système temps réel, une bibliothèque de fonctions appelées primi-
tives est fournie. Ces dernières permettent de faire des appels systèmes et de
travailler directement avec le noyau.
On trouve des fonctions qui permettent :

I la gestion et le contrôle de l’exécution des tâches : création des
tâches, mise en attente, modification de la priorité, ...
I la synchronisation et la communication entre les tâches :
sémaphores, mémoires partagées, messages, les signaux.
I la gestion du temps : timers, horloge temps réel, chien de garde.
I la gestion des interruptions : événements (externes et asynchrones),
flux d’entrée/sortie (liaison série, actionneurs, récupérations de mesures).
Eric TERNISIEN
Quoi de plus ?
La prise en compte des interruptions
Les interruptions jouent un rôle fondamental dans les systèmes temps réel.
Ce sont elles qui permettent la prise en compte d’événements asynchrones
demandant une réponse temps réel.
Une interruption n’est pas une tâche, elle lance une tâche.
Le temps de prise en compte et de traitement des interruptions est directement

lié à la réponse temps réel du système.
Fonctionnement d’une interruption
1 L’interruption active un ISR (Interrupt Service Routine).
2 L’ISR s’exécute en avant-plan. Il doit être le plus court possible (pour
pouvoir prendre en compte d’autres ISR).
3 L’ISR provoque la création de la tâche associée à l’interruption.
Eric TERNISIEN
Quoi de plus ?
Gestion des interruptions en fonction du type de noyau
Noyau non-préemptif Noyau préemptif
Eric TERNISIEN
Quoi de plus ?
Phase de traitement d’une interruption
Eric TERNISIEN
Systèmes temps réel Types de systèmes temps réel
Plan

1 - Concepts
Eric TERNISIEN
Système temps réel purement cyclique

I Les tâches s’exécutent périodiquement ;
I Les I/O sont scrutées périodiquement ;
I Les demandes en ressources sont stables.
Régulation d’un procédé
Type de contraintes : dans une voiture on échantillonne l’angle de rotation

du vilebrequin toutes les 10−6 sec et la température du moteur toutes les 10
sec.
Eric TERNISIEN
Système temps réel purement cyclique
Contrôle, supervision et pilotage d’une machine
Type de contraintes : pilotage de la machine à la ms ou à la seconde et

affichage sur la supervision de données à la minute ou à l’heure.
Eric TERNISIEN
Système temps réel majoritairement cyclique

I Les tâches s’exécutent périodiquement ;
I Le système doit répondre à des événements externes.
Contrôle d’une chaı̂ne de production
Eric TERNISIEN
Système temps réel asynchrone mais partiellement prévisible
I Les tâches sont non-périodiques ;

I Leurs durées d’exécution sont très variables ;
I Les ressources consommées sont variables d’une exécution à l’autre.
MAIS les variations sont bornées et on a des informations statistiques sur les
variations.
Domaines d’application
I Télécommunications ;
I Multimédia ;
I Poursuite radar ;
I Traitement de flux de données.
Eric TERNISIEN
Système temps réel asynchrone mais partiellement prévisible

Contraintes dans le domaine du multimédia
Des contraintes temporelles fortes s’appliquent, particulièrement sur les appli-
cations interactives (TV en direct) où les compressions et transmissions des
deux flux doivent respecter des contraintes de régularité et de synchronisation.
I Cas de l’image :
X Standard vidéo 30 images/sec (TVHD 60 images/sec), téléconférence 10
à 20 personnes ;
X MPEG-2 : débit en compression selon l’application de 1,5 à 35 Mbit/sec
(très gros consommateur de CPU).
I Cas du son :
X De 16kbit/sec téléphone à 128kbit/sec son qualité CD ;
X Dans une diffusion son/image la synchronisation des lèvres impose un
décalage de moins de 80 msec entre les flux audio et vidéo ;
X L’oreille est très sensible aux glitchs ou trous de quelques centaines de
millisecondes.
Eric TERNISIEN
Système temps réel asynchrone et imprévisible

I Réagit à des événements asynchrones ;
I Déclenche des tâches de haute complexité.
Domaines d’application
I Transport ;
I Aérospatial ;
I Temps réel critique.
Eric TERNISIEN
Systèmes temps réel du marché
Nom Base Société Open source Types d’applications

LynxOS Unix LynuxWorks non embarqué
QNX Software oui si usage
QNX Unix embarqué
Systems personnel
RTLinux Unix FSMLabs oui embarqué et PC
VxWorks Unix Wind River non embarqué
Il existe bien d’autres systèmes : Xenomai (utilisé à Numalliance), RTAI, FreeRTOS,

eCos, µC/OS, propriétaires ...
Eric TERNISIEN
Les stratégies d’ordonnancement Généralités
Plan

Eric TERNISIEN
Les différents temps d’une tâche

Temps d’attente
Temps entre le moment où la tâche est créée et le moment où elle est élue
pour la première fois.
Temps d’exécution
Temps entre la création et la fin de la tâche.
Temps de calcul
Temps nécessaire à la tâche pour effectuer le code qui lui est associé.
Exemple
Eric TERNISIEN
Performances d’un algorithme d’ordonnancement
Les deux critères qui peuvent donner un aperçu des performances d’un ordon-
nanceur sont :
I Temps moyen d’attente : moyenne de tous les temps d’attente de chaque
tâche ;
I Temps moyen d’exécution : moyenne de tous les temps d’exécution de
chaque tâche.
Eric TERNISIEN
Les stratégies d’ordonnancement Noyau non-préemptif (coopératif)
Plan

Eric TERNISIEN
La pile FIFO
Fonctionnement
Les tâches sont exécutées dans l’ordre d’arrivée.
Exemple
Tâche Durée Temps de création

T1 3 0
T2 2 2
T3 4 1
T4 3 3
Tâche Temps d’attente Temps d’exécution

T1 0 3
T2 5 7
T3 2 6
T4 6 9
Moyenne 3.25 6.25
Eric TERNISIEN
Le plus court temps de traitement
Fonctionnement
Les tâches sont rangées dans la file en fonction de leur temps de calcul.
Inconvénients
Cette stratégie favorise les traitements courts par rapport aux traitements
longs.
I Il faut une connaissance a priori de la durée du traitement ;
I Il y a privation d’accès au processeur des processus longs.
Eric TERNISIEN
Le plus court temps de traitement

Exemple

T1 3 0
T2 2 2
T3 4 1
T4 3 3

T1 0 3
T2 1 3
T3 7 11
T4 2 5
Moyenne 2.5 5.5
Eric TERNISIEN
Les stratégies d’ordonnancement Noyau préemptif
Plan

Eric TERNISIEN
Le temps partagé (round robin)
Fonctionnement
La technique du temps partagé est utilisé dans les systèmes d’exploitation où
l’utilisateur est susceptible d’intervenir fréquemment et de manière asynchrone
par rapport au fonctionnement du système.
⇒ Il faut alors pouvoir priver une tâche longue du processeur et céder ce

dernier à un processus plus court.
Une tâche en cours d’exécution est interrompue tous les n ticks (unité de base
du noyau ≈ 10ms) et replacée en fin de file. Les n ticks sont appelés Quantum
de temps (50ms à 100ms)
Eric TERNISIEN

Exemple

T1 0 4
T1 3 0
T2 2 6
T2 2 2
T3 1 10
T3 4 1
T4 3 9
T4 3 3
Moyenne 1.5 7.25
Eric TERNISIEN

Exemple
Si Q=10 ticks et si on a 5 tâches T1 , T2 , T3 , T4 , T5 de durée respectives
10,20,30,40, et 50 ticks. Alors pour effectuer toutes les tâches, il faudra
toujours 150 ticks, mais au bout de combien de ticks se termineront T2 et T4 ?
Eric TERNISIEN

Exemple
T2 sera achevée au bout de 60 ticks : T1 + T2 + T3 + T4 + T5 + T2
Eric TERNISIEN

Exemple
T4 sera achevée au bout de 130 ticks : T1 + T2 + T3 + T4 + T5 + T2 + T3 +

T4 + T5 + T3 + T4 + T5 + T4
Eric TERNISIEN

Exemple
T4 sera achevée au bout de 130 ticks : T1 + T2 + T3 + T4 + T5 + T2 + T3 +

T4 + T5 + T3 + T4 + T5 + T4
Conclusion
I Les tâches commencent plus vite à s’exécuter (temps d’attente réduit).
I Les tâches mettent plus de temps à s’exécuter (temps d’exécution plus
grand).
Eric TERNISIEN

Problème du choix du quantum
Le temps partagé pose le problème du réglage du découpage du temps. Sur la
majorité des SE, le quantum n’est pas réglable.
Néanmoins, quand cela est possible, le problème est que si le choix de l’unité
de temps est mal adapté, on risque de consommer ± de temps machine pour la
commutation des tâches.
Par conséquent, le dimensionnement du quantum est important (fonction de la charge

du système) :
I si Q trop petit : processeur utilisé pour la commutation de tâches uniquement
(phénomène de overhead) ;
I si Q trop grand : rafraı̂chissement trop lent de l’exécution des tâches (système
coopératif).
On choisira généralement Q en fonction de la fréquence des E/S du système.
Eric TERNISIEN

Exemple de choix du quantum
Soit un SE possédant un quantum de 50 ticks. Le Noyau effectue la com-
mutation des tâches en 0.5 ticks. Soit 5 tâches traitées par un Round-Robin
et ayant un temps de calcul long par rapport au quantum. Chaque tâche
attendra pendant un cycle de plus de 200 ticks pour reprendre la main. Le
temps cumulé par le processeur pour réaliser les commutations des tâches
pendant cette période n’est que de 2.5 ticks donc négligeable par rapport à
200 ticks (1.25% du temps de cycle).
Si dans les mêmes conditions, le quantum est fixé à 4 ticks. Chaque tâche
attendra pendant un cycle de plus de 16 ticks pour reprendre la main. Par
contre le Noyau, lui, occupe toujours le processeur pendant 2.5 ticks non
négligeables devant les 16 ticks (16% du temps de cycle ⇒ début d’overhead).
Eric TERNISIE

Choix du quantum
T : durée du cycle - C : durée de la commutation - Q : durée du quantum
Eric TERNISIEN
Le round robin amélioré

Round robin multi-niveau
On cherche à accorder aux tâches les plus courtes un privilège encore plus grand
que la technique du Round-Robin classique ne le permet. On introduit plusieurs
files d’attente auxquelles sont associées des quantums différents. Généralement
3 files sont utilisées : Q, 2Q, 4Q.
I Méthode qui favorise les

tâches de courte durée
I Risque de privation pour
les tâches longues
Eric TERNISIEN

Exemple
Considérons l’exemple du transparent 81 et un système à 2 files d’attente F1
et F2 au lieu d’une unique FIFO comme précédemment.
La file F1 est affectée d’un quantum Q et la file F2 d’un quantum 2Q.
Le parcours des 2 files s’effectuera de la façon suivante : F1 , F1 , F2 , F1 , F1 ,

F2 , etc. Dès que F1 est vide, la tâche la plus courte de la file F2 est introduite
dans la première file.
Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple

Eric TERNISIEN

Exemple
On remarque que la tâche T2 se termine en 40 ticks (au lieu de 60 dans le
cas d’une seule file). De même, la tâche T3 s’achève en 70 ticks au lieu de
100 ticks.
En contrepartie, la tâche T4 démarre au bout de 60 ticks au lieu de 40 ticks,

de même que la tâche T5 démarre au bout de 90 ticks au lieu de 50 ticks.
Eric TERNISIEN

Exemple
On remarque que la tâche T2 se termine en 40 ticks (au lieu de 60 dans le
cas d’une seule file). De même, la tâche T3 s’achève en 70 ticks au lieu de
100 ticks.
En contrepartie, la tâche T4 démarre au bout de 60 ticks au lieu de 40 ticks,

de même que la tâche T5 démarre au bout de 90 ticks au lieu de 50 ticks.
Conclusion
En conclusion, la multiplication des files d’attente associées à des quantums
différents favorise bien l’exécution des tâches les plus courtes, mais retarde le
démarrage de l’exécution des tâches les plus longues.
Eric TERNISIEN
Ordonnancement par priorités
Fonctionnement
Le temps partagé est idéal pour les systèmes transactionnels (répartition
équitable de l’accès au processeur).
Il est inadapté dans un contexte industriel (conduite de processus industriels)

car les tâches doivent avoir des degrés d’importance et d’urgence différents ⇒
la mise en œuvre d’un ordonnancement par priorité est nécessaire. L’insertion
d’une tâche dans la file est alors conditionnée par sa priorité par rapport aux
autres tâches.
les tâches les plus prioritaires sont dans l’ordre :

I les traitements de défaut du système (panne, reconfiguration, alarme, ...) ;
I les tâches associées à des événements matériels (interruptions) ;
I les tâches associées à la gestion des périphériques.
Eric TERNISIEN
Ordonnancement par priorités statiques

Fonctionnement
La priorité est fixée au démarrage du programme (par un algorithme).
Exemple
Tâche Durée Priorité Temps de création

T1 3 3 0
T2 2 4 2
T3 4 1 1
T4 3 2 3

T1 0 10
T2 8 10
T3 0 4
T4 2 5
Moyenne 2.5 7.25
Eric TERNISIEN

Algorithme Rate Monotonic (RM)
L’algorithme Rate Monotonic [1973] est un algorithme dynamique et préemptif
basé sur des priorités fixes.
La priorité de chaque tâche est inversement proportionnelle à sa période

d’apparition (plus elle apparaı̂t souvent plus elle est prioritaire).
Son utilisation nécessite quelques hypothèses :

I tâches périodiques (tâches i de période Pi ).
I tâches préemptibles et indépendantes.
I temps de calcul Ci connu a priori et constant.
Eric TERNISIEN

Algorithme Rate Monotonic (RM)
Les conditions à vérifier pour son utilisation sont :
I condition nécessaire :
N
X Ci
m= 61
Pi
i=1
I condition suffisante :
N
X Ci 1
m= 6 N(2 N − 1)
Pi
i=1
avec
I m : taux d’occupation du processeur ;
I Ci : temps de calcul de la tâche i ; Si N → ∞, on a 70% d’occupation.
I Pi : période de la tâche i ;
I N : nombre de tâches.
Eric TERNISIEN

Algorithme Deadline Monotonic (DM)
le Rate Monotonic pénalise les tâches rares mais urgentes (défauts). le
Deadline Monotonic est meilleur pour les tâches dont l’échéance (contrainte
de temps) est très inférieure à la période → tâche courte qui n’apparaı̂t pas
souvent.
Les hypothèses sont identiques au Rate Monotonic.
Le principe est le même sauf que les priorités sont affectées aux tâches selon
l’ordre inverse de leurs échéances.
Eric TERNISIEN
Algorithme RM et DM
Avantages
Inconvénients
I mécanisme simple
I hypothèses restrictives
I s’implante naturellement avec
I uniquement avec préemption
les OS du marché
I indépendance impérative
I peut être utilisé pour affecter
entre les tâches
des priorités d’interruptions
Eric TERNISIEN

Exemple Algorithme RM
Tâche Durée Période Priorité Temps de création
T1 2 6 1 0
T2 2 8 2 0
T3 3 12 3 0
Eric TERNISIEN
Ordonnancement par priorités dynamiques

Principe
Priorité déterminée pendant l’exécution de la tâche. Par exemple, la tâche
dont l’échéance est la plus proche est élue (algorithme EDF).
Exemple
Soient 2 tâches T1 et T2 de période respective P1 et P2 . T1 et T2 ont
besoin respectivement de 50% de leur période P1 et P2 pour s’exécuter
complètement. On suppose que P1 et P2 sont dans le rapport 3/2.
Eric TERNISIEN

Algorithme Earliest Deadline First (EDF)
L’algorithme Earliest Deadline First [1974] est un algorithme dynamique et
préemptif basé sur des priorités dynamiques.
A chaque instant, la tâche qui s’exécute est celle dont l’échéance est la plus
proche.
Son utilisation nécessite quelques hypothèses :

I échéances quelconques mais connues à l’activation.
I tâches préemptibles et indépendantes.
I temps d’exécution Ci connu a priori et constant.
Eric TERNISIEN

Algorithme Earliest Deadline First (EDF)
Les conditions à vérifier pour son utilisation sont :
I test exact (si P = D (période = échéance)) :
N
X Ci
m= 61
Pi
i=1
I test suffisant (si D quelconque) :

N
X Ci
m= 61
Di
i=1
avec
I m : taux d’occupation du processeur ;
I Ci : temps de calcul de la tâche i ;
I Pi : période de la tâche i ; Si N → ∞, on a 100% d’occupation.
I Di : échéance de la tâche i ;
I N : nombre de tâches.
Eric TERNISIEN

Algorithme Least Laxity First (LLF)
L’algorithme Least Laxity First est un algorithme dynamique et préemptif
basé sur des priorités dynamiques.
Les hypothèses sont les mêmes que pour l’EDF.
Il est optimal sur 1 CPU et meilleur qu’EDF en multiprocesseur.
A chaque instant la tâche qui s’exécute est celle qui a la marge la plus courte
(marge = échéance - temps de calcul restant).
Eric TERNISIEN
Algorithme EDF et LLF
Inconvénients
I mauvais comportement en cas
Avantages de surcharge
I mécanisme simple I uniquement avec préemption
I optimise l’usage des res- I indépendance impérative
sources entre les tâches
I bien adapté aux tâches I pas implantable facilement
périodiques à courtes dans les OS actuels
échéances I nécessite de maintenir à
jour le temps de calcul déjà
consommé par chaque tâche
Eric TERNISIEN

Exemple Algorithme EDF
Tâche Durée Période Priorité au départ Temps de création
T1 2 6 1 0
T2 2 8 2 0
T3 3 12 3 0
Eric TERNISIEN
Priorité et temps partagé

Principe
Dans le cas où certaines tâches ont la même priorité, on applique le round
robin sur ces dernières.
Exemple
Tâche Durée Priorité Temps de création

T1 3 4 0
T2 4 3 2
T3 4 3 3
T4 2 1 5
T5 2 7 0
T6 2 3 2
Eric TERNISIEN
Communication entre tâches Généralités
Plan

Eric TERNISIEN
Types d’échanges entre tâches

En environnement multitâches, les tâches coopèrent pour réaliser une activité
commune. Les tâches fonctionnent en parallèle, il y a donc nécessité de
dialoguer pour optimiser le fonctionnement et gérer les ressources.
Il faut gérer les relations entre l’ensemble des tâches qui communiquent avec
le système informatique. Il y a 3 types de relations possibles.
Tâches indépendantes
Les tâches sont complètement indépendantes

et n’ont en commun que la ressource que
constitue le système informatique (cas très peu
rencontré).
Eric TERNISIEN
Types d’échanges entre tâches
Ressources communes
Une tâche ne peut pas connaı̂tre le contenu

d’une variable pendant qu’une autre la met
à jour. Les 2 tâches partagent ici une res-
source commune et sont en concurrence pour
y accéder. ⇒ Partage de ressources
Tâches liées
Les tâches ont besoin d’informations concer-

nant d’autres tâches pour poursuivre leur
évolution. ⇒ Synchronisation
Eric TERNISIEN
Communication entre tâches Synchronisation entre tâches
Plan

Eric TERNISIEN
Principes
Définition
Le problème de synchronisation se pose dès que des tâches doivent réagir
face à des signaux associés à des événements.
Ces événements sont soit des événements hardwares (venant des périphériques)
ou softwares (venant d’autres tâches).
Il est important de mémoriser tous les évènements provenant des utilisateurs

du bus processeur pour ne pas perdre de demandes d’interruptions en cours
de route. Le principe est que TOUT EVENEMENT PRODUIT DOIT ETRE
COMSOMME ! ! !
La synchronisation peut être :

I directe : tâche émetteur connaı̂t la tâche récepteur
I indirecte : tâche émetteur ignore l’identité de la tâche récepteur.
Eric TERNISIEN
Synchronisation directe
Une tâche agit directement sur une autre tâche ⇒ le nom de la tâche à
synchroniser doit être connu de la tâche qui la contrôle.
On utilise deux primitives : Bloquer et Eveiller.
Autres formes de synchronisation directe

Une tâche peut créer, lancer et tuer une autre tâche.
Une tâche peut se bloquer elle-même afin de rendre la main ou se tuer

Eric TERNISIEN
Synchronisation indirecte par sémaphore
L’émetteur signale au récepteur un événement particulier par l’intermédiaire

d’une entité de message nommée sémaphore. L’émetteur diffuse un sémaphore
avec la fonction vendre (signaler) sans se préoccuper des récepteurs potentiels
qui la reçoivent par la fonction prendre (attendre).
Principe de la synchronisation indirecte par sémaphore

1 Le récepteur du sémaphore se met en attente d’un jeton dans le
sémaphore.
2 La tâche émettrice du sémaphore active le sémaphore en déposant un
jeton.
3 Le récepteur est réveillé dès que le sémaphore est actif.
Eric TERNISIEN
Synchronisation indirecte par sémaphore
L’identité de la tâche récepteur n’est pas connue de la tâche

émetteur ! ! !
Eric TERNISIEN
Monsieur, c’est quoi un sémaphore ?

Définition
Un sémaphore est utilisé pour synchroniser deux tâches et pour gérer l’accès
à certaines ressources.
Il y a deux types de sémaphores :

I Sémaphore binaire : utilisable par un seul récepteur à la fois.
I Sémaphore à compte : utilisable par un certain nombre de récepteurs.
Structure d’un sémaphore

I Un compteur entier S ;
I Une file d’attente F (type
FIFO ou priorités).
I 2 primitives pour la gestion
des jetons.
Eric TERNISIEN
Monsieur, c’est quoi un sémaphore ?

Algorithme des primitives prendre et vendre
Eric TERNISIEN
Synchronisation indirecte par événements
L’émetteur signale au récepteur choisi un événement particulier par l’in-

termédiaire d’une entité message nommée événement équivalente au
sémaphore. Généralement les événements sont rassemblés par groupe.
On utilise deux primitives : Attendre et Signaler.
Eric TERNISIEN
Communication entre tâches Partage de ressources et exclusion mutuelle
Plan

Eric TERNISIEN
Principes
Définition
La ressource est un objet nécessaire à l’exécution d’une tâche. L’exécution
concurrente de plusieurs tâches fait apparaı̂tre le problème de l’accès simultané
à une même ressource.
Si une ressource est utilisée par plusieurs tâches, elle est dite commune
(partageable). A une ressource partageable, on associe une capacité N. Dans
ce cas la ressource est N-partageable. Si N=1, la ressource est une ressource
critique.
Cette ressource peut être de différentes natures :

I matérielle : mémoire, système E/S, coprocesseur, etc...
I logicielle : liste, file d’attente, zones de mémoire, tampon, etc...
Eric TERNISIEN
Exclusion mutuelle
Lorsque la ressource n’est pas partageable entre plusieurs tâches, un

mécanisme doit en assurer l’accès exclusif. La séquence d’instructions
manipulant une ressource critique est appelée section critique. Quand une
tâche est dans cette section critique, il faut empêcher les autres tâches d’y
accéder ⇒ principe d’exclusion mutuelle.
2 méthodes pour gérer l’exclusion mutuelle :

I l’attente active : utilisation d’un verrou.
I l’attente passive : utilisation d’un sémaphore
Eric TERNISIEN
Exclusion mutuelle
Compte en banque
T1 compte T2 compte
...
-50e
lire compte
...
lire compte
compte = compte + 300e 250e
écrire compte
...
compte = compte - 50e
écrire compte -100e
...
La variable compte est une ressource critique ! ! !
Eric TERNISIEN
Attente active
Principe du verrou
L’exclusion est réalisée à l’aide d’un verrou binaire qui indique si la ressource
est libre ou utilisée.
Chaque tâche va tester le verrou avant d’utiliser la ressource. Si la ressource

est déjà utilisée par une autre tâche, la tâche va réaliser une attente active
en bouclant dans le processeur.
Si la ressource est libre, la tâche va positionner le verrou à occupé avant

d’utiliser la ressource et elle va le positionner à nouveau à libre lorsqu’elle a
terminé avec la ressource.
Verrou = 1 ⇒ ressource indisponible

Verrou = 0 ⇒ ressource disponible
Eric TERNISIEN
Attente active
Exemple d’exclusion mutuelle à base de verrou
int verrou;
void prendreVerrou(void)
{
while(verrou==1);/* Tant que le verrou n’est pas libre
j’attend ... */
verrou=1; /* Maintenant qu’il est libre je le prends */
return;
}
void rendreVerrou(void)
{
verrou=0; /* je libere l’acces a la ressource */
return;
}
Eric TERNISIEN
Attente passive
L’exclusion est réalisée à l’aide d’un sémaphore qui indique si la ressource est
libre ou utilisée.
Chaque tâche va tester le sémaphore avant d’utiliser la ressource. Si la

ressource est déjà utilisée par une autre tâche, la tâche va réaliser une attente
passive en restant bloquée dans la file d’attente du sémaphore.
Si la ressource est libre, la tâche va prendre le sémaphore avant d’utiliser la

ressource et elle va le vendre lorsqu’elle a terminé avec la ressource.
Initialisation du compteur du sémaphore

I Si ressource N-partageable ⇒ sémaphore à compte (S = N)
I Si ressource critique ⇒ sémaphore binaire (S = 1)
Eric TERNISIEN
Attente passive
La tâche sollicitant la ressource est bloquée ⇒ pas d’utilisation du

processeur
Eric TERNISIEN
Attente passive
Compte en banque
Eric TERNISIEN
Validité de l’exclusion mutuelle

Propriétés à respecter
I La solution est indépendante de la vitesse d’exécution du programme ;
I Deux processus (ou plus) ne peuvent se trouver en même temps en section
critique ;
I Un processus hors de la section critique et qui ne demande pas à y entrer
ne doit pas empêcher un autre d’y entrer (oubli du vendre) ;
I Deux processus ne doivent pas s’empêcher mutuellement et indéfiniment
d’entrer en section critique (interblocage) ;
I Un processus entre toujours en section critique au bout d’un temps fini
(pas de famine).
Eric TERNISIEN
Validité de l’exclusion mutuelle

Exemple d’interblocage
Eric TERNISIEN
Automate et multitâche Rappels
Plan
1 - Rappels
2 - Questions
Eric TERNISIEN
Cycle d’un automate
I Lecture des entrées : L’automate lit les

entrées (de façon synchrone) et les recopie
dans la mémoire image des entrées.
I Exécution du programme : L’automate
exécute le programme instruction par
instruction et écrit les sorties dans la
mémoire image des sorties.
I Ecriture des sorties : L’automate bascule les différentes sorties (de façon
synchrone) aux positions définies dans la mémoire image des sorties.
Le temps d’un cycle d’API varie selon la taille du programme, la complexité

des calculs et la puissance de l’API. Il est généralement de l’ordre de 20ms.
C’est ce que l’on appelle la tâche maı̂tre ou programme maı̂tre.

Eric TERNISIEN
Cycle d’un automate

Exécutions possibles
La tâche maı̂tre peut être exécutée de manière :
I Cyclique
I Périodique
Elle est surveillée par un chien de garde (Watchdog) et mise en défaut en cas
de dépassement du temps d’exécution imparti.
Eric TERNISIEN
Automate et multitâche Questions
Plan
1 - Rappels
2 - Questions
Eric TERNISIEN
Un automate est-il multitâche ?
Eric TERNISIEN

OUI ! ! !
Eric TERNISIEN

OUI ! ! ! mais cela est assez peu utilisé.
Eric TERNISIEN

OUI ! ! ! mais cela est assez peu utilisé.
Les tâches d’un automate
I La tâche système qui s’occupe de la gestion de l’automate →
cyclique.
I La tâche maı̂tre qui contient le programme principal de l’auto-
mate → cyclique ou périodique.
I Les tâches rapides qui contiennent des programmes nécessitant
une période de lancement précise et prioritaire. Elles conviennent
par exemple aux alarmes horaires ou aux calculs des consignes de
régulation → périodiques.
I Les tâches événementielles qui contiennent des programmes
qui sont lancés suite au changement d’état d’une entrée, d’une
sortie, d’une variable mémoire ou d’un sémaphore (instruction
d’une autre tâche) → asynchrone.
Eric TERNISIEN
Un automate est-il temps réel ?
Eric TERNISIEN
OUI ! ! !
Eric TERNISIEN
OUI ! ! ! Si les contraintes de temps sont respectées.
Eric TERNISIEN
OUI ! ! ! Si les contraintes de temps sont respectées.
Qui fixe la contrainte de temps ?

I Le temps de cycle de la machine.
I La cadence de production.
Qui est le garant du temps de cycle ?

Les chiens de garde (watchdog) associées aux différentes tâches qui vérifient
que celles-ci ne restent pas bloquées dans le même état pendant un temps
supérieur à un temps défini.
Eric TERNISIEN
Automate et multitâche Ordonnancement des tâches
Plan
1 - Rappels
2 - Questions
Eric TERNISIEN
Ordonnancement
C’est un ordonnancement statique préemptif (type Rate Monotonic). La prio-
rité est attribuée à la tâche pendant la programmation.
Exemple
Tâche maı̂tre cyclique, tâche rapide de période 20ms et une tâche
événementielle.
Eric TERNISIEN
Propriétés des tâches

Entrées/sorties
Chaque tâche possède son propre cycle de lecture d’entrées et d’écriture de
sorties. Cependant, le nombre d’entrées lues et de sorties affectées décroı̂t pour
des raisons de rapidité d’exécution.
Communication
Les tâches ne peuvent communiquer entre elles que par des zones mémoires
allouées. Les zones de communication sont des ressources partagées qui ne
peuvent être lues ou écrites que par une seule tâche à la fois.
Ces ressources peuvent être :

I une variable interne (bit ou mot) ;
I une entrée ou une sortie.
Eric TERNISIEN
Chez Siemens
Les tâches sont réparties par blocs d’organisation (OB) qui ont chacun une
priorité prédéfinie. L’ensemble des OB regroupe les tâches maı̂tres, rapides et
événementielles.
I OB1 : tâche maı̂tre ;
I OB10 à OB17 : alarmes horaires ;
I OB20 à OB23 : alarmes temporisées ;
I OB30 à OB38 : alarmes d’horloge ;
I OB40 à OB47 : alarme process ;
I OB80 à OB87 : réaction aux erreurs asynchrones ;
I OB90 : tâche de fond (système) ;
I OB121 - OB122 : réaction aux erreurs synchrones.
Eric TERNISIEN
Chez Schneider
Les tâches sont réparties en 3 groupes.

I la tâche maı̂tre (MAST) : elle est la moins prioritaire et gère la majeure
partie du programme ;
I la tâche rapide (FAST) : toujours périodique (1 à 255ms) et plus courte
que la tâche MAST ;
I les tâches événementielles (EVTi) : elles sont exécutées lors de l’appari-
tion d’un événement sur une carte d’E/S. Leur nombre est variable et
dépend du modèle d’automate.
Eric TERNISIEN
Problèmes possibles ...

I Influence des tâches prioritaires sur le temps de cycle de la tâche maı̂tre ;
I Maintien de la périodicité de la tâche rapide en fonction de la charge du
système ;
I Temps de réaction de la tâche événementielle.
Eric TERNISIEN
Automatismes embarqués Rappels
Plan

1 - Rappels
Eric TERNISIEN
La norme
Les API se programment à l’aide des 5 langages définis par la norme IEC
61131-3.
Le langage SFC (sequential function chart)
Langage graphique utilisé pour décrire les opérations
séquentielles. Le procédé est représenté par une suite
connue d’étapes reliées entre elles par des transitions.
Le langage FBD (function block diagram)

langage graphique qui permet la construction
d’équations complexes à partir des opérateurs stan-
dards, de fonctions ou de blocs fonctionnels.
Eric TERNISIEN
La norme
Le langage LD (ladder diagram)
représentation graphique d’équations booléennes com-
binant des contacts (en entrée) et des relais (en sortie).
Le langage ST (structured text)

langage textuel de haut niveau. Ce langage est princi-
palement utilisé pour décrire les procédures complexes,
difficilement modélisables avec les langages graphiques
(≈ C, Pascal).
Le langage IL (instruction list)

langage textuel de bas niveau particulièrement adapté
aux applications de petite taille (≈ assembleur).
Eric TERNISIEN
Automatismes embarqués L’automatisme autrement
Plan

1 - Rappels
Eric TERNISIEN
Les cartes embarquées
Les cartes embarquées sont des équipement dédiés à des applications pour
lesquelles un automate est trop coûteux, trop volumineux ou n’offrant pas
assez de fonctionnalités (gestion simple d’affichage, de divers protocoles
(RS232, I2C, ...), ...).
Elles proposent souvent une programmation dans un langage évolué (type C

ou Java) et un noyau plus ouvert sur le hardware.
L’automaticien doit alors être capable de passer d’un grafcet à un algorithme

afin de réaliser le programme.
Eric TERNISIEN
Les cartes embarquées

Carte Beck DK50
Eric TERNISIEN
Automatismes embarqués Grafcet vs Machine d’états
Plan

1 - Rappels
Eric TERNISIEN
Grafcet et machine d’états
Grafcet Machine d’états
r1
1 KM1
r2
2 V 1+
r3 r4
3 4
r5 r6
Eric TERNISIEN
Les transitions
Grafcet Algorithme
Si l’état vaut 1 (étape 1), la machine ne change pas
1 KM1 d’état tant que la réceptivité associée à la transition
n’est pas validée.
r2 while 1 do
...
2 V 1+ if etat = 1 ET r2 then
etat = 2
end if
....
end while
Eric TERNISIEN
Les divergences en OU
Algorithme
Grafcet while 1 do
...
2
if etat = 2 ET r3 then
etat = 3
r3 r4 end if
if etat = 2 ET r4 then
3 4 etat = 4
end if
...
end while
Eric TERNISIEN
Les convergences en OU
Grafcet
Algorithme
3 4
while 1 do
r5 r6 ...
if (etat = 3 ET r5 ) OU (etat = 4 ET r6 ) then
etat = 0
end if
0
...
end while
Eric TERNISIEN
Les divergences en ET
Algorithme
Grafcet
La solution consiste à transformer chaque
1 KM1 branche du ET en une machine (tâche)
r1 indépendante et à les synchroniser (avec ou
sans tâche principale).
2 V 1+ 3 KM12
On utilise ensuite de la synchronisation (directe

ou indirecte) pour exécuter les tâches.
Eric TERNISIEN
Les actions
Algorithme
Grafcet while 1 do
...
1 KM1 Traitement de l’état de la machine
....
r2 if (etat = 1) then
KM1 = 1
2 V 1+ end if
if (etat = 2) then
V1+ = 1
end if
end while
Eric TERNISIEN
Exemple
Grafcet Machine d’états
r1
1 KM1
r2
2 V 1+
r3 r4
3 4
r5 r6
Eric TERNISIEN
Exemple
Machine d’états Algorithme

etatCourant = 0, etatFutur = 0
while 1 do
if (etatCourant = 0 ET r1 ) then
etatFutur = 1
end if
etatFutur = 2
end if
etatFutur = 3
end if
etatFutur = 4
end if
if (etatCourant = 3 ET r5 ) OU (etatCourant = 4 ET r6 ) then
etatFutur = 0
end if
etatCourant = etatFutur
if (etatCourant = 1) then
KM1 = 1
end if
V1+ = 1
end if
end while
Eric TERNISIEN
La synchronisation de graphes
Algorithme
while 1 do
...
if (etatCourant = 1 ET r1 ) while 1 do
then ...
Grafcet etatFutur = 2 if (etatCourant = 15) then
vendre(sem) pendre(sem)
end if etatFutur = 16
if (etatCourant = 2 ET r2 ) end if
1 KM1 15 KM12 then if (etatCourant = 16 ET r21 )
etatFutur = ... then
r1 X2 end if etatFutur = ...
... end if
etatCourant = etatFutur ...
2 V 1+ 16
if (etatCourant = 1) then etatCourant = etatFutur
KM1 = 1 if (etatCourant = 15) then
r2 r21 end if KM12 = 1
if (etatCourant = 2) then end if
V1+ = 1 ...
end if end while
...
end while
On peut également utiliser une synchronisation

directe ou un événement.
Eric TERNISIEN
L’exclusion (partage de ressources)
Algorithme
Grafcet while 1 do
...
while 1 do
...
pendre(sem)
1 KM1 11 KM12 etatFutur = 2
pendre(sem)
end if
etatFutur = 12
r1 .X 12.X 13 r20 .X 2.X 3 end if
etatFutur = 3
end if
2 V 1+ 12 etatFutur = 13
end if
etatFutur = 4
r2 r21 vendre(sem)
etatFutur = 14
end if
vendre(sem)
3 13 end if
etatFutur = ...
end if
r3 r22 etatFutur = ...
...
end if
...
4 14 if (etatCourant = 1) then
KM1 = 1
r4 r23 end if
KM12 = 1
end if
V1+ = 1
...
end if
end while
...
end while
Eric TERNISIEN

Infor

Transféré par

Informations du document

Titre original

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

Infor

Transféré par

Droits d'auteur :

Formats disponibles

Systèmes multitâches

Automatismes temps réel

IV - Les stratégies d’ordonnancement

IV - Les stratégies d’ordonnancement

V - Communication entre tâches

VII - Automatismes embarqués

Architecture d’un ordinateur

Types de systèmes informatiques

Types de systèmes informatiques

2 Systèmes interactifs (systèmes transactionnels, outils bureautiques)

Types de systèmes informatiques

2 Systèmes interactifs (systèmes transactionnels, outils bureautiques)

3 Systèmes réactifs ou temps réel

Qu’est-ce qu’un système multitâche ?

Conditions pour qu’un système soit multitâche

Objectifs d’un système multitâche

1 Partager le temps entre les différentes tâches en cours d’exécution :

Objectifs d’un système multitâche

1 Partager le temps entre les différentes tâches en cours d’exécution :

2 Optimiser le partage des ressources entre les différentes tâches en

Objectifs d’un système multitâche

1 Partager le temps entre les différentes tâches en cours d’exécution :

2 Optimiser le partage des ressources entre les différentes tâches en

3 Optimiser l’occupation du processeur en bloquant les tâches en attente

DMA (Direct Memory Access)

Comparaison entre les 2 architectures multiprocesseurs

IUT de Saint Dié des Vosges 25/152

Etats d’une tâche

Zone de données (tas ou heap)

Contenu du descripteur de tâche

On appelle ce descripteur le TIB (Task Information Block).

Les états d’une tâche

Les 5 états d’une tâche

Les états d’une tâche

Les types de tâche (1)

Point de vue physique

I Tâches logicielles (différées) :

Les types de tâche (2)

Point de vue temporel

Qu’est ce qu’un noyau ?

Sa taille et sa conception sont plus ou moins complexe en fonction du système

Son rôle est de :

En fonction du système d’exploitation, l’architecture du noyau est différentes.

Les 4 grandes familles de noyau sont :

Fonctionnement d’un noyau

Afin d’assurer la répartition des tâches pour l’occupation du processeur, le

Structure simplifiée d’un noyau

Critères pour un bon ordonnancement

Le répartiteur réalise l’élection effective d’une tâche et le changement de

Il est déclenché par une interruption, ce qui fait qu’entre 2 exécutions du

Les 4 phases de la commutation de contexte

Gestion des tâches par le noyau

Le chaı̂nage de la file est bidirectionnel ce qui permet d’intervenir rapidement

IUT de Saint Dié des Vosges 41/152

Gestion des tâches par le noyau

Gestion des tâches par le noyau

Gestion des tâches par le noyau

Gestion des tâches par le noyau

Gestion des tâches par le noyau

Gestion des tâches par le noyau

Gestion des tâches par le noyau

Type de noyau (1)

Noyau non préemptif (coopératif)