Cours Systemes embarques.pptx

Plan
Cours:
₋ Chapitre 1: Généralités sur les microprocesseurs
₋ Chapitre 2: Le pipeline
₋ Chapitre 3: L’ordonnancement
₋ Chapitre 4: OS temps-réel sur STM32
₋ Programmation C pour les systèmes embarqués
Travaux pratiques:
̵ TP1 : Prise en main du logiciel Keil µVision
̵ TP2 : Manipulation des ports d’entrée-sortie (GPIO) de la carte STM32F429-DISCOVERY
̵ TP3 : Configuration et manipulation de l’afficheur LCD via le bus SPI
̵ TP4 : Conception et ajout d’une interface graphique sur l’afficheur LCD
̵ TP5 : Configuration et manipulation de l’écran tactile via le bus I2C
̵ TP6 : Lecture des données à partir de périphérique de stockage USB
2

3
1. Architecture interne
UAL: Unité Arithmétique et Logique.
PC : Compteur Ordinal (Programme
Counter).
Unité de commande
Unité de traitement
Les différents constituants d’un microprocesseur ( µp) peuvent être regroupés dans deux
blocs principaux; l'unité de traitement et l'unité de commande.
Chapitre 1: Généralités sur les microprocesseurs

4
1.1 Unité de commande: Elle permet de séquencer le déroulement des instructions.
Compteur Ordinal (PC) : contient toujours l’adresse de la
prochaine instruction à exécuter.
Le décodeur d'instruction : Le mot binaire (instruction)
est décodé pour savoir à quelle action correspond
l’instruction.
Bloc logique de commande (séquenceur) : organise
l'exécution des instructions au rythme de l’horloge. Il
élabore tous les signaux de synchronisation du
microprocesseur en fonction de l’instruction qu’il a à
exécuter.

5
1.2 Unité de traitement: Elle permet d’exécute les instructions.
L’accumulateur : C’est un registre de travail qui sert à stocker
le résultat des opérations réalisées par L’UAL.
L’Unité Arithmétique et Logique (UAL) est un circuit
complexe qui assure les fonctions logiques (ET, OU,
comparaison, décalage, etc…) ou arithmétique (addition,
soustraction…).
Le registre d'état : Chacun des bits de ce registre dépend du
résultat de la dernière opération effectuée par l’UAL.
Exemple: Bit de retenue (carry : C), débordement (overflow:
OV ou V), Zéro (Z) ...

6
1.3 Le fonctionnement basique d’une opération de calcul
(1) Charger une instruction depuis la mémoire
(2) Charger les opérandes depuis la mémoire
(3) Effectuer les calculs
(4) Stocker le résultat en mémoire
CPU Mémoire
(1)
(2)
(4)
(3)

7
1.4 Von Neuman
CPU
Mémoire
programme et
données
BUS
 Un seul chemin d'accès à la mémoire
- Un bus de données (programme et données),
- Un bus d’adresse (programme et données)
 Architecture des processeurs d’usage général
 Goulot d'étranglement pour l'accès à la mémoire

8
1.4 Harvard
CPU
Mémoire
programme BUS
Mémoire
données
BUS
 Séparation des mémoires programme et données
- Un bus de données programme,
- Un bus de données pour les données,
- Un bus d’adresse programme,
- Un bus d’adresse pour les données.
 Meilleure utilisation du CPU :
Chargement du programme et des données en parallèle

9
1.5 Exemple: Les processeurs ARM Cortex-M
Les processeurs ARM Cortex se déclinent en une large gamme d’architectures et de cœurs très
populaires dans le monde de l’embarqué. Ils sont regroupés en trois familles principales :
− Le Cortex-A (Application): C’est une gamme de processeurs développée pour des tâches
nécessitant des calculs complexes. Ces processeurs supportent les jeux d’instructions
ARM, Thumb et Thumb-2.
− Le Cortex-M (eMbedded): Cette gamme est destinée aux microcontrôleurs qui
nécessitent une faible consommation d’énergie et un bas prix de vente. Cette gamme
supporte seulement le jeu d’instructions Thumb-2.
− Le Cortex-R (Real-time): Les processeurs de cette gamme offrent de hautes
performances pour les systèmes temps réel dans lesquels la fiabilité et le déterminisme
sont essentiels. Ils supportent les jeux d’instructions ARM, Thumb et Thumb-2.

10
 Contrairement aux gammes Cortex-A et Cortex-R, la gamme Cortex-M est un cœur
complet devenu un standard dans le domaine des processeurs.
 Il s’appuie sur une architecture système bien définie qui comprend:
- une gestion des interruptions,
- une horloge système,
- un système de débogage
- un espace d’adressage mémoire standardisé.

11
 L’espace mémoire est divisé en régions distinctes prédéfinies pour le code, les
données, les périphériques et le système.
 S’appuyant sur une architecture de Harvard,
 le Cortex-M possède ainsi plusieurs bus, ce qui lui permet d’effectuer des opérations
en parallèle.
 Le mode d’accès non aligné aux données lui assure une meilleure utilisation de la
mémoire et un accès plus efficace aux registres des périphériques

12

13
2. Le traitement des instructions
2.1 Organisation d’une instruction:
 Le microprocesseur ne comprend qu’un certain nombre d’instructions qui sont codées en
binaire.
 Une instruction est composée de deux éléments :
- Le code opération : c’est un code binaire qui correspond à l’action à effectuer
par le processeur.
- Le champ opérande : donnée ou bien adresse de la donnée.
 La taille d'une instruction peut varier, elle est généralement de quelques octets (1 à 8) et
dépend de l'architecture du processeur.

14
Etape 1: Recherche de l’instruction en mémoire
 La valeur du PC est placée sur le bus d'adresse, et l'unité de commande émet un ordre de
lecture de la mémoire.
 Après le temps d'accès à la mémoire, le contenu de la case mémoire sélectionnée (instruction)
est disponible sur le bus des données et arrive à l’entrée du décodeur.
Etape 2: Décodage et recherche de l’opérande
Si l'instruction nécessite une donnée en provenance de la mémoire, l'unité de commande
récupère sa valeur sur le bus de données en faisant un nouvel accès mémoire. La donnée arrive à
l’entrée de l’ALU.
Etape 3: Exécution de l’instruction
 L’ALU réaliser l’opération que le séquenceur lui demande. Les drapeaux sont positionnés
(registre d'état).
 Le PC est incrémenté pour indiquer l'instruction suivante
2. Le traitement des instructions Chapitre 1: Généralités sur les microprocesseurs

15
Actuellement il existe plusieurs architectures des microprocesseurs:
 Architecture CISC (Complex Instruction Set Computer),
 Architecture RISC (Reduced Instruction Set Computer)
 Architecture VLIW (Very long instruction word)
 Architecture vectorielle
 Architectures dataflow

16
2.1 Codage de l’instruction
 Les instructions et leurs opérandes (données) sont stockés dans la mémoire.
 La taille d’une instruction (nombre de bits nécessaires pour la représenter en mémoire)
dépend du type de l’instruction et du type de l’opérande.
- Code opération (code instruction): un code sur N bits qui indique quelle instruction.
- Le champ opérande: qui contient la donnée ou la référence (adresse) à la donnée.
 Le format d’une instruction peut ne pas être le même pour toutes les instructions.
 Le champ opérande peut être découpé en plusieurs champs.
Code opération Opérande
N bits K bits

17
2.1.1 Machines à 3 adresses
 Dans ce type de machine pour chaque instruction il faut préciser:
- l’adresse du premier opérande ,
- l’adresse du deuxième opérande ,
- et l'emplacement du résultat.
 Exemple:
ADD A, B, C ( C  B + C )
- Dans ce type des machines la taille de l’instruction est grande.
- Pratiquement il n’existe pas des machines de ce type.
Code opération Opérande 1 Opérande 2 Résultat

18
2.1.1 Machines à 2 adresses
 Dans ce types de machine pour chaque instruction il faut préciser:
- l’adresse du premier opérande ,
- et l’adresse du deuxième opérande .
 L’adresse de résultat est implicitement l’adresse du deuxième opérande.
 Exemple:
ADD A, B (C  B + C)
Code opération Opérande 1 Opérande 2

19
2.1.1 Machines à 1 adresse
 Dans ce type des machines pour chaque instruction il faut préciser uniquement l’adresse
du deuxième opérande .
 Le résultat est mis dans le registre accumulateur.
 Exemple:
ADD A (ACC  (ACC) + A)
Code opération Opérande 1 Opérande 2

20
 De nombreuses instructions font référence à des données se trouvant à différents
endroits de la machine : registres internes de µp, pile d'exécution, EEPROM,
RAM, ports d'E/S. On appelle modes d'adressage les différentes façons de spécifier les
endroits où se trouvent les données dont on a besoin.
 Les modes d’adressage les plus courant sont :
- Adressage direct
- Adressage indirect
- Adressage immédiat
3. Les modes d’adressages Chapitre 1: Généralités sur les microprocesseurs

21
3.1 Adressage direct
 Le champ opérande de l’instruction contient l’adresse de l’opérande (emplacement en
mémoire)
 Pour réaliser l’opération il faut récupérer (lire) l’opérande à partir de la mémoire
ACC  (ACC) + (ADR)
 Exemple: on suppose que l’accumulateur contient la valeur 20.
À la fin de l’exécution on obtient la valeur 50 ( 20+30).
3. Les modes d’adressages
ADD 150
30 150

22
3.2 Adressage indirect
 La champs d’adresse contient l’adresse de l’adresse de l’opérande.
 Pour réaliser l’opération il faut :
– Récupérer l’adresse de l’opérande à partir de la mémoire.
– Par la suite il faut chercher l’opérande à partir de la mémoire.
ACC  (ACC) + ((ADR))
 Exemple :
- Initialement l’accumulateur contient la valeur 20
- Il faut récupérer l’adresse de l’adresse (150).
- Récupérer l’adresse de l’opérande à partir de l’adresse 150 ( la valeur 200 )
- Récupérer la valeur de l’opérande à partir de l’adresse 200 ( la valeur 40 )
- Additionner la valeur 40 avec le contenu de l’accumulateur (20) et nous allons avoir la valeur 60.
ADD 150
200
40
150
200

23
3.3 Adressage immédiat
 L’opérande existent dans le champ adresse de l’instruction
 Exemple:
ADD 150
- Cette commande va avoir l’effet suivant : ACC  (ACC) + 150
- Si le registre accumulateur contient la valeur 200 alors après l’exécution son contenu sera
égale à 350.
Code opération Opérande
ADD 150

24
Chapitre 2: Le pipeline
1. Définition d’un pipeline
 Technique utilisée pour optimiser le temps d’exécution d’un processus répétitif.
 Avec un pipeline, le processeur peut commencer à exécuter une nouvelle instruction sans
attendre que la précédente soit terminée.
 Une instruction est découpée dans un pipeline en petits morceaux appelés étage de
pipeline.
 La technique du pipeline exploite le parallélisme entre les instructions d’un flot séquentiel
d’instructions.
Cycles d'horloge
Programme
Instruction 1
Instruction 2
Instruction 3
Instruction 5
Instruction 4
1 2 3 4 5 6 7 8 9

25
2. Étages du pipeline
 Pour mettre en œuvre un pipeline, la première tâche est de découper l'exécution des
instructions en plusieurs étapes.
 Chaque étape est prise en charge par un étage du pipeline.
 Si le pipeline possède n étages, il y a n instructions en cours d'exécution simultanée,
chacune dans une étape différente.
→Le facteur d'accélération est donc le nombre n d'étages.
 Chacune des étapes du pipeline est implémentée par un circuit intégré indépendant,
appelé étage.
 Le nombre d'étages d'un pipeline est appelé sa profondeur..

26
2. Étages du pipeline
Exemples de profondeur de pipeline

27
2. Étages du pipeline: Pipeline RISC classique
Exemple
→Chacune des instructions commence son exécution un cycle après l'instruction précédente et
passe par les cinq étapes d'exécution pendant cinq cycles consécutifs.

28
 Créé par David Patterson, inventeur des processeurs RISC.
 5 étapes sont nécessaires pour traiter une instruction :
1.Lecture de l'instruction (Instruction Fetch: IF)
2.Décodage de l'instruction (Instruction Decode: ID )
3.Exécution de l'instruction (Instruction Execution: EX)
4.Accès à la mémoire (Memory Access: MEM)
5.Rangement du résultat (Write Back: WB)

29
2.1 Lecture de l'instruction (Instruction Fetch: IF)
 La prochaine instruction à exécuter est chargée dans le pipeline à partir de la case
mémoire pointée par le compteur de programme PC dans le registre d'instruction (IR).
 Le compteur de programme est incrémenté pour pointer sur l'instruction suivante.

30
2.2 Décodage de l'instruction (Instruction Decode: ID )
 Préparation des arguments de l'instruction pour
l'étape suivante où ils seront utilisés.
 Les arguments sont placés dans deux registres A et B.
₋ Si l'instruction utilise le contenu de un ou deux registres,
ceux-ci sont lus et leurs contenus sont rangés en A et B.
₋ Si l'instruction contient une valeur immédiate, celle-ci est
étendue (signée ou non signée) à 16 bits et placée dans
le registre B.
₋ Pour les instructions de branchement avec offset, le
contenu de PC est rangé en A et l'offset étendu dans B.
₋ Pour les instructions de branchement avec un registre, le
contenu de ce registre est rangé en A et B est rempli avec
0.
₋ Les instructions de rangement (ST) mettent le contenu du
registre qui doit être transféré en mémoire dans le
registre C.
2. Étages du pipeline: Pipeline RISC classique Chapitre 2: Le pipeline

31
2.3 Exécution de l'instruction (Instruction Execution: EX)
 Cette étape utilise l'unité arithmétique et logique (UAL) pour
combiner les arguments.
 L'opération précise réalisée par cette étape dépend du type de
l'instruction.
₋ Instruction arithmétique ou logique (ADD, AND et NOT): Les
deux arguments contenus dans les registres A et B sont
fournis à l'unité arithmétique et logique pour calculer le
résultat.
₋ Instruction de chargement et rangement (LD et ST): Le calcul
de l'adresse est effectué à partir de l'adresse provenant du
registre A et de l'offsetcontenu dans le registre B.
₋ Instruction de branchement (BR, JMP, JSR, JSRR et TRAP):
• Pour les instructions contenant un offset, l'addition avec
le contenu du PC est effectuée à cette étape.
• Pour les instructions utilisant un registre, le contenu du
registre est juste transmis.

32
2.4 Accès à la mémoire (Memory Access: MA)
 Cette étape est uniquement utile pour les instruction de chargement et de rangement.
₋ Pour les instructions arithmétiques et logiques ou les branchements, rien n'est
effectué.
₋ L'adresse du mot mémoire est contenue dans le registre R.
 Dans le cas d'un rangement, la valeur à ranger provient du registre C.
 Dans le cas d'un chargement, la valeur lue en mémoire est mise dans le registre R pour
l'étape suivante.

33
2.5 Rangement du résultat (Write Back: WB)
 Le résultat des opérations arithmétiques et logiques est rangé dans le registre destination.
 La valeur lue en mémoire par les instructions de chargement est aussi rangée dans le
registre destination.
 Les instructions de branchement rangent la nouvelle adresse dans PC.

34
3. Gain en performances Chapitre 2: Le pipeline
 Pour exécuter n instructions nécessitant chacune k cycles d’horloge, il faut :
• n x k : cycles d’horloge pour une exécution séquentielle
• k : cycles pour la première instruction, puis (n-1) cycles pour les (n-1) instructions
restantes si on utilise un pipeline à k étages.
 Gain :
1
n k
G
n k


 
 Si n est grand par rapport à k, on divise le temps d’exécution par k.

35
4. Temps de cycle des processeurs pipelinés Chapitre 2: Le pipeline
 Le temps de cycle d’un processeur pipeliné dépend de quatre facteurs :
₋ Le temps de cycle de la version non pipelinée du processeur ,
₋ Le nombre d’étage du pipeline ,
₋ La manière dont la logique du chemin de données est répartie entre les étages (si cette
répartition est équilibrée) ,
₋ La latence de latch du pipeline (le temps de stabilisation après le passage dans chaque
étage).
 Si la logique peut être répartie de manière égale entre les étages du pipeline, la période
d’horloge du processeur pipeliné est :
Temps de cycle
non pipeliné
Temps de cycle = +latence de latch du pipeline
pipeliné Nombre d'étages du pipeline
→ Si le nombre d’étages du pipeline augmente, la latence de latch correspond à une fraction
de plus en plus grande du temps de cycle.
→ Ce qui limite progressivement l’intérêt de diviser le processeur en un plus grand nombre
d’étages de pipeline.

36
4. Temps de cycle des processeurs pipelinés Chapitre 2: Le pipeline
 Lorsqu’un processeur ne peut pas être divisé en étages de latences égales, le temps de cycle
de l’horloge du processeur est égal à la latence du plus long étage du pipeline ajoutée au délai
de latch du pipeline.
→ Le temps de cycle doit être suffisamment long pour que l’étage le plus long se termine et
stocke son résultat dans le latch qui le sépare de l’étage suivant.
 Exercice:
Un processeur non pipeliné possède un temps de cycle de 30 ns.
1- Quel est le temps de cycle (Tc) d’une version pipelinée du processeur avec 5 étages de
pipeline également divisés, si chaque latch du pipeline possède une latence de 1 ns ?
2- Qu’en serait-il le Tc si le processeur divisé en 60 étages de pipeline ?
Solution:
1- Le temps de cycle pour le pipeline à 5 étages: Tc = (30ns/5) + 1ns = 7 ns.
2- Le temps de cycle pour le pipeline à 60 étages: Tc = (30ns/60) + 1 ns = 1,5 ns.

37
5. Latence de pipeline Chapitre 2: Le pipeline
 La latence d’un pipeline correspond à la quantité de temps qu’une instruction prend pour le
traverser, c'est-à-dire au produit du nombre d’étages du pipeline par le temps de cycle:
 Exercice: Un processeur non pipeliné possédant un temps de cycle de 25 ns est divisé de
manière égale en 5 étages de pipeline utilisant des latches d’une latence de 1 ns chacun.
₋ quelle est la latence totale du pipeline ?
₋ quelle est la latence si le processeur était divisé en 50 étages de pipeline ?
Latence d’un pipeline = nombre d’étages * temps de cycle
Solution:
Temps de cycle du processeur pipeliné à 5 étages : 6 ns, et à 50 étages 1,5 ns .
Latence du pipeline à 5 étages = 6 x 5 = 30 ns
Latence du pipeline à 50 étages = 1,5 x 50 = 75 ns

38
6. Aléas de pipeline
Le bon fonctionnement du pipeline peut être perturbé par plusieurs événements
appelés aléas (problèmes). Ces événements sont classés en trois catégories:
 aléas structurels: Ce type de problèmes survient lorsque deux instructions dans des étages
différents du pipeline nécessitent la même ressource.
 aléas de données: Ce type de problèmes survient lorsqu'une instruction nécessite une
donnée qui n'a pas encore été calculée par une instruction précédente. Ceci provient du fait
que les instructions lisent leurs arguments dans les premiers étages du pipeline alors
qu'elles produisent leur résultat dans les derniers étages.
 aléas de contrôle: Ce type de problèmes survient dès qu'une instruction de branchement
est exécutée. Si le branchement est effectué, les instructions qui suivent dans le pipeline ne
doivent pas être exécutée. Ceci provient du fait que la nouvelle adresse est calculée alors
que les instructions qui suivent ont déjà été chargées

39
 La solution générale pour résoudre un aléa est de bloquer l'instruction qui pose problème et
toutes celles qui suivent dans le pipeline jusqu'à ce que le problème se résolve.
 On voit alors apparaître des bulles dans le Pipeline
 De manière pratique, la bulle correspond à l'exécution de l'instruction NOP qui ne fait rien.
6. Aléas de pipeline Chapitre 2: Le pipeline

40
4.1 Les aléas structurels
Considérons par exemple le morceau de code suivant:
₋ LDR R7,R6,0
₋ ADD R6,R6,1
₋ ADD R0,R0,1
₋ ADD R1,R1,1
Le déroulement de l'exécution des quatre premières instructions dans le pipeline devrait être le
suivant.

41
 L'étape MA (accès mémoire) de l'instruction LDR R7,R6,0 a lieu en même temps que l'étape IF
(chargement de l'instruction) de l'instruction ADD R1,R1,1.
 Ces deux étapes nécessitent simultanément l'accès à la mémoire.
 Il s'agit d'un aléa structurel. Comme cela est impossible, l'instruction ADD R1,R1,1 et celles qui
suivent sont retardées d'un cycle.

42
 Le conflit d'accès à la mémoire se produit à chaque fois qu'une instruction de chargement ou
de rangement est exécutée.
 Celle-ci rentre systématiquement en conflit avec le chargement d'une instruction qui a lieu à
chaque cycle d'horloge.
 Ce problème est généralement résolu en séparant la mémoire où se trouvent les instructions
de celle où se trouvent les données. Ceci est réalisé au niveau des caches de niveau 1.
 Le microprocesseur doit alors avoir deux bus distincts pour accéder simultanément aux deux
caches.
 Comme le microprocesseur LC3 est très simple, les seuls aléas structurels possibles sont ceux
dûs à des accès simultanés à la mémoire.
 Les registres sont utilisés aux étapes ID (décodage) et WB (rangement du résultat) mais les
premiers accès sont en lecture et les seconds en écriture. Ceci ne provoque pas d'aléa.

43
4.2 Les aléas de données
Considérons le morceau de code suivant:
ADD R1,R1,1
ADD R0,R1,R2
Le déroulement de l'exécution de ces deux instructions dans le pipeline devrait être le suivant.
 Le problème est que le résultat de la première instruction est écrit dans le registre R1 après la
lecture de ce même registre par la seconde instruction.
 La valeur utilisée par la seconde instruction est alors erronée.

44
 Le résultat de la première instruction est disponible dès la fin de l'étape IE (exécution de
l'instruction) de celle-ci.
 Il est seulement utilisé à l'étape IE de la seconde instruction.
 Il suffit alors de le fournir en entrée de l'additionneur à la place de la valeur lue dans R1 par la
seconde instruction. Ceci est réalisé en ajoutant un chemin de données.

45
Considérons un autre morceau de code assez semblable.
LDR R1,R6,0
ADD R0,R1,R2
Le déroulement de l'exécution de ces deux instructions dans le pipeline devrait être le suivant.
 Ici, le résultat de la première instruction est écrit dans le registre R1 après la lecture de ce même registre
par la seconde instruction.
 Par contre, le résultat n'est pas disponible avant l'étape MA (accès mémoire) de la première instruction.
Comme cette étape a lieu après l'étape IE de la seconde instruction, il ne suffit pas d'ajouter un chemin de
données pour faire disparaître l'aléa. Il faut en outre retarder la seconde instruction.
 Ceci introduit une bulle dans le pipeline.

46
4.2 Les aléas de branchement
 Lors de l'exécution d'une instruction de branchement conditionnel, on dit que le branchement
est pris si la condition est vérifiée et que le programme se poursuit effectivement à la nouvelle
adresse. Un branchement sans condition est toujours pris.
 Lorsqu'un branchement est pris, l'adresse de celui-ci est calculée à l'étape IE (exécution de
l'instruction) et rangée dans le registre PC à l'étape WB (rangement du résultat). Toutes les
instructions qui suivent l'instruction de branchement ne doivent pas être exécutées.
 Au niveau du pipeline, on obtient le diagramme d'exécution suivant.

47
 On constate que l'exécution d'un branchement pris dégrade notablement la performance du
pipeline puisque quatre cycles sont perdus. Comme les branchements constituent en général
20 à 30% des instructions exécutées par un programme, il est primordial d'améliorer leur
exécution.
 Dans le cas du micro-processeur LC-3, les instructions de branchement sont relativement
simples. Une façon simple d'optimiser les branchements est de ne pas leur faire suivre toutes
les étapes du pipeline afin que la nouvelle adresse soit écrite le plus tôt possible dans le
registre PC.

48
 Pour les branchements conditionnels, la condition ne dépend que des indicateurs n, z et p et
du code de l'instruction.
 Cette condition peut donc être calculée à l'étape ID (décodage de l'instruction).
 De même, l'adresse du branchement est soit le contenu d'un registre soit la somme de PC et
d'un offset.
 Dans les deux cas, cette valeur peut être rendue disponible à la fin de l'étape ID.
 Le prix à payer est l'ajout d'un nouvel additionneur dédié à ce calcul.
 La nouvelle adresse est alors écrite dans le registre PC à la fin de l'étape ID.
Le diagramme précédent devient alors le diagramme ci-dessous qui montre qu'il ne reste plus
qu'un seul cycle d'horloge de perdu.

49
 Le conflit d'accès à la mémoire se produit à chaque fois qu'une instruction de chargement
ou de rangement est exécutée (MA)
 Celle-ci rentre systématiquement en conflit avec le chargement d'une instruction qui a lieu
à chaque cycle d'horloge (IF)
 Ce problème est résolu en séparant la mémoire où se trouvent les instructions de celle où
se trouvent les données.
₋ Ceci est réalisé au niveau des caches de niveau 1.
₋ Le micro-processeur doit alors avoir deux bus distincts pour accéder simultanément
aux deux caches.
Exemples
• A
₋ ADD R1, R2, R3 // R1 = R2 + R3
₋ STORE R1, 1000 // C(1000) = R1
• B
₋ MOV R1, #1000 // R1 = 1000
₋ JUMP R1 // Saut

50
Chapitre 3: Ordonnancement dans le temps-réel
1. Introduction
 Un ordonnanceur (planificateur ou Scheduler en anglais) gère l'allocation et la suspension des
tâches.
 L’ordonnancement peut être préemptif ou non-préemptif
- Préemptif (avec réquisition): l’ordonnanceur peut interrompre un processus en cours
d’exécution, si un nouveau processus de priorité plus élevée est inséré dans la file des
Prêts.
- Non-préemptif : lorsqu’un processus à la main, il s’exécute entièrement même si des
processus plus prioritaires ont atteint la liste des Prêts.

Objectifs d’ordonnancement
1. Maximiser le nombre de processus exécutés par unité de temps.
2. Minimiser le temps d’attente d’exécution de chaque processus.
3. Maximiser les temps d’utilisation des processeurs et autres ressources.
4. Respecter les échéanciers (terminer l’exécution avant leurs deadlines).
5. Éviter le problème de famine (attente infinie).
6. Favoriser les processus les plus prioritaires (éviter le problème d’inversion des priorités).
7. Minimiser le nombre et la durée des changements de contexte.
- Difficile de les satisfaire à la fois.
- Prioriser les objectifs.
1. Introduction

52
2. Algorithmes d’ordonnancement dans les systèmes classiques
2.1 Algorithme d'ordonnancement PAPS
PAPS: le Premier Arrivé est le Premier Servi (ou FCFS: First-Come First-Served)
• Quand un processus est prêt à s’exécuter, il est mis en queue de la file d’attente des
processus prêts
• Quand le processeur devient libre, il est alloué au processus se trouvant en tête de file
d’attente des processus prêts.
• Le processus élu relâche le processeur s’il se termine ou s’il demande une entrée sortie.
Temps 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
Processus
Démarrage
P1 P2 P3
P3
P2
P2
P2 P2
P1 P1 P1 P1 P2
P1 P2 P3
P1, P2 etP3 sont 3 processus dont le temps d’exécution respectifs P1=5, P2=6 et P3=2

53
Exemple: On considère un système d’exploitation qui ordonnance 5 processus: P1, P2, P3, P4
et P5 selon l’algorithme d’ordonnancement PAPS. Le temps d’exécution et l’arrivage de
chaque processus sont donnés par le tableau suivant:
En utilisant un algorithme d’ordonnancement PAPS donnez :
- le diagramme de Gantt,
- le temps de séjour de chaque processus,
- le temps moyen de séjour des processus,
- le temps d’attente de chaque processus,
- le temps moyen d’attente des processus.
Processus Temps d’exécution Temps d’arrivée
P1 3 0
P2 6 1
P3 4 4
P4 2 6
P5 1 7

54
1- diagramme de Gantt (DG):
- P1 arrive à 0s donc il est servi en premier car étant le premier arrivé. Il est servi en 3
secondes. Donc son temps fin "de service" est 3 secondes.
- P2 arrive à 1s, mais c'est à 3s qu'il se fait servir (principe PAPS). Il est servi en 6s. Donc
son temps fin "de service" est 9s.
- P3 arrive à 4s, mais est servi à 9s. Il est servi en 4s. Donc son temps fin "de service" est 13s.
P5
P4
P3
P2
P1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Processus
temps

55
2- temps de séjour de chaque processus:
Application:
3- temps moyen de séjour (TMS):
Application:
TMS= (3+8+9+9+9) / 5 = 7.6
Temps de séjour = temps fin d'exécution - temps d'arrivée
Processus Temps de séjour
P1 3-0=3
P2 9-1=8
P3 13-4=9
P4 15-6=9
P5 16-7=9
Temps moyen de séjour = somme des temps de séjour de chaque processus
divisée par le nombre de processus

56
4- temps d’attente de chaque processus:
Application:
5- temps moyen d'attente (TMA):
Application:
TMA = 22/5 = 4.4
Temps d'attente = temps de séjour - temps d'exécution
Processus Temps d’attente
P1 3-3=0
P2 8-6=2
P3 9-4=5
P4 9-2=7
P5 9-1=8
Temps moyen d'attente = somme des temps d'attente divisée par le nombre
de processus

57
2.2 Algorithme d'ordonnancement Shortest Job First (SJF)
L’ordonnanceur choisit, parmi le lot de processus à exécuter, le plus court (plus petit temps
d'exécution).
Exemple: P1, P2 etP3 sont 3 processus dont le temps d’exécution respectifs P1=5, P2=6 et P3=2
P3
P2
P1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Processus
Temps
En utilisant un algorithme d’ordonnancement SJF calculez:
- le temps de séjour de chaque processus,
- le temps moyen de séjour des processus,
- le temps d’attente de chaque processus,
- le temps moyen d’attente des processus.
Stratégie offre le temps moyen d’attente minimale

58
2.3 Algorithme d'ordonnancement Tourniquet (Round Robin)
Exemple: P1, P2 et P3 sont 3 processus dont le temps d’exécution respectifs P1=5, P2=6 et
P3=2.
- Le processeur gère une liste circulaire de processus.
P3
P2
P1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Processus
Temps

59
2.4 Algorithme PAPS + Priorité
Exemple: P1, P2 etP3 sont 3 processus:
– Durée: P1=5, P2=6 , P3=2
– Priorité: P1=+ , P2=++ , P3=++
P3
P2
P1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Processus
Temps

60
2.5 Algorithme Tourniquet + Priorité
P3
P2
P1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Processus
Temps
Exemple: P1, P2 etP3 sont 3 processus:
– Durée: P1=5, P2=6 , P3=2
– Priorité: P1=+ , P2=++ , P3=++

61
2.6 Algorithme Shortest Remaining Time (SRT)
• SRT: c’est la version préemptive de l'algorithme Shortest Job First (SJF).
• Si un processus dont le temps d’exécution est plus court que le reste du temps d’exécution
du processus en cours de traitement, alors il prendra sa place.
Exemple:
• Calculer le temps moyen d’attente et comparer avec le temps moyen d’attente de SJF.
Processus Temps d’arrivée Temps d’exécution
P1 0 5
P2 1 6
P3 2 2
TMA(SRT) < TMA(SJF)
P3
P2
P1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Processus
Temps

62
2.7 Algorithme Round Robin(RR)
• Il alloue le processeur au processus en tête de file, pendant un quantum de temps.
• Si le processus se bloque ou se termine avant la fin de son quantum, le processeur est
immédiatement alloue a un autre processus (celui en tête de file).
• Si le processus ne se termine pas au bout de son quantum, son exécution est suspendue.
– Le processeur est alloue a un autre processus (celui en tête de file).
– Le processus suspendu est insère en queue de file.
– Les processus qui arrivent ou qui passent de l‘état bloque a l‘état prêt sont insères en
queue de file.
– Pour éviter la famine, un nouveau processus est insérer en fin de file, pour ne pas
doubler les processus existants

63
Exemple: P1, P2 et P3 sont 3 processus:
Processus Temps d’exécution
P1 9
P2 2
P3 2
Quantum = 4ms
P3
P2
P1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Processus
Temps

64
Remarques: Impact de la valeur du quantum dans RR
• Un quantum trop petit provoque trop de commutations de processus et abaisse
l'efficacité du processeur.
• Un quantum trop élève augmente le temps de réponse des courtes commandes en
mode interactif.
• Un quantum entre 20 et 50 ms est souvent un compromis raisonnable

65
2.8 Inconvénients des ordonnanceurs classiques
• Le processeur est toujours utilisé et ne peut se mettre en veille.
• Le quantum de temps doit plutôt être choisi en fonction de la charge de la machine.
Solution :
– au lieu d'être lancé périodiquement, l'ordonnanceur indique dans combien de temps il
doit être réveillé.
– Evidemment, il peut être réveillé par une tâche prioritaire qui devient prête.

66
3. Ordonnancement temps-réel
Les algorithmes d'ordonnancement les plus connus sont:
 Rate Monotonic (RM)
 Earliest Deadline First (EDF)
 Least Laxity First (LLF)

Cours Systemes embarques.pptx

Contenu connexe

Tendances

Similaire à Cours Systemes embarques.pptx

Dernier

Cours Systemes embarques.pptx